• A JavaScript runtime environment that operates outside the browser. Useful for both servers and desktop applications.
• Runs cross-platform, supported by Linux, MacOS, and Windows.
• Consists of: 
• A JavaScript runtime environment which includes:
• Google's open sourced V8 JavaScript engine, the same JS engine used by Google Chrome and MS Edge browsers.
• Bindings: Some Node libraries are written in C and C++ so Node provides bindings to convert them from/to JS. 
• The libuv library for handling asynchronous I/O operations. 
• JavaScript Libraries:
• A core library of JavaScript modules with APIs for interacting with the file system, http, timers, etc. 
• A package management system (NPM) for incorporating third party libraries into your project.
• Open source so free to use. Governed by the OpenJS Foundation, which is facilitated by the Linux Foundation's Collaborative Projects program.
• Originally written by Ryan Dahl and released in 2009.
• Operates on a single thread using an event loop. A thread is the smallest sequence of a program that can be managed independently by the operating system's scheduler. Single thread means it executes tasks one at a time blocking other tasks until it completes. Multi-threaded programs can run multiple tasks concurrently. Because JS is single threaded, Browsers have a timeout for tasks that take too long.

• I/O operations are asynchronous (i.e., non-blocking) and event driven allowing other operations to run in parallel while it is completing its task. 
• Input/Output operations interact with resources outside Node such as the system disk, database, http requests, etc. 
• These are handled by Node's libuv library and passed to the operating system to process in the background.
• I/O tasks that can't be handled asynchronously by the operating system may be passed to a thread pool (making Node multithreaded in these cases).
• When the task is complete it triggers an event and a callback function handles the result. 
• Promises, including async/await syntax, can be used in place of a callback function.
• Node does have synchronous (i.e., blocking) I/O functions that can be used if needed. 
• Node is frequently used as a web server because its single thread is fast/efficient for a large volume of I/O requests such as HTTP requests. Because it is single threaded it is not a good option for CPU intensive programs. 

• Install/upgrade Node by downloading it from their website nodejs.org/en/download

• The Nodemon package gives you hot reloading. It reloads your app whenever you save a .js, .mjs, .json file that is inside your project directory.
• Ref: npmjs.com/package/nodemon
• Installation: To make it available for all Node apps, install it globally.

• nodemon command will look for a file to run in this order:
1. If there is a filename argument nodemon filename it will run the file.
2. If there is no filename arg given, nodemon looks for the default filename index.js
3. Looks for file in package.json: "main": "filename",
4. Looks for a "start" script to run in package.json: "scripts": {"start": "node filename"},
5. If all the above fail, nodemon throws an error.

const calculator = require('./calculator');
console.log(calculator.double(10)); // logs 20
console.log(calculator.triple(10)); // logs 30

app.js (import file)

const { double, triple } = require('./calculator');
console.log(double(10)); // logs 20
console.log(triple(10)); // logs 30

import calculator from './calculator.mjs';
console.log(calculator.double(10)); // logs 20
console.log(calculator.triple(10)); // logs 30

app.mjs (import file)

import { double, triple } from './calculator.mjs';
console.log(double(10)); // logs 20
console.log(triple(10)); // logs 30

• Express is a light-weight web application framework.
• At the top of a file that uses the package, import the package as a module with the require function set to the "express" variable name:

• The you can use the express variable to access the module methods, variables or other constructs. Express has a method for parsing JSON data:

• It is a good candidate for global installation because:
• It is run from the command line.
• It is used frequently across many projects.
• Install nodemon: npm install nodemon --global 
• Run your project just by executing the program: nodemon 

...
"dependencies": {
  "ejs": "^3.1.8",
  "express": "^4.18.1",
  "sequelize": "^6.21.2"
}
...

• To see what packages are not up-to-date run: npm outdated
• It will show you the outdated packages and versions side by side. It will show you what version it will update to if you re-install or update it. 
• If the latest ejs version is 4.1.3 which is a major version higher. To update to that version run: npm i ejs@4

• Ask a question. Add > as a response prompt.
• This opens a session of Node.js in the terminal.
• The stdin method processes user standard input from the Terminal.
• Chain the Event module's "on" method, listening for the "data" event. 
• The "data" event occurs when the user presses the return key.
• Output a response using that data.
• The default stdin encoding is as a buffer object, so you need to convert it to a string.
• Unless you set the encoding to UTF-8 (a standard encoding for text).

• Stdin terminates in a new line. In this case we don't want that new line so chain .trim().
• Exit the process which takes us out of the Node.js terminal session.

fs.appendFile('myTextFile.txt', '\nAppend more data.', (err) => {
  if (err) throw err;
});

fs.unlink('myTextFile.txt', (err) => {
  if (err) throw err;
});

fs.unlinkSync('myTextFile.txt');

fs.readdirSync('src').forEach((filename) => {
  fs.unlinkSync(`src/${filename}`);
});

if (!fs.existsSync('src')) {
  fs.mkdir('src', (err) => {
    if (err) throw err;
    console.log('directory created');
  });
}

• Synchronous version.

fs.mkdirSync('src')

• Option: create the src and nested data directory recursively.

fs.mkdirSync('src/data', { recursive: true })

fs.rmdir('src', (err) => {
  if (err) throw err;
});

fs.rmdirSync('src')

fs.readdirSync('src').forEach((filename) => {
  fs.unlinkSync(`src/${filename}`);
});
fs.rmdirSync('src');

fs.rename('myTextFile.txt', 'src/textFile.txt', (err) => {
  if (err) { throw err; }
});

fs.renameSync('src', 'data');

const fs = require('fs');
const readStream = fs.createReadStream('hugeFile.txt', 'utf8');
readStream.once('data', () => {
  console.log('Start the data stream.');
});
readStream.on('data', (chunk) => {
  console.log('\nPrint new chunk:\n', chunk);
});
readStream.on('end', () => {
  console.log('Data stream complete');
});
readStream.on('error', (err) => {
  console.error(err.message);
});

• Load the File System 'fs' module.
• Create a read stream object specifying the path. fs.createReadStream(path[, options])
• Set the encoding option to 'utf8' or it will return a buffer object instead of text.
• When the buffer sends a data chunk it emits the "data" event.
• The once() method will execute the callback function the first time the event occurs.
• The on() method executes the callback function every time the event occurs.
• The "end" event is emitted when the stream has finished sending all the data.
• You need to listen for an "error" event to handle any errors.

• Readable streams work with writeable streams.
• Read data from the input.txt file then output it to a new file called output.txt.

// read-write-stream.js

const fs = require('fs');
const readStream = fs.createReadStream('hugeFile.txt', 'utf8');
const writeStream = fs.createWriteStream('output.txt');
readStream.on('data', (chunk) => {
  console.log(`Chunk received: ${chunk.length} characters`);
  writeStream.write(chunk);
});

• Run the file: node read-write-stream 

readStream.on('data', (chunk) => {
  writeStream.write(chunk);
});

1. A client (a browser) sends an HTTP request to a server over the internet.
2. The web server receives the request.
3. The web server application processes the request, getting files, possibly data from a database.
4. The server returns an HTTP response (output) to the browser.
5. The client (the browser) receives the response and processes it (e.g., displays an HTML page).

• The request message is a stream of data from the client to the server.
• Starts with a Request line which contains:
• Request method: GET, POST, PUT, PATCH, DELETE.
• URL: the host (e.g., example.com) and path (e.g., /about).
• Protocol: HTTP or HTTPS.
• Request Headers containing additional info about the request.
• Optional Request Body:
• If the request is a form submission then it will send the form data.
• POST requests add new data.
• PUT or PATCH requests update existing data.

The Response Message:

• The server responds to the request with a response message. A stream of data from the server to the client.
• It starts with a Status line with the status code and reason message.
• 2xx success, 3xx redirect, 4xx client error, 5xx server error.
• Response Headers: includes type of content sent (e.g., HTML, JSON, CSS).
• Optional Response Body: The data sent back (e.g., HTML document, image, CSS).

• Informational responses (100–199)
• Successful responses (200–299)
• 200 OK - The request has succeeded.
• 201 Created - POST or PUT request succeeded and a new resource created.
• 204 No Content - The action is successfully completed and no further info is to be supplied. Can use for a successful delete request.
• Successful responses by HTTP Request method:
  

  • GET: 200
  • POST: 201
  • PUT: 200 update success, include data or a message. 204 indicates update success without sending back data or a message. 201 request was successful and created a new record.
  • DELETE: 200 delete success, include a success message. 204 indicates success without sending back a message. 
• Redirects (300–399)
• 301 Moved Permanently - Requested URL has been changed permanently. The new URL is given in the response.
• 302 Found - Requested URI has been changed temporarily. The original URI should be used by the client in future requests.
• 307 Temporary Redirect - Same as 302, but specifically specifies that the HTTP method must not change.
• 308 Permanent Redirect - Same as 301, but specifically specifies that the HTTP method must not change.
• Client errors (400–499)
• 400 BadRequest - Server could not understand request due to invalid syntax.
• 401 Unauthorized - Client must be authenticated before getting the requested response.
• 403 Forbidden - Client is known to the server but does not have access rights to the content.
• 404 NotFound - Server can not find requested resource. In the browser, this means the URL is not recognized.
• 422 UnprocessableEntity - Request content type and syntax are ok but the server was unable to process the contained instructions. Client should modify the request.
• Server errors (500–599)
• 500 InternalServerError - The server has encountered a situation it doesn't know how to handle.

• Listen for the Request:
• When an HTTP request is received, a connection must first be established.
• The server.listen(port) method asynchronously listens for requests. 
• In development include the port option, with a valid port such as 3000.
• When a request is received the following occurs behind the scenes.
• An TCP connection is established and the connection event is emitted. TCP is the protocol used for exchanging messages over the internet.
• On a connection event, the listener function reads the request, creates a request object, and emits a request event.
• The server object is listening for the request event.
• Handle the Request:
• createServer() takes the requestListener function as it's argument:

• Synchronous (sync): Code is executed in sequence, line by line, one line at a time. Blocking: When a synchronous function is called, the program waits until the function returns its value before proceeding to the next line. 
• Asynchronous (async): Function calls are made in sequence but the program doesn't wait for the result before moving on to the next line. Non-blocking: Instead, the async function's task is processed in the background. Event-driven: When complete it passes the result to a callback function which gets sent to the event loop for execution.

• Ref: Nodejs.org/en/docs/guides/event-loop-timers-and-nexttick
• The JS Engine contains the call stack and a memory heap.
• It parses the JS code, converts it to machine code, and executes it.
• To do this it creates a space in RAM memory to hold data objects (variables, function definitions, objects, arrays) using a heap data structure.

• Functions are placed on the call stack and executed. When the functions are executed, all the data is written to the heap and the stack references the memory addresses when executing the code. When the code finishes executing, the JS Garbage Collector removes the data from memory. 
• The call stack operates on a Last-In-First-Out (LIFO) basis. So if the function on the stack calls another function, that will get placed on top of the stack and executed first. 
• Functions in the call stack are executed synchronously. Other code is blocked from running until it is complete. Once complete it is removed from the stack and the function below it is executed. This continues until the stack is empty.
• I/O operations: Managed by Node's libuv library using a design called the Reactor pattern.
• I/O operations such as accessing the file system, network, timer, or a database generally need to be processed asynchronously for performance reasons.
• When a function on the call stack calls an I/O-related function, it passes a callback function argument (or creates a Promise object) to handle the result.  It is then immediately removed from the call stack (so it doesn't block). 
• Node passes the I/O task to be processed in parallel by the operating system or in some cases by a pool of threads.
• Node modules inherit from the Event module which they use to emit an event when an I/O task is complete.
• Node listens for the event. When emitted the callback function is added to the end of the callback queue with the result.
• Like the browser, Node.js runs an event loop. The event loop monitors the call stack which runs synchronously. When the call stack is empty the event loop checks the callback queue for the next callback function. If there is one it places it on the call stack to be executed.
• The Callback Queue operates on a First-In-First-Out basis. If there are multiple callback functions in the queue it takes the oldest one first.
• When the callback queue is empty, the event loop continually monitors it for a new callback.

• The above example imports the Node fs (File System) module. Ref: Nodejs.org:api
• It calls the readdir method which returns an array of all file names in the given directory.

• Node passes this task off to the operating system. When it is complete it passes Node the result or an error.
• If there is an error Node calls the callback function passing in the error object. The if statement checks for an error, then throws the error. 
• If there is not an error Node calls the callback with a null value for err, and the files array as the second arg. The function then logs the files array to the console.

• Create an instance of the EventEmitter class:

• Or create instance of class that inherits from EventEmitter:

• With arguments:

• With arguments: