All posts by admin

Debug typescript in Node JS

March 22, 2021javascript, Node JSadmin

demo download

Create REST API with Typescript

mkdir Und-TSC-sec15
cd Und-TSC-sec15

Create Node Project
npm init
You’ll then have a package.json file.

1

tsc --init

You’ll then have a tsconfig.json file.

In tsconfig.json:

{

"compilerOptions": {

/* Visit https://aka.ms/tsconfig.json to read more about this file */

/* Basic Options */

// "incremental": true, /* Enable incremental compilation */

"target": "es2018", /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */

"module": "commonjs", /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */

"moduleResolution": "node",

"lib": [

"dom",

"es6",

"dom.iterable",

"scripthost"

], /* Specify library files to be included in the compilation. */

"sourceMap": true, /* Generates corresponding '.map' file. */

// "outFile": "./", /* Concatenate and emit output to single file. */

"outDir": "./dist", /* Redirect output structure to the directory. */

"rootDir": "./src", /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */

// "composite": true, /* Enable project compilation */

// "tsBuildInfoFile": "./", /* Specify file to store incremental compilation information */

"removeComments": true, /* Do not emit comments to output. */

// "noEmit": true, /* Do not emit outputs. */

// "importHelpers": true, /* Import emit helpers from 'tslib'. */

// "downlevelIteration": true, /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */

// "isolatedModules": true, /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */

/* Strict Type-Checking Options */

"strict": true, /* Enable all strict type-checking options. */

"noImplicitReturns": true, /* Report error when not all code paths in function return a value. */

// "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */

// "noUncheckedIndexedAccess": true, /* Include 'undefined' in index signature results

"typeRoots": [

"node_modules/@types"

], /* List of folders to include type definitions from. */

// "types": [], /* Type declaration files to be included in compilation. */

// "allowSyntheticDefaultImports": true, /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */

"esModuleInterop": true, /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */

}

Now let’s install the needed modules:

standard web server independencies:
npm install –save express body-parser

development independencies:
npm install –save-dev nodemon

create src folder:
mkdir src
cd src
touch app.ts

import express from 'express';

import { json } from 'body-parser';

const app = express();

app.use(json());

app.get('/', (req, res)=> {

console.log('entered root endpoint');

res.status(400).send('Welcome to Guang Dong!');

});

// error handling middleware function

app.use((err: Error, req: express.Request, res: express.Response, next: express.NextFunction) => {

res.status(500).json({message: err.message});

});

app.listen(3000);

When you are done, type tsc to compile the typescript into javascript.

Then you can debug it. Put a breakpoint there and make sure you’re on the index file. In our file, we’re on app.ts.

Once you’re on that file, go to Run > Start Debugging. You’ll see the bottom status bar turn orange. This means the server is running.

Click on View > Terminal, and you’ll see the terminal pop up. Then click on debug console. You’ll be able to see the console log from the node js app appear.

Creating Routes

cd src/routes
touch todos.ts

We extract Router from express. We can then register routes to hit functionality.
We set up the router to receive POST, GET, PATCH, and DELETE on ‘/’.
Each HTTP request will get mapped to certain functionalities that we declare in controllers/todos file.

routes/todos.ts

import { Router } from 'express';

import { createTodo, getTodos, updateTodo, deleteTodo} from '../controllers/todos';

const router = Router();

router.post('/', createTodo);

router.get('/', getTodos);

router.patch('/:id', updateTodo);

router.delete('/:id', deleteTodo);

export default router;

Finally, we need to connect our router to our server for endpoint /todos.

app.ts

import express from 'express';

import todoRoutes from './routes/todos';

const app = express();

app.use('/todos', todoRoutes); // localhost:3000/todos will hit todoRoutes

// depending on what HTTP verb it is, it will hit the functionalities mapped to that verb.

// error handling middleware function

app.use((err: Error, req: express.Request, res: express.Response, next: express.NextFunction) => {

res.status(500).json({message: err.message});

});

Add additional routes

First, we create a class Todos so we have a structure to work with. We export a class Todo so other modules can import it, and then new it to create an instance of Todo.

export class Todo {

constructor(public id: string, public text: string) {

console.log('Constructingn a Todo instance...');

}

Then import the class so that we get a simple data structure going.

We create functionality by implementing a function createTodo.
Note that we use RequestHandler interface, which contracts us to use
req, res, and next parameters.

controllers/todo.ts

import { RequestHandler } from 'express';

import { Todo } from '../models/todo';

// TODOS is the name of an array of type Todo

const TODOS: Todo [] = [];

export const createTodo: RequestHandler = (req, res, next) => {

console.log('entered createTodo');

const text = (req.body as {text:string}).text;

console.log('text', text);

const newTodo = new Todo(Math.random().toString(), text);

TODOS.push(newTodo);

res.status(201).json({

message: 'Created the todo',

createdTodo: newTodo

})

};

Since it takes care of a POST request, we use parse the body property in the request
object to get the body data. The body data’s key is text.

In order do that we need to import the body-parser package in app.ts, and then extract json.
This is so that we parse the body using json.

app.ts

import { json } from 'body-parser';

...

app.use(json());

Open up your postman and query it like so:

class – typescript to js

March 19, 2021javascriptadmin

ref – https://www.geeksforgeeks.org/typescript-class/

typescript

// typescript code

class Student {

studCode: number;

studName: string;

constructor(code: number, name: string) {

this.studName = name;

this.studCode = code;

}

getGrade() : string {

return "A+" ;

}

gets converted to js:

var Student = /** @class */ (function () {

function Student(code, name) {

this.studName = name;

this.studCode = code;

}

Student.prototype.getGrade = function () {

return "A+";

};

return Student;

}());

What does ‘this’ reference inside a function in an IIFE?

We have functions in IIFE, and we see that it uses this. But what does this reference?
As you can see from the example below, the ‘this’ keyword refers to the IIFE object.

var test4 = (function() {

var name = 'ricky';

function sayBye() {return 'bye bye';}

function sayHello() {console.dir(this); return 'hallo!!!' + name;}

return {

hello: sayHello,

bye: sayBye,

}

}());

> test4.bye()

“bye bye”

> test4.hello()

hello reference sayHello function. sayHello logs the ‘this’ keyword of the IIFE.
It will display the IIFE object.

Object
bye: ƒ sayBye()
hello: ƒ sayHello()
__proto__: Object
“hallo!!!ricky”

However, notice that we return a literal object. We can’t use new on the literal object because it’s not a function. So we must change this a bit in order to accomodate ‘new’.

var Student = /** @class */ (function () {

function Student(code, name) {

this.studName = name;

this.studCode = code;

}

Student.prototype.getGrade = function () {

return "A+";

};

return Student;

}());

So in our IIFE Student, we have a function constructor Student. That way when we go new Student, it would be valid because we can instantiate a function instructor.

var Student = /** @class */ (function () {

// notice function constructor!

function Student(code, name) {

this.studName = name;

this.studCode = code;

}

Student.prototype.getGrade = function () {

return "A+";

};

return Student; // return the func constructor so we can use new

}());

var a = new Student(123, 'haha');

console.log(a.getGrade()); // A+

Accessing Attributes and Functions

A class’s attributes and functions can be accessed by the object. With the help of ‘ . ’ dot notation or bracket notation([”]) we access the data members of a class.

// typescript code

class Car {

//field

engine:string;

//constructor

constructor(engine:string) {

this.engine = engine

}

//function

display():void {

console.log("Function displays Engine is : "+this.engine)

}

//create an object

var o1 = new Car("geeks")

//access the field

console.log("Reading attribute value Engine as : "+o1.engine)

//access the function

o1.disp()

// JS code

let Car = (function() {

// create function constructor so we can call new on it

function Car(newEngine) {

this.engine = newEngine;

}

// functions get attached to prototype object

Car.prototype.display = function() {

console.log("Function displays Engine is : "+ this.engine)

}

return Car;

}());

var o1 = new Car("geeks");

//access the field

console.log("Reading attribute value Engine as : " + o1.engine);

//access the function

o1.disp();

child processes in Node JS 2

March 15, 2021Node JSadmin

getCount.js

const slowFunction = (name) => {

let counter = 0;

console.log(`starting ${name}`)

while (counter < 1000000000 * 10) {

console.log(`counter ${counter}`);

counter++;

}

console.log(`finish ${name}`);

return counter;

}

process.on('message', (message) => {

const arr = message.split(' ');

if (arr[0] == 'START') {

slowFunction(arr[1]);

process.send(`FINISH ${arr[1]}`);

}

});

index.js

var express = require("express");

var app = express();

const { addLongTask, pauseQueue, resumeQueue } = require('./tasker.js');

app.get('/example',function(req,res){

console.log(req.query);

console.log(req.query.firstname);

res.send("Query String printed to console");

});

app.get('/task',function(req,res) {

addLongTask((pid) => {

res.setHeader('Content-Type', 'application/json');

res.writeHead(200);

res.end(`you've added process with id: ${pid}`);

}, (pid) => {

console.log(`running pid is ${pid}`);

});

app.get('/resume',function(req,res) {

console.log('Going to resume process');

resumeQueue();

});

app.get('/pause',function(req,res) {

console.log('Going to pause executing process');

pauseQueue();

// pause all process in the queue

// search out the process with the query ID.

// kill it

// resume queue

// if just kill...then we kill the current running process

// if given a pid, then we search it out.

// 1) is the current running process THAT id?

// 2) then look through the queue.

if (child) {

child.kill("SIGKILL");

console.log('kill the child process!!!!!!');

res.setHeader('Content-Type', 'application/json');

res.writeHead(200);

res.end(`${new Date().toISOString()} {"message":"process killed"}`);

}

});

app.get('/hello',function(req,res){

console.log('Returning /hello results');

res.setHeader('Content-Type', 'application/json');

res.writeHead(200);

res.end(`${new Date().toISOString()} {"message":"hello"}`);

});

app.listen(8080);

tasker.js

const { fork } = require('child_process');

const Queue = require('./queue.js');

let running = false;

let currentExecuting;

execute = async (obj) => {

const { pid, process } = obj;

process.send('START '+pid);

return new Promise((resolve, reject) => {

process.on('message', (message) => {

const [status, pid] = message.split(' ');

console.log(`${status} on process ${pid}`);

if (Queue.count() == 0 && running) {

running = false;

}

resolve({ status, pid });

});

}

exports.pauseQueue = async() => {

// All we have to do is PAUSE the executing process, and the whole queue will stand still.

const { pid, process } = currentExecuting;

console.log(`Pausing process ${pid}`);

process.kill('SIGSTOP');

}

exports.resumeQueue = async() => {

// first pause the executing process

const { pid, process } = currentExecuting;

console.log(`Resuming process ${pid}`);

process.kill('SIGCONT');

// then pause all the processes in the queue

}

exports.kill = async(pidToKill) => {

// first we pause the queue

this.pauseQueue();

// 1) is the executing process the pid to kill?

const { pid, process } = currentExecuting;

if (pidToKill == pid) {

// kill the current executing process!

process.kill("SIGKILL");

console.log(`killed the process ${$pid}`);

}

// 2) then search through the queue to kill the pid

Queue.find(item => {

const { pid, process} = item;

if (pid === pidToKill) {

process.kill("SIGKILL");

return true;

}

return false;

});

// then we resume

this.resumeQueue();

}

exports.addLongTask = async (addedCB, runningCB) => {

const child = fork(__dirname + '/getCount');

console.log(`enqueued child process ${child.pid}`);

Queue.enqueue({

pid: child.pid,

process: child

});

addedCB(child.pid);

// if its running, just add it to the queue to be auto processed

if (running) {

console.log(`Sorry process ${child.pid}! There are processes running, please wait your turn...`);

return;

}

// if its not running and the queue is empty, then we set it off

if (!running && !Queue.isEmpty()) {

console.log(`Nothing is running and there are ${Queue.count()} tasks on the queue`);

running = true;

do {

const obj = Queue.dequeue();

const { pid } = obj;

currentExecuting = obj;

runningCB(pid);

await execute(obj);

} while (Queue.count() > 0);

}

// always return the pid

return child.pid;

}

queue.js

let _queue = [];

exports.isEmpty = () => {

return (_queue.length == 0);

}

exports.enqueue = (item) => {

_queue.push(item);

}

exports.dequeue = () => {

return _queue.shift();

}

exports.count = () => {

return _queue.length;

}

exports.print = () => {

if (!isEmpty()) {

for (let i = 0; i < _queue.length; i++) {

_queue[i].toString();

}

child process in Node JS

March 12, 2021Node JSadmin

ref – https://www.digitalocean.com/community/tutorials/how-to-launch-child-processes-in-node-js

Creating a Child Process with fork()

index.js

const http = require('http');

const host = 'localhost';

const port = 8000;

// this function will take some time to run

const slowFunction = () => {

let counter = 0;

while (counter < 5000000000) {

counter++;

}

return counter;

}

const requestListener = function (req, res) {

if (req.url === '/total') {

let slowResult = slowFunction();

let message = `{"totalCount":${slowResult}}`;

console.log('Returning /total results');

res.setHeader('Content-Type', 'application/json');

res.writeHead(200);

res.end(message);

} else if (req.url === '/hello') {

console.log('Returning /hello results');

res.setHeader('Content-Type', 'application/json');

res.writeHead(200);

res.end(`{"message":"hello"}`);

}

};

const server = http.createServer(requestListener);

server.listen(port, host, () => {

console.log(`Server is running on http://${host}:${port}`);

});

Fork is a variation of spawn. To create a process that’s also a Node Process.

Main benefit of fork over (exec, spawn) is that fork enables communication between the parent and child process.

CPU intensive tasks (iterating over large loops, parsing large JSON) stop other JS code from running. If a web server is blocked, it cannot process any new incoming requests until the blocking code has completed its execution.

1) Now run the server
2) run /hello (1st time)
3) run /total
4) run /hello (2nd time)

So we’ll only see the result from the first /hello. The slow function will block other code, and that’s why we won’t see the 2nd /hello.

The blocking code is slowFunction.

So how do we solve this?

Move blocking code to own module:

getCount.js

const slowFunction = () => {

let counter = 0;

while (counter < 50000000000) {

console.log(`counter - ${counter}`);

counter++;

}

return counter;

}

Since it will be run with fork, we can add code to communicate with the parent process when slowFunction has completed processing. Let’s send a message to the parent process with JSON message.

process.on('message', (message) => {

if (message == 'START') { // server will do: child.send('START'), so we must receive

console.log('Child process received START message');

let slowResult = slowFunction(); // upon receiving START, we run our long task

let message = `${new Date().toISOString()} {"totalCount":${slowResult}}`;

process.send(message); // send data back to the parent process

}

});

– Why look for message ‘START’? Our server code will send the START event when someone access the ‘/total’ endpoint.
– Upon receiving that event, we run slowFunction().
– we use process.send() to send a message to the parent process.

index.js

const http = require('http');

const { fork } = require('child_process');

const host = 'localhost';

const port = 8000;

let child;

const requestListener = function (req, res) {

if (req.url === '/total') {

console.log(` ${new Date().toISOString()} - Start slow job`);

child = fork(__dirname + '/getCount');

console.log('child process id: ' + child.pid);

child.on('message', (message) => {

console.log('Returning /total results');

res.setHeader('Content-Type', 'application/json');

res.writeHead(200);

res.end(message);

});

child.send('START');

} else if (req.url === '/hello') {

console.log('Returning /hello results');

res.setHeader('Content-Type', 'application/json');

res.writeHead(200);

res.end(`${new Date().toISOString()} {"message":"hello"}`);

} else if (req.url === '/kill') {

if (child) {

child.kill("SIGKILL");

console.log('kill the child process!!!!!!');

res.setHeader('Content-Type', 'application/json');

res.writeHead(200);

res.end(`${new Date().toISOString()} {"message":"process killed"}`);

}

const server = http.createServer(requestListener);

server.listen(port, host, () => {

console.log(`Server is running on http://${host}:${port}`);

});

getCount.js

const slowFunction = () => {

let counter = 0;

while (counter < 50000000000) {

console.log(`counter - ${counter}`);

counter++;

}

return counter;

}

process.on('message', (message) => {

if (message == 'START') {

console.log('Child process received START message');

let slowResult = slowFunction();

let message = `${new Date().toISOString()} {"totalCount":${slowResult}}`;

process.send(message);

}

});

process.on('beforeExit', (code) => {

console.log('Process beforeExit event with code: ', code);

});

process.on('exit', (code) => {

console.log('Process exit event with code: ', code);

});

Run the app: node index.js

Open a 2nd terminal and type: curl http://localhost:8000/total
This will start up a long running task at say 7:41:18.

Open a 3rd terminal and type: curl http://localhost:8000/hello

Hi it a bunch of times. As you can see, it is running concurrently and not blocking the main JS code. This is because its a child process that’s running it concurrently. From the time stamp, you will also see that it’s happening after 7:41:18.

Then when the long task is done, it stops at 7:42:20. This proves that the /hello logs before 7:42:20 were all done concurrently with the task at /total.

Worker Thread with Node JS

March 4, 2021Node JSadmin

mkdir spawnEx
then ls into that directory

set it up all default
npm init

create an index.js file
touch index.js

Open it up with VCode
Code . index.js

copy and paste the code like so:
index.js

const http = require('http');

const hostname = '127.0.0.1';

const port = 3000;

const server = http.createServer((req, res) => {

res.statusCode = 200;

res.setHeader('Content-Type', 'text/plain');

res.end('Hello World');

});

server.listen(port, hostname, () => {

console.log(`Server running at http://${hostname}:${port}/`);

});

Then we create the run file. use worker_threads to extract Worker object. We create a new worker whenever we call runService().

run.js

const { Worker } = require('worker_threads')

function runService(name) {

return new Promise((resolve, reject) => {

const worker = new Worker('./worker.js', { workerData: name });

worker.on('message', data => {

console.log('------->', data);

resolve(data);

});

worker.on('error', reject);

worker.on('exit', (code) => {

if (code !== 0)

reject(new Error(`Worker stopped with exit code ${code}`));

})

}

runService("A").catch(err => console.error(err))

runService("B").catch(err => console.error(err))

runService("C").catch(err => console.error(err))

Create a worker class.
touch worker.js

worker.js

const { workerData, parentPort } = require('worker_threads');

const fs = require('fs');

for (let i = 0; i < 1000; i++) {

fs.appendFile('test.txt', `\n ${workerData} ${Date.now()}`, function (err) {

parentPort.postMessage({ workerData: `postMessage: ${workerData} ${Date.now()}` });

if (err) console.log('err', err);

});

}

test.txt

I will show the time at milliseconds of when the worker has written to the text.txt file. As you scroll down using the right hand scroll bar, you’ll notice this millisecond increase. This is the increase of time, and you’ll see exactly which worker was executing at that time.

When you should use Node JS

March 4, 2021Node JSadmin

ref – https://livecodestream.dev/post/when-you-should-and-should-not-use-nodejs-for-your-project/

A multi-threaded program has a pool of threads that run concurrently to accept requests. The number of threads used by the program is limited by the system’s RAM or other parameters. So, the number of requests it can process at a given time is limited to this number of threads.

Whereas the single-threaded Node.js program can process any number of requests at a given time that are in the event queue to be executed. Node’s event loop uses a single-threaded implementation when handling events. Each event is handled one after another in the order they arrive by a single processor thread. The requests received to a Node web server are served in the order they were received.

However, there is a downside to Node.js being single-threaded. The single-threaded implementation makes Node a bad choice for CPU-intensive programs. When a time-consuming task is running in the program it blocks the event loop from moving forward for a longer period. Unlike in a multi-threaded program, where one thread can be doing the CPU-intensive task and others can handle arriving requests, a Node.js program has to wait until the computation completes to handle incoming requests.

Node.js introduced a workaround for this problem in version 10.5.0: worker threads. You can read up more on this topic to understand how to use worker threads to solve this problem for CPU-intensive programs.

You may now have a question? How can a single thread handle more events at a given time than a thread pool if events are handled one after another and not concurrently? This is where Node’s asynchronous model steps in. Even though the Node’s event loop implementation is single-threaded, it achieves a concurrent-like behavior with the use of callbacks.

Assume you want to connect to a separate API from your Node server to retrieve some data.

You send a request to this particular API from the server. You also pass a callback function with the instruction on what to do when the response from the API is received.

After executing the task that makes the request to the API, the Node program doesn’t wait for the response from the that API. Instead, after sending the request, it continues to the next step of the program. When the response from the API arrives the callback function starts running, and therefore handles the received data. In this manner, the callback function runs concurrently to the main program thread.

In contrast, in a synchronous multi-threaded program, the thread sending making the API call waits for the response to arrive to continue to the next step. This does not stall the multi-threaded program because, even though this one thread is waiting, other threads in the thread pool are ready to accept receiving requests.

The asynchronous feature is what makes the single-thread of the Node.js program quite efficient. It makes the program fast and scalable without using as many resources as a multi-threaded application.

Naturally, this makes Node a good fit for data-intensive and I/O intensive programs. Data-intensive programs are focus on retrieving and storing data, while I/O-intensive programs focus on interacting with external resources.

When to Use Node.js?

Now back to our main question. When should you use Node.js for your projects? Considering the main features of Node.js and its strengths, we can say

– data-driven
– I/O-driven
– event-driven
– non-blocking

applications benefit the best from a Node.js implementation.

Especially, web backends that follow microservices architecture, which is now growing in popularity, are well suited for a Node implementation. With the microservices architecture, sending requests from one microservice to another becomes inevitable. With Node’s asynchronous programming, waiting for responses from outside resources can be done without blocking the program thread.

Unlike a multi-threaded program, which can run out of threads to serve incoming requests because many threads are waiting for responses from external resources, this I/O-intensive architecture does not affect the performance of the Node application. However, web servers that implement computational-heavy or processes-heavy tasks are not a good fit for Node.js. The programming community is still apprehensive of using Node with a relational database given Node tools for relational databases are still not as developed as compared to other languages.

Heavy Computational Applications

If your application is likely to run tasks that involve heavy computing and number crunching, like running the Fibonacci algorithm, Node.js is not the best language to turn to. As discussed above, the heavy computation blocks the single-thread running in the application and halts the progress of the event loop until the computation is finished. And it delays serving the requests still in the queue, which may not take as much time.

If your application has a few heavy computational tasks, but in general benefits from Node’s characteristics, the best solution is to implement those heavy computational tasks as background processes in another appropriate language. Using microservices architecture and separating heavy computational tasks from Node implementation is the best solution.

process.nextTick() vs setImmediate()

March 4, 2021Uncategorizedadmin

ref – https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/

process.nextTick() vs setImmediate()
We have two calls that are similar as far as users are concerned, but their names are confusing.

process.nextTick() fires immediately on the same phase

setImmediate() fires on the following iteration or ‘tick’ of the event loop

In essence, the names should be swapped. process.nextTick() fires more immediately than setImmediate(), but this is an artifact of the past which is unlikely to change. Making this switch would break a large percentage of the packages on npm. Every day more new modules are being added, which means every day we wait, more potential breakages occur. While they are confusing, the names themselves won’t change.

We recommend developers use setImmediate() in all cases because it’s easier to reason about.

Unpacking fields from objects passed as a function parameter

February 27, 2021Uncategorizedadmin

ref – https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment

const user = {

id: 42,

displayName: 'jdoe',

fullName: {

firstName: 'John',

lastName: 'Doe'

}

};

function userId({id}) {

return id;

}

function whois({displayName, fullName: {firstName: name}}) {

return `${displayName} is ${name}`;

}

console.log(userId(user)); // 42

console.log(whois(user)); // "jdoe is John"

mongo db commands

February 23, 2021Uncategorizedadmin

ref – https://www.tutorialspoint.com/mongodb/mongodb_create_database.htm

MongoDB’s

use some DB name is used to create database. The command will create a new database if it doesn’t exist, otherwise it will return the existing database.

1 2	>use portfolio switched to db portfolio

However, you must have at least 1 document in your DB before it shows up in the list. So we create one collection and insert 1 document in order for the DB to exist.

1	db.transfers.insert({"money", "$1000"})

WriteResult({ “nInserted” : 1 })

show dbs

and you’ll see database portfolio listed.

Kafka Node

February 23, 2021Uncategorizedadmin

https://www.npmjs.com/package/kafka-node
kafka-node-hello-world

We first require kafkajs module and extract the class. We then create a topic and group ID.
It is simply to identify the group that will be consuming, and the name of a topic that we’ll be producing.

const { Kafka } = require('kafkajs')

const topicName = "test-topic22"

const GroupID = "test-group22"

Then we instantiate it with a unique client id. For brokers let’s use localhost:9092 because that is what we’re using in our Kafka settings file.

const kafka = new Kafka({

clientId: 'my8app',

brokers: ['localhost:9092', 'localhost:9092']

})

get a producer

1	const producer = kafka.producer()

get a consumer

1	const consumer = kafka.consumer({ groupId: GroupID })

Consumers Subscribe

server.route({

method: 'GET',

path: '/consumer-subscribe',

handler: async (request, h) => {

console.log("consumer connect")

await consumer.connect()

console.log("consumer subscribe")

await consumer.subscribe({ topic: topicName, fromBeginning: true })

return true

}

});

Consumer Run

server.route({

method: 'GET',

path: '/consumer-run',

handler: async (request, h) => {

console.log("consumer run")

await consumer.run({

eachMessage: async ({ topic, partition, message }) => {

console.log({

partition,

offset: message.offset,

value: message.value.toString(),

})

return true

}

});

Consumer Unsubscribe

server.route({

method: 'GET',

path: '/consumer-unsubscribe',

handler: async (request, h) => {

console.log("consumer disconnect")

await consumer.disconnect({ topic: topicName })

return true

}

});

Producer Start

server.route({

method: 'GET',

path: '/producer-start',

handler: async (request, h) => {

console.log('producer connected')

await producer.connect();

return true;

}

});

Producer Send Data

server.route({

method: 'GET',

path: '/producer-send',

handler: async (request, h) => {

console.log('producer send')

return await producer.send({

topic: topicName,

messages: [

{ value: '8 - Herro KafkaJS user!' },

})

}

});

Producer Stop

server.route({

method: 'GET',

path: '/producer-stop',

handler: async (request, h) => {

console.log('producer stop')

await producer.disconnect()

return true

}

});