TypeScript Node.js: Implementacija tipne sigurnosti na poslužiteljskoj strani

U svijetu web razvoja koji se neprestano razvija, izgradnja robusnih i održivih poslužiteljskih aplikacija je najvažnija. Iako je JavaScript dugo bio jezik weba, njegova dinamična priroda ponekad može dovesti do pogrešaka tijekom izvođenja i poteškoća u skaliranju većih projekata. TypeScript, nadskup JavaScripta koji dodaje statično tipiziranje, nudi snažno rješenje za te izazove. Kombiniranje TypeScripta s Node.js-om pruža privlačno okruženje za izgradnju tipno sigurnih, skalabilnih i održivih backend sustava.

Zašto TypeScript za razvoj Node.js aplikacija na poslužiteljskoj strani?

TypeScript donosi mnoštvo prednosti u razvoju Node.js-a, rješavajući mnoga ograničenja svojstvena dinamičkom tipiziranju JavaScripta.

• Poboljšana tipna sigurnost: TypeScript nameće strogu provjeru tipova u vrijeme kompilacije, hvatajući potencijalne pogreške prije nego što stignu u produkciju. To smanjuje rizik od iznimaka tijekom izvođenja i poboljšava ukupnu stabilnost vaše aplikacije. Zamislite scenarij u kojem vaš API očekuje korisnički ID kao broj, ali prima string. TypeScript bi tu pogrešku označio tijekom razvoja, sprječavajući potencijalni pad u produkciji.
• Poboljšana održivost koda: Aneksije tipova olakšavaju razumijevanje i refaktoriranje koda. Kada radite u timu, jasne definicije tipova pomažu programerima da brzo shvate svrhu i očekivano ponašanje različitih dijelova kodne baze. Ovo je posebno ključno za dugoročne projekte s promjenjivim zahtjevima.
• Poboljšana podrška za IDE: Statično tipiziranje u TypeScriptu omogućuje IDE-ovima (Integriranim razvojnim okruženjima) pružanje superiornog automatskog dovršavanja, navigacije kroz kod i alata za refaktoriranje. To značajno poboljšava produktivnost programera i smanjuje vjerojatnost pogrešaka. Na primjer, TypeScript integracija u VS Codeu nudi inteligentne prijedloge i isticanje pogrešaka, čineći razvoj bržim i učinkovitijim.
• Rano otkrivanje pogrešaka: Identificiranjem pogrešaka vezanih uz tipove tijekom kompilacije, TypeScript vam omogućuje rano rješavanje problema u razvojnom ciklusu, štedeći vrijeme i smanjujući napore otklanjanja pogrešaka. Ovaj proaktivni pristup sprječava širenje pogrešaka kroz aplikaciju i utjecaj na korisnike.
• Postupno usvajanje: TypeScript je nadskup JavaScripta, što znači da se postojeći JavaScript kod može postupno migrirati na TypeScript. To vam omogućuje postupno uvođenje tipne sigurnosti, bez potrebe za potpunim prepisivanjem vaše kodne baze.

Postavljanje TypeScript Node.js projekta

Da biste započeli s TypeScriptom i Node.js-om, morat ćete instalirati Node.js i npm (Node Package Manager). Nakon što ih instalirate, možete slijediti ove korake za postavljanje novog projekta:

1. Stvorite direktorij projekta: Stvorite novi direktorij za svoj projekt i uđite u njega putem terminala.
2. Inicijalizirajte Node.js projekt: Pokrenite npm init -y za stvaranje package.json datoteke.
3. Instalirajte TypeScript: Pokrenite npm install --save-dev typescript @types/node za instalaciju TypeScripta i definicija tipova za Node.js. Paket @types/node pruža definicije tipova za ugrađene Node.js module, omogućujući TypeScriptu da razumije i validira vaš Node.js kod.
4. Stvorite konfiguracijsku datoteku za TypeScript: Pokrenite npx tsc --init za stvaranje tsconfig.json datoteke. Ova datoteka konfigurira TypeScript kompajler i određuje opcije kompilacije.
5. Konfigurirajte tsconfig.json: Otvorite datoteku tsconfig.json i konfigurirajte je prema potrebama vašeg projekta. Neke uobičajene opcije uključuju:
• target: Određuje ciljnu ECMAScript verziju (npr., "es2020", "esnext").
• module: Određuje sustav modula koji će se koristiti (npr., "commonjs", "esnext").
• outDir: Određuje izlazni direktorij za kompiliranu JavaScript datoteku.
• rootDir: Određuje korijenski direktorij za TypeScript izvorne datoteke.
• sourceMap: Omogućuje generiranje izvornih mapa za lakše otklanjanje pogrešaka.
• strict: Omogućuje strogu provjeru tipova.
• esModuleInterop: Omogućuje interoperabilnost između CommonJS i ES modula.

Primjer tsconfig.json datoteke mogao bi izgledati ovako:

{
  "compilerOptions": {
    "target": "es2020",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "sourceMap": true,
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": [
    "src/**/*"
  ]
}

Ova konfiguracija govori TypeScript kompajleru da kompilira sve .ts datoteke u direktoriju src, da izlazne kompiliranu JavaScript datoteku u direktorij dist, i da generira izvorne mape za otklanjanje pogrešaka.

Osnovne aneaksije tipova i sučelja

TypeScript uvodi aneaksije tipova, koje vam omogućuju eksplicitno određivanje tipova varijabli, parametara funkcija i povratnih vrijednosti. To omogućuje TypeScript kompajleru da provodi provjeru tipova i rano hvata pogreške.

Osnovni tipovi

TypeScript podržava sljedeće osnovne tipove:

• string: Predstavlja tekstualne vrijednosti.
• number: Predstavlja brojčane vrijednosti.
• boolean: Predstavlja booleanske vrijednosti (true ili false).
• null: Predstavlja namjerno odsustvo vrijednosti.
• undefined: Predstavlja varijablu kojoj nije dodijeljena vrijednost.
• symbol: Predstavlja jedinstvenu i nepromjenjivu vrijednost.
• bigint: Predstavlja cijele brojeve proizvoljne preciznosti.
• any: Predstavlja vrijednost bilo kojeg tipa (koristiti štedljivo).
• unknown: Predstavlja vrijednost čiji je tip nepoznat (sigurnije od any).
• void: Predstavlja odsustvo povratne vrijednosti iz funkcije.
• never: Predstavlja vrijednost koja se nikada ne događa (npr., funkcija koja uvijek baca pogrešku).
• array: Predstavlja uređenu kolekciju vrijednosti istog tipa (npr., string[], number[]).
• tuple: Predstavlja uređenu kolekciju vrijednosti sa specifičnim tipovima (npr., [string, number]).
• enum: Predstavlja skup imenovanih konstanti.
• object: Predstavlja ne-primitivni tip.

Evo nekoliko primjera aneaksija tipova:

let name: string = "John Doe";
let age: number = 30;
let isStudent: boolean = false;

function greet(name: string): string {
  return `Hello, ${name}!`;
}

let numbers: number[] = [1, 2, 3, 4, 5];

let person: { name: string; age: number } = {
  name: "Jane Doe",
  age: 25,
};

Sučelja

Sučelja definiraju strukturu objekta. Ona specificiraju svojstva i metode koje objekt mora imati. Sučelja su snažan način za provođenje tipne sigurnosti i poboljšanje održivosti koda.

Evo primjera sučelja:

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

function getUser(id: number): User {
  // ... fetch user data from database
  return {
    id: 1,
    name: "John Doe",
    email: "john.doe@example.com",
    isActive: true,
  };
}

let user: User = getUser(1);

console.log(user.name); // John Doe

U ovom primjeru, sučelje User definira strukturu korisničkog objekta. Funkcija getUser vraća objekt koji je sukladan sučelju User. Ako funkcija vrati objekt koji ne odgovara sučelju, TypeScript kompajler će baciti pogrešku.

Aliasi tipova

Aliasi tipova stvaraju novo ime za tip. Oni ne stvaraju novi tip – oni samo daju postojećem tipu opisnije ili prikladnije ime.

type StringOrNumber = string | number;

let value: StringOrNumber = "hello";
value = 123;

//Type alias for a complex object
type Point = {
 x: number;
 y: number;
};

const myPoint: Point = { x: 10, y: 20 };

Izgradnja jednostavnog API-ja s TypeScriptom i Node.js-om

Izgradimo jednostavan REST API koristeći TypeScript, Node.js i Express.js.

1. Instalirajte Express.js i njegove definicije tipova: Pokrenite npm install express @types/express
2. Stvorite datoteku pod nazivom src/index.ts sa sljedećim kodom:

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

const app = express();
const port = process.env.PORT || 3000;

interface Product {
  id: number;
  name: string;
  price: number;
}

const products: Product[] = [
  { id: 1, name: 'Laptop', price: 1200 },
  { id: 2, name: 'Keyboard', price: 75 },
  { id: 3, name: 'Mouse', price: 25 },
];

app.get('/products', (req: Request, res: Response) => {
  res.json(products);
});

app.get('/products/:id', (req: Request, res: Response) => {
  const productId = parseInt(req.params.id);
  const product = products.find(p => p.id === productId);

  if (product) {
    res.json(product);
  } else {
    res.status(404).json({ message: 'Product not found' });
  }
});

app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

Ovaj kod stvara jednostavan Express.js API s dvije krajnje točke:

• /products: Vraća popis proizvoda.
• /products/:id: Vraća određeni proizvod prema ID-u.

Sučelje Product definira strukturu objekta proizvoda. Niz products sadrži popis objekata proizvoda koji su sukladni sučelju Product.

Da biste pokrenuli API, morat ćete kompilati TypeScript kod i pokrenuti Node.js poslužitelj:

1. Kompilacija TypeScript koda: Pokrenite npm run tsc (možda ćete morati definirati ovu skriptu u package.json kao "tsc": "tsc").
2. Pokrenite Node.js poslužitelj: Pokrenite node dist/index.js.

Tada možete pristupiti API krajnjim točkama u vašem pregledniku ili s alatom poput curl:

curl http://localhost:3000/products
curl http://localhost:3000/products/1

Napredne TypeScript tehnike za razvoj na poslužiteljskoj strani

TypeScript nudi nekoliko naprednih značajki koje mogu dodatno poboljšati tipnu sigurnost i kvalitetu koda u razvoju na poslužiteljskoj strani.

Generici

Generici vam omogućuju pisanje koda koji može raditi s različitim tipovima bez žrtvovanja tipne sigurnosti. Oni pružaju način parametriziranja tipova, čineći vaš kod ponovno upotrebljivijim i fleksibilnijim.

Evo primjera generičke funkcije:

function identity<T>(arg: T): T {
  return arg;
}

let myString: string = identity<string>("hello");
let myNumber: number = identity<number>(123);

U ovom primjeru, funkcija identity prima argument tipa T i vraća vrijednost istog tipa. Sintaksa <T> označava da je T parametar tipa. Kada pozovete funkciju, možete eksplicitno navesti tip za T (npr., identity<string>) ili pustiti TypeScript da ga zaključi iz argumenta (npr., identity("hello")).

Diskriminirane unije

Diskriminirane unije, poznate i kao označene unije, snažan su način predstavljanja vrijednosti koje mogu biti jedan od nekoliko različitih tipova. Često se koriste za modeliranje stanja strojeva ili predstavljanje različitih vrsta pogrešaka.

Evo primjera diskriminirane unije:

type Success = {
  status: 'success';
  data: any;
};

type Error = {
  status: 'error';
  message: string;
};

type Result = Success | Error;

function handleResult(result: Result) {
  if (result.status === 'success') {
    console.log('Success:', result.data);
  } else {
    console.error('Error:', result.message);
  }
}

const successResult: Success = { status: 'success', data: { name: 'John Doe' } };
const errorResult: Error = { status: 'error', message: 'Something went wrong' };

handleResult(successResult);
handleResult(errorResult);

U ovom primjeru, tip Result je diskriminirana unija tipova Success i Error. Svojstvo status je diskriminator, koji označava koji je tip vrijednost. Funkcija handleResult koristi diskriminator za određivanje načina obrade vrijednosti.

Pomoćni tipovi

TypeScript pruža nekoliko ugrađenih pomoćnih tipova koji vam mogu pomoći u manipulaciji tipovima i stvaranju sažetijeg i izražajnijeg koda. Neki često korišteni pomoćni tipovi uključuju:

• Partial<T>: Sve svojstva T čini opcionalnima.
• Required<T>: Sve svojstva T čini obveznima.
• Readonly<T>: Sve svojstva T čini samo za čitanje.
• Pick<T, K>: Stvara novi tip samo sa svojstvima T čiji su ključevi u K.
• Omit<T, K>: Stvara novi tip sa svim svojstvima T osim onih čiji su ključevi u K.
• Record<K, T>: Stvara novi tip s ključevima tipa K i vrijednostima tipa T.
• Exclude<T, U>: Isključuje iz T sve tipove koji su dodjeljivi U.
• Extract<T, U>: Izdvaja iz T sve tipove koji su dodjeljivi U.
• NonNullable<T>: Isključuje null i undefined iz T.
• Parameters<T>: Dobiva parametre funkcijskog tipa T u n-torki.
• ReturnType<T>: Dobiva povratni tip funkcijskog tipa T.
• InstanceType<T>: Dobiva tip instance konstruktorske funkcije tipa T.

Evo nekoliko primjera kako koristiti pomoćne tipove:

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

// Make all properties of User optional
type PartialUser = Partial<User>;

// Create a type with only the name and email properties of User
type UserInfo = Pick<User, 'name' | 'email'>;

// Create a type with all properties of User except the id
type UserWithoutId = Omit<User, 'id'>;

Testiranje TypeScript Node.js aplikacija

Testiranje je bitan dio izgradnje robusnih i pouzdanih aplikacija na poslužiteljskoj strani. Kada koristite TypeScript, možete iskoristiti sustav tipova za pisanje učinkovitijih i održivijih testova.

Popularni testni okviri za Node.js uključuju Jest i Mocha. Ovi okviri pružaju razne značajke za pisanje jedinčnih testova, integracijskih testova i testova od kraja do kraja.

Evo primjera jedinčnog testa koristeći Jest:

// src/utils.ts
export function add(a: number, b: number): number {
  return a + b;
}

// test/utils.test.ts
import { add } from '../src/utils';

describe('add', () => {
  it('should return the sum of two numbers', () => {
    expect(add(1, 2)).toBe(3);
  });

  it('should handle negative numbers', () => {
    expect(add(-1, 2)).toBe(1);
  });
});

U ovom primjeru, funkcija add testirana je koristeći Jest. Blok describe grupira povezane testove zajedno. Blokovi it definiraju pojedinačne testne slučajeve. Funkcija expect koristi se za postavljanje tvrdnji o ponašanju koda.

Prilikom pisanja testova za TypeScript kod, važno je osigurati da vaši testovi pokrivaju sve moguće scenarije tipova. To uključuje testiranje s različitim tipovima unosa, testiranje s null i undefined vrijednostima, te testiranje s nevažećim podacima.

Najbolje prakse za razvoj TypeScript Node.js aplikacija

Kako bi se osiguralo da su vaši TypeScript Node.js projekti dobro strukturirani, održivi i skalabilni, važno je slijediti neke najbolje prakse:

• Koristite strogi način rada: Omogućite strogi način rada u svojoj datoteci tsconfig.json kako biste nametnuli strožu provjeru tipova i rano uhvatili potencijalne pogreške.
• Definirajte jasna sučelja i tipove: Koristite sučelja i tipove za definiranje strukture vaših podataka i osiguravanje tipne sigurnosti kroz cijelu aplikaciju.
• Koristite generike: Koristite generike za pisanje koda koji se može ponovno koristiti i raditi s različitim tipovima bez žrtvovanja tipne sigurnosti.
• Koristite diskriminirane unije: Koristite diskriminirane unije za predstavljanje vrijednosti koje mogu biti jedan od nekoliko različitih tipova.
• Pišite sveobuhvatne testove: Pišite jedinčne testove, integracijske testove i testove od kraja do kraja kako biste osigurali da vaš kod ispravno radi i da je vaša aplikacija stabilna.
• Slijedite dosljedan stil kodiranja: Koristite formatiranje koda poput Prettiera i linter poput ESLinta za provođenje dosljednog stila kodiranja i hvatanje potencijalnih pogrešaka. Ovo je posebno važno kada radite u timu kako biste održali dosljednu kodnu bazu. Postoji mnogo opcija konfiguracije za ESLint i Prettier koje se mogu dijeliti unutar tima.
• Koristite injektiranje ovisnosti: Injektiranje ovisnosti je obrazac dizajna koji vam omogućuje da razdvojite svoj kod i učinite ga lakšim za testiranje. Alati poput InversifyJS mogu vam pomoći implementirati injektiranje ovisnosti u vašim TypeScript Node.js projektima.
• Implementirajte pravilno rukovanje pogreškama: Implementirajte robusno rukovanje pogreškama kako biste graciozno uhvatili i obradili iznimke. Koristite try-catch blokove i bilježenje pogrešaka kako biste spriječili pad vaše aplikacije i pružili korisne informacije za otklanjanje pogrešaka.
• Koristite modulski bundler: Koristite modulski bundler poput Webpacka ili Parcela za spajanje vašeg koda i optimiziranje za produkciju. Iako se često povezuju s frontend razvojem, modulski bundleri mogu biti korisni i za Node.js projekte, pogotovo kada radite s ES modulima.
• Razmislite o korištenju okvira: Istražite okvire poput NestJS-a ili AdonisJS-a koji pružaju strukturu i konvencije za izgradnju skalabilnih i održivih Node.js aplikacija s TypeScriptom. Ovi okviri često uključuju značajke poput injektiranja ovisnosti, rutiranja i podrške za middleware.

Razmatranja implementacije

Implementacija TypeScript Node.js aplikacije slična je implementaciji standardne Node.js aplikacije. Međutim, postoji nekoliko dodatnih razmatranja:

• Kompilacija: Morat ćete kompilati svoj TypeScript kod u JavaScript prije implementacije. To se može učiniti kao dio vašeg procesa izgradnje.
• Izvorne mape: Razmislite o uključivanju izvornih mapa u svoj paket za implementaciju kako biste olakšali otklanjanje pogrešaka u produkciji.
• Varijable okoline: Koristite varijable okoline za konfiguriranje vaše aplikacije za različita okruženja (npr., razvoj, testiranje, produkcija). Ovo je standardna praksa, ali postaje još važnija kada se radi s kompiliranim kodom.

Popularne platforme za implementaciju za Node.js uključuju:

• AWS (Amazon Web Services): Nudi razne usluge za implementaciju Node.js aplikacija, uključujući EC2, Elastic Beanstalk i Lambda.
• Google Cloud Platform (GCP): Pruža slične usluge kao AWS, uključujući Compute Engine, App Engine i Cloud Functions.
• Microsoft Azure: Nudi usluge poput virtualnih strojeva, App Service i Azure Functions za implementaciju Node.js aplikacija.
• Heroku: Platforma kao usluga (PaaS) koja pojednostavljuje implementaciju i upravljanje Node.js aplikacijama.
• DigitalOcean: Pruža virtualne privatne poslužitelje (VPS) koje možete koristiti za implementaciju Node.js aplikacija.
• Docker: Tehnologija kontejnerizacije koja vam omogućuje pakiranje vaše aplikacije i njezinih ovisnosti u jedan kontejner. To olakšava implementaciju vaše aplikacije u bilo koje okruženje koje podržava Docker.

Zaključak

TypeScript nudi značajno poboljšanje u odnosu na tradicionalni JavaScript za izgradnju robusnih i skalabilnih aplikacija na poslužiteljskoj strani s Node.js-om. Iskorištavanjem tipne sigurnosti, poboljšane podrške za IDE i naprednih jezičnih značajki, možete stvoriti održivije, pouzdanije i učinkovitije backend sustave. Iako postoji krivulja učenja pri usvajanju TypeScripta, dugoročne koristi u smislu kvalitete koda i produktivnosti programera čine ga vrijednom investicijom. Kako potražnja za dobro strukturiranim i održivim aplikacijama nastavlja rasti, TypeScript će postati sve važniji alat za developere na poslužiteljskoj strani diljem svijeta.