Merge branch 'master' of https://github.com/getmscode2013/NodeJsTutorial

getmscode2013 · getmscode2013 · commit 0d0ba330028f · 2020-05-20T21:44:54.000+05:30
diff --git a/README.md b/README.md
@@ -125,6 +125,193 @@ Some other global object are
 - //Reports
 - //Process
 
+## Day 4 -  ECMA Script
+
+ECMA  was created to standardize JavaScript to help foster multiple independent implementations.
+The full form of ECMA is European Computer Manufacturer's Association.A standard for scripting languages like JavaScript, JScript is ECMAScript.
+
+Here NodeJS follow the ECMA standard, here we are going to dicuss about Const, Let and class.
+> <b>let :</b>  Unlike variables declared with var that are function-scoped, variables declared with let are block-scoped: they only exist in the block they are defined in.
+
+```ruby
+var a = 20
+var a = 30;
+
+console.log(a);
+
+let x = 20;
+x = "satya"; /// but you can change the datatype
+//let x = 30; /// if you will defined like that it will give error
+
+console.log(x);
+var v = () => {
+    let x = 50;   /// here again you can defined it and it will work like scoped variable.
+    console.log(x);
+}
+v();
+
+```
+Difference in Var and Let
+
+
+|Var 		   		                            | let 					                                    |
+| ----------------------------------------------|--------------------------------------------------------------------------- |
+|variables belong to the global scope or local scope  if they are declared  inside a function: var counter;| The let variables are blocked scopes: let counter;				 |
+|var variables are added to the global object as properties. The global object is window on the web browser and global on Node.js: |However, the let variables are not added to the global object|
+|The var keyword allows you to redeclare a variable without any issue.| If you redeclare a variable with the let keyword, you will get an error|
+
+
+> <b>Const :</b>  Variables defined with const behave like let variables, except they cannot be reassigned. <br />
+
+If we assign a primitive value to a constant, we cannot change the primitive value: 
+
+
+```ruby
+const a = 30;
+//a = 40; // you can not assign the a to another value
+
+console.log(a);
+
+```
+
+You can change the properties of a constant object:
+
+```ruby
+
+// but if you defined the object and want to change the value of it tha you can do that
+
+const obj =  {name : "satya", phoneNo : 1234567890, email : "Test@gmail.com"}
+
+console.log(obj);
+
+obj.age = 20;
+console.log(obj);
+
+obj.phoneNo = 1234512345;
+console.log(obj);
+```
+> <b>Class :</b>  Its type of function, but instead of using function keyword to initiate it, here use the keyword class, and the properties are assigned inside a constructor() method. <br />
+
+```ruby
+class TestUserClass 
+{
+    constructor()
+    {
+        this.name = "Satya first ";
+        this.phoneNumber = "6776777"
+    }
+
+    getName()
+    {
+        //console.log(name); // this will give error to access any of the class values you need to use thi.
+        console.log(this.name);
+        this.age = 12
+        return this.name;
+    }
+
+    getAge()
+    {
+        return this.age;
+    }
+}
+
+
+var tc = new TestUserClass();
+//tc.getName();
+console.log(tc.getAge()); // you need to call the Get name first as the Age setting their.
+```
+
+## Day 5 -  Prototype
+
+In the previous chapter we learned how to use an object constructor.
+
+Sometimes you want to add new properties (or methods) to all existing objects of a given type.
+Sometimes you want to add new properties (or methods) to an object constructor.
+
+Prototype property  in Javascript allows you to add new properties to object constructors.
+
+``` ruby
+// prototype usese to extend the functionalty of exiting function.
+
+var Employee = function()
+{
+this.name = "Satya";
+this.age = 30;
+
+
+}
+
+
+var e =  new Employee();
+console.log(e.age);
+
+Employee.prototype = {
+    phoneNumber : "4545454",
+
+    GetAge : function()
+    {
+        return this.name;
+    }
+}
+
+var e =  new Employee();
+console.log(e.age);
+console.log(e.phoneNumber);
+console.log(e.GetAge());
+```
+
+## Day 6 -  Modules
+
+1. Instead of keeping all the code in one file we split the code into multiple file. 
+2. To splitting the file into mutiple file we defined it as modules.
+3. You can create your own modules, and easily include them in your applications.
+4. It will be useful for code resuability and for maintability. <br /><br />
+
+Creating a samall calculator with is having addition, substartion and defined all in different file<br />
+
+<b> addition.js </b>
+
+```ruby
+// Addition module which need to export.
+
+module.exports = {
+
+    Addition : function(a,b)
+    {
+        return a + b;
+    }
+
+}
+```
+
+<b> subtration.js </b>
+
+```ruby
+// you can define the modules like that as well as.
+// We define modules into two type.
+
+var subtration = function(a,b)
+{
+    return a -b;
+}
+
+module.exports.subtration = subtration;
+```
+
+<b> Calculator.js </b> < br/>
+Need to use require to export the module.
+
+```ruby 
+// exporting both of the module using require.
+
+var add = require("./addition");
+var sub = require("./subtration");
+
+console.log(`Addition  of number 10 and 12 : ${add.Addition(10, 12)}`);
+console.log(`Subtration  of number 14 and 12 :  ${sub.subtration(14, 12)}`);
+```
+
+
 ## Day 10 -  ExpressJs
 
 ExpressJs use to build the Node Application, it make faster the devlopment and provide inbuild code for development.<br /><br />
@@ -529,3 +716,203 @@ Plug that method which we need to attach that middle ware
   })
 
 ```
+
+  ## Day 17 -  NestJs
+  
+```https://docs.nestjs.com/``` <br />
+- It is used to build serverside application microservices and RestAPI.
+- It is proper framework like Asp.net, Django. It is provide you the architecture to build a server.
+- It is Extensible, Versatile and prograssive javascript.
+- If you are working with NestJs, type script is the default module. If you have worked with angular than NEST js is pretty similar.
+- Nest makes use of robust HTTP Server frameworks like Express (the default) and optionally can be configured to use Fastify as well!
+- Nest provides an out-of-the-box application architecture which allows developers and teams to create highly testable, scalable, loosely coupled, and easily maintainable applications.
+
+```https://docs.nestjs.com/techniques/database``` <br />
+```https://docs.nestjs.com/recipes/sql-typeorm``` <br/>
+- Nest is database agnostic, allowing you to easily integrate with any SQL or NoSQL database
+- You can also directly use any general purpose Node.js database integration library or ORM,
+- Nest provides tight integration with TypeORM and Sequelize out-of-the-box with the @nestjs/typeorm and @nestjs/sequelize packages respectively, @nestjs/mongoose package for mango DB.
+
+```https://docs.nestjs.com/techniques/authentication```
+- Passport is the most popular node.js authentication library, well-known by the community and successfully used in many production applications. It's straightforward to integrate this library with a Nest application using the @nestjs/passport module
+At a high level, Passport executes a series of steps to:
+a) Authenticate a user by verifying their "credentials" (such as username/password, JSON Web Token (JWT), or identity token from an Identity Provider)
+b)Manage authenticated state (by issuing a portable token, such as a JWT, or creating an Express session)
+c)Attach information about the authenticated user to the Request object for further use in route handlers
+
+```https://docs.nestjs.com/techniques/logger``` <br />
+- Nest comes with a built-in text-based logger which is used during application bootstrapping and several other circumstances such as displaying caught exceptions (i.e., system logging). This functionality is provided via the Logger class in the @nestjs/common package. 
+
+```https://docs.nestjs.com/techniques/performance``` <br />
+- Nest also provides compatibility with other libraries such as, for example, Fastify. 
+Fastify provides a good alternative framework for Nest because it solves design issues in a similar manner to Express. However, fastify is much faster than Express, achieving almost two times better benchmarks results.
+
+```https://docs.nestjs.com/graphql/quick-start``` <br />
+- Harnessing the power of TypeScript & GraphQL.
+GraphQL is a powerful query language for APIs and a runtime for fulfilling those queries with your existing data. It's an elegant approach that solves many problems typically found with REST APIs.
+- GraphQL queries access not just the properties of one resource but also smoothly follow references between them. While typical REST APIs require loading from multiple URLs, GraphQL APIs get all the data your app needs in a single request. Apps using GraphQL can be quick even on slow mobile network connections.
+
+```https://docs.nestjs.com/microservices/basics``` <br />
+- Nest natively supports the microservice architectural style of development.In Nest, a microservice is fundamentally an application that uses a different transport layer than HTTP.
+Nest supports several built-in transport layer implementations, called transporters, which are responsible for transmitting messages between different microservice instances. Most transporters natively support both request-response and event-based message styles. 
+It uses package @nestjs/microservices.
+
+```https://docs.nestjs.com/fundamentals/testing``` <br />
+- Automated testing is considered an essential part of any serious software development effort. It is provides integration with Jest and Supertest out-of-the-box, while remaining agnostic to testing tools.
+  
+## Day 18 -  NestJs-into (hello world)
+    
+1. It is mainly used to create Rest API, a NodeJS framework, builds on ExpressJs.
+2. Embraces TypeScript, dependency Injection and Modularity("Angular for Backend")
+3. Can be used to build MVC apps or Rest or GraphQl Apis.
+4. Enforces clean code and a clear project staructure by giving you a series of building blockes.
+5. Makes building complex application easy.
+
+
+6. Lets install NestJs first.
+
+https://docs.nestjs.com/first-steps
+a) Open ```NodeJs command``` promt.
+Setting up a new project is quite simple with the Nest CLI. With npm installed. [It is similar to angular installation]
+ <br>
+b) ```npm i -g @nestjs/cli```
+
+c) Create new project using NEST
+```nest new project-name```
+e.g. nest new day18-NestIntro
+
+it will ask for which package manager you want yo use for. I have chossen npm. Now it will install all th dependent packages.
+It takes 5 - 10 minute to install successfully.
+
+<img src="https://github.com/getmscode2013/NodeJsTutorial/day18-nest-intro/NestPackaesInstalledsuccessfully.png">
+
+7) Now open your application in visual studio code.
+a) now to see the diffrnce on the icon you can install extension "Material Icon Theme"
+b) so lets see the application structure.
+<img src="https://github.com/getmscode2013/NodeJsTutorial/day18-nest-intro/projectstructure.png">
+
+ - Node_module - consist all the package installed for application. - you can get details from package.json.
+- Src - is the mail folder on which we will work its contains all the source files.
+- Test - it is nothing but test setup for application. by default in jest.
+- .gitignore file - is file used to ignore the git  uploads.
+- nest-cli.json  file - It is nest configuration file.
+- package.json - contain all the installed module definations.
+- tsconfig.json - is type script configuratio files.
+
+c) let see what we have in src.
+
+- <b> main.ts <b/> - its entry point for application. nodejs not run typescript so code compile to javascript. 
+if you will se the code here it is follow like expressJS.
+Creating the server and which will work on 3000 port.
+```ruby
+ const app = await NestFactory.create(AppModule);
+  await app.listen(3000);
+```
+- <b>app.module.ts </b>
+Nest is written the application in the moduler form like angular.
+As in above its written NEST is embraces modularity.  Nest is not taken all the files in your working folder. it will take only which has imported their. <br />
+Imported part in NESTJs is controller and provide. As you need to list over here.
+    ```ruby
+ controllers: [AppController], // bundle of controller
+  providers: [AppService], // bundle of services
+    ```
+
+> Controller : it is responsible to get the comming request and doing something and response it back.
+> Provider : it will inject the certain functionlaity to controller. it like service of database to get the data from database.
+
+here you can see the ``` @module``` as the decorator which is attched to the class.
+
+
+- <b> app.controller.ts - </b>
+It is app class as AppController which is decorated by @controller. 
+It is having method of getHello() decorated by @Get
+in Appcontroller you will find the code like below.
+
+```ruby
+@Controller()
+export class AppController {
+```
+Means it will accept the empty parameter like
+your-domain.com/
+
+if you have the parameter in controller like user
+```ruby
+@Controller('user')
+export class AppController {
+```
+you need to use it like your-domain.com/user
+
+Same happan for the get also if it is like
+```ruby
+@Controller('User')
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get('Product')
+  getHello(): string {
+    return this.appService.getHello();
+  }
+}
+```
+you need to use it like your-domain.com/user/product
+
+Last thing is service. So here you are injecting the service to app.controller.
+```ruby
+constructor(private readonly appService: AppService) {}
+```
+this service should be registerd in the module. here you are declaring ut and using it by.
+```ruby
+this.appService.getHello();
+```
+
+-<b> app.service.ts </b>
+
+All your login aout the application or DB call are written to the service.
+It is using @Injectable decorator code for AppService class.  And defined a method like getHello in service.
+```ruby
+getHello(): string {
+    return 'Hello World!';
+  }
+```
+Here you can write your complex logic.
+
+- <b>app.controller.spec.ts </b>
+It used to write the unit test methods for app.controller
+
+8) Run application
+Now let run and see the application.
+> cd day18-nest-intro
+> npm run start
+or to run with nodemon 
+> npm run start:dev
+
+<img src="https://github.com/getmscode2013/NodeJsTutorial/day18-nest-intro/helloworld.png">
+
+it is showing "hello world" it is giving the result of string from service.
+Lets change it to some of the JSON values. Changes in controller directly with below code.
+
+```ruby
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello(): {name: string,phoneNumber: number, addresses: string} {
+    return {name: "Satya", phoneNumber: 1234567890, addresses : "test"};;
+  }
+}
+```
+
+<img src="https://github.com/getmscode2013/NodeJsTutorial/day18-nest-intro/jsonoutput.png">
+
+You can even define the heder also for your API you need to import header.
+import { Controller, Get, Header } from '@nestjs/common';
+
+and add the decorator @Hedader like below.
+```ruby
+ @Get()
+  @Header("Content-type",'test/html')
+  getHello(): {name: string,phoneNumber: number, addresses: string} {
+    return {name: "Satya", phoneNumber: 1234567890, addresses : "test1"};;
+  }
+```
+
