swallowkit 1.0.0-beta.12 → 1.0.0-beta.13

package/src/core/mock/connector-mock-server.ts

@@ -0,0 +1,307 @@
+/**
+ * コネクタモデル用モックサーバー
+ * - コネクタモデルへのリクエスト → Zodベースのインメモリ CRUD で応答
+ * - その他のリクエスト → 実Azure Functions へプロキシ
+ */
+
+import * as http from "http";
+import { ModelInfo, toCamelCase } from "../scaffold/model-parser";
+import { generateMockDocuments } from "./zod-mock-generator";
+import { loadDevSeedFiles } from "../../cli/commands/dev-seeds";
+
+export interface ConnectorMockServerOptions {
+  /** モックサーバーのリッスンポート */
+  port: number;
+  /** Azure Functions の転送先ホスト:ポート（例: "localhost:7071"） */
+  functionsTarget: string;
+  /** コネクタモデル一覧 */
+  connectorModels: ModelInfo[];
+  /** 全モデル一覧（dev-seeds 読み込み用） */
+  allModels?: ModelInfo[];
+  /** dev-seeds 環境名（指定時はシードデータを初期データとして読み込む） */
+  seedEnv?: string;
+  /** dev-seeds ディレクトリ */
+  seedsDir?: string;
+  /** 各モデルの初期生成レコード数（デフォルト: 5） */
+  mockCount?: number;
+  /** ホスト名 */
+  host?: string;
+}
+
+type MockDocument = Record<string, unknown>;
+
+/**
+ * コネクタモデル用モックサーバー
+ */
+export class ConnectorMockServer {
+  private server: http.Server | null = null;
+  private stores = new Map<string, MockDocument[]>();
+  private routeMap = new Map<string, ModelInfo>(); // route → model
+  private options: ConnectorMockServerOptions;
+
+  constructor(options: ConnectorMockServerOptions) {
+    this.options = options;
+
+    // ルートマップを構築: モデル名(camelCase) → ModelInfo
+    for (const model of options.connectorModels) {
+      const route = toCamelCase(model.name);
+      this.routeMap.set(route, model);
+    }
+  }
+
+  /**
+   * モックデータを初期化し、サーバーを起動
+   */
+  async start(): Promise<void> {
+    await this.initializeStores();
+
+    return new Promise((resolve, reject) => {
+      this.server = http.createServer((req, res) => {
+        this.handleRequest(req, res);
+      });
+
+      this.server.on("error", reject);
+      this.server.listen(this.options.port, this.options.host || "localhost", () => {
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * サーバーを停止
+   */
+  stop(): Promise<void> {
+    return new Promise((resolve) => {
+      if (this.server) {
+        // Force close keep-alive connections (Node.js 18.2+)
+        if (typeof (this.server as any).closeAllConnections === "function") {
+          (this.server as any).closeAllConnections();
+        }
+        this.server.close(() => resolve());
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  /**
+   * 特定モデルの現在のストアデータを取得（テスト用）
+   */
+  getStore(modelName: string): MockDocument[] {
+    const route = toCamelCase(modelName);
+    return this.stores.get(route) || [];
+  }
+
+  // ─── Internal ─────────────────────────────────────────────
+
+  private async initializeStores() {
+    const allModels = this.options.allModels || this.options.connectorModels;
+    const mockCount = this.options.mockCount ?? 5;
+
+    // まず Zod ベースのモックデータで初期化
+    for (const model of this.options.connectorModels) {
+      const route = toCamelCase(model.name);
+      this.stores.set(route, generateMockDocuments(model, mockCount, allModels));
+    }
+
+    // dev-seeds があれば上書き
+    if (this.options.seedEnv) {
+      try {
+        const seedFiles = await loadDevSeedFiles(
+          this.options.seedEnv,
+          this.options.connectorModels,
+          this.options.seedsDir
+        );
+        for (const seedFile of seedFiles) {
+          const route = toCamelCase(seedFile.model.name);
+          if (this.stores.has(route)) {
+            this.stores.set(route, seedFile.documents as MockDocument[]);
+            console.log(`  📂 Loaded ${seedFile.documents.length} seed doc(s) for ${seedFile.model.name}`);
+          }
+        }
+      } catch (err) {
+        console.warn(`⚠️  Failed to load dev-seeds for connectors: ${(err as Error).message}`);
+      }
+    }
+  }
+
+  private handleRequest(req: http.IncomingMessage, res: http.ServerResponse) {
+    const { route, id } = this.parseRoute(req.url || "");
+
+    // コネクタモデルのルートか判定
+    if (route && this.routeMap.has(route)) {
+      this.handleMockCrud(req, res, route, id);
+    } else {
+      this.proxyToFunctions(req, res);
+    }
+  }
+
+  /**
+   * URL パス解析: /api/backlogIssue/123 → { route: "backlogIssue", id: "123" }
+   */
+  private parseRoute(url: string): { route: string | null; id: string | null } {
+    const parsed = new URL(url, "http://localhost");
+    const segments = parsed.pathname.split("/").filter(Boolean);
+
+    // /api/<route> or /api/<route>/<id>
+    if (segments.length >= 2 && segments[0] === "api") {
+      return {
+        route: segments[1],
+        id: segments.length >= 3 ? segments[2] : null,
+      };
+    }
+
+    return { route: null, id: null };
+  }
+
+  private handleMockCrud(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    route: string,
+    id: string | null
+  ) {
+    const method = (req.method || "GET").toUpperCase();
+    const store = this.stores.get(route) || [];
+    const model = this.routeMap.get(route)!;
+    const ops = model.connectorConfig?.operations || [];
+
+    switch (method) {
+      case "GET":
+        req.resume();
+        if (id) {
+          if (!ops.includes("getById")) {
+            return this.sendJson(res, 405, { error: "getById not supported" });
+          }
+          const item = store.find((doc) => doc.id === id);
+          return item
+            ? this.sendJson(res, 200, item)
+            : this.sendJson(res, 404, { error: "Item not found" });
+        }
+        if (!ops.includes("getAll")) {
+          return this.sendJson(res, 405, { error: "getAll not supported" });
+        }
+        return this.sendJson(res, 200, store);
+
+      case "POST":
+        if (!ops.includes("create")) {
+          return this.drainAndRespond(req, res, 405, { error: "create not supported" });
+        }
+        this.readBody(req, (body) => {
+          if (!body.id) {
+            body.id = `${route}-${Date.now()}`;
+          }
+          body.createdAt = body.createdAt || new Date().toISOString();
+          body.updatedAt = body.updatedAt || new Date().toISOString();
+          store.push(body);
+          this.sendJson(res, 201, body);
+        });
+        return;
+
+      case "PUT":
+        if (!ops.includes("update")) {
+          return this.drainAndRespond(req, res, 405, { error: "update not supported" });
+        }
+        if (!id) return this.drainAndRespond(req, res, 400, { error: "id required" });
+        this.readBody(req, (body) => {
+          const idx = store.findIndex((doc) => doc.id === id);
+          if (idx === -1) return this.sendJson(res, 404, { error: "Item not found" });
+          body.updatedAt = new Date().toISOString();
+          store[idx] = { ...store[idx], ...body, id };
+          this.sendJson(res, 200, store[idx]);
+        });
+        return;
+
+      case "DELETE":
+        req.resume();
+        if (!ops.includes("delete")) {
+          return this.sendJson(res, 405, { error: "delete not supported" });
+        }
+        if (!id) return this.sendJson(res, 400, { error: "id required" });
+        const deleteIdx = store.findIndex((doc) => doc.id === id);
+        if (deleteIdx === -1) return this.sendJson(res, 404, { error: "Item not found" });
+        store.splice(deleteIdx, 1);
+        return this.sendJson(res, 204, null);
+
+      default:
+        req.resume();
+        return this.sendJson(res, 405, { error: `Method ${method} not allowed` });
+    }
+  }
+
+  /**
+   * コネクタモデル以外のリクエストをAzure Functionsへプロキシ
+   */
+  private proxyToFunctions(req: http.IncomingMessage, res: http.ServerResponse) {
+    const [targetHost, targetPort] = this.options.functionsTarget.split(":");
+
+    const proxyOpts: http.RequestOptions = {
+      hostname: targetHost,
+      port: parseInt(targetPort, 10),
+      path: req.url,
+      method: req.method,
+      headers: { ...req.headers, host: this.options.functionsTarget },
+    };
+
+    const proxyReq = http.request(proxyOpts, (proxyRes) => {
+      res.writeHead(proxyRes.statusCode || 502, proxyRes.headers);
+      proxyRes.pipe(res, { end: true });
+    });
+
+    proxyReq.on("error", (err) => {
+      // Functions がまだ起動していない場合
+      this.sendJson(res, 502, {
+        error: "Azure Functions not available",
+        detail: err.message,
+      });
+    });
+
+    req.pipe(proxyReq, { end: true });
+  }
+
+  // ─── Utilities ────────────────────────────────────────────
+
+  private readBody(req: http.IncomingMessage, callback: (body: MockDocument) => void) {
+    let data = "";
+    req.on("data", (chunk) => (data += chunk));
+    req.on("end", () => {
+      try {
+        callback(JSON.parse(data));
+      } catch {
+        callback({});
+      }
+    });
+  }
+
+  private sendJson(res: http.ServerResponse, status: number, body: unknown) {
+    res.writeHead(status, {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*",
+      "Connection": "close",
+    });
+    if (body !== null && body !== undefined) {
+      res.end(JSON.stringify(body));
+    } else {
+      res.end();
+    }
+  }
+
+  /**
+   * リクエストボディを完全に読み捨ててからレスポンスを送信
+   * POST/PUT の 405 等で未読ボディがある場合に Linux で RST を防ぐ
+   */
+  private drainAndRespond(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    status: number,
+    body: unknown
+  ) {
+    if (req.readableEnded) {
+      this.sendJson(res, status, body);
+      return;
+    }
+    req.resume();
+    req.on("end", () => {
+      this.sendJson(res, status, body);
+    });
+  }
+}

package/src/core/mock/zod-mock-generator.ts

@@ -0,0 +1,205 @@
+/**
+ * Zod スキーマ（ModelInfo）からモックデータを自動生成する
+ * フィールド名・型のヒューリスティクスで現実的な値を生成
+ */
+
+import { ModelInfo, FieldInfo, toCamelCase, toKebabCase } from "../scaffold/model-parser";
+
+/**
+ * 単一のモックドキュメントを生成
+ */
+export function generateMockDocument(
+  model: ModelInfo,
+  index: number,
+  allModels: ModelInfo[] = [model],
+  seenModels: Set<string> = new Set()
+): Record<string, unknown> {
+  const nextSeen = new Set(seenModels);
+  nextSeen.add(model.name);
+
+  const doc: Record<string, unknown> = {};
+  for (const field of model.fields) {
+    doc[field.name] = generateFieldValue(model, field, index, allModels, nextSeen);
+  }
+  return doc;
+}
+
+/**
+ * 複数のモックドキュメントを生成
+ */
+export function generateMockDocuments(
+  model: ModelInfo,
+  count: number = 5,
+  allModels: ModelInfo[] = [model]
+): Record<string, unknown>[] {
+  const docs: Record<string, unknown>[] = [];
+  for (let i = 0; i < count; i++) {
+    docs.push(generateMockDocument(model, i + 1, allModels));
+  }
+  return docs;
+}
+
+// ─── Field Value Generation ─────────────────────────────────
+
+function generateFieldValue(
+  model: ModelInfo,
+  field: FieldInfo,
+  index: number,
+  allModels: ModelInfo[],
+  seenModels: Set<string>
+): unknown {
+  // ネストされたスキーマ
+  if (field.isNestedSchema && field.nestedModelName) {
+    const nestedModel = allModels.find((m) => m.name === field.nestedModelName);
+    if (nestedModel && !seenModels.has(nestedModel.name)) {
+      const nested = generateMockDocument(nestedModel, index, allModels, seenModels);
+      return field.isArray ? [nested] : nested;
+    }
+    const fallback = { id: `${toKebabCase(field.nestedModelName!)}-${padIndex(index)}` };
+    return field.isArray ? [fallback] : fallback;
+  }
+
+  if (field.isArray) {
+    return [generateScalarValue(model, field, index)];
+  }
+
+  return generateScalarValue(model, field, index);
+}
+
+function generateScalarValue(
+  model: ModelInfo,
+  field: FieldInfo,
+  index: number
+): unknown {
+  const name = field.name.toLowerCase();
+  const modelKebab = toKebabCase(model.name);
+
+  // id フィールド
+  if (field.name === "id") {
+    return `${modelKebab}-${padIndex(index)}`;
+  }
+
+  // enum フィールド — ラウンドロビン
+  if (field.enumValues && field.enumValues.length > 0) {
+    return field.enumValues[(index - 1) % field.enumValues.length];
+  }
+
+  // boolean フィールド
+  if (field.type === "boolean") {
+    return index % 2 === 0;
+  }
+
+  // number フィールド
+  if (field.type === "number") {
+    return generateNumberValue(name, index);
+  }
+
+  // date フィールド / *At パターン
+  if (field.type === "date" || name.endsWith("at")) {
+    return generateDateValue(index);
+  }
+
+  // object フィールド
+  if (field.type === "object") {
+    return {};
+  }
+
+  // string フィールド — 名前パターンで分岐
+  return generateStringValue(model, field, index);
+}
+
+function generateStringValue(model: ModelInfo, field: FieldInfo, index: number): string {
+  const name = field.name.toLowerCase();
+  const modelKebab = toKebabCase(model.name);
+
+  // email
+  if (name.includes("email") || name.includes("mail")) {
+    return `${modelKebab}-${padIndex(index)}@example.com`;
+  }
+
+  // URL / ウェブサイト
+  if (name.includes("url") || name.includes("website") || name.includes("link") || name === "href") {
+    return `https://example.com/${modelKebab}/${padIndex(index)}`;
+  }
+
+  // 電話番号
+  if (name.includes("phone") || name.includes("tel")) {
+    return `090-0000-${String(index).padStart(4, "0")}`;
+  }
+
+  // 名前系
+  if (name === "name" || name === "displayname" || name === "fullname" || name === "username") {
+    return `${model.name} ${index}`;
+  }
+  if (name === "firstname" || name === "givenname") {
+    return `FirstName${index}`;
+  }
+  if (name === "lastname" || name === "familyname" || name === "surname") {
+    return `LastName${index}`;
+  }
+
+  // タイトル / 件名
+  if (name === "title" || name === "subject" || name === "summary") {
+    return `Sample ${model.displayName || model.name} ${index}`;
+  }
+
+  // 説明 / 本文
+  if (name === "description" || name === "body" || name === "content" || name === "text") {
+    return `This is a sample ${toCamelCase(model.name)} description for item ${index}.`;
+  }
+
+  // コード / キー
+  if (name.includes("code") || name.includes("key") && !name.includes("api")) {
+    return `${modelKebab.toUpperCase().replace(/-/g, "_")}-${String(index).padStart(3, "0")}`;
+  }
+
+  // ステータス
+  if (name === "status") {
+    const statuses = ["active", "inactive", "pending"];
+    return statuses[(index - 1) % statuses.length];
+  }
+
+  // タイプ / カテゴリ
+  if (name === "type" || name === "category") {
+    return `type-${((index - 1) % 3) + 1}`;
+  }
+
+  // 住所
+  if (name.includes("address") || name.includes("city") || name.includes("country")) {
+    return `Address ${index}`;
+  }
+
+  // 部署
+  if (name === "department" || name === "team" || name === "group") {
+    const depts = ["Engineering", "Sales", "Marketing", "Support", "HR"];
+    return depts[(index - 1) % depts.length];
+  }
+
+  // *Id パターン（外部キー）
+  if (name.endsWith("id") && name !== "id") {
+    const refName = field.name.replace(/Id$/, "");
+    return `${toKebabCase(refName)}-${padIndex(((index - 1) % 3) + 1)}`;
+  }
+
+  // デフォルト
+  return `${modelKebab}-${toKebabCase(field.name)}-${index}`;
+}
+
+function generateNumberValue(name: string, index: number): number {
+  if (name.includes("age")) return 20 + index;
+  if (name.includes("price") || name.includes("cost") || name.includes("amount")) return index * 1000;
+  if (name.includes("count") || name.includes("quantity") || name.includes("qty")) return index * 5;
+  if (name.includes("priority") || name.includes("order") || name.includes("sort")) return index;
+  if (name.includes("rating") || name.includes("score")) return Math.min(index, 5);
+  return index;
+}
+
+function generateDateValue(index: number): string {
+  const baseDate = new Date("2026-01-01T00:00:00.000Z");
+  baseDate.setDate(baseDate.getDate() + index);
+  return baseDate.toISOString();
+}
+
+function padIndex(index: number): string {
+  return String(index).padStart(3, "0");
+}