DEV Community: Muhammed Sarbast

Advanced Authentication in Node.js with Auth0

Muhammed Sarbast — Fri, 16 Jun 2023 22:52:55 +0000

Introduction:

Node.js provides an ideal environment to create server-side applications, with the possibility to employ different authentication strategies. One of the powerful tools you can use is Auth0, a flexible, drop-in solution to add authentication and authorization services to your applications. This blog will explore advanced usage of Auth0 with Node.js.

Prerequisites:

Basic knowledge of Node.js and Express.js
Familiarity with Auth0
An Auth0 account

Creating a Node.js Application:

Create a new directory for your application and initialize it with a package.json file. This can be done by running the following commands:

mkdir myAuthApp && cd myAuthApp
npm init -y

Setting Up Auth0:

Sign up or log into your Auth0 account. Create a new 'Regular Web Application' and note down your 'Domain', 'Client ID', and 'Client Secret'. These values will be used later.

Implementing Auth0 in Node.js:

Install necessary packages by running: npm install express dotenv passport passport-auth0 express-session.

Create a .env file and add the following lines, replacing the placeholders with the credentials from Auth0.

AUTH0_CLIENT_ID=YOUR_CLIENT_ID
AUTH0_DOMAIN=YOUR_DOMAIN
AUTH0_CLIENT_SECRET=YOUR_CLIENT_SECRET
AUTH0_CALLBACK_URL=http://localhost:3000/callback
SESSION_SECRET=YOUR_RANDOM_VALUE

Configuring Passport:

Passport is the authentication middleware for Node.js. Passport-Auth0 strategy is employed for the Auth0 implementation. Set up passport with Auth0 strategy like this:

const passport = require('passport');
const Auth0Strategy = require('passport-auth0');

let strategy = new Auth0Strategy(
  {
    domain: process.env.AUTH0_DOMAIN,
    clientID: process.env.AUTH0_CLIENT_ID,
    clientSecret: process.env.AUTH0_CLIENT_SECRET,
    callbackURL: process.env.AUTH0_CALLBACK_URL || 'http://localhost:3000/callback'
  },
  function(accessToken, refreshToken, extraParams, profile, done) {
    return done(null, profile);
  }
);

passport.use(strategy);

passport.serializeUser(function(user, done) {
  done(null, user);
});

passport.deserializeUser(function(user, done) {
  done(null, user);
});

Securing Routes:

To secure routes, you can use the 'ensureLoggedIn' middleware from 'connect-ensure-login' package. It will redirect unauthenticated users to the login page.

const ensureLoggedIn = require('connect-ensure-login').ensureLoggedIn();
app.get('/user', ensureLoggedIn, (req, res) => {
    res.send(req.user);
});

Conclusion:

Auth0 offers a robust, highly customizable authentication and authorization service. It's easy to integrate with a Node.js application and can take a lot of the work off your shoulders when it comes to managing user authentication. The above guide gives a glimpse into the advanced application of Auth0. Always remember to keep your sensitive data secure and never expose your secrets in the client-side or public repositories.

Advanced Usage of tus.io with Node.js

Muhammed Sarbast — Fri, 09 Jun 2023 15:27:06 +0000

In this blog post, we'll delve into an advanced usage of tus.io, a robust open-source protocol for resumable file uploads to servers, with Node.js. The tus.io protocol, combined with the versatility of Node.js, can make file handling operations significantly smoother. We will consider a scenario where we need to upload large files and handle any connection interruptions seamlessly.

Setup

Firstly, we need to install the necessary libraries.

npm install tus-node-server express

Here we've installed tus-node-server, the Node.js implementation of tus.io, and express, a minimal and flexible Node.js web application framework.

Server Configuration

Let's start by setting up our server:

const tus = require('tus-node-server');
const express = require('express');
const server = new tus.Server();

server.datastore = new tus.FileStore({
    path: '/uploads'
});

const app = express();

app.all('*', (req, res) => {
  server.handle(req, res);
});

const host = 'localhost';
const port = 8000;
app.listen(port, host, () => {
  console.log(`Server running on http://${host}:${port}`);
});

Here, we're using the built-in FileStore datastore, which stores the uploaded files on disk at the specified path. Every request is then passed to our tus server to handle.

Client Configuration

On the client side, we can use the tus-js-client to handle the upload. We need to install it first:

npm install tus-js-client

Here is a simple upload example:

const tus = require('tus-js-client');
const fs = require('fs');
const path = require('path');

const file = fs.createReadStream(path.resolve(__dirname, 'largefile.txt'));
const size = fs.statSync(path.resolve(__dirname, 'largefile.txt')).size;

const upload = new tus.Upload(file, {
    endpoint: 'http://localhost:8000/files/',
    retryDelays: [0, 1000, 3000, 5000],
    metadata: {
        filename: 'largefile.txt',
        filetype: 'text/plain'
    },
    onError: function(error) {
        console.log("Failed because: " + error)
    },
    onProgress: function(bytesUploaded, bytesTotal) {
        let percentage = (bytesUploaded / bytesTotal * 100).toFixed(2);
        console.log(bytesUploaded, bytesTotal, percentage + "%")
    },
    onSuccess: function() {
        console.log("Download %s from %s", upload.file.name, upload.url)
    }
})

upload.start();

This script reads the file, prepares it for upload, and sets various callbacks for error handling, progress tracking, and upload success. The retryDelays option sets up automatic retries when the upload fails due to a connection interruption.

Extending Functionality

The beauty of the tus-node-server library is in its extensibility. The server emits various events that we can listen for and respond to. For example:

server.on(tus.EVENTS.EVENT_UPLOAD_COMPLETE, (event) => {
    console.log(`Upload complete for file ${event.file.id}`);
});

Wrapping up

By leveraging tus.io with Node.js, we can create powerful applications capable of handling large file uploads and connection interruptions seamlessly. While the basic implementation is straightforward, the true power of these tools lies in their flexibility and extensibility.

ObjectionJs & Advanced Techniques

Muhammed Sarbast — Thu, 08 Jun 2023 23:34:23 +0000

Objection.js is a highly flexible and performant Object-Relational Mapping (ORM) library for Node.js, designed to help you build efficient SQL queries with a delightful API. In this blog post, we'll delve into some advanced features that can take your Objection.js skill set to the next level.

1. Eager Loading

One of the greatest features in Objection.js is the ability to use eager loading, reducing the number of queries and thus the overall load on the database. Leveraging the .eager() method, you can load related data in a single query. But have you tried the modifyEager function? This allows you to apply transformations or additional conditions on your eagerly loaded data.

Person.query()
  .eager('pets')
  .modifyEager('pets', builder => builder.where('species', 'dog'))
  .then(persons => {
    // Each person in persons has a 'pets' property that contains only their dogs.
  });

2. Efficient Use of Transactions

Transactions in Objection.js are designed to help you manage your database operations efficiently, ensuring that related operations either all succeed or fail together, maintaining the integrity of your data. The .transaction() method makes it a breeze to use transactions, but you can enhance efficiency by reusing transaction instances for multiple queries.

const trx = await Person.startTransaction();

try {
  await Person.query(trx).insert({name: 'John'});
  await Pet.query(trx).insert({name: 'Fluffy', ownerId: 1});
  await trx.commit();
} catch (err) {
  await trx.rollback();
  throw err;
}

3. Graph Insertion and Upserts

Graph insertion is another Objection.js feature that can help reduce the amount of code you write and the number of database round-trips. It allows you to insert a graph of objects with relations in a single command.

await Person.query().insertGraph({
  name: 'Jennifer',
  pets: [{
    name: 'Fluffy',
    species: 'dog'
  }]
});

What's even more exciting is the combination of graph operations with upserts (update or insert). This is achieved using the upsertGraph method.

await Person.query().upsertGraph({
  id: 1,
  name: 'Jennifer',
  pets: [{
    id: 1,
    name: 'Fluffy',
    species: 'dog'
  }]
}, { relate: true, unrelate: true });

4. Query Context

With the .context() method, you can add a context to your queries, which can be accessed in all query lifecycle methods. This can be highly useful for passing request-specific data, such as the currently logged in user's ID.

Person.query()
  .context({userId: 1})
  .findById(1)
  .then(person => {
    // The context is accessible in person.$beforeInsert, person.$beforeUpdate etc.
  });

Objection.js is a powerful ORM with a host of features that can help developers write efficient, maintainable, and performant SQL-based applications in Node.js. Mastering its advanced features allows for even more refined control and optimization, which will truly help you stand out as a Node.js developer.