Node.js 6.x Blueprints电子书

Node.js 6.x Blueprints

Node.js 6.x Blueprints

Credits

About the Author

About the Reviewer

www.PacktPub.com

eBooks, discount offers, and more

Why subscribe?

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. Building a Twitter-Like Application Using the MVC Design Pattern

Installing Node.js

Installing Yeoman

Installing Express generator

Building the baseline

Adding changes to the package.json file

Running the application

Changing the application's structure

Changing the default behavior to start the application

Restructuring the views folder using partials

Adding templates for login, sign-up, and profile

Installing additional middleware

Refactoring the app.js file with the new middleware

Adding config and passport files

Creating a models folder and adding a user schema

Protecting routes

Creating the controllers folder

Running the application and adding comments

Checking the error messages

Summary

2. Build a Basic Website Using MySQL Database

What we are building

Creating the baseline applications

Installing the Swig template engine

Refactoring the views folder

Creating a controllers folder

Removing the default routes folder

Adding partials files for head and footer

Installing and configuring Sequelize-cli

Editing the config.js file with database credentials

Creating a User scheme

Creating Band schema

Creating associations between Band and User models

Creating the database on MySql

Using db migrations to insert data on Mysql

Checking database tables

Creating the application controllers

Creating the application templates/views

Adding style to the application

Adding routes and a controller to the application

Adding database content

Creating a Bands form

Inserting a new Band

Main difference between ODM (mongoose) and ORM (sequelize)

Summary

3. Building a Multimedia Application

What we are building?

Starting with package.json

Adding baseline configuration files

Adding server folders

Configuring the app.js file

Creating the config.js file

Creating the controller's files

Creating model files

Creating view files

Creating the public folder content

Inserting images in the application using the upload form

Inserting video files into the application using the upload form

Important notes about image and video upload

Summary

4. Dont Take a Photograph, Make It – An App for Photographers

What we are building

Creating the baseline applications

Changing the application structure

Adding Node modules to deal with images and the Cloudinary cloud service

Creating the book controller

Creating the book model file

Adding a CSS framework to the application

Refactoring the views folder

Creating the .env.js file

Creating and configuring a Cloudinary account

How Cloudinary works

Running the application

Uploading and showing images

Checking the MongoDb picture collection

Creating folders in the Cloudinary dashboard

URL transformation rendering

Adding a direct link to the original image

Summary

5. Creating a Store Locator Application with MongoDB Geospatial Query

What we are building

Creating the baseline application

Refactoring the default structure

Creating partial views for footer and head

Setting Swig template to use HTML extension

Creating partial files

Creating applications template files

Using the Geolocation HTML5 API

Creating the application controller

Creating models

Creating the views template

Adding locations to MongoDB

Understanding Geospatial indexes on MongoDB

Creating 2dsphere indexes in MongoDB

Checking the Geolocation application

Ordering points by distance

Summary

6. Building a Customer Feedback App with a Restful API and Loopback.io

What we are building

Creating the baseline structure

Creating models with command line

Editing models after creation with command line

Creating a datasource through the command line

Connecting models to datasources

Using the API Explorer

Inserting records using endpoint

Retrieving records using endpoint

Adding database relations

Dealing with LoopBack boot files

Consuming the API

Adding HTML content to client side

Adding Bootstrap framework and React library

Creating React components

Creating new feedbacks

Simple checking endpoints

Disable remote LoopBack endpoints

Summary

7. Building a Real–Time Chat Application with Socket.io

What we are building

Starting with a package.json file

Adding configuration files

Adding task manager files

Creating the app.js file

Creating the route file

Creating the application views

Installing frontend components with Bower

Adding some CSS

Adding live reload plugin

Checking the application folder structure

Creating the Socket.io events

Adding socket.io behavior on the client side

Starting the chat application

Summary

8. Creating a Blog with the Keystone CMS

What we are building

Installing Keystone framework

Creating the scaffold application

Fixing the lint error and admin object name

Running the Keystone blog

Anatomy of the Keystone engine

Changing the default bootstrap theme

Modifying the KeystoneJS core template path

Building our own theme

Changing the stylesheet

Adding the Gallery script

Extending the keystone.js core

Inserting content using control panel

Summary

9. Building a Frontend Process with Node.js and NPM

What we are building

Creating the baseline application

Adding a Datasource to the project

Creating application models

Adding relationships between application models

Setting up a static site

Refactoring the application folder

Creating the images folder

Creating the libraries folder

Creating the scripts folder

Creating the SASS folder

Installing Bower

Installing application dependencies

Create the scss folder structure

Refactoring the client folder

Adding the application views

Installing AngularJS files

Creating the AngularJS application

Using Loopback's AngularJS SDK

Adding content to the application

Creating the Building tasks

Installing the dependencies

Creating the copy task

Creating the SASS task

Creating the linting task

Creating the image optimization task

Creating the concatenate task

Creating the build task

Using tasks with individual commands

Deploying to Heroku Cloud

Creating a Heroku application

Creating a deploy.sh file

Summary

10. Creating and Deploying Using Continuous Integration and Docker

What we are building

What Continuous Integration means

Creating the baseline application

Adding the root files

Creating the config folder and files

Creating the controllers folder and files

Adding modules and authentication middleware

Adding login GET and POST methods

Adding signup GET and POST methods

Adding account GET and UPDATE methods

Adding account DELETE method

Creating the model folder and files

Creating the public folder and files

Creating a custom stylesheet

Creating the fonts folder and adding font files

Creating the JavaScript folder and files

Creating the views folder and files

Adding the layouts folder and file

Adding the pages folder and files

Adding the partial folder and files

Creating the test folder and test file

Running the application

Creating a GitHub or Bitbucket free account

Creating a GitHub free account

Creating a Heroku free account

Creating a MongoLab free sandbox account

Creating a user and password for the database

Getting the string connection

Initializing a git repository and pushing to GitHub

Creating a Heroku application using Heroku Dashboard

Linking the Heroku application to your git repository

Adding environment variables to Heroku

Creating a Codeship free account

Adding environment variables to Codeship

Creating setup and test commands in the Codeship project configuration

Creating the pipeline for deployment on Heroku

Adding the Heroku API key to Codeship

Checking the test and deploy steps on the Codeship dashboard

Installing Docker and setting up the application

Checking the Docker version

Creating a Docker file

Creating a Docker image

Preparing and running the Docker image

Uploading the project image to your Docker hub account

Summary