TypeScript Express Entegrasyonu: Rota İşleyici Tür Güvenliği

TypeScript, kod kalitesini, bakımı kolaylaştırılmasını ve ölçeklenebilirliği artıran statik yazma yetenekleri sunan modern JavaScript geliştirmesinin bir mihenk taşı haline geldi. Popüler bir Node.js web uygulaması çerçevesi olan Express.js ile birleştirildiğinde, TypeScript, arka uç API'lerinizin sağlamlığını önemli ölçüde artırabilir. Bu kapsamlı kılavuz, Express.js uygulamalarında rota işleyici tür güvenliğini elde etmek için TypeScript'ten nasıl yararlanılacağını, pratik örnekler ve küresel bir kitle için sağlam ve bakımı kolay API'ler oluşturmaya yönelik en iyi uygulamaları incelemektedir.

Neden Tür Güvenliği Express.js'de Önemlidir?

JavaScript gibi dinamik dillerde, hatalar genellikle çalışma zamanında yakalanır, bu da beklenmedik davranışlara ve düzeltilmesi zor sorunlara yol açabilir. TypeScript, statik yazma özelliği getirerek bunu ele alır ve geliştirme sırasında, üretime geçmeden önce hataları yakalamanıza olanak tanır. Express.js bağlamında, tür güvenliği özellikle istek ve yanıt nesneleri, sorgu parametreleri ve istek gövdeleriyle uğraştığınız rota işleyiciler için çok önemlidir. Bu öğelerin yanlış işlenmesi, uygulama çökmelerine, veri bozulmasına ve güvenlik açıklarına yol açabilir.

• Erken Hata Tespiti: Geliştirme sırasında türle ilgili hataları yakalayın, çalışma zamanı sürprizlerinin olasılığını azaltın.
• Geliştirilmiş Kod Bakımı: Tür açıklamaları, kodu anlamayı ve yeniden düzenlemeyi kolaylaştırır.
• Gelişmiş Kod Tamamlama ve Araçlar: IDE'ler, tür bilgileriyle daha iyi öneriler ve hata denetimi sağlayabilir.
• Azaltılmış Hatalar: Tür güvenliği, işlevlere yanlış veri türleri gönderme gibi yaygın programlama hatalarını önlemeye yardımcı olur.

Bir TypeScript Express.js Projesi Kurma

Rota işleyici tür güvenliğine dalmadan önce, temel bir TypeScript Express.js projesi kuralım. Bu, örneklerimiz için temel oluşturacaktır.

Önkoşullar

• Node.js ve npm (Node Paket Yöneticisi) yüklü. Bunları resmi Node.js web sitesinden indirebilirsiniz. En iyi uyumluluk için güncel bir sürüme sahip olduğunuzdan emin olun.
• Mükemmel TypeScript desteği sunan Visual Studio Code gibi bir kod düzenleyici.

Proje Başlatma

1. Yeni bir proje dizini oluşturun: mkdir typescript-express-app && cd typescript-express-app
2. Yeni bir npm projesi başlatın: npm init -y
3. TypeScript ve Express.js yükleyin: npm install typescript express
4. Express.js için TypeScript bildirim dosyalarını yükleyin (tür güvenliği için önemlidir): npm install @types/express @types/node
5. TypeScript'i başlatın: npx tsc --init (Bu, TypeScript derleyicisini yapılandıran bir tsconfig.json dosyası oluşturur.)

TypeScript'i Yapılandırma

tsconfig.json dosyasını açın ve uygun şekilde yapılandırın. İşte bir örnek yapılandırma:

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

Dikkat edilmesi gereken önemli yapılandırmalar:

• target: ECMAScript hedef sürümünü belirtir. es6 iyi bir başlangıç noktasıdır.
• module: Modül kod üretimini belirtir. commonjs Node.js için yaygın bir seçimdir.
• outDir: Derlenmiş JavaScript dosyaları için çıktı dizinini belirtir.
• rootDir: TypeScript kaynak dosyalarınızın kök dizinini belirtir.
• strict: Geliştirilmiş tür güvenliği için tüm katı tür denetimi seçeneklerini etkinleştirir. Bu şiddetle tavsiye edilir.
• esModuleInterop: CommonJS ve ES Modülleri arasında birlikte çalışabilirliği etkinleştirir.

Giriş Noktası Oluşturma

Bir src dizini oluşturun ve bir index.ts dosyası ekleyin:

mkdir src
touch src/index.ts

src/index.ts dosyasını temel bir Express.js sunucu kurulumuyla doldurun:

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

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

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

app.listen(port, () => {
  console.log(`Sunucu http://localhost:${port} adresinde çalışıyor`);
});

Bir Yapı Komut Dosyası Ekleme

TypeScript kodunu derlemek için package.json dosyanıza bir yapı komut dosyası ekleyin:

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

Artık sunucuyu oluşturmak ve başlatmak için npm run dev komutunu çalıştırabilirsiniz.

Rota İşleyici Tür Güvenliği: İstek ve Yanıt Türlerini Tanımlama

Rota işleyici tür güvenliğinin özü, Request ve Response nesneleri için türleri doğru bir şekilde tanımlamaktır. Express.js, sorgu parametrelerinin, istek gövdesinin ve rota parametrelerinin türlerini belirtmenize olanak tanıyan bu nesneler için genel türler sağlar.

Temel Rota İşleyici Türleri

Adı bir sorgu parametresi olarak bekleyen basit bir rota işleyicisiyle başlayalım:

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

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

interface NameQuery {
  name: string;
}

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

  if (!name) {
    return res.status(400).send('Ad parametresi gereklidir.');
  }

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

app.listen(port, () => {
  console.log(`Sunucu http://localhost:${port} adresinde çalışıyor`);
});

Bu örnekte:

• Request<any, any, any, NameQuery>, istek nesnesinin türünü tanımlar.
• İlk any, rota parametrelerini temsil eder (örneğin, /users/:id).
• İkinci any, yanıt gövdesi türünü temsil eder.
• Üçüncü any, istek gövdesi türünü temsil eder.
• NameQuery, sorgu parametrelerinin yapısını tanımlayan bir arayüzdür.

NameQuery arayüzünü tanımlayarak, TypeScript artık req.query.name özelliğinin var olduğunu ve string türünde olduğunu doğrulayabilir. Mevcut olmayan bir özelliğe erişmeye veya yanlış türde bir değer atamaya çalışırsanız, TypeScript bir hata işaretleyecektir.

İstek Gövdelerini İşleme

İstek gövdelerini (örneğin, POST, PUT, PATCH) kabul eden rotalar için, istek gövdesi için bir arayüz tanımlayabilir ve bunu Request türünde kullanabilirsiniz:

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

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

app.use(bodyParser.json()); // JSON istek gövdelerini ayrıştırmak için önemli

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

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

  // İstek gövdesini doğrulayın
  if (!firstName || !lastName || !email) {
    return res.status(400).send('Gerekli alanlar eksik.');
  }

  // Kullanıcı oluşturmayı işleyin (örneğin, veritabanına kaydetme)
  console.log(`Kullanıcı oluşturuluyor: ${firstName} ${lastName} (${email})`);

  res.status(201).send('Kullanıcı başarıyla oluşturuldu.');
});

app.listen(port, () => {
  console.log(`Sunucu http://localhost:${port} adresinde çalışıyor`);
});

Bu örnekte:

• CreateUserRequest, beklenen istek gövdesinin yapısını tanımlar.
• app.use(bodyParser.json()), JSON istek gövdelerini ayrıştırmak için çok önemlidir. Bunu kullanmazsanız, req.body tanımsız olacaktır.
• Request türü artık Request<any, any, CreateUserRequest> şeklindedir ve istek gövdesinin CreateUserRequest arayüzüne uyması gerektiğini belirtir.

TypeScript artık req.body nesnesinin beklenen özellikleri (firstName, lastName ve email) içerdiğinden ve türlerinin doğru olduğundan emin olacaktır. Bu, yanlış istek gövdesi verilerinden kaynaklanan çalışma zamanı hataları riskini önemli ölçüde azaltır.

Rota Parametrelerini İşleme

Parametreli rotalar için (örneğin, /users/:id), rota parametreleri için bir arayüz tanımlayabilir ve bunu Request türünde kullanabilirsiniz:

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, res: Response) => {
  const userId = req.params.id;

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

  if (!user) {
    return res.status(404).send('Kullanıcı bulunamadı.');
  }

  res.json(user);
});

app.listen(port, () => {
  console.log(`Sunucu http://localhost:${port} adresinde çalışıyor`);
});

Bu örnekte:

• UserParams, rota parametrelerinin yapısını tanımlar ve id parametresinin bir dize olması gerektiğini belirtir.
• Request türü artık Request<UserParams> şeklindedir ve req.params nesnesinin UserParams arayüzüne uyması gerektiğini belirtir.

TypeScript artık req.params.id özelliğinin var olduğundan ve string türünde olduğundan emin olacaktır. Bu, mevcut olmayan rota parametrelerine erişim veya bunları yanlış türlerle kullanma nedeniyle oluşan hataları önlemeye yardımcı olur.

Yanıt Türlerini Belirtme

İstek türü güvenliğine odaklanmak çok önemli olsa da, yanıt türlerini tanımlamak da kod açıklığını artırır ve tutarsızlıkların önlenmesine yardımcı olur. Yanıtta geri gönderdiğiniz verilerin türünü tanımlayabilirsiniz.

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) => {
    res.json(users);
});

app.listen(port, () => {
  console.log(`Sunucu http://localhost:${port} adresinde çalışıyor`);
});

Burada, Response<User[]>, yanıt gövdesinin User nesnelerinin bir dizisi olması gerektiğini belirtir. Bu, API yanıtlarınızda tutarlı bir veri yapısı göndermenizi sağlar. `User[]` türüne uymayan veriler göndermeye çalışırsanız, TypeScript bir uyarı yayınlayacaktır.

Middleware Tür Güvenliği

Middleware işlevleri, Express.js uygulamalarında kesişen kaygıları ele almak için çok önemlidir. Middleware'de tür güvenliğini sağlamak, rota işleyicilerde olduğu kadar önemlidir.

Middleware İşlevlerini Yazma

TypeScript'teki bir middleware işlevinin temel yapısı, bir rota işleyicisinin yapısına benzerdir:

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

function authenticationMiddleware(req: Request, res: Response, next: NextFunction) {
  // Kimlik doğrulama mantığı
  const isAuthenticated = true; // Gerçek kimlik doğrulama kontrolüyle değiştirin

  if (isAuthenticated) {
    next(); // Bir sonraki middleware veya rota işleyicisine geçin
  } else {
    res.status(401).send('Yetkisiz');
  }
}

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

app.use(authenticationMiddleware);

app.get('/', (req: Request, res: Response) => {
  res.send('Merhaba, kimliği doğrulanmış kullanıcı!');
});

app.listen(port, () => {
  console.log(`Sunucu http://localhost:${port} adresinde çalışıyor`);
});

Bu örnekte:

• NextFunction, Express.js tarafından sağlanan ve zincirdeki bir sonraki middleware işlevini temsil eden bir türdür.
• Middleware işlevi, rota işleyicilerle aynı Request ve Response nesnelerini alır.

İstek Nesnesini Artırma

Bazen, middleware'inizdeki Request nesnesine özel özellikler eklemek isteyebilirsiniz. Örneğin, bir kimlik doğrulama middleware'i, istek nesnesine bir user özelliği ekleyebilir. Bunu tür güvenli bir şekilde yapmak için, Request arayüzünü artırmanız gerekir.

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

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

// İstek arayüzünü artırın
declare global {
  namespace Express {
    interface Request {
      user?: User;
    }
  }
}

function authenticationMiddleware(req: Request, res: Response, next: NextFunction) {
  // Kimlik doğrulama mantığı (gerçek kimlik doğrulama kontrolüyle değiştirin)
  const user: User = { id: '123', username: 'johndoe', email: 'john.doe@example.com' };
  req.user = user; // Kullanıcıyı istek nesnesine ekleyin
  next(); // Bir sonraki middleware veya rota işleyicisine geçin
}

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

app.use(authenticationMiddleware);

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

app.listen(port, () => {
  console.log(`Sunucu http://localhost:${port} adresinde çalışıyor`);
});

Bu örnekte:

• Express.Request arayüzünü artırmak için küresel bir bildirim kullanıyoruz.
• Request arayüzüne User türünde isteğe bağlı bir user özelliği ekliyoruz.
• Artık, TypeScript'in şikayet etmeden rota işleyicilerinizde req.user özelliğine erişebilirsiniz. req.user?.username içindeki ?, kullanıcının kimliği doğrulanmadığı durumları ele almak, olası hataları önlemek için çok önemlidir.

TypeScript Express Entegrasyonu İçin En İyi Uygulamalar

Express.js uygulamalarınızda TypeScript'in faydalarını en üst düzeye çıkarmak için şu en iyi uygulamaları izleyin:

• Katı Modu Etkinleştirin: Tüm katı tür denetimi seçeneklerini etkinleştirmek için tsconfig.json dosyanızda "strict": true seçeneğini kullanın. Bu, olası hataları erken yakalamanıza ve daha yüksek düzeyde tür güvenliği sağlar.
• Arayüzler ve Tür Takma Adları Kullanın: Verilerinizin yapısını temsil etmek için arayüzler ve tür takma adları tanımlayın. Bu, kodunuzu daha okunabilir ve bakımı kolay hale getirir.
• Genel Türleri Kullanın: Yeniden kullanılabilir ve tür güvenli bileşenler oluşturmak için genel türlerden yararlanın.
• Birim Testleri Yazın: Kodunuzun doğruluğunu doğrulamak ve tür açıklamalarınızın doğru olduğundan emin olmak için birim testleri yazın. Test etme, kod kalitesini korumak için çok önemlidir.
• Bir Linter ve Biçimlendirici Kullanın: Tutarlı kodlama stilleri uygulamak ve olası hataları yakalamak için bir linter (ESLint gibi) ve bir biçimlendirici (Prettier gibi) kullanın.
• any Türünden Kaçının: Tür denetimini atladığı ve TypeScript kullanmanın amacını ortadan kaldırdığı için any türünün kullanımını en aza indirin. Yalnızca kesinlikle gerekli olduğunda kullanın ve mümkün olduğunda daha özel türler veya jenerikler kullanmayı düşünün.
• Projenizi mantıksal olarak yapılandırın: Projenizi işlevselliğe göre modüllere veya klasörlere düzenleyin. Bu, uygulamanızın bakımını ve ölçeklenebilirliğini artıracaktır.
• Bağımlılık Enjeksiyonu Kullanın: Uygulamanızın bağımlılıklarını yönetmek için bir bağımlılık enjeksiyonu kapsayıcısı kullanmayı düşünün. Bu, kodunuzu daha test edilebilir ve bakımı kolay hale getirebilir. InversifyJS gibi kitaplıklar popüler seçeneklerdir.

Express.js İçin Gelişmiş TypeScript Kavramları

Dekoratörleri Kullanma

Dekoratörler, sınıflara ve işlevlere meta veri eklemenin öz ve açıklayıcı bir yolunu sağlar. Express.js'de rota kaydını basitleştirmek için dekoratörleri kullanabilirsiniz.

İlk olarak, tsconfig.json dosyanızda "experimentalDecorators": true ekleyerek deneysel dekoratörleri etkinleştirmeniz gerekir.

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

Ardından, rotaları kaydetmek için özel bir dekoratör oluşturabilirsiniz:

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('Kullanıcı listesi');
  }

  @route('post', '/users')
  createUser(req: Request, res: Response) {
    res.status(201).send('Kullanıcı oluşturuldu');
  }

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

const userController = new UserController();

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

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

app.listen(port, () => {
  console.log(`Sunucu http://localhost:${port} adresinde çalışıyor`);
});

Bu örnekte:

• route dekoratörü, HTTP yöntemini ve yolu bağımsız değişken olarak alır.
• Dekore edilmiş yöntemi, sınıfla ilişkili yönlendiricide bir rota işleyicisi olarak kaydeder.
• Bu, rota kaydını basitleştirir ve kodunuzu daha okunabilir hale getirir.

Özel Tür Korumaları Kullanma

Tür korumaları, bir değişkenin türünü belirli bir kapsam içinde daraltan işlevlerdir. İstek gövdelerini veya sorgu parametrelerini doğrulamak için özel tür korumaları kullanabilirsiniz.

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('Geçersiz ürün verisi');
    }

    const product: Product = req.body;
    console.log(`Ürün oluşturuluyor: ${product.name}`);
    res.status(201).send('Ürün oluşturuldu');
});

app.listen(port, () => {
    console.log(`Sunucu http://localhost:${port} adresinde çalışıyor`);
});

Bu örnekte:

• isProduct işlevi, bir nesnenin Product arayüzüne uyup uymadığını kontrol eden özel bir tür korumasıdır.
• /products rota işleyicisinin içinde, istek gövdesini doğrulamak için isProduct işlevi kullanılır.
• İstek gövdesi geçerli bir ürünse, TypeScript, if bloğu içinde req.body'nin Product türünde olduğunu bilir.

API Tasarımında Küresel Hususların Ele Alınması

Küresel bir kitle için API'ler tasarlarken, erişilebilirlik, kullanılabilirlik ve kültürel duyarlılığı sağlamak için çeşitli faktörlerin dikkate alınması gerekir.

• Yerelleştirme ve Uluslararasılaştırma (i18n ve L10n):
  • İçerik Müzakeresi: Accept-Language başlığına göre içerik müzakeresi yoluyla birden çok dil ve bölgeyi destekleyin.
  • Tarih ve Saat Biçimlendirmesi: Farklı bölgelerde belirsizliği önlemek için tarih ve saat gösterimi için ISO 8601 biçimini kullanın.
  • Sayı Biçimlendirmesi: Sayı biçimlendirmeyi kullanıcının yerel ayarına göre işleyin (örneğin, ondalık ayırıcılar ve binlik ayırıcılar).
  • Para Birimi İşleme: Birden çok para birimini destekleyin ve gerektiğinde döviz kuru bilgileri sağlayın.
  • Metin Yönü: Arapça ve İbranice gibi sağdan sola (RTL) dilleri barındırın.
• Saat Dilimleri:
  • Sunucu tarafında tarihleri ve saatleri UTC (Eşgüdümlü Evrensel Zaman) cinsinden saklayın.
  • Kullanıcıların tercih ettikleri saat dilimini belirtmelerine izin verin ve tarihleri ve saatleri buna göre istemci tarafında dönüştürün.
  • Saat dilimi dönüştürmelerini işlemek için moment-timezone gibi kitaplıklar kullanın.
• Karakter Kodlaması:
  • Farklı dillerden çok çeşitli karakterleri desteklemek için tüm metin verileri için UTF-8 kodlamasını kullanın.
  • Veritabanınızın ve diğer veri depolama sistemlerinizin UTF-8 kullanacak şekilde yapılandırıldığından emin olun.
• Erişilebilirlik:
  • API'nizi engelli kullanıcılar için erişilebilir hale getirmek için erişilebilirlik yönergelerini (örneğin, WCAG) izleyin.
  • Anlaşılması kolay, net ve açıklayıcı hata mesajları sağlayın.
  • API belgelerinizde anlamsal HTML öğeleri ve ARIA öznitelikleri kullanın.
• Kültürel Duyarlılık:
  • Tüm kullanıcılar tarafından anlaşılmayabilecek kültüre özgü referanslardan, deyimlerden veya mizahlardan kaçının.
  • İletişim stilleri ve tercihleri ​​konusundaki kültürel farklılıkların farkında olun.
  • API'nizin farklı kültürel gruplar üzerindeki potansiyel etkisini düşünün ve klişeleri veya önyargıları sürdürmekten kaçının.
• Veri Gizliliği ve Güvenliği:
  • GDPR (Genel Veri Koruma Yönetmeliği) ve CCPA (California Tüketici Gizliliği Yasası) gibi veri gizliliği düzenlemelerine uyun.
  • Kullanıcı verilerini korumak için güçlü kimlik doğrulama ve yetkilendirme mekanizmaları uygulayın.
  • Hassas verileri hem aktarım sırasında hem de bekleme sırasında şifreleyin.
  • Kullanıcılara verileri üzerinde kontrol sağlayın ve verilerine erişmelerine, değiştirmelerine ve silmelerine izin verin.
• API Belgeleri:
  • Anlaşılması ve gezinmesi kolay, kapsamlı ve iyi organize edilmiş API belgeleri sağlayın.
  • Etkileşimli API belgeleri oluşturmak için Swagger/OpenAPI gibi araçlar kullanın.
  • Çeşitli bir kitleye hitap etmek için birden çok programlama dilinde kod örnekleri ekleyin.
  • Daha geniş bir kitleye ulaşmak için API belgelerinizi birden çok dile çevirin.
• Hata İşleme:
  • Belirli ve bilgilendirici hata mesajları sağlayın. "Bir şeyler ters gitti" gibi genel hata mesajlarından kaçının.
  • Hata türünü belirtmek için standart HTTP durum kodlarını kullanın (örneğin, Kötü İstek için 400, Yetkisiz için 401, Dahili Sunucu Hatası için 500).
  • Sorunları izlemek ve hata ayıklamak için kullanılabilen hata kodları veya tanımlayıcılar ekleyin.
  • Hata ayıklama ve izleme için sunucu tarafında hataları günlüğe kaydedin.
• Hız Sınırlandırma: API'nizi kötüye kullanımdan korumak ve adil kullanım sağlamak için hız sınırlaması uygulayın.
• Sürümlendirme: Geriye dönük uyumlu değişikliklere izin vermek ve mevcut istemcileri kırmamak için API sürüm oluşturmayı kullanın.

Sonuç

TypeScript Express entegrasyonu, arka uç API'lerinizin güvenilirliğini ve bakımı kolaylığını önemli ölçüde artırır. Rota işleyicilerde ve middleware'de tür güvenliğinden yararlanarak, geliştirme sürecinde erken hataları yakalayabilir ve küresel bir kitle için daha sağlam ve ölçeklenebilir uygulamalar oluşturabilirsiniz. İstek ve yanıt türlerini tanımlayarak, API'nizin tutarlı bir veri yapısına uymasını sağlayarak çalışma zamanı hataları olasılığını azaltırsınız. Katı modu etkinleştirme, arayüzler ve tür takma adları kullanma ve TypeScript'in faydalarını en üst düzeye çıkarmak için birim testleri yazma gibi en iyi uygulamalara uymayı unutmayın. API'lerinizin dünya çapında erişilebilir ve kullanılabilir olmasını sağlamak için her zaman yerelleştirme, saat dilimleri ve kültürel duyarlılık gibi küresel faktörleri göz önünde bulundurun.