Ex 01

• runtime environment for JS code

• -> previous: did only run in browser…

• single threaded

• event driven

• non-blocking

• asynchronous

• allows node.js to perform

  • non-blocking I/O operatoins

  • despite fact that java scrip tis single-threaded

• => by assigning operations to the OS

• has event queue that is processed FIFO

• registers callbacks for intensive operations (i.e. file system, db access, computation) to OS

• non-intensive / non-outsourced events and callbacks (response from registered, finished callbacks) are in event queue

• real-time applications

  • process high volume of short messages

  • requiring low latency

• fast and scalable environemnt

  • ability to process many requests with low response time

  • greate fit for modern web applications carrying out lots of processing on the client side

• CPU-heavy jobs

  • single-thread -> uses only one CPU core

  • CPU-heavy operations will just block incoming requests, rendering biggest advantage of Node.js useless

• simple web applications

  • superfluous

  • we dont need separate API and all data comes from server…

• used to install node programs/modules

• like pip but for node.js

• modules get installed inside “node_modules” folder

• npm install express

  • //install express module

    • -> folder in local projcet where all dependencies are installed

• npm install express —save

  • // install express module and add in package.json

• npm install -g express

  • // install express globally

• express

  • web development framework

• connect

  • extensible http server framework

• socket.io

  • server side component for websocket

• mongo/mongoose

  • wrappers to interact with mongo database

• presnt inside root folder of your package / application

• tells npm how package is structured and what all dependencies need to be installed

• communication paradigm for client server architectures

• Representational state transfer

• resource based - deals with things instead of actions (like a person, address,…)

• transfer typically using json or xml

1. uniform interface

2. stateless

3. client-server

4. cacheable

5. layered system

6. code on demand (optional)

• use HTTP actions

  • get

  • post

  • put

  • delete

• uniform resource identifiers (URI)

  • -> resource names

• HTTP response

  • status, body

• server contains no client state

  • no session

  • no history

• each request contains enough context to process message

• Client application and server application MUST be able to evolve separately without any dependency on each other

• caching can be applied to resources when applicable

  • and these resources MUST be declared cacheable.

• Caching can be implemented on the server or client side.

• Uses layered system architecture where for example

  • we deploy the APIs on server A,

  • and store data on server B

  • and authenticate requests in Server C.

• Most of the time we will be sending the static representations of resources in form of XML or JSON.

• Can return executable code to support a part of your application

  • e.g. clients may call API to get a UI widget rendering code.

• open source document database

• high performance

• high availability

• automatic scaling

• NoSQL database

  • uses JSON like documents to store information

  
  

• document

  • -> datastructure with field and value pairs

• collection:

  • grouping of MongoDB documents

• databases

  • collections of documents

we are making use of Mongoose

• Import Mongoose

const mongoose = require(‘mongoose’),

Schema = mongoose.Schema;

• Creating Schema for Object (in our case Book)

const BooksSchema = new Schema({

title: String,

…

});

• creating mongoose model (wrapper for schema)

const BooksModel =

mongoose.model(‘books’, BooksSchema);

• export model to be usable in other program with import…

module.exports = BooksModel;

have extra file like Index.js consolidating all DB schemas

• connect to MongoDB (running locally at localhost:27017

const mongoose = require(“mongoose”);

mongoose.connect(process.env.MONGODB_URI

|| “mongodb://localhost:27017/booksData”,

{useNewUrlParser: true});

• export it

module.export.books =

require(“./books.js”);

server.js -> start web server an contains all API endpoints

• create web server using express

const express = require(‘express’);

const app = express();

• when accessing i.e. root endpoint (http://example.com/)

• calls the function homepage

• which (as defined here)

  • sends the index.html file in the response (res)

app.get(‘/’, function homepage(req, res){

res.sendFile(__dirname +

‘/views/index.html’);

});

• when accessing http://example.com/api

• sends some json information…

• => is syntactic sugar to define a function…

app.get(‘/api’, (req, res) => {

res.json([…])

});

app.use(express.static(__dirname +

‘/public’));

• this particular directory is called public…

app.get(‘/api/books/’, (req, res) => {

db.books.find({}, function (err,books) {

if (err) throw err;

res json(books);

});

});

• uses books model and query to mongo database to get all ({}) objects stored

• books is array of json objects -> returned to user…

app.listen(process.env.PORT || 80, () => {

console.log(‘Express server is up and

running on http://localhost:80/’);

});

=> process.env.PORT | | 80

-> if environemnt variable is present

-> else use 80 as default…

• mkdir data

  • here, all mongo db info is stored in some directory…

• mongod —dbpaht=./data