DEV Community: humanfriend22

Load JSON into env in NodeJS

humanfriend22 — Mon, 07 Nov 2022 03:12:22 +0000

Almost all of us have heard of dotenv, which loads key-value pairs from .env into process.env so it is globally accessible.

But what if we don't want to install another package to perform a similar task? We can keep it as a one-liner to load a JSON file into process.env.

NodeJS has a built-in function called Object.assign which merges one object to another object. In our case, object 1 would process.env & object 2 would be our parsed JSON. We would then want to set process.env to our updated object.

EDIT: Object.assign automatically adds the values to the first object and doesn't create a new object (like Object.create) so we don't need the process.env = before the rest of the assignment.

Let's do exactly that:

console.log

humanfriend22 — Tue, 29 Mar 2022 23:35:53 +0000

~~This post is in response to this article~~

Instead of the code in the article, I suggest using this one because it allows multiple arguments:

This was more of a tip than a post which is why there is no explanation. Hope this helped!

Custom Parser for "pipe" Streams in NodeJS

humanfriend22 — Sun, 27 Feb 2022 05:48:22 +0000

This article will show a efficient way to modify data while its being piped, say to a client in Express.

Let's get started.

Take a normal NodeJS server:

const express = require('express');
const server = express();

const fs = require('fs')

server.get('/', (req, res) => {
   fs.createReadStream('/index.html').pipe(res);
});

server.listen(8080)

Here, we are using the fs.createReadStream function to pipe data without storing much in memory (RAM). This is completly fine. It's better than fs.readFile.

The Problem: If we want to dynamically make small edits to index.html based of say, the HTTP headers, this cute syntax doesn't have that functionality. Now, for anyone that has worked around streams in NodeJS, they know that the .pipes can be chained. One method that is not to different to the original code, we can use custom streams from the in-built stream module, and an awesome module called new-line from NPM.

This module only passes chunks of data to the next pipe only line by line. This means that it waits until it finds a new-line: \n. For example, if we have to replace "hello" with "world", we may get "he" in one chunk and "llo" in the next. This results in our function completely skipping the "hello".

Let's implement it:

const newLineStream = require('new-line');

server.get('/', (req, res) => {
   fs.createReadStream('/index.html')
    .pipe(newLineStream())
    .pipe(res);
});

Now, the client gets data line by line. We're one step closer!

Time for the lengthy part. Lets implement our custom parser with the Transform class from the stream module.

const newLineStream = require('new-line');
const { Transform } = require('stream');

class MyParser extends Transform {
   constructer() {
      super()
      this._transform = (chunk, encoding, cb) => {
         cb(null, chunk.toString().replace("hello", "world"))
      }
   }
}

server.get('/', (req, res) => {
   fs.createReadStream('/index.html')
    .pipe(newLineStream())
    .pipe(new MyParser())
    .pipe(res);
});

Lets break this down:

The class, constructer, and super just make a copy of the Transform class and load all the Transform functions.

The this._transform is declaring _transform for our class because that's what .pipe uses for _transforming the data.

The chunk parameter is the chunk of data that is of encoding specified by the encoding parameter. The cb parameter is a callback function. I pass null meaning that there is no error and the modified chunk data.

We can use this principle with chained .replaces and using the g flag with RegExp to manipulate data while keeping up our performance. After all, IO is the strong set of NodeJS.

That's it for this article. I hope this helped someone. I can be contacted at humanfriend22@gmail.com. Check out my github profile.

Custom SSL Certificates for Your Dev Environment

humanfriend22 — Fri, 18 Feb 2022 03:55:58 +0000

This article will explain how to setup a SSL certificate for all your HTTPS development needs.

Note: This is for development environments ONLY!

We will explore how to setup a certificate, tell our computer to trust it, how to use it in a basic NodeJS server, and how to delete the certificate from our trust store after we are done.

Step 1 (Installation)

We will be using a tool called mkcert:

Windows:

Via Chocolatey:

choco install mkcert

Via Scoop

scoop bucket add extras
scoop install mkcert

MacOS:

Via Brew

brew install mkcert

and (Firefox)

brew install nss

Other installation methods for macOS and Linux are on the mkcert github repo

Step 2 (Create the certificate)

The following command will create 2 files depending on your input

mkcert %your-domain-here%

Replace %your-domain-here% with the domain you would like to secure for your computer. As we are going to be using this for development, I shall use localhost as such:

mkcert localhost

For my command, the following 2 files were created:

That's it! Its as simple as that for creating the certificate.

Step 3 (Trusting the certificate)

Time to tell our computer that our certificate is alright to trust!

In the same directory as both of your files, run the following command regardless of your domain:

mkcert -install

On Windows, mkcert will kindly warn us of the danger:

The redacted information will be specific to your computer.

Done! Now our computer has no problem whatsoever with our certificate.

Step 4 (Using it!)

The following implementation is in NodeJS and uses the Express framework.

The following code will sum up exactly what we need:

const express = require('express');

const https = require('https');
const fs = require('fs');
const path = require('path');

const certificate = {
    key: fs.readFileSync(path.resolve('./localhost-key.pem')),
    cert: fs.readFileSync(path.resolve('./localhost.pem'))
}

const app = express();

app.get('/', function (req, res) {
    res.end('Am I secure?');
});

const server = https.createServer(certificate, app);

server.listen(443, () => {
    console.log('HTTPS server is UP! https://localhost/');
});

Run this server:

node server.js

We are officially using
HTTPS in a development environment!

You should be able to go to localhost and see that beautiful lock.

After every development session, I highly suggest you tell the computer to not trust the certificate just in case the certificate is accidently pushed to Git or the project is abandoned because we do not want to leave random certificates trusted.

The command to remove the certificate from the trust store is as below regardless of your domain:

mkcert -uninstall

NOTE: I had to restart my browser for the certificate to not be trusted

Well, that's it for SSL certificates for development. This is my first dev.to article so I hope this helped someone. I can be contacted at humanfriend22@gmail.com. Check out my github profile.

Bye! ✌