DEV Community: Leandro Andrade

Authenticate users with Firebase

Leandro Andrade — Sun, 05 Jun 2022 16:52:00 +0000

Every day a mount of applications need to authenticate users, maybe to do something or to access some feature. Anyway, authentication is an important part of any software and at moment is not a smart decision to create our own solution.

Exist a lot of solutions for authenticating users, some of those are free, and some are paid based on amount of users. A solution that I really like is Google Firebase Auth because is free, simple, has amazing documentation, and works pretty well.

Firebase provide for us a lot of type of authentication using email, Facebook, Google... I'd suggest to check the documentation for more details.

Our purpose is to show the simplest way how to authenticate and register users using just an email and passowrd.

First of all, we need to create a directory called sample-firebase-auth, enter into it and start a new Node.js project using:

npm init -y

After that, just install firebase dependency:

npm i firebase

Now, lets create a file called firebase.js:

touch firebase.js

Our base project is configured. Now, we need to create a new project into firebase console. Let's show the images below to see show to do this. Lets go to firebase console https://console.firebase.google.com and click on Add project.

Type a name for your project and click on Continue

For our purpose, disable Google Analytics and click in Create project

Wait for a couple of seconds and our project will be created. Click on Continue

Now, we need to enable authentication using email. Let's click on Authentication

Select Sign-in method and click in Email/Password

Enable Email/Password and click in Save

Now, we need to get our firebase credentials. Let's go back to your main console page and click on Web App

Create an app nickname and click on Register app

After that, copy the content of firbeaseConfig variable. This is the credentials that we need.

We did all of the things that we needed. Let's go to the code and create our base structure to start our sample:

const firebase = require('firebase/app');
const {
    getAuth,
    signInWithEmailAndPassword,
    createUserWithEmailAndPassword,
} = require('firebase/auth');

const firebaseConfig = {
    apiKey: "YOU_API_KEY",
    authDomain: "YOUR_AUTH_DOMAIN",
    projectId: "YOUR_PROJECT_ID",
    storageBucket: "YOUR_STORAGE_BUCKET",
    messagingSenderId: "YOUR_SENDER_ID",
    appId: "YOUR_APP_ID"
  };

firebase.initializeApp(firebaseConfig);

The firebase library segregates different types of functions into sub dependencies like firebase/app and firebase/auth.

After initializing our firebase app, we can build a function that creates a user and a password into firebase:

async function createUser(auth, email, password) {
    try {
        const signUp = await createUserWithEmailAndPassword(
            auth,
            email,
            password
        );
        console.log('Create user:', signUp.user.uid);
    } catch (err) {
        // auth/weak-password
        if (err.code === 'auth/email-already-in-use') {
            console.error('User already registered!');
        } else {
            console.error(err);
        }
    }
}

Now, we can run this function and see the uid created by firebase:

async function run() {
    const auth = getAuth();
    const email = 'firebase_auth@gmail.com';
    const password = '123456';

    await createUser(auth, email, password);
}
run().catch(console.error);

We can check into firebase console and see our user created.

If you try to run this function more than one time with the same values, you will see a message User already registered!. Great, firebase validate this for us.

Now, lets create a function that authenticate our users:

async function login(auth, email, password) {
    try {
        const signIn = await signInWithEmailAndPassword(
            auth,
            email,
            password
        );
        console.log('Login user:', signIn.user.uid);
    } catch (err) {
        if (err.code === 'auth/wrong-password') {
            console.error('Invalid user or password!');
        } else {
            console.error(err);
        }
    }
}

Now, we can run this function and see the uid of the user previously created:

async function run() {
    const auth = getAuth();
    const email = 'firebase_auth@gmail.com';
    const password = '123456';
    await login(auth, email. password);
}
run().catch(console.error);

If you change the password and send a new request, you will see the message Invalid user or password!.

Exist a lot of functions in Firebase like change password, signout, and some other things. Is good to see the documentation.

Here is the source code: https://github.com/leandroandrade/sample-firebase-auth

I hope that it will help you.

Thanks!!!

Fastify - your next Web Framework

Leandro Andrade — Fri, 27 May 2022 16:50:43 +0000

Recently I started to develop some API's using Fastify and I really impressed.

Basically, Fastify is a modern web framework that was built to be high performant, extensible with concepts about decorators and plugins, schema-based, logging, developer-friendly, and typescript ready. This framework has a big active community that for me is really important when I choose a library.

What really impressed me was the big ecosystem with a hundred core and community plugins, the philosophy behind decorators and plugins that really give us powerfully on our applications, and how fast Fastify handles requests.

The best thing about it is if you want to not use their plugin, like fastify-mongodb, is not a problem. The framework allows you to use mongodb in your way. Seriously, I really like the plugins, it is awesome.

But, and the Express?

Yes, Express is a big web framework and exists a lot of projects stable in production. In case you use or like express, it is ok, no problem. But I suggest that in your next project, give a chance to Fastify and I believe that it will surprise you.

As I said, I developed some products using Fastify, and to help me with the basic configurations and other stuffs, I decided to create a base project on my Github in my own way. Feel free to use it.

https://github.com/leandroandrade/fastify-cjs

Anyway, I continue studying Fastify and how to create great solutions using this framework. I don't know everything about the framework, but I in continuing to learn to do my best job.

I hope that it helps you.

Estratégia de timeout cache com Node.js e Redis

Leandro Andrade — Mon, 18 Jan 2021 10:32:30 +0000

Um dos assuntos que considero mais incríveis é performance. Sobre performance de API's Rest, uma das formas mais conhecidas de melhorar o tempo de resposta de requisições à API é utilizando cache.

Cache permite acesso rápido a dados que são solicitados com maior frequência. Com isso, temos menos acesso à base de dados, com isso ganhamos mais velocidade em responder a solicitações que nossa API venha a receber.

Para isso, um dos bancos de dados mais utilizados na estratégia de cache é o Redis, solução de dados em memória simples, eficiente e que entrega uma performance excelente.

Mas um detalhe que deve ser observado quando utilizamos estratégias de cache é determinar um timeout para acesso aos dados, pois podemos ter uma indisponibilidade de acesso ao cache e não queremos que nossa aplicação fique aguardando um longo período de tempo até obter uma resposta.

Em API's que utilizam Node.js, podemos conseguir essa estratégia utilizando duas bibliotecas, quais são:

ioredis: cliente Redis para conexão com a base de dados;
bluebird: biblioteca que adiciona recursos ao trabalhar com Promises;

A biblioteca ioredis já utiliza Promises nas suas funções, mas o que podemos fazer é adicionar comportamentos extras, fazendo com que o ioredis passe a utilizar as funções de Promises disponibilizadas pelo bluebird.

Configuramos esse comportamento da seguite forma:

const Redis = require("ioredis");
const Promise = require('bluebird');

// cancelamos a Promise original
Promise.config({ cancellation: true });

// alteramos para utilizar as funções de Promise do bluebird.
Redis.Promise = Promise;

Configuramos o trecho Promise.config({ cancellation: true }) para informar que queremos que a Promise que originou a solicitação seja cancelada após o timeout ser atingido, assim o comando não ficará "tentando" enviar ao Redis.

Após esta configuração, podemos alterar o comportamento do acesso ao cache adicionando a função timeout que a biblioteca bluebird disponibiliza. Criamos a função que acessa os dados do cache da seguinte forma:

exports.getCache = async (key) => {
    return Redis.client().get(key)
        .timeout(2000)
        .then(cache => cache ? (console.log(`REDIS: data from cache!`), JSON.parse(cache)) : null)
        .catch(err => console.log('ERROR_REDIS: Timeout exceeded!'));
}

Agora o comportamento será o seguinte: caso o cache não responda à solicitação em 2000 milissegundos (2 segundos), apenas informamos que o timeout do cache foi excedido e seguimos o fluxo da aplicação. Assim, temos oportunidade de pensar em alguma outra estratégia na nossa API, como buscar a informação em outra base de dados, acessar uma API externa, etc.

Podemos fazer a mesma coisa com a função que registra o dado no cache:

exports.setCache = async (key, value) => {
    const newKey = getKey({ key });
    Redis.client().set(newKey, JSON.stringify(value), 'EX', 120)
        .timeout(2000)
        .then(() => console.log(`REDIS: key ${ key } set cache!`))
        .catch(err => console.log('ERROR_REDIS: Timeout exceeded'));
}

Agora o comportamento será o seguinte: caso o cache não responda em 2000 milissegundos (2 segundos), apenas informamos que o timeout do cache foi excedido e seguimos o fluxo da aplicação.

Podemos fazer outras melhorias nas funções que recuperam e inserem os dados no cache, como apresentar no log algum erro que possa acontecer, mas preferi deixar o mais simples e claro para que possamos deixar nosso foco no comportamento esperado.

Conclusão

Desenvolver API's em Node.js utilizando o Redis como estratégia de cache torna-se uma excelente alternativa. Trabalhar com as bibliotecas ioredis e bluebird nos permite adicionar comportamentos extras. Com isso, conseguimos construir uma API mais resiliente e que entregue mais valor ao usuário final.

Desenvolvi um exemplo de API em Node.js utilizando MySQL e Redis com estratégia de cache apresentada aqui. Caso queira ver o código, acesse: https://github.com/leandroandrade/ncache

Experimente alterar o valor da função timeout e veja como a API se comporta.

Espero ter ajudado e divirtam-se.

Cache timeout strategy with Node.js and Redis

Leandro Andrade — Mon, 18 Jan 2021 10:23:55 +0000

A topic that I consider most incredible is related to performance. About Rest API's performance, the best known ways to improve the response time of API requests is by using cache.

Cache allows quick access to data that is requested most often. With this, we have less access to the database, and we get more speed in responding to requests that our API may be receive.

For this, one of the most used databases in the cache strategy is Redis, a memory data solution that is simple, efficient and that delivers excellent performance.

But a detail that we must observe when using cache strategies is to determine a timeout for accessing data, because we can have an unavailability of access to the cache and we do not want our application waiting a long period of time to obtain an answer.

In APIs that use Node.js, we can achieve this strategy using two libraries, which are:

ioredis: Redis client for connection to the database;
bluebird: library that adds resources when working with Promises;

The ioredis library already uses Promises in our functions, but what we can do is add extra behaviors, making ioredis start using the Promises functions provided by bluebird.

We can set this behavior as it follows:

const Redis = require("ioredis");
const Promise = require('bluebird');

// Promise original enable for cancelation
Promise.config({ cancellation: true });

// Change to use bluebird Promises.
Redis.Promise = Promise;

We have set the Promise.config ({cancellation: true}) snippet to define that we want the Promise that originated the request to be canceled after the timeout is reached, so the command will not be "trying" to send to Redis.

After that, we can change the behavior of the cache access by adding a function timeout that bluebird library provided. We create a function that accesses the cache data as it follows:

exports.getCache = async (key) => {
    return Redis.client().get(key)
        .timeout(2000)
        .then(cache => cache ? (console.log(`REDIS: data from cache!`), JSON.parse(cache)) : null)
        .catch(err => console.log('ERROR_REDIS: Timeout exceeded!'));
}

Now the behavior will be as it follows: if the cache does not respond the request in 2000 milliseconds (2 seconds), we only print that cache timeout has been exceeded and we follow the application flow. So we have the opportunity to think of some another strategies in our API like searching for information in other database, accessing an external API, etc.

We can do the same thing with the function that registers the data in the cache:

exports.setCache = async (key, value) => {
    const newKey = getKey({ key });
    Redis.client().set(newKey, JSON.stringify(value), 'EX', 120)
        .timeout(2000)
        .then(() => console.log(`REDIS: key ${ key } set cache!`))
        .catch(err => console.log('ERROR_REDIS: Timeout exceeded'));
}

Now the behavior will be as it follows: if the cache does not respond in 2000 milliseconds (2 seconds), we only print the cache timeout has been exceeded and we follow the application flow.

We can make other improvements in the functions that retrieve and insert the data in the cache, such as printing an error that may be happen, but I preferred to make it as simple and clear as possible for that we can focus on the expected behavior.

Conclusion

Developing API's in Node.js using Redis as a cache strategy becomes an excellent alternative. Working with the ioredis and bluebird library allows us to add extra behaviors. With that, we were able to build a more resilient API that improve better experience to the user.

I developed some example API in Node.js using MySQL and Redis with cache strategy presented here. If you like to see the code, access: https://github.com/leandroandrade/ncache

Try to change the timeout function and see how the API behavior

I hope I helped and have fun.

Base Node.js project

Leandro Andrade — Wed, 06 Jan 2021 12:31:33 +0000

Hi guys, I'd like to share my minimalistic boostrap Node.js project, node-essential. The propose of node-essential is a base structure to start a development with Node.js.

Sometimes we needed do create a new Node.js project with a base structure and base libraries to start a Web API's, swagger documentation and so fourfh.

In this project, I am create a base structure using clean architecture principles.

Please, check out on my github: https://github.com/leandroandrade/node-essential

I hope it helps you, just as it is helping me. Thank you and have fun!!!