DEV Community: CodeInit

Hono

CodeInit — Thu, 01 May 2025 03:07:46 +0000

Installing and managing Node.js with NVM

CodeInit — Mon, 20 Jan 2025 07:23:41 +0000

In 2025, Node.js remains an essential tool for JavaScript development. This detailed guide covers not only installing Node.js on different platforms but also advanced usage of Node Version Manager (NVM) for efficient management of multiple versions.

What is NVM?

NVM (Node Version Manager) is a command-line tool that allows developers to manage multiple versions of Node.js easily.

Key Features of NVM:

Enables installation, switching, and removal of different Node.js versions on a single machine.
Provides a simple interface for managing Node.js versions via terminal commands.
Allows running multiple Node.js versions on the same computer.
Facilitates switching between Node.js versions for different projects, avoiding compatibility issues.
Also manages npm (Node Package Manager) installations corresponding to each Node.js version.
Works on Unix systems, macOS, and Windows (via WSL).

NVM is particularly useful for developers working on projects that require specific Node.js versions, allowing seamless switching between them and avoiding version conflicts.

Alternative Note: If you prefer a traditional installation, you can download the official installer directly from the Node.js website at https://nodejs.org, where you will find specific versions for each operating system with pre-configured installers.

Installing NVM

On macOS and Linux:
Open the terminal and run the installation command:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash

Update the shell profile:

source ~/.bashrc # For bash
source ~/.zshrc  # For zsh

Verify the installation:

nvm --version

On Windows:
Download the nvm-windows installer from GitHub, run the installer, and follow the instructions.

Open a new command prompt and verify the installation:

nvm version

Installing Node.js with NVM

After installing NVM, you can easily manage different Node.js versions.

Installing the latest LTS version:

nvm install --lts

Installing a specific version:

nvm install 16.14.0

Listing installed versions:

nvm ls

Switching between versions:

nvm use 16.14.0

Advanced Configuration for Projects

To ensure consistency in team projects, create an .nvmrc file in the project root:

16.14.0

Then, any team member can simply run:

nvm use

Tips and Best Practices

Always use the LTS version for production projects. Regularly update NVM to the latest version.
Implement .nvmrc files in all projects for team consistency.
Back up global npm configurations before switching versions.
Use npm scripts to automate version switching across environments.

Advanced NVM Features

Custom Aliases:

nvm alias myproject 14.17.0
nvm use myproject

Running Commands with Specific Versions:

nvm exec 14.17.0 node script.js

Installing Global Packages Per Version:

nvm use 14.17.0
npm install -g yarn

Common Troubleshooting

PATH Conflicts: Check your shell profile configuration.
Permissions on macOS/Linux:

sudo chown -R $(whoami) ~/.nvm

Performance on Windows: Consider using the Windows Subsystem for Linux (WSL) for a Unix-like experience.

Conclusion

In 2025, efficiently using NVM to manage Node.js installations is more critical than ever. With the rapid evolution of the JavaScript ecosystem, the ability to easily switch between Node.js versions and manage multiple development environments is essential for modern developers. By mastering NVM and following the best practices outlined in this guide, you’ll be well-equipped to tackle the challenges of contemporary Node.js development, ensuring flexibility, consistency, and efficiency in your projects.

Originally published on https://codeinit.dev/blog/instalacao-e-gerenciamento-do-nodejs-com-nvm

How to setup a Node.js API with TypeScript in 2025

CodeInit — Thu, 02 Jan 2025 19:53:54 +0000

Nowadays, creating an efficient and scalable API with Node.js and TypeScript is simpler and more powerful than ever. At CodeInit, we aim to deliver practical and straightforward tutorials to help you build professional solutions that meet market demands. In this article, I’ll walk you step-by-step through setting up a modern API using the best practices for 2025.

Whether you're a beginner or an experienced developer looking to boost your workflow, this guide is for you. Let’s dive into it together!

Why Use Node.js and TypeScript?

Node.js remains one of the most popular backend technologies, and when combined with TypeScript, you get the best of both worlds: speed and safety. TypeScript adds static typing, making your code easier to maintain and reducing common errors.

In 2025, mastering tools that boost productivity and align with market trends is essential.

What You Need Before Starting

Before getting started, make sure your environment is set up correctly. Here are the prerequisites:

Node.js 20 or later
Text Editor – I recommend Visual Studio Code
Basic knowledge of JavaScript and terminal
npm, yarn, or pnpm installed on your system

Tip: Use the integrated terminal in VS Code to follow this tutorial more easily.

Personally, I like using pnpm. To install pnpm globally, use the command below:

npm i -g pnpm

Step 1: Setting Up the Environment

First, ensure that Node.js is installed:

node -v

If everything is set up correctly, you should see the Node.js version. Otherwise, download the latest version from the official website.

Now, let’s create the project structure:

mkdir my-api && cd my-api
pnpm init -y

This command creates the package.json file, which manages the project dependencies.

Step 2: Installing TypeScript

TypeScript is essential for maintaining and organizing larger projects. Let’s install it:

pnpm install typescript tsx @types/node -D

Next, configure TypeScript by creating a tsconfig.json file:

npx tsc --init

Edit the file to reflect the best practices for 2025:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "CommonJS",
    "strict": true,
    "outDir": "dist",
    "rootDir": "src"
  }
}

Create the src directory to organize your code:

mkdir src

Step 3: Adding ESLint

Maintaining clean code is crucial. Let’s add ESLint to ensure quality and standardization.

Use the command below to configure ESLint:

pnpm create @eslint/config@latest

Recommended ESLint Settings

How would you like to use ESLint? (To check syntax and find problems)
What type of modules does your project use? (JavaScript modules (import/export))
Which framework does your project use? (None)
Does your project use TypeScript? (Yes)
Where does your code run? (Node)
Would you like to install them now? (Yes)

Once installed, the eslint.config.js file will be created in the project root.

Here’s an example configuration:

import pluginJs from '@eslint/js';
import globals from 'globals';
import tseslint from 'typescript-eslint';

/** @type {import('eslint').Linter.Config[]} */
export default [
  { files: ['**/*.{js,mjs,cjs,ts}'] },
  { languageOptions: { globals: globals.node } },
  pluginJs.configs.recommended,
  ...tseslint.configs.recommended,
  {
    rules: {
      semi: 'off',
      quotes: ['error', 'single']
    }
  }
];

Add ESLint Commands

Add the following scripts to package.json:

"scripts": {
  "lint": "npx eslint ./src/**",
  "lint:fix": "npx eslint ./src/** --fix"
}

The first command runs ESLint and displays errors in the console, while the second tries to fix the errors automatically.

Run:

pnpm lint

pnpm lint:fix

Step 4: Building the API

Creating the Health Check Route

Now it’s time to get started with your API. Let’s use Express, a minimalist framework for Node.js.

Install Express and its types:

pnpm add express @types/express

Create the src/index.ts file and add the following code:

import express, { Request, Response } from 'express';

const app = express();
app.use(express.json());

// Health check route with defined types
app.get('/health', (req: Request, res: Response) => {
  res.status(200).json({ status: 'API is running successfully!' });
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

Add the following script to package.json:

"scripts": {
  ...
  "start": "tsx watch src/index.ts"
}

Run:

pnpm start

Visit: http://localhost:3000/health to check the API health.

Adding the Pokémon Route

Let’s expand the API with a route that returns a list of Pokémon.

Update src/index.ts with the following code:

// Interface to define a Pokémon type
interface Pokemon {
  id: number;
  name: string;
  type: string;
}

// Sample data
const pokemons: Pokemon[] = [
  { id: 1, name: 'Pikachu', type: 'Electric' },
  { id: 2, name: 'Charmander', type: 'Fire' },
  { id: 3, name: 'Bulbasaur', type: 'Grass/Poison' }
];

// Route to return the list of Pokémon
app.get('/pokemons', (req: Request, res: Response<Pokemon[]>) => {
  res.status(200).json(pokemons);
});

Test the route: http://localhost:3000/pokemons.

Conclusion

In this guide, you learned how to set up a modern API with Node.js and TypeScript, starting with a simple route and expanding it to include typed data. This is just the beginning! With this foundation, you can implement authentication, database connections, and much more.

If you found this article helpful, share it with other developers and subscribe to our newsletter for more tips. Let’s conquer the development world together! 🚀

Melhorando seus commits com lefthook e conventional commits

CodeInit — Sat, 28 Dec 2024 21:47:16 +0000

Os commits bem estruturados são fundamentais para a manutenção e evolução de qualquer projeto de software. Ferramentas como Husky já são bastante conhecidas no mundo JavaScript para gerenciar git hooks, mas uma alternativa poderosa, eficiente e fácil de usar tem ganhado destaque: Lefthook.

Neste tutorial, você aprenderá:

O que é o Lefthook e por que ele é uma alternativa ao Husky.
Como configurar o Lefthook em um projeto Node.js.
Integrar o Conventional Commits para garantir mensagens de commit padronizadas.
Criar uma configuração prática para automatizar verificações e garantir qualidade no seu fluxo de commits.

O que é o Lefthook e Por que Escolher Ele?

O Lefthook é uma ferramenta para gerenciar git hooks, como o Husky, mas oferece algumas vantagens significativas:

Performance Superior: Ele é mais rápido que o Husky, especialmente em projetos maiores.
Configuração Simples e Flexível: O Lefthook usa um único arquivo YAML para configurar seus hooks, o que facilita a manutenção.
Multiplataforma: Suporte nativo a Windows, Linux e macOS.
Execução em Paralelo: Ele permite rodar tarefas paralelamente, reduzindo o tempo de execução.

Por que trocar o Husky pelo Lefthook?

Embora o Husky seja amplamente usado, ele introduz dependências no package.json e scripts adicionais, o que pode complicar a configuração em equipes ou ambientes CI/CD. O Lefthook, por outro lado, funciona fora do package.json, mantendo seu projeto mais limpo.

O legal é que o Lefthook funciona para qualquer stack de projeto desde que você tenha o NodeJS instalado.

Dica: Como criar um projeto NodeJS

Como configurar o Lefthook?

Instalando o Lefthook

Instale o lefthook no seu projeto:

pnpm add -D @evilmartians/lefthook

Configurando o Lefthook

Crie o arquivo de configuração lefthook.yml na raiz do seu projeto:

# lefthook.yml
pre-commit:
  parallel: true
  commands:
    lint:
      run: npm run lint
    test:
      run: npm run test

commit-msg:
  commands:
    conventional-commit:
      run: npx commitlint --edit $1

Este exemplo define um hook de pre-commit que roda tarefas de lint e testes.
Configura um hook de commit-msg para verificar se a mensagem segue o Conventional Commits.

Caso você ainda não consegue o padrão de conventional commits, sugiro que acesso esse link.

Mas basicamente é uma forma padronizada de colocar mensagens nos commits, tornando o processo de commit padronizado e organizado. Além de contar com ferramentas para fazer bump de versão e geração de CHANGELOG baseado em commits.

Instalando os Hooks

Execute o comando abaixo para instalar os hooks no repositório:

npx lefthook install

Esse comando fará com os hooks do git sejam instalado.

Nota: o projeto deve estar dentro de um repositório git.

Configurando o Conventional Commits

Adicione o Commitlint e as dependências necessárias:

pnpm add -D @commitlint/{config-conventional,cli}

Adicione um arquivo de configuração chamado commitlint.config.js na raiz do seu projeto:

module.exports = {
  extends: ['@commitlint/config-conventional'],
};

Adicione um script no package.json para facilitar a execução manual do Commitlint:

"scripts": {
  "lint:commit": "commitlint --from=HEAD~1"
}

Automatizando e Garantindo Qualidade

Agora que configuramos o Lefthook e o Commitlint, toda vez que você fizer um commit:

O Lefthook rodará as verificações configuradas antes de finalizar o commit.
O Commitlint validará se sua mensagem de commit está no formato correto.

Exemplo de conventional commit:

feat: adicionar funcionalidade de login

- Implementa autenticação via JWT.
- Adiciona testes para a funcionalidade.

BREAKING CHANGE: A API agora requer autenticação em todas as rotas.

Se a mensagem não seguir o formato esperado, o commit será rejeitado.

Agora toda vez que você executar git commit -m ... o Lefthook executará o pre-commit para validar se o seu commit está seguindo as convenções.

Conclusão

Com o Lefthook e o Conventional Commits, você eleva o padrão de qualidade do seu projeto Node.js, garantindo commits bem formatados e processos automatizados. Além disso, ao substituir o Husky pelo Lefthook, você obtém ganhos de performance e simplicidade na configuração.

Que tal começar a usar o Lefthook hoje mesmo? Experimente e compartilhe sua experiência!

Como configurar uma API Node.js com TypeScript em 2025

CodeInit — Wed, 25 Dec 2024 17:05:59 +0000

Hoje em dia, criar uma API eficiente e escalável com Node.js e TypeScript é mais simples e poderoso do que nunca. No CodeInit, gostamos de abordar tutoriais de maneira prática e direta, ajudando você a construir soluções profissionais que o mercado realmente pede. Neste artigo, vou te mostrar, passo a passo, como configurar uma API moderna utilizando as melhores práticas para 2025.

Se você é iniciante ou mesmo um desenvolvedor experiente buscando acelerar seu workflow, este guia é para você. Vamos juntos nessa jornada!

Por que usar Node.js e TypeScript?

Node.js continua sendo uma das tecnologias mais populares para backend, e quando combinado com TypeScript, você tem o melhor dos dois mundos: velocidade e segurança. TypeScript adiciona tipagem estática, o que torna seu código mais fácil de manter e reduz erros comuns.

Em 2025, é fundamental dominar ferramentas que trazem produtividade e que estão alinhadas com o mercado.

O que você precisa antes de começar

Antes de iniciar, você precisa garantir que o ambiente está preparado. Aqui estão os pré-requisitos:

Node.js 20 ou superior
Editor de texto - Recomendo o Visual Studio Code
Conhecimento básico de JavaScript e terminal
npm, yarn ou pnpm instalado no sistema

Dica: Use o terminal integrado do VS Code para seguir este tutorial mais facilmente.

Eu particularmente gosto de usar o pnpm. Para instlar o pnpm globalmente utitlize o comando abaixo:

npm i -g pnpm

Passo 1: Configurando o ambiente

Primeiro, certifique-se de que o Node.js está instalado:

node -v

Se tudo estiver certo, você deve ver a versão do Node.js. Caso contrário, instale a versão mais recente pelo site oficial.

Agora, vamos criar a estrutura do projeto:

mkdir minha-api && cd minha-api
pnpm init -y

Esse comando cria o arquivo package.json, que gerencia as dependências do projeto.

Passo 2: Instalando o TypeScript

TypeScript é essencial para quem busca manutenção e organização em projetos maiores. Vamos instalá-lo:

pnpm install typescript tsx @types/node -D

Agora, configure o TypeScript criando um arquivo tsconfig.json:

npx tsc --init

Edite o arquivo para refletir as melhores práticas de 2025:

{
   "compilerOptions": {
    "target": "ES2022",
    "module": "CommonJS",
    "strict": true,
    "outDir": "dist",
    "rootDir": "src"
  }
}

Crie o diretório src onde vamos organizar nosso código:

mkdir src

Passo 3: Adicionando ESLint

Manter um código limpo é crucial. Vamos adicionar o ESLint para garantir qualidade e padronização.

Utilize o comando abaixo para configurar o ESLint:

pnpm create @eslint/config@latest

Configurações recomendadas para o ESLint

How would you like to use ESLint? (To check syntax and find problems)
What type of modules does your project use? (JavaScript modules (import/export)
Which framework does your project use? (None)
Does your project use TypeScript? (Yes)
Where does your code run? (Node)
Would you like to install them now? (Yes)

Apos a instalação, o arquivo eslint.config.js será criado na raiz do seu projeto.

Abaixo eu vou deixar a minha configuração, mas você configurar o ESlint com as regras que desejar.

import pluginJs from '@eslint/js'
import globals from 'globals'
import tseslint from 'typescript-eslint'

/** @type {import('eslint').Linter.Config[]} */
export default [
  {files: ['**/*.{js,mjs,cjs,ts}']},
  {languageOptions: { globals: globals.node }},
  pluginJs.configs.recommended,
  ...tseslint.configs.recommended,
  {
    rules: {
      semi: 'off',
      quotes: ['error', 'single']
    }
  }
]

Vamos agora criar os comandos para executar o ESlint, adione os scripts no package.json:

...
"scripts": {
  "lint": "npx eslint ./src/**",
  "lint:fix": "npx eslint ./src/** --fix"
}

O primeiro comando roda o ESlint e mostra os erros no console, o segundo tenta fazer o fix do erros de forma automatica.

Execute no terminal:

pnpm lint

pnpm lint:fix

Passo 4: Construindo a API

Criando a rota de saúde

Agora é hora de colocar a mão na massa e criar nossa API. Vamos usar o Express, um framework minimalista para Node.js.

Instale o Express e seus tipos:

pnpm add express @types/express

Crie o arquivo src/index.ts e adicione o seguinte código:

import express, { Request, Response } from 'express'

const app = express()
app.use(express.json())

// Rota de saúde com tipos definidos
app.get('/health', (req: Request, res: Response) => {
  res.status(200).json({ status: 'API rodando com sucesso!' });
})

app.listen(3000, () => {
  console.log('Servidor rodando na porta 3000');
})

Para rodar o servidor, adicione o seguinte script ao package.json:

...
"scripts": {
  ...,
  "start": "tsx watch src/index.ts"
}

E execute: npm start

Você deve ver a mensagem: "Servidor rodando na porta 3000". Teste acessando: http://localhost:3000/health para verificar a saúde da API.

Adicionando a rota de Pokémons

Agora vamos expandir a API com uma rota que retorna uma lista de Pokémons.

Atualize o arquivo src/index.ts adicionando o seguinte código:

// Interface para definir o tipo de um Pokémon
interface Pokemon {
  id: number;
  name: string;
  type: string;
}

// Dados de exemplo
const pokemons: Pokemon[] = [
  { id: 1, name: 'Pikachu', type: 'Electric' },
  { id: 2, name: 'Charmander', type: 'Fire' },
  { id: 3, name: 'Bulbasaur', type: 'Grass/Poison' }
]

// Rota que retorna a lista de Pokémons
app.get('/pokemons', (req: Request, res: Response<Pokemon[]>) => {
  res.status(200).json(pokemons)
})

Agora teste acessando: http://localhost:3000/pokemons para obter a lista de Pokémons.

Conclusão

Neste guia, você aprendeu como configurar uma API moderna com Node.js e TypeScript, começando com uma rota simples e expandindo para incluir dados tipados. Este é apenas o começo! Com essa base, você pode implementar autenticação, conexão com bancos de dados e muito mais.

Se este artigo foi útil, compartilhe com outros desenvolvedores e inscreva-se na nossa newsletter para não perder as próximas dicas. Vamos juntos dominar o mundo do desenvolvimento!