Hono入門｜TypeScriptでAPIを作成する方法【Node.js・Cloudflare対応】

$ curl https://get.volta.sh | bash

$ volta -v

$ volta install node@24.21.0

$ node -v

$ brew install pnpm

$ pnpm -v

$ mkdir hono-sample && cd hono-sample
$ pnpm create hono@latest .

$ touch .npmrc

engine-strict=true

{

・・・

  "engines": {
    "node": "24.21.0",
    "pnpm": "12.6.0"
  },
  "packageManager": "pnpm@12.6.0",

・・・

$ pnpm run dev

/hono-sample
 └─ /src
     |
     ├─ /core（中核の業務領域）
     |   |
     |   └─ /[domainName]（ドメインモジュール）
     |       |
     |       ├─ /domain（ドメイン）
     |       |   |
     |       |   ├─ [entityName].ts（エンティティ）
     |       |   |
     |       |   ├─ [valueObjectName].ts（値オブジェクト）
     |       |   |
     |       |   ├─ [domainServiceName]Service.ts（ドメインサービス）
     |       |   |
     |       |   ├─ [repositoryName]Repository.ts（リポジトリのインターフェース）
     |       |   |
     |       |   └─ [gatewayName]Gateway.ts（外部サービス用のインターフェース）
     |       |
     |       |
     |       ├─ /usecase（ユースケース層）
     |       |
     |       └─ /infrastructure（ドメイン用のインフラストラクチャ層）
     |           |
     |           ├─ /persistence（パーシステンス層）
     |           |   |
     |           |   └─ /pg（PostgreSQL用）
     |           |       |
     |           |       ├─ /command（書き込み）
     |           |       |
     |           |       └─ /query（読み込み）
     |           |
     |           └─ /external（外部サービスの実装）
     |
     ├─ /supporting（補完的なの業務領域）
     |   |
     |   └── /[supportingName]（サービス層）
     |        |
     |        └─ useCase.ts（ユースケース）
     |
     ├─ /generic（一般的な業務領域）
     |
     ├─ /shared（横断関心）
     |   |
     |   └─ /logger（共通ロガーの定義）
     |       |
     |       └─ logger.ts
     |
     ├─ /di（DIコンテナ層）
     |   |
     |   └─ nodeContainer.ts（Node.js環境用）
     |
     ├─ /infrastructure（共通のインフラストラクチャ層）
     |   |
     |   ├─ /logger
     |   |   |
     |   |   └─ consoleLogger.ts（consoleロガーの実装）
     |   |
     |   └─ /database
     |       |
     |       └─ /drizzle（Drizzle ORM用）
     |           |
     |           └─ /pg（PostgreSQL用）
     |               |
     |               ├─ /migration（マイグレーション関連）
     |               |
     |               ├─ /schema（スキーマ定義）
     |               |
     |               └─ client.ts（接続設定）
     |
     ├─ /presentation（プレゼンテーション層）
     |   |
     |   └─ /http
     |       |
     |       ├─ /middleware（ミドルウェア）
     |       |
     |       ├─ /core
     |       |   |
     |       |   └─ /[domainName]
     |       |       |
     |       |       ├─ handler.ts（ハンドラー部分）
     |       |       |
     |       |       └─ routes.ts（ルーティング部分）
     |       |
     |       ├─ /supporting
     |       |   |
     |       |   └─ /[supportingName]
     |       |       |
     |       |       ├─ handler.ts（ハンドラー部分）
     |       |       |
     |       |       └─ routes.ts（ルーティング部分）
     |       |
     |       ├─ /generic
     |       |
     |       └─ routesNode.ts（Node.js環境用のルーティング設定）
     |
     ├─ /runtime（ランタイム層）
     |   |
     |   └─ /node（Node.js環境用）
     |       |
     |       ├─ config.ts（コンフィグ設定）
     |       |
     |       ├─ app.ts（アプリ設定）
     |       |
     |       └─ server.ts（サーバー設定）
     |
     ├─ /tests（結合テスト用）
     |
     └─ app.ts（アプリ全体の定義）

$ pnpm add -D vitest @biomejs/biome
$ pnpm add zod @hono/zod-validator

$ pnpm biome init

$ mkdir -p src/shared/logger && touch src/shared/logger/logger.ts
$ mkdir -p src/infrastructure/logger && touch src/infrastructure/logger/consoleLogger.ts

// ログ用コンテキストの型定義
export type LogContext = {
  requestId?: string;
  [key: string]: unknown;
};

// ロガーのインターフェース定義
export interface Logger {
  info(message: string, context?: LogContext): void;
  warn(message: string, context?: LogContext): void;
  error(message: string, context?: LogContext): void;
  debug(message: string, context?: LogContext): void;
  withRequestId(requestId: string): Logger;
};

import type { LogContext, Logger } from "../../shared/logger/logger.js";

// ロガーの作成用関数
const createLogger = (baseContext: LogContext = {}): Logger => {
  // ログ出力用の関数定義
  const log = (level: string, message: string, context: LogContext = {}) => {
    console.log(
      JSON.stringify({
        level,
        message,
        ...baseContext,
        ...context,
        timestamp: new Date().toISOString(),
      }),
    );
  };

  return {
    info(message, context) {
      log("INFO", message, context);
    },

    warn(message, context) {
      log("WARN", message, context);
    },

    error(message, context) {
      log("ERROR", message, context);
    },

    debug(message, context) {
      log("DEBUG", message, context);
    },

    withRequestId(requestId) {
      return createLogger({
        ...baseContext,
        requestId,
      });
    },
  };
};

// ロガーのインスタンス
export const logger = createLogger();

$ mkdir -p src/supporting/sample && touch src/supporting/sample/useCase.ts src/supporting/sample/useCase.test.ts
$ mkdir -p src/tests/integration/supporting/sample && touch src/tests/integration/supporting/sample/sample.test.ts
$ mkdir -p src/presentation/http/supporting/sample && touch src/presentation/http/supporting/sample/handler.ts
$ touch src/presentation/http/supporting/sample/routes.ts src/presentation/http/supporting/sample/routes.test.ts
$ mkdir -p src/presentation/http/middleware && touch src/presentation/http/middleware/requestLogger.ts
$ touch src/app.ts .env
$ rm src/index.ts

import type { Logger } from "../../shared/logger/logger.js";

type SampleTextInput = {
  text: string;
};

export class SampleHelloUseCase {
  execute(logger: Logger) {
    // ログ出力
    logger.info("SampleHelloUseCaseを実行！");

    return {
      message: "Hello World !!",
    };
  }
}

export class SampleTextUseCase {
  execute(logger: Logger, input: SampleTextInput) {
    // ログ出力
    logger.info("SampleTextUseCaseを実行！", { text: input.text });

    return {
      message: input.text,
    };
  }
}

import { beforeEach, describe, expect, it, vi } from "vitest";
import type { Logger } from "../../shared/logger/logger.js";
import { SampleHelloUseCase, SampleTextUseCase } from "./useCase.js";

// ロガーのモック化
const createMockLogger = (): Logger => ({
  info: vi.fn(),
  warn: vi.fn(),
  error: vi.fn(),
  debug: vi.fn(),
  withRequestId: vi.fn(),
});

let logger: Logger;

// テスト前の共通セットアップ
beforeEach(() => {
  logger = createMockLogger();
});

describe("SampleHelloUseCase", () => {
  it("Hello Worldを返す", () => {
    // ユースケース作成
    const useCase = new SampleHelloUseCase();

    // ユースケース実行
    const result = useCase.execute(logger);

    // 検証
    expect(result).toEqual({
      message: "Hello World !!",
    });

    expect(logger.info).toHaveBeenCalledWith("SampleHelloUseCaseを実行！");
  });
});

describe("SampleTextUseCase", () => {
  it("渡されたtextを返す", () => {
    // ユースケース作成
    const useCase = new SampleTextUseCase();

    // ユースケース実行
    const result = useCase.execute(logger, {
      text: "テストメッセージ",
    });

    // 検証
    expect(result).toEqual({
      message: "テストメッセージ",
    });

    expect(logger.info).toHaveBeenCalledWith("SampleTextUseCaseを実行！", {
      text: "テストメッセージ",
    });
  });
});

import { testClient } from "hono/testing";
import { describe, expect, it, vi } from "vitest";
import { createNodeApp } from "../../../../runtime/node/app.js";
import type { NodeConfig } from "../../../../runtime/node/config.js";
import { config } from "../../../../runtime/node/config.js";

// ログ出力の無効化
vi.spyOn(console, "log").mockImplementation(() => {});

// テスト用コンフィグ変数
let testConfig: NodeConfig;

// テスト用クライアント作成関数
const createTestClient = () => {
  testConfig = {
    ...config,
  };

  return testClient(createNodeApp(testConfig));
};

describe("GET /api/v1/sample", () => {
  const client = createTestClient();

  it("メッセージに「Hello World !!」を出力し、正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.sample.$get();

    // 検証
    expect(response.status).toBe(200);

    // レスポンス結果の検証
    const body = await response.json();
    expect(body).toEqual({
      message: "Hello World !!",
    });
  });
});

describe("POST /api/v1/sample", () => {
  const client = createTestClient();

  it("メッセージに「サンプルテキスト！」を出力し、正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.sample.$post({
      json: {
        text: "サンプルテキスト！",
      },
    });

    // 検証
    expect(response.status).toBe(200);

    // レスポンス結果の検証
    const body = await response.json();
    expect(body).toEqual({
      message: "サンプルテキスト！",
    });
  });
});

import type { Context } from "hono";
import type {
  SampleHelloUseCase,
  SampleTextInput,
  SampleTextUseCase,
} from "../../../../supporting/sample/useCase.js";

export const createSampleHelloHandler =
  (useCase: SampleHelloUseCase) => (c: Context) => {
    // 共通ロガー取得
    const logger = c.get("logger");

    // ユースケース実行
    const result = useCase.execute(logger);

    return c.json(result);
};

export const createSampleTextHandler =
  (useCase: SampleTextUseCase) => (c: Context, input: SampleTextInput) => {
    // 共通ロガー取得
    const logger = c.get("logger");

    // ユースケース実行
    const result = useCase.execute(logger, input);

    return c.json(result);
};

import { zValidator } from "@hono/zod-validator";
import { Hono } from "hono";
import { z } from "zod";
import type {
  SampleHelloUseCase,
  SampleTextInput,
  SampleTextUseCase,
} from "../../../../supporting/sample/useCase.js";
import {
  createSampleHelloHandler,
  createSampleTextHandler,
} from "./handler.js";

// リクエストボディ用のスキーマ定義
const sampleTextRequestBodySchema = z.object({
  text: z
    .string()
    .min(1, "textは必須です")
    .max(10, "textは10文字以内で入力してください"),
});


export const createSampleRoutes = (
  sampleHelloUseCase: SampleHelloUseCase,
  sampleTextUseCase: SampleTextUseCase,
) => {
  // Honoでルーティングを作る際は、メソッドチェーン推薦
  return (
    new Hono()
      // GET /sample
      .get("/", createSampleHelloHandler(sampleHelloUseCase))
      // POST /sample
      .post(
        "/",
        zValidator("json", sampleTextRequestBodySchema), // バリデーションチェック
        (c) => {
          // バリデーション済みのリクエストパラメータを取得
          const { text } = c.req.valid("json");

          // バリデーション済みのリクエストパラメータを取得
          const input: SampleTextInput = { text };

          return createSampleTextHandler(sampleTextUseCase)(c, input);
        },
      )
  );
};

import { Hono } from "hono";
import { testClient } from "hono/testing";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { createApp } from "../../../../app.js";
import type { NodeConfig } from "../../../../runtime/node/config.js";
import { config } from "../../../../runtime/node/config.js";
import type {
  SampleHelloUseCase,
  SampleTextUseCase,
} from "../../../../supporting/sample/useCase.js";
import { createSampleRoutes } from "./routes.js";

// ログ出力の無効化
vi.spyOn(console, "log").mockImplementation(() => {});

// UseCaseのモック
let sampleHelloUseCase: {
  execute: ReturnType<typeof vi.fn>;
};

let sampleTextUseCase: {
  execute: ReturnType<typeof vi.fn>;
};

// テスト用クライアント作成関数
const createTestClient = (config: NodeConfig) => {
  // ルーティング設定
  const v1 = new Hono().route(
    "/sample",
    createSampleRoutes(
      sampleHelloUseCase as SampleHelloUseCase,
      sampleTextUseCase as SampleTextUseCase,
    ),
  );
  const routes = new Hono().route("/v1", v1);
  const app = createApp(config).route("/api", routes);

  return testClient(app);
};

// テスト用クライアント変数
let client: ReturnType<typeof createTestClient>;

// テスト用コンフィグ変数
let testConfig: NodeConfig;

// テスト前の共通セットアップ
beforeEach(() => {
  // モックの初期化
  sampleHelloUseCase = {
    execute: vi.fn().mockReturnValue({
      message: "Hello World !!",
    }),
  };

  sampleTextUseCase = {
    execute: vi.fn().mockReturnValue({
      message: "テキスト！",
    }),
  };

  testConfig = {
    ...config,
  };

  client = createTestClient(testConfig);
});

describe("GET /api/v1/sample", () => {
  it("正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.sample.$get();

    // 検証
    expect(response.status).toBe(200);
    expect(sampleHelloUseCase.execute).toHaveBeenCalledTimes(1);
  });
});

describe("POST /api/v1/sample", () => {
  it("正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.sample.$post({
      json: {
        text: "サンプル！",
      },
    });

    // 検証
    expect(response.status).toBe(200);
    expect(sampleTextUseCase.execute).toHaveBeenCalledTimes(1);
    expect(sampleTextUseCase.execute).toHaveBeenCalledWith(expect.anything(), {
      text: "サンプル！",
    });
  });

  it("textが未指定の場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.sample.$post({
      json: {
        text: "",
      },
    });

    // 検証
    expect(response.status).toBe(400);
    expect(sampleTextUseCase.execute).not.toHaveBeenCalled();
  });

  it("textが全角10文字以内の場合に正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.sample.$post({
      json: {
        text: "あいうえおかきくけこ",
      },
    });

    // 検証
    expect(response.status).toBe(200);
    expect(sampleTextUseCase.execute).toHaveBeenCalledTimes(1);
  });

  it("textが全角10文字を超えている場合にバリデーションエラーになること", async () => {
     // テスト実行
     const response = await client.api.v1.sample.$post({
       json: {
         text: "あいうえおかきくけこさ",
       },
     });

     // 検証
     expect(response.status).toBe(400);
     expect(sampleTextUseCase.execute).not.toHaveBeenCalled();
  });

  it("textが半角10文字以内の場合に正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.sample.$post({
      json: {
        text: "abcdefghij",
      },
    });

    // 検証
    expect(response.status).toBe(200);
    expect(sampleTextUseCase.execute).toHaveBeenCalledTimes(1);
  });

  it("textが半角10文字を超えている場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.sample.$post({
      json: {
        text: "abcdefghijk",
      },
    });

    // 検証
    expect(response.status).toBe(400);
    expect(sampleTextUseCase.execute).not.toHaveBeenCalled();
  });
});

import { createMiddleware } from "hono/factory";
import { logger } from "../../../infrastructure/logger/consoleLogger.js";

export const requestLogger = createMiddleware(async (c, next) => {
  // 処理の開始時刻を取得
  const start = performance.now();

  // Honoのミドルウェアで設定したリクエストIDを取得
  const requestId = c.get("requestId");

  // リクエストIDをセットしたロガーを取得
  const requestLogger = logger.withRequestId(requestId);

  // 共通ロガーを設定
  c.set("logger", requestLogger);

  // 処理実行
  await next();

  // 処理時間を取得
  const duration = performance.now() - start;

  // 処理結果をログ出力
  requestLogger.info("HTTP request", {
    method: c.req.method,
    path: c.req.path,
    durationMs: Math.round(duration),
    status: c.res.status,
  });
});

import { Hono } from "hono";
import { cors } from "hono/cors";
import { requestId } from "hono/request-id";
import { requestLogger } from "./presentation/http/middleware/requestLogger.js";
import type { Logger } from "./shared/logger/logger.js";

// アプリのコンフィグ型
export type AppConfig = {
  env: string;
  corsOrigin: string;
};

// アプリの変数型
export type AppVariables = {
  Variables: {
    requestId: string;
    logger: Logger;
  };
};

export const createApp = (config: AppConfig) => {
  // Honoでルーティングを作る際は、メソッドチェーン推薦
  return (
    new Hono<AppVariables>()
      .get("/", (c) => {
        return c.text("Hello Hono!");
      })
      // CORS設定
      .use(
        "*",
        cors({
          origin: config.corsOrigin,
          allowHeaders: ["Content-Type", "Authorization"],
          credentials: true,
        }),
      )
      // 共通ミドルウェア設定
      .use("*", requestId())
      .use("*", requestLogger)
  );
};

ENV=local
PORT=3000
CORS_ORIGIN="http://localhost:3000"

$ mkdir -p src/runtime/node
$ touch src/runtime/node/config.ts src/runtime/node/app.ts src/runtime/node/server.ts
$ mkdir -p src/di && touch src/di/nodeContainer.ts
$ touch src/presentation/http/routesNode.ts

import type { AppConfig } from "../../app.js";

// Node環境用のコンフィグ型
export type NodeConfig = AppConfig & {
  port: number;
};

// Node環境用のコンフィグ設定
export const config: NodeConfig = {
  env: process.env.ENV ?? "local",
  corsOrigin: process.env.CORS_ORIGIN ?? "http://localhost:3000",
  port: Number(process.env.PORT ?? "3000"),
};

import { createApp } from "../../app.js";
import { createNodeContainer } from "../../di/nodeContainer.js";
import { createRoutesNode } from "../../presentation/http/routesNode.js";
import type { NodeConfig } from "./config.js";

// Node.js環境用のapp作成関数
export const createNodeApp = (config: NodeConfig) => {
  const container = createNodeContainer(config);

  return createApp(config).route("/api", createRoutesNode(container));
};

export type NodeApp = ReturnType<typeof createNodeApp>;

import { serve } from "@hono/node-server";
import { createNodeApp } from "./app.js";
import { config } from "./config.js";

// Node.js環境用のapp作成
const app = createNodeApp(config);

// サーバー起動処理
serve(
  {
    fetch: app.fetch,
    port: config.port,
  },
  (info) => {
    console.log(`Server is running on http://localhost:${info.port}`);
  },
);

import type { NodeConfig } from "../runtime/node/config.js";
import {
  SampleHelloUseCase,
  SampleTextUseCase,
} from "../supporting/sample/useCase.js";

export const createNodeContainer = (_config: NodeConfig) => {
  const sampleHelloUseCase = new SampleHelloUseCase();
  const sampleTextUseCase = new SampleTextUseCase();

  return {
    sampleHelloUseCase,
    sampleTextUseCase,
  };
};

export type NodeContainer = ReturnType<typeof createNodeContainer>;

import { Hono } from "hono";
import type { NodeContainer } from "../../di/nodeContainer.js";
import { createSampleRoutes } from "../http/supporting/sample/routes.js";

export const createRoutesNode = (container: NodeContainer) => {
  /******************************
  * v1用のルーティング
  ******************************/
  // Honoでルーティングを作る際は、メソッドチェーン推薦
  const v1 = new Hono()
    .route(
      "/sample",
      createSampleRoutes(
        container.sampleHelloUseCase,
        container.sampleTextUseCase,
      ),
    );

  /******************************
  * ルーティング設定
  ******************************/
  return new Hono().route("/v1", v1);
};

{

・・・

  "scripts": {
    "dev": "pnpm run dev:node",
    "dev:node": "tsx watch src/runtime/node/server.ts",
    "build:node": "tsc",
    "start:node": "node dist/runtime/node/server.js",
    "test": "vitest run",
    "test:verbose": "vitest run --reporter=verbose",
    "test:watch": "vitest",
    "format": "biome format --write . && biome check --write --only=assist/source/organizeImports .",
    "lint": "biome lint .",
    "check": "biome check .",
    "check:fix": "biome check --write ."
  },

・・・

}

$ pnpm run format
$ pnpm run lint

$ pnpm run test

$ pnpm run dev

$ mkdir -p deploy/docker/local/db/pg && touch deploy/docker/local/db/pg/Dockerfile
$ mkdir -p deploy/docker/local/db/pg/init && touch deploy/docker/local/db/pg/init/init.sql
$ touch compose.yaml

FROM postgres:18.6

ENV LANG=ja_JP.utf8

# PostgreSQLの日本語化で「ja_JP.utf8」を使うために必要
RUN apt-get update && \
    apt-get install -y locales && \
    rm -rf /var/lib/apt/lists/* && \
    localedef -i ja_JP -c -f UTF-8 -A /usr/share/locale/locale.alias ja_JP.UTF-8

-- テスト用DB作成
CREATE DATABASE "testing-db-pg";

services:
  pg:
    container_name: hono-sample-pg
    build:
      context: .
      dockerfile: ./deploy/docker/local/db/pg/Dockerfile
    environment:
      POSTGRES_DB: "local-db-pg"
      POSTGRES_USER: "root"
      POSTGRES_PASSWORD: "root-pass"
      # ローカル環境でもパスワードを有効化する設定
      POSTGRES_INITDB_ARGS: --auth-local=scram-sha-256 --auth-host=scram-sha-256
    volumes:
      - hono-sample-pg-data:/var/lib/postgresql
      # 初回起動時にSQLを実行する設定
      - ./deploy/docker/local/db/pg/init:/docker-entrypoint-initdb.d
    ports:
      - "5432:5432"
volumes:
  hono-sample-pg-data:

ENV=production
PORT=3000
CORS_ORIGIN="http://localhost:3000"
DB_PG_NAME=local-db-pg
DB_PG_USER=root
DB_PG_PASSWORD=root-pass
DB_PG_HOST=localhost
DB_PG_PORT=5432
DB_PG_MAX_OPEN_CONNS=2
DB_PG_CONN_MAX_LIFETIME=300

$ docker compose up -d

$ docker compose ps

$ pnpm add drizzle-orm pg dotenv
$ pnpm add -D drizzle-kit @types/pg

$ touch drizzle.pg.config.ts
$ mkdir -p src/infrastructure/database/drizzle/pg && touch src/infrastructure/database/drizzle/pg/client.ts

import "dotenv/config";
import { defineConfig } from "drizzle-kit";

// テスト用のDB名
const testingDbPgName = "testing-db-pg";

// 接続先DB名
const dbPgName =
  process.env.ENV === "testing" ? testingDbPgName : process.env.DB_PG_NAME;

// 接続先URL
const url =
  `postgresql://${process.env.DB_PG_USER}:${process.env.DB_PG_PASSWORD}` +
  `@${process.env.DB_PG_HOST}:${process.env.DB_PG_PORT}` +
  `/${dbPgName}`;

// drizzleのDB接続設定
export default defineConfig({
  dialect: "postgresql",
  schema: "./src/infrastructure/database/drizzle/pg/schema/*.ts",
  out: "./src/infrastructure/database/drizzle/pg/migrations",
  dbCredentials: {
    url: url,
  },
});

import type { NodePgDatabase } from "drizzle-orm/node-postgres";
import { drizzle } from "drizzle-orm/node-postgres";
import { Pool } from "pg";

// PostgreSQL用のコンフィグ型
export type PgConfig = {
  name: string;
  user: string;
  password: string;
  host: string;
  port: number;
  maxOpenConns: number;
  connMaxLifetime: number;
};

// PostgreSQLのインスタンス型
export type PgDatabase = NodePgDatabase;

// PostgreSQLのトランザクションのインスタンス型
export type PgTransaction = Parameters<
  Parameters<PgDatabase["transaction"]>[0]
>[0];

// PostgreSQLのDBクライアント型
export type PgDbClient = PgDatabase | PgTransaction;

// DBインスタンス生成用関数
export const createDbPg = (config: PgConfig) => {
  const pool = new Pool({
    database: config.name,
    user: config.user,
    password: config.password,
    host: config.host,
    port: config.port,
    max: config.maxOpenConns,
    maxLifetimeSeconds: config.connMaxLifetime,
  });

  const db = drizzle({
    client: pool,
  });

  return {
    pool,
    db,
  };
};

export type DbPg = ReturnType<typeof createDbPg>;

{
  ・・・

  "exclude": ["node_modules", "drizzle.pg.config.ts"]
}

$ mkdir -p src/infrastructure/database/drizzle/pg/schema && touch src/infrastructure/database/drizzle/pg/schema/users.ts

import {
  bigint,
  index,
  integer,
  pgTable,
  text,
  timestamp,
  uuid,
} from "drizzle-orm/pg-core";

export const users = pgTable(
  "users",
  {
    id: bigint("id", { mode: "number" })
      .primaryKey()
      .generatedAlwaysAsIdentity(),
    uid: uuid().notNull().defaultRandom().unique(),
    lastName: text("last_name").notNull(),
    firstName: text("first_name").notNull(),
    totalPurchaseAmount: integer("total_purchase_amount").notNull().default(0),
    createdAt: timestamp("created_at", {
      withTimezone: true,
    })
      .notNull()
      .defaultNow(),
    updatedAt: timestamp("updated_at", {
      withTimezone: true,
    })
      .notNull()
      .defaultNow(),
  },
  (table) => [index("users_last_name_idx").on(table.lastName)],
);

$ pnpm drizzle-kit generate --config=drizzle.pg.config.ts

$ pnpm drizzle-kit migrate --config=drizzle.pg.config.ts

docker compose exec pg bash
PGPASSWORD=root-pass psql -U root -d local-db-pg
\dt

\d users

\q
exit

$ pnpm add -D wrangler @cloudflare/workers-types

$ pnpm wrangler --version

$ touch wrangler.jsonc

{
  "name": "local-d1",
  "compatibility_date": "2026-09-29",

  "d1_databases": [
    {
      "binding": "DB",
      "database_name": "local-db-d1",
      "database_id": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
      "migrations_dir": "src/infrastructure/database/drizzle/d1/migrations"
    }
  ]
}

$ pnpm wrangler d1 execute local-db-d1 --local --command="SELECT 1"

{
  "name": "local-d1",
  "compatibility_date": "2026-09-29",

  "d1_databases": [
    {
      "binding": "DB",
      "database_name": "local-db-d1",
      "database_id": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
      "migrations_dir": "src/infrastructure/database/drizzle/d1/migrations"
    },
    {
      "binding": "TEST_DB",
      "database_name": "testing-db-d1",
      "database_id": "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy",
      "migrations_dir": "src/infrastructure/database/drizzle/d1/migrations"
    }
  ]
}

$ pnpm wrangler d1 execute testing-db-d1 --local --command="SELECT 1"

ENV=production
PORT=3000
CORS_ORIGIN="http://localhost:3000"
DB_PG_NAME=local-db-pg
DB_PG_USER=root
DB_PG_PASSWORD=root-pass
DB_PG_HOST=localhost
DB_PG_PORT=5432
DB_PG_MAX_OPEN_CONNS=2
DB_PG_CONN_MAX_LIFETIME=300
DB_D1_PATH=".wrangler/state/v3/d1/miniflare-D1DatabaseObject/423c60534c20823e3775c6e1de8b0d6f1fb85ef14b525413932d985d8dc6abf5.sqlite"
DB_D1_TEST_PATH=".wrangler/state/v3/d1/miniflare-D1DatabaseObject/d5cace998a99b013073f98823ec85d6a6601f80941c4f243f809eef878b809e8.sqlite"

・・・

# wrangler
.wrangler/

$ pnpm add -D node-gyp @types/better-sqlite3
$ pnpm add better-sqlite3

$ touch drizzle.d1.config.ts
$ mkdir -p src/infrastructure/database/drizzle/d1 && touch src/infrastructure/database/drizzle/d1/client.ts

import "dotenv/config";
import { defineConfig } from "drizzle-kit";

// 接続先DBパス
const dbPath =
  process.env.ENV === "testing"
    ? process.env.DB_D1_TEST_PATH
    : process.env.DB_D1_PATH;

// 接続先URL
const url = `${dbPath}`;

// drizzleのDB接続設定
export default defineConfig({
  dialect: "sqlite",
  schema: "./src/infrastructure/database/drizzle/d1/schema/*.ts",
  out: "./src/infrastructure/database/drizzle/d1/migrations",
  dbCredentials: {
    url: url,
  },
});

import type { DrizzleD1Database } from "drizzle-orm/d1";
import { drizzle } from "drizzle-orm/d1";

// DBインスタンスの型
export type DatabaseD1 = DrizzleD1Database;

// DBクライアントの型
export type DbClient = DatabaseD1;

// DBインスタンス生成用関数
export const createDbD1 = (db: D1Database): DatabaseD1 => {
  return drizzle(db);
};

{
  "compilerOptions": {

    ・・・

    "types": ["node", "@cloudflare/workers-types"],
  
    ・・・

  },
  "exclude": ["node_modules", "drizzle.pg.config.ts", "drizzle.d1.config.ts"]
}

$ mkdir -p src/infrastructure/database/drizzle/d1/schema && touch src/infrastructure/database/drizzle/d1/schema/users.ts

import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";

export const users = sqliteTable(
  "users",
  {
    id: integer("id").primaryKey({ autoIncrement: true }),
    uid: text("uid").notNull().unique(),
    lastName: text("last_name").notNull(),
    firstName: text("first_name").notNull(),
    totalPurchaseAmount: integer("total_purchase_amount").notNull().default(0),
    createdAt: integer("created_at", {
      mode: "timestamp",
    })
      .notNull()
      .$defaultFn(() => new Date()),
    updatedAt: integer("updated_at", {
      mode: "timestamp",
    })
      .notNull()
      .$defaultFn(() => new Date()),
  },
  (table) => [index("users_last_name_idx").on(table.lastName)],
);

$ pnpm drizzle-kit generate --config=drizzle.d1.config.ts

$ pnpm drizzle-kit migrate --config=drizzle.d1.config.ts

$ pnpm wrangler d1 execute local-db-d1 --local --command="SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;"

$ pnpm wrangler d1 execute local-db-d1 --local --command="PRAGMA table_info(users);"

$ pnpm wrangler types

{

・・・

  "files": {
    "ignoreUnknown": false,
    "includes": ["**", "!**/worker-configuration.d.ts"]
  },

・・・

}

$ mkdir -p src/runtime/cloudflare
$ touch src/runtime/cloudflare/config.ts src/runtime/cloudflare/app.ts src/runtime/cloudflare/worker.ts
$ touch src/di/cloudflareContainer.ts
$ touch src/presentation/http/routesCloudflare.ts

import type { AppConfig } from "../../app.js";

// Cloudflare環境用のコンフィグ定義
export type CloudflareConfig = AppConfig & {
  db: D1Database;
};

// Cloudflare環境用のコンフィグ設定関数
export const createConfig = (env: Env): CloudflareConfig => {
  return {
    env: env.ENV,
    corsOrigin: env.CORS_ORIGIN,
    db: env.ENV === "testing" ? env.TEST_DB : env.DB,
  };
};

import { createApp } from "../../app.js";
import { createCloudflareContainer } from "../../di/cloudflareContainer.js";
import { createRoutesCloudflare } from "../../presentation/http/routesCloudflare.js";
import type { CloudflareConfig } from "./config.js";

// Cloudflare環境用のapp作成関数
export const createCloudflareApp = (config: CloudflareConfig) => {
  const container = createCloudflareContainer(config);

  return createApp(config).route("/api", createRoutesCloudflare(container));
};

export type CloudflareApp = ReturnType<typeof createCloudflareApp>;

import { createCloudflareApp } from "./app.js";
import { createConfig } from "./config.js";

// サーバー起動処理
export default {
  fetch: (request: Request, env: Env, ctx: ExecutionContext) => {
    // コンフィグ作成
    const config = createConfig(env);

    // Cloudflare用のapp作成
    const app = createCloudflareApp(config);

    // 戻り値
    return app.fetch(request, env, ctx);
  },
};

import type { CloudflareConfig } from "../runtime/cloudflare/config.js";
import {
  SampleHelloUseCase,
  SampleTextUseCase,
} from "../supporting/sample/useCase.js";

export const createCloudflareContainer = (_config: CloudflareConfig) => {
  const sampleHelloUseCase = new SampleHelloUseCase();
  const sampleTextUseCase = new SampleTextUseCase();

  return {
    sampleHelloUseCase,
    sampleTextUseCase,
  };
};

export type CloudflareContainer = ReturnType<typeof createCloudflareContainer>;

import { Hono } from "hono";
import type { CloudflareContainer } from "../../di/cloudflareContainer.js";
import { createSampleRoutes } from "../http/supporting/sample/routes.js";

export const createRoutesCloudflare = (container: CloudflareContainer) => {
  /******************************
  * v1用のルーティング
  ******************************/
  // Honoでルーティングを作る際は、メソッドチェーン推薦
  const v1 = new Hono().route(
    "/sample",
    createSampleRoutes(
      container.sampleHelloUseCase,
      container.sampleTextUseCase,
    ),
  );
  /******************************
  * ルーティング設定
  ******************************/
  return new Hono().route("/v1", v1);
};

$ pnpm wrangler dev

$ mkdir -p src/shared/error && touch src/shared/error/appError.ts
$ mkdir -p src/presentation/http/error
$ touch src/presentation/http/error/errorHandler.ts src/presentation/http/error/errorStatusMap.ts
$ mkdir -p src/generic/user && touch src/generic/user/errors.ts

// ログレベル
export type LogLevel = "info" | "warn" | "error" | "debug";

// 共通エラークラス
export class AppError<TCode extends string = string> extends Error {
  constructor(
    message: string,
    public readonly code: TCode,
    public readonly logLevel: LogLevel = "info",
  ) {
    super(message);
    this.name = "AppError";
  }
}

import type { ErrorHandler } from "hono";
import { AppError } from "../../../shared/error/appError.js";
import { errorStatusMap } from "./errorStatusMap.js";

export const errorHandler: ErrorHandler = (err, c) => {
  const logger = c.get("logger");

  // カスタムエラー用のエラーハンドリング
  // 共通エラークラスを利用してカスタムエラークラスを作成し、
  // エラーコードとHTTPステータスコードのマッピングを行う
  if (err instanceof AppError) {
    const status = errorStatusMap[err.code];

    // エラーコードに対応するHTTPステータスコードが存在する場合は、エラーレスポンスを返す
    if (status) {
      // ログ出力
      logger[err.logLevel]("AppError occurred", {
        error: err,
        requestId: c.get("requestId"),
      });

      return c.json(
        {
          code: err.code,
          message: err.message,
        },
        status,
      );
    }
  }

  logger.error("Unexpected error", {
    error: err,
  });

  return c.json(
    {
      message: "Internal Server Error",
    },
    500,
  );
};

import type { ContentfulStatusCode } from "hono/utils/http-status";
import { userErrorStatusMap } from "../../../generic/user/errors.js";

// 共通エラーコードとHTTPステータスコードのマッピング
export const errorStatusMap: Record<string, ContentfulStatusCode> = {
  ...userErrorStatusMap,
};

import type { ContentfulStatusCode } from "hono/utils/http-status";
import { AppError } from "../../shared/error/appError.js";

// エラーコード（カスタムエラー用）
// 「|」で区切って追加可能
export type UserErrorCode = "USER_NOT_FOUND";

// エラーコードとHTTPステータスコードのマッピング
export const userErrorStatusMap: Record<UserErrorCode, ContentfulStatusCode> = {
  USER_NOT_FOUND: 404,
};

export class UserNotFoundError extends AppError<UserErrorCode> {
  constructor() {
    super("User not found", "USER_NOT_FOUND", "warn");
  }
}

import { Hono } from "hono";
import { cors } from "hono/cors";
import { requestId } from "hono/request-id";
import { errorHandler } from "./presentation/http/error/errorHandler.js";
import { requestLogger } from "./presentation/http/middleware/requestLogger.js";
import type { Logger } from "./shared/logger/logger.js";

// アプリのコンフィグ型
export type AppConfig = {
  env: string;
  corsOrigin: string;
};

// アプリの変数型
export type AppVariables = {
  Variables: {
    requestId: string;
    logger: Logger;
  };
};

export const createApp = (config: AppConfig) => {
  // Honoでルーティングを作る際は、メソッドチェーン推薦
  return (
    new Hono<AppVariables>()
      .get("/", (c) => {
        return c.text("Hello Hono!");
      })
      // エラーハンドラー設定
      .onError(errorHandler)
      // CORS設定
      .use(
        "*",
        cors({
          origin: config.corsOrigin,
          allowHeaders: ["Content-Type", "Authorization"],
          credentials: true,
        }),
      )
      // 共通ミドルウェア設定
      .use("*", requestId())
      .use("*", requestLogger)
  );
};

import type { AppConfig } from "../../app.js";
import type { PgConfig } from "../../infrastructure/database/drizzle/pg/client.js";

// Node環境用のコンフィグ型
export type NodeConfig = AppConfig & {
  port: number;
  db: PgConfig;
};

// Node環境用のコンフィグ設定
export const config: NodeConfig = {
  env: process.env.ENV ?? "local",
  corsOrigin: process.env.CORS_ORIGIN ?? "http://localhost:3000",
  port: Number(process.env.PORT ?? "3000"),
  db: {
    name: process.env.DB_PG_NAME ?? "local-db-pg",
    user: process.env.DB_PG_USER ?? "root",
    password: process.env.DB_PG_PASSWORD ?? "root-pass",
    host: process.env.DB_PG_HOST ?? "localhost",
    port: Number(process.env.DB_PG_PORT ?? "5432"),
    maxOpenConns: Number(process.env.DB_PG_MAX_OPEN_CONNS ?? "2"),
    connMaxLifetime: Number(process.env.DB_PG_CONN_MAX_LIFETIME ?? "300"),
  },
};

$ touch src/generic/user/useCase.ts src/generic/user/useCase.test.ts
$ mkdir -p src/presentation/http/generic/user
$ touch src/presentation/http/generic/user/handler.ts
$ touch src/presentation/http/generic/user/routes.ts src/presentation/http/generic/user/routes.test.ts
$ mkdir -p src/tests/integration/generic/user && touch src/tests/integration/generic/user/user.test.ts

import { eq } from "drizzle-orm";
import type { PgDatabase } from "../../infrastructure/database/drizzle/pg/client.js";
import { users } from "../../infrastructure/database/drizzle/pg/schema/users.js";
import type { Logger } from "../../shared/logger/logger.js";
import { UserNotFoundError } from "./errors.js";

export type CreateUserInput = {
  lastName: string;
  firstName: string;
  totalPurchaseAmount: number;
};

export type FindUserInput = {
  uid: string;
};

export type UpdateUserInput = {
  uid: string;
  lastName: string;
  firstName: string;
  totalPurchaseAmount: number;
};

export type DeleteUserInput = {
  uid: string;
};

// ユーザー作成
export class CreateUserUseCase {
  constructor(private readonly db: PgDatabase) {}

  async execute(logger: Logger, input: CreateUserInput) {
    logger.info("Create user", input);

    const [user] = await this.db
      .insert(users)
      .values({
        lastName: input.lastName,
        firstName: input.firstName,
        totalPurchaseAmount: input.totalPurchaseAmount,
      })
      .returning();

    return user;
  }
}

// 全てのユーザー取得
export class FindUsersUseCase {
  constructor(private readonly db: PgDatabase) {}

  async execute(logger: Logger) {
    logger.info("Find users");

    const result = await this.db.select().from(users);

    return result;
  }
}

// 対象のユーザー取得
export class FindUserUseCase {
  constructor(private readonly db: PgDatabase) {}

  async execute(logger: Logger, input: FindUserInput) {
    logger.info("Find user", input);

    const [user] = await this.db
      .select()
      .from(users)
      .where(eq(users.uid, input.uid))
      .limit(1);

      return user ?? {};
  }
}

// 対象のユーザー更新
export class UpdateUserUseCase {
  constructor(private readonly db: PgDatabase) {}

  async execute(logger: Logger, input: UpdateUserInput) {
    logger.info("Update user", input);

    const user = await this.db.transaction(async (tx) => {
      const [user] = await tx
        .update(users)
        .set({
          lastName: input.lastName,
          firstName: input.firstName,
          totalPurchaseAmount: input.totalPurchaseAmount,
          updatedAt: new Date(),
        })
        .where(eq(users.uid, input.uid))
        .returning();

      if (!user) {
        throw new UserNotFoundError();
      }

      return user;
    });

    return user;
  }
}

// 対象のユーザー削除
export class DeleteUserUseCase {
  constructor(private readonly db: PgDatabase) {}

  async execute(logger: Logger, input: DeleteUserInput) {
    logger.info("Delete user", input);

    const [user] = await this.db
      .delete(users)
      .where(eq(users.uid, input.uid))
      .returning();

    if (!user) {
      throw new UserNotFoundError();
    }

    return user;
  }
}

import { beforeEach, describe, expect, it, vi } from "vitest";
import type { PgDatabase } from "../../infrastructure/database/drizzle/pg/client.js";
import type { Logger } from "../../shared/logger/logger.js";
import { UserNotFoundError } from "./errors.js";
import {
  CreateUserUseCase,
  DeleteUserUseCase,
  FindUsersUseCase,
  FindUserUseCase,
  UpdateUserUseCase,
} from "./useCase.js";

// ロガーのモック化
const createMockLogger = (): Logger => ({
  info: vi.fn(),
  warn: vi.fn(),
  error: vi.fn(),
  debug: vi.fn(),
  withRequestId: vi.fn(),
});

// DBのモック化
const createMockDb = <T extends object>(mock: T): PgDatabase =>
  mock as unknown as PgDatabase;

let logger: Logger;

// テスト前の共通セットアップ
beforeEach(() => {
  logger = createMockLogger();
});

describe("CreateUserUseCase", () => {
  it("ユーザーを作成できること", async () => {
    // DBのモック化
    const user = {
      uid: "00000000-0000-0000-0000-000000000001",
      lastName: "山田",
      firstName: "太郎",
      totalPurchaseAmount: 1000,
    };
    const returning = vi.fn().mockResolvedValue([user]);
    const values = vi.fn().mockReturnValue({ returning });
    const insert = vi.fn().mockReturnValue({ values });
    const db = createMockDb({
      insert,
    });

    // ユースケース作成
    const useCase = new CreateUserUseCase(db);

    // ユースケース実行
    const result = await useCase.execute(logger, {
      lastName: "山田",
      firstName: "太郎",
      totalPurchaseAmount: 1000,
    });

    // 検証
    expect(result).toEqual(user);

    expect(logger.info).toHaveBeenCalledWith("Create user", {
      lastName: "山田",
      firstName: "太郎",
      totalPurchaseAmount: 1000,
    });

    expect(values).toHaveBeenCalledWith({
      lastName: "山田",
      firstName: "太郎",
      totalPurchaseAmount: 1000,
    });
  });
});

describe("FindUsersUseCase", () => {
  it("全てのユーザーを取得できること", async () => {
    // DBのモック化
    const users = [
      {
        uid: "00000000-0000-0000-0000-000000000001",
        lastName: "山田",
        firstName: "太郎",
        totalPurchaseAmount: 1000,
      },
      {
        uid: "00000000-0000-0000-0000-000000000002",
        lastName: "佐藤",
        firstName: "花子",
        totalPurchaseAmount: 2000,
      },
    ];
    const from = vi.fn().mockResolvedValue(users);
    const select = vi.fn().mockReturnValue({ from });
    const db = createMockDb({
      select,
    });

    // ユースケース作成
    const useCase = new FindUsersUseCase(db);

    // ユースケース実行
    const result = await useCase.execute(logger);

    // 検証
    expect(result).toEqual(users);

    expect(logger.info).toHaveBeenCalledWith("Find users");
  });
});

describe("FindUserUseCase", () => {
  it("指定したユーザーを取得できること", async () => {
    // DBのモック化
    const user = {
      uid: "00000000-0000-0000-0000-000000000001",
      lastName: "山田",
      firstName: "太郎",
      totalPurchaseAmount: 1000,
    };
    const limit = vi.fn().mockResolvedValue([user]);
    const where = vi.fn().mockReturnValue({ limit });
    const from = vi.fn().mockReturnValue({ where });
    const select = vi.fn().mockReturnValue({ from });
    const db = createMockDb({
      select,
    });

    // ユースケース作成
    const useCase = new FindUserUseCase(db);

    // ユースケース実行
    const result = await useCase.execute(logger, {
      uid: user.uid,
    });

    // 検証
    expect(result).toEqual(user);

    expect(logger.info).toHaveBeenCalledWith("Find user", {
      uid: user.uid,
    });

    expect(limit).toHaveBeenCalledWith(1);
  });

  it("ユーザーが存在しない場合は空オブジェクトを返すこと", async () => {
    // DBのモック化
    const limit = vi.fn().mockResolvedValue([]);
    const where = vi.fn().mockReturnValue({ limit });
    const from = vi.fn().mockReturnValue({ where });
    const select = vi.fn().mockReturnValue({ from });
    const db = createMockDb({
      select,
    });

    // ユースケース作成
    const useCase = new FindUserUseCase(db);

    // ユースケース実行
    const result = await useCase.execute(logger, {
      uid: "00000000-0000-0000-0000-000000000099",
    });

    // 検証
    expect(result).toEqual({});

    expect(logger.info).toHaveBeenCalledWith("Find user", {
      uid: "00000000-0000-0000-0000-000000000099",
    });
  });
});

describe("UpdateUserUseCase", () => {
  it("ユーザーを更新できること", async () => {
    // DBのモック化
    const user = {
      uid: "00000000-0000-0000-0000-000000000001",
      lastName: "山田",
      firstName: "次郎",
      totalPurchaseAmount: 3000,
    };
    const returning = vi.fn().mockResolvedValue([user]);
    const where = vi.fn().mockReturnValue({ returning });
    const set = vi.fn().mockReturnValue({ where });
    const update = vi.fn().mockReturnValue({ set });
    const transaction = vi.fn(async (callback) => {
      return callback({
        update,
      });
    });
    const db = createMockDb({
      transaction,
    });

    // ユースケース作成
    const useCase = new UpdateUserUseCase(db);

    // ユースケース実行
    const result = await useCase.execute(logger, {
      uid: user.uid,
      lastName: "山田",
      firstName: "次郎",
      totalPurchaseAmount: 3000,
    });

    // 検証
    expect(result).toEqual(user);

    expect(logger.info).toHaveBeenCalledWith("Update user", {
      uid: user.uid,
      lastName: "山田",
      firstName: "次郎",
      totalPurchaseAmount: 3000,
    });

    expect(set).toHaveBeenCalledWith({
      lastName: "山田",
      firstName: "次郎",
      totalPurchaseAmount: 3000,
      updatedAt: expect.any(Date),
    });
  });

  it("ユーザーが存在しない場合はUserNotFoundErrorを投げること", async () => {
    // DBのモック化
    const returning = vi.fn().mockResolvedValue([]);
    const where = vi.fn().mockReturnValue({ returning });
    const set = vi.fn().mockReturnValue({ where });
    const update = vi.fn().mockReturnValue({ set });
    const transaction = vi.fn(async (callback) => {
      return callback({
        update,
      });
    });
    const db = createMockDb({
      transaction,
    });

    // ユースケース作成
    const useCase = new UpdateUserUseCase(db);

    // ユースケース実行・検証
    await expect(
      useCase.execute(logger, {
        uid: "00000000-0000-0000-0000-000000000099",
        lastName: "山田",
        firstName: "次郎",
        totalPurchaseAmount: 3000,
      }),
    ).rejects.toBeInstanceOf(UserNotFoundError);

    expect(logger.info).toHaveBeenCalledWith("Update user", {
      uid: "00000000-0000-0000-0000-000000000099",
      lastName: "山田",
      firstName: "次郎",
      totalPurchaseAmount: 3000,
    });
  });
});

describe("DeleteUserUseCase", () => {
  it("ユーザーを削除できること", async () => {
    // DBのモック化
    const user = {
      uid: "00000000-0000-0000-0000-000000000001",
      lastName: "山田",
      firstName: "太郎",
      totalPurchaseAmount: 1000,
    };
    const returning = vi.fn().mockResolvedValue([user]);
    const where = vi.fn().mockReturnValue({ returning });
    const deleteUser = vi.fn().mockReturnValue({ where });
    const db = createMockDb({
      delete: deleteUser,
    });

    // ユースケース作成
    const useCase = new DeleteUserUseCase(db);

    // ユースケース実行
    const result = await useCase.execute(logger, {
      uid: user.uid,
    });

    // 検証
    expect(result).toEqual(user);

    expect(logger.info).toHaveBeenCalledWith("Delete user", {
      uid: user.uid,
    });
  });

  it("ユーザーが存在しない場合はUserNotFoundErrorを投げること", async () => {
    // DBのモック化
    const returning = vi.fn().mockResolvedValue([]);
    const where = vi.fn().mockReturnValue({ returning });
    const deleteUser = vi.fn().mockReturnValue({ where });
    const db = createMockDb({
      delete: deleteUser,
    });

    // ユースケース作成
    const useCase = new DeleteUserUseCase(db);

    // ユースケース実行・検証
    await expect(
      useCase.execute(logger, {
        uid: "00000000-0000-0000-0000-000000000099",
      }),
    ).rejects.toBeInstanceOf(UserNotFoundError);

    expect(logger.info).toHaveBeenCalledWith("Delete user", {
      uid: "00000000-0000-0000-0000-000000000099",
    });
  });
});

import type { Context } from "hono";
import type {
  CreateUserInput,
  CreateUserUseCase,
  DeleteUserInput,
  DeleteUserUseCase,
  FindUserInput,
  FindUsersUseCase,
  FindUserUseCase,
  UpdateUserInput,
  UpdateUserUseCase,
} from "../../../../generic/user/useCase.js";

export const createCreateUserHandler =
  (useCase: CreateUserUseCase) =>
  async (c: Context, input: CreateUserInput) => {
    // 共通ロガー取得
    const logger = c.get("logger");

    // ユースケース実行
    const result = await useCase.execute(logger, input);

    return c.json(result, 201);
  };

export const createFindUsersHandler =
  (useCase: FindUsersUseCase) => async (c: Context) => {
    // 共通ロガー取得
    const logger = c.get("logger");

    // ユースケース実行
    const result = await useCase.execute(logger);

    return c.json(result);
  };

export const createFindUserHandler =
  (useCase: FindUserUseCase) => async (c: Context, input: FindUserInput) => {
    // 共通ロガー取得
    const logger = c.get("logger");

    // ユースケース実行
    const result = await useCase.execute(logger, input);

    return c.json(result);
  };

export const createUpdateUserHandler =
  (useCase: UpdateUserUseCase) =>
  async (c: Context, input: UpdateUserInput) => {
    // 共通ロガー取得
    const logger = c.get("logger");

    // ユースケース実行
    const result = await useCase.execute(logger, input);

    return c.json(result);
  };

export const createDeleteUserHandler =
  (useCase: DeleteUserUseCase) =>
  async (c: Context, input: DeleteUserInput) => {
    // 共通ロガー取得
    const logger = c.get("logger");

    // ユースケース実行
    const _result = await useCase.execute(logger, input);

    return c.body(null, 204);
  };

import { zValidator } from "@hono/zod-validator";
import { Hono } from "hono";
import { z } from "zod";
import type {
  CreateUserInput,
  CreateUserUseCase,
  DeleteUserInput,
  DeleteUserUseCase,
  FindUserInput,
  FindUsersUseCase,
  FindUserUseCase,
  UpdateUserInput,
  UpdateUserUseCase,
} from "../../../../generic/user/useCase.js";
import {
  createCreateUserHandler,
  createDeleteUserHandler,
  createFindUserHandler,
  createFindUsersHandler,
  createUpdateUserHandler,
} from "./handler.js";

// ユーザー作成用のリクエストボディスキーマ定義
const createUserRequestBodySchema = z.object({
  lastName: z
    .string()
    .min(1, "lastNameは必須です")
    .max(10, "lastNameは10文字以内で入力してください"),
  firstName: z
    .string()
    .min(1, "firstNameは必須です")
    .max(10, "firstNameは10文字以内で入力してください"),
  totalPurchaseAmount: z
    .number()
    .min(0, "totalPurchaseAmountは0以上の数値で入力してください"),
});

// ユーザー取得用のリクエストパラメータのスキーマ定義
const findUserRequestParamSchema = z.object({
  uid: z.uuid().min(1, "uidは必須です"),
});

// ユーザー更新用のリクエストパラメータのスキーマ定義
const updateUserRequestParamSchema = z.object({
  uid: z.uuid().min(1, "uidは必須です"),
});

// ユーザー更新用のリクエストボディスキーマ定義
const updateUserRequestBodySchema = z.object({
  lastName: z
    .string()
    .min(1, "lastNameは必須です")
    .max(10, "lastNameは10文字以内で入力してください"),
  firstName: z
    .string()
    .min(1, "firstNameは必須です")
    .max(10, "firstNameは10文字以内で入力してください"),
  totalPurchaseAmount: z
    .number()
    .min(0, "totalPurchaseAmountは0以上の数値で入力してください"),
});

// ユーザー削除用のリクエストパラメータのスキーマ定義
const deleteUserRequestParamSchema = z.object({
  uid: z.uuid().min(1, "uidは必須です"),
});

export const createUserRoutes = (
  createUserUseCase: CreateUserUseCase,
  findUsersUseCase: FindUsersUseCase,
  findUserUseCase: FindUserUseCase,
  updateUserUseCase: UpdateUserUseCase,
  deleteUserUseCase: DeleteUserUseCase,
) => {
  // Honoでルーティングを作る際は、メソッドチェーン推薦
  const routes = new Hono()
    .post("/", zValidator("json", createUserRequestBodySchema), (c) => {
      // バリデーション済みのリクエストパラメータを取得
      const { lastName, firstName, totalPurchaseAmount } = c.req.valid("json");

      // インプットパラメータ作成
      const input: CreateUserInput = {
        lastName,
        firstName,
        totalPurchaseAmount,
      };

      return createCreateUserHandler(createUserUseCase)(c, input);
    })
    .get("/", createFindUsersHandler(findUsersUseCase))
    .get("/:uid", zValidator("param", findUserRequestParamSchema), (c) => {
      // バリデーション済みのリクエストパラメータを取得
      const { uid } = c.req.valid("param");

      // インプットパラメータ作成
      const input: FindUserInput = { uid };

      return createFindUserHandler(findUserUseCase)(c, input);
    })
    .put(
      "/:uid",
      zValidator("param", updateUserRequestParamSchema),
      zValidator("json", updateUserRequestBodySchema),
      (c) => {
        // バリデーション済みのリクエストパラメータを取得
        const { uid } = c.req.valid("param");
        const { lastName, firstName, totalPurchaseAmount } =
          c.req.valid("json");

        // インプットパラメータ作成
        const input: UpdateUserInput = {
          uid,
          lastName,
          firstName,
          totalPurchaseAmount,
        };

        return createUpdateUserHandler(updateUserUseCase)(c, input);
      },
    )
    .delete("/:uid", zValidator("param", deleteUserRequestParamSchema), (c) => {
      // バリデーション済みのリクエストパラメータを取得
      const { uid } = c.req.valid("param");

      // インプットパラメータ作成
      const input: DeleteUserInput = { uid };

      return createDeleteUserHandler(deleteUserUseCase)(c, input);
    });

  return routes;
};

import { Hono } from "hono";
import { testClient } from "hono/testing";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { createApp } from "../../../../app.js";
import type {
  CreateUserUseCase,
  DeleteUserUseCase,
  FindUsersUseCase,
  FindUserUseCase,
  UpdateUserUseCase,
} from "../../../../generic/user/useCase.js";
import type { NodeConfig } from "../../../../runtime/node/config.js";
import { config } from "../../../../runtime/node/config.js";
import { createUserRoutes } from "./routes.js";

// ログ出力の無効化
vi.spyOn(console, "log").mockImplementation(() => {});

// UseCaseのモック
type MockUseCase = {
  execute: ReturnType<typeof vi.fn>;
};
let createUserUseCase: MockUseCase;
let findUsersUseCase: MockUseCase;
let findUserUseCase: MockUseCase;
let updateUserUseCase: MockUseCase;
let deleteUserUseCase: MockUseCase;

// テスト用クライアント作成関数
const createTestClient = (config: NodeConfig) => {
  // ルーティング設定
  const v1 = new Hono().route(
    "/users",
    createUserRoutes(
      createUserUseCase as unknown as CreateUserUseCase,
      findUsersUseCase as unknown as FindUsersUseCase,
      findUserUseCase as unknown as FindUserUseCase,
      updateUserUseCase as unknown as UpdateUserUseCase,
      deleteUserUseCase as unknown as DeleteUserUseCase,
    ),
  );
  const routes = new Hono().route("/v1", v1);
  const app = createApp(config).route("/api", routes);

  return testClient(app);
};

// テスト用クライアント変数
let client: ReturnType<typeof createTestClient>;

// テスト用コンフィグ変数
let testConfig: NodeConfig;

// テストデータ用のUID
let uid: string;

// テスト前の共通セットアップ
beforeEach(() => {
  // モックの初期化
  createUserUseCase = {
    execute: vi.fn().mockResolvedValue({
      uid: "550e8400-e29b-41d4-a716-446655440000",
      lastName: "山田",
      firstName: "太郎",
      totalPurchaseAmount: 1000,
    }),
  };

  findUsersUseCase = {
    execute: vi.fn().mockResolvedValue([]),
  };

  findUserUseCase = {
    execute: vi.fn().mockResolvedValue({
      uid: "550e8400-e29b-41d4-a716-446655440000",
      lastName: "山田",
      firstName: "太郎",
      totalPurchaseAmount: 1000,
    }),
  };

  updateUserUseCase = {
    execute: vi.fn().mockResolvedValue({
      uid: "550e8400-e29b-41d4-a716-446655440000",
      lastName: "山田",
      firstName: "次郎",
      totalPurchaseAmount: 2000,
    }),
  };

  deleteUserUseCase = {
    execute: vi.fn().mockResolvedValue({
      uid: "550e8400-e29b-41d4-a716-446655440000",
    }),
  };

  testConfig = {
    ...config,
  };

  client = createTestClient(testConfig);

  uid = "550e8400-e29b-41d4-a716-446655440000";
});

describe("POST /api/v1/users", () => {
  it("正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.users.$post({
      json: {
        lastName: "山田",
        firstName: "太郎",
        totalPurchaseAmount: 1000,
      },
    });

    // 検証
    expect(response.status).toBe(201);
    expect(createUserUseCase.execute).toHaveBeenCalledTimes(1);
    expect(createUserUseCase.execute).toHaveBeenCalledWith(expect.anything(), {
      lastName: "山田",
      firstName: "太郎",
      totalPurchaseAmount: 1000,
    });
  });

  it("lastNameが未指定の場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users.$post({
      json: {
        firstName: "太郎",
        totalPurchaseAmount: 1000,
      } as never,
    });

    // 検証
    expect(response.status).toBe(400);
    expect(createUserUseCase.execute).not.toHaveBeenCalled();
  });

   it("firstNameが未指定の場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users.$post({
      json: {
        lastName: "山田",
        totalPurchaseAmount: 1000,
      } as never,
    });

    // 検証
    expect(response.status).toBe(400);
    expect(createUserUseCase.execute).not.toHaveBeenCalled();
  });

  it("totalPurchaseAmountが未指定の場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users.$post({
      json: {
        lastName: "山田",
        firstName: "太郎",
      } as never,
    });

    // 検証
    expect(response.status).toBe(400);
    expect(createUserUseCase.execute).not.toHaveBeenCalled();
  });

  it("lastNameが10文字以内の場合に正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.users.$post({
      json: {
        lastName: "あいうえおかきくけこ",
        firstName: "太郎",
        totalPurchaseAmount: 1000,
      },
    });

    // 検証
    expect(response.status).toBe(201);
    expect(createUserUseCase.execute).toHaveBeenCalledTimes(1);
  });

  it("lastNameが10文字を超えている場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users.$post({
      json: {
        lastName: "あいうえおかきくけこさ",
        firstName: "太郎",
        totalPurchaseAmount: 1000,
      },
    });

    // 検証
    expect(response.status).toBe(400);
    expect(createUserUseCase.execute).not.toHaveBeenCalled();
  });

  it("firstNameが10文字以内の場合に正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.users.$post({
      json: {
        lastName: "山田",
        firstName: "あいうえおかきくけこ",
        totalPurchaseAmount: 1000,
      },
    });

    // 検証
    expect(response.status).toBe(201);
    expect(createUserUseCase.execute).toHaveBeenCalledTimes(1);
  });

  it("firstNameが10文字を超えている場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users.$post({
      json: {
        lastName: "山田",
        firstName: "あいうえおかきくけこさ",
        totalPurchaseAmount: 1000,
      },
    });

    // 検証
    expect(response.status).toBe(400);
    expect(createUserUseCase.execute).not.toHaveBeenCalled();
  });

  it("totalPurchaseAmountが0の場合に正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.users.$post({
      json: {
        lastName: "山田",
        firstName: "太郎",
        totalPurchaseAmount: 0,
      },
    });

    // 検証
    expect(response.status).toBe(201);
    expect(createUserUseCase.execute).toHaveBeenCalledTimes(1);
  });

  it("totalPurchaseAmountがマイナスの場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users.$post({
      json: {
        lastName: "山田",
        firstName: "太郎",
        totalPurchaseAmount: -1,
      },
    });

    // 検証
    expect(response.status).toBe(400);
    expect(createUserUseCase.execute).not.toHaveBeenCalled();
  });

  it("totalPurchaseAmountが文字列の場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users.$post({
      json: {
        lastName: "山田",
        firstName: "太郎",
        totalPurchaseAmount: "1000",
      } as never,
    });

    // 検証
    expect(response.status).toBe(400);
    expect(createUserUseCase.execute).not.toHaveBeenCalled();
  });
});

describe("GET /api/v1/users", () => {
  it("正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.users.$get();

    // 検証
    expect(response.status).toBe(200);
    expect(findUsersUseCase.execute).toHaveBeenCalledTimes(1);
  });
});

describe("GET /api/v1/users/:uid", () => {
  it("正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.users[":uid"].$get({
      param: {
        uid: uid,
      },
    });

    // 検証
    expect(response.status).toBe(200);
    expect(findUserUseCase.execute).toHaveBeenCalledTimes(1);
    expect(findUserUseCase.execute).toHaveBeenCalledWith(expect.anything(), {
      uid,
    });
  });

  it("uidがUUID形式ではない場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users[":uid"].$get({
      param: {
        uid: "invalid-uid",
      },
    });

    // 検証
    expect(response.status).toBe(400);
    expect(findUserUseCase.execute).not.toHaveBeenCalled();
  });
});

describe("PUT /api/v1/users/:uid", () => {
  it("正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.users[":uid"].$put({
      param: {
        uid: uid,
      },
      json: {
        lastName: "山田",
        firstName: "次郎",
        totalPurchaseAmount: 2000,
      },
    });

    // 検証
    expect(response.status).toBe(200);
    expect(updateUserUseCase.execute).toHaveBeenCalledTimes(1);
    expect(updateUserUseCase.execute).toHaveBeenCalledWith(expect.anything(), {
      uid,
      lastName: "山田",
      firstName: "次郎",
      totalPurchaseAmount: 2000,
    });
  });

  it("uidがUUID形式ではない場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users[":uid"].$put({
      param: {
        uid: "invalid-uid",
      },
      json: {
        lastName: "山田",
        firstName: "次郎",
        totalPurchaseAmount: 2000,
      },
    });

    // 検証
    expect(response.status).toBe(400);
    expect(updateUserUseCase.execute).not.toHaveBeenCalled();
  });

  it("lastNameが未指定の場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users[":uid"].$put({
      param: {
        uid: uid,
      },
      json: {
        firstName: "次郎",
        totalPurchaseAmount: 2000,
      } as never,
    });

    // 検証
    expect(response.status).toBe(400);
    expect(updateUserUseCase.execute).not.toHaveBeenCalled();
  });

  it("firstNameが未指定の場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users[":uid"].$put({
      param: {
        uid: uid,
      },
      json: {
        lastName: "山田",
        totalPurchaseAmount: 2000,
      } as never,
    });

    // 検証
    expect(response.status).toBe(400);
    expect(updateUserUseCase.execute).not.toHaveBeenCalled();
  });

  it("totalPurchaseAmountが未指定の場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users[":uid"].$put({
      param: {
        uid: uid,
      },
      json: {
        lastName: "山田",
        firstName: "次郎",
      } as never,
    });

    // 検証
    expect(response.status).toBe(400);
    expect(updateUserUseCase.execute).not.toHaveBeenCalled();
  });

  it("lastNameが10文字以内の場合に正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.users[":uid"].$put({
      param: {
        uid: uid,
      },
      json: {
        lastName: "あいうえおかきくけこ",
        firstName: "次郎",
        totalPurchaseAmount: 1000,
      },
    });

    // 検証
    expect(response.status).toBe(200);
    expect(updateUserUseCase.execute).toHaveBeenCalledTimes(1);
  });

  it("lastNameが10文字を超えている場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users[":uid"].$put({
      param: {
        uid: uid,
      },
      json: {
        lastName: "あいうえおかきくけこさ",
        firstName: "次郎",
        totalPurchaseAmount: 1000,
      },
    });

    // 検証
    expect(response.status).toBe(400);
    expect(updateUserUseCase.execute).not.toHaveBeenCalled();
  });

  it("firstNameが10文字以内の場合に正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.users[":uid"].$put({
      param: {
        uid: uid,
      },
      json: {
        lastName: "山田",
        firstName: "あいうえおかきくけこ",
        totalPurchaseAmount: 1000,
      },
    });

    // 検証
    expect(response.status).toBe(200);
    expect(updateUserUseCase.execute).toHaveBeenCalledTimes(1);
  });

  it("firstNameが10文字を超えている場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users[":uid"].$put({
      param: {
        uid: uid,
      },
      json: {
        lastName: "山田",
        firstName: "あいうえおかきくけこさ",
        totalPurchaseAmount: 1000,
      },
    });

    // 検証
    expect(response.status).toBe(400);
    expect(updateUserUseCase.execute).not.toHaveBeenCalled();
  });

  it("totalPurchaseAmountが0の場合に正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.users[":uid"].$put({
      param: {
        uid: uid,
      },
      json: {
        lastName: "山田",
        firstName: "太郎",
        totalPurchaseAmount: 0,
      },
    });

    // 検証
    expect(response.status).toBe(200);
    expect(updateUserUseCase.execute).toHaveBeenCalledTimes(1);
  });

  it("totalPurchaseAmountがマイナスの場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users[":uid"].$put({
      param: {
        uid: uid,
      },
      json: {
        lastName: "山田",
        firstName: "太郎",
        totalPurchaseAmount: -1,
      },
    });

    // 検証
    expect(response.status).toBe(400);
    expect(updateUserUseCase.execute).not.toHaveBeenCalled();
  });
});

describe("DELETE /api/v1/users/:uid", () => {
  it("正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.users[":uid"].$delete({
      param: {
        uid: uid,
      },
    });

    // 検証
    expect(response.status).toBe(204);
    expect(deleteUserUseCase.execute).toHaveBeenCalledTimes(1);
    expect(deleteUserUseCase.execute).toHaveBeenCalledWith(expect.anything(), {
      uid,
    });
  });

  it("uidがUUID形式ではない場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.users[":uid"].$delete({
      param: {
        uid: "invalid-uid",
      },
    });

    // 検証
    expect(response.status).toBe(400);
    expect(deleteUserUseCase.execute).not.toHaveBeenCalled();
  });
});

import { eq } from "drizzle-orm";
import { testClient } from "hono/testing";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import type { DbPg } from "../../../../infrastructure/database/drizzle/pg/client.js";
import { createDbPg } from "../../../../infrastructure/database/drizzle/pg/client.js";
import { users } from "../../../../infrastructure/database/drizzle/pg/schema/users.js";
import { createNodeApp } from "../../../../runtime/node/app.js";
import type { NodeConfig } from "../../../../runtime/node/config.js";
import { config } from "../../../../runtime/node/config.js";

// ログ出力の無効化
vi.spyOn(console, "log").mockImplementation(() => {});

// テスト用クライアント作成関数
const createTestClient = (config: NodeConfig) => {
  return testClient(createNodeApp(config));
};

// テスト用クライアント変数
let client: ReturnType<typeof createTestClient>;

let testDbPg: DbPg;

// テスト用コンフィグ変数
let testConfig: NodeConfig;

// テスト前の共通セットアップ
beforeEach(() => {
  testConfig = {
    ...config,
    db: {
      ...config.db,
      name: "testing-db-pg",
    },
  };

  client = createTestClient(testConfig);
  testDbPg = createDbPg(testConfig.db);
});

// テスト後の共通クリーンアップ
afterEach(async () => {
  await testDbPg.db.delete(users);
  await testDbPg.pool.end();
});

describe("POST /api/v1/users", () => {
  it("ユーザーが新規作成され、正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.users.$post({
      json: {
        lastName: "山田",
        firstName: "太郎",
        totalPurchaseAmount: 1000,
      },
    });

    // 検証
    expect(response.status).toBe(201);

    // レスポンス結果の検証
    type CreateUserResponse = {
      id: number;
      uid: string;
      lastName: string;
      firstName: string;
      totalPurchaseAmount: number;
      createdAt: string;
      updatedAt: string;
    };
    const body = (await response.json()) as CreateUserResponse;
    expect(body).toEqual({
      id: expect.any(Number),
      uid: expect.any(String),
      lastName: "山田",
      firstName: "太郎",
      totalPurchaseAmount: 1000,
      createdAt: expect.any(String),
      updatedAt: expect.any(String),
    });

    // DBに保存されていることを検証
    const [user] = await testDbPg.db
      .select()
      .from(users)
      .where(eq(users.uid, body.uid))
      .limit(1);

    expect(user).toEqual({
      id: body.id,
      uid: body.uid,
      lastName: body.lastName,
      firstName: body.firstName,
      totalPurchaseAmount: body.totalPurchaseAmount,
      createdAt: new Date(body.createdAt),
      updatedAt: new Date(body.updatedAt),
    });
  });
});

describe("GET /api/v1/users", () => {
  it("全てのユーザーを取得し、正常終了すること", async () => {
    // テストデータ登録
    const resultUsers = await testDbPg.db
      .insert(users)
      .values([
        {
          lastName: "山田",
          firstName: "太郎",
          totalPurchaseAmount: 1000,
        },
        {
          lastName: "佐藤",
          firstName: "花子",
          totalPurchaseAmount: 2000,
        },
      ])
      .returning();
    const expectedUsers = resultUsers.map((user) => ({
      ...user,
      createdAt: user.createdAt.toISOString(),
      updatedAt: user.updatedAt.toISOString(),
    }));

    // テスト実行
    const response = await client.api.v1.users.$get();

    // 検証
    expect(response.status).toBe(200);

    // レスポンス結果の検証
    const body = await response.json();
    expect(body).toHaveLength(2);
    expect(body).toEqual(expectedUsers);
  });
});

describe("GET /api/v1/users/:uid", () => {
  it("対象ユーザーを取得し、正常終了すること", async () => {
    // テストデータ登録
    const [resultUser] = await testDbPg.db
      .insert(users)
      .values({
        lastName: "山田",
        firstName: "太郎",
        totalPurchaseAmount: 1000,
    })
    .returning();
    const expectedUser = {
      ...resultUser,
      createdAt: resultUser.createdAt.toISOString(),
      updatedAt: resultUser.updatedAt.toISOString(),
    };

    // テスト実行
    const response = await client.api.v1.users.$get();

    // 検証
    expect(response.status).toBe(200);

    // レスポンス結果の検証
    const [body] = await response.json();
    expect(body).toEqual(expectedUser);
  });
});

describe("PUT /api/v1/users/:uid", () => {
  it("対象ユーザーを更新し、正常終了すること", async () => {
    // テストデータ登録
    const [resultUser] = await testDbPg.db
      .insert(users)
      .values({
        lastName: "山田",
        firstName: "太郎",
        totalPurchaseAmount: 1000,
      })
      .returning();
    const expectedUser = {
      ...resultUser,
      lastName: "佐藤",
      firstName: "二郎",
      totalPurchaseAmount: 2000,
      createdAt: resultUser.createdAt.toISOString(),
      updatedAt: expect.any(String),
    };

    // テスト実行
    const response = await client.api.v1.users[":uid"].$put({
      param: {
        uid: expectedUser.uid,
      },
      json: {
        lastName: expectedUser.lastName,
        firstName: expectedUser.firstName,
        totalPurchaseAmount: expectedUser.totalPurchaseAmount,
      },
    });

    // 検証
    expect(response.status).toBe(200);

    // レスポンス結果の検証
    const body = await response.json();
    expect(body).toEqual(expectedUser);
    if ("createdAt" in body) {
      expect(body.createdAt).toBe(expectedUser.createdAt);
    }
    if ("updatedAt" in body) {
      expect(body.updatedAt).not.toBe(expectedUser.createdAt);
    }
  });
});

describe("DELETE /api/v1/users/:uid", () => {
  it("対象ユーザーを削除し、正常終了すること", async () => {
    // テストデータ登録
    const [resultUser] = await testDbPg.db
      .insert(users)
      .values({
        lastName: "山田",
        firstName: "太郎",
        totalPurchaseAmount: 1000,
      })
      .returning();

    // テスト実行
    const response = await client.api.v1.users[":uid"].$delete({
      param: {
        uid: resultUser.uid,
      },
    });

    // 検証
    expect(response.status).toBe(204);

    // DBから削除されていることを確認
    const deletedUsers = await testDbPg.db
      .select()
      .from(users)
      .where(eq(users.uid, resultUser.uid));

    expect(deletedUsers).toHaveLength(0);
  });
});

import {
  CreateUserUseCase,
  DeleteUserUseCase,
  FindUsersUseCase,
  FindUserUseCase,
  UpdateUserUseCase,
} from "../generic/user/useCase.js";
import { createDbPg } from "../infrastructure/database/drizzle/pg/client.js";
import type { NodeConfig } from "../runtime/node/config.js";
import {
  SampleHelloUseCase,
  SampleTextUseCase,
} from "../supporting/sample/useCase.js";

export const createNodeContainer = (config: NodeConfig) => {
  // DBインスタンスの初期化
  const dbPg = createDbPg(config.db);

  // サンプル関連のユースケースを初期化
  const sampleHelloUseCase = new SampleHelloUseCase();
  const sampleTextUseCase = new SampleTextUseCase();

  // ユーザー関連のユースケースを初期化
  const createUserUseCase = new CreateUserUseCase(dbPg.db);
  const findUsersUseCase = new FindUsersUseCase(dbPg.db);
  const findUserUseCase = new FindUserUseCase(dbPg.db);
  const updateUserUseCase = new UpdateUserUseCase(dbPg.db);
  const deleteUserUseCase = new DeleteUserUseCase(dbPg.db);

  return {
    sampleHelloUseCase,
    sampleTextUseCase,
    createUserUseCase,
    findUsersUseCase,
    findUserUseCase,
    updateUserUseCase,
    deleteUserUseCase,
  };
};

export type NodeContainer = ReturnType<typeof createNodeContainer>;

import { Hono } from "hono";
import type { NodeContainer } from "../../di/nodeContainer.js";
import { createUserRoutes } from "../http/generic/user/routes.js";
import { createSampleRoutes } from "../http/supporting/sample/routes.js";

export const createRoutesNode = (container: NodeContainer) => {
  /******************************
  * v1用のルーティング
  ******************************/
  // Honoでルーティングを作る際は、メソッドチェーン推薦
  const v1 = new Hono()
    .route(
      "/sample",
      createSampleRoutes(
        container.sampleHelloUseCase,
        container.sampleTextUseCase,
      ),
    )
    .route(
      "/users",
      createUserRoutes(
        container.createUserUseCase,
        container.findUsersUseCase,
        container.findUserUseCase,
        container.updateUserUseCase,
        container.deleteUserUseCase,
      ),
    );
  /******************************
  * ルーティング設定
  ******************************/
  return new Hono().route("/v1", v1);
};

$ pnpm run format
$ pnpm run lint
$ pnpm run test

$ mkdir -p src/core/member/domain
$ touch src/core/member/domain/memberUid.ts src/core/member/domain/memberUid.test.ts
$ touch src/core/member/domain/member.ts src/core/member/domain/member.test.ts
$ touch src/core/member/domain/memberRankService.ts src/core/member/domain/memberRankService.test.ts
$ touch src/core/member/domain/memberRepository.ts
$ mkdir -p src/core/member/infrastructure/persistence/pg/query
$ touch src/core/member/infrastructure/persistence/pg/query/drizzleMemberRepository.ts

export class MemberUid {
  constructor(readonly value: string) {
    if (!MemberUid.isValid(value)) {
      throw new Error(`Invalid MemberUid: ${value}`);
    }
  }

  // uuid形式チェック
  private static isValid(value: string): boolean {
    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
      value,
    );
  }
}

import { describe, expect, it } from "vitest";
import { MemberUid } from "./memberUid.js";

describe("MemberUid", () => {
  it("有効なUUIDをMemberUidとして生成できる", () => {
    const value = "550e8400-e29b-41d4-a716-446655440000";

    const memberUid = new MemberUid(value);

    expect(memberUid.value).toBe(value);
  });

  it("不正なUUIDの場合はエラーになる", () => {
    expect(() => {
      new MemberUid("invalid-uuid");
    }).toThrow("Invalid MemberUid: invalid-uuid");
  });

  it("空文字の場合はエラーになる", () => {
    expect(() => {
      new MemberUid("");
    }).toThrow("Invalid MemberUid: ");
  });
});

import type { MemberUid } from "./memberUid.js";

export class Member {
  constructor(
    readonly uid: MemberUid,
    readonly lastName: string,
    readonly firstName: string,
    readonly totalPurchaseAmount: number,
  ) {}

  // フルネームを出力するメソッド
  get fullName(): string {
    return `${this.lastName} ${this.firstName}`;
  }
}

import { describe, expect, it } from "vitest";
import { Member } from "./member.js";
import { MemberUid } from "./memberUid.js";

describe("Member", () => {
  it("メンバー情報を保持する", () => {
    const uid = new MemberUid("550e8400-e29b-41d4-a716-446655440000");

    const member = new Member(uid, "山田", "太郎", 10000);

    expect(member.uid).toBe(uid);
    expect(member.lastName).toBe("山田");
    expect(member.firstName).toBe("太郎");
    expect(member.totalPurchaseAmount).toBe(10000);
  });

  it("fullNameに姓と名を結合した名前を返す", () => {
    const member = new Member(
      new MemberUid("550e8400-e29b-41d4-a716-446655440000"),
      "山田",
      "太郎",
      10000,
    );

    expect(member.fullName).toBe("山田 太郎");
  });
});

import type { Member } from "./member.js";

export type MemberRank = "bronze" | "silver" | "gold" | "platinum";

export class MemberRankService {
  calculate(member: Member): MemberRank {
    // 100万円以上でプラチナ
    if (member.totalPurchaseAmount >= 1_000_000) {
      return "platinum";
    }

    // 10万円以上でゴールド
    if (member.totalPurchaseAmount >= 100_000) {
      return "gold";
    }

    // 1万円以上でシルバー
    if (member.totalPurchaseAmount >= 10_000) {
      return "silver";
    }

    return "bronze";
  }
}

import { describe, expect, it } from "vitest";
import { Member } from "./member.js";
import { MemberRankService } from "./memberRankService.js";
import { MemberUid } from "./memberUid.js";

describe("MemberRankService", () => {
  const service = new MemberRankService();

  const createMember = (totalPurchaseAmount: number) => {
    return new Member(
      new MemberUid("550e8400-e29b-41d4-a716-446655440000"),
      "山田",
      "太郎",
      totalPurchaseAmount,
    );
  };

  it("合計購入金額が10,000円未満ならbronze", () => {
    const member = createMember(9_999);

    expect(service.calculate(member)).toBe("bronze");
  });

  it("合計購入金額が10,000円以上ならsilver", () => {
    const member = createMember(10_000);

    expect(service.calculate(member)).toBe("silver");
  });

  it("合計購入金額が100,000円以上ならgold", () => {
    const member = createMember(100_000);

    expect(service.calculate(member)).toBe("gold");
  });

  it("合計購入金額が1,000,000円以上ならplatinum", () => {
    const member = createMember(1_000_000);

    expect(service.calculate(member)).toBe("platinum");
  });
});

import type { Member } from "./member.js";
import type { MemberUid } from "./memberUid.js";

export interface MemberRepository {
  findByUid(uid: MemberUid): Promise<Member | null>;
}

import { eq } from "drizzle-orm";
import type { PgDbClient } from "../../../../../../infrastructure/database/drizzle/pg/client.js";
import { users } from "../../../../../../infrastructure/database/drizzle/pg/schema/users.js";
import { Member } from "../../../../domain/member.js";
import type { MemberRepository } from "../../../../domain/memberRepository.js";
import { MemberUid } from "../../../../domain/memberUid.js";

export class DrizzleMemberRepository implements MemberRepository {
  constructor(private readonly db: PgDbClient) {}

  async findByUid(uid: MemberUid): Promise<Member | null> {
    // 対象ユーザー取得
    const [user] = await this.db
      .select()
      .from(users)
      .where(eq(users.uid, uid.value))
      .limit(1);

    // ユーザー取得チェック
    if (!user) {
      return null;
    }

    return new Member(
      new MemberUid(user.uid),
      user.lastName,
      user.firstName,
      user.totalPurchaseAmount,
    );
  }
}

$ touch src/infrastructure/database/database.ts
$ mkdir -p src/infrastructure/repository
$ touch src/infrastructure/repository/drizzleRepositoryFactory.ts

import type { PgDbClient } from "./drizzle/pg/client.js";

export class Database {
  constructor(private readonly db: PgDbClient) {}

  getClient(): PgDbClient {
    return this.db;
  }
}

import { DrizzleMemberRepository } from "../../core/member/infrastructure/persistence/pg/query/drizzleMemberRepository.js";
import type { PgDbClient } from "../database/drizzle/pg/client.js";

export class DrizzleRepositoryFactory {
  create(db: PgDbClient) {
    return {
      member: new DrizzleMemberRepository(db),
    };
  }
}

$ mkdir -p src/core/member/usecase
$ touch src/core/member/usecase/calculateMemberRank.ts src/core/member/usecase/calculateMemberRank.test.ts
$ touch src/core/member/usecase/errors.ts

import type { Database } from "../../../infrastructure/database/database.js";
import type { DrizzleRepositoryFactory } from "../../../infrastructure/repository/drizzleRepositoryFactory.js";
import type { Logger } from "../../../shared/logger/logger.js";
import { MemberRankService } from "../domain/memberRankService.js";
import { MemberUid } from "../domain/memberUid.js";
import { MemberNotFoundError } from "./errors.js";

export type CalculateMemberRankUseCaseInput = {
  uid: string;
};

export class CalculateMemberRankUseCase {
  constructor(
    private readonly db: Database,
    private readonly repositoryFactory: DrizzleRepositoryFactory,
  ) {}

  async execute(_logger: Logger, input: CalculateMemberRankUseCaseInput) {
    // リポジトリのインスタンス化
    const repo = this.repositoryFactory.create(this.db.getClient());

    // uidからメンバーを取得
    const member = await repo.member.findByUid(new MemberUid(input.uid));

    // 必須チェック
    if (!member) {
      throw new MemberNotFoundError();
    }

    // メンバーのランク取得
    const rank = new MemberRankService().calculate(member);

    return {
      rank,
    };
  }
}

import { beforeEach, describe, expect, it, vi } from "vitest";
import type { Database } from "../../../infrastructure/database/database.js";
import type { PgDbClient } from "../../../infrastructure/database/drizzle/pg/client.js";
import type { DrizzleRepositoryFactory } from "../../../infrastructure/repository/drizzleRepositoryFactory.js";
import type { Logger } from "../../../shared/logger/logger.js";
import { Member } from "../domain/member.js";
import { MemberUid } from "../domain/memberUid.js";
import { CalculateMemberRankUseCase } from "./calculateMemberRank.js";
import { MemberNotFoundError } from "./errors.js";

// ロガーのモック化
const createMockLogger = (): Logger => ({
  info: vi.fn(),
  warn: vi.fn(),
  error: vi.fn(),
  debug: vi.fn(),
  withRequestId: vi.fn(),
});

// DBのモック化
const createMockDb = <T extends object>(mock: T): PgDbClient =>
  mock as unknown as PgDbClient;

  let logger: Logger;

  beforeEach(() => {
    logger = createMockLogger();
  });

  describe("CalculateMemberRankUseCase", () => {
    it("メンバーのランクを取得できること", async () => {
      // メンバーのモック
      const uid = "550e8400-e29b-41d4-a716-446655440000";

      const member = new Member(new MemberUid(uid), "山田", "太郎", 100_000);

      // Repositoryのモック化
      const findByUid = vi.fn().mockResolvedValue(member);

      const repository = {
        member: {
          findByUid,
        },
      };

      // DBのモック化
      const dbClient = createMockDb({});

      const getClient = vi.fn().mockReturnValue(dbClient);

      const db = {
        getClient,
      } as unknown as Database;

      // RepositoryFactoryのモック化
      const create = vi.fn().mockReturnValue(repository);

      const repositoryFactory = {
        create,
      } as unknown as DrizzleRepositoryFactory;

      // ユースケース作成
      const useCase = new CalculateMemberRankUseCase(db, repositoryFactory);

      // ユースケース実行
      const result = await useCase.execute(logger, {
        uid,
      });

      // 検証
      expect(result).toEqual({
        rank: "gold",
      });
      expect(findByUid).toHaveBeenCalledOnce();
  });

  it("メンバーが存在しない場合はエラーになること", async () => {
    // Repositoryのモック化
    const findByUid = vi.fn().mockResolvedValue(null);

    const repository = {
      member: {
        findByUid,
      },
    };

    // DBのモック化
    const dbClient = createMockDb({});

    const getClient = vi.fn().mockReturnValue(dbClient);

    const db = {
      getClient,
    } as unknown as Database;

    // RepositoryFactoryのモック化
    const create = vi.fn().mockReturnValue(repository);

    const repositoryFactory = {
      create,
    } as unknown as DrizzleRepositoryFactory;

    // ユースケース作成
    const useCase = new CalculateMemberRankUseCase(db, repositoryFactory);

    // ユースケース実行・検証
    await expect(
      useCase.execute(logger, {
        uid: "550e8400-e29b-41d4-a716-446655440000",
      }),
    ).rejects.toBeInstanceOf(MemberNotFoundError);
  });
});

import type { ContentfulStatusCode } from "hono/utils/http-status";
import { AppError } from "../../../shared/error/appError.js";

// エラーコード（カスタムエラー用）
// 「|」で区切って追加可能
export type MemberErrorCode = "MEMBER_NOT_FOUND";

// エラーコードとHTTPステータスコードのマッピング
export const memberErrorStatusMap: Record<
  MemberErrorCode,
  ContentfulStatusCode
> = {
  MEMBER_NOT_FOUND: 404,
};

export class MemberNotFoundError extends AppError<MemberErrorCode> {
  constructor() {
    super("Member not found", "MEMBER_NOT_FOUND", "warn");
  }
}

import { CalculateMemberRankUseCase } from "../core/member/usecase/calculateMemberRank.js";
import {
  CreateUserUseCase,
  DeleteUserUseCase,
  FindUsersUseCase,
  FindUserUseCase,
  UpdateUserUseCase,
} from "../generic/user/useCase.js";
import { Database } from "../infrastructure/database/database.js";
import { createDbPg } from "../infrastructure/database/drizzle/pg/client.js";
import { DrizzleRepositoryFactory } from "../infrastructure/repository/drizzleRepositoryFactory.js";
import type { NodeConfig } from "../runtime/node/config.js";
import {
  SampleHelloUseCase,
  SampleTextUseCase,
} from "../supporting/sample/useCase.js";

export const createNodeContainer = (config: NodeConfig) => {
  // DBインスタンスの初期化
  const dbPg = createDbPg(config.db);

  // サンプル関連のユースケースを初期化
  const sampleHelloUseCase = new SampleHelloUseCase();
  const sampleTextUseCase = new SampleTextUseCase();

  // ユーザー関連のユースケースを初期化
  const createUserUseCase = new CreateUserUseCase(dbPg.db);
  const findUsersUseCase = new FindUsersUseCase(dbPg.db);
  const findUserUseCase = new FindUserUseCase(dbPg.db);
  const updateUserUseCase = new UpdateUserUseCase(dbPg.db);
  const deleteUserUseCase = new DeleteUserUseCase(dbPg.db);

  // メンバードメイン関連のユースケースを初期化
  const database = new Database(dbPg.db);
  const drizzleRepositoryFactory = new DrizzleRepositoryFactory();
  const calculateMemberRankUseCase = new CalculateMemberRankUseCase(
    database,
    drizzleRepositoryFactory,
  );

  return {
    sampleHelloUseCase,
    sampleTextUseCase,
    createUserUseCase,
    findUsersUseCase,
    findUserUseCase,
    updateUserUseCase,
    deleteUserUseCase,
    calculateMemberRankUseCase,
  };
};

export type NodeContainer = ReturnType<typeof createNodeContainer>;

$ mkdir -p src/presentation/http/core/member
$ touch src/presentation/http/core/member/handler.ts
$ touch src/presentation/http/core/member/routes.ts src/presentation/http/core/member/routes.test.ts

import type { Context } from "hono";
import type {
  CalculateMemberRankUseCase,
  CalculateMemberRankUseCaseInput,
} from "../../../../core/member/usecase/calculateMemberRank.js";

export const createCalculateMemberRankHandler =
  (useCase: CalculateMemberRankUseCase) =>
  async (c: Context, input: CalculateMemberRankUseCaseInput) => {
    // 共通ロガー取得
    const logger = c.get("logger");

    // ユースケース実行
    const result = await useCase.execute(logger, input);

    return c.json(result);
  };

import { zValidator } from "@hono/zod-validator";
import { Hono } from "hono";
import { z } from "zod";
import type {
  CalculateMemberRankUseCase,
  CalculateMemberRankUseCaseInput,
} from "../../../../core/member/usecase/calculateMemberRank.js";
import { createCalculateMemberRankHandler } from "./handler.js";

// リクエストパラメータのスキーマ定義
const calculateMemberRankRequestParamSchema = z.object({
  uid: z.uuid().min(1, "uidは必須です"),
});

export const createMemberRoutes = (
  calculateMemberRankUseCase: CalculateMemberRankUseCase,
) => {
  const routes = new Hono().get(
    "/:uid/rank",
    zValidator("param", calculateMemberRankRequestParamSchema),
    (c) => {
      // バリデーション済みのリクエストパラメータを取得
      const { uid } = c.req.valid("param");

      // インプットパラメータ作成
      const input: CalculateMemberRankUseCaseInput = { uid };

      return createCalculateMemberRankHandler(calculateMemberRankUseCase)(
        c,
        input,
      );
    },
  );

  return routes;
};

import { Hono } from "hono";
import { testClient } from "hono/testing";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { createApp } from "../../../../app.js";
import type { CalculateMemberRankUseCase } from "../../../../core/member/usecase/calculateMemberRank.js";
import type { NodeConfig } from "../../../../runtime/node/config.js";
import { config } from "../../../../runtime/node/config.js";
import { createMemberRoutes } from "./routes.js";

// ログ出力の無効化
vi.spyOn(console, "log").mockImplementation(() => {});

// UseCaseのモック
type MockUseCase = {
  execute: ReturnType<typeof vi.fn>;
};
let calculateMemberRankUseCase: MockUseCase;

// テスト用クライアント作成関数
const createTestClient = (config: NodeConfig) => {
  // ルーティング設定
  const v1 = new Hono().route(
    "/members",
    createMemberRoutes(
      calculateMemberRankUseCase as unknown as CalculateMemberRankUseCase,
    ),
  );
  const routes = new Hono().route("/v1", v1);
  const app = createApp(config).route("/api", routes);

  return testClient(app);
};

// テスト用クライアント変数
let client: ReturnType<typeof createTestClient>;

// テスト用コンフィグ変数
let testConfig: NodeConfig;

// テストデータ用のUID
let uid: string;

// テスト前の共通セットアップ
beforeEach(() => {
  // モックの初期化
  calculateMemberRankUseCase = {
    execute: vi.fn().mockResolvedValue({
      rank: "gold",
    }),
  };

  testConfig = {
    ...config,
  };

  client = createTestClient(testConfig);

  uid = "550e8400-e29b-41d4-a716-446655440000";
});

describe("GET /api/v1/members/:uid/rank", () => {
  it("正常終了すること", async () => {
    // テスト実行
    const response = await client.api.v1.members[":uid"].rank.$get({
      param: {
        uid: uid,
      },
    });

    // 検証
    expect(response.status).toBe(200);
    expect(calculateMemberRankUseCase.execute).toHaveBeenCalledTimes(1);
    expect(calculateMemberRankUseCase.execute).toHaveBeenCalledWith(
      expect.anything(),
      {
        uid,
      },
    );
  });

  it("uidがUUID形式ではない場合にバリデーションエラーになること", async () => {
    // テスト実行
    const response = await client.api.v1.members[":uid"].rank.$get({
      param: {
        uid: "invalid-uid",
      },
    });

    // 検証
    expect(response.status).toBe(400);
    expect(calculateMemberRankUseCase.execute).not.toHaveBeenCalled();
  });
});

import { Hono } from "hono";
import type { NodeContainer } from "../../di/nodeContainer.js";
import { createUserRoutes } from "../http/generic/user/routes.js";
import { createSampleRoutes } from "../http/supporting/sample/routes.js";
import { createMemberRoutes } from "./core/member/routes.js";

export const createRoutesNode = (container: NodeContainer) => {
  /******************************
  * v1用のルーティング
  ******************************/
  // Honoでルーティングを作る際は、メソッドチェーン推薦
  const v1 = new Hono()
    .route(
      "/sample",
      createSampleRoutes(
        container.sampleHelloUseCase,
        container.sampleTextUseCase,
      ),
    )
    .route(
      "/users",
      createUserRoutes(
        container.createUserUseCase,
        container.findUsersUseCase,
        container.findUserUseCase,
        container.updateUserUseCase,
        container.deleteUserUseCase,
      ),
    )
    .route(
      "/members",
      createMemberRoutes(container.calculateMemberRankUseCase),
    );

    /******************************
    * ルーティング設定
    ******************************/
    return new Hono().route("/v1", v1);
};

import type { ContentfulStatusCode } from "hono/utils/http-status";
import { memberErrorStatusMap } from "../../../core/member/usecase/errors.js";
import { userErrorStatusMap } from "../../../generic/user/errors.js";

// 共通エラーコードとHTTPステータスコードのマッピング
export const errorStatusMap: Record<string, ContentfulStatusCode> = {
  ...userErrorStatusMap,
  ...memberErrorStatusMap,
};

$ mkdir -p src/tests/integration/core/member
$ touch src/tests/integration/core/member/member.test.ts

import { testClient } from "hono/testing";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import type { DbPg } from "../../../../infrastructure/database/drizzle/pg/client.js";
import { createDbPg } from "../../../../infrastructure/database/drizzle/pg/client.js";
import { users } from "../../../../infrastructure/database/drizzle/pg/schema/users.js";
import { createNodeApp } from "../../../../runtime/node/app.js";
import type { NodeConfig } from "../../../../runtime/node/config.js";
import { config } from "../../../../runtime/node/config.js";

// ログ出力の無効化
vi.spyOn(console, "log").mockImplementation(() => {});

// テスト用クライアント作成関数
const createTestClient = (config: NodeConfig) => {
  return testClient(createNodeApp(config));
};

// テスト用クライアント変数
let client: ReturnType<typeof createTestClient>;

let testDbPg: DbPg;

// テスト用コンフィグ変数
let testConfig: NodeConfig;

// テスト前の共通セットアップ
beforeEach(() => {
  testConfig = {
    ...config,
    db: {
      ...config.db,
      name: "testing-db-pg",
    },
  };

  client = createTestClient(testConfig);
  testDbPg = createDbPg(testConfig.db);
});

// テスト後の共通クリーンアップ
afterEach(async () => {
  await testDbPg.db.delete(users);
  await testDbPg.pool.end();
});

describe("GET /api/v1/members/:uid/rank", () => {
  it("対象メンバーのランクを取得し、正常終了すること", async () => {
    // テストデータ登録
    const [resultUser] = await testDbPg.db
      .insert(users)
      .values([
        {
          lastName: "山田",
          firstName: "太郎",
          totalPurchaseAmount: 10_000,
        },
      ])
      .returning();

    // テスト実行
    const response = await client.api.v1.members[":uid"].rank.$get({
      param: {
        uid: resultUser.uid,
      },
    });

    // 検証
    expect(response.status).toBe(200);

    // レスポンス結果の検証
    const body = await response.json();
    expect(body).toEqual({
      rank: "silver",
    });
  });
});

$ pnpm run format
$ pnpm run lint
$ pnpm run test