Hands-On Full Stack Web Development with Aurelia电子书

Title Page

Copyright and Credits

Hands-On Full Stack Web Development with Aurelia

Dedication

Packt Upsell

Why subscribe?

PacktPub.com

Foreword

Contributors

About the authors

About the reviewer

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Conventions used

Get in touch

Reviews

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

Technical information

Dependency injection

Component encapsulation

Aurelia

Technical information

Dependency injection

Component encapsulation

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

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

Summary

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

Summary

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!

Summary

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

Summary

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

Creating a new team

Listing the teams

Finding a single team

Updating teams

The async/await instruction

Deleting teams

Summary

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!

Installation and configuration

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

Summary

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

Summary

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

Summary

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

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think