swallowkit 1.0.0-beta.11 → 1.0.0-beta.13

package/src/core/scaffold/model-parser.ts

@@ -6,6 +6,8 @@ import * as fs from "fs";
 import * as path from "path";
 import { pathToFileURL } from "url";
 
+import { ModelConnectorConfig } from "../../types";
+
 export interface ModelInfo {
   name: string; // モデル名（例: "Todo"）
   displayName: string; // 表示名（例: "Todo" または "タスク"）
@@ -16,6 +18,7 @@ export interface ModelInfo {
   hasCreatedAt: boolean; // createdAt フィールドがあるか
   hasUpdatedAt: boolean; // updatedAt フィールドがあるか
   nestedSchemaRefs: NestedSchemaRef[]; // ネストしたスキーマ参照
+  connectorConfig?: ModelConnectorConfig; // コネクタメタデータ（外部データソース用）
 }
 
 export interface FieldInfo {
@@ -60,11 +63,15 @@ export async function parseModelFile(modelPath: string): Promise<ModelInfo> {
   const modelName = toPascalCase(fileName);
   
   // スキーマ変数名を抽出
+  // コメント内のコードパターンを誤認識しないよう、先にコメントを除去してから正規表現を適用する
   // パターン1: export const todoSchema = z.object({ ... })  (camelCase + Schema接尾辞)
   // パターン2: export const Todo = z.object({ ... })         (Zod公式パターン)
-  let schemaMatch = content.match(/export\s+const\s+(\w+Schema)\s*=/);
+  const contentWithoutComments = content
+    .replace(/\/\*[\s\S]*?\*\//g, '')  // ブロックコメントを除去
+    .replace(/\/\/.*/g, '');           // 行コメントを除去
+  let schemaMatch = contentWithoutComments.match(/export\s+const\s+(\w+Schema)\s*=/);
   if (!schemaMatch) {
-    schemaMatch = content.match(/export\s+const\s+(\w+)\s*=\s*z\.object\s*\(/);
+    schemaMatch = contentWithoutComments.match(/export\s+const\s+(\w+)\s*=\s*z\.object\s*\(/);
   }
   if (!schemaMatch) {
     throw new Error(`Could not find exported schema in ${modelPath}. Expected patterns:\n  - export const xxxSchema = z.object({ ... })\n  - export const Xxx = z.object({ ... })`);
@@ -75,6 +82,9 @@ export async function parseModelFile(modelPath: string): Promise<ModelInfo> {
   // displayName を抽出（例: export const displayName = 'Task'）
   const displayNameMatch = content.match(/export\s+const\s+displayName\s*=\s*['"]([^'"]+)['"]/);  
   const displayName = displayNameMatch ? displayNameMatch[1] : modelName;
+
+  // connectorConfig を抽出（外部データソース用メタデータ）
+  const connectorConfig = parseConnectorConfig(content);
   
   // ネストしたスキーマ参照を検出
   const nestedSchemaRefs = detectNestedSchemaRefs(modelPath, content, schemaName);
@@ -100,6 +110,7 @@ export async function parseModelFile(modelPath: string): Promise<ModelInfo> {
     hasCreatedAt,
     hasUpdatedAt,
     nestedSchemaRefs,
+    ...(connectorConfig ? { connectorConfig } : {}),
   };
 }
 
@@ -291,6 +302,59 @@ function mergeNestedSchemaInfo(fields: FieldInfo[], nestedRefs: NestedSchemaRef[
   }
 }
 
+/**
+ * ローカル依存ファイルを再帰的にインライン化する（動的インポート用一時スクリプト生成用）。
+ * seen によって循環依存を防ぐ。
+ * importedNames が指定された場合はその名前の const だけを残し、他を除去する。
+ */
+function inlineLocalDeps(
+  filePath: string,
+  importedNames: Set<string> | null,
+  seen: Set<string>
+): string {
+  const resolvedPath = path.resolve(filePath);
+  if (seen.has(resolvedPath)) return '';
+  seen.add(resolvedPath);
+
+  if (!fs.existsSync(resolvedPath)) return '';
+
+  let content = fs.readFileSync(resolvedPath, 'utf8');
+  const fileDir = path.dirname(resolvedPath);
+  const transitiveParts: string[] = [];
+
+  // ローカル（相対）インポートを再帰的にインライン化
+  content = content.replace(
+    /import\s*\{([^}]+)\}\s*from\s*['"](\.[^'"]+)['"]\s*;?/g,
+    (_match: string, _imports: string, importPath: string) => {
+      let depPath = path.resolve(fileDir, importPath);
+      if (!depPath.endsWith('.ts') && !depPath.endsWith('.js')) depPath += '.ts';
+      const inlined = inlineLocalDeps(depPath, null, seen);
+      if (inlined) transitiveParts.push(inlined);
+      return '';
+    }
+  );
+
+  // 外部パッケージのインポートを除去
+  content = content.replace(/import\s+.*?\s+from\s+['"](?!\.).*?['"];?\s*/g, '');
+  // export キーワードを除去
+  content = content.replace(/export\s+(const|type|interface|class|function)\s+/g, '$1 ');
+  // 型宣言を除去（ランタイムでは不要）
+  content = content.replace(/^type\s+\w+\s*=\s*[^;]+;/gm, '');
+  content = content.replace(/^interface\s+\w+\s*\{[\s\S]*?\}/gm, '');
+  // コメントを除去
+  content = content.replace(/\/\*[\s\S]*?\*\//g, '');
+  content = content.replace(/\/\/.*/g, '');
+
+  // 直接インポートされていない const 宣言を除去（displayName 等の重複を防ぐ）
+  if (importedNames) {
+    content = content.replace(/^const\s+(\w+)\s*=\s*[^;]+;/gm, (constMatch: string, varName: string) => {
+      return importedNames.has(varName) ? constMatch : '';
+    });
+  }
+
+  return [...transitiveParts, content.trim()].filter(Boolean).join('\n\n');
+}
+
 /**
  * Zodスキーマから動的にフィールド情報を抽出
  */
@@ -300,52 +364,33 @@ async function extractFieldsFromSchema(modelPath: string, schemaName: string): P
   try {
     // child_processでtsxを実行
     const { execSync } = require('child_process');
-    const { tmpdir } = require('os');
-    const { join } = require('path');
     const { writeFileSync, unlinkSync, readFileSync } = require('fs');
     
     // モデルファイルの内容を読み込む
     let modelContent = readFileSync(modelPath, 'utf8');
     const modelDir = path.dirname(path.resolve(modelPath));
     
-    // ローカル相対インポートを絶対パスの .mjs import 文に変換して保持
+    // ローカル相対インポートを再帰的にインライン化して保持
     // パターン: import { categorySchema } from './category'
+    const seenPaths = new Set<string>([path.resolve(modelPath)]);
     const localImports: string[] = [];
     modelContent = modelContent.replace(
       /import\s*\{([^}]+)\}\s*from\s*['"](\.[^'"]+)['"]\s*;?/g,
       (_match: string, imports: string, importPath: string) => {
         // インポートされた変数名を取得
-        const importedNames = imports.split(',').map(s => {
-          const trimmed = s.trim();
-          // 'as' エイリアスに対応
-          return trimmed.split(/\s+as\s+/).pop()!.trim();
-        }).filter(s => s.length > 0);
-        
+        const importedNames = new Set(
+          imports.split(',').map(s => s.trim().split(/\s+as\s+/).pop()!.trim()).filter(s => s.length > 0)
+        );
+
         // 相対パスを絶対パスに解決
         let resolvedPath = path.resolve(modelDir, importPath);
         if (!resolvedPath.endsWith('.ts') && !resolvedPath.endsWith('.js')) {
           resolvedPath += '.ts';
         }
-        if (fs.existsSync(resolvedPath)) {
-          // インポート先の内容を読み込み、インライン化する
-          let refContent = readFileSync(resolvedPath, 'utf8');
-          // インポート先の import 文を除去
-          refContent = refContent.replace(/import\s+.*?\s+from\s+['"](?!\.).*?['"];?\s*/g, '');
-          refContent = refContent.replace(/import\s+.*?\s+from\s+['"]\..*?['"];?\s*/g, '');
-          refContent = refContent.replace(/export\s+(const|type|interface|class|function)\s+/g, '$1 ');
-          refContent = refContent.replace(/^type\s+\w+\s*=\s*[^;]+;/gm, '');
-          refContent = refContent.replace(/^interface\s+\w+\s*\{[\s\S]*?\}/gm, '');
-          refContent = refContent.replace(/\/\*[\s\S]*?\*\//g, '');
-          refContent = refContent.replace(/\/\/.*/g, '');
-          
-          // インポートされていない const 宣言を除去（displayName 等の重複を防ぐ）
-          const importedNameSet = new Set(importedNames);
-          refContent = refContent.replace(/^const\s+(\w+)\s*=\s*[^;]+;/gm, (constMatch: string, varName: string) => {
-            return importedNameSet.has(varName) ? constMatch : '';
-          });
-          
-          localImports.push(refContent.trim());
-        }
+
+        // 推移的なローカル依存を含めて再帰的にインライン化
+        const inlined = inlineLocalDeps(resolvedPath, importedNames, seenPaths);
+        if (inlined) localImports.push(inlined);
         return ''; // 元のインポート文は除去
       }
     );
@@ -586,6 +631,102 @@ export function toCamelCase(str: string): string {
   return pascal.charAt(0).toLowerCase() + pascal.slice(1);
 }
 
+/**
+ * モデルファイルから connectorConfig エクスポートを静的解析で抽出する
+ */
+export function parseConnectorConfig(content: string): ModelConnectorConfig | undefined {
+  // export const connectorConfig = { ... } を検出
+  const connectorMatch = content.match(/export\s+const\s+connectorConfig\s*=\s*\{/);
+  if (!connectorMatch) {
+    return undefined;
+  }
+
+  // connectorConfig オブジェクトの内容を抽出
+  const startIdx = content.indexOf('{', connectorMatch.index!);
+  let braceCount = 1;
+  let endIdx = startIdx + 1;
+  while (braceCount > 0 && endIdx < content.length) {
+    if (content[endIdx] === '{') braceCount++;
+    if (content[endIdx] === '}') braceCount--;
+    endIdx++;
+  }
+
+  const objectStr = content.substring(startIdx, endIdx);
+
+  // connector 名を抽出
+  const connectorNameMatch = objectStr.match(/connector\s*:\s*['"]([^'"]+)['"]/);
+  if (!connectorNameMatch) {
+    return undefined;
+  }
+  const connector = connectorNameMatch[1];
+
+  // operations を抽出
+  const opsMatch = objectStr.match(/operations\s*:\s*\[([^\]]*)\]/);
+  const operations: string[] = [];
+  if (opsMatch) {
+    const opsStr = opsMatch[1];
+    const opEntries = opsStr.match(/['"]([^'"]+)['"]/g);
+    if (opEntries) {
+      for (const entry of opEntries) {
+        operations.push(entry.replace(/['"]/g, ''));
+      }
+    }
+  }
+
+  // table を抽出（RDB 固有）
+  const tableMatch = objectStr.match(/table\s*:\s*['"]([^'"]+)['"]/);
+
+  // idColumn を抽出（RDB 固有）
+  const idColumnMatch = objectStr.match(/idColumn\s*:\s*['"]([^'"]+)['"]/);
+
+  // endpoints を抽出（API 固有）— endpoint値に {id} 等のプレースホルダが含まれるためbrace-countingで抽出
+  let endpoints: Record<string, string> | undefined;
+  const endpointsStart = objectStr.match(/endpoints\s*:\s*\{/);
+  if (endpointsStart) {
+    const epStartIdx = objectStr.indexOf('{', endpointsStart.index!);
+    let epBraceCount = 1;
+    let epEndIdx = epStartIdx + 1;
+    while (epBraceCount > 0 && epEndIdx < objectStr.length) {
+      const ch = objectStr[epEndIdx];
+      // 文字列内の波括弧をスキップ
+      if (ch === "'" || ch === '"') {
+        epEndIdx++;
+        while (epEndIdx < objectStr.length && objectStr[epEndIdx] !== ch) {
+          epEndIdx++;
+        }
+      } else if (ch === '{') {
+        epBraceCount++;
+      } else if (ch === '}') {
+        epBraceCount--;
+      }
+      epEndIdx++;
+    }
+    const epStr = objectStr.substring(epStartIdx + 1, epEndIdx - 1);
+    endpoints = {};
+    const endpointEntries = epStr.matchAll(/(\w+)\s*:\s*['"]([^'"]+)['"]/g);
+    for (const entry of endpointEntries) {
+      endpoints[entry[1]] = entry[2];
+    }
+  }
+
+  if (tableMatch) {
+    // RDB コネクタ
+    return {
+      connector,
+      operations: operations as ModelConnectorConfig['operations'],
+      table: tableMatch[1],
+      ...(idColumnMatch ? { idColumn: idColumnMatch[1] } : {}),
+    };
+  }
+
+  // API コネクタ
+  return {
+    connector,
+    operations: operations as ModelConnectorConfig['operations'],
+    ...(endpoints ? { endpoints } : {}),
+  };
+}
+
 /**
  * 文字列を kebab-case に変換
  */

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

@@ -215,3 +215,157 @@ export async function DELETE(
     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/types/index.ts

@@ -26,6 +26,52 @@ export interface UseServerFnResult<TResult> {
   refetch: () => void;
 }
 
+// コネクタの操作種別
+export type ConnectorOperation = "getAll" | "getById" | "create" | "update" | "delete";
+
+// RDB コネクタ設定
+export interface RdbConnectorConfig {
+  type: "rdb";
+  provider: "mysql" | "postgres" | "sqlserver";
+  connectionEnvVar: string;
+}
+
+// API コネクタの認証設定
+export interface ApiConnectorAuth {
+  type: "apiKey" | "bearer" | "oauth2";
+  envVar: string;
+  placement?: "query" | "header";
+  paramName?: string;
+}
+
+// API コネクタ設定
+export interface ApiConnectorConfig {
+  type: "api";
+  baseUrlEnvVar: string;
+  auth?: ApiConnectorAuth;
+}
+
+// コネクタ設定の共用型
+export type ConnectorDefinition = RdbConnectorConfig | ApiConnectorConfig;
+
+// モデルに付与するコネクタメタデータ（RDB用）
+export interface RdbModelConnectorConfig {
+  connector: string;
+  operations: readonly ConnectorOperation[];
+  table: string;
+  idColumn?: string;
+}
+
+// モデルに付与するコネクタメタデータ（API用）
+export interface ApiModelConnectorConfig {
+  connector: string;
+  operations: readonly ConnectorOperation[];
+  endpoints?: Partial<Record<ConnectorOperation, string>>;
+}
+
+// モデルに付与するコネクタメタデータの共用型
+export type ModelConnectorConfig = RdbModelConnectorConfig | ApiModelConnectorConfig;
+
 // CLI設定の型
 export interface SwallowKitConfig {
   database?: {
@@ -42,4 +88,5 @@ export interface SwallowKitConfig {
       credentials?: boolean;
     };
   };
+  connectors?: Record<string, ConnectorDefinition>;
 }