TypeScript Express Integráció: Útvonalkezelő Típusbiztonság

A TypeScript a modern JavaScript fejlesztés sarokkövévé vált, statikus gépelési képességeket kínálva, amelyek javítják a kód minőségét, karbantarthatóságát és skálázhatóságát. Amikor az Express.js, egy népszerű Node.js webalkalmazási keretrendszerrel kombinálják, a TypeScript jelentősen javíthatja a backend API-k robusztusságát. Ez a átfogó útmutató bemutatja, hogyan lehet a TypeScript-et felhasználni az útvonalkezelő típusbiztonságának eléréséhez az Express.js alkalmazásokban, gyakorlati példákat és legjobb gyakorlatokat kínálva a robusztus és karbantartható API-k létrehozásához egy globális közönség számára.

Miért fontos a Típusbiztonság az Express.js-ben

Az olyan dinamikus nyelvekben, mint a JavaScript, a hibákat gyakran futásidőben fogják el, ami váratlan viselkedéshez és nehezen debuggolható problémákhoz vezethet. A TypeScript ezt statikus gépeléssel oldja meg, lehetővé téve a hibák fejlesztés közbeni elkapását, mielőtt azok eljutnának a gyártásba. Az Express.js kontextusában a típusbiztonság különösen fontos az útvonalkezelők számára, ahol kérést és válasz objektumokkal, lekérdezési paraméterekkel és kérés törzsekkel foglalkozunk. Ezen elemek helytelen kezelése alkalmazás-összeomlásokat, adatromlást és biztonsági réseket eredményezhet.

• Korai hibaészlelés: Kapcsolja el a típushoz kapcsolódó hibákat fejlesztés közben, csökkentve a futásidő meglepetések valószínűségét.
• Javított kódkarbantarthatóság: A típusjelölések megkönnyítik a kód megértését és refaktorálását.
• Fejlettebb kódkiegészítés és eszközök: Az IDE-k jobb javaslatokat és hibakeresést nyújthatnak típusinformációkkal.
• Csökkentett hibák: A típusbiztonság segít megelőzni az általános programozási hibákat, mint például a helytelen adattípusok függvényeknek való átadása.

TypeScript Express.js Projekt Beállítása

Mielőtt belemerülnénk az útvonalkezelő típusbiztonságába, állítsunk be egy alapvető TypeScript Express.js projektet. Ez fogja képezni példáink alapját.

Előfeltételek

• Telepítve van a Node.js és az npm (Node Csomagkezelő). Letöltheti őket a hivatalos Node.js weboldalról. Győződjön meg róla, hogy rendelkezik egy friss verzióval az optimális kompatibilitás érdekében.
• Egy kódszerkesztő, mint például a Visual Studio Code, amely kiváló TypeScript támogatást kínál.

Projekt inicializálás

1. Hozzon létre egy új projektkönyvtárat: mkdir typescript-express-app && cd typescript-express-app
2. Inicializáljon egy új npm projektet: npm init -y
3. Telepítse a TypeScript-et és az Express.js-t: npm install typescript express
4. Telepítse a TypeScript deklarációs fájljait az Express.js-hez (fontos a típusbiztonsághoz): npm install @types/express @types/node
5. Inicializálja a TypeScript-et: npx tsc --init (Ez létrehoz egy tsconfig.json fájlt, amely konfigurálja a TypeScript fordítót.)

TypeScript Konfigurálása

Nyissa meg a tsconfig.json fájlt, és konfigurálja megfelelően. Íme egy minta konfiguráció:

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

Megjegyzendő kulcsfontosságú konfigurációk:

• target: Meghatározza az ECMAScript célverziót. Az es6 jó kiindulópont.
• module: Meghatározza a modul kódgenerálást. A commonjs gyakori választás a Node.js-hez.
• outDir: Meghatározza a lefordított JavaScript fájlok kimeneti könyvtárát.
• rootDir: Meghatározza a TypeScript forrásfájljainak gyökérkönyvtárát.
• strict: Engedélyezi az összes szigorú típusellenőrzési opciót a fokozott típusbiztonság érdekében. Ez erősen ajánlott.
• esModuleInterop: Engedélyezi az együttműködést a CommonJS és az ES modulok között.

A Belépési Pont Létrehozása

Hozzon létre egy src könyvtárat és adjon hozzá egy index.ts fájlt:

mkdir src
touch src/index.ts

Töltse fel a src/index.ts fájlt egy alapvető Express.js szerverbeállítással:

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

const app = express();
const port = 3000;

app.get('/', (req: Request, res: Response) => {
  res.send('Hello, TypeScript Express!');
});

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

Build Parancs Hozzáadása

Adjon hozzá egy build parancsot a package.json fájljához a TypeScript kód lefordításához:

"scripts": {
  "build": "tsc",
  "start": "node dist/index.js",
  "dev": "npm run build && npm run start"
}

Most futtathatja az npm run dev parancsot a szerver lefordításához és elindításához.

Útvonalkezelő Típusbiztonság: Kérés és Válasz Típusok Meghatározása

Az útvonalkezelő típusbiztonságának magja a Request és Response objektumok típusainak megfelelő meghatározásában rejlik. Az Express.js generikus típusokat biztosít ezekhez az objektumokhoz, amelyek lehetővé teszik a lekérdezési paraméterek, kérés törzsek és útvonalparaméterek típusainak megadását.

Alapvető Útvonalkezelő Típusok

Kezdjük egy egyszerű útvonalkezelővel, amely egy nevet vár lekérdezési paraméterként:

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

const app = express();
const port = 3000;

interface NameQuery {
  name: string;
}

app.get('/hello', (req: Request<any, any, any, NameQuery>, res: Response) => {
  const name = req.query.name;

  if (!name) {
    return res.status(400).send('Név paraméter szükséges.');
  }

  res.send(`Hello, ${name}!`);
});

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

Ebben a példában:

• Request<any, any, any, NameQuery> meghatározza a kérés objektum típusát.
• Az első any az útvonalparamétereket jelenti (pl. /users/:id).
• A második any a válasz törzs típusát jelenti.
• A harmadik any a kérés törzs típusát jelenti.
• A NameQuery egy interfész, amely meghatározza a lekérdezési paraméterek struktúráját.

A NameQuery interfész meghatározásával a TypeScript most ellenőrizheti, hogy a req.query.name tulajdonság létezik-e, és string típusú-e. Ha egy nem létező tulajdonságot próbál meg elérni, vagy helytelen típusú értéket rendel hozzá, a TypeScript hibát fog jelezni.

Kérés Törzsek Kezelése

Azokhoz az útvonalakhoz, amelyek kérés törzseket fogadnak (pl. POST, PUT, PATCH), definiálhat egy interfészt a kérés törzséhez, és használhatja azt a Request típusban:

import express, { Request, Response } from 'express';
import bodyParser from 'body-parser';

const app = express();
const port = 3000;

app.use(bodyParser.json()); // Fontos a JSON kérés törzsek elemzéséhez

interface CreateUserRequest {
  firstName: string;
  lastName: string;
  email: string;
}

app.post('/users', (req: Request<any, any, CreateUserRequest>, res: Response) => {
  const { firstName, lastName, email } = req.body;

  // Validálja a kérés törzset
  if (!firstName || !lastName || !email) {
    return res.status(400).send('Hiányzó kötelező mezők.');
  }

  // Dolgozza fel a felhasználó létrehozását (pl. mentés az adatbázisba)
  console.log(`Creating user: ${firstName} ${lastName} (${email})`);

  res.status(201).send('Felhasználó sikeresen létrehozva.');
});

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

Ebben a példában:

• A CreateUserRequest meghatározza a várt kérés törzs struktúráját.
• Az app.use(bodyParser.json()) elengedhetetlen a JSON kérés törzsek elemzéséhez. Anélkül a req.body undefined lesz.
• A Request típus most Request<any, any, CreateUserRequest>, jelezve, hogy a kérés törzsének meg kell felelnie a CreateUserRequest interfésznek.

A TypeScript most biztosítja, hogy a req.body objektum tartalmazza a várt tulajdonságokat (firstName, lastName, és email), és azok típusa helyes. Ez jelentősen csökkenti a helytelen kérés törzs adatok okozta futásidő hibák kockázatát.

Útvonalparaméterek Kezelése

Paraméterekkel rendelkező útvonalakhoz (pl. /users/:id), definiálhat egy interfészt az útvonalparaméterekhez, és használhatja azt a Request típusban:

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

const app = express();
const port = 3000;

interface UserParams {
  id: string;
}

interface User {
  id: string;
  firstName: string;
  lastName: string;
  email: string;
}

const users: User[] = [
  { id: '1', firstName: 'John', lastName: 'Doe', email: 'john.doe@example.com' },
  { id: '2', firstName: 'Jane', lastName: 'Smith', email: 'jane.smith@example.com' },
];

app.get('/users/:id', (req: Request<UserParams>, res: Response) => {
  const userId = req.params.id;

  const user = users.find(u => u.id === userId);

  if (!user) {
    return res.status(404).send('Felhasználó nem található.');
  }

  res.json(user);
});

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

Ebben a példában:

• A UserParams meghatározza az útvonalparaméterek struktúráját, jelezve, hogy az id paraméternek stringnek kell lennie.
• A Request típus most Request<UserParams>, jelezve, hogy a req.params objektumnak meg kell felelnie a UserParams interfésznek.

A TypeScript most biztosítja, hogy a req.params.id tulajdonság létezik, és string típusú. Ez segít megelőzni azokat a hibákat, amelyek a nem létező útvonalparaméterek eléréséből vagy helytelen típusokkal való használatából adódnak.

Válasz Típusok Megadása

Miközben a kérés típusbiztonságára való összpontosítás kulcsfontosságú, a válasz típusok meghatározása is növeli a kód átláthatóságát és segít megelőzni az inkonzisztenciákat. Meghatározhatja a válaszban küldött adatok típusát.

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

const app = express();
const port = 3000;

interface User {
  id: string;
  firstName: string;
  lastName: string;
  email: string;
}

const users: User[] = [
  { id: '1', firstName: 'John', lastName: 'Doe', email: 'john.doe@example.com' },
  { id: '2', firstName: 'Jane', lastName: 'Smith', email: 'jane.smith@example.com' },
];

app.get('/users', (req: Request, res: Response<User[]>) => {
    res.json(users);
});

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

Itt a Response<User[]> megadja, hogy a válasz törzsének a User objektumok tömbjének kell lennie. Ez segít biztosítani, hogy következetesen a megfelelő adatstruktúrát küldje el API válaszaiban. Ha olyan adatokat próbál meg küldeni, amelyek nem felelnek meg a `User[]` típusnak, a TypeScript figyelmeztetést ad.

Middleware Típusbiztonság

A middleware függvények elengedhetetlenek az Express.js alkalmazásokban a keresztező aggályok kezeléséhez. A middleware típusbiztonságának biztosítása ugyanolyan fontos, mint az útvonalkezelőké.

Middleware Függvények Gépelése

Egy middleware függvény alapvető szerkezete TypeScript-ben hasonló az útvonalkezelőéhez:

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

function authenticationMiddleware(req: Request, res: Response, next: NextFunction) {
  // Hitelesítési logika
  const isAuthenticated = true; // Cserélje le tényleges hitelesítési ellenőrzésre

  if (isAuthenticated) {
    next(); // Folytassa a következő middleware-el vagy útvonalkezelővel
  } else {
    res.status(401).send('Nincs engedélyezve');
  }
}

const app = express();
const port = 3000;

app.use(authenticationMiddleware);

app.get('/', (req: Request, res: Response) => {
  res.send('Hello, hitelesített felhasználó!');
});

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

Ebben a példában:

• A NextFunction egy típus, amelyet az Express.js biztosít, és amely a láncban lévő következő middleware függvényt jelöli.
• A middleware függvény ugyanazokat a Request és Response objektumokat kapja, mint az útvonalkezelők.

A Kérés Objektum Bővítése

Néha hozzá szeretne adni egyéni tulajdonságokat a Request objektumhoz a middleware-ben. Például egy hitelesítési middleware hozzáadhat egy user tulajdonságot a kérés objektumhoz. Ennek típusbiztonságos módon történő elvégzéséhez bővítenie kell a Request interfészt.

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

interface User {
  id: string;
  username: string;
  email: string;
}

// Bővítse a Request interfészt
declare global {
  namespace Express {
    interface Request {
      user?: User;
    }
  }
}

function authenticationMiddleware(req: Request, res: Response, next: NextFunction) {
  // Hitelesítési logika (cserélje le tényleges hitelesítési ellenőrzésre)
  const user: User = { id: '123', username: 'johndoe', email: 'john.doe@example.com' };
  req.user = user; // Adja hozzá a felhasználót a kérés objektumhoz
  next(); // Folytassa a következő middleware-el vagy útvonalkezelővel
}

const app = express();
const port = 3000;

app.use(authenticationMiddleware);

app.get('/', (req: Request, res: Response) => {
  const username = req.user?.username || 'Vendég';
  res.send(`Hello, ${username}!`);
});

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

Ebben a példában:

• Globális deklarációt használunk a Express.Request interfész bővítésére.
• Hozzáadunk egy opcionális user tulajdonságot User típusban a Request interfészhez.
• Most a req.user tulajdonságot elérheti az útvonalkezelőkben anélkül, hogy a TypeScript panaszkodna. A `?` a `req.user?.username`-ban kulcsfontosságú a felhasználó nem hitelesített eseteinek kezeléséhez, megelőzve a lehetséges hibákat.

Legjobb Gyakorlatok TypeScript Express Integrációhoz

A TypeScript előnyeinek maximalizálása érdekében az Express.js alkalmazásokban kövesse ezeket a legjobb gyakorlatokat:

• Engedélyezze a Szigorú Módót: Használja a "strict": true opciót a tsconfig.json fájlban az összes szigorú típusellenőrzési opció engedélyezéséhez. Ez segít a lehetséges hibák korai elkapásában, és magasabb szintű típusbiztonságot biztosít.
• Használjon interfészeket és típus aliasokat: Határozzon meg interfészeket és típus aliasokat az adatai struktúrájának képviseletére. Ez olvashatóbbá és karbantarthatóbbá teszi a kódot.
• Használjon generikus típusokat: Használja ki a generikus típusokat újrafelhasználható és típusbiztonságos komponensek létrehozásához.
• Írjon egységteszteket: Írjon egységteszteket a kód helyességének ellenőrzéséhez és annak biztosításához, hogy a típusjelölések pontosak. A tesztelés kulcsfontosságú a kódminőség megőrzéséhez.
• Használjon Linter és Formatter: Használjon lintert (mint az ESLint) és formattert (mint a Prettier) a következetes kódolási stílusok érvényesítésére és a lehetséges hibák elkapására.
• Kerülje az any Típust: Minimalizálja az any típus használatát, mivel ez megkerüli a típusellenőrzést és legyőzi a TypeScript használatának célját. Csak akkor használja, ha feltétlenül szükséges, és fontolja meg specifikusabb típusok vagy generikusok használatát, amikor csak lehetséges.
• Logikusan strukturálja a projektet: Szervezze projektjét modulokra vagy mappákra a funkcionalitás alapján. Ez javítja az alkalmazás karbantarthatóságát és skálázhatóságát.
• Használjon Függőség Injekciót: Fontolja meg egy függőség injekciós konténer használatát az alkalmazás függőségeinek kezelésére. Ez tesztelhetőbbé és karbantarthatóbbá teheti a kódját. Az olyan könyvtárak, mint az InversifyJS, népszerű választások.

Fejlett TypeScript Koncepciók Express.js-hez

Dekorátorok Használata

A dekorátorok tömör és kifejező módot kínálnak metaadatok hozzáadására osztályokhoz és függvényekhez. Dekorátorokat használhat az Express.js útvonalak regisztrációjának egyszerűsítésére.

Először is engedélyeznie kell a kísérleti dekorátorokat a tsconfig.json fájlban a "experimentalDecorators": true hozzáadásával a compilerOptions-hoz.

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

Ezután létrehozhat egy egyéni dekorátort az útvonalak regisztrálásához:

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

function route(method: string, path: string) {
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    if (!target.__router__) {
      target.__router__ = Router();
    }

    target.__router__[method](path, descriptor.value);
  };
}

class UserController {
  @route('get', '/users')
  getUsers(req: Request, res: Response) {
    res.send('List of users');
  }

  @route('post', '/users')
  createUser(req: Request, res: Response) {
    res.status(201).send('User created');
  }

  public getRouter() {
    return this.__router__;
  }
}

const userController = new UserController();

const app = express();
const port = 3000;

app.use('/', userController.getRouter());

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

Ebben a példában:

• A route dekorátor az HTTP metódust és az útvonalat veszi át argumentumként.
• Regisztrálja a dekorált metódust útvonalkezelőként az osztályhoz tartozó routeren.
• Ez egyszerűsíti az útvonalak regisztrálását és olvashatóbbá teszi a kódot.

Egyéni Típus Gárda Használata

A típus gárdák olyan függvények, amelyek egy adott hatókörön belül szűkítik egy változó típusát. Egyéni típus gárdákat használhat kérés törzsek vagy lekérdezési paraméterek érvényesítésére.

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

function isProduct(obj: any): obj is Product {
    return typeof obj === 'object' &&
           obj !== null &&
           typeof obj.id === 'string' &&
           typeof obj.name === 'string' &&
           typeof obj.price === 'number';
}

import express, { Request, Response } from 'express';
import bodyParser from 'body-parser';

const app = express();
const port = 3000;

app.use(bodyParser.json());

app.post('/products', (req: Request, res: Response) => {
    if (!isProduct(req.body)) {
        return res.status(400).send('Érvénytelen termékadatok');
    }

    const product: Product = req.body;
    console.log(`Creating product: ${product.name}`);
    res.status(201).send('Termék létrehozva');
});

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

Ebben a példában:

• Az isProduct függvény egy egyéni típus gárda, amely ellenőrzi, hogy egy objektum megfelel-e a Product interfésznek.
• A /products útvonalkezelőn belül az isProduct függvényt használják a kérés törzs érvényesítésére.
• Ha a kérés törzs érvényes termék, a TypeScript tudja, hogy a req.body Product típusú az if blokkon belül.

Globális Megfontolások az API Tervezésben

Amikor API-kat tervez globális közönség számára, több tényezőt kell figyelembe venni az elérhetőség, használhatóság és kulturális érzékenység biztosítása érdekében.

• Lokalizáció és Nemzetköziesítés (i18n és L10n):
  • Tartalom-tárgyalás: Több nyelv és régió támogatása tartalom-tárgyalás révén, amely az Accept-Language fejlécen alapul.
  • Dátum és Idő Formázás: Használja az ISO 8601 formátumot a dátum és idő megjelenítésére, hogy elkerülje a kétértelműséget a különböző régiókban.
  • Számformázás: Kezelje a számformázást a felhasználó helyi beállításai szerint (pl. tizedesvesszők és ezres elválasztók).
  • Valuta Kezelés: Több valuta támogatása és árfolyaminformációk megadása, ahol szükséges.
  • Szöveg Irány: Jobbról balra (RTL) íródó nyelvek, mint például az arab és a héber, támogatása.
• Időzónák:
  • Tárolja a dátumokat és időket UTC-ben (Coordinated Universal Time) a szerveroldalon.
  • Lehetőséget biztosítson a felhasználóknak a preferált időzónájuk megadására, és konvertálja a dátumokat és időket ennek megfelelően az ügyféloldalon.
  • Használjon olyan könyvtárakat, mint a moment-timezone az időzóna konverziók kezeléséhez.
• Karakterkódolás:
  • Használjon UTF-8 kódolást minden szöveges adat esetén, hogy támogassa a különböző nyelvek széles körű karakterét.
  • Győződjön meg arról, hogy az adatbázisa és más adattároló rendszerei UTF-8 használatára vannak konfigurálva.
• Elérhetőség:
  • Kövesse az elérhetőségi irányelveket (pl. WCAG) az API elérhetővé tételéhez a fogyatékos felhasználók számára.
  • Világos és leíró hibaüzeneteket biztosítson, amelyek könnyen érthetők.
  • Használjon szemantikus HTML elemeket és ARIA attribútumokat az API dokumentációban.
• Kulturális Érzékenység:
  • Kerülje a kulturálisan specifikus utalások, szólások vagy humor használatát, amelyeket nem minden felhasználó érthet.
  • Legyen tudatában a kommunikációs stílusok és preferenciák kulturális különbségeinek.
  • Vegye figyelembe API-jának különböző kulturális csoportokra gyakorolt lehetséges hatását, és kerülje a sztereotípiák vagy előítéletek fenntartását.
• Adatvédelem és Biztonság:
  • Tartsa be az adatvédelmi szabályozásokat, mint például a GDPR (General Data Protection Regulation) és a CCPA (California Consumer Privacy Act).
  • Erős hitelesítési és engedélyezési mechanizmusokat implementáljon a felhasználói adatok védelme érdekében.
  • Titkosítsa az érzékeny adatokat mind átvitel közben, mind pihenő üzemmódban.
  • Biztosítson a felhasználóknak kontrollt az adataik felett, és engedje meg nekik adataik elérését, módosítását és törlését.
• API Dokumentáció:
  • Biztosítson átfogó és jól szervezett API dokumentációt, amely könnyen érthető és navigálható.
  • Használjon olyan eszközöket, mint a Swagger/OpenAPI, interaktív API dokumentáció generálásához.
  • Tartalmazzon kódpéldákat több programozási nyelven, hogy kielégítse a változatos közönséget.
  • Fordítsa le API dokumentációját több nyelvre, hogy szélesebb közönséget érjen el.
• Hibakezelés:
  • Specifikus és informatív hibaüzeneteket biztosítson. Kerülje az általános hibaüzeneteket, mint például "Valami elromlott.".
  • Használjon szabványos HTTP státuszkódokat a hiba típusának jelzésére (pl. 400 Bad Request, 401 Unauthorized, 500 Internal Server Error).
  • Tartalmazzon hiba kódokat vagy azonosítókat, amelyek problémák nyomon követésére és hibaelhárítására használhatók.
  • Naplózza a hibákat a szerveroldalon hibaelhárítás és felügyelet céljából.
• Sebességkorlátozás: Implementáljon sebességkorlátozást az API abuse-tól való védelme és a méltányos használat biztosítása érdekében.
• Verziózás: Használjon API verziózást a hátrafelé kompatibilis változtatások engedélyezéséhez és a meglévő kliensek megszakításának elkerüléséhez.

Következtetés

A TypeScript Express integráció jelentősen javítja backend API-jainak megbízhatóságát és karbantarthatóságát. Az útvonalkezelőkben és middleware-ben a típusbiztonság kihasználásával korán elkaphatja a hibákat a fejlesztési folyamat során, és robusztusabb és skálázhatóbb alkalmazásokat építhet globális közönség számára. A kérés és válasz típusok meghatározásával biztosítja, hogy API-ja egy következetes adatstruktúrát kövessen, csökkentve a futásidő hibák valószínűségét. Ne feledje a legjobb gyakorlatokat, mint például a szigorú mód bekapcsolása, interfészek és típus aliasok használata, valamint egységtesztek írása a TypeScript előnyeinek maximalizálása érdekében. Mindig vegye figyelembe az olyan globális tényezőket, mint a lokalizáció, az időzónák és a kulturális érzékenység, hogy biztosítsa API-jai elérhetőségét és használhatóságát világszerte.