swallowkit 1.0.0-beta.6 → 1.0.0-beta.60

package/src/core/scaffold/nextjs-generator.ts

@@ -0,0 +1,382 @@
+/**
+ * Next.js BFF API Routes コード生成
+ * Azure Functions を呼び出す BFF パターンの API routes を生成
+ * callFunction ヘルパー方式
+ */
+
+import { ModelInfo, toCamelCase } from "./model-parser";
+
+/**
+ * BFF callFunction ヘルパー (lib/api/call-function.ts) のコードを生成
+ */
+export function generateBFFCallFunction(): string {
+  return `import { NextResponse } from 'next/server';
+import { z } from 'zod/v4';
+
+/**
+ * SwallowKit BFF Call Function Helper
+ * Azure Functions を呼び出す汎用ヘルパー
+ *
+ * @example
+ * // シンプルな GET
+ * return callFunction({ method: 'GET', path: '/api/todo', responseSchema: z.array(TodoSchema) });
+ *
+ * // バリデーション付き POST
+ * return callFunction({ method: 'POST', path: '/api/todo', body, inputSchema: InputSchema, responseSchema: TodoSchema, successStatus: 201 });
+ *
+ * // カスタムビジネスロジック関数の呼び出し
+ * return callFunction({ method: 'POST', path: '/api/todo/archive', body: { ids } });
+ */
+
+function getFunctionsBaseUrl(): string {
+  return process.env.BACKEND_FUNCTIONS_BASE_URL || process.env.FUNCTIONS_BASE_URL || 'http://localhost:7071';
+}
+
+function isLocalFunctionsUrl(url: string): boolean {
+  return url.startsWith('http://localhost:') || url.startsWith('http://127.0.0.1:');
+}
+
+function getFunctionsKeyHeaders(functionsBaseUrl: string): Record<string, string> {
+  const key = process.env.BACKEND_FUNCTIONS_KEY;
+  if (key) return { 'x-functions-key': key };
+  if (isLocalFunctionsUrl(functionsBaseUrl)) return {};
+  throw new Error('BACKEND_FUNCTIONS_KEY is required for non-local Functions calls');
+}
+
+interface CallFunctionConfig<TInput = unknown, TOutput = unknown> {
+  /** HTTP メソッド */
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+  /** Azure Functions のパス (例: '/api/todo', '/api/todo/123') */
+  path: string;
+  /** リクエストボディ (POST/PUT 用) */
+  body?: unknown;
+  /** 入力バリデーション用 Zod スキーマ (省略時はバリデーションなし) */
+  inputSchema?: z.ZodSchema<TInput>;
+  /** 出力バリデーション用 Zod スキーマ (省略時はそのまま返す) */
+  responseSchema?: z.ZodSchema<TOutput>;
+  /** 成功時の HTTP ステータスコード (デフォルト: 200) */
+  successStatus?: number;
+}
+
+export async function callFunction<TInput = unknown, TOutput = unknown>(
+  config: CallFunctionConfig<TInput, TOutput>
+): Promise<NextResponse> {
+  const { method, path, body, inputSchema, responseSchema, successStatus = 200 } = config;
+
+  try {
+    // 入力バリデーション
+    let validatedBody = body;
+    if (inputSchema && body !== undefined) {
+      const result = inputSchema.safeParse(body);
+      if (!result.success) {
+        console.error('[BFF] Validation failed:', result.error.issues);
+        return NextResponse.json(
+          { error: 'Validation failed', details: result.error.issues },
+          { status: 400 }
+        );
+      }
+      validatedBody = result.data;
+    }
+
+    // Azure Functions を呼び出し
+    const functionsBaseUrl = getFunctionsBaseUrl();
+    const url = functionsBaseUrl + path;
+    const keyHeaders = getFunctionsKeyHeaders(functionsBaseUrl);
+    console.log(\`[BFF] \${method} \${url}\`);
+
+    const response = await fetch(url, {
+      method,
+      headers: { 'Content-Type': 'application/json', ...keyHeaders },
+      body: validatedBody !== undefined ? JSON.stringify(validatedBody) : undefined,
+    });
+
+    console.log('[BFF] Functions response status:', response.status);
+
+    // エラーレスポンスの転送
+    if (!response.ok) {
+      const text = await response.text();
+      console.error('[BFF] Functions error:', { status: response.status, body: text });
+
+      let errorMessage = 'Request failed';
+      try {
+        const error = JSON.parse(text);
+        errorMessage = error.error || errorMessage;
+      } catch {
+        errorMessage = text || errorMessage;
+      }
+      return NextResponse.json({ error: errorMessage }, { status: response.status });
+    }
+
+    // DELETE 204 の場合はボディなし
+    if (response.status === 204 || method === 'DELETE') {
+      return new NextResponse(null, { status: 204 });
+    }
+
+    // レスポンスの取得と出力バリデーション
+    const data = await response.json();
+
+    if (responseSchema) {
+      const validated = responseSchema.parse(data);
+      return NextResponse.json(validated, { status: successStatus });
+    }
+
+    return NextResponse.json(data, { status: successStatus });
+  } catch (error) {
+    console.error(\`[BFF] Error:\`, error);
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+`;
+}
+
+/**
+ * 明示的ハンドラー方式の BFF ルートファイルを生成
+ */
+export function generateCompactBFFRoutes(model: ModelInfo, sharedPackageName: string): {
+  listRoute: string;
+  detailRoute: string;
+} {
+  const modelName = model.name;
+  const modelCamel = toCamelCase(modelName);
+  const schemaName = model.schemaName;
+
+  const listRoute = `import { NextRequest } from 'next/server';
+import { callFunction } from '@/lib/api/call-function';
+import { ${schemaName} } from '${sharedPackageName}';
+import { z } from 'zod/v4';
+
+const InputSchema = ${schemaName}.omit({ id: true, createdAt: true, updatedAt: true });
+
+// GET /api/${modelCamel} - 一覧取得
+export async function GET() {
+  return callFunction({
+    method: 'GET',
+    path: '/api/${modelCamel}',
+    responseSchema: z.array(${schemaName}),
+  });
+}
+
+// POST /api/${modelCamel} - 新規作成
+export async function POST(request: NextRequest) {
+  const body = await request.json();
+  return callFunction({
+    method: 'POST',
+    path: '/api/${modelCamel}',
+    body,
+    inputSchema: InputSchema,
+    responseSchema: ${schemaName},
+    successStatus: 201,
+  });
+}
+`;
+
+  const detailRoute = `import { NextRequest } from 'next/server';
+import { callFunction } from '@/lib/api/call-function';
+import { ${schemaName} } from '${sharedPackageName}';
+
+const InputSchema = ${schemaName}.omit({ id: true, createdAt: true, updatedAt: true });
+
+// GET /api/${modelCamel}/{id} - 詳細取得
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  return callFunction({
+    method: 'GET',
+    path: \`/api/${modelCamel}/\${id}\`,
+    responseSchema: ${schemaName},
+  });
+}
+
+// PUT /api/${modelCamel}/{id} - 更新
+export async function PUT(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const body = await request.json();
+  return callFunction({
+    method: 'PUT',
+    path: \`/api/${modelCamel}/\${id}\`,
+    body,
+    inputSchema: InputSchema,
+    responseSchema: ${schemaName},
+  });
+}
+
+// DELETE /api/${modelCamel}/{id} - 削除
+export async function DELETE(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  return callFunction({
+    method: 'DELETE',
+    path: \`/api/${modelCamel}/\${id}\`,
+  });
+}
+`;
+
+  return {
+    listRoute,
+    detailRoute,
+  };
+}
+
+/**
+ * コネクタ用 BFF ルートファイルを生成（操作制限に対応）
+ * 指定された operations のみハンドラーを生成する
+ */
+export function generateConnectorBFFRoutes(
+  model: ModelInfo,
+  sharedPackageName: string,
+  operations: readonly string[]
+): {
+  listRoute: string;
+  detailRoute: string;
+} {
+  const modelName = model.name;
+  const modelCamel = toCamelCase(modelName);
+  const schemaName = model.schemaName;
+  const ops = new Set(operations);
+
+  const hasGetAll = ops.has("getAll");
+  const hasCreate = ops.has("create");
+  const hasGetById = ops.has("getById");
+  const hasUpdate = ops.has("update");
+  const hasDelete = ops.has("delete");
+
+  // --- List route ---
+  let listImports = `import { callFunction } from '@/lib/api/call-function';
+import { ${schemaName} } from '${sharedPackageName}';
+import { z } from 'zod/v4';`;
+
+  if (hasCreate) {
+    listImports = `import { NextRequest } from 'next/server';
+${listImports}
+
+const InputSchema = ${schemaName}.omit({ id: true, createdAt: true, updatedAt: true });`;
+  }
+
+  let listHandlers = "";
+  if (hasGetAll) {
+    listHandlers += `
+// GET /api/${modelCamel} - 一覧取得
+export async function GET() {
+  return callFunction({
+    method: 'GET',
+    path: '/api/${modelCamel}',
+    responseSchema: z.array(${schemaName}),
+  });
+}
+`;
+  }
+
+  if (hasCreate) {
+    listHandlers += `
+// POST /api/${modelCamel} - 新規作成
+export async function POST(request: NextRequest) {
+  const body = await request.json();
+  return callFunction({
+    method: 'POST',
+    path: '/api/${modelCamel}',
+    body,
+    inputSchema: InputSchema,
+    responseSchema: ${schemaName},
+    successStatus: 201,
+  });
+}
+`;
+  }
+
+  const listRoute = `${listImports}
+${listHandlers}`;
+
+  // --- Detail route ---
+  const needDetailImport = hasGetById || hasUpdate || hasDelete;
+  let detailImports = "";
+  let detailHandlers = "";
+
+  if (needDetailImport) {
+    const needNextRequest = hasUpdate;
+    detailImports = needNextRequest
+      ? `import { NextRequest } from 'next/server';
+import { callFunction } from '@/lib/api/call-function';
+import { ${schemaName} } from '${sharedPackageName}';`
+      : `import { NextRequest } from 'next/server';
+import { callFunction } from '@/lib/api/call-function';
+import { ${schemaName} } from '${sharedPackageName}';`;
+
+    if (hasUpdate) {
+      detailImports += `\n\nconst InputSchema = ${schemaName}.omit({ id: true, createdAt: true, updatedAt: true });`;
+    }
+
+    if (hasGetById) {
+      detailHandlers += `
+// GET /api/${modelCamel}/{id} - 詳細取得
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  return callFunction({
+    method: 'GET',
+    path: \`/api/${modelCamel}/\${id}\`,
+    responseSchema: ${schemaName},
+  });
+}
+`;
+    }
+
+    if (hasUpdate) {
+      detailHandlers += `
+// PUT /api/${modelCamel}/{id} - 更新
+export async function PUT(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const body = await request.json();
+  return callFunction({
+    method: 'PUT',
+    path: \`/api/${modelCamel}/\${id}\`,
+    body,
+    inputSchema: InputSchema,
+    responseSchema: ${schemaName},
+  });
+}
+`;
+    }
+
+    if (hasDelete) {
+      detailHandlers += `
+// DELETE /api/${modelCamel}/{id} - 削除
+export async function DELETE(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  return callFunction({
+    method: 'DELETE',
+    path: \`/api/${modelCamel}/\${id}\`,
+  });
+}
+`;
+    }
+  }
+
+  const detailRoute = needDetailImport
+    ? `${detailImports}
+${detailHandlers}`
+    : `// No detail operations defined for this connector model
+`;
+
+  return {
+    listRoute,
+    detailRoute,
+  };
+}

package/src/core/scaffold/openapi-generator.ts

@@ -0,0 +1,212 @@
+import { FieldInfo, ModelInfo, toCamelCase } from "./model-parser";
+
+type OpenApiSchema =
+  | {
+      type?: string;
+      format?: string;
+      enum?: string[];
+      items?: OpenApiSchema;
+      properties?: Record<string, OpenApiSchema>;
+      required?: string[];
+      additionalProperties?: boolean;
+      nullable?: boolean;
+      $ref?: string;
+    };
+
+function toScalarSchema(field: FieldInfo): OpenApiSchema {
+  if (field.enumValues?.length) {
+    return {
+      type: "string",
+      enum: field.enumValues,
+    };
+  }
+
+  switch (field.type) {
+    case "string":
+      return {
+        type: "string",
+        format: field.name.toLowerCase().endsWith("at") ? "date-time" : undefined,
+      };
+    case "date":
+      return {
+        type: "string",
+        format: "date-time",
+      };
+    case "number":
+      return {
+        type: "number",
+      };
+    case "boolean":
+      return {
+        type: "boolean",
+      };
+    default:
+      return {
+        type: "object",
+        additionalProperties: true,
+      };
+  }
+}
+
+function toFieldSchema(field: FieldInfo): OpenApiSchema {
+  const schema = field.isNestedSchema && field.nestedModelName
+    ? {
+        $ref: `#/components/schemas/${field.nestedModelName}`,
+      }
+    : toScalarSchema(field);
+
+  if (field.isArray) {
+    return {
+      type: "array",
+      items: schema,
+    };
+  }
+
+  return schema;
+}
+
+function createComponentSchema(model: ModelInfo): OpenApiSchema {
+  const properties: Record<string, OpenApiSchema> = {};
+  const required: string[] = [];
+
+  for (const field of model.fields) {
+    properties[field.name] = toFieldSchema(field);
+    if (!field.isOptional) {
+      required.push(field.name);
+    }
+  }
+
+  return {
+    type: "object",
+    properties,
+    required,
+  };
+}
+
+export function generateOpenApiDocument(models: ModelInfo[], rootModel: ModelInfo): string {
+  const rootModelRoute = toCamelCase(rootModel.name);
+  const components = Object.fromEntries(
+    models.map((model) => [model.name, createComponentSchema(model)])
+  );
+
+  const document = {
+    openapi: "3.0.3",
+    info: {
+      title: `${rootModel.name} API`,
+      version: "1.0.0",
+      description: "Generated from SwallowKit Zod model metadata.",
+    },
+    paths: {
+      [`/api/${rootModelRoute}`]: {
+        get: {
+          operationId: `${rootModelRoute}GetAll`,
+          responses: {
+            "200": {
+              description: "Successful response",
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "array",
+                    items: {
+                      $ref: `#/components/schemas/${rootModel.name}`,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+        post: {
+          operationId: `${rootModelRoute}Create`,
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: `#/components/schemas/${rootModel.name}`,
+                },
+              },
+            },
+          },
+          responses: {
+            "201": {
+              description: "Created response",
+              content: {
+                "application/json": {
+                  schema: {
+                    $ref: `#/components/schemas/${rootModel.name}`,
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      [`/api/${rootModelRoute}/{id}`]: {
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string",
+            },
+          },
+        ],
+        get: {
+          operationId: `${rootModelRoute}GetById`,
+          responses: {
+            "200": {
+              description: "Successful response",
+              content: {
+                "application/json": {
+                  schema: {
+                    $ref: `#/components/schemas/${rootModel.name}`,
+                  },
+                },
+              },
+            },
+          },
+        },
+        put: {
+          operationId: `${rootModelRoute}Update`,
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: `#/components/schemas/${rootModel.name}`,
+                },
+              },
+            },
+          },
+          responses: {
+            "200": {
+              description: "Updated response",
+              content: {
+                "application/json": {
+                  schema: {
+                    $ref: `#/components/schemas/${rootModel.name}`,
+                  },
+                },
+              },
+            },
+          },
+        },
+        delete: {
+          operationId: `${rootModelRoute}Delete`,
+          responses: {
+            "204": {
+              description: "Deleted response",
+            },
+          },
+        },
+      },
+    },
+    components: {
+      schemas: components,
+    },
+  };
+
+  return JSON.stringify(document, null, 2);
+}