TypeScript é uma linguagem que se baseia em JavaScript, adicionando tipos estáticos e outros recursos avançados que melhoram a qualidade do código e a experiência do desenvolvedor. Integrar TypeScript com Node.js oferece uma série de benefícios, incluindo melhor autocompletar, refatoração segura e detecção de erros em tempo de compilação. Neste artigo, vamos explorar como configurar e utilizar TypeScript com Node.js, cobrindo desde a instalação até a criação de um projeto completo.

Pré-requisitos

Antes de começarmos, certifique-se de que você possui:

• Node.js e npm instalados em seu sistema.
• Conhecimento básico de JavaScript e Node.js.
• Familiaridade com os conceitos de programação orientada a objetos e tipos estáticos.

Passo 1: Instalando o TypeScript

Para começar, precisamos instalar o TypeScript globalmente em nosso sistema.

npm install -g typescript

Também vamos instalar o ts-node para poder executar arquivos TypeScript diretamente sem precisar transpilar manualmente.

npm install -g ts-node

Passo 2: Inicializando o Projeto

Crie um diretório para o seu projeto e inicialize um novo projeto Node.js.

mkdir my-typescript-node-project
cd my-typescript-node-project
npm init -y

Passo 3: Configurando o TypeScript

Dentro do diretório do projeto, crie um arquivo de configuração do TypeScript chamado tsconfig.json.

{
  "compilerOptions": {
    "target": "ES6",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  }
}

Passo 4: Instalando Tipos e Dependências

Instale os tipos necessários para Node.js e outras dependências que você possa precisar.

npm install @types/node

Passo 5: Criando o Estrutura do Projeto

Crie uma estrutura básica de diretórios e arquivos para o seu projeto.

mkdir src
touch src/index.ts

Passo 6: Escrevendo Código TypeScript

Vamos escrever um exemplo simples em TypeScript. Abra o src/index.ts e adicione o seguinte código:

const express = require('express');
const app = express();
const PORT = 3000;

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

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

Passo 7: Executando o Código

Para executar o código TypeScript diretamente, use o ts-node.

ts-node src/index.ts

Exemplos de Uso Avançado

1. Usando Interfaces

TypeScript permite definir interfaces que podem ser usadas para garantir a tipagem correta dos objetos.

interface User {
  id: number;
  name: string;
  email: string;
}

const getUser = (id: number): User => {
  return {
    id,
    name: 'John Doe',
    email: 'john.doe@example.com'
  };
};

const user = getUser(1);
console.log(user.name);

2. Classes e Herança

Com TypeScript, você pode utilizar classes e herança para estruturar seu código de maneira mais organizada.

class Animal {
  constructor(public name: string) {}

  move(distance: number) {
    console.log(`${this.name} moved ${distance} meters.`);
  }
}

class Dog extends Animal {
  bark() {
    console.log('Woof! Woof!');
  }
}

const dog = new Dog('Rex');
dog.bark();
dog.move(10);

3. Modularização

Organize seu código em módulos para melhorar a manutenção e a escalabilidade.

// src/math.ts
export const add = (a: number, b: number): number => a + b;

// src/index.ts
import { add } from './math';

const sum = add(5, 3);
console.log(`The sum is ${sum}`);

Integração com Ferramentas de Build

Para projetos maiores, é comum utilizar ferramentas de build como Webpack ou Babel. Aqui está um exemplo básico de configuração do Webpack para TypeScript.

Instalando Dependências

npm install --save-dev webpack webpack-cli ts-loader

Configuração do Webpack

Crie um arquivo webpack.config.js na raiz do seu projeto.

const path = require('path');

module.exports = {
  entry: './src/index.ts',
  module: {
    rules: [
      {
        test: /\.tsx?$/,
        use: 'ts-loader',
        exclude: /node_modules/,
      },
    ],
  },
  resolve: {
    extensions: ['.tsx', '.ts', '.js'],
  },
  output: {
    filename: 'bundle.js',
    path: path.resolve(__dirname, 'dist'),
  },
};

Adicionando Script ao package.json

Adicione o seguinte script ao seu package.json para construir o projeto.

"scripts": {
  "build": "webpack"
}

Executando o Build

npm run build

Conclusão

Integrar TypeScript com Node.js é uma excelente maneira de melhorar a qualidade e a manutenção do seu código. A tipagem estática, autocompletar e refatoração segura são apenas alguns dos benefícios que você obterá ao utilizar TypeScript. Com a configuração e as práticas adequadas, você poderá desenvolver aplicações robustas e escaláveis com maior facilidade.

---