---
title: 'Patterns and Anti-patterns in Node.js'
date: '2022-04-03'
slug: 'patterns-and-anti-patterns-in-nodejs'
thumbnail: '/thumbnails/node.png'
tag: 'nodejs'
canonicalUrl: 'https://blog.appsignal.com/2022/02/23/patterns-and-anti-patterns-in-nodejs.html/'
---

![cover_image](https://blog.appsignal.com/_next/image?url=%2Fimages%2Fblog%2F2022-02%2Fpatterns.png&w=2048&q=50)

> Originally posted at [AppSignal Blog](https://blog.appsignal.com/2022/02/23/patterns-and-anti-patterns-in-nodejs.html)

Node.js is a back-end JavaScript runtime built on Chrome's V8 engine that's asynchronous and event-driven by nature. It's relatively simple to create a REST API with Node.js and use frameworks like [Express.js](https://expressjs.com/). With this simplicity comes a lot of flexibility. However, you can get side-tracked on what patterns to follow when building scalable network-driven applications.

This article focuses on some of the patterns and practices to follow when building Node.js applications. You will learn about coding style, error handling, loggers, and testing.

Let's dive in!

## Node.js Coding Style and Best Practices

### const and let Keywords to Declare Variables

There are different ways to declare variables in JavaScript: the old school `var` and the more recent `let` and `const`.

`var` declares a function-scoped (when declared within a function) or globally-scoped variable (when declared outside a function).

`let` and `const` declare block-scoped variables.

`let` allows you to create variables whose value can change. When pointing to an object, it can be assigned to another object.

```js
let myInt = 3;
myInt = 6;
console.log(myInt); // 6
let myArray = [0, 1, 2, 3];
console.log(myArray); // [ 0, 1, 2, 3 ]
let myOtherArray = ['one', 'two', 'three'];
myArray = myOtherArray;
console.log(myArray); // [ 'one', 'two', 'three' ]
```

The `const` keyword can be a little confusing. It doesn't necessarily define a constant value, it defines a constant reference to a value. It creates a read-only reference to a value, but this doesn't mean the value it holds is immutable, just that it cannot be reassigned.

```js
const myInt = 3;
myInt = 6; // TypeError: Assignment to constant variable.
const myArray = [0, 1, 2, 3];
console.log(myArray); // [ 0, 1, 2, 3 ]
myArray[0] = 'eleven';
console.log(myArray); // [ 'eleven', 1, 2, 3 ]

let myOtherArray = ['one', 'two', 'three'];
myArray = myOtherArray; // TypeError: Assignment to constant variable
```

As shown above, if it holds a primitive, you cannot assign it another value. When it holds an object/array, you can alter the value of that object (its properties/elements), but you cannot assign it another object.

With the definitions down, let's look at why you should consider using `let` and `const` over `var`.

1. Duplicate variable declarations using `var` will not trigger an error.

With `var` you can declare a variable in the same scope as a similarly named variable. Because of this, you can unknowingly overwrite another variable's value.

```js
function thisFunction() {
  var x = 1;

  // In another part of the code, declare another variable x
  var x = 2;

  console.log(x); // 2
}

thisFunction();
```

Both `const` and `let` cannot be re-declared, so you cannot accidentally create a duplicate variable in the same scope.

```js
function thisFunction() {
  let x = 1;

  // In another part of the code, declare another variable x
  let x = 2;

  console.log(x);
}

thisFunction();
```

If you try to run the above code, you will get the following error:

```shell
SyntaxError: Identifier 'x' has already been declared
```

2. `var` allows you to read a variable that has not been declared.

When you try to access a `var` before it is declared, it will return `undefined`. This might cause bugs when you try to use a variable in your code that has not been declared. Tracking down the bug might be difficult since the code might cause no errors that will cause it to crash, but it might cause unexpected results when you use the `undefined`.

The following code will run just fine.

```js
console.log(bar); // undefined
var bar = 1;
```

With `let` and `const`, you won't be able to use a variable that has not been declared.

```js
console.log(foo); // ReferenceError
let foo = 2;
```

Trying to run the above will give the below error:

```shell
ReferenceError: Cannot access 'foo' before initialization
```

3. Because they are block-scoped, `let` and `const` make for more readable and straightforward code, that is less error-prone.
   With block-scoped variables, it is easier to read through code and track down the scope in which a variable operates. You just have to look at the inner-most block in which it has been declared to know its scope.

Look at the following code.

```js
let x = 5;

function thisFunction() {
  let x = 1;

  if (true) {
    let x = 2;
  }

  console.log(x); // 1
}

thisFunction();

console.log(x); // 5
```

Since `let x = 2;` is declared inside the block of the `if` statement, you know it only operates inside that block. As you can see, it doesn't affect similarly named variables outside the block. You can declare variables inside blocks without worrying that you might be re-declaring them.

When using `var`, it's not so straightforward.

```js
var x = 5;

function thisFunction() {
  var x = 1;

  if (true) {
    var x = 2;
  }

  console.log(x); // 2
}

thisFunction();

console.log(x); // 5
```

With `var`, you have to be more careful with variables.

In the above, we declare a variable `var x = 2;` inside the `if` statement. The scope of `x` is the entire function `thisFunction()`. Since there is a similarly named variable in the function, we re-declared `x`, and when we later use the function's `x`, it has the value `2`. So you need to be aware of the variables in scope, so as not to accidentally overwrite them.

### Proper Naming Conventions

It's important to follow a naming convention when naming constants, variables, classes, and functions in an app. This helps you visually differentiate between local variables, global variables, functions, classes, etc., and maintain a consistent style throughout your codebase.

For naming local variables and functions, use lowerCamelCase.

```js
const myFunction() {
  let someVariable;
}
```

Even if you define variables using the `const` keyword within the scope of a function, lowerCamelCase is preferred.

```js
const myFunction() {
  const someVariable = "That holds a string value";
}
```

Variables can also be defined by a `const` keyword in a specific use case. If you intend to declare a variable whose value (or nested values, in the case of declaring an object) is not going to change throughout the lifecycle of a codebase, use UPPER_SNAKE_CASE with the `const` keyword.

```js
const ANOTHER_VAR = 3;
```

Define classes in Node.js applications with UpperCamelCase:

```js
class MyClass() {
  // ...
}
```

Following these naming conventions will help you write more readable code. Naming your functions is vital, especially when you are about to profile a Node.js project. Profiling makes it simpler to understand what function to look for when checking a memory snapshot. However, if you use anonymous functions, profiling can make it challenging to debug production issues.

### ESLint and Style Guides

Instead of overthinking a project's coding style, use a linting tool like [ESLint](https://eslint.org/). Over the years, it has become the JavaScript ecosystem's standard for fixing code styles automatically. ESLint checks for possible code errors, fixes code styles such as spacing issues, avoids anti-patterns and small errors, and keeps project code uniform. Using ESLint with a tool like [Prettier](https://prettier.io/) can help you fix formatting issues as well.

By default, ESLint contains standard rules for vanilla JavaScript. It has a plugin system specific to the framework. For Node.js, you can use plugins like eslint-plugin-node and eslint-plugin-node-security.

It is much easier to understand a large project when its code is written in a consistent style. This is where style guides come in handy. Using a style guide enhances a team's productivity and avoids arguments about the best style guide for Node.js projects. In addition, you can opt-in to already existing style guides created at companies like [Google](https://github.com/google/eslint-config-google) and [Airbnb](https://github.com/airbnb/javascript) that have been tested with time.

## Error Handling in Node.js

You can handle errors using `async/await` syntax and the built-in error object in Node.js. Let's take a look at both.

### async/await Syntax to Catch Errors

When Node.js first came out, handling asynchronous code meant using callbacks. From my experience, it doesn't take too long for nested callbacks to get out of hand. This is known as 'callback hell', and here is a typical example:

```js
function getData(err, function(err, res) {
  if(err !== null) {
    function(valueA, function(err, res) {
      if(err !== null) {
        function(valueB, function(err, res) {
          // it continues
        }
      }
    })
  }
})
```

The example above is quite ergonomic. In a real scenario, there will be many more lines of code in each function's scope. This is considered an anti-pattern: handling the callback style of errors gets more awkward and only gets more un-maintainable with more nested functions.

You can avoid nested callbacks or callback hell by using ES6 `async/await` syntax (completely supported by Node.js version 8 and onwards). `async/await` is a way to deal with asynchronous code. It provides a much more compact way of writing code and familiar code syntax. To handle errors, you can use `try/catch` blocks along with `async/await` syntax.

If we use `async/await`, we can rewrite the previous example like this:

```js
async function getData(err, res) {
  try {
    let resA = await functionA(res);
    let resB = await functionB(resA);

    return resB;
  } catch (err) {
    logger.error(err);
  }
}
```

### Built-in Node.js Error Object

Errors are impossible to avoid. However, in many cases you'll want to handle errors such as rejected promises and thrown exceptions.

To avoid complications in error-handling, use the built-in error object in Node.js. It helps you maintain uniformity and prevent loss of information. You can also reap the advantages of finding information with StackTrace.

As an example, throw a string as shown below:

```js
if (!data) {
  throw 'There is no data';
}
```

This lacks any stack trace information and is an anti-pattern.

Instead, use the built-in Error object:

```js
if (!data) {
  throw new Error('There is no data');
}
```

## Loggers for Your Node.js Project

There's no denying it - we've all used `console` statements at times. They can be good for quickly debugging something or printing a standard output. But the console lacks proper configuration options for production-grade applications.

It is also crucial for a logger to be high-performant in identifying errors and possible issues. A slow logging library might harm your application's runtime performance.

A typical logger lets you use correct log levels such as fatal, warn, info, error, debug, and trace. These levels help to identify and distinguish between different critical events. A logger will also help provide contextual information in a JSON object, with timestamped log lines for you to determine when the log entry occurred. The logging format should be readable by human beings.

A good logging library provides features that make it easier to centralize and format logs. In the Node.js ecosystem, the following are some of the options available:

- [Winston](https://github.com/winstonjs/winston): A popular logging library that is easily configurable.
- [Bunyan](https://github.com/trentm/node-bunyan): Another popular logging library that outputs in JSON by default.
- [Log4js](https://github.com/log4js-node/log4js-node): A logger for the Express framework that supports colored console logging out of the box.
- [Pino](https://github.com/pinojs/pino): A logger that is focused on performance. It is considered to be faster than its alternatives.

An example of configuring Pino:

```js
const app = require('express')();
const pino = require('pino-http')();

app.use(pino);

app.get('/', function (req, res) {
  req.log.info('something');
  res.send('hello world');
});

app.listen(3000);
```

Pino also supports [various Web frameworks in the Node.js ecosystem](https://github.com/pinojs/pino/blob/HEAD/docs/web.md#express), such as Fastify, Express, Hapi, Koa, and Nest.

## Writing Tests in Node.js

If you work on a big application, you'll make continuous changes to the app's source code. By writing tests, you can avoid breaking existing features when pushing a new change. Failing tests will also help you determine where to make changes in specific sections of your code.

### Write API Tests

In a Node.js application, writing API tests is a good start. They provide more coverage than unit testing. You can use frameworks like [Supertest](https://github.com/visionmedia/supertest), [Jest](https://jestjs.io/), or any other library that provides a high-level abstraction for testing APIs.

Consider the example below. It is a simple Express app that serves one route:

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));

// Other middlewares...

app.get('/', (req, res, next) => {
  res.json({ hello: 'Hello World' });
});

module.exports = app;
```

Here's appropriate way to write this using Supertest:

```js
const request = require('supertest');
const app = require('./index');

describe('hello test', () => {
  it('/ should return a response', async () => {
    const res = await request(app).get('/');
    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({ hello: 'Hello World' });
  });
});
```

### Write Clear Test Names

A test name should be descriptive and self-explanatory for other people working on your team and include what is being tested, the scenario, and expected result.

### Inspect Outdated Packages

You can check for outdated packages with commands like `npm outdated` or use a package like `npm-check`. This will prevent build fails related to outdated packages.

### Inspect for Vulnerable Dependencies

A package can have vulnerabilities. Use community-based tools such as [npm audit](https://docs.npmjs.com/cli/audit) or commercial tools like [snyk](https://snyk.io/) to discover vulnerabilities. If you don't use these tools, your only alternative is to keep up with tech communities online.

## Wrap Up: Write Better Code for Your Node.js Apps

In this article, we covered practices and patterns to help you avoid anti-patterns and write better code for your Node.js applications.

We looked at some key principles around coding style, error handling, loggers, and testing. Some of the practices we discussed are more general - like checking for outdated packages or vulnerable dependencies. Others - such as using a performant logging library using ESLint and style guides - will help you maintain a consistent way of writing code, especially when working on large projects.

Happy coding!


Patterns and Anti-patterns in Node.js

---
title: 'How to install Node.js using NVM on macOS M1'
date: '2022-02-06'
slug: 'install-nodejs-using-nvm-on-macos-m1'
thumbnail: '/thumbnails/node.png'
tag: 'nodejs'
canonicalUrl: 'https://amanhimself.dev/blog/install-nodejs-using-nvm-on-macos-m1/'
---

> Updated on July 24, 2023

Node.js can be installed in different ways. I recently started working on an organization repository that requires using different Node.js versions. Using [Node Version Manager (NVM)](https://github.com/nvm-sh/nvm) it is possible to switch between different Node.js versions on the fly. It also allows testing code with older Node.js versions.

NVM is a shell script used for installing and managing Node.js on a Unix based system. It allows switching between different versions of Node.js via the command line quickly. It also works with any [POSIX](https://en.wikipedia.org/wiki/POSIX) shell such as `zsh`.

## Prerequisites

Make sure you have installed the following before proceeding:

- [Command line tools](https://amanhimself.dev/blog/setup-macbook-m1/#xcode)
- [Homebrew](https://amanhimself.dev/blog/setup-macbook-m1/#homebrew)
- [Git](https://amanhimself.dev/blog/setup-macbook-m1/#git)
- [zsh](https://amanhimself.dev/blog/setup-macbook-m1/#zsh-and-oh-my-zsh)

## Remove existing installed Node.js version

> This step is optional. If you haven't installed Node.js previously using Homebrew, skip this.

If you have an existing Node.js version installed, please remove it before installing NVM. For example, my machine already has a node version installed via Homebrew.

Open the terminal window and run:

```shell
brew uninstall --ignore-dependencies node
brew uninstall --force node
```

## Install NVM via Homebrew

Install NVM using Homebrew:

```shell
brew install nvm
```

After the above command runs, create a directory for NVM at the home working directory:

```shell
mkdir ~/.nvm
```

When using the `zsh` shell, add the following config inside `~/.zshrc`:

```shell
export NVM_DIR="$HOME/.nvm"
[ -s "/opt/homebrew/opt/nvm/nvm.sh" ] && \. "/opt/homebrew/opt/nvm/nvm.sh"  # This loads nvm
[ -s "/opt/homebrew/opt/nvm/etc/bash_completion.d/nvm" ] && \. "/opt/homebrew/opt/nvm/etc/bash_completion.d/nvm"  # This loads nvm bash_completion
```

Now, either restart the terminal app or execute `source ~/.zshrc` to re-load the latest config for the `zsh` shell from the file.

Run the command `nvm --version` to verify. For example, if the config has loaded, this command would display a version.

## Install Node.js via NVM

Node.js is available in two different versions:

- Long Term Support (LTS)
- Current with latest features

Although I used to love using the Current version with the latest features on my personal machine, I use the LTS version for work. At the time of writing this post, the current LTS version is `16`.

Running the command `nvm install node` would install the current version with the latest features.

To install the current LTS Node.js version, execute:

```shell
nvm install --lts
```

Then, verify the version by running:

```shell
node --version

# Output: v16.13.2
```

## Multiple Node.js versions

To install different versions of Node.js, you can run:

```shell
# nvm install Version-Number
nvm install 14
```

## Use a specific Node.js version

After installing multiple versions, use the command below to set a specific version as the default version and use it:

```shell
nvm use 16
```

## Uninstall a Node.js version

Before uninstalling a Node.js version, make sure it is not the active version or currently used version on the machine. Switch to a different version and then run the command:

```shell
nvm uninstall 14
```

## List all installed Node.js versions

To check for all the installed Node.js versions via nvm, run:

```shell
nvm ls
```

## Set the latest Node.js version as the default

To always set the latest Node.js version as the default in the shell, run:

```shell
nvm alias default node
```

## Update to the latest version

To update to the latest version `nvm` provides the following command:

```shell
nvm install --lts
```

After installing the latest version, to re-install any global packages installed with the previous version, run:

```shell
nvm reinstall-packages previous_version
```


How to install Node.js using NVM on macOS M1

---
title: 'How to use ES6 import syntax in Node.js'
date: '2021-04-07'
thumbnail: '/thumbnails/node.png'
slug: 'how-to-use-es6-import-syntax-in-node'
tag: 'nodejs'
canonicalUrl: 'https://amanhimself.dev/blog/how-to-use-es6-import-syntax-in-node/'
---

![cover_image](https://i.imgur.com/mztPVQI.png)

<blockquote>
Photo by <a href="https://unsplash.com/@weirick?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Jake Weirick</a> on <a href="https://unsplash.com/?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
</blockquote>

<br />

A module is a JavaScript file that exports one or more values. The exported value can be a variable, an object, or a function.

An ES6 import syntax allows importing modules exported from a different JavaScript file. It is a common pattern to use modules across React and React Native applications. The syntax is composed of the following ES module standard:

```js
import XXX from 'xxx';
```

An ES module is the ECMAScript standard of working with modules. Node.js uses the CommonJS standard to import modules. The syntax for this type of standard can be described as:

```js
const XXX = require('xxx');
```

Node js doesn’t support ES6 import directly. Try writing the `import` syntax in a JS file:

```js
// index.js

import { ApolloServer, gql } from 'apollo-server';
```

Run the Node.js server either by using `npm start` or `npm run dev` and you will encounter the following error:

![ss1](https://i.imgur.com/lbHW7pl.png)

The solution to this error is in the first line of the above error snippet and is now [a recommend way by Node.js](https://nodejs.org/api/esm.html#esm_enabling). Set the `"type": "module"` in `package.json` file.

```json
{
  "type": "module"
}
```

This solution works for the latest Node.js versions (which is `15.4.x` at the time of writing) and versions above `14.x.x`.

![ss2](https://i.imgur.com/Mm92hul.png)

## What about environments using Node version lower than 14

Another solution to this problem is to use [Babel](https://babeljs.io/). It's a JavaScript compiler and allows you to write JS using the latest syntax. Babel is not framework or platform opinionated. This means that it can be used in any project that is written in JavaScript and thus, in a Node.js project as well.

Start by installing the following dev dependencies from a terminal window:

```bash
npm i -D @babel/core @babel/preset-env @babel/node
```

Then create a file at the root of the Node.js project called `babel.config.json` and add the following:

```json
{
  "presets": ["@babel/preset-env"]
}
```

The package `@babel/node` is a CLI utility that compiles JS code in a Node.js project with Babel presets and plugins before running it. It means it will read and apply any configuration mention in `babel.config.json` before executing the Node project.

Replace the `node` with `babel-node` to execute the server in the `start` or `dev` scripts.

An example of running Node server using `npm run dev` script:

```json
{
  "scripts": {
    "dev": "nodemon --exec babel-node server.js"
  }
}
```


How to use ES6 import syntax in Node.js

---
title: 'Add Environment Variables in a Netlify Deployment'
date: '2020-09-01'
slug: 'add-environment-variables-in-netlify-deployment'
thumbnail: '/thumbnails/netlify.png'
tag: 'nodejs'
canonicalUrl: 'https://danblogs.vercel.app/blog/add-environment-variables-in-netlify-deployment/'
---

![cover_image](https://i.imgur.com/SX2uERE.png)

Recently I migrated my blog (the one you reading right now) from [Gatsby](https://www.gatsbyjs.com/) to [Next.js](https://nextjs.org/) for some specific reasons. The first reason, me being curious about how Next.js works and how is the developer experience. The second one, I want to have minimal effort and spend less time in managing a blog's UI and spend more time on writing posts. Lately, the vice versa has been the reality.

To not write every CSS element from scratch for responsive design, I am using [Chakra UI](https://blog.logrocket.com/how-to-create-forms-with-chakra-ui-in-react-apps/) for this blog which is a UI component library for React apps. It serves the purpose.

## The idea for the post

The idea of the post came from a problem of my own. Since I am a fan of minimal effort, this blog has been running from a [GitHub repository](https://github.com/MicoDan) deployed with [Vercel](https://vercel.com/).

There are many advantages to this bare infrastructure such as free HTTPS certificate, using a custom domain, and so on. This way, Netlify manages continuous deployment runs the build command from a Gatsby or a Next.js rendered site. It also triggers a deployment whenever there is a new commit pushed in the GitHub repository.

## The problem that leads me to use an environment variable

That said, let's get back to the main topic. After deploying the blog with 90+ posts, I ran into an issue that is known as "Allocation failed - JavaScript heap out of memory" in Node.js world.

The issue occurs when the deployment build runs out of memory. Node.js does not handle this by rolling back and moves forward with the build which eventually concludes in the build to fail.

Regardless of what stack or framework you use to deploy your site, if the deployment instance is using a node server, one day you might run into an issue as shown below.

![ss1](https://i.imgur.com/heymZ2D.png)

## The good "Old space" problem in V8

Diving further I got to learn a new thing even though I've been using Node.js since the starting of my own developer career. This issue occurs when the memory consumption of garbage collection in V8 reaches its max limit. If the limit is exceeded, V8 kills the process.

> More information on this issue can be found on [Stackoverflow here](https://stackoverflow.com/questions/48387040/nodejs-recommended-max-old-space-size/48392705). It also explains, when to increase the memory and when to avoid.

## Increasing the memory limit with Environment Variable

According to Chris McCraw's answer [here](https://community.netlify.com/t/fatal-error-call-and-retry-last-allocation-failed-javascript-heap-out-of-memory/1840/4), a Netlify build (if not using an Enterprise plan) should not exceed the limit of 3GB for reliability. In the same thread, there is a proper solution and that leads to the use of environment variables.

If you face this problem using the same approach with Netlify as I did, or for some other reason you want to use environment variables, here is how to get started. Step one is to go to your deployment on Netlify and click the option **Deploy Settings**.

![ss2](https://i.imgur.com/qjEP2pR.png)

This is where all the deployment-related settings are stored. On the next screen, observe a sidebar and under the tab **Build & deploy** there is a sub-tab called **Environment**. Click on that and then click on the button **Edit variables**. Now, you can add the key and value for each environment variable as shown below.

![ss3](https://i.imgur.com/5NKWri1.png)

## Further reading

Here is a list of all the links I came across when resolving this issue. Might be helpful:

- [The JavaScript heap out of memory thread](https://community.netlify.com/t/fatal-error-call-and-retry-last-allocation-failed-javascript-heap-out-of-memory/1840/4)
- [The Stackoverflow thread that explains shortcomings of V8 in managing memory](https://stackoverflow.com/questions/48387040/nodejs-recommended-max-old-space-size/48392705)
- [Features of Netlify + GitHub app](https://github.com/apps/netlify)


Add Environment Variables in a Netlify Deployment

---
title: 'How to Create a Chatbot with Dialogflow, NodeJS, and Webhooks'
date: '2019-07-19'
slug: 'build-chatbot-dialogflow-nodejs-webhooks'
thumbnail: '/thumbnails/node.png'
tag: 'nodejs'
canonicalUrl: 'https://crowdbotics.ghost.io/build-chatbot-dialogflow-nodejs-webhooks/'
---

![cover_image](https://i.imgur.com/cOAePoA.jpg)

> [Originally published at Crowdbotics](https://crowdbotics.ghost.io/build-chatbot-dialogflow-nodejs-webhooks/)

Chatbots are the hottest things in the modern digital world. Every day, organizations and individuals are powering their digital products such as websites or messenger apps to provide conversational experiences for their users. Each conversational experience depends on the implementation of the chatbot to either be a good or poor experience for the user. The modern day world is living in the technology wave of Artificial Intelligence, and chatbots are a massive part of it.

In this tutorial, you are going to be introduced to an easy to use tool for such uses cases known as [Dialogflow](https://dialogflow.com/). Formerly known as API.AI, it can be customized to provide information such as weather in your user's city or information about a movie they like to see. This customization, however, can only be applied using a third party API that is consistent in delivering results for the specific search term.

By providing a step by step on setting up and running the chatbot and how to use a third party API with Dialogflow. You are going to create a custom webhook using Nodejs, deploy it as a service, and then use it with your Dialogflow setups to develop agents and intents. _What are webhooks, you ask?_

A Webhook is a simple HTTP callback that gets triggered based on some event. These events are defined by the user, for example, publishing a comment to blog post, or publishing a new tweet on your Twitter app.

You are going to build a movie chatbot that provides information about a movie using [The Open Movie Database API](http://www.omdbapi.com). The webhooks will be used to fetch the details of a film.

**Table of Contents**

- Requirements
- Create a Node Server
- Fetching the Movie
- Deploy the Webhook on Heroku
- Setup Dialogflow
- Create Training Phrases
- Enable the Webhook
- Conclusion

## Requirements

To follow this tutorial, you need the following:

- Nodejs v8.x.x or higher installed along with npm/yarn as the package manager
- Github Account
- Crowdbotics App builder Platform account (preferably log in with your valid Github ID)
- Dialogflow account (_you can use your Google ID_)
- [OMDb API API Key](https://developers.themoviedb.org/3/getting-started/introduction): make sure when you register the account, you request for an API key. It is very to get one, register an account.
- Heroku or some similar service to deploy the webhook

## Create a Node Server

The following steps have to perform inside the project directory you have set up to create the Nodejs server. Once you are inside the server folder, make sure you run the following commands sequentially using a terminal window. The first command will initialize the server directory as a node server and generate a package.json file. The second command will let you install all the required dependencies.

```shell
# to initialize
npm init --yes

# to install dependencies
npm install -save express dotenv
```

Once all the dependencies are installed, let us bootstrap a small server and see if everything is working or not. Create a new file `index.js` and add the following snippet to it.

```js
const express = require('express');
// will use this later to send requests
const http = require('http');
// import env variables
require('dotenv').config();

const app = express();
const port = process.env.PORT || 3000;

app.use(express.json());
app.use(express.urlencoded({ extended: true }));

app.get('/', (req, res) => {
  res.status(200).send('Server is working.');
});

app.listen(port, () => {
  console.log(`🌏 Server is running at http://localhost:${port}`);
});
```

The above server is simple as it can be with only one `/` home route for now. This route is created now only to test whether the server being bootstrapped in this section is going to work or not. Sometimes small errors are time wasters, so it is better to check out. The module `dotenv` enable the file to read environment variables and their values from the file `.env`. Here is how the `.env` the file looks like.

```shell
API_KEY=XXXX
```

The Xs are going to be the value of the API key that you have got from registering an account at OMDB API. Replace the value of these Xs with that key. Now, go to the terminal window and execute the command `node index.js`. This will prompt with the message you have defined in the above snippet. Visit the URL `http://localhost:3000` from the browser window, and you will get the following result.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss3-1.png' />

## Fetching the Movie

In this section, you are going to create a route called `/getmovie`. It is going to be a post request. This request is going to search for the movie specified on the user's input. If that movie exists, it will return the user with the details of the movie such as the name itself, the year it was released, a summarised plot, and so on.

Open `index.js` file and the following after you have defined middleware functions.

```js
app.post('/getmovie', (req, res) => {
  const movieToSearch =
    req.body.queryResult &&
    req.body.queryResult.parameters &&
    req.body.queryResult.parameters.movie
      ? req.body.result.parameters.movie
      : '';

  const reqUrl = encodeURI(
    `http://www.omdbapi.com/?t=${movieToSearch}&apikey=${process.env.API_KEY}`
  );
  http.get(
    reqUrl,
    responseFromAPI => {
      let completeResponse = '';
      responseFromAPI.on('data', chunk => {
        completeResponse += chunk;
      });
      responseFromAPI.on('end', () => {
        const movie = JSON.parse(completeResponse);

        let dataToSend = movieToSearch;
        dataToSend = `${movie.Title} was released 
        in the year ${movie.Year}. It is directed 
        by ${movie.Director} and stars ${movie.Actors}.\n Here some glimpse of the plot: $
        {movie.Plot}.
                }`;

        return res.json({
          fulfillmentText: dataToSend,
          source: 'getmovie'
        });
      });
    },
    error => {
      return res.json({
        fulfillmentText: 'Could not get results at this time',
        source: 'getmovie'
      });
    }
  );
});
```

The `http` module is from Nodejs core. It is going to send the request which is the variable `reqUrl` and a callback function `responseFromAPI`. This function is going to trigger two events: `data` and `end`. The event `data` is going to return the information about the movie from API in chunks.

The `completeResponse` holds the data is parsed into JSON when the response from the API is ended. The customized response that is being returned in the above route's snippet should contain the field `fulfillmentText` and `error` response for cases that might now work at all.

On a side note, here is how an object for a specific movie data in JSON looks like from the OMDB API.

```json
{
  "Title": "Flashbacks of a Fool",
  "Year": "2008",
  "Rated": "R",
  "Released": "17 Oct 2008",
  "Runtime": "109 min",
  "Genre": "Drama",
  "Director": "Baillie Walsh",
  "Writer": "Baillie Walsh",
  "Actors": "Emile Robert, Scoutt Lowe, Daniel Craig, Julie Ordon",
  "Plot": "A fading Hollywood star looks back at
  the days of his youth as he returns home from his
  best friend's funeral.",
  "Language": "English",
  "Country": "UK",
  "Awards": "N/A",
  "Poster": "https://m.media-amazon.com/images/M/
  MV5BMTIzMDk0MDc3OV5BMl5BanBnXkFtZTcwODMwODY5MQ@@.
  _V1_SX300.jpg",
  "Ratings": [
    { "Source": "Internet Movie Database", "Value": "6.8/10" },
    { "Source": "Rotten Tomatoes", "Value": "38%" }
  ],
  "Metascore": "N/A",
  "imdbRating": "6.8",
  "imdbVotes": "11,348",
  "imdbID": "tt1037218",
  "Type": "movie",
  "DVD": "22 Sep 2008",
  "BoxOffice": "N/A",
  "Production": "Anchor Bay Entertainment",
  "Website": "http://www.thefilmfactory.co.uk/flashbacks/",
  "Response": "True"
}
```

From this considerable object, you are only using some amount of information described in the previous snippet. To test that the result is being fetched from the OMDB API, start the server by going to the terminal window. Execute command `node index.js`.

Open your favorite rest clients such as Postman or Insomnia. Enter the URL `http://localhost:3000/getmovie` and even though it is POST request, and you will have to enter the `parameters` as shown below. Let us test out if the API is returning the details of the movie name entered or not. In the below image, you can verify that the information related to the data is being replaced.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/SS4.png' />

## Deploy the Webhook on Heroku

Since the route `/getmovie` is working, it is time to deploy the webhook you successfully build in the previous step. [Login](https://id.heroku.com/login) to your Heroku account or if you do not have one, create an account. You can upload up to five web applications that can run for free to some number of hours (_called as dynos_).

Before you proceed with any of the steps below, in the `package.json` file, make sure the `start` script exists as specified below.

```json
"scripts": {
        "start": "node index.js",
        "test": "echo \"Error: no test specified\" && exit 1"
}
```

Once you log in, you will be welcomed by the screen known as Dashboard. Create on the button **New** on the top right corner and then create choose **Create new app**.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss5-1.png' />

Fill in the name of the application. Once you have entered the details, click the button **Create app**.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss6-1.png' />

Now, you will be welcomed by the following page that has instructions to deploy your current Node app. If you are using Github, go ahead and choose the **Connect to Github** deployment method. I am going to use [heroku-cli](https://devcenter.heroku.com/articles/heroku-cli).

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss7-1.png' />

To proceed with the following set of instructions, also as mentioned in the above screen under the section **Deploy using Heroku Git**. What this means is that the instance of your complete Node application is going to be deployed from the local development environment where the application is currently located. Once you have installed the Heroku CLI, enter the following command to proceed. Also, if you are using the Crowdbotics platform to generate the current demo app or have initialized the directory, you are working using the command `git init`, ignore the section **Clone the repository** in the above image.

```shell
# login
heroku login

# to deploy
$ git add .
$ git commit -am "deploy"
$ git push heroku master
```

The only thing to notice here is that you are not going to `git push` to the `origin` but `heroku`. Once the deployment is done, you will get a message like below in the terminal window.

```shell
remote:        https://getmoviehook.herokuapp.com/ deployed to Heroku
remote:
remote: Verifying deploy... done.
To https://git.heroku.com/getmoviehook.git
 * [new branch]      master -> master
```

You will get the URL `https://getmoviehook.herokuapp.com/` from the above deployment procedure. To test it out, you cannot merely send a GET request by visiting the URL `https://getmoviehook.herokuapp.com/getmovie` from a browser window. You can again use a REST client like Postman. Just replace the `localhost` URL with deployed one that is previously mentioned.

You will get successful results.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss8-1.png' />

## Setup Dialogflow

Dialogflow is a Natural Language Processing (NLP) service from Google. It has many integrations, SDKs for programming languages and some prebuilt agents. It works very straightforward with Google Assistant. Visit the [Dialogflow website](https://dialogflow.com/) and create a new account or log-in with your existing Google ID.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss9-2.png' />

Once you are logged in, you will be welcomed by a screen that consists of different **Agents**.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss10.png' />

Click on the Create Agent button to make one for yourself. Name it something similar to `OMDBbot`. Fill in the details like below.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss11.png' />

After filling out the details, click on the button **Create**.

Generally, for small applications, you will have one agent. In Dialogflow, the basic flow of conversation involves these steps:

- The user giving input in the form of a query
- Your Dialogflow agent parses the input from the training phrases
- Your agent returns a response back to the user

These agents understand the varied nuances of human language. They can translate that to standard and structured meaning that chatbot applications and services can understand. Each agent contains different **intents**. The intent is the action taken based on the user's input. It can be the response sent back to the user in a chatbot application. It can contain different types of responses or actions. The next step in the process is to create your first intent.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss12.png' />

Click on the button **Create intent** and fill in the name `getmovie`. You can name your intent anything.

Intent can be a simple text response that is displayed back to the user or a set of trained phrases. There are also actions and parameters that extract information from user queries. Examples of this kind of information include dates, times, names, places, and more.

## Create Training Phrases

Let us create new training phrases in this section. To create a new phrase, go to the section **Training phrases** and a unique user expression as shows below.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss13.png' />

For the movie chatbot, each user expression is going to contain the name of the movie. The Dialogflow agent is not smart enough to extract the name of the movie out of the user's expression. You have to provide an entity that can highlight the name of the movie every time a new training phrase is introduced to the bot.

From the sidebar menu, go to the entity section and click on the button **Create Entity**. Fill in the name of your entity as `movie` because this is what is being passed inside the webhook's request body. From the server, remember the following line:

```js
req.body.queryResult.parameters.movie;
```

Once you have saved your entity, go back to the intent.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss14.png' />

## Enable the Webhook

To test out that everything is working, let us use the default response provided by the Dialogflow intent. As shown below, on the right-hand side of the screen, you can test out by entering a user expression. The movie chatbot will return the default response.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss15.png' />

This is okay and verifies that the intent has been created successfully. Now, to use the real-time data from the OMDB API, you are going to enable the webhook. From the sidebar menu, go to the **Fulfillment** section. You will be welcomed by the following screen.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss16.png' />

Enable the **Webhook** and then enter the **URL** of the deployed endpoint.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss17.png' />

Once that is done, go back to the **Intents** section, and scroll down to the bottom of the web page. There is a **Fulfillment** section. Toggle the button to **Enable webhook call for this intent**.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss18.png' />

Once that is done, go to the right side of the screen to test it out. Fill in the user expression similar to a training phrase you have provided earlier. The agent will get a response back with the details of the movie.

<img src='https://crowdbotics.ghost.io/content/images/2019/07/ss19.png' />

## Conclusion

You have successfully created, deployed, and tested a Nodejs Webhook for Dialogflow chatbot application. By the end of this tutorial, we are sure you have learned how easy it is to create a new chatbot agent using Dialogflow. The possibilities of using a powerful API such as Dialogflow are endless. In no time, you can build up your own chatbot interface for front-end clients using Reactjs, Angular, and even mobile cross-platform framework like React Native. We hope this tutorial provided you an easy walkthrough to grab the concepts and build something of your own.


How to Create a Chatbot with Dialogflow, NodeJS, and Webhooks

---
title: 'Build a Twitter Clone Server with Apollo, GraphQL, Nodejs, and Crowdbotics'
date: '2019-06-13'
slug: 'build-a-twitter-clone-server-with-apollo-graphql-nodejs'
thumbnail: '/thumbnails/node.png'
tag: 'nodejs'
canonicalUrl: 'https://crowdbotics.ghost.io/build-a-twitter-clone-server-with-apollo-graphql-nodejs-and-crowdbotics/'
---

![cover_image](https://i.imgur.com/Cg4Xsqq.jpg)

> [Originally published at Crowdbotics](https://crowdbotics.ghost.io/build-a-twitter-clone-server-with-apollo-graphql-nodejs-and-crowdbotics/)

In the last few years, GraphQL becomes a popular choice to build an API. It serves a great alternative to the REST APIs approach. Not only it is an open source application-layer query language, in comparison to REST, GraphQL fulfills the approach that a client request's only the desired set of information from the server in a single request.

In this tutorial, you will be building a server using Node.js, Express and Apollo server library. You will learn how to efficiently build a server from scratch that implements GraphQL as the query language to create the API. We will be using MongoDB to create a local instance of the database and store the application data.

To learn more about the basics of GraphQL, how it differs from REST, its building blocks like schema, resolvers, queries, and mutations, please refer to the previous post **[Creating a GraphQL Server with Nodejs](https://medium.com/crowdbotics/creating-a-graphql-server-with-nodejs-ef9814a7e0e6)**. If you have an idea of what they are, you can continue to read this tutorial.

TLDR;

- Requirements
- Getting Started
- Running your first GraphQL server
- Adding a Mongoose Schema
- How to define GraphQL Types, Queries and Mutations
- Real-time Database Updates with GraphQL API
- Conclusion

## Requirements

In order to follow this tutorial, you are required to have installed the following on your local machine:

- Nodejs `v8.x.x` or higher installed along with `npm/yarn` as the package manager

## Getting Started

Create a new empty directory and initialize it with a `package.json` file by running the following commands from a terminal window.

```shell
# create new directory
mkdir twitter-clone-apollo-server

# traverse inside the directory
cd twitter-clone-apollo-server

# initialize the package.json file
npm init  --yes
```

The last command will create a `package.json` file. We are going to build an integrated server using [Expressjs](https://expressjs.com/) and Apollo server.

> **Wait, what is an Apollo Server?**

The Apollo Server is the server part of GraphQL where you manage and define a GraphQL API and handle responses that are sent back to the client in response to a network request.

When it comes to building a GraphQL API using Apollo on the server, there are two ways you can do that. One is called _standalone_ which is irrespective of the server-side web framework (_such as Express, Koa, Hapi and so on_) using the `apollo-server` library. This package is kept library-agnostic, so it is possible to connect it with a lot of third-party libraries in client and server applications.

Another way is to use the community maintained packages such as `apollo-server-express`. Most popular HTTP Node.js frameworks are having their own community packages that you can check [here](https://github.com/apollographql/apollo-server/tree/master/packages). We are going to leverage this approach.

Run the following command to install the dependencies.

```shell
npm install --save express apollo-server-express graphql
```

To verify if these dependencies are installed, open `package.json` file in your favorite code editor and you will get a similar result like below.

```json
{
  "name": "twitter-clone-apollo-server",
  "version": "0.0.1",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "Aman Mittal <amandeepmittal@live.com> (www.amanhimself.dev)",
  "license": "MIT",
  "dependencies": {
    "apollo-server-express": "^2.5.0",
    "express": "^4.17.0",
    "graphql": "^14.3.0"
  }
}
```

## Running your first GraphQL server

To understand how Apollo Server works, let us create a small bare minimum GraphQL server with the Express framework. Please note that, if you already know how to integrate Apollo server with express and create a hello world example, you are free to skip this section and move on to the next one.

At the root of your project, create a new file: `index.js` with the following code. We start by requiring the required dependencies in order to create this server and make it work.

```js
const express = require('express');
const { ApolloServer, gql } = require('apollo-server-express');
```

Then define some constants such as for an instance of the Express application, `app` and a port number where the local instance of the server is going to run. Note that, the `port` is currently using an environment value plus the default value of `5000` as the local port number if there is not environment value provided via `process.env.PORT`.

```js
const app = express();
const port = process.env.PORT || 5000;
```

The `process.env`global variable is injected by the Node at runtime for your application to use and it represents the state of the system environment your application is in when it starts.

Next, we define a basic schema. A **schema** in GraphQL is defined at the server in the form of objects. Each object corresponds to data types such that they can be queried upon. This object type has a name and fields. Like the below snippet, there is `Query` called `hello` which is of type string.

```js
const typeDefs = gql`
  type Query {
    hello: String
  }
`;
```

There are pre-defined scalar types in GraphQL like the string in the above snippet. Visit this **[link](https://graphql.org/learn/schema/)** to read more about them. **Queries** are what you use to make a request to a GraphQL API.

In order to execute this query, you need a resolver. Resolvers are the link between the schema and the data. They are the functions that contain the logic behind a query or mutation. They are used to retrieve data and return it on the relevant client request.

```js
const resolvers = {
  Query: {
    hello: () => 'Hello world!'
  }
};
```

In the above snippet, we are defining a resolver that will return the string `Hello World` on querying the server. If you have built servers before using Express, you can think of a resolver as a controller where each controller is built for a specific route.

Lastly, we need to use a middleware function from the Apollo Server Express library to instantiate the GraphQL API.

```js
const server = new ApolloServer({ typeDefs, resolvers });

server.applyMiddleware({ app });
```

Here is the complete code for `index.js` file.

```js
const express = require('express');
const { ApolloServer, gql } = require('apollo-server-express');

const app = express();
const port = process.env.PORT || 5000;

const typeDefs = gql`
  type Query {
    hello: String
  }
`;

const resolvers = {
  Query: {
    hello: () => 'Hello world!'
  }
};

const server = new ApolloServer({ typeDefs, resolvers });

server.applyMiddleware({ app });

app.listen(port, () =>
  console.log(
    `🚀 Server ready at http://localhost:${port}${server.graphqlPath}`
  )
);
```

Now, go back to the terminal window and run `node index.js` command to trigger the server up and running. Visit `http://localhost:5000/graphql` in a browser window to see that API endpoint in action. Apollo comes with a default playground in order to test the API.

<img src='https://crowdbotics.ghost.io/content/images/2019/05/ss1-4.png' />

## Adding a Mongoose Schema

Let us mongoose to create a MongoDB based database model inside the Express server app. To proceed, you will have to install the dependency first. Go to your terminal window, terminate the `node index.js` command first and then run the following.

```shell
npm install -S mongoose
```

Once this dependency is installed, create a new folder called `models`. Inside it, create a new file called `TweetModel.js`. This will be responsible for holding the mongoose schema. For those of who do not know what mongoose, well, it is an ORM (object relation mapper) that helps the server app written in Node.js/Expressjs to communicate with the MongoDB database.

Mongoose allows you to define objects with a strongly typed schema that is mapped as a MongoDB collection. This schema architecture allows us to provide an organized shape to the document inside the MongoDB collection where the data is stored.

Start by importing the dependency at the top of the file and then connect the ORM to a local instance of the MongoDB database in the form of a URI: `mongodb://localhost:27017/twitter`. The port `27017` is the default port number where MongoDB runs on your local dev machine irrespective of the operating system you are using. The `/twitter` in the end is just the name of the database instance. You can name it anything. `mongoose.connect()` the function takes this URI as the first argument.

_To learn more about how to create and use MongoDB in the cloud using MongoDB atlas, read our earlier post [here](https://medium.com/crowdbotics/how-to-build-a-serverless-backend-with-aws-lambda-and-nodejs-e0d1257086b4)._

Open `TweetModel.js` file and add the following.

```js
const mongoose = require('mongoose');

mongoose.Promise = global.Promise;
mongoose.connect('mongodb://localhost:27017/twitter', {
  useNewUrlParser: true
});

const Schema = mongoose.Schema;

const tweetSchema = new Schema({
  tweet: String,
  author: String
});

const TweetModel = mongoose.model('Tweet', tweetSchema);
```

Notice the `tweetSchema` object. It only contains three fields at the moment. The whole `tweet` as a string, and the name of the author who tweets. It is important to take notice of this schema, later, when you are going to create GraphQL queries, this is the same schema pattern you will have to follow.

Now, let us define the CRUD operations that this current Tweet model is going to perform on the MongoDB instance. Add the below snippet of code to `TweetModel.js` after you have defined the `TweetModel` itself.

```js
export default {
  getTweets: () => TweetModel.find().sort({ _id: -1 }),
  getTweet: _id => TweetModel.findOne({ _id }),
  createTweet: args => TweetModel(args).save(),
  deleteTweet: args => {
    const { _id } = args;

    TweetModel.remove({ _id }, error => {
      if (error) {
        console.log('Error Removing: ', error);
      }
    });

    return args;
  },
  updateTweet: args => {
    const { _id, tweet } = args;

    TweetModel.update(
      { _id },
      {
        $set: { tweet }
      },
      { upsert: true },
      error => {
        if (error) {
          console.log('Error Updating: ', error);
        }
      }
    );

    args.author = 'User123'; // temporary user

    return args;
  }
};
```

Using these functions that are defined in the above code snippet, it will be possible to perform CRUD operations with the MongoDB database. These functions perform all sort of functions like getting a tweet by its `id`, getting all tweets, creating a new tweet, and updating and deleting a specific tweet. The `id` to each tweet document is going to be generated automatically by the MongoDB database. Each of these function is taking an argument by default and that is the name of the author of the tweet. To keep this demo approachable and bare minimum, the author name right now is hard coded.

## How to define GraphQL Types, Queries and Mutations

To define queries, mutations, and resolvers, create a new folder called `api`. Inside this folder create two new files: `Types.js` and `Resolvers.js`.

Open `Types.js` file and add the following snippet to add the type of the individual tweet based on the mongoose schema and our first mutation to create a new tweet.

```js
const { gql } = require('apollo-server-express');

const typeDefs = gql`
  # Type(s)

  type Tweet {
    _id: String
    tweet: String
    author: String
  }

  # Query(ies)
  type Query {
    getTweet(_id: String): Tweet
    getTweets: [Tweet]
  }

  # Mutation(s)

  type Mutation {
    createTweet(tweet: String, author: String): Tweet

    deleteTweet(_id: String): Tweet

    updateTweet(_id: String!, tweet: String!): Tweet
  }
`;

module.exports = typeDefs;
```

In the above snippet, we define the type of the `Tweet` that will be used in every query and mutation. We are using `gql` for the graphql template literal. You can comment inside the GraphQL template literal using a hash `#`. Now open up the `Resolvers.js` file and add the following.

```js
const TweetModel = require('../models/TweetModel');

const resolvers = {
  Query: {
    getTweet: _id => TweetModel.getTweet(_id),

    getTweets: () => TweetModel.getTweets()
  },

  Mutation: {
    createTweet: (_, args) => TweetModel.createTweet(args),

    deleteTweet: (_, args) => TweetModel.deleteTweet(args),

    updateTweet: (_, args) => TweetModel.updateTweet(args)
  }
};

module.exports = resolvers;
```

In the above file, start by importing the `TweetModel` since it will be used to extend GraphQL queries and mutations (_defined above_) to communicate with the MongoDB database in real time.

Currently, the `index.js` file contains the `typeDefs` and resolver from the previous hello world example. Let us import these two files from the `api/` directory to replace them.

```js
const express = require('express');
const { ApolloServer } = require('apollo-server-express');

const typeDefs = require('./api/Types');
const resolvers = require('./api/Resolvers');

const app = express();
const port = process.env.PORT || 5000;

const server = new ApolloServer({
  typeDefs,
  resolvers
});

server.applyMiddleware({ app });

app.listen(port, () =>
  console.log(
    `🚀 Server ready at http://localhost:${port}${server.graphqlPath}`
  )
);
```

Now, go to the terminal window and run `node index.js` command. If you get zero errors, that means your server is running successfully. Also, make sure if you are using the local instance of MongoDB database, make sure to run the command `mongod` to kickstart the MongoDB service.

## Real-time Database Updates with GraphQL API

Once the server is running, visit the Apollo playground URL `http://localhost:5000/graphql` and run the following mutation.

```graphql
mutation {
  createTweet(tweet: "👋 Hello", author: "User12") {
    _id
    tweet
    author
  }
}
```

On running this mutation you will get the following result.

<img src='https://crowdbotics.ghost.io/content/images/2019/05/ss2-3.png' />

Add a bunch of more tweets by running the above mutation again. Now, let us run a query to fetch all the tweets from the database.

```graphql
query {
  getTweets {
    _id
    tweet
    author
  }
}
```

Writing the keyword `query` is an option only in the case of running a query. This is not possible in the case of running a mutation operation. You have to specify the keyword `mutation`. The above query fetches the unique identifier of each tweet in the database as well as the tweet and the name of the author itself. See the result below.

<img src='https://crowdbotics.ghost.io/content/images/2019/05/ss3-4.png' />

To delete a tweet from the database, all you have to provide is the `_id` of the tweet and provide sub-fields. Providing at least sub-field is necessary for the delete mutation to run, otherwise, it will throw an error.

```graphql
mutation {
  deleteTweet(_id: "5ce1a2f4f1ef7153d0fc7776") {
    tweet
    author
  }
}
```

You will get the following result.

<img src='https://crowdbotics.ghost.io/content/images/2019/05/ss4-3.png' />

Run the query to fetch all the tweets to see how many tweets are left.

<img src='https://crowdbotics.ghost.io/content/images/2019/05/ss5-4.png' />

The last operation is to update a tweet. Again, it is a mutation. All you to provide is the updated tweet in the form of a string and `_id` of the tweet you want to update.

```graphql
mutation {
  updateTweet(
    _id: "5cd7cb5f19c9b4673f860600"
    tweet: "This could be my last tweet..."
  ) {
    _id
    tweet
    author
  }
}
```

The output you get:

<img src='https://crowdbotics.ghost.io/content/images/2019/05/ss6-1.png' />

By fetching all the tweets you can verify that the updating mutation worked!

<img src='https://crowdbotics.ghost.io/content/images/2019/05/ss7-2.png' />

## Conclusion

If you completed this tutorial, **Congratulations!🎉**

Not only did you learn how to configure and integrate an Express web server with the Apollo server library and MongoDB database. You ended up building complete CRUD functionality.

Apollo Server is an open source project and is one the most stable solution to create GraphQL APIs for full-stack applications. It also supports client-side out of the box for React, Vue, Angular, Meteor, and Ember as well as Native mobile development with Swift and Java.

You can find the complete code for the tutorial in this **[Github repository](https://github.com/amandeepmittal/twitter-clone-apollo-server)**.


Build a Twitter Clone Server with Apollo, GraphQL, Nodejs, and Crowdbotics

Top open source libraries for Node.js

---
title: 'Top Node.js Libraries and Tools For Machine Learning'
slug: 'top-nodejs-libraries-and-tools-for-machine-learning'
date: '2018-12-19'
thumbnail: '/thumbnails/node.png'
tag: 'nodejs'
canonicalUrl: 'https://medium.com/crowdbotics/top-nodejs-libraries-and-tools-for-machine-learning-ae0c106c9a69'
---

> [Originally published at Crowdbotics](https://medium.com/crowdbotics/top-nodejs-libraries-and-tools-for-machine-learning-ae0c106c9a69)

Javascript is often thought of a web programming language but Javascript, and javascript frameworks such as NodeJS, have many applications apart from just web apps including desktop applications, mobile applications, embedded systems, and back-end development.

If you are in web development (as I am), and you also want to explore new applications in machine learning (as I do), you may be wondering, ‘do I have to wander spend time learning a whole new programming language to explore machine learning?’ No, in fact. Machine learning concepts can be explored with many different programming language and frameworks, including NodeJS.

In this article, I review some of the top machine learning libraries for NodeJS to help you get started.

## ml.js

This library is a collection of tools developed by the [mljs](https://github.com/mljs) organization. It includes a vast list of libraries under different categories such as unsupervised learning, supervised learning, artificial neural networks, regression, optimization, statistics, data processing, and math utilities.

Most of the libraries that are included in ml.js tend to be used in a web browser, but if you are looking to work with them in Node.js environment, you will find an npm package.

Check out some examples that use utilities from ml.js:

- [Naive-Bayes Classification](https://github.com/mljs/naive-bayes)

Each tool utility is available as a separate module so you do not have to install all of them at once, if there is no need too.

```shell
npm install ml-naivebayes
```

After installing the package, you can directly import your JavaScript project. ml.js even supports ES6 modules.

```js
import { GaussianNB } from 'ml-naivebayes';

var model = new GaussianNB();
model.train(Xtrain, Ytrain);

var predictions = model.predict(Xtest);
```

- [Finding a minimum value in an array](https://github.com/mljs/array/tree/master/packages/array-min)

All utilities that helps in transform and computing values using arrays are also packaged separately and are listed under `ml-array` which you can find [**here**](https://github.com/mljs/array)**.** For example, let us say you want to get a minimum value of all the inputs provided as an array. To do so, you will first install the utility `ml-array-min` .

```shell
npm install --save ml-array-min
```

Then you directly require it like below.

```js
import min from 'ml-array-min';

const result = min(\[1, 5, 3, 2, 4\]); // 1
```

To see the vast list of libraries that are included in `ml.js`, visit the link below.

[**mljs/ml**](https://github.com/mljs/ml)

## Brain.js

Brain.js is a library written in JavaScript for [**neural networks**](http://en.wikipedia.org/wiki/Artificial_neural_network) that can be used with Node.js as well as in the browser. You can simply access it and start using it by installing it through [npm](https://www.npmjs.com/package/brainjs). Since it is written in JavaScript, it has support for asynchronous to train network data using `trainAsync()` and support for streams as well.

Generally, neural networks are considered to be math-heavy sub-domain in machine learning. Brian.js does a great job simplifying the process of creating and training a neural network by utilizing the ease-of-use of JavaScript and by limiting the API to just a few method calls and options.

For example, to train a network to approximate the [XOR](https://en.wikipedia.org/wiki/Exclusive_or) function (which is one of the standard examples), you would need:

```js
var brain = require('brain');
var net = new brain.NeuralNetwork();

net.train(\[{input: \[0, 0\], output: \[0\]},
 {input: \[0, 1\], output: \[1\]},
 {input: \[1, 0\], output: \[1\]},
 {input: \[1, 1\], output: \[0\]}\]);

var output = net.run(\[1, 0\]); _// \[0.933\]_
```

This code creates a new network (`net`) and `train`s the network using an array of example. It then`run`s the network with an input of `[1, 0]`, which results in `[0.933]` .

There are various meaningful machine learning applications that use Brain.js. Take a look at this one: [**Cracking Captcha with Neural Networks**](http://codepen.io/birjolaxew/blog/cracking-captchas-with-neural-networks), in which the author uses captcha images for the dataset and uses image processing and Brain.js library to create a neural network that identifies each individual character.

Another example of Brain.js being used with React Native can be found [**here**](https://github.com/BrainJS/BrainJSReactNative).

[**BrainJS/brain.js**](https://github.com/BrainJS/brain.js)

## Synaptic

Synaptic is another JavaScript neural network for Node.js. It has a few built-in architectures like multilayer perceptrons, multilayer long-short term memory networks (LSTM), liquid state machines or _Hopfield_ networks, and a trainer capable of training different networks. It also works with your browser.

Check out the example below for predicting a next character in a stream of text based articles from Wikipedia using a long-short term memory.

Brain.js and Synaptic are both written in JavaScript. Surely, there will be similar use cases for Synaptic as the previous one.

I can give you one more reason to choose synaptic over Brain.js. It has more API functionalities than the previous library mentioned in this article. This certainly means Synaptic will have more use cases and also, It is also actively developed.

For example, you can train and teach a perceptron to learn an XOR:

```js
var myPerceptron = new Perceptron(2,3,1);
var myTrainer = new Trainer(myPerceptron);

myTrainer.XOR(); // { error: 0.004998819355993572, iterations: 21871, time: 356 }

myPerceptron.activate(\[0,0\]); // 0.0268581547421616
myPerceptron.activate(\[1,0\]); // 0.9829673642853368
myPerceptron.activate(\[0,1\]); // 0.9831714267395621
myPerceptron.activate(\[1,1\]); // 0.02128894618097928
```

Check out common use cases using this machine learning module such as:

- [Solving an XOR](http://caza.la/synaptic/#/xor)
- [Painting a picture](http://caza.la/synaptic/#/paint-an-image)
- [Reading from Wikipedia](http://caza.la/synaptic/#/wikipedia)

[**Synaptic - The javascript neural network library**](http://caza.la/synaptic/#/wikipedia)

## Limdu.js

Limdu.js is a machine learning framework for Node.js that supports Binary classification, multi-label classification, feature engineering, online learning and real-time classification. It is currently in alpha state and looking for contributors.

Check out the example below of how batch learning can be implemented with the help of Limdu.js

```js
var limdu = require('limdu');

var colorClassifier = new limdu.classifiers.NeuralNetwork();

colorClassifier.trainBatch(\[
 {input: { r: 0.03, g: 0.7, b: 0.5 }, output: 0}, // black
 {input: { r: 0.16, g: 0.09, b: 0.2 }, output: 1}, // white
 {input: { r: 0.5, g: 0.5, b: 1.0 }, output: 1} // white
\]);

console.log(colorClassifier.classify({ r: 1, g: 0.4, b: 0 }));
// 0.99 - almost white
```

In the above example, an array as resource is provided to train the batch of key value pairs in the form of input and output.

Other use cases for this library can be found in the link below. Some of them are listed here:

- Serialization: you might want to train a classifier on your home computer, and use it on a remote server. To do this, you should somehow convert the trained classifier to a string, send the string to the remote server, and deserialize it there.
- Mutli-label classification: In binary classification, you get the output either as `0` or `1` . On multi-label, , the output is a set of zero or more labels.

[**erelsgl/limdu**](https://github.com/erelsgl/limdu)

> [**Try out the Crowdbotics application builder to instantly scaffold and deploy a Node app.**](https://app.crowdbotics.com/accounts/login/?utm_campaign=v1&utm_source=blog-post&utm_medium=Medium&utm_content=app-builder)

## ConvNetJS

The ConvNetJS JavaScript implementation of neural networks that is developed by a Stanford University PhD. It currently supports common neural network modules, SVM, regression, and the ability train convolutional networks to process images.

It has [great documentation](http://cs.stanford.edu/people/karpathy/convnetjs/docs.html), as well as [in-browser examples](http://cs.stanford.edu/people/karpathy/convnetjs/demo/mnist.html). Here are some use cases where you can see ConvNetJS in action:

- [Image Painting (Regreesion)](https://cs.stanford.edu/~karpathy/convnetjs/demo/image_regression.html)
- [Training an Autoencoder on MNIST digits](http://cs.stanford.edu/~karpathy/convnetjs/demo/autoencoder.html)
- [Speedtest](https://github.com/karpathy/convnetjs/blob/master/demo/speedtest.html)

[**karpathy/convnetjs**](https://github.com/karpathy/convnetjs)

### Stdlib

Stdlib is a JavaScript library which can be used to build advanced statistical models and machine learning libraries. It can also be used for plotting and graphics functionality for data visualization and exploratory data analysis. Stdlib supports in the form of different libraries such as linear regression, binary classification, and natural language processing.

This library is huge when it comes to providing support in the form of tooling. Some of the advantages it posses are :

- It has its own REPL environment with integrated help and examples.
- Native add-ons for interfacing with BLAS libraries, with pure JavaScript fallbacks.
- 50+ [sample datasets](https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/datasets) for testing and development.
- 200+ [assertion utilities](https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/assert) for data validation and feature detection.
- 200+ general [utilities](https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/utils) for data transformation, functional programming, and asynchronous control flow.
- Can be bundled using Browserify, Webpack, and other bundlers for use in web browsers.

[**stdlib-js/stdlib**](https://github.com/stdlib-js/stdlib)

## TensorFlow.js

[TensorFlow](https://medium.com/u/b1d410cb9700) is an open-source hardware-accelerated JavaScript library for training and deploying machine learning models. It is one of the most popular libraries out there. You can use flexible and easy to pick APIs to build models from scratch using the low-level JavaScript linear algebra library or the high-level layers API.

You will find more implementations of TensorFlow rather than any other library mentioned in this article. There is a reason for that. Not only it is actively maintained, it lets you write, train, and deploy your GPU-based DL models all in JavaScript.

Check out some live use cases for Tensorflow:

- [EMOJI SCAVENGER HUNT](https://emojiscavengerhunt.withgoogle.com/)
- [WEBCAM CONTROLLER](https://storage.googleapis.com/tfjs-examples/webcam-transfer-learning/dist/index.html)
- [NODE.JS: PITCH PREDICTION](https://github.com/tensorflow/tfjs-examples/tree/master/baseball-node)

It has vast variety of tutorials and guides listed officially on its website [**here**](https://js.tensorflow.org/tutorials/) to get you started. It also provide model converters to run pre-existing TensorFlow models right in the browser or under Node.js.

[**tensorflow/tfjs**](https://github.com/tensorflow/tfjs)

## KerasJS

It is similar to Tensorflow.js in many ways. One of the similarities is that Keras has support for high-level APIs that take care of abstraction provided by backend frameworks. Using Keras, models can be trained in any backend and you can even hook Tensorflow for that.

Offical KerasJS library offers many use cases in different domains such as:

- Basic Convnet for MNIST
- Convolutional Variational Autoencoder, trained on MNIST
- Auxiliary Classifier Generative Adversarial Networks (AC-GAN) on MNIST
- 50-layer Residual Network, trained on ImageNet
- Inception v3, trained on ImageNet
- DenseNet-121, trained on ImageNet
- SqueezeNet v1.1, trained on ImageNet
- Bidirectional LSTM for IMDB sentiment classification

Another thing about these use cases are that all of them are written in [**VueJS**](https://vuejs.org/).

While much of the use case for this library lies in using directly with a web based browser. However, to use Keras with Node.js, there is one limitation you will have to be aware of: the Node.js models only run in CPU mode.

[**transcranial/keras-js**](https://github.com/transcranial/keras-js)

## NeuroJS

NeuroJS is a JavaScript framework for deep learning. It mainly focuses on reinforcement learning, but can be used for any neural network based task. It contains neat demos to visualize these capabilities, for instance a 2D self-driving car. It also include support for Support for deep-q-networks and actor-critic models.

A complete list of its features are listed below:

- Implements a full-stack neural-network based machine learning framework
- Extended reinforcement-learning support
- Support for deep-q-networks and actor-critic models (via deep-deterministic-policy-gradients)
- Binary import and export of network configurations (weights etc.)
- High-performance

[**janhuenermann/neurojs**](https://github.com/janhuenermann/neurojs)

## Mind

Another flexible neural network library for Node.js, it uses matrix implementation to process training data. It does allow you to configure the network topology and use community made plugins. These plugins generally provide a way to configure pre-trained networks that can go straight to making predictions.

To create a plugin, simply call `download` on your trained mind:

```js
const Mind = require('node-mind')

const mind = Mind()
 .learn(\[
 { input: \[0, 0\], output: \[ 0 \] },
 { input: \[0, 1\], output: \[ 1 \] },
 { input: \[1, 0\], output: \[ 1 \] },
 { input: \[1, 1\], output: \[ 0 \] }
 \]);

const xor = mind.download()
```

Steven, the author, has written a 2 part tutorial on building neural networks by using _Mind_ ([Part 1](http://stevenmiller888.github.io/mind-how-to-build-a-neural-network) | [Part 2](http://stevenmiller888.github.io/mind-how-to-build-a-neural-network-part-2)). This series offer a lot more information than simply how to use _Mind_. Also, check out a live [**demo**](http://stevenmiller888.github.io/mindjs.net/) of a movie recommendation engine built with Mind.

[**stevenmiller888/mind**](https://github.com/stevenmiller888/mind)

## Natural

Natural is a library that provides tokenzing, stemming, classification, phonetics, tf-idf, WordNet, and string similarity. In other words, this library provide language facilities that you can use a module in Node.js. This is an interesting project with a variety of use cases.

All of these utilities are bundled together and provided as a package that can be easily installed via `npm` : `npm install -S natural`

As it seems this library is still in early stages and most of the algorithms are English-specific but recent community based contributors have implemented support for other language such as Russian and Spanish.

[**NaturalNode/natural**](https://github.com/NaturalNode/natural)

## Compromise

Another natural language processing that is only `230kb` minified when used in the browser. It is an advantage of using this library as compared to the previously mentioned, Natural.

This library provides lot of utilities that are basic and effortless, as well as support community made plugins to extend and use pre-configuration that allow adding vocabulary, fixing errors, and setting context quickly.

Apart from English, support for languages including German and French is still a _work in progress._

[**spencermountain/compromise**](https://github.com/spencermountain/compromise)

## Conclusion

JavaScript might be not a go-to programming language for machine learning yet, but the many powerful libraries listed here prove that JavaScript is not behind the curve when it come to machine learning applications.

Many machine learning library developers and teams write libraries using using C, LIBSVM, LIBLINEAR, and so on. These can be implemented in Node.js too, using native extensions provided by the Node.js core APIs.

I hope, this post prove useful to you as well for learning and using different libraries mentioned in your Node.js application.


Top Node.js Libraries and Tools For Machine Learning

How To Build a REST API With Nodejs and PostgreSQL

Building an authenticated MERN Stack App Using Material UI

How to Build a Serverless Backend with AWS Lambda and Nodejs

---
title: 'How to use Import statements in Nodejs'
date: '2018-11-01'
slug: 'how-to-use-import-statements-in-nodejs'
thumbnail: '/thumbnails/node.png'
tag: 'nodejs'
canonicalUrl: 'https://medium.com/better-programming/how-to-use-import-statements-in-nodejs-94c85e23aeb7'
---

> **UPDATE:** Up to date version of this post is at [How to use ES6 import syntax in Node.js](https://amanhimself.dev/blog/how-to-use-es6-import-syntax-in-node/).

I don’t always like to try different versions of setting up a Nodejs application. Don’t get me wrong — I believe in experimenting with one’s set up, which can lead to learning new things. But there is a limit. Recently, I find myself more often going to set up a Nodejs server to develop a RESTful API. Furthermore, the server has to work with the client in a way that the client can consume the API easily. For the client-side development, I am using ReactJS.

With the context switching between the client and the server I often find myself making errors during the process. One of the most common is using `import` statements in Nodejs files. This leads to a syntax error called `Unexpected identifier`. Even after switching to Nodejs `v10` LTS on my local machine, I find the lack of using ES6 modules rather disappointing.

To overcome this problem, and reduce the number of errors I cause during development, I read a few tutorials but decided to mesh a setup of my own. These tutorials, though well written, use methods that are almost completely opposite to one another. I want consistency when working on full-stack applications for my day job.

As a result, I m going to show you a streamlined, less time-consuming version of using `import` statements in a Nodejs server-side application. To continue to read this article, please make sure you have following applications installed on your local machine:

- Nodejs
- npm

### Getting Started With a Mock Project

I call it a mock project because I am going to start from scratch to build this setup. At the end of this tutorial, I will leave a link to a Github repository that can serve as a starter kit to many of your Nodejs plus Express projects. You can skip to the link part and DIY — there’s no complexity here. If you’re still curious, continue to read this short piece.

To start, create a new directory, traverse inside it and initialize it with `npm`.

```shell
mkdir node-babel-setup
npm init -y
```

You can check out the `package.json` file after initializing your project as an npm project. It will be filled with details that you have used to configure npm.

```json
{
  "name": "node-babel-setup",
  "version": "0.0.1",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "Aman Mittal <amandeepmittal@live.com> (www.amanhimself.me)",
  "license": "MIT"
}
```

Next, create a new file with the following command from your terminal:

```shell
touch index.js
```

<img src='https://cdn-images-1.medium.com/max/800/1*cToGazhSQLTx3oIwsJULPQ.png' />

That’s all we need to set up a bare minimum project directory. In the next section, we take a look at what dependencies we have to install and why we need those dependencies.

### Creating the Node Server

To create a server I am going to use Express. To include Express in our project as a dependency, run the following command from your terminal:

```shell
npm install -S express
```

Next, append the `index.js` file with the following code:

```js
const express = require('express');

const app = express();
const PORT = process.env.PORT || 3000;

app.get('/', (req, res) => {
  res.send('Hello from Nodejs!');
});

app.listen(PORT, () => {
  console.log(`🚀 at port ${PORT}`);
});
```

You can run the server by running the command `node index.js`. Visit URL `http://localhost:3000/` and you’ll see a message displayed in the browser window: `Hello from Nodejs!`.

This indicates that the code for the server is fine. Now modify the first line of `index.js` to:

```js
import express from 'express';
```

Run the same command `node index.js` and stay at the terminal window. This time the server does not start as there is an error in the process. It’s the same error I told you about at the start of this article. Nodejs cannot execute `import` statements by default.

<img src='https://cdn-images-1.medium.com/max/800/1*itCGCm0lnbBG94KS6D0bOg.png' />

### Using Babel

All we need is a transpiler, which allows us to write JavaScript using ES6 features such as `import` statements in our Nodejs project. _What’s a transpiler?_

> Transpilers are also known as source-to-source compilers that read code from source written in one programming language and produce an equivalent code in another language.

In our case we’re not switching programming languages, rather we need to use new language features that are not yet supported by the LTS version of Node. I’m going to set up Babel compiler and enable it in our project by going through the following configuration process:

First, you will have to install few dependencies. Do mind -D flag as we only need these dependencies for our development environment:

```shell
npm install -D babel-cli babel-preset-env babel-watch
```

Once you have installed them, add a `.babelrc` file to the root of the project and add the following config:

```json
{
  "presets": ["env"]
}
```

The last step in the configuration process is to add a `dev` script in `package.json`. You can name this script whatever you like. This will take care of running the babel compiler on its own (automate) once there is a change. This done by `babel-watch` that also takes care of re-starting Nodejs web server.

```json
"scripts": {
  "dev": "babel-watch index.js",
}
```

To see it action make sure the following code to your `index.js` uses `import` statement like below.

```js
import express from 'express';

const app = express();
const PORT = process.env.PORT || 3000;

app.get('/', (req, res) => {
  res.send('Hello!');
});

app.listen(PORT, () => {
  console.log(`🚀 at port ${PORT}`);
});
```

From terminal write `nr dev`. If there are no errors, you’ll get the following:

<img src='https://cdn-images-1.medium.com/max/800/1*Rz9TPPfk6B4p4NPTntXKvg.png' />

Where `nr` is shorthand for `npm run`. You can also visit `http://localhost3000/` in your browser to verify the result and see if the server is working or not.

### Conclusion

This article has shown you how to create a bare minimum Node server from scratch, and how you can introduce upcoming JavaScript features in your Node.js environment using Babel. I’m sure now you are not going to make the same silly errors like me in _Nodejs_ + _insert a frontend framework/library of your choice_ as I did.

_You can find the complete source code for the above article at_ [**_Github Repo_**](https://github.com/amandeepmittal/node-babel-setup)


How to use Import statements in Nodejs

---
title: 'Setting up Nodejs Backend for a React App'
date: '2018-10-18'
slug: 'setting-up-nodejs-backend-for-a-react-app'
thumbnail: '/thumbnails/node.png'
template: post
tag: 'nodejs'
canonicalUrl: 'https://medium.com/crowdbotics/setting-up-nodejs-backend-for-a-react-app-fe2219f26ea4'
---

In this article, I am going to walk you through setting up your own [Node.js](http://crowdbotics.com/build/node-js) backend server for a [React application](https://crowdbotics.com/build/react). Both frameworks are often used together to build real time, fullstack web applications. A database, such as MySQL, Postgresql, or a NoSQL database such as MongoDB, is used to store information. For brevity’s sake, I will not use a database in this walkthrough.

_Requirements:_ You need Node.js and npm installed on your local machine as well as `create-react-app` installed as a global dependency. If you do not have it, run the following command and install it.

```shell
npm install -g create-react-app
```

_In some cases, you might have to give root permissions when installing a global dependency._

For the Nodejs backend, I am going to use [**HapiJS**](https://hapijs.com/). If you are not familiar with it, it will be fun as you will be learning a lot of new things.

### Getting Started with the Backend

To start, we need an empty directory inside which we can have our server and client live alongside each other. Initialize it by running the command `npm init` and you are ready to install Hapijs as a framework to build the web server.

```shell
npm install hapi --save
```

After Express, Hapi is quite popular among teams and individuals who write the server side of their application using Node. Hapi is currently being used by organizations such as Walmart and Yahoo and has an active community. After the dependency is successfully installed, create a new file called `server.js`.

```js
'use strict';

const Hapi = require('hapi');

// Create a server with a host and port
const server = Hapi.server({
  host: 'localhost',
  port: 8000
});

// Add the route
server.route({
  method: 'GET',
  path: '/',
  handler: (request, h) => {
    return 'hello world';
  }
});

// Start the server
async function start() {
  try {
    await server.start();
  } catch (err) {
    console.log(err);
    process.exit(1);
  }

  console.log('Server running at:', server.info.uri);
}

start();
```

This is the most basic server you can create using Hapi.

We start as usual by requiring Hapijs dependency and create a new object with a configuration of our own. See the `host` and `port` above.

After that, we add a simple route that uses HTTP method `GET` and has a handler function or usually called a callback function to return the response back to the client when a request comes in. Lastly, we are creating an asynchronous function to bootstrap the server using `async/await` syntax.

The `async/await` requires you to add a `try/catch` block every time you want to catch the errors. We `console.log` in case any error occurs running the program and use Nodejs global `process` object to make sure that program exits gracefully in case of one. To see it in action, run `node server.js` and it will eventually run on port `8000`.

<img src='https://cdn-images-1.medium.com/max/800/1*yR_UcIKCzTeNoN9HPYCNdQ.png' />

### Setting up a React app

Now that we have built our server, let us create the front end of our application. We have already installed the main ingredient we need to start with. Open your terminal and type:

```shell
create-react-app client
```

This will create a react application named `client` inside the folder where we previously built our server. Simple as that.

Now you can traverse to the `client` directory and run the React app separately on a different port. However, this is not what we want.

### The proxy

We want a setup that will make our React app and use the server URL as a global variable. This is easier than you might think.

Navigate to client directory and locate `package.json` file. Add the following configuration to it.

<img src='https://cdn-images-1.medium.com/max/800/1*jEgu48E180zXD0Z3_NyuHA.png' />

And that’s it. This is all you need to do. _But wait! How is this even possible?_ The answer lies with the `create-react-app`.

`create-react-app` does all this automatically and behind the scene because it is using [_webpack_](https://webpack.js.org/).

Webpack has a development server that uses a proxy to handle the API server or in other terms, it requests to our Hapi server running on port `8000`. This is one of the biggest advantages I have found for using create-react-app so far. Webpack handles all the configuration.

### Conclusion: Running the app

Let us now test a route that sends the data from the Hapi backend server to React front-end side whenever a request comes from the client. Create a route /`mock`in `server.js` to serve the data the dummy data defined as an array `data` itself.

```js
'use strict';

const Hapi = require('hapi');

// mock data

const data = [
  { id: 1, name: 'Alex', age: 21 },
  { id: 2, name: 'Alice', age: 23 }
];

// Create a server with a host and port
const server = Hapi.server({
  host: 'localhost',
  port: 8000
});

// Add the route
server.route({
  method: 'GET',
  path: '/',
  handler: (request, h) => {
    return 'hello world';
  }
});

server.route({
  method: 'GET',
  path: '/mock',
  handler: (request, h) => {
    return { data };
  }
});

// Start the server
async function start() {
  try {
    await server.start();
  } catch (err) {
    console.log(err);
    process.exit(1);
  }

  console.log('Server running at:', server.info.uri);
}

start();
```

To test this route, let us use REST client like POSTMAN or Insomnia and see if the data is being requested at the route `/mock`.

<img src='https://cdn-images-1.medium.com/max/1200/1*ygiAUjIzThy-NHFfbi9Rsg.png' />

Now let us display this data in our front end. Traverse to `client/App.js` file and do the following.

```js
import React, { Component } from 'react';
import logo from './logo.svg';
import './App.css';

class App extends Component {
  state = {
    data: []
  };

  componentDidMount() {
    this.fetchData()
      .then(res => this.setState(res))
      .catch(err => console.log(err));
  }

  fetchData = async () => {
    const response = await fetch('/mock');
    const body = response.json();

    return body;
  };

  render() {
    return (
      <div className="App">
        <header className="App-header">
          <img src={logo} className="App-logo" alt="logo" />
          <h1>Data from the Backend</h1>
          {this.state.data.map(person => (
            <p key={person.id}>
              Name: {person.name} <br /> Age: {person.age}
            </p>
          ))}
        </header>
      </div>
    );
  }
}

export default App;
```

We start by defining a local state that will contain the data coming from the backend inside `componentDidMount()` life-cycle hook method. This further calls the asynchronous method`fetchData()` that actually requests the data from the API url `/mock`. Since we have already defined the complete URL as `proxy` we do not have to write the complete url.

Finally, we are able to see the data as below.

<img src='https://cdn-images-1.medium.com/max/1200/1*79TNeMIHMbzT1Vcnh7ZNZw.png' />

_You can find the complete source code for the above article at_ [**_Github Repo_**](https://github.com/amandeepmittal/hapi-react-example)

_[Originally published at Crowdbotics](https://medium.com/crowdbotics/setting-up-nodejs-backend-for-a-react-app-fe2219f26ea4)_


Setting up Nodejs Backend for a React App

---
title: 'Building a REST API with Koajs'
date: '2018-10-16'
slug: 'building-a-rest-api-with-koajs/'
thumbnail: '/thumbnails/node.png'
tag: 'nodejs'
canonicalUrl: 'https://medium.com/crowdbotics/building-a-rest-api-with-koajs-417c276929e2'
---

![cover](https://i.imgur.com/ohg3d3s.png)

> [Originally published at Crowdbotics](https://medium.com/crowdbotics/building-a-rest-api-with-koajs-417c276929e2)

There are quite a few [Node.js](http://crowdbotics.com/build/node-js?utm_source=medium&utm_campaign=nodeh&utm_medium=node&utm_content=koa-rest-api) frameworks available for web development to build a back-end server for a web or a mobile application. The most popular framework is ExpressJS, which has been used widely in the industry for a long time.

In this article, however, **we are going to discuss** [**Koa**](http://koajs.com)**, to write server-side code that uses Node.js as the runtime engine. In this tutorial, I will show how to build a** [**small REST API**](https://blog.crowdbotics.com/how-to-write-an-api-in-3-lines-of-code-with-django-rest-framework/) **then test it using a REST Client.**

### What is Koa?

Koa is designed and built by the team behind ExpressJS with additions such as promises and `async/await` support in its core. These ES2015 features are used to tackle API's asynchronous calls. Distributed as a lightweight Node.js framework, Koa provides a minimal interface for developing web applications and APIs.

Koa has features that help JavaScript developers who want to use and leverage Node.js to accelerate the development of APIs and web applications. I have been using Koa for some of my latest back-end applications and I would love to share my knowledge to get you started.

### Features of Koa

Some of the features of the Koa framework include:

- Designed as a lightweight and flexible framework for Node.js
- Support for ECMAScript 6 (/ES2015) by default
- Developers can use generators as functions to stop and resume the code execution
- Simplifies the use of Error handling by using middleware more effectively
- Identifies and understands all HTTP methods
- Even before Express, Koa had support for `async/await`

To use this framework, the only two requirements for runing the code examples below is to have Node.js installed in your local machine along with `npm` to access and install it as a dependency. The second requirement is to have a general understanding of JavaScript as a programming language.

### Getting Started

To start using Koa as a server-side framework you will have to first install it. Create a directory where you will want to place all the project related files. We will first initialize it as a Node.js project.

```shell
# First initialize an empty directory
npm init -y
```

This will help us generate a `package.json` file that holds all the records of dependencies we add to our project using `npm`. I am using `-y` flag to skip the questionnaire prompted by npm. You will get a similar result once it is done.

```json
{
  "name": "koa-rest-api-tut",
  "version": "0.0.1",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "Aman Mittal",
  "license": "MIT"
}
```

Next step is to add Koa as a local dependency. I am sure you know what a local dependency here means. If not, please refer to `[npm](https://docs.npmjs.com/)` [documentation](https://docs.npmjs.com/).

```shell
npm install -S koa
```

So far so good. Now we can get started and build our application. However, please note that to use Koa either on your local machine or deploy any server-side project that uses it, _you need to have Node.js version equal to or greater than_ `_v7.6.0_`_._

### Our First Koa App

To understand Koa better, and point out the differences with a commonly used framework such as ExpressJS, we are going to first write an obligatory _Hello World_ program.

Below, we create a route in a file called `app.js`.

```js
// app.js
const Koa = require('koa');
const app = new Koa();

// Our First Route
app.use(async ctx => {
  ctx.body = 'Hello World';
});

// Bootstrap the server
app.listen(3000);
```

Now, open the terminal and run the following command:

```js
node app.js
```

If you are not prompted with an error, that means the server ran successfully.

Right now, we are not getting anything exciting from the terminal. If you go to `http://localhost:3000` in your browser window, you should see a `Hello World` message greeting you!

<img src='https://cdn-images-1.medium.com/max/800/1*vmF-dRrg83Uq4Zt6BbkAEg.png' />

To understand more about what is happening, let’s import the Koa library into our `app.js` file.

Next, we define an instance called `app` that will access all the methods that are included in Koa's API such as `use()` and `listen()`. `app.use()` is how th middleware function is defined. We are using this middleware function as a route. The `app.listen()` is how the server knows to run on a port number specified such as `3000`.

### Wait, what is ctx?

Another important feature that we use in our bare minimum example is `ctx`. I do hope you noticed it there.

We are using `ctx` as an argument to the asynchronous middleware function. It is called **Context** in Koa and it encapsulates **request** and **response** objects into a single object. Unlike ExpressJS, that requires request and response as separate objects passed as arguments. For example:

```js
// request and response objects in ExpressJS

app.use((request, response) => {
  // ... rest of the route
});
```

In Koa, a context is created for every request that comes to the server and is always referenced as a middleware.

```js
// request and response as context in Koa
app.use(async ctx => {
  ctx.request;
  ctx.response;
});
```

### Side Tip: Installing nodemon

Before I start on REST APIs, the core of the article, I want to introduce a great tip that is helpful in building a Node.js application. During the development mode, irrespective of the framework I am using, I use `nodemon` as a dependency to watch for file changes and automatically restart the application. This eliminates the need of running `node [filename].js` command again and again. You can totally, skip this step and move on the next one where I show the steps for writing the REST API.

This small utility has such an impact on my workflow that it saves hours of development chores. So let me show you how to set it up in our demo application. I am using the same project as previous **Hello World** example to demonstrate this. Write the following command to install it.

```shell
npm install -D nodemon
```

`-D` flag is used to tell npm to install the current dependency as a `devDependency`. The difference between it and a normal dependency is that `devDependencies` tend to work only in development environment. They are not installed in a production environment since there is no use of them there. Other types of `devDependencies` you might come across when writing Node applications are linting tools such as ESLint.

Once, `nodemon` is installed, append the `package.json` file and an npm script.

```json
"scripts":{
  "dev": "nodemon app.js"
}
```

Point this script to the initial file of the Koa application, in our case, it is `app.js`. To run the application now, all you have to type is `npm run dev` command in your terminal. This time, you will see a few messages suddenly prompted in the terminal. These messages are provided by `nodemon`.

### Building the REST API

Finally, you have arrived at the point where you can start building the REST API. You have to install dependencies for the API to work. Let’s install them.

```shell
npm i -S koa-body koa-router
```

> What are these dependencies for?

**koa-body** is a body-parser middleware. It supports `urlencoded`, multi-part and `json` request bodies. Basically, it helps to create and respond to HTTP `POST` requests which are available as a form field, or a file upload, etc. It tells the server that the incoming request from the client has a body of data. ExpressJS uses the same approach in handling body requests.

**koa-router** is the routing middleware that provides ExpressJS style routing using HTTP verbs. It has methods that you can directly use in the application Such as `app.get()`, `app.post()`, etc.

**Note:** I will be mocking data in this application for the sake of brevity and clear understanding of framework’s concepts. If you want to, you can use the database of your choice. The structure of data is not complex.

Write the following code in the `app.js` file.

```js
// app.js

const Koa = require('koa');
const koaBody = require('koa-body');

// create app instance
const app = new Koa();

// middleware functions
app.use(koaBody());

// Require the router here

// use the router here

app.listen(3000);
```

After body-parser middleware, you are going to have the routes. I am using another file to describe the routes to separate the code for clear understanding. Create a new file called `books.js`. Define the following inside that file with the data to mock.

```js
// books.js

const Router = require('koa-router');

// Prefix all routes with: /books
const router = new Router({
  prefix: '/books'
});

let books = [
  { id: 101, name: 'Fight Club', author: 'Chuck Palahniuk' },
  { id: 102, name: 'Sharp Objects', author: 'Gillian Flynn' },
  { id: 103, name: 'Frankenstein', author: 'Mary Shelley' },
  { id: 101, name: 'Into The Wild', author: 'John Krakauer' }
];

// Routes will go here

module.exports = router;
```

First, I am importing the necessary dependency to create routes: `koa-router`. The next step is to create an instance of this newly imported dependency. Notice the prefix part: `/books`. Using a prefix for the routes is how you can define and categorized different routes. You can also use this technique to classify the different API versions such as `v1`, `v2`, etc.

The `books` array is the mock data. It contains information about books and each book is represented by a separate object inside the array. Each object further has three data fields: `id`, `name`, and `author`.

Let’s build the first route of our API.

### Creating a route to handle GET request

Below is the code for handling a `GET` request in Koa. Add the following code to `books.js`.

```js
// books.js
router.get('/', (ctx, next) => {
  ctx.body = books;
  next();
});
```

The callback function attached to the `router.get()` contains two arguments. I have already explained to you what `ctx` or context is. The last argument is `next()`. This is often used in middleware functions. Any middleware function invokes this function to indicate the current middleware function has suspended running and the next middleware function available must be invoked.

This callback function traverses through the `books` array when to send the response. To run this, you have to first include the routes file in `app.js` and invoke them.

```js
// app.js
const Koa = require('koa');
const koaBody = require('koa-body');

const app = new Koa();

// Set up body parsing middleware
app.use(koaBody());

// Require the Router we defined in books.js
let books = require('./books.js');

// Use the Router on the sub route /books
app.use(books.routes());

app.listen(3000);
```

Next step is to run the command: `npm run dev` and visit the url `http://localhost:3000/books` to see the following result.

<img src='https://cdn-images-1.medium.com/max/800/1*d-GFucqnhOEIeORSytPH4w.png' />

> _Congratulations! 🎉 You just build your first route using Koa._

Next step is to create a route to fetch a book by its `id`. It is going to use the similar approach as the previous route, plus we see how to extract information from `request.params` object of an incoming request.

```js
// books.js
router.get('/:id', (ctx, next) => {
  let getCurrentBook = books.filter(function (book) {
    if (book.id == ctx.params.id) {
      return true;
    }
  });

  if (getCurrentBook.length) {
    ctx.body = getCurrentBook[0];
  } else {
    ctx.response.status = 404;
    ctx.body = 'Book Not Found';
  }
  next();
});
```

Routing parameters are named segments that are used capture the values specified in the URL. In our case, such as`:id`. Above, we define a routing middleware function that can handle incoming requests from URLs such as `http:localhost:3000/books/103`. Enter this URL in your browser window and you will get the following result.

<img src='https://cdn-images-1.medium.com/max/800/1*-F6g2j_QsvwBjXUdrVsZhw.png' />

In case of when `id` does not exist or is invalid, you have to send an error message with an HTTP status of `404`.

<img src='https://cdn-images-1.medium.com/max/800/1*BKDmJ80xYVoOsVQTNaMiKw.png' />

### Handling a POST request

The last route you are going to build for this demonstration is going to handle `POST` requests.

```js
// books.js

router.post('/new', (ctx, next) => {
  // Check if any of the data field not empty
  if (
    !ctx.request.body.id ||
    !ctx.request.body.name ||
    !ctx.request.body.author
  ) {
    ctx.response.status = 400;
    ctx.body = 'Please enter the data';
  } else {
    let newBook = books.push({
      id: ctx.request.body.id,
      name: ctx.request.body.name,
      author: ctx.request.body.author
    });
    ctx.response.status = 201;
    ctx.body = `New book added with id: ${ctx.request.body.id} & name: ${ctx.request.body.name}`;
  }
  next();
});
```

The `/new` route is used for creating a new book add it into our `books` array. I am using this to mock data and not real database so restarting the application will delete the newly added books. In the above routing middleware, the Koa Context object first checks if any of the data field required in `request.body` is present or not. If one of them is missing, this routing middleware will be terminated and sends back an error to the user.

If everything is fine, this routing middleware accepts the data and returns success message with correct HTTP status of code for creating a new record. To run this URL, I am using `curl` command from my terminal but you can use any REST client such as Postman or Insomnia.

<img src='https://cdn-images-1.medium.com/max/800/1*qbXL75_xqOrtgE0UTXEPPw.png' />

For our all routes to be more descriptive and follow REST API pattern, I have re-written every `ctx.body` object from each routing middleware function. Here is how the complete routing file looks so far.

```js
// books.js
const Router = require('koa-router');

// Prefix all routes with /books
const router = new Router({
	prefix: '/books'
});

let books = [
	{ id: 101, name: 'Fight Club', author: 'Chuck Palahniuk' },
	{ id: 102, name: 'Sharp Objects', author: 'Gillian Flynn' },
	{ id: 103, name: 'Frankenstein', author: 'Mary Shelley' },
	{ id: 104, name: 'Into The Willd', author: 'Jon Krakauer' }
];

// Routes will go here
router.get('/', (ctx, next) => {
	ctx.body = {
		status: 'success',
		message: books
	};
	next();
});

router.get('/:id', (ctx, next) => {
	let getCurrentBook = books.filter(function(book) {
		if (book.id == ctx.params.id) {
			return true;
		}
	});

	if (getCurrentBook.length) {
		ctx.body = getCurrentBook[0];
	} else {
		ctx.response.status = 404;
		ctx.body = {
			status: 'error!',
			message: 'Book Not Found with that id!'
		};
	}
	next();
});

router.post('/new', (ctx, next) => {
	// Check if any of the data field not empty
	if (
		!ctx.request.body.id ||
		!ctx.request.body.name ||
		!ctx.request.body.author
	) {
		ctx.response.status = 400;
		ctx.body = {
			status: 'error',
			message: 'Please enter the data';
    }
	} else {
		let newBook = books.push({
			id: ctx.request.body.id,
			name: ctx.request.body.name,
			author: ctx.request.body.author
		});
		ctx.response.status = 201;
		ctx.body = {
			status: 'success',
			message: `New book added with id: ${ctx.request.body.id} & name: ${
				ctx.request.body.name
			}`
		};
	}
	next();
});

module.exports = router;
```

<img src='https://cdn-images-1.medium.com/max/800/1*R2_CY-WOiEM2pqE-bLQbRg.png' />

This completes the basics of building a REST API using Koa as a Node.js framework. It’s a pretty minimal framework with all the necessary ways to tackle incoming requests and send the response back from the server. Koa also supports ready-made middleware functions to make use for logging, handling errors, testing, compression, and security.

> You can find the complete code used in this tutorial at [this Github repository](https://github.com/amandeepmittal/koa-rest-api-tut)


Building a REST API with Koajs

---
title: 'How to Upload a File with Reactjs and Nodejs'
slug: 'connecting-a-node-js-and-reactjs-example'
date: '2018-06-23'
thumbnail: '/thumbnails/node.png'
tag: 'nodejs'
canonicalUrl: 'https://www.zeolearn.com/magazine/connecting-reactjs-frontend-with-nodejs-backend'
---

![cover](https://i.imgur.com/X7ju8yL.jpg)

> [Originally this article was published on Zeolearn.com](https://www.zeolearn.com/magazine/connecting-reactjs-frontend-with-nodejs-backend)

Uploading Files might seem a task that needs to be conquered especially if you are getting into web development. In this tutorial, simple AJAX based file uploads using Reactjs on front-end and Node.js back-end. This is easy to accomplish with the following technologies since the whole source code will be in one language, JavaScript. In this example, to demonstrate for connecting a Reactjs application with Node.js backend, we will be making the use of a simple file upload example. The topics we will be covering are going to be:

- Setting up a Back-end of our app using `express-generator`
- Using `create-react-app` to scaffold a front-end Reactjs app
- Using `axios` for cross-origin API calls
- Handling POST requests on our server
- Using `express-fileupload`, a promise based library
- Lastly, making a connection between Reactjs and Node.js

### Getting Started

We will be starting without back-end first. We will write a server application with necessary configurations required to accept cross-origin requests and uploading files. First, we need to install `express-generator` which is the official and quickest way to start with an Express back-end application.

```shell
npm install -g express-generator
```

We will install this module globally from our terminal. After installing this global `npm` module, we have an instance of it named `express` to generate our project structure.

```shell
mkdir fileupload-example
express server
cd server
```

When changing the current directory to the project `express` command just scaffolded, we can observe the following structure and files:

<img src='https://cdn-images-1.medium.com/max/800/0*x6livl3bk3Wc8OX6.png' />

To run this backend server on default configuration, we have to install the dependencies mentioned in `package.json` first.

```js
npm install
npm start
```

Express-generator comes with following dependencies. Some of them are essential to use such as `morgan` and `body-parser` and some we can leave out for this project.

```json
"dependencies": {
    "body-parser": "~1.18.2",
    "cookie-parser": "~1.4.3",
    "debug": "~2.6.9",
    "express": "~4.15.5",
    "jade": "~1.11.0",
    "morgan": "~1.9.0",
    "serve-favicon": "~2.4.5"
  }
```

I will be adding two more packages for our configurable back-end application to behave in the way we want to.

```shell
npm install --save cors express-fileupload
```

`cors` provide a middleware function for Express applications to enable various Cross-Origin Resource Sharing options. CORS is a mechanism that allows restricted resources (in our case, API or AJAX requests) on a web page from another domain. It helps a browser and a server to communicate and can be hosted on separate domains. You will understand it more when you will see it in action.

The other module, `express-fileupload` is a bare minimum express middleware function for uploading files. The advantages it has it that it has support for Promises and can handle multiple file uploads.

With these two important packages added as dependencies in our project, we can now start by modifying the default Express back-end in `app.js` file.

```js
const express = require('express');
const path = require('path');
const favicon = require('serve-favicon');
const logger = require('morgan');
const cookieParser = require('cookie-parser');
const bodyParser = require('body-parser');
const cors = require('cors'); // addition we make
const fileUpload = require('express-fileupload'); //addition we make

const index = require('./routes/index');
const users = require('./routes/users');

const app = express();

// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

// uncomment after placing your favicon in /public
//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(cookieParser());

// Use CORS and File Upload modules here
app.use(cors());
app.use(fileUpload());

app.use('/public', express.static(__dirname + '/public'));

app.use('/', index);

// catch 404 and forward to error handler
app.use(function (req, res, next) {
  const err = new Error('Not Found');
  err.status = 404;
  next(err);
});

// error handler
app.use(function (err, req, res, next) {
  // set locals, only providing error in development
  res.locals.message = err.message;
  res.locals.error = req.app.get('env') === 'development' ? err : {};

  // render the error page
  res.status(err.status || 500);
  res.render('error');
});

module.exports = app;
```

In the above code, you would notice that we made some additions. The first addition we did is to import packages `cors` and `express-fileupload` in `app.js` after other dependencies are loaded.

```js
const cors = require('cors'); // addition we make
const fileUpload = require('express-fileupload'); //addition we make
```

Then just after other middleware functions, we will instantiate these two newly imported packages.

```js
// Use CORS and File Upload modules here
app.use(cors());
app.use(fileUpload());
```

Also, we need to allow data coming from a form. For this, we have to enable `urlencoded` options of `body-parser` module and specify a path as to store the image file coming from the client.

```js
app.use(bodyParser.urlencoded({ extended: true }));

// below, also change this to
app.use('/public', express.static(__dirname + '/public'));
```

With this, we can see if our server is working correctly by running:

```shell
npm start
```

If you get the screen below by navigation on port `http://localhost:3000`, it means that our server is running.

<img src='https://cdn-images-1.medium.com/max/800/0*Tgeuf8qKcqzzwfSZ.png' />

Before we move to generate our front-end application, we need to change to port for our backend since front-end application generated using `create-react-app` will also be running on port `3000`. Open `bin/www` file and edit:

```js
/**
 * Get port from environment and store in Express.
 */

// 3000 by default, we change it to 4000

var port = normalizePort(process.env.PORT || '4000');
app.set('port', port);
```

### Setting up Front-end

`create-react-app` is another command line utility that to generate a default Reactjs front-end application.

```shell
create-react-app node-react-fileupload-front-end
```

We will also install the required library we are going to use for making API calls to our backend server.

```shell
yarn add axios
```

`index.js` is the starting point of our application in the `src/` directory. It registers the render function using `ReactDOM.render()` by mounting `App` component. Components are the building blocks in any Reactjs application. This `App` component comes from `src/App.js`. We will be editing this file in our front-end source code.

### File Upload Form

We will be using the HTML `form` element that has an input which provides access to the value, that is the file, using `refs`. `Ref` is a special attribute that can be attached to any component in React. It takes a callback function and this callback will be executed immediately after the component is mounted. It can be also be used on an HTML element and the callback function associated will receive the DOM element as the argument. This way, `ref` can be used to store a reference for that DOM element. That is exactly what we are going to do.

```js
class App extends Component {
  // We will add this part later

  render() {
    return (
      <div className="App">
        <h1>FileUpload</h1>
        <form onSubmit={this.handleUploadImage}>
          <div>
            <input
              ref={ref => {
                this.uploadInput = ref;
              }}
              type="file"
            />
          </div>
          <br />
          <div>
            <input
              ref={ref => {
                this.fileName = ref;
              }}
              type="text"
              placeholder="Enter the desired name of file"
            />
          </div>
          <br />
          <div>
            <button>Upload</button>
          </div>
          <hr />
          <p>Uploaded Image:</p>
          <img src={this.state.imageURL} alt="img" />
        </form>
      </div>
    );
  }
}
```

The `input` element must have the `type="file"` otherwise it would not be able to recognize what type we are using it for. It is similar to the values like `email`, `password`, etc.

The `handleUploadImage` method will take care of the API calls that we need to request to the server. If that call is successful, the local state of our React application will be set to let the user know that the upload was successful. Inside this function, to make the API call, we will be using `axios` library we installed when setting up our front end app.

```js
constructor(props) {
		super(props);

		this.state = {
			imageURL: ''
		};

		this.handleUploadImage = this.handleUploadImage.bind(this);
	}

	handleUploadImage(ev) {
		ev.preventDefault();

		const data = new FormData();
		data.append('file', this.uploadInput.files[0]);
		data.append('filename', this.fileName.value);

		fetch('http://localhost:4000/upload', {
			method: 'POST',
			body: data
		}).then(response => {
			response.json().then(body => {
				this.setState({ imageURL: `http://localhost:4000/${body.file}` });
			});
		});
	}
```

The FormData object lets you compile a set of key/value pairs to send using XMLHttpRequest. It is primarily intended for use in sending form data but can be used independently from forms in order to transmit keyed data. To build a FormData object, instantiating it then appending fields to it by calling its `append()` method like we did above.

<img src='https://cdn-images-1.medium.com/max/800/0*Xa5qBk-hqFkJsTIW.png' />

Since we are not using any styling, our form looks bare minimum and ugly. But you can go ahead and make it look more professional. For brevity, I am going to keep things simple. I recommend you to always enter a file uname, other wise it will store the file on the with `undefined.jpg` name.

### Updating the server to handle AJAX Request

Right now, we do not have in our server code to handle the `POST` request React app makes a request to. We will add the route in our `app.js` in our Express application where the default route is defined.

```js
app.post('/upload', (req, res, next) => {
  // console.log(req);
  let imageFile = req.files.file;

  imageFile.mv(`${__dirname}/public/${req.body.filename}.jpg`, err => {
    if (err) {
      return res.status(500).send(err);
    }

    res.json({ file: `public/${req.body.filename}.jpg` });
    console.log(res.json);
  });
});
```

```shell
npm start
```

This route gets triggered when a request is made to `/upload/`. The callback associated using the route contain `req`, `res` objects and access to `next`, a standard way of defining a middleware function in an Express application. The `req` object has the file and the filename that was uploaded during form submission from the client application. If any error occurs, we return the 500 server error code. Otherwise we return the path to the actual file and console the `response` object to check if everything is work as we expect it.

`.mv` file is promise-based and provided to us by the `express-fileupload` package we installed earlier. Try uploading an image file from the client now. Make sure both the client and server are running from different terminal tabs at this point. If you get a success message like this in your terminal:

```shell
POST /upload 200 98.487 ms - 25
GET /public/abc.jpg 200 6.231 ms - 60775
```

At the same time, the client is requesting to view the file on the front-end with a `GET` HTTP method. That means the route `/upload` from the browser is successfully called and everything is working fine. Once the file is uploaded on the server and it will be sent back to the client to reflect that the user has successfully uploaded the file.

<img src='https://cdn-images-1.medium.com/max/800/0*cWOzuejEhEOtSQV8.png' />

You can find the complete code for this example at [**FileUpload-Example**](https://github.com/amandeepmittal/fileupload-example) Github Repository.


How to Upload a File with Reactjs and Nodejs

---
title: 'Designing a REST API with Node.js and MongoDB Atlas'
date: '2018-01-22'
slug: 'designing-a-rest-api-with-node-js-and-mongodb-atlas'
thumbnail: '/thumbnails/node.png'
tag: 'nodejs'
canonicalUrl: 'https://www.zeolearn.com/magazine/designing-a-rest-api-with-nodejs-and-mongodb-atlas'
---

![cover](https://i.imgur.com/5rvcM6q.png)

> [Originally Published at Zeolearn.com](https://www.zeolearn.com/magazine/designing-a-rest-api-with-nodejs-and-mongodb-atlas)

Nodejs is a remarkable technology for the fulfilling and developing web applications. Being open source and in the past few years, we have seen it rising. It might be a bit different from other traditional web technologies in terms of learning curve but I urge you to stick with it if you are getting in to web development and have opted [Node.js](https://www.zeolearn.com/node-js-training) ecosystem. In this tutorial, I will walk you through the basics of REST API design with using Node.js ecosystem.

I’d love if you follow along with me with snippets of code that are in continuation below. Before we begin, I want you to understand what is REST and how its beneficial to use it with server side JavaScript.

**What is REST?**

REST is an acronym for Representation State Transfer and is an industry standard (till Graphql conquers the world) for defining how an API and its endpoint (routes) should communicate with the server code of your web application. A REST API consumes HTTP methods such GET, POST, etc. with endpoints that are nothing but URLs that you can use to fetch some data or update/create new data in the database. In his [whitepaper](https://www.ics.uci.edu/%7Efielding/pubs/dissertation/rest_arch_style.htm), Roy Fielding described the paradigms and practical use of REST. I am going to summarise points what he exactly says in that paper. The basis of a RESTful API depends on below:

- Client-Server
- Stateless
- Uniform Interface
- Cacheable
- Layered System
- Code-On-Demand style

To read about them in detail, please see Roy Fielding’s paper on the same [here](https://www.ics.uci.edu/%7Efielding/pubs/dissertation/rest_arch_style.htm).

Applications that make use of REST APIs perform four basic operations that are known as CRUD.

- C: Creating data
- R: Reading data
- U: Updating data
- D: Deleting/removing data​

**Prequisites**

There are some things we need to go through this tutorial successfully.

- [Node.js](https://nodejs.org/) installed
- Access to [MongoDB](https://www.mongodb.com/), a NoSQL database on your local machine or cloud
- IDE/Editor
- [Postman](https://www.getpostman.com/), a REST client to test our API’s endpoints

If you do not have [MongoDB](https://www.zeolearn.com/mongodb-training) installed on your local mahcine, do not worry. In the next step I am going walk you through setting up a free tier of MongoDB in cloud.

**Consuming MongoDB in Cloud**

For the sake of brevity, I am going to use [MongoDB Atlas](https://www.mongodb.com/cloud/atlas) a service that you can use to store data for your sample application. You can also use other popular database-as-a-service [Mlab](https://mlab.com/) without any hassle.

I already have an account setup, so I’d suggest you to sign up on mongodb atlas’ site with your email. Once you have logged in, you will get the below screen:

<img src='https://cdn-images-1.medium.com/max/1200/0*K-3GHE1axS48h85u.png' />

At this point, you can either take time to explore what MongoDB Atlas is or you can skip and together we will setup a Sandbox for our sample application. Click on the “New Project” button on the right side of the web page.

<img src='https://d6vdma9166ldh.cloudfront.net/media/images/b7a62c69-71a3-4678-89d3-276832706d9a.png' />

<img src='https://d6vdma9166ldh.cloudfront.net/media/images/e910bddb-5e50-4d0a-aaa4-d7d36939e491.png' />

Then you will be prompted to fill in the details. See screenshots below, enter a name for your project and click “next” and then click “Create Project”. Per one account in MongoDB Atlas, you will get one free tier/cluster. Follow the steps below to setup one.

<img src='https://d6vdma9166ldh.cloudfront.net/media/images/71db2429-c41d-48bb-a9e1-21281f5cfbcb.png' />

Click on the Build new Cluster button.

<img src='https://d6vdma9166ldh.cloudfront.net/media/images/145b86aa-63c1-45e4-ae53-f92bdf852562.png' />

Scroll down a bit, and then select the free tier M0. Per free cluster, we get 512mb of space. More than enough for what we need for this tutorial.

<img src='https://d6vdma9166ldh.cloudfront.net/media/images/9c0385c7-e282-4fd7-a266-487425841b0e.png' />

Then enter username and password for an Admin connection that we will use to connect to our database through our application. Make sure you remember both username and password and password must a bit strong. Lastly, click on confirm and deploy and the service will take at least 10 minutes to setup a database cluster.

<img src='https://d6vdma9166ldh.cloudfront.net/media/images/17807485-9b69-43c4-9d83-e9c7aa5abb1f.png' />

That’s it. The database is now ready to be used. Now let us setup our application.

## Configuring Server Side

From your terminal:

```shell
# to initalise our node project, we need a package.json file
npm init --yes

# install express framework
npm install -S express mongoose body-parser
```

Mongoose is client that helps us connect and communicate with our database. BodyParser is needed as a middleware to parse the data to be sent through HTTP requests. Express is de facto standard and is one of the reason we will be using it.

## Running the Server

Let’s first the nitty gritties of our server. Create a file app.js in the root directory with the following code:

```js
// app.js

const express = require('express');

const app = express();

const port = process.env.PORT || 3301;

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});
```

The app is an object provided by Express API for the developer to communicate with the application and bootstrap a server. In Express application, it is that easy to write bare minimum server. There are different ways you can setup your server but the basics will remain same. For brevity, I am using app.js but you can take a look at Express generator that scaffolds a structure in a quick manner.

Now, add an npm script to package.json file to test and start our server.

```json
"scripts": {
    "start": "node app.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
```

From terminal, npm run start or npm start and you should see the success message without any error.

<img src='https://d6vdma9166ldh.cloudfront.net/media/images/180b1cc9-7178-44ff-8319-8747548ad6cd.png' />

## Setting up Mongoose

Mongoose is an ORM (Object Relational Mapper) that is used to interact with MongoDB database instance. We have already setup our instance using MongoDB atlas and installed mongoose as the project dependency. So let us start by defining a schema. Though, NoSQL database are schema less it is consider a best practice to define a schema to give some structure to the data that will be stored in our database.

A typical Express application follows MVC (model-view-controller) model to define a directory structure and that is what we are going to do. Create a directory models and inside it a file Task.js with following code:

```js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const TaskSchema = new Schema({
  taskName: {
    type: String,
    required: true
  },
  createdOn: {
    type: Date,
    default: Date.now
  }
});

module.exports = mongoose.model('Tasks', TaskSchema);
```

This schema does look like a JSON data and that is exactly what MongoDB stores or it appears to be for the developer to. Original format of data stored in MongoDB is called BSON (stands for \_Binary JSON) and it converts JSON to BSON is handled by the dtabase itself. You can read more about it here in the official docs.

Mongoose allows us to create define a schema for our the document to be stored in our application via inside the application just by defining a model. You can think it of as a blueprint. All your tasks in the database collection, will have taskName and createdOn value. Lastly, we bind our schema with the name of our collection Tasks. The collection in MongoDB our by default plural since they tend to contain a number of documents. taskName and createOn are called fields in terms of MongodB terminology. Together they constitute a document inside the collection Tasks and each document will have a unique ID to identify them as a record in the database. This unique ID is stored in MongoDB database by default and is a 12 byte value made up of different things related to our database. You can read more about how this unique ID created by the database [here](https://docs.mongodb.com/manual/reference/method/ObjectId/).

## Connecting Database To our Application

Before we further go with the controller part, let us first connect the database to our server and see if everything is working A-OK.

I like to store all my application’s configuration in a config directory. Create a db.js file inside that directory.

```js
const mongoose = require('mongoose');

const dbURI =
  'mongodb://newuser:myNewPassword@cluster0-shard-00-00-gibou.mongodb.net:27017,cluster0-shard-00-01-gibou.
  mongodb.net:27017,cluster0-shard-00-02-gibou.mongodb.net:27017/test?ssl=true&replicaSet=Cluster0-shard-0&
  authSource=admin';

const options = {
  reconnectTries: Number.MAX_VALUE,
  poolSize: 10
};

mongoose.connect(dbURI, options).then(
  () => {
    console.log('Database connection established!');
  },
  err => {
    console.log('Error connecting Database instance due to: ', err);
  }
);

// require any models

require('../models/Task');
```

To get the connection string you have to follow the following steps:

First click on the connect button on your MongoDB Atlas page the following screen will prompt.

<img src='https://d6vdma9166ldh.cloudfront.net/media/images/1ed9e590-2aad-47e2-989b-95bcad69e339.png' />

Then, click “Allow Access from Anywhere” to white list our server URL.

<img src='https://d6vdma9166ldh.cloudfront.net/media/images/1434b0f6-7bde-4e3c-8a13-68fe382894e2.png' />

Then, copy the URI string for version 3.4:

<img src='https://d6vdma9166ldh.cloudfront.net/media/images/d7458a10-1220-4c67-ac1f-eafcce4190b4.png' />

And enter the username and password you entered during the setup of our instance in place of `username:<password>` and remove the placeholders `<>`. I am using options variable to spike your curiosity such that you will explore about it and the power of mongoose. You can read more about connection options that provided by mongoose here.

Lastly, we use `mongoose.connect()` to establish a connection between server and the database instance and handle it gracefully using a promise. But wait, the connection won't be establish until we connect this config file with our application and for that we need to require this file in our main app.js file.

```js
const express = require('express');

// db instance connection
require('./config/db');

const app = express();

const port = process.env.PORT || 3301;

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});
```

Now restart our server from command line and you will see the success prompt:

<img src='https://d6vdma9166ldh.cloudfront.net/media/images/2f7929df-6a92-4823-b48d-a7e3cffe86ee.png' />

Do you notice one thing here? For every change we make in our application, we have to restart our server from command line and to ignore this tedious process we can make use of a powerful utility called nodemon developed by Remy Sharp.

## Enter Nodemon

After we setup nodemon I promise we will be focusing on code of our API but making use of this utility will save tons of amount of time when working on an API yourself. Let's install nodemon as a dev dependency first.

```shell
npm install -D nodemon
```

After installing it, change the start script in package.json file to:

```json
npm install -D nodemon
```

Now if we start our server, nodemon will monitor for any changes made and restart the server when necessary on its own. We don’t have to worry about that anymore.

Back to our API code.

## Setting up Business Logic

To setup routes or endpoints of our application, we need to include `body-parser` in our `app.js`.

```js
const express = require('express');
const bodyParser = require('body-parser');

// db instance connection
require('./config/db');

const app = express();

const port = process.env.PORT || 3301;
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});
```

BodyParser parses incoming HTTP requests as middleware under req.bodybefore routes or API have access to them and perform any further actions on them. Very useful and essential step when using forms in a web application.

To define the business logic of our APIs endpoints, we are going to create a separate file TaskController.js under directory controllers.

For our API routes (I am going to call them route for brevity but they are same as endpoints) we are going to five different actions or operations or way to handle incoming requests. These tasks will cover our CRUD operations. Each route will have at least two parameters: req and res.

- `req`: request, useful when creating or or updating a new task and read data from the body (this where BodyParser works like a charm).
- `res`: response to fulfill that incoming request with response.

```js
const Task = require('../models/Task');

exports.listAllTasks = (req, res) => {
  Task.find({}, (err, task) => {
    if (err) {
      res.status(500).send(err);
    }
    res.status(200).json(task);
  });
};

exports.createNewTask = (req, res) => {
  let newTask = new Task(req.body);
  newTask.save((err, task) => {
    if (err) {
      res.status(500).send(err);
    }
    res.status(201).json(task);
  });
};

exports.readTask = (req, body) => {
  Task.findById(req.params.taskid, (err, task) => {
    if (err) {
      res.status(500).send(err);
    }
    res.status(200).json(task);
  });
};

exports.updateTask = (req, res) => {
  Task.findOneAndUpdate(
    { _id: req.params.taskid },
    req.body,
    { new: true },
    (err, task) => {
      if (err) {
        res.status(500).send(err);
      }
      res.status(200).json(task);
    }
  );
};

exports.deleteTask = (req, res) => {
  Task.remove({ _id: req.params.taskid }, (err, task) => {
    if (err) {
      res.status(404).send(err);
    }
    res.status(200).json({ message: 'Task successfully deleted' });
  });
};
```

This completes our controller. The controller is the business logic that binds our endpoints/routes that we are going to define soon to what action or operation they will perform on an incoming request.

Each of the above operation when sending a response does send HTTP status code which clearly determines whether the incoming request was fulfilled or was there an error. This the part of REST paradigm and is best practice. You can read more about this [here](http://www.restapitutorial.com/lessons/httpmethods.html).

## Setting up Routes

```js
const express = require('express');
const bodyParser = require('body-parser');
const taskController = require('./controllers/TaskController');

// db instance connection
require('./config/db');

const app = express();

const port = process.env.PORT || 3301;
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());

// API ENDPOINTS

app
  .route('/tasks')
  .get(taskController.listAllTasks)
  .post(taskController.createNewTask);

app
  .route('/tasks/:taskid')
  .get(taskController.readTask)
  .put(taskController.updateTask)
  .delete(taskController.deleteTask);

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});
```

We setup our API’s endpoints by first requiring the controller and then passing on a specific endpoint it using the correct HTTP method. The endpoints can be elaborated as:

- POST /tasks to create a new task

- GET /tasks to get a list of all tasks

- GET /tasks/:taskid to get a specific task by its unique id(the one mongodb creates for us)

- PUT /tasks/:taskid to modify existing task

- DELETE /tasks/:taskid to delete an existing task from our database instance

As a best practice, APIs routes should always use nouns for identifying resource.

Now let us test our API routes using Postman.

## Testing our API

Open postman and type http://localhost:3301/tasks and selct the POSTmethod. We will first use the POST request to create a new task since our database is currently empty and does not have any data. Use body to fill in the data which follows same schema we defined in our model.

<img src='https://d6vdma9166ldh.cloudfront.net/media/images/36858c3c-1a16-4a84-9821-804b2b5435dc.png' />

Hitting the send button should respond with 200 status and the data we created structured exactly like our schema in JSON format.

<img src='https://d6vdma9166ldh.cloudfront.net/media/images/eb03c175-41f7-4bc0-859a-0a007086af91.png' />

Similarly, we can test other endpoints of our API. Such as getting all tasks (so far we have so it will give only one task that we just created):

<img src='https://d6vdma9166ldh.cloudfront.net/media/images/b1300d7d-6493-43b0-8e10-e4642e57e421.png' />

Getting the task by its \_id:

<img src='https://d6vdma9166ldh.cloudfront.net/media/images/86018023-045d-4cc5-8db4-cead1261a6a4.png' />

Try updating the task or removing it by using the endpoints we defined earlier and changing the HTTP method from Postman yourself.

Hope you learned something valuable by reading this article.

You can find the complete code at this [Github repository](https://github.com/amandeepmittal/nodejs-restapi).


Designing a REST API with Node.js and MongoDB Atlas

---
title: 'Tips for Creating Nodejs REST APIs'
date: '2017-11-22'
thumbnail: '/thumbnails/node.png'
slug: 'tips-for-creating-node-js-rest-apis'
tag: 'nodejs'
canonicalUrl: 'https://codeburst.io/tips-for-creating-node-js-rest-apis-dfa0b2adb39c'
---

> [Originally Published at Codeburst.io](https://codeburst.io/tips-for-creating-node-js-rest-apis-dfa0b2adb39c)

In this article, I am going to offer you some tips for writing REST APIs in Nodejs for a production level application. Writing RESTful APIs with Nodejs is one of the most popular use case using the JavaScript server side platform.

## Use HTTP Methods

CRUD operations are basis of any API. In most applications you will be either:

- Creating new records
- Display them on a front end client aka reading a record from the database
- Updating an existing record
- Or deleting an existing record

Record here stands for anything that goes into the database. Afterall, an API is just way a to communicate from the user interface to database.

To develop an API that consist of CRUD operations, you must consider using correct HTTP method with the suitable endpoint:

- `POST /record` for creating a new record
- `PUT` or `PATCH /record/:id` for updating an existing record
- `GET /record/:id` getting a single record
- `GET /record` getting a list of all records
- `DELETE /record/:id` deleting a single existing record

## Use HTTP response status codes

You must consider using an HTTP status code if anything fails when serving a request.

- `2xx` if everything works fine
- `3xx` if record was moved
- `4xx` request fails due to client error
- `5xx` request fails due to server error (or API)

You can refer to either of these links for a detailed error code and message along with it.

- [HTTP Status Codes](http://www.restapitutorial.com/httpstatuscodes.html)
- [Mozilla HTTP Response Status Codes](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status)

If using Express, most commonly framework used with Nodejs to create APIs, consider writing your code in this format:

```js
// in case 5xx
res.status(500).send({ error: 'Internal Server Error.' });

// in case 4xx, unauthorized
res.status(401).send({ error: 'Unauthorized. Please check.' });
```

## Consider Creating an API Documentation

Working as a team or even if individual and having a documented API, in the end will benefit all. Following open-source API documentation projects can help in this case:

## Avail options for building APIs in Nodejs

There are quite a number of frameworks that you can choose from to build your next RESTful API with Nodejs.

Express, Koa, Hapi all can be used for creating browser based applications but Restify allows you to focus on building a RESTful service.


Tips for Creating Nodejs REST APIs

---
date: '2017-09-10'
title: 'Remove node_modules Recursively'
thumbnail: '/thumbnails/node.png'
slug: 'remove-node-modules-recursively'
tag: 'nodejs'
canonicalUrl: 'https://amanhimself.dev/blog/remove-node-modules-recursively/'
---

`node_modules` tend to take a lot of space in your local system especially if you work with Node.js or related frameworks (such as client side frameworks: React or Angular). They are the part and parcel of modern day JavaScript applications and workflow.

Each day `npm` registry is getting around [350 million downloads](https://twitter.com/seldo/status/864298310785310720) daily, at the current time of writing this post. That's almost 2.2 billion downloads per week and you can take the calculation further.

Here’s Laurie Voss [(@seldo)](https://twitter.com/seldo) [tweet](https://twitter.com/seldo/status/864298310785310720), sharing the aforementioned details:

<img src='https://cdn-images-1.medium.com/max/800/0*HHMm699bdI2QMoOy.jpg' />

Nonetheless, after all your efforts are paid of and everything is deployed and is over cloud, either Github or some deployment service you or your client prefers, I think it will be generous to remove `node_modules` that take useful space on our local machines (especially, Mac users with limited GigaBytes of SSD).

There’s a simple command that you can run in your terminal either in a folder or from the root.

```shell
find . -name "node_modules" -exec rm -rf '{}' +
```

This will delete `node_modules` folder in every local repository/directory that's on your system so take precaution or exclude those projects that you are currently working on.

However, don’t panic. Everything can be back to normal just by going into the project’s directory and running package installing command:

```shell
npm install
```

I have used this command earlier today it saved me up to 9 GB of space from local system over several projects that I am currently not working or are already on [Github](https://github.com/amandeepmittal).

I even replaced `node_modules` with `bower_components` to do the same thing:

```shell
find . -name "bower_components" -exec rm -rf '{}' +
```


Remove node_modules Recursively

---
date: '2017-09-10'
title: 'Setup Nodemon to auto restart Nodejs application server'
thumbnail: '/thumbnails/node.png'
slug: 'setup-nodemon-to-auto-restart-nodejs-application-server'
tag: 'nodejs'
canonicalUrl: 'https://medium.com/hackernoon/setup-nodemon-to-auto-restart-nodejs-application-server-8d8993b7dfd9'
---

Manually restarting Node.js application is a tiring and tedious job. [Nodemon](https://www.npmjs.com/package/nodemon) is the best solution available to autorestart a nodejs app server in development mode.

### Step 1

Organize the source directory `src` and initiate it with an `app.js` or `index.js` or `server.js` or any other convention you use to bootstrap a Node.js server.

Update the `package.json` file accordingly by adding a `start` script.

```json
{
  "name": "nodemon-auto-restart",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "node src/index.js"
  },
  "keywords": [],
  "author": "Aman Mittal <amandeepmittal@live.com> (http://amandeepmittal.github.io/)",
  "license": "MIT"
}
```

### Step 2

Add `express` or any other framework as dependency to bootstrap a minimal server.

Code for a minimal server:

```js
'use strict';

const express = require('express');
const app = express();

app.use('/', (req, res) => {
  res.status(200).send('Hello World!');
});

app.listen(3000);
```

In first terminal window start the server:

```shell
$ npm run start
> node src/index.js
```

In second terminal window, request the url to test if the api is working and to see the response message:

```shell
$ curl -X GET http://localhost:3000/
Hello World!
```

Now if I change the response message, I have to restart the server to get the desired result:

```js
app.use('/', (req, res) => {
  res.status(200).send('Lorem Ipsum');
});
```

Use `Ctrl + C` to stop the currently running server and restart it by using the same command before: `npm run start`.

Using the curl command again from terminal window we get the desired result:

```shell
curl -X GET http://localhost:3000/
Lorem Ipsum
```

This whole process is repetitive will slow your development of any package or application. Better solution is to use `nodemon`.

### Step 3

Add nodemon as `devDependency`:

```shell
$ npm i -D nodemon
```

```json
{
  "name": "nodemon-auto-restart",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "node src/index.js"
  },
  "keywords": [],
  "author": "Aman Mittal <amandeepmittal@live.com> (http://amandeepmittal.github.io/)",
  "license": "MIT",
  "dependencies": {
    "express": "4.15.3"
  },
  "devDependencies": {
    "nodemon": "1.11.0"
  }
}
```

### Step 4

Make another script `dev` under npm scripts in `package.json` file:

```json
{
  "scripts": {
    "start": "node src/index.js",
    "dev": "nodemon --watch src src/index.js"
  }
}
```

Now run `$ npm run dev` and request using curl command, we will see the last familiar result:

```shell
curl -X GET http://localhost:3000/
Lorem Ipsum
```

If I change the response message in `index.js` file back to `Hello World`, this time I don't I have to restart the server since `nodemon` is watching for the changes using inside the src directory, through its `--watch`parameter. If I use the curl command again, the result is familiar with the update:

```shell
curl -X GET http://localhost:3000/
Hello World
```

One can verify by observing the log messages in the terminal window where nodemon is running:

```shell
$ npm run dev

> nodemon-auto-restart@1.0.0 dev /Users/amandeepmittal/github/nodemon-auto-restart
> nodemon --watch src src/index.js

[nodemon] 1.11.0
[nodemon] to restart at any time, enter `rs`
[nodemon] watching: /Users/amandeepmittal/github/nodemon-auto-restart/src/**/*
[nodemon] starting `node src/index.js`
[nodemon] restarting due to changes...
[nodemon] starting `node src/index.js`
```

To stop the nodemon process, use `Ctrl + C`.

Full Source at [this Github Repository](https://github.com/amandeepmittal/nodemon-auto-restart).

[Originally Published at Hackernoon.com](https://medium.com/hackernoon/setup-nodemon-to-auto-restart-nodejs-application-server-8d8993b7dfd9)


Setup Nodemon to auto restart Nodejs application server

---
title: 'What’s New in npm 5?'
date: '2017-08-24'
thumbnail: '/thumbnails/node.png'
slug: 'whats-new-in-npm-5'
tag: 'nodejs'
canonicalUrl: 'https://amanhimself.dev/blog/whats-new-in-npm-5/'
---

In May, in the very last week, [**npm**](https://npmjs.com/) announced the new major release for the JavaScript package manager. **5.0.0**, hopefully, will be shipped with upcoming version of [**Nodejs**](https://nodejs.org/en/) **(>=8.0.0)**as well. It seems a big step towards providing better tooling with significantly improved performance as quite a lot of developers made a switch to `yarn`, just because it could download the packages from the `npm` registery at a faster rate. However, this point is debatable, so let’s not get into that.

## A Peek at Major Changes

Some of the major changes which I want to hightlight in this article and am eagerly looking forward to are:

- `npm will --save` is available by default now. See the [demo](https://twitter.com/maybekatz/status/859229741676625920) with your own eyes.
- Running `npm` while offline will no longer insist on retrying network requests. npm will now immediately fall back to cache if possible, or fail.
- `--cache-min` and `--cache-max` have been deprecated, so, existing npm caches will no longer be used.
- A new `--prefer-offline` option will make npm skip any conditional requests for stale cache data, and only hit the network if something is missing from the cache.
- A new `--prefer-online` option that will force npm to revalidate cached data, ignoring any staleness checks, and refreshing the cache with revalidated, fresh data.
- A new `--offline` option will force npm to use the cache or exit. It will error with an `ENOTCACHED` code if anything it tries to install isn’t already in the cache.
- A standardised lockfile feature is available by default and will be for cross-package-manager compatibility (`package-lock.json`), and a new format and semantics for shrinkwrap.
- Downloads for large packages are streamed in and out of disk. npm is now able to install packages of any size without running out of memory.
- Last, it’s a bit faster. [Demo here](https://twitter.com/maybekatz/status/865393382260056064?ref_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed&ref_url=https%3A%2F%2Fcdn.embedly.com%2Fwidgets%2Fmedia.html%3Ftype%3Dtext%252Fhtml%26key%3Da19fcc184b9711e1b4764040d3dc5c07%26schema%3Dtwitter%26url%3Dhttps%253A%2F%2Ftwitter.com%2Fmaybekatz%2Fstatus%2F865393382260056064%26image%3Dhttps%253A%2F%2Fi.embed.ly%2F1%2Fimage%253Furl%253Dhttps%25253A%25252F%25252Fpbs.twimg.com%25252Fprofile_images%25252F848625085942349824%25252FBZtSBqtV_400x400.jpg%2526key%253Da19fcc184b9711e1b4764040d3dc5c07)

Hopefully, they update their docs quickly with this new update and more users like me will be able to switch or access much of these key features. For detailed look into npm5’s features have a look at their [official blog post](http://blog.npmjs.org/post/161081169345/v500) in which they have listed every other breaking change coming with the new release.

To start using the latest version of npm, you can in your terminal window or preferable shell:

```shell
npm install -g npm@next

# Or

npm install -g npm@latest
```


What’s New in npm 5?

---
title: 'Converting a Buffer to JSON and Utf8 Strings in Nodejs'
date: '2017-08-10'
thumbnail: '/thumbnails/node.png'
slug: 'converting-a-buffer-to-json-and-utf8-strings-in-nodejs'
tag: 'nodejs'
canonicalUrl: 'https://amanhimself.dev/blog/converting-a-buffer-to-json-and-utf8-strings-in-nodejs'
---

Nodejs and browser based JavaScript differ because Node has a way to handle binary data even before the ES6 draft came up with `ArrayBuffer`. In Node, `Buffer` class is the primary data structure used with most I/O operations. It is a raw binary data that is allocated outside the V8 heap and once allocated, cannot be resized.

Before Nodejs v6.0, to create a new buffer you could just call the constructor function with `new` keyword:

```js
let newBuff = new Buffer('New String');
```

To create a new buffer instance, in latest and current stable releases of Node:

```js
let newBuff = Buffer.from('New String');
```

The `new Buffer()` constructor have been deprecated and replaced by separate `Buffer.from()`, `Buffer.alloc()`, and `Buffer.allocUnsafe()` methods.

More information can be read through [**official documentation**](https://nodejs.org/api/buffer.html).

### Convert a Buffer to JSON

Buffers can convert to JSON.

```js
let bufferOne = Buffer.from('This is a buffer example.');
console.log(bufferOne);

// Output: <Buffer 54 68 69 73 20 69 73 20 61 20 62 75 66
// 66 65 72 20 65 78 61 6d 70 6c 65 2e>

let json = JSON.stringify(bufferOne);
console.log(json);

// Output: {"type":"Buffer","data":[84,104,105,115,32,105,
// 115,32,97,32,98,117,102,102,101,114,32,101,120,97,109,
// 112,108,101,46]}
```

The JSON specifies that the type of object being transformed is a `Buffer`, and its data.

### Convert JSON to Buffer

```js
let bufferOriginal = Buffer.from(JSON.parse(json).data);
console.log(bufferOriginal);

// Output: <Buffer 54 68 69 73 20 69 73 20 61 20 62 75 66
// 66 65 72 20 65 78 61 6d 70 6c 65 2e>
```

### Convert Buffer to Utf-8 String

```js
console.log(bufferOriginal.toString('utf8'));

// Output: This is a buffer example.
```

`.toString()` is not the only way to convert a buffer to a string. Also, it by defaults converts to a utf-8 format string.

The other way to convert a buffer to a string is using `StringDecoder` core module from Nodejs API.


Converting a Buffer to JSON and Utf8 Strings in Nodejs

---
date: '2017-07-02'
title: 'Setting up MEAN Stack with Webstorm'
thumbnail: '/thumbnails/node.png'
slug: 'setting-up-mean-stack-with-webstorm'
tag: 'nodejs'
canonicalUrl: 'https://amanhimself.dev/blog/setting-up-mean-stack-with-webstorm/'
---

Ever since I got interested in Node.js and started learning to program in JavaScript, both the programming language and the server side platform have been most relevant to me. Due them, I have made my first PR to an open source project on Github, heck, I even built one of my own using them (_see_ [_#100DaysOfCode_](https://github.com/freeCodeCamp/100DaysOfCode-twitter-bot)) which currently has more than 6 people actively contributing and enhancing it.

With Node.js, from quickly building server side application to build fullstack application is not much of a hassle. There are two important solutions to this:

- MEAN Stack
- Meteor.js

### MEAN Stack

MEAN Stack is the used to create complete web development solutions. With JavaScript it’s base, it has lot of advantages to offer and the important of all is one programming language both on server and client side. No context switching. A perfect fullstack solution for me personally.

MEAN is an acronym for MongoDB, ExpressJS, AngularJS, and Node.js. So instead of learning four different programming languages, you just need to know JavaScript.

### Setup MEAN Stack in Webstorm

I am sharing a video here which shows on how to get started with MEAN using JetBrain’s Webstorm (_A JavaScript IDE_) by [John Lindquist](https://www.youtube.com/watch?feature=player_embedded&v=JnMvok0Yks8).


Setting up MEAN Stack with Webstorm

---
date: '2017-06-20'
title: 'How to paginate records in MySQL using Sequelize and Nodejs'
thumbnail: '/thumbnails/node.png'
slug: 'paginate-records-in-mysql-using-sequelize-and-nodejs'
tag: 'nodejs'
canonicalUrl: 'https://medium.com/hackernoon/how-to-paginate-records-in-mysql-using-sequelize-and-nodejs-a3465d12aad5'
---

Often at times, I find my self struggling with Sequelize to find a direct answer for my query. Recently, I have been working on a fullstack application in which there was a basic requirement of paginating results from backend (REST API) to the frontend. I struggled for two reasons. Firstly, coming from NoSQL background it’s hard to grasp SQL DBs. Second reason being is Sequelize documentation does not provide a clear and direct solution to this very basic abstraction. Lot of people assume things in the world of SQL databases.

Thus, in this post we will be talking about a basic paginating module using Sequelize, MySQL and Node.js. I am using you have some tables and records inside your MySQL database. To setup a new app and making database connection, read my post on [**Getting started with Sequelize**](https://hackernoon.com/getting-started-with-sequelize-for-nodejs-applications-2854c58ffb8c)**.**

### Defining a Model

I am directly jumping on `user` model definition:

```js
'use strict';
module.exports = function (sequelize, DataTypes) {
  var user = sequelize.define(
    'user',
    {
      id: {
        allowNull: false,
        autoIncrement: true,
        primaryKey: true,
        type: DataTypes.INTEGER
      },
      username: DataTypes.INTEGER,
      first_name: DataTypes.STRING,
      last_name: DataTypes.STRING,
      date_of_birth: DataTypes.STRING,
      created: DataTypes.INTEGER,
      updated: DataTypes.INTEGER
    },
    {
      timestamps: false,
      freezeTableName: true,
      underscore: true
    }
  );
  return user;
};
```

I am using that we a table that contains hundred of user records that we want to display on an web application, say in the admin panel, and we want to show just 50 records at once.

In the `api/user.js` I am defining an endpoint `/:page` that will fetch number of results we need from the database.

```js
router.get('/:page', (req, res) => {
  let limit = 50; // number of records per page
  let offset = 0;
  db.user
    .findAndCountAll()
    .then(data => {
      let page = req.params.page; // page number
      let pages = Math.ceil(data.count / limit);
      offset = limit * (page - 1);
      db.user
        .findAll({
          attributes: ['id', 'first_name', 'last_name', 'date_of_birth'],
          limit: limit,
          offset: offset,
          $sort: { id: 1 }
        })
        .then(users => {
          res
            .status(200)
            .json({ result: users, count: data.count, pages: pages });
        });
    })
    .catch(function (error) {
      res.status(500).send('Internal Server Error');
    });
});
```

`findAndCountAll` is the model for searching multiple records in the database and it returns both the data required and the count of elements in that table. The above query will get 50 user records at once until the next page is called to fetch the next 50 records. `limit` and `offset` are required in queries related to pagination in which `limit` fetches the number of rows based on the query whereas `offset` is used to skip the number of rows in the database table.

> [Originally Published at Hackernoon.com](https://medium.com/hackernoon/how-to-paginate-records-in-mysql-using-sequelize-and-nodejs-a3465d12aad5)


How to paginate records in MySQL using Sequelize and Nodejs

---
title: 'Getting Started with Sequelize for Nodejs Applications'
date: '2017-05-30'
thumbnail: '/thumbnails/node.png'
slug: 'getting-started-with-sequelize-for-nodejs'
tag: 'nodejs'
canonicalUrl: 'https://medium.com/hackernoon/getting-started-with-sequelize-for-nodejs-applications-2854c58ffb8c'
---

> [Originally Published at Hackernoon.com](https://medium.com/hackernoon/getting-started-with-sequelize-for-nodejs-applications-2854c58ffb8c)

### Introduction to ORM

ORM or Object Relation Mapping is a process of mapping between objects and relation database systems. An ORM acts like an interface between two system. ORM provide advantages for developers from basic ones like saving time and effort and rather focusing on business logic. The code is robust instead of redundant. ORM helps in managing queries for multiple tables in an effective manner. Lastly, an ORM (like [sequelize](http://docs.sequelizejs.com/en/v3/)) is capable to connect with different databases (which comes in handy when switching from one database to another).

### Getting Started with Sequelize

[Sequelize](https://github.com/sequelize/sequelize) is a promise-based ORM for Node.js. Sequelize is easy to learn and has dozens of cool features like synchronization, association, validation, etc. It also has support for PostgreSQL, MySQL, MariaDB, SQLite, and MSSQL. I am assuming you have some form of SQL database service started on your machine. I am currently using MySQL.

### Installation

Sequelize is available via npm.

```shell
$ npm install --save sequelize

# And one of the following:
$ npm install --save pg pg-hstore
$ npm install --save mysql // For both mysql and mariadb dialects
$ npm install --save sqlite3
$ npm install --save tedious // MSSQL
```

### Setting up a Connection

Sequelize does setup a connection between the rest api/application and your SQL database. To setup basic connection between the two:

```js
const sequelize = new Sequelize('database', 'username', 'password', {
  host: 'localhost',
  //choose anyone between them
  dialect: 'mysql' | 'mariadb' | 'sqlite' | 'postgres' | 'mssql',

  // To create a pool of connections
  pool: {
    max: 5,
    min: 0,
    idle: 10000
  },

  // For SQLite only
  storage: 'path/to/database.sqlite'
});
```

### How do I setup my Sequelize Connection?

For the sake brevity, I like to divide code into modules. After all, the Unix philosophy of [_one program/module should do one thing_](https://amandeepmittal.github.io/blog/2017/04/05/The-Node-Way-Philosophy-of-a-Platform/) is major part of the philosophy behind writing code in JavaScript (and using Node.js as a server side platform) these days.

I start with `config.json`/`config.js` file in the root of my application/api folder in which I define the general constraints needed to setup the connection with database:

```json
{
  "development": {
    "username": "root",
    "password": "root",
    "database": "articles",
    "host": "localhost",
    "dialect": "mysql"
  },
  "test": {
    "username": "root",
    "password": "root",
    "database": "articles",
    "host": "127.0.0.1",
    "dialect": "mysql"
  },
  "production": {
    "username": "root",
    "password": "root",
    "database": "articles",
    "host": "127.0.0.1",
    "dialect": "mysql"
  }
}
```

You can do this in your `.env` file if you like to follow that pattern. For more info on this see `[dotenv](https://www.npmjs.com/package/dotenv)`.

After defining the configuration variables, in my `models/` folder or where I define schema of tables in the database at application level, I create the connection in an `index.js` file:

```js
'use strict';

const fs = require('fs');
const path = require('path');
const Sequelize = require('sequelize');
const basename = path.basename(module.filename);
const env = process.env.NODE_ENV || 'development';
const config = require(__dirname + '/config.json')[env];
const db = {};

if (config.use_env_variable) {
  const sequelize = new Sequelize(process.env[config.use_env_variable]);
} else {
  const sequelize = new Sequelize(
    config.database,
    config.username,
    config.password,
    config
  );
}

fs.readdirSync(__dirname)
  .filter(file => {
    return (
      file.indexOf('.') !== 0 && file !== basename && file.slice(-3) === '.js'
    );
  })
  .forEach(file => {
    const model = sequelize['import'](path.join(__dirname, file));
    db[model.name] = model;
  });

Object.keys(db).forEach(modelName => {
  if (db[modelName].associate) {
    db[modelName].associate(db);
  }
});

sequelize
  .authenticate()
  .then(() => {
    console.log('Connection has been established successfully.');
  })
  .catch(err => {
    console.log('Unable to connect to the database:', err);
  });

db.sequelize = sequelize;
db.Sequelize = Sequelize;

// Import Models such that I can use them in the api just by importing 'db'
db.user = require('./user')(sequelize, Sequelize);
db.admin = require('./admin')(sequelize, Sequelize);
db.articles = require('./articles')(sequelize, Sequelize);

module.exports = db;
```

It’s important to notice that I am exposing `db` object which contains every model/table schema definition. From now, I just have to import the `db` object to apply operations on specific database tables using it.

This setup can be auto-generated with the help of [Sequelize CLI](https://github.com/sequelize/cli) tool that helps in bootstrapping a new project in an effective manner (like the above) and handle database migrations directly from the terminal.

### Conclusion

Sequelize is feature rich ORM for Node.js. It has a documentation that at times may not provide direct solutions to your problems but there always Github issues for that. What I like about is its Promise based control flow. Coming from NoSQL background (and using MongoDB), understanding Sequelize really took less time. Most of the query based models are quite similar to that in MongoDB (especially the CRUD operations). I am looking for a brighter, more improved documentation and ease of support from Sequelize.


Getting Started with Sequelize for Nodejs Applications

---
title: 'How to use ESLint in Node.js Applications'
date: '2017-04-28'
thumbnail: '/thumbnails/node.png'
slug: 'blog/how-to-use-eslint-in-node-js-applications'
tag: 'nodejs'
canonicalUrl: 'https://medium.com/hackernoon/how-to-use-eslint-in-node-js-applications-cc4b2298ce55'
---

> [Originally Published at Hackernoon.com](https://medium.com/hackernoon/how-to-use-eslint-in-node-js-applications-cc4b2298ce55)

ESLint is an open source JavaScript linting utility that help you overcome developer errors as JavaScript is loosely-typed language. There are quite a few options such as JSHint and JSCS in Javascript community for code linting and this post doesn’t suggest that you cannot use them.

ESLint is designed to have all rules completely pluggable. That’s one of the primary reasons it came into existence. It allows developers to create their own linting rules. Every rule provided in the [ESLint official guide](http://eslint.org/docs/user-guide) is standalone rule and a developer at any point can decide whether to use a specific rule or not.

### Installing

_Note_: You must have Node.js installed in order to access ESLint via it’s package manager `npm`.

For local installation to a project directory:

```shell
npm install eslint --save-dev
```

For a global installation in your working system:

```shell
npm install eslint -g
```

ESLint will now be available via `eslint` command in your terminal.

### Configuration

Easiest way to configure it to setup a `.eslintrc` JSON file where are all the linting rules can be described.

An example of `.eslintrc`:

```json
{
  "env": {
    "node": 1,
    "browser": 1
  },
  "globals": {
    "exampleGlobalVariable": true
  },
  "rules": {
    "eqeqeq": 1
  },
  "plugins": []
}
```

If you installed eslint globally, you can also generate config file using:

```shell
eslint --init
```

Other case, if you have installed it locally to a project, you will need to type in your terminal:

```shell
./node_modules/.bin/eslint --init
```

In both cases, you will be prompted with set of basic questions to generate `.eslintrc` file.

<img src='https://cdn-images-1.medium.com/max/800/0*RMPR1vjmB6jsHtHw.png' />

An example of file generated after above prompt:

```json
{
  "env": {
    "browser": true,
    "commonjs": true
  },
  "extends": "eslint:recommended",
  "rules": {
    "indent": ["error", "tab"],
    "linebreak-style": ["error", "unix"],
    "quotes": ["error", "single"],
    "semi": ["error", "never"]
  }
}
```

For detailed information on Configuration, [read here](http://eslint.org/docs/user-guide/configuring).

### Rules

Rules in ESLint are added individually. No rules are enforced by default. You have to specify rules explicitly, then only it will be enabled for the linting process.

You can find a complete list of rules in the [official documentation here](http://eslint.org/docs/rules/)

After deciding which rules to include, you have to set there error levels. Each error level can be defined as following:

- `0` - Turn the rule off
- `1` - Turn the rule on as a warning
- `2` - Turn the rule on as an error

The difference between an error and a warning is the exit code that eslint will have when it finishes. If any errors are found, eslint will exit with a `1` exit code, otherwise it will exit with a `0`. If you are linting within a build step this allows you to control which rules should "break your build" and which ones should be considered as warnings.

Learn how to [configure rules in detail here](http://eslint.org/docs/user-guide/configuring#configuring-rules).

### Environments

The code you are writing might be suitable for a particular environment such as, you might be writing a REST API in Node.js application using Express Framework (Sinatra) and the frontend of that application is going to be built in AngularJS. Two different projects, two different environments and both can have separate eslint configurations in one file even though the client and the server are under one project directory that is been considered as root of your project.

How is it done? By setting the environment id to true in the `"env"` section of `.eslintrc`.

### Linting

ESLint comes with a command line interface (CLI) to lint your files or directory.

```js
eslint file.js
eslint dir/
```

The output generated will be grouped by file, and will specify the `line:column` number, warning/error, reason for the error, and the name of the rule for each failure.

### Use ESLint with your preferred Coding Style

ESLint personally does not promote any coding style. You can setup `.eslintrc` file to enforce coding style using [style rules](http://eslint.org/docs/rules/#stylistic-issues) that you like.

You can also use ESLint with Style guides such as [JavaScript Standard Style](http://standardjs.com/). You have to use extra plugin for that. The full guide can be found here [https://github.com/feross/eslint-config-standard](https://github.com/feross/eslint-config-standard).

To add a plugin to `.eslintrc`:

Some plugins for popular libraries: [Angular](https://www.npmjs.com/package/eslint-plugin-angular) | [React](https://www.npmjs.com/package/eslint-plugin-react)

Another plugin, I find very useful is [one variable per var](https://www.npmjs.com/package/eslint-plugin-one-variable-per-var) just to maintain code consistency over a large/open-source project.


How to use ESLint in Node.js Applications

---
title: 'How to Mock Data for Node.js Applications using faker.js'
date: '2017-04-01'
thumbnail: '/thumbnails/node.png'
slug: 'how-to-mock-data-for-nodejs-applications-using-fakerjs'
tag: 'nodejs'
canonicalUrl: 'https://hackernoon.com/how-to-mock-data-for-node-js-applications-using-faker-js-b1f4c0e78102'
---

> [Originally Published at Hackernoon.com](https://hackernoon.com/how-to-mock-data-for-node-js-applications-using-faker-js-b1f4c0e78102)

When we start to build an application, we generally do not want to worry much about data. To create a database and fill it with sample data seems much of a hassle to me personally. I instead focus more on creating RESTful API and the front end of the application when I am prototyping.

However, this doesn’t mean I don’t pay attention to data organization in the database. It’s important to have schemas of collections and documents or any other way you want to organize your data. With this aspect complete, it clarifies _what_ and _how_ questions when creating APIs.

In a recent scenario, building a prototype of an E-Commerce web application for a client, I found myself in a similar situation. I had a deadline to deliver the prototype with a maximum number of functionalities checked required by the client. After settling on how to architecture database’s schemas, I went on searching​ and finding a gem to solve this issue: **faker.js.**

### Enter faker.js

It’s a wonderful node module to create fake/mock data when you face a similar situation. fakerjs has its own API, and it’s huge. All credit goes to [**Marak**](https://twitter.com/marak), who built it. It has a vast API for almost every use case with an excellent [_documentation_ that can help you get familiar in minutes on Github.](https://github.com/marak/Faker.js/)

Let’s consider a test case where I want some _a user_ to have the following amount of fields:

- name
- email
- website
- address
- bio
- image/avatar

```js
const faker = require('faker');

const User = {
  name: faker.name.findName(),
  email: faker.internet.email(),
  website: faker.internet.url(),
  address:
    faker.address.streetAddress() +
    faker.address.city() +
    faker.address.country(),
  bio: faker.lorem.sentences(),
  image: faker.image.avatar()
};

module.exports = User;
```

<img src='https://cdn-images-1.medium.com/max/1200/1*t8BjRlFjuUnbf0iXl-FZCQ.png' />

That’s it. This is how you mock data using faker.js. It’s quick, simple to setup and no hassle at all. You just have to add it to your `npm` dependencies:

```shell
npm install faker --save
```

#### faker.js Data

List of data that can generate faker.js:

- address
- commerce
- company
- date
- finance
- hacker
- helpers
- image
- internet
- lorem
- name
- phone
- random
- system

Each element has many sub-items that you can check [here](https://github.com/Marak/faker.js) in the documentation.

Another good thing about Faker I like is that it’s not only restricted to server-side JavaScript only. You can mock data for browser JavaScript too. A little snippet from the documentation shows how to do this:

```html
<script src="faker.js" type="text/javascript"></script>
<script>
  var randomName = faker.name.findName(); // Caitlyn Kerluke
  var randomEmail = faker.internet.email(); // Rusty@arne.info
  var randomCard = faker.helpers.createCard(); // random contact card containing many properties
</script>
```

This API will help you to prototype your JavaScript/Node.js applications at a faster rate. Not only that, you can easily mock your TDD/BDD tests when creating a RESTful API utilizing this library.

For full source code at [this Github Repository](https://github.com/amandeepmittal/fakerjs)


How to Mock Data for Node.js Applications using faker.js

---
date: '2017-01-11'
title: 'Migrating from Expressjs 4 to 5'
thumbnail: '/thumbnails/node.png'
slug: 'migrating-from-expressjs-4-to-5'
tag: ' nodejs'
canonicalUrl: 'https://hackernoon.com/migrating-from-expressjs-4-to-5-156dcd80eb11'
---

ExpressJS 5.0 is in alpha release stage but I believe we’ll be adding it as a dependency in our `package.json` files in matter of no time. This article gives some tips regarding the way we are writing code using this framework and how we should adapt the new changes even if we are using ExpressJS _version 4.0_.

I’ll start with most common thing such as `response`.

Express 5 no longer supports the signature `res.send`, instead we should adapt using this method in this form:

`res.status(statusCode).send();`

We have to set the status code before sending the response object. This new version of `res.send` is basically a chain of two methods: `res.status` & `res.send`.

With that mind, ExpressJS 5 deprecates `res.send(statusCode)` method where `statusCode` is the number representing the HTTP response header status code. To send just the statusCode, that is, without sending the response object, we can use `res.sendStatus(statusCode)` method.

In similar manner, other methods that have been changed are:

```js
res.json()-- > res.status().json();
res.jsonp()-- > res.status.jsonp();
```

Another notable method that is going to be deprecated in next version of ExpressJS is `res.sendfile()`. Instead, we must adapt its new form, the camelCase one: `res.sendFile()` which is already been supported by the ExpressJS versions later than `4.8.x`. It comes with optional parameters that you can check them [**here**](http://expressjs.com/en/4x/api.html#res.sendFile)**.**

Whether you are planning to use the alpha release of Express 5.0 or still going on with the latest versions of Express 4.0, I would suggest to start adapting these methods immediately.

_The full list of changes or the official Express Migration Guide is to be found_ [here](http://expressjs.com/en/guide/migrating-5.html)**_._**

[Originally Published at Hackernoon.com](https://hackernoon.com/migrating-from-expressjs-4-to-5-156dcd80eb11)


Migrating from Expressjs 4 to 5

---
date: '2016-12-25'
title: 'Writing a Node.js Twitter Bot Part 2'
thumbnail: '/thumbnails/node.png'
slug: 'node-js-twitter-bot-tutorial-part-2'
tag: 'nodejs'
canonicalUrl: 'https://community.risingstack.com/how-to-make-a-twitter-bot-with-node-js/'
---

If you read the [first part of my tutorial](https://community.risingstack.com/node-js-twitter-bot-tutorial/), you already know how to make a Twitter Bot with Node.js that retweets and favorites tweets using the Twitter API.

In the second part of the Twitter Bot tutorial, we will continue to extend our Bot by adding functionality that will tweet back to any Twitter user who follows our bot.

Before starting this, make sure your directory structure includes:

- `package.json` (the configuration file for our Node.js application)
- `config.js` (the configuration file of our Twitter application that contains both consumer and access key & tokens)
- `bot.js` (our main application file)

The representation would be:

```shell
root/project-name
|- bot.js
|- config.js
|- package.json
```

You can take a look at the complete bot.js file from [the first part of this tutorial](https://community.risingstack.com/node-js-twitter-bot-tutorial/).

Also, make sure you have the [twit](https://www.npmjs.com/search?q=twit) npm module installed.

## How to make a Twitter bot that replies

After setting up the dependencies and loading/requiring the configuration related to our application, we are going to develop a functionality that is going to tweet back to a Twitter user who follows the Bot's Twitter Handler.

We are going to use [Twitter's Streaming API](https://dev.twitter.com/streaming/overview) to interact with our followers.

## Setting up the Streams API

First, we have to set up a stream. Fortunately, the third party npm dependency `twit` provides an API function `.stream()` to do this task.

```js
// Use Streams API for interacting with a USER
// set up a user stream

var stream = Twitter.stream('user');
```

`.stream()` keeps the connection alive, and returns an `EventEmitter`.

`twit` provides a list of stream events to listen on, such as 'follow', 'unfollow', 'favorite' and 'unfavorite'.

Right now we are only interested in the follow event, however the basic syntax is similar to every event.

```js
// when someone follows
stream.on('follow', followed);
```

When a user follows our Twitter Bot, the `follow` event will trigger the callback associated with it, in our case `followed`.

```js
// ...trigger the callback
function followed(event) {
    console.log('Follow Event is running');
    //get user's twitter handler (screen name)
    var name = event.source.name,
    var screenName = event.source.screen_name;
    // function that replies back to the user who followed
    tweetNow('@' + screenName + ' Thank you for the follow up.');
}
```

## Replying with tweetnow()

In the followed callback, we pass an event argument which gets the Twitter handle and the screen name of the user. In the last line, we invoke a `tweetnow()` function that replies back to the user who followed our bot.

The `tweetnow()` function takes a string as an argument and updates our bots status. In other terms, it tweets by using `.post()`function provided by the `twit` API to post to the `statuses/update`Twitter API endpoint.

This endpoint gets called whenever you tweet from your Twitter account.

If you noticed in the [previous tutorial](https://community.risingstack.com/node-js-twitter-bot-tutorial/) when retweeting or to favorite a tweet, we used `.post()` to update our status.

```js
function tweetNow(tweetTxt) {
  var tweet = {
    status: tweetTxt
  };
  Twitter.post('statuses/update', tweet, function (err, data, response) {
    if (err) {
      console.log('Error in Replying');
    } else {
      console.log('Gratitude shown successfully');
    }
  });
}
```

Unlike in the previous tutorial, we don't need JavaScripts Timer function this time, since we are using the Streaming API which helps to keep the connection alive.

Here comes the complete code of our bot:

```js
// Use Streams API for interacting with a USER ==========
// set up a user stream

var stream = Twitter.stream('user');

// FOLLOW-Reply BOT ===========================

// when someone follows
stream.on('follow', followed);

// ...trigger the callback
function followed(event) {
  console.log('Follow Event is running');
  //get their twitter handler (screen name)
  var name = event.source.name,
    screenName = event.source.screen_name;
  // function that replies back to the user who followed
  tweetNow('@' + screenName + ' Thank you for the follow up.');
}

// function definition to tweet back to user who followed
function tweetNow(tweetTxt) {
  var tweet = {
    status: tweetTxt
  };
  Twitter.post('statuses/update', tweet, function (err, data, response) {
    if (err) {
      console.log('Error in Replying');
    } else {
      console.log('Gratitude shown successfully');
    }
  });
}
```

## Running the Twitter Bot

To run this bot, go to your terminal:

```shell
node bot.js
```

To avoid this monotonous process, you can use npm scripts or `nodemon`. You can also deploy this app on Heroku for a continuous deployment.

If you are planning to deploy on Heroku, make sure to include a `Procfile` in the root of your directory structure and add the following line to the file:

```shell
worker: node bot.js
```

If you are using npm scripts, make sure you edit the `scripts` attribute in the`package.json` file:

```json
{
  "scripts": {
    "start": "node bot.js"
  }
}
```

Then to run from terminal:

```shell
$ npm start
```

## Next up

To do further smart things with your bot, go and check out the [twit documentation](https://www.npmjs.com/package/twit) for other RESTful API methods and Streaming API events.

If you are interested in Twitter Bots, check [Botwiki.org](https://botwiki.org/bots/twitterbots/) - as they have the vast collection of Twitter Bots in different programming languages.

The sole purpose of Bot as a web application is automation. For example, when I created my first Twitter Bot [@nodejstweets](https://twitter.com/nodejstweet), the whole idea was to remain up to date with the most recent happenings.

You can do a lot of things with a Twitter Bot, whether for your own sole purpose or to solve a purpose for a community. See [@100DaysOfCode](http://twitter.com/@_100DaysOfCode) as a great example.

[Originally Published at RisingStack.com](https://community.risingstack.com/how-to-make-a-twitter-bot-with-node-js/)


Writing a Node.js Twitter Bot Part 2

---
date: '2016-12-25'
title: 'Writing a Node.js Twitter Bot Part 1'
thumbnail: '/thumbnails/node.png'
slug: 'node-js-twitter-bot-tutorial'
tag: 'nodejs'
canonicalUrl: 'https://community.risingstack.com/node-js-twitter-bot-tutorial/'
---

In this tutorial, we will create a Twitter Bot with Node.js that retweets or favorites based on hashtags, and replies to users if they follow the account.

## What do you need to create this bot?

- You must have [Node.js](http://nodejs.org) installed on your system.
- A Twitter Account.
- Your bot will be using [`twit`](https://www.npmjs.com/package/twit) which is an npm module to manipulate tweets and streams, and to communicate with the [Twitter API](https://dev.twitter.com/docs).

## Let’s Start

Setup an empty directory and initialise it with:`$ npm init` to configure this web application with `package.json` file. Then create two new files: `bot.js` & `config.js` in that directory.

`bot.js` will be our main app file in which we will be writing the source code of our Twitter Bot, and so in `package.json` edit the `main` field to:

```json
{
  "main": "bot.js"
}
```

Your current directory structure should look like this:

```shell
root/project-name
|- bot.js
|- config.js
|- package.json
```

## Configuring and granting permissions from Twitter API

After logging to to your Twitter account, follow to this link: [https://apps.twitter.com/app/new](https://apps.twitter.com/app/new) to create a new application. Fill out the necessary fields in the form click on the button _Create Your Twitter Application._ After creating the application, look for `Keys and Access Tokens` under the nav-panes and click on `Generate Token Actions\` and then copy:

- Consumer Key
- Consumer Secret
- Access Token
- Access Token Secret

Open the `config.js` file and paste all four values inside it. Expose those values using `module.export`:

```js
//config.js
/\*\* TWITTER APP CONFIGURATION
 \* consumer\_key
 \* consumer\_secret
 \* access\_token
 \* access\_token\_secret
 \*/

module.exports = {
  consumer\_key: '',
  consumer\_secret: '',
  access\_token: '',
  access\_token\_secret: ''
}
```

Now, the Twitter bot’s configuration is step is complete. _Please note,_ for every different application, the `consumer key`, `consumer secret`, `access_token` and `access_token_secret` will differ.

## Building the bot

Since the configuration step is complete, now let’s install our third requisite that is [Twitter API client for node](https://www.npmjs.com/package/twit) and will help us to communicate to Twitter API and provide an API for all necessary actions _(such as retweet and favorite a tweet)._

We will start by installing the dependency we need for our application.

```shell
$ npm install --save twit
```

After the dependency has finished installing, go to the `bot.js` file and require the dependency and `config.js` file.

```js
var twit = require(’twit’);
var config = require(’./config.js’);
```

Pass the configuration (_consumer and access tokens_) of our Twitter application in `config.js` to `twit:`

```js
var Twitter = new twit(config);
```

So far, so good?

**PLEASE NOTE: You must refer to** `[**twit**](https://www.npmjs.com/package/twit)` [**documentation**](https://www.npmjs.com/package/twit) **for a deep reference.**

#### Retweet Bot

Let’s write a function expression that finds the latest tweets according to the query passed as a parameter. We will initialise a `params` object that will hold various properties to search a tweet, but most importantly `query` or `q` property that will refine our searches. Whatever value you feed in this property, our bot will search the tweets to retweet based on this criteria. You can feed this property values like a twitter handler, to monitor a specific twitter account or a #hashtag. For our example bot, we have find latest tweets on #nodejs.

This is how the functionality of the retweet bot starts:

```js
var retweet = function() {
  var params = {
    q: '#nodejs, #Nodejs',
    result\_type: 'recent',
    lang: 'en'
  }
```

The other two properties: `result_type` and `lang` are optional. On defining the `result_type: 'recent'` notifies bot to only search for the latest tweets, tweets that have occurred in the time period since our bot has started or it made the last retweet.

[There is a list of parameters provided by the Twitter API](//%20for%20more%20parametes,%20see:%20https://dev.twitter.com/rest/reference/get/search/tweets).

Our next step is to search for the tweets based on our parameters. For this, we will use `Twitter.get` function provided by `twit` API to GET any of the REST API endpoints. The REST API endpoint is a reference to the T[witter API endpoint](https://dev.twitter.com/docs) we are going to make a call to search for tweets. The `Twitter.get` function accepts three arguments: API endpoint, params object (defined by us) and a callback.

```js
// RETWEET BOT ==========================

// find latest tweet according the query 'q' in params
var retweet = function () {
  var params = {
    q: '#nodejs, #Nodejs', // REQUIRED
    result_type: 'recent',
    lang: 'en'
  };
  // for more parametes, see: https://dev.twitter.com/rest/reference/get/search/tweets

  Twitter.get('search/tweets', params, function (err, data) {
    // if there no errors
    if (!err) {
      // grab ID of tweet to retweet
      var retweetId = data.statuses[0].id_str;
      // Tell TWITTER to retweet
      Twitter.post(
        'statuses/retweet/:id',
        {
          id: retweetId
        },
        function (err, response) {
          if (response) {
            console.log('Retweeted!!!');
          }
          // if there was an error while tweeting
          if (err) {
            console.log(
              'Something went wrong while RETWEETING... Duplication maybe...'
            );
          }
        }
      );
    }
    // if unable to Search a tweet
    else {
      console.log('Something went wrong while SEARCHING...');
    }
  });
};
```

To post or to retweet the tweet our bot has found we use `Twitter.post()` method to _POST any of the REST API endpoints_. It also takes the same number of arguments as `Twitter.get()`.

Now to automate this action we defined above, we can use JavaScript’s timer function `setInterval()` to search and retweet after a specific period of time.

```js
// grab & retweet as soon as program is running...
retweet();
// retweet in every 50 minutes
setInterval(retweet, 3000000);
```

Please note that all JavaScript’s Timer functions take the _amount of time_ argument in milliseconds.

#### Favorite Bot

Similar to `retweet` bot we can define and initialise another function expression that will search and _favorite_ a tweet randomly. Yes, the difference here is to search and grab the tweet randomly. We will start by creating a parameter object `params` that will consist of three properties as in `retweet()` function expression. The bot will search for tweets using the same `.get()` function provided by `twit` API to GET any of the Twitter API endpoints. In our case, we need `search/tweets`. Then we will store the status of the search for tweet to _favorite_ in a variable and in a another variable we will apply the random function by passing the “status of the search” variable as an argument.

```js
// FAVORITE BOT====================

// find a random tweet and 'favorite' it
var favoriteTweet = function () {
  var params = {
    q: '#nodejs, #Nodejs', // REQUIRED
    result_type: 'recent',
    lang: 'en'
  };
  // for more parametes, see: https://dev.twitter.com/rest/reference

  // find the tweet
  Twitter.get('search/tweets', params, function (err, data) {
    // find tweets
    var tweet = data.statuses;
    var randomTweet = ranDom(tweet); // pick a random tweet

    // if random tweet exists
    if (typeof randomTweet != 'undefined') {
      // Tell TWITTER to 'favorite'
      Twitter.post(
        'favorites/create',
        { id: randomTweet.id_str },
        function (err, response) {
          // if there was an error while 'favorite'
          if (err) {
            console.log('CANNOT BE FAVORITE... Error');
          } else {
            console.log('FAVORITED... Success!!!');
          }
        }
      );
    }
  });
};
// grab & 'favorite' as soon as program is running...
favoriteTweet();
// 'favorite' a tweet in every 60 minutes
setInterval(favoriteTweet, 3600000);

// function to generate a random tweet tweet
function ranDom(arr) {
  var index = Math.floor(Math.random() * arr.length);
  return arr[index];
}
```

Note that the tweets searched by our bot are all stored in an array. Again, we use JavaScript’s timer function `setInterval()`to search and favorite the tweet after a specific period of time in milliseconds.

The complete module: `bot.js` :

```js
// Dependencies =========================
var twit = require('twit'),
  config = require('./config');

var Twitter = new twit(config);

// RETWEET BOT ==========================

// find latest tweet according the query 'q' in params
var retweet = function () {
  var params = {
    q: '#nodejs, #Nodejs', // REQUIRED
    result_type: 'recent',
    lang: 'en'
  };
  Twitter.get('search/tweets', params, function (err, data) {
    // if there no errors
    if (!err) {
      // grab ID of tweet to retweet
      var retweetId = data.statuses[0].id_str;
      // Tell TWITTER to retweet
      Twitter.post(
        'statuses/retweet/:id',
        {
          id: retweetId
        },
        function (err, response) {
          if (response) {
            console.log('Retweeted!!!');
          }
          // if there was an error while tweeting
          if (err) {
            console.log(
              'Something went wrong while RETWEETING... Duplication maybe...'
            );
          }
        }
      );
    }
    // if unable to Search a tweet
    else {
      console.log('Something went wrong while SEARCHING...');
    }
  });
};

// grab & retweet as soon as program is running...
retweet();
// retweet in every 50 minutes
setInterval(retweet, 3000000);

// FAVORITE BOT====================

// find a random tweet and 'favorite' it
var favoriteTweet = function () {
  var params = {
    q: '#nodejs, #Nodejs', // REQUIRED
    result_type: 'recent',
    lang: 'en'
  };
  // find the tweet
  Twitter.get('search/tweets', params, function (err, data) {
    // find tweets
    var tweet = data.statuses;
    var randomTweet = ranDom(tweet); // pick a random tweet

    // if random tweet exists
    if (typeof randomTweet != 'undefined') {
      // Tell TWITTER to 'favorite'
      Twitter.post(
        'favorites/create',
        { id: randomTweet.id_str },
        function (err, response) {
          // if there was an error while 'favorite'
          if (err) {
            console.log('CANNOT BE FAVORITE... Error');
          } else {
            console.log('FAVORITED... Success!!!');
          }
        }
      );
    }
  });
};
// grab & 'favorite' as soon as program is running...
favoriteTweet();
// 'favorite' a tweet in every 60 minutes
setInterval(favoriteTweet, 3600000);

// function to generate a random tweet tweet
function ranDom(arr) {
  var index = Math.floor(Math.random() * arr.length);
  return arr[index];
}
```

#### Usage

To run this bot, go to your terminal:

```shell
$ node bot.js
```

To avoid this monotonous process you can use `npm scripts` or `nodemon.` You can also deploy this app on `Heroku` for a continuous integration.

To use npm scripts, make this edit under `scripts` in `package.json` :

```json
{
  "scripts": {
    "start": "node bot.js"
  }
}
```

Then from terminal:

```shell
$ npm start
```

## Conclusion

There are various ways to write a Twitter Bot, this is just one way. Your bot can be smart and you can do various things with it. You just have to refer to [twit documentation](https://www.npmjs.com/package/twit) for other RESTful API methods to manipulate [Twitter API endpoints](http://REST%20API%20Endpoints:%20https://dev.twitter.com/rest/public).

For further reading check out [Botwiki.org](https://botwiki.org/bots/twitterbots/) for various types of bots on vast amount of platforms. For advanced reading, check out [Botwiki’s list of tutorials of Twitter Bots in different programming languages](https://botwiki.org/tutorials/twitterbots/).

Update: the second part of this tutorial is available [here!](https://community.risingstack.com/how-to-make-a-twitter-bot-with-node-js/)

[Originally Published at RisingStack.com](https://community.risingstack.com/node-js-twitter-bot-tutorial/)


Writing a Node.js Twitter Bot Part 1

---
title: 'Create a Simple Twitter Bot with Node.js'
date: '2016-11-23'
thumbnail: '/thumbnails/node.png'
slug: 'create-a-simple-twitter-bot-with-node-js'
tag: 'nodejs'
canonicalUrl: 'https://medium.com/hackernoon/create-a-simple-twitter-bot-with-node-js-5b14eb006c08'
---

> [Originally Published at Hackernoon.com](https://medium.com/hackernoon/create-a-simple-twitter-bot-with-node-js-5b14eb006c08)

How about a Twitter Bot that retweets, favorites, on the basis of hashtags and replies to other users if they follow it? I made a similar kind of a Twitter Bot [(@nodejstweet)](https://twitter.com/nodejstweet) that feeds me the latest or the ongoing news/articles/how-to’s on a set of hashtags such as #Nodejs, #MongoDB, #AngularJS, #IonicFramework, et cetera. At the time I never expected it having more followers than me but that has been surpassed.

<img src='https://cdn-images-1.medium.com/max/800/1*DcLASOdtPlO8p86oUg86JA.png' />

### What this bot will do?

This is a simple Twitter bot and will retweet, favorite/like randomly on the basis of hashtags as a query that we will use and continue to do so after a certain period of time interval.

## What you need?

- You must have [Node.js](http://nodejs.org) installed on your system.
- A Twitter Account.
- Your bot will be using [`twit`](https://www.npmjs.com/package/twit) which is an npm module to manipulate tweets and streams, and to communicate with the [Twitter API](https://dev.twitter.com/docs).

## Let’s Start

Setup an empty directory and initialise it with:`$ npm init` to configure this web application with `package.json` file. Then create two new files: `bot.js` & `config.js` in that directory.

`bot.js` will be our main app file in which we will be writing the source code of our Twitter Bot, and so in `package.json` edit the `main` field to:

```json
{
  "main": "bot.js"
}
```

Your current directory structure should look like this:

```shell
root/project-name
|- bot.js
|- config.js
|- package.json
```

## Configuring and granting permissions from Twitter API

After logging to to your Twitter account, follow to this link: [https://apps.twitter.com/app/new](https://apps.twitter.com/app/new) to create a new application. Fill out the necessary fields in the form click on the button _Create Your Twitter Application._ After creating the application, look for `Keys and Access Tokens` under the nav-panes and click on `Generate Token Actions\` and then copy:

- Consumer Key
- Consumer Secret
- Access Token
- Access Token Secret

Open the `config.js` file and paste all four values inside it. Expose those values using `module.export`:

```js
//config.js
/* TWITTER APP CONFIGURATION
 * consumer_key
 * consumer_secret
 * access_token
 * access_token_secret
 */

module.exports = {
  consumerconsumer_key: '',
  consumerconsumer_secret: '',
  accessaccess_token: '',
  accessaccess_tokenaccess_token_secret: ''
};
```

Now, the Twitter bot’s configuration is step is complete. _Please note,_ for every different application, the `consumer key`, `consumer secret`, `access_token` and `access_token_secret` will differ.

## Building the bot

Since the configuration step is complete, now let’s install our third requisite that is [Twitter API client for node](https://www.npmjs.com/package/twit) and will help us to communicate to Twitter API and provide an API for all necessary actions _(such as retweet and favorite a tweet)._

We will start by installing the dependency we need for our application.

```shell
$ npm install --save twit
```

After the dependency has finished installing, go to the `bot.js` file and require the dependency and `config.js` file.

```js
var twit = require(’twit’);
var config = require(’./config.js’);
```

Pass the configuration (_consumer and access tokens_) of our Twitter application in `config.js` to `twit:`

```js
var Twitter = new twit(config);
```

So far, so good?

**PLEASE NOTE: You must refer to** [twit documentation](https://www.npmjs.com/package/twit) **for a deep reference.**

#### Retweet Bot

Let’s write a function expression that finds the latest tweets according to the query passed as a parameter. We will initialise a `params` object that will hold various properties to search a tweet, but most importantly `query` or `q` property that will refine our searches. Whatever value you feed in this property, our bot will search the tweets to retweet based on this criteria. You can feed this property values like a twitter handler, to monitor a specific twitter account or a #hashtag. For our example bot, we have find latest tweets on #nodejs.

This is how the functionality of the retweet bot starts:

```js
var retweet = function() {
  var params = {
    q: '#nodejs, #Nodejs',
    result\_type: 'recent',
    lang: 'en'
  }
```

The other two properties: `result_type` and `lang` are optional. On defining the `result_type: 'recent'` notifies bot to only search for the latest tweets, tweets that have occurred in the time period since our bot has started or it made the last retweet.

[There is a list of parameters provided by the Twitter API](https://dev.twitter.com/rest/reference/get/search/tweets).

Our next step is to search for the tweets based on our parameters. For this, we will use `Twitter.get` function provided by `twit` API to GET any of the REST API endpoints. The REST API endpoint is a reference to the T[witter API endpoint](https://dev.twitter.com/docs) we are going to make a call to search for tweets. The `Twitter.get` function accepts three arguments: API endpoint, params object (defined by us) and a callback.

```js
// RETWEET BOT ==========================

// find latest tweet according the query 'q' in params
var retweet = function () {
  var params = {
    q: '#nodejs, #Nodejs', // REQUIRED
    result_type: 'recent',
    lang: 'en'
  };
  // for more parametes, see: https://dev.twitter.com/rest/reference/get/search/tweets

  Twitter.get('search/tweets', params, function (err, data) {
    // if there no errors
    if (!err) {
      // grab ID of tweet to retweet
      var retweetId = data.statuses[0].id_str;
      // Tell TWITTER to retweet
      Twitter.post(
        'statuses/retweet/:id',
        {
          id: retweetId
        },
        function (err, response) {
          if (response) {
            console.log('Retweeted!!!');
          }
          // if there was an error while tweeting
          if (err) {
            console.log(
              'Something went wrong while RETWEETING... Duplication maybe...'
            );
          }
        }
      );
    }
    // if unable to Search a tweet
    else {
      console.log('Something went wrong while SEARCHING...');
    }
  });
};
```

To post or to retweet the tweet our bot has found we use `Twitter.post()` method to _POST any of the REST API endpoints_. It also takes the same number of arguments as `Twitter.get()`.

Now to automate this action we defined above, we can use JavaScript’s timer function `setInterval()` to search and retweet after a specific period of time.

```js
// grab & retweet as soon as program is running...
retweet();
// retweet in every 50 minutes
setInterval(retweet, 3000000);
```

Please note that all JavaScript’s Timer functions take the _amount of time_ argument in milliseconds.

#### Favorite Bot

Similar to `retweet` bot we can define and initialise another function expression that will search and _favorite_ a tweet randomly. Yes, the difference here is to search and grab the tweet randomly. We will start by creating a parameter object `params` that will consist of three properties as in `retweet()` function expression. The bot will search for tweets using the same `.get()` function provided by `twit` API to GET any of the Twitter API endpoints. In our case, we need `search/tweets`. Then we will store the status of the search for tweet to _favorite_ in a variable and in a another variable we will apply the random function by passing the “status of the search” variable as an argument.

```js
// FAVORITE BOT====================

// find a random tweet and 'favorite' it
var favoriteTweet = function () {
  var params = {
    q: '#nodejs, #Nodejs', // REQUIRED
    result_type: 'recent',
    lang: 'en'
  };
  // for more parametes, see: https://dev.twitter.com/rest/reference

  // find the tweet
  Twitter.get('search/tweets', params, function (err, data) {
    // find tweets
    var tweet = data.statuses;
    var randomTweet = ranDom(tweet); // pick a random tweet

    // if random tweet exists
    if (typeof randomTweet != 'undefined') {
      // Tell TWITTER to 'favorite'
      Twitter.post(
        'favorites/create',
        { id: randomTweet.id_str },
        function (err, response) {
          // if there was an error while 'favorite'
          if (err) {
            console.log('CANNOT BE FAVORITE... Error');
          } else {
            console.log('FAVORITED... Success!!!');
          }
        }
      );
    }
  });
};
// grab & 'favorite' as soon as program is running...
favoriteTweet();
// 'favorite' a tweet in every 60 minutes
setInterval(favoriteTweet, 3600000);

// function to generate a random tweet tweet
function ranDom(arr) {
  var index = Math.floor(Math.random() * arr.length);
  return arr[index];
}
```

Note that the tweets searched by our bot are all stored in an array. Again, we use JavaScript’s timer function `setInterval()`to search and favorite the tweet after a specific period of time in milliseconds.

The complete module: `bot.js` :

```js
// Dependencies =========================
var twit = require('twit'),
  config = require('./config');

var Twitter = new twit(config);

// RETWEET BOT ==========================

// find latest tweet according the query 'q' in params
var retweet = function () {
  var params = {
    q: '#nodejs, #Nodejs', // REQUIRED
    result_type: 'recent',
    lang: 'en'
  };
  Twitter.get('search/tweets', params, function (err, data) {
    // if there no errors
    if (!err) {
      // grab ID of tweet to retweet
      var retweetId = data.statuses[0].id_str;
      // Tell TWITTER to retweet
      Twitter.post(
        'statuses/retweet/:id',
        {
          id: retweetId
        },
        function (err, response) {
          if (response) {
            console.log('Retweeted!!!');
          }
          // if there was an error while tweeting
          if (err) {
            console.log(
              'Something went wrong while RETWEETING... Duplication maybe...'
            );
          }
        }
      );
    }
    // if unable to Search a tweet
    else {
      console.log('Something went wrong while SEARCHING...');
    }
  });
};

// grab & retweet as soon as program is running...
retweet();
// retweet in every 50 minutes
setInterval(retweet, 3000000);

// FAVORITE BOT====================

// find a random tweet and 'favorite' it
var favoriteTweet = function () {
  var params = {
    q: '#nodejs, #Nodejs', // REQUIRED
    result_type: 'recent',
    lang: 'en'
  };
  // find the tweet
  Twitter.get('search/tweets', params, function (err, data) {
    // find tweets
    var tweet = data.statuses;
    var randomTweet = ranDom(tweet); // pick a random tweet

    // if random tweet exists
    if (typeof randomTweet != 'undefined') {
      // Tell TWITTER to 'favorite'
      Twitter.post(
        'favorites/create',
        { id: randomTweet.id_str },
        function (err, response) {
          // if there was an error while 'favorite'
          if (err) {
            console.log('CANNOT BE FAVORITE... Error');
          } else {
            console.log('FAVORITED... Success!!!');
          }
        }
      );
    }
  });
};
// grab & 'favorite' as soon as program is running...
favoriteTweet();
// 'favorite' a tweet in every 60 minutes
setInterval(favoriteTweet, 3600000);

// function to generate a random tweet tweet
function ranDom(arr) {
  var index = Math.floor(Math.random() * arr.length);
  return arr[index];
}
```

## Usage

To run this bot, go to your terminal:

```shell
$ node bot.js
```

To avoid this monotonous process you can use `npm scripts` or `nodemon.` You can also deploy this app on `Heroku` for a continuous integration.

To use npm scripts, make this edit under `scripts` in `package.json` :

```json
{
  "scripts": {
    "start": "node bot.js"
  }
}
```

Then from terminal:

```shell
$ npm start
```

There are various ways to write a Twitter Bot, this is just one way. Your bot can be smart and you can do various things with it. You just have to refer to [twit documentation](https://www.npmjs.com/package/twit) for other RESTful API methods to manipulate [Twitter API endpoints](http://REST%20API%20Endpoints:%20https://dev.twitter.com/rest/public).

For further reading check out [Botwiki.org](https://botwiki.org/bots/twitterbots/) for various types of bots on vast amount of platforms. For advanced reading, check out [Botwiki’s list of tutorials of Twitter Bots in different programming languages](https://botwiki.org/tutorials/twitterbots/).


Create a Simple Twitter Bot with Node.js

---
title: 'How process.nextTick() works in Node.js?'
date: '2016-06-25'
thumbnail: '/thumbnails/node.png'
slug: 'how-process-nexttick-works-in-node-js'
tag: 'nodejs'
canonicalUrl: 'https://amanhimself.dev/blog/how-process-nexttick-works-in-node-js/'
---

The [process](https://nodejs.org/api/process.html) object is a one of the few global objects provided by the Node.js core API. It can be access from anywhere, thus its methods can also be accessed. Such is a method called `process.nextTick()` which is used by developers in realtime applications everyday to defer the execution of a function until the next [Event Loop Iteration](https://medium.com/@amanhimself/the-node-js-system-51090c35dddc).

Browser JavaScript introduced us functions like `setTimeout()` to defer tasks in the near future. The `setTimeout()` function takes a callback function and a number value representing the time after which the callback function will be executed, in milliseconds.

```js
setTimeout(callback, 0);
```

In Node.js, each iteration of an Event Loop is called a tick. To schedule a callback function to be invoked in the next iteration of the Event Loop, we use process.nextTick(). It just takes a callback with no time bound, since it will be executing in the next iteration of the Event Loop.

```js
process.nextTick(callback);
```

The difference between setTimeout() and process.nextTick() is that the process.nextTick() function is specific to the Node.js Event Loop. setTimeout() uses JavaScript runtime to schedule its own queue of events. When using process.nextTick(), callback function associated with [it runs immediately after events in the Event Queue are processed by the Event Loop in a single iteration. In comparison to setTimeout(), it is faster since queue associated with setTimeout() or the JavaScript runtime](https://gist.github.com/mmalecki/1257394).

```js
function cb() {
  console.log('Processed in next iteration');
}
process.nextTick(cb);
console.log('Processed in the first iteration');
```

The above snippet is an example of how `process.nextTick()` works. You can save the snippet in a file.js and run using \$node file.js from your terminal. You will definitely notice that the second console.log printed before the console.log associated with function `cb()`.

```js
Processed in the first iteration
Processed in next iteration
```

### Further Reading:

- [process.nextTick vs setTimeout(fn, 0)](https://gist.github.com/mmalecki/1257394)
- [Nodejs Official Docs](https://nodejs.org/docs/latest/api/process.html#process_process_nexttick_callback_args)
- [Understanding process.nextTick()](https://howtonode.org/understanding-process-next-tick)


How process.nextTick() works in Node.js?

---
title: 'The Node.js system'
date: '2016-04-22'
thumbnail: '/thumbnails/node.png'
slug: 'nodejs-system'
tag: 'nodejs'
canonicalUrl: 'https://medium.com/hackernoon/the-node-js-system-51090c35dddc'
---

When I started learning Node.js, I always wondered, how does it work? How is it inside Node.js? Event loop and Event Queue jargons are digested. But what exactly is going on? Where do those jargons Event Loop and Event Queue come from.To satisfy my curiosity as well to know the answer to my previous question, I went in depth as much as I can and came across some things which I’d like to share with you. In brief, this article is about **Node.js System** — a glimpse of internal workings of Node.

If you are familiar with Node.js, it is a known fact that Node.js is single threaded. If you are from programming/computer science background you know what a thread means. Consider this scenario: traditionally — an I/O request comes to a web server and is assigned to an available thread, and for each concurrent connection there is one thread available. That request is handled on the specific thread until it is fulfilled and the response is sent.

This scenario is a perfect example of **Blocking I/O** because while handling a particular request by a specific thread, there will be some idle time when the operations are being done (such as retrieving a file, opening it, reading it, etc.). A single thread consumes memory. A longer running thread for each connection and then sitting idly for some amount of time is not considered an efficient way in the [world of Node.js](https://medium.com/@amanhimself/the-node-way-philosophy-of-a-platform-f9738ed5f9d2).

## Enter Reactor Pattern- Heart of Node.js

Reactor Pattern is an idea of non-blocking I/O operations in Node.js. This pattern provides a handler(in case of Node.js, a callback function) that is associated with each I/O operation. When an I/O request is generated, it is submitted to a demultiplexer.

This demultiplexer is a notification interface that is used to handle concurrency in non-blocking I/O mode and collects every request in form of an event and queues each event in a queue. Thus, the demultiplexer provides the Event Queue, which we often hear. When a request is collected by the demultiplexer, it returns the control back to the system and does not blocks the I/O. At the same time, there is an Event Loop which iterates over the items in the Event Queue. Every event has a callback function associated with it, and that callback function is invoked when the Event Loop iterates.

The callback function further mostly have other callbacks associated within representing some asynchronous operations. These operations are inserted in the Event Queue by the demultiplexer and are ready to be processed once the Event Loop iterates over them. That is why calls to other operations must be asynchronous.

When all the items in the Event Queue are processed and there are no pending operations left, Node.js terminates the application automatically.

## Building Blocks of Node.js

- Reactor Pattern
- [libuv](http://docs.libuv.org/en/v1.x/)
- A set of Bindings
- Chrome’s V8
- Core JS Library

## libuv

Pronounced as “lib u v”, is library written in C language to make Node.js compatible with every OS and provide the non-blocking I/O behaviour. libuv is the low-level engine that implements reactor pattern thus providing an API for creating the Event Loop, managing an Event Queue and running asynchronous I/O operations. It is built specifically to provide a unified experience over different Operating Systems.

## Need for libuv?

Each operating system has its own interface for the demultiplexer. Such as Kqueue for Mac OS X, IOCP for Windows and Epoll for Linux. Different multiplexers will behave differently when handling an I/O request. And then, each I/O operation can differ in its behaviour within the same operating system. This creates an inconsistency and to overcome this inconsistency libuv is the solution.

I am not going to talk about internal workings of libuv here, not an expert on that, myself. For more info on libuv [check their docs](http://docs.libuv.org/) or this [slide](http://www.slideshare.net/saghul/libuv-nodejs-and-everything-in-between) by Saúl Ibarra Corretgé [(@saghul)](https://twitter.com/saghul) is a good start.

[Also, libuv is independently maintained by awesome developers.](https://github.com/libuv/libuv)

## Set of Bindings

These set of bindings are responsible for wrapping and exposing libuv and other low-level functionality to JavaScript.

## V8

It’s a runtime engine[ developed by Google for Chrome browser for JavaScript](https://developers.google.com/v8/). It is the reason Node.js is fast and efficient.

## Core Library

This is a JavaScript library that implements high-level Node.js API (a.k.a. node-core).

<img src='https://miro.medium.com/max/451/1*dTYKv5fII4doUAqJSA51Qg.png' />

The image borrowed above clarifies and represents a complete Node.js System. I hope this article has made things more clear as it did to me.

> [Orignally Published at Hackernoon.com](https://medium.com/hackernoon/the-node-js-system-51090c35dddc)


The Node.js system

---
title: 'The Node way - Philosophy of a Platform'
date: '2016-03-10'
thumbnail: '/thumbnails/node.png'
slug: 'the-node-way'
tag: 'nodejs'
canonicalUrl: 'https://amanhimself.dev/blog/the-node-way/'
---

Last week, when [Node.js](https://nodejs.org/en/blog/) community introduced its logo, it got me into thinking of why this technology as fresh in my mind as when I was first introduced to it a few months back. Why is that spark still ignited in the back of my head? The answer to this is the philosophy behind the technology of Node.js platform.

Every platform has its own philosophy, its own set of rules, its own principles and guidelines. This is necessary for the evolution of a platform and is important for developing an application using that platform. (Otherwise, we all can get carried away.) Node.js has its own philosophy, since its a platform, and it manages to find a middleground between JavaScript and UNIX.

Two of the most important principles of UNIX that are adaptable in Node.js are:

- Modularity, keeping simple parts short, connected with clean interfaces.
- A program should do one thing and it should do that awesomely.

Other rules described by Eric Steven Raymond in [The Art of UNIX Programming](http://www.catb.org/esr/writings/taoup/html/index.html) might fit to some extent but the two aforementioned are necessary to use Node.js pragmatically.

In Node.js this pragmaticism is provided the by a ‘module’. Module is the fundamental to structure the code of a program in Node.js. Module is also the building block of a package. (A package is any application or reusable libraries).

The principle here is to design small modules in terms of code and in terms of application scope. This principle provides:

- reusability of code
- easier to understand the code
- thus, making it simple to test and maintain

---

Another important aspect in the Node Philosophy is the dependency of each package. Writing a Node.js application, one tends to use a lot of packages (which is the genesis of Node.js Ecosystem: npm) and this might create a common problem known as: dependency hell. To overcome this conflict, Node.js manages dependencies of each installed package to have its own separate set of dependencies.


🔥 33 Posts filtered by tag "nodejs"