Hands-on full stack web development with Aurelia : develop modern and real-time web applications with Aurelia and Node. js / Diego Arguelles Rojas, Erikson Murrugarra.

Format:

Book

Author/Creator:

Arguelles Rojas, Diego, author.

Murrugarra, Erikson, author.

Language:

English

Subjects (All):

Network analysis (Planning).

Physical Description:

1 online resource (336 pages)

Edition:

1st edition

Place of Publication:

Birmingham ; Mumbai : Packt Publishing, 2018.

System Details:

text file

Summary:

Develop rich and scalable web applications with Node.js, Express.js, and MongoDB About This Book Learn the advanced features of Aurelia to build responsive web applications Write clean, modular, and testable code that will be easy to maintain and evolve Harness the power of JavaScript on the client and server side to build full-stack applications Who This Book Is For Hands-On Full Stack Web Development with Aurelia is for you if you are a web or full-stack JavaScript developer who has experience with traditional stacks such as LAMP, MEAN, or MERN and wish to explore the power of Aurelia and new stack with modern web technologies. What You Will Learn Employ best practices and modern approaches to create frontend applications Learn about modern CSS preprocessors and improve the readability of your application Use the Aurelia framework to create navigable web applications Write your own tests, making your application secure and fault-tolerant Create solid RESTful APIs using the microservice architecture Understand the NoSQL paradigm and get the best performance from your database Integrate third-party libraries such as Gmail for Single Sign On Write UI testing scripts and integration tests to build extensible apps In Detail Hands-On Full Stack Web Development with Aurelia begins with a review of basic JavaScript concepts and the structure of an Aurelia application generated with the Aurelia-CLI tool. You will learn how to create interesting and intuitive application using the Aurelia-Materialize plugin, which implements the material design approach. Once you fully configure a FIFA World Cup 2018 app, you'll start creating the initial components through TDD practices and then develop backend services to process and store all the user data. This book lets you explore the NoSQL model and implement it using one of the most popular NoSQL databases, MongoDB, with some exciting libraries to make the experience effortless. You'll also be able to add some advanced behavior to your components, from managing the lifecycle properly to using dynamic binding, field validations, and the custom service layer. You will integrate your application with Google OAuth Service and learn best practices to secure your applications. Furthermore, you'll write UI Testing scripts to create high-quality Aurelia Apps and explore the most used tools to run end-to-end tests. In the concluding chapters, you'll be able to deploy your application to the Cloud and Docker containers....

Contents:

Cover

Title Page

Copyright and Credits

Dedication

Packt Upsell

Foreword

Contributors

Table of Contents

Preface

Chapter 1: Introducing Aurelia

JavaScript fundamentals

Dynamic typing

Object oriented

Functional

Prototyped

Events handling

The ECMAScript standard

ES 6

Arrow functions

String interpolation

Destructuring

Setting up our environment

Installing Node.js

The Node Package Manager

NPM website

NPM Registry

NPM CLI

Common NPM operations

Updating NPM

Installing NPM packages

Versions

The package.json file

Dependencies and devDependencies

The Aurelia framework

What is a JavaScript framework?

Why use a JavaScript framework?

JavaScript framework comparison

Why Aurelia?

Angular

Technical information

Dependency injection

Component encapsulation

React.js

Aurelia

Aurelia command-line tool

Installation

Creating a new application

Running our Application

Testing our application

Building our application

Generating custom resources

World Cup app overview

Exploring the application features

Matches explorer

Listing the matches

Creating a new Match

Teams explorer

Listing the teams

Creating a new team

News

Listing the News

Create a New

Social authentication

Creating our app

The project structure

The Bootstrap process

Understanding components

Summary

Chapter 2: Styling the User Interface

Talking about CSS

How does it work?

Exploring SASS and LESS

Variables

Nesting

Extends

If/else statements

Automating tasks with Gulp

Understanding Gulp

How does Gulp.js work?

Installing Gulp.

JavaScript task

Automating tasks

Exploring CSS frameworks

Bootstrap

Material Design

Material is the metaphor

Bold, graphic, and intentional

Motion provides meaning

Semantic UI

The mobile-first approach

Configuring our project with Aurelia-Materialize

Chapter 3: Testing and Debugging

Benefits of testing

For the development team

For the project

For the organization

For the users

Test-Driven Development

Making our code fail

Implementing the code

Refactoring our code

Aurelia testing frameworks

Learning JasmineJS

Installation and configuration

Test suites

Test cases

Expects

Learning KarmaJS

Installing karma

Configuring Karma

Testing example

Launching the test runner

Testing an Aurelia component

Coding the application

Creating the application

Creating our component

Implementing the info-box view model

Implementing the info-box view HTML template

Rendering the info-box component

Writing the test

Bootstrapping the component

Testing the component

Debugging our code

Refactoring our application

Debugging with Chrome Developer Tools

Chapter 4: Creating Components and Templates

Lego components

A little puzzle

Learning how DI works

Managing a component's life cycle

Managing events with Aurelia

Data binding

Binding computed properties

Value converters

Routing and resources

Testing our components

Testing component life cycle

Time to practice!

Chapter 5: Creating Our RESTful API

Understanding RESTful

Understanding HTTP

URLs

Verbs

Headers

Body

CRUD over HTTP

Designing APIs

API first

API design

Nouns as paths

HTTP verbs for CRUD

API documentation

Creating an API with Node.js

Node advantages

Asynchronous.

Single-thread

Simple HTTP Server

Improving our API with Express.js

Coding our server

Using routes

Coding our project

Our project structure

Implementing the Teams API

Configuring the JSON Parser

Refactoring routes

Creating a team

Retrieving the list

Updating a Team

Deleting a Team

Chapter 6: Storing Our Data in MongoDB

NoSQL databases

Document databases

Introducing MongoDB

Installing MongoDB

CRUD operations

Creating a document

Retrieving documents

Updating documents

Deleting documents

MongooseJS

Installing Mongoose

Configuring Mongoose

Defining schemas

Data types

Validation

Creating models

Integrating our API with MongoDB

Decoupling the Team Model

Implementing the Rest Controller

Connecting the app

Finding a single team

Updating teams

The async/await instruction

Deleting teams

Chapter 7: Advanced Features on Aurelia

Subscribing and publishing events - Event Aggregator at the rescue!

Configuring Event Aggregator

publish(event, data)

subscribe(event, callbackFunction)

subscribeOnce(event, callbackFunction)

Adding more languages to our application - Internationalization!

For Webpack users

JSPM users

Aurelia CLI users

Configuring and defining our first translation files

Using the plugin - Multilanguage support!

Tracking method calls and user actions - Logging

Configuring your log manager

Modal configuration - Aurelia dialog at rescue!

Getting the Aurelia-dialog plugin

Adding dialog components to our application

Dynamic value converters - Less code, more functionality

The problem - Data is not exposed as we need

Binding custom behaviors to our application.

Improving our application forms - Validators

Preparing for war - Getting the validation plugin

First steps - Defining our rules

Manipulating the DOM - Custom attributes

Understanding how computed properties work

Chapter 8: Security

Understanding JSON Web Tokens

JWT

Custom authentication and authorization

Implementing authentication

The authentication logic

Generating the token

The authentication REST controller

Implementing authorization

Creating the Admin API

Managing matches

Creating the Match schema

Creating the REST controller

Creating Matches

List Matches

Updating the Scores

Securing the REST controller

Validate token

Validate permissions

Introducing Auth0

A simple example

Creating an account

Registering an Auth0 client application

Exploring our example application

Social Login with Auth0

Single sign-on

Chapter 9: Running E2E Tests

Integration testing - Multiple services, one application

Configuring applications for integration testing

Mocking external dependencies

Calculating code coverage

Does our app meet our business requirements? UI testing

Scripted testing

Exploratory testing

UX testing

Planning our tests - Time for the truth

Defining common scenarios

Writing test cases

Organizing our test - Creating scripts

API test with Swagger

Installing Swagger

Chapter 10: Deployment

Configuring our web for production

Deploying on your own server

Creating our NGINX configuration file

Creating our Dockerfile

Running our application on Docker

Deploying on Heroku

Creating a Heroku account

Preparing the application

Deploy

Deploying on AWS S3 Buckets

Uploading files

Configuring our S3 Bucket for the web

Other Books You May Enjoy

Index.

Notes:

Includes index.

Description based on print version record.

ISBN:

9781788834919

1788834917

OCLC:

1042323513