TypeScriptでREST APIを構築する方法（例付き）

イントロダクション

TypeScriptはJavaScriptに静的型を追加することで開発体験を向上させ、実行時ではなく開発時に潜在的なエラーをキャッチします。これは特にAPI開発において、データ整合性と契約の一貫性を維持することが重要です。このチュートリアルの終わりまでに、実用的に使用できる、構造化され、型安全なREST APIを用意できます。

REST APIアーキテクチャの説明

実装に入る前に、APIが真にRESTfulであるために必要なことを明確にしましょう：

コアREST原則

ステートレス: クライアントからの各リクエストにはそれを処理するために必要なすべての情報が含まれます。サーバーはリクエスト間でクライアントのコンテキストを保存しません。
リソースベース: リソースはURLで識別され、標準のHTTPメソッドを使用して操作が行われます。
表現: リソースはクライアントが要求できる複数の表現（JSON、XMLなど）を持つことができます。
標準HTTPメソッド: RESTはGET、POST、PUT、DELETE、PATCHのようなメソッドを使用してCRUD操作を実行します：

GET: リソースを取得
POST: 新しいリソースを作成
PUT: 既存のリソースを更新（完全更新）
PATCH: リソースを部分的に更新
DELETE: リソースを削除

一様インターフェース: URLとHTTPメソッドを通じた一貫したリソースの識別と操作。

REST APIにTypeScriptを使用する理由

TypeScriptはAPI開発にいくつかの利点を提供します：

静的型チェック: 開発中に型に関連するエラーをキャッチします
強化されたIDEサポート: より良いオートコンプリートとドキュメントを提供します
インターフェース定義: クライアントとサーバー間の明確な契約が可能になります
コードの整理: モジュールとデコレーターを通じてより良いアーキテクチャを促進します
容易なリファクタリング: 型安全性により、大規模な変更がより安全になります
自己文書化されたコード: 型がデータ構造のドキュメントとして機能します

以下は、包括的なTypeScript REST APIチュートリアルと流れの良い関係のあるAPIテストセクションの書き直しです：

ApidogでREST APIをテストすべき理由

TypeScript REST APIを開発する際、Apidogは開発ワークフローと深く統合されているため、Postmanよりも優れたテスト体験を提供します。このツールのスキーマファーストアプローチはTypeScriptの型安全性を完全に補完し、次のことを可能にします：

TypeScriptインターフェースに対してレスポンスを検証する
Apidogは、APIレスポンスが定義されたスキーマと一致するかを自動的にチェックします。これはTypeScriptのコンパイル時の型チェックをAPIレベルで模倣しており、数値IDが文字列として返されたときなど、TypeScriptクライアントコードで実行時エラーを引き起こす可能性があるデータ型の不一致をキャッチします。

リアルなテストデータを生成する
TypeScriptモデル定義（Bookインターフェースなど）に基づいて、Apidogは適切に型付けされたモックデータを持つテストケースを自動的に作成でき、手動でのテスト設定に要する時間を何時間も節約します。これにより、テストが実際の使用パターンを反映することが保証されます。

環境間での一貫性を維持する
環境管理システムでは、開発、ステージング、プロダクション間で機能する型付けされた変数（API基本URLなど）を定義することができます。これはTypeScriptのconfig.tsがコードベースの環境変数を管理する方法に似ています。

複雑なテストシナリオを自動化する
Apidogのプリプロセッサースクリプトは高度なテストオーケストレーションを可能にし、次のことを実現します：

型安全を維持しながらAPI呼び出しをつなげる
リクエスト間でレスポンスデータを変換する
条件付きテストロジックを実装する
すべてTypeScriptのような型ヒントとオートコンプリートを活用しながら。

統合されたドキュメント
自動生成されたAPIドキュメントはテストと完全に同期しているため、APIプロジェクトによくあるドキュメントのズレを排除します。これは特にTypeScriptを使用する際に重要で、ランタイム動作が型定義と一致することを保証します。

TypeScript APIを構築するチームにとって、デザイン、テスト、ドキュメント間のApidogの緊密な統合は、Postmanの断片的なアプローチよりも効率的なワークフローを作成します。TypeScriptインターフェースに対してレスポンスを検証し、型安全なテストケースを生成する能力は、型駆動の開発プロセスに最適なコンパニオンです。

ボタン

前提条件

このチュートリアルを進めるためには、次のものが必要です：

Node.js（v14+推奨）がインストールされていること
テキストエディタまたはIDE（TypeScriptのサポートのためにVS Code推奨）
JavaScriptとNode.jsの基本的な知識
HTTPおよびRESTの概念に慣れていること
コマンドライン/ターミナルアクセス

ステップ1: プロジェクトのセットアップと初期化

構造化されたプロジェクト環境を作成しましょう：

# プロジェクトディレクトリを作成
mkdir typescript-rest-api
cd typescript-rest-api

# package.jsonを初期化
npm init -y

package.jsonの理解

package.jsonファイルは、Node.jsプロジェクトの心臓部です。プロジェクトに関するメタデータが含まれ、依存関係を管理します。-yフラグは、すぐにカスタマイズするデフォルト設定を作成します。

ステップ2: 依存関係のインストール

TypeScript REST APIに必要なパッケージをインストールしましょう：

# TypeScriptと開発ツールをインストール
npm install typescript ts-node nodemon @types/node --save-dev

# Expressと型定義をインストール
npm install express
npm install @types/express --save-dev

# ログ記録とパース用のミドルウェアをインストール
npm install morgan cors helmet
npm install @types/morgan @types/cors --save-dev

# 環境変数管理のためにdotenvをインストール
npm install dotenv

依存関係の内訳：

typescript: TypeScriptコンパイラ
ts-node: TypeScriptファイルを直接実行することを可能にします
nodemon: ファイルの変更を監視しサーバーを再起動します
express: HTTPリクエストを処理するためのWebフレームワークです
morgan: HTTPリクエストのロギングミドルウェア
cors: クロスオリジンリソースシェアリングを処理するためのミドルウェア
helmet: 様々なHTTPヘッダーを設定するセキュリティミドルウェアです
dotenv: .envファイルから環境変数を読み込みます

型定義パッケージ（@types/*）は、JavaScriptで記述されたライブラリに対してTypeScript型情報を提供します。

ステップ3: TypeScriptを設定する

TypeScriptの設定を初期化します：

npx tsc --init

これによりデフォルト設定を持つtsconfig.jsonファイルが作成されます。REST API用にカスタマイズしましょう：

{
  "compilerOptions": {
    "target": "ES6",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "skipLibCheck": true,
    "sourceMap": true,
    "resolveJsonModule": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "**/*.test.ts"]
}

設定の説明：

target: ECMAScriptターゲットバージョンを指定します（ES6はモダンな機能を提供）
module: モジュールシステムを定義します（CommonJSはNode.jsに適しています）
outDir: コンパイルされたJavaScriptファイルが配置される場所
rootDir: ソースTypeScriptファイルの場所
strict: すべての厳密型チェックオプションを有効にします
esModuleInterop: デフォルトエクスポートなしのモジュールからのデフォルトインポートを許可します
sourceMap: デバッグ用にソースマップファイルを生成します
resolveJsonModule: JSONファイルをモジュールとしてインポートできるようにします

ステップ4: 環境設定の作成

環境変数を格納するために、ルートディレクトリに.envファイルを作成します：

NODE_ENV=development
PORT=3000
API_VERSION=v1

次に、同じ構造の.env.exampleファイルを作成しますが、機密値は含めません。これは他の開発者のためのテンプレートとして使用されます：

NODE_ENV=development
PORT=3000
API_VERSION=v1

.envを.gitignoreファイルに追加して、機密情報がコミットされるのを防ぎます：

node_modules
dist
.env

ステップ5: package.jsonスクリプトの更新

有用なスクリプトを用意してpackage.jsonを強化します：

"main": "dist/server.js",
"scripts": {
  "start": "node dist/server.js",
  "dev": "nodemon src/server.ts",
  "build": "tsc",
  "lint": "eslint . --ext .ts",
  "test": "jest",
  "clean": "rimraf dist"
}

これらのスクリプトは、開発、プロダクションビルド、リント、テスト、コンパイル済みファイルのクリーンアップ用のコマンドを提供します。

ステップ6: プロジェクト構造の作成

整然としたディレクトリ構造を作成します：

typescript-rest-api/
├── src/
│   ├── config/        # 設定ファイル
│   │   └── index.ts   # 中央設定のエクスポート
│   ├── controllers/   # ルートハンドラー
│   ├── middleware/    # カスタムミドルウェア
│   ├── models/        # データモデル/インターフェース
│   ├── routes/        # ルート定義
│   │   └── v1/        # APIバージョン1のルート
│   ├── services/      # ビジネスロジック
│   ├── utils/         # ユーティリティ関数
│   ├── types/         # 型定義
│   ├── app.ts         # Expressアプリケーションのセットアップ
│   └── server.ts      # サーバーのエントリーポイント
├── .env               # 環境変数（gitignored）
├── .env.example       # 環境変数の例
├── .gitignore         # Gitの無視ファイル
├── package.json       # プロジェクトメタデータと依存関係
└── tsconfig.json      # TypeScript設定

この構造は関心の分離の原則に従い、コードベースが成長するにつれて管理しやすくなります。

ステップ7: 設定のセットアップ

src/config/index.tsに設定モジュールを作成します：

import dotenv from 'dotenv';
import path from 'path';

// .envファイルから環境変数を読み込む
dotenv.config({ path: path.resolve(__dirname, '../../.env') });

const config = {
  env: process.env.NODE_ENV || 'development',
  port: parseInt(process.env.PORT || '3000', 10),
  apiVersion: process.env.API_VERSION || 'v1',
  // 必要に応じて他の設定変数を追加
};

export default config;

ステップ8: Expressアプリケーションの作成

まず、src/app.tsを作成してExpressアプリケーションをセットアップしましょう：

import express, { Express } from 'express';
import morgan from 'morgan';
import helmet from 'helmet';
import cors from 'cors';

import config from './config';
import routes from './routes';
import { errorHandler, notFoundHandler } from './middleware/error.middleware';

const app: Express = express();

// ミドルウェア
app.use(helmet()); // セキュリティヘッダー
app.use(cors()); // CORSを有効にする
app.use(morgan(config.env === 'development' ? 'dev' : 'combined')); // リクエストのロギング
app.use(express.json()); // JSONボディを解析
app.use(express.urlencoded({ extended: true })); // URLエンコードされたボディを解析

// APIルート
app.use(`/api/${config.apiVersion}`, routes);

// ヘルスチェックエンドポイント
app.get('/health', (_req, res) => {
  res.status(200).json({ status: 'OK', timestamp: new Date() });
});

// エラーハンドリング
app.use(notFoundHandler);
app.use(errorHandler);

export default app;

次に、エントリーポイントとしてsrc/server.tsを作成します：

import app from './app';
import config from './config';

const startServer = () => {
  try {
    app.listen(config.port, () => {
      console.log(`サーバーがポート${config.port}で${config.env}モードで実行中`);
      console.log(`APIは:${config.port}/api/${config.apiVersion}で利用可能`);
      console.log(`ヘルスチェックは:${config.port}/healthで利用可能`);
    });
  } catch (error) {
    console.error('サーバーの起動に失敗しました:', error);
    process.exit(1);
  }
};

// 未処理のPromise拒否を処理する
process.on('unhandledRejection', (reason, promise) => {
  console.error('未処理の拒否が発生しました:', promise, '理由:', reason);
});

startServer();

ステップ9: データモデルと型の定義

src/models/book.model.tsにデータのための基本インターフェースを作成します：

export interface Book {
  id: number;
  title: string;
  author: string;
  publishYear?: number;
  genre?: string;
  isbn?: string;
  createdAt: Date;
  updatedAt: Date;
}

// 新しい本を作成するためのDTO（データ転送オブジェクト）
export interface CreateBookDTO {
  title: string;
  author: string;
  publishYear?: number;
  genre?: string;
  isbn?: string;
}

// 既存の本を更新するためのDTO（すべてのフィールドがオプション）
export interface UpdateBookDTO {
  title?: string;
  author?: string;
  publishYear?: number;
  genre?: string;
  isbn?: string;
}

// APIの一貫性のためのレスポンス構造
export interface BookResponse {
  data: Book | Book[] | null;
  message?: string;
  success: boolean;
}

ステップ10: サービスレイヤーの作成

サービスレイヤーには、コントローラーから分離されたビジネスロジックが含まれます。src/services/book.service.tsを作成します：

import { Book, CreateBookDTO, UpdateBookDTO } from '../models/book.model';

// メモリ内データベース（実際のアプリではデータベースを使用します）
let books: Book[] = [
  { id: 1, title: '1984', author: 'George Orwell', publishYear: 1949 },
  { id: 2, title: 'To Kill a Mockingbird', author: 'Harper Lee', publishYear: 1960 }
];

export class BookService {
  async getAllBooks(): Promise {
    return books;
  }

  async getBookById(id: number): Promise {
    const book = books.find(b => b.id === id);
    return book || null;
  }

  async createBook(bookData: CreateBookDTO): Promise {
    const newId = books.length > 0 ? Math.max(...books.map(b => b.id)) + 1 : 1;

    const newBook: Book = {
      id: newId,
      ...bookData
    };

    books.push(newBook);
    return newBook;
  }

  async updateBook(id: number, bookData: UpdateBookDTO): Promise {
    const index = books.findIndex(b => b.id === id);

    if (index === -1) {
      return null;
    }

    books[index] = { ...books[index], ...bookData };
    return books[index];
  }

  async deleteBook(id: number): Promise {
    const initialLength = books.length;
    books = books.filter(b => b.id !== id);

    return books.length !== initialLength;
  }
}

export default new BookService();

ステップ11: コントローラーをサービスレイヤーを使用するようにリファクタリング

src/controllers/book.controller.tsを更新して、新しいサービスレイヤーを使用します：

import { Request, Response } from 'express';
import bookService from '../services/book.service';

export const getBooks = async (_req: Request, res: Response) => {
  try {
    const books = await bookService.getAllBooks();
    return res.status(200).json(books);
  } catch (error) {
    return res.status(500).json({ message: '本の取得中にエラーが発生しました', error });
  }
};

export const getBookById = async (req: Request, res: Response) => {
  try {
    const id: number = parseInt(req.params.id);
    const book = await bookService.getBookById(id);

    if (!book) {
      return res.status(404).json({ message: '本が見つかりません' });
    }

    return res.status(200).json(book);
  } catch (error) {
    return res.status(500).json({ message: '本の取得中にエラーが発生しました', error });
  }
};

export const createBook = async (req: Request, res: Response) => {
  try {
    const bookData = req.body;

    // リクエストを検証
    if (!bookData.title || !bookData.author) {
      return res.status(400).json({ message: 'タイトルと著者は必須です' });
    }

    const newBook = await bookService.createBook(bookData);
    return res.status(201).json(newBook);
  } catch (error) {
    return res.status(500).json({ message: '本の作成中にエラーが発生しました', error });
  }
};

export const updateBook = async (req: Request, res: Response) => {
  try {
    const id: number = parseInt(req.params.id);
    const bookData = req.body;
    const updatedBook = await bookService.updateBook(id, bookData);

    if (!updatedBook) {
      return res.status(404).json({ message: '本が見つかりません' });
    }

    return res.status(200).json(updatedBook);
  } catch (error) {
    return res.status(500).json({ message: '本の更新中にエラーが発生しました', error });
  }
};

export const deleteBook = async (req: Request, res: Response) => {
  try {
    const id: number = parseInt(req.params.id);
    const success = await bookService.deleteBook(id);

    if (!success) {
      return res.status(404).json({ message: '本が見つかりません' });
    }

    return res.status(204).send();
  } catch (error) {
    return res.status(500).json({ message: '本の削除中にエラーが発生しました', error });
  }
};

ステップ12: リクエスト検証の追加

src/middleware/validation.middleware.tsに検証ミドルウェアを作成します：

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

export interface ValidationSchema {
  [key: string]: {
    required?: boolean;
    type?: 'string' | 'number' | 'boolean';
    minLength?: number;
    maxLength?: number;
    min?: number;
    max?: number;
    custom?: (value: any) => boolean;
    message?: string;
  };
}

export const validateRequest = (schema: ValidationSchema) => {
  return (req: Request, res: Response, next: NextFunction) => {
    const errors: string[] = [];

    Object.entries(schema).forEach(([field, rules]) => {
      const value = req.body[field];

      // 必須フィールドのチェック
      if (rules.required && (value === undefined || value === null || value === '')) {
        errors.push(rules.message || `フィールド '${field}' は必須です`);
        return;
      }

      // フィールドが存在しない場合、必要でない場合はさらに検証をスキップ
      if ((value === undefined || value === null) && !rules.required) {
        return;
      }

      // 型検証
      if (rules.type && typeof value !== rules.type) {
        errors.push(rules.message || `フィールド '${field}' は${rules.type}でなければなりません`);
      }

      // 文字列検証
      if (rules.type === 'string') {
        if (rules.minLength !== undefined && value.length < rules.minLength) {
          errors.push(rules.message || `フィールド '${field}' は最小${rules.minLength}文字である必要があります`);
        }

        if (rules.maxLength !== undefined && value.length > rules.maxLength) {
          errors.push(rules.message || `フィールド '${field}' は最大${rules.maxLength}文字を超えてはいけません`);
        }
      }

      // 数字の検証
      if (rules.type === 'number') {
        if (rules.min !== undefined && value < rules.min) {
          errors.push(rules.message || `フィールド '${field}' は最小${rules.min}である必要があります`);
        }

        if (rules.max !== undefined && value > rules.max) {
          errors.push(rules.message || `フィールド '${field}' は最大${rules.max}を超えてはいけません`);
        }
      }

      // カスタム検証
      if (rules.custom && !rules.custom(value)) {
        errors.push(rules.message || `フィールド '${field}' は検証に失敗しました`);
      }
    });

    if (errors.length > 0) {
      return res.status(400).json({ errors });
    }

    next();
  };
};

次に、src/validators/book.validator.tsに検証スキーマを作成します：

import { ValidationSchema } from '../middleware/validation.middleware';

export const createBookSchema: ValidationSchema = {
  title: {
    required: true,
    type: 'string',
    minLength: 1,
    maxLength: 100,
    message: 'タイトルは必須であり、1文字以上100文字以下である必要があります'
  },
  author: {
    required: true,
    type: 'string',
    minLength: 1,
    maxLength: 100,
    message: '著者は必須であり、1文字以上100文字以下である必要があります'
  },
  publishYear: {
    type: 'number',
    min: 0,
    max: new Date().getFullYear(),
    message: `出版年は0から${new Date().getFullYear()}の間である必要があります`
  }
};

export const updateBookSchema: ValidationSchema = {
  title: {
    type: 'string',
    minLength: 1,
    maxLength: 100,
    message: 'タイトルは1文字以上100文字以下である必要があります'
  },
  author: {
    type: 'string',
    minLength: 1,
    maxLength: 100,
    message: '著者は1文字以上100文字以下である必要があります'
  },
  publishYear: {
    type: 'number',
    min: 0,
    max: new Date().getFullYear(),
    message: `出版年は0から${new Date().getFullYear()}の間である必要があります`
  }
};

ステップ13: 検証を含むようにルートを更新

src/routes/book.routes.tsを更新して、検証ミドルウェアを含めます：

import { Router } from 'express';
import { getBooks, getBookById, createBook, updateBook, deleteBook } from '../controllers/book.controller';
import { validateRequest } from '../middleware/validation.middleware';
import { createBookSchema, updateBookSchema } from '../validators/book.validator';

const router = Router();

// GET /api/books - すべての本を取得
router.get('/', getBooks);

// GET /api/books/:id - 特定の本を取得
router.get('/:id', getBookById);

// POST /api/books - 新しい本を作成
router.post('/', validateRequest(createBookSchema), createBook);

// PUT /api/books/:id - 本を更新
router.put('/:id', validateRequest(updateBookSchema), updateBook);

// DELETE /api/books/:id - 本を削除
router.delete('/:id', deleteBook);

export default router;

ステップ14: APIドキュメントの追加

APIドキュメントのためにSwaggerをインストールします：

npm install swagger-ui-express @types/swagger-ui-express swagger-jsdoc @types/swagger-jsdoc --save-dev

src/utils/swagger.tsを作成します：

import swaggerJsdoc from 'swagger-jsdoc';
import swaggerUi from 'swagger-ui-express';

const options = {
  definition: {
    openapi: '3.0.0',
    info: {
      title: 'TypeScript REST API',
      version: '1.0.0',
      description: 'ExpressとTypeScriptで構築されたシンプルなREST API',
    },
    servers: [
      {
        url: '',
      },
    ],
  },
  apis: ['./src/routes/*.ts'],
};

const specs = swaggerJsdoc(options);

export { specs, swaggerUi };

SwaggerドキュメントのためにルートファイルにJSDocコメントを追加します：

/**
 * @swagger
 * components:
 *   schemas:
 *     Book:
 *       type: object
 *       required:
 *         - title
 *         - author
 *       properties:
 *         id:
 *           type: number
 *           description: 本の自動生成されたID
 *         title:
 *           type: string
 *           description: 本のタイトル
 *         author:
 *           type: string
 *           description: 本の著者
 *         publishYear:
 *           type: number
 *           description: 本が出版された年
 */

/**
 * @swagger
 * tags:
 *   name: Books
 *   description: 本管理API
 */

/**
 * @swagger
 * /books:
 *   get:
 *     summary: すべての本のリストを返す
 *     tags: [Books]
 *     responses:
 *       200:
 *         description: 本のリスト
 *         content:
 *           application/json:
 *             schema:
 *               type: array
 *               items:
 *                 $ref: '#/components/schemas/Book'
 */

// その他のエンドポイントにも似たようにJSDocコメントを追加します

server.tsを更新してSwaggerを含めます：

import { specs, swaggerUi } from './utils/swagger';

// ルートの前に追加
app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(specs));

ステップ15: CORSサポートの追加

CORSミドルウェアを追加してクロスオリジンリクエストを許可します：

npm install cors @types/cors --save-dev

server.tsを更新します：

import cors from 'cors';

// 他のミドルウェアの前に追加
app.use(cors());

// CORSオプションのより多くの制御のために：
app.use(cors({
  origin: ['', ''],
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization']
}));

ステップ16: 環境設定の追加

環境変数のための.envファイルを作成します：

PORT=3000
NODE_ENV=development
# データベース接続文字列のような他の設定変数を追加

環境変数を読み込むためにdotenvをインストールします：

npm install dotenv --save

src/config/env.config.tsを作成します：

import dotenv from 'dotenv';
import path from 'path';

// .envファイルから環境変数を読み込む
dotenv.config({ path: path.resolve(__dirname, '../../.env') });

export default {
  port: parseInt(process.env.PORT || '3000'),
  nodeEnv: process.env.NODE_ENV || 'development',
  // 他の環境変数をここに追加
};

server.tsを更新してこの設定を使用します：

import config from './config/env.config';

const PORT: number = config.port;

ステップ17: 最終統合とテスト

すべてのコンポーネントが整ったら、ファイル構造は次のようになります：

typescript-rest-api/
├── src/
│   ├── config/
│   │   └── env.config.ts
│   ├── controllers/
│   │   └── book.controller.ts
│   ├── middleware/
│   │   ├── error.middleware.ts
│   │   └── validation.middleware.ts
│   ├── models/
│   │   └── book.model.ts
│   ├── routes/
│   │   ├── book.routes.ts
│   │   └── index.ts
│   ├── services/
│   │   └── book.service.ts
│   ├── utils/
│   │   └── swagger.ts
│   ├── validators/
│   │   └── book.validator.ts
│   └── server.ts
├── .env
├── tsconfig.json
└── package.json

APIを実行します：

npm run dev

Postmanのようなツールを使用してエンドポイントをテストするか、http://localhost:3000/api-docsでSwaggerドキュメントにアクセスします。

結論

すでにTypeScriptを用いて堅牢なREST APIの構築が完了しました。このAPIは以下のベストプラクティスを示しています：

型安全性：TypeScriptインターフェースとモデルを通じて
クリーンアーキテクチャ：関心の分離（コントローラー、サービス、モデル）
入力検証：データ整合性を確保
エラーハンドリング：堅牢なAPIレスポンス
APIドキュメント：開発者体験を向上させるためにSwaggerを使用
CORSサポート：クロスオリジンリクエストのため
環境設定：異なるデプロイシナリオに対応

この基盤は、より複雑なアプリケーションの出発点として素晴らしいものになります。APIが成長するにつれて、次のことを実装することを検討してください：

TypeORM、Prisma、またはMongooseを使用したデータベース統合
JWTまたはOAuthを使用した認証ミドルウェア
悪用を防ぐためのレート制限
Winstonやその他のロギングライブラリを使用したロギング
Jest、Mocha、またはSuperTestを使用したテスト
一貫したデプロイのためのDockerを使用したコンテナ化

TypeScriptの静的型付けとExpressの柔軟なアーキテクチャの組み合わせにより、アプリケーションのニーズに応じて進化できる保守可能でスケーラブルなAPIが実現しました。