TypeScript doskonale nadaje się do pisania aplikacji backendowych w Node.js. Wprowadza większą stabilność i bezpieczeństwo kodu, oferując m.in. silne typowanie i lepsze wsparcie dla nowoczesnych funkcji ECMAScript.

W tym wpisie omówimy, jak skonfigurować i używać TypeScript w środowisku Node.js, oraz jakie korzyści płyną z jego stosowania.

Aby zacząć korzystać z TypeScript w Node.js, najpierw musimy zainstalować odpowiednie zależności oraz skonfigurować środowisko.

1.1 Tworzenie projektu Node.js z TypeScript

mkdir my-node-app
cd my-node-app
npm init -y

npm install typescript @types/node --save-dev

npx tsc --init

{
  "compilerOptions": {
    "target": "ES2019",                // Wersja ECMAScript
    "module": "commonjs",              // Używanie modułów CommonJS
    "outDir": "./dist",                // Katalog na skompilowane pliki
    "rootDir": "./src",                // Katalog na źródłowe pliki TypeScript
    "strict": true,                    // Włączenie ścisłego sprawdzania typów
    "esModuleInterop": true,           // Zgodność z importami ECMAScript
    "skipLibCheck": true,              // Pomija sprawdzanie typów dla bibliotek
  }
}

mkdir src

Teraz możemy napisać prostą aplikację backendową, która uruchomi serwer HTTP. Poniżej znajdziesz przykład serwera HTTP stworzonego z użyciem TypeScript.

2.1 Przykład serwera HTTP

Stwórz plik src/server.ts:

import http from 'http';

// Funkcja obsługująca żądania
const requestListener = (req: http.IncomingMessage, res: http.ServerResponse) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello, TypeScript with Node.js!\n');
};

// Tworzenie serwera HTTP
const server = http.createServer(requestListener);

// Nasłuchiwanie na porcie 3000
server.listen(3000, () => {
  console.log('Server is running on http://localhost:3000');
});

2.2 Kompilacja i uruchomienie

Aby uruchomić projekt, najpierw skompiluj pliki TypeScript, a następnie uruchom Node.js

npx tsc

node dist/server.js

Jedną z największych zalet korzystania z TypeScript w Node.js jest możliwość typowania kodu. W Node.js często operujemy na danych pochodzących z żądań HTTP, plików, baz danych itp. Dzięki TypeScriptowi możemy zdefiniować, jakie typy danych są oczekiwane, co pomaga unikać błędów.

3.1 Przykład typowania funkcji

Załóżmy, że mamy funkcję, która przetwarza dane z żądania HTTP:

import { IncomingMessage } from 'http';

const parseRequest = (req: IncomingMessage): string => {
  if (req.method === 'GET') {
    return 'Processing GET request';
  } else {
    return 'Processing other request';
  }
};

TypeScript w Node.js obsługuje zarówno moduły CommonJS, jak i ES6. Moduły CommonJS są standardem w Node.js, ale możemy korzystać z nowoczesnych modułów ECMAScript dzięki TypeScript.

4.1 Eksportowanie i importowanie modułów

W TypeScript możemy używać zarówno eksportów typu CommonJS, jak i ES6. Oto przykład:

Eksport w CommonJS:

// plik src/util.ts
const greet = (name: string) => {
  return `Hello, ${name}!`;
};

export = greet;

Import w CommonJS:

// plik src/server.ts
import greet = require('./util');

console.log(greet('TypeScript'));

Eksport w ES6:

// plik src/util.ts
export const greet = (name: string) => {
  return `Hello, ${name}!`;
};

Import w ES6:

// plik src/server.ts
import { greet } from './util';

console.log(greet('TypeScript'));

W aplikacjach Node.js bardzo często korzystamy z operacji asynchronicznych, takich jak odczyt plików czy zapytania do bazy danych. TypeScript oferuje wsparcie dla typowania funkcji zwracających Promise.

5.1 Przykład asynchronicznej funkcji

Załóżmy, że mamy funkcję, która odczytuje dane z pliku:

import { promises as fs } from 'fs';

const readFileContent = async (filePath: string): Promise<string> => {
    const content = await fs.readFile(filePath, 'utf-8');
    return content;
};

readFileContent('./data.txt')
    .then((content) => console.log(content))
    .catch((err) => console.error(err));

W aplikacjach Node.js obsługa błędów jest kluczowa. W TypeScript możemy typować błędy, co ułatwia zarządzanie wyjątkami.

6.1 Typowanie wyjątków

Przykład funkcji, która obsługuje błędy w sposób typowany:

const handleRequest = (data: any): void => {
  try {
    if (!data) {
      throw new Error('Brak danych');
    }
    console.log('Dane są poprawne');
  } catch (error) {
    if (error instanceof Error) {
      console.error(`Błąd: ${error.message}`);
    }
  }
};

Podczas pracy z TypeScript w Node.js warto korzystać z narzędzi wspierających procesy automatyzacji:

npm install nodemon --save-dev

"scripts": {
  "dev": "nodemon --watch 'src/**/*.ts' --exec 'ts-node' src/server.ts"
}

npm install ts-node --save-dev

TypeScript w Node.js to potężne narzędzie, które znacząco zwiększa stabilność i czytelność kodu backendowego. Dzięki silnemu typowaniu, narzędziom wspierającym, takim jak ts-node czy nodemon, oraz możliwości wykorzystania nowoczesnych funkcji ECMAScript, TypeScript staje się naturalnym wyborem dla programistów tworzących aplikacje serwerowe w Node.js.