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

package/src/cli/commands/dev.ts

@@ -9,6 +9,7 @@ import { ModelInfo } from '../../core/scaffold/model-parser';
 import { applyDevSeedEnvironment, getContainerNameForModel, loadProjectModels } from './dev-seeds';
 import { BackendLanguage } from '../../types';
 import { detectFromProject, getCommands } from '../../utils/package-manager';
+import { ConnectorMockServer } from '../../core/mock/connector-mock-server';
 
 interface DevOptions {
   port?: string;
@@ -18,6 +19,7 @@ interface DevOptions {
   verbose?: boolean;
   noFunctions?: boolean;
   seedEnv?: string;
+  mockConnectors?: boolean;
 }
 
 export function buildFunctionsStartArgs(functionsPort: string): string[] {
@@ -323,7 +325,8 @@ export const devCommand = new Command()
   .option('--verbose', 'Show verbose logs', false)
   .option('--no-functions', 'Skip Azure Functions startup', false)
   .option('--seed-env <environment>', 'Replace Cosmos DB Emulator data from dev-seeds/<environment> before startup')
-  .action(async (options: DevOptions & { functionsPort?: string; noFunctions?: boolean; seedEnv?: string }) => {
+  .option('--mock-connectors', 'Start mock server for connector models (serves Zod-generated data)', false)
+  .action(async (options: DevOptions & { functionsPort?: string; noFunctions?: boolean; seedEnv?: string; mockConnectors?: boolean }) => {
     // SwallowKit プロジェクトディレクトリかどうかを検証
     ensureSwallowKitProject("dev");
 
@@ -454,10 +457,14 @@ async function startDevEnvironment(options: DevOptions) {
   // プロセスを管理する配列
   const processes: ChildProcess[] = [];
   let functionsEnv: NodeJS.ProcessEnv = process.env;
+  let mockServer: ConnectorMockServer | null = null;
 
   // Cleanup processes on Ctrl+C
-  process.on('SIGINT', () => {
+  process.on('SIGINT', async () => {
     console.log('\n🛑 Stopping development servers...');
+    if (mockServer) {
+      await mockServer.stop();
+    }
     processes.forEach((proc) => {
       if (proc && !proc.killed) {
         proc.kill();
@@ -695,6 +702,41 @@ async function startDevEnvironment(options: DevOptions) {
     console.log('');
     console.log('🚀 Starting Next.js development server...');
 
+    // Mock connector server — start proxy if --mock-connectors is enabled
+    let bffTargetPort = functionsPort;
+
+    if (options.mockConnectors) {
+      const allModels = await loadProjectModels();
+      const connectorModels = allModels.filter((m) => m.connectorConfig);
+
+      if (connectorModels.length > 0) {
+        const mockPort = parseInt(functionsPort, 10) + 1;
+        mockServer = new ConnectorMockServer({
+          port: mockPort,
+          functionsTarget: `${options.host || 'localhost'}:${functionsPort}`,
+          connectorModels,
+          allModels,
+          seedEnv: options.seedEnv,
+          host: options.host || 'localhost',
+        });
+
+        await mockServer.start();
+        bffTargetPort = String(mockPort);
+
+        console.log('');
+        console.log(`🔌 Connector mock server started (port: ${mockPort})`);
+        console.log(`   Mocking ${connectorModels.length} connector model(s):`);
+        for (const m of connectorModels) {
+          const ops = m.connectorConfig!.operations.join(', ');
+          console.log(`     - ${m.name} [${ops}]`);
+        }
+        console.log(`   Other routes → proxied to Azure Functions (port: ${functionsPort})`);
+      } else {
+        console.log('');
+        console.log('ℹ️  --mock-connectors specified but no connector models found. Skipping mock server.');
+      }
+    }
+
     // 5. Start Next.js development server
     const nextArgs = buildNextDevArgs(pm, port);
     
@@ -712,8 +754,8 @@ async function startDevEnvironment(options: DevOptions) {
 
     const nextEnv: NodeJS.ProcessEnv = {
       ...process.env,
-      BACKEND_FUNCTIONS_BASE_URL: `http://${options.host || 'localhost'}:${functionsPort}`,
-      FUNCTIONS_BASE_URL: `http://${options.host || 'localhost'}:${functionsPort}`,
+      BACKEND_FUNCTIONS_BASE_URL: `http://${options.host || 'localhost'}:${bffTargetPort}`,
+      FUNCTIONS_BASE_URL: `http://${options.host || 'localhost'}:${bffTargetPort}`,
     };
 
     const nextProcess = spawn(pm === 'pnpm' ? 'pnpm' : 'npx', nextArgs, {
@@ -735,6 +777,9 @@ async function startDevEnvironment(options: DevOptions) {
         console.log(`\n⏹️  Next.js exited (exit code: ${code})`);
       }
       // Exit all processes when Next.js exits
+      if (mockServer) {
+        mockServer.stop().catch(() => {});
+      }
       processes.forEach((proc) => {
         if (proc && !proc.killed) {
           proc.kill();
@@ -750,10 +795,16 @@ async function startDevEnvironment(options: DevOptions) {
     if (hasFunctions && !options.noFunctions) {
       console.log(`⚡ Azure Functions: http://${options.host || 'localhost'}:${functionsPort}`);
     }
+    if (mockServer) {
+      console.log(`🔌 Mock Proxy: http://${options.host || 'localhost'}:${bffTargetPort} (BFF → here)`);
+    }
     console.log('');
     if (hasFunctions && !options.noFunctions) {
       console.log('💡 Azure Functions and Next.js BFF are connected');
     }
+    if (mockServer) {
+      console.log('💡 Connector models served from mock server (Zod-generated data)');
+    }
     console.log('');
     console.log('🛑 Press Ctrl+C to stop');
     console.log('');

package/src/cli/commands/scaffold.ts

@@ -6,14 +6,23 @@
 import * as fs from "fs";
 import * as path from "path";
 import { spawn, spawnSync } from "child_process";
-import { getBackendLanguage, ensureSwallowKitProject } from "../../core/config";
-import { ModelInfo, parseModelFile, toKebabCase, toPascalCase } from "../../core/scaffold/model-parser";
+import { getBackendLanguage, getConnectorDefinition, ensureSwallowKitProject } from "../../core/config";
+import { ModelInfo, parseModelFile, toKebabCase, toPascalCase, toCamelCase } from "../../core/scaffold/model-parser";
 import {
   generateCSharpAzureFunctionsCRUD,
   generateCompactAzureFunctionsCRUD,
   generatePythonAzureFunctionsCRUD,
 } from "../../core/scaffold/functions-generator";
-import { generateCompactBFFRoutes, generateBFFCallFunction } from "../../core/scaffold/nextjs-generator";
+import {
+  generateRdbConnectorFunctionTS,
+  generateApiConnectorFunctionTS,
+  generateRdbConnectorFunctionCSharp,
+  generateApiConnectorFunctionCSharp,
+  generateRdbConnectorFunctionPython,
+  generateApiConnectorFunctionPython,
+  isReadOnlyConnector,
+} from "../../core/scaffold/connector-functions-generator";
+import { generateCompactBFFRoutes, generateBFFCallFunction, generateConnectorBFFRoutes } from "../../core/scaffold/nextjs-generator";
 import { generateOpenApiDocument } from "../../core/scaffold/openapi-generator";
 import {
   generateListPage,
@@ -23,7 +32,13 @@ import {
   generateEditPage,
 } from "../../core/scaffold/ui-generator";
 import { detectFromProject, getCommands } from "../../utils/package-manager";
-import { BackendLanguage } from "../../types";
+import {
+  BackendLanguage,
+  RdbConnectorConfig,
+  ApiConnectorConfig,
+  RdbModelConnectorConfig,
+  ApiModelConnectorConfig,
+} from "../../types";
 
 interface ScaffoldOptions {
   model: string; // モデルファイルのパス（例: "lib/models/todo.ts" or "todo"）
@@ -51,6 +66,13 @@ export async function scaffoldCommand(options: ScaffoldOptions) {
     const backendLanguage = getBackendLanguage();
     console.log(`🧠 Backend language: ${backendLanguage}`);
     
+    // コネクタモデルかどうかを判定
+    const isConnectorModel = !!modelInfo.connectorConfig;
+    if (isConnectorModel) {
+      console.log(`🔌 Connector model detected: ${modelInfo.connectorConfig!.connector}`);
+      console.log(`   Operations: ${modelInfo.connectorConfig!.operations.join(", ")}`);
+    }
+    
     // ネストスキーマ参照があれば表示
     if (modelInfo.nestedSchemaRefs.length > 0) {
       console.log(`🔗 Nested schema references detected:`);
@@ -79,18 +101,28 @@ export async function scaffoldCommand(options: ScaffoldOptions) {
     await generateCallFunctionHelper();
 
     // 6. Generate Azure Functions code
-    await generateFunctionsCode(modelInfo, functionsDir, sharedPackageName, backendLanguage);
+    if (isConnectorModel) {
+      await generateConnectorFunctionsCode(modelInfo, functionsDir, sharedPackageName, backendLanguage);
+    } else {
+      await generateFunctionsCode(modelInfo, functionsDir, sharedPackageName, backendLanguage);
 
-    if (backendLanguage !== "typescript") {
-      await generateLanguageSchemaArtifacts(relatedModels, modelInfo, functionsDir, backendLanguage);
+      if (backendLanguage !== "typescript") {
+        await generateLanguageSchemaArtifacts(relatedModels, modelInfo, functionsDir, backendLanguage);
+      }
     }
 
     // 7. Generate Next.js BFF API Routes
     const apiDir = options.apiDir || "app/api";
-    await generateBFFRoutes(modelInfo, apiDir, sharedPackageName);
+    if (isConnectorModel) {
+      await generateConnectorBFFRoutesFiles(modelInfo, apiDir, sharedPackageName);
+    } else {
+      await generateBFFRoutes(modelInfo, apiDir, sharedPackageName);
+    }
 
-    // 8. Generate Cosmos DB container Bicep file
-    await generateCosmosContainer(modelInfo);
+    // 8. Generate Cosmos DB container Bicep file (skip for connector models)
+    if (!isConnectorModel) {
+      await generateCosmosContainer(modelInfo);
+    }
 
     // 9. Generate UI components (unless --api-only)
     if (!options.apiOnly) {
@@ -263,6 +295,140 @@ async function generateFunctionsCode(
   console.log(`✅ Created: ${blueprintPath}`);
 }
 
+/**
+ * コネクタモデル用 Azure Functions コード生成
+ */
+async function generateConnectorFunctionsCode(
+  modelInfo: ModelInfo,
+  functionsDir: string,
+  sharedPackageName: string,
+  backendLanguage: BackendLanguage
+): Promise<void> {
+  console.log("\n🔌 Generating Connector Azure Functions code...");
+
+  const connectorConfig = modelInfo.connectorConfig!;
+  const connectorDef = getConnectorDefinition(connectorConfig.connector);
+
+  if (!connectorDef) {
+    throw new Error(
+      `Connector '${connectorConfig.connector}' not found in swallowkit.config.js.\n` +
+      `  Please add it to the 'connectors' section of your configuration.`
+    );
+  }
+
+  const modelKebab = toKebabCase(modelInfo.name);
+
+  if (backendLanguage === "typescript") {
+    const functionFilePath = path.join(
+      process.cwd(),
+      functionsDir,
+      "src",
+      `${modelKebab}.ts`
+    );
+    fs.mkdirSync(path.dirname(functionFilePath), { recursive: true });
+
+    let code: string;
+    if (connectorDef.type === "rdb") {
+      code = generateRdbConnectorFunctionTS(
+        modelInfo, sharedPackageName,
+        connectorDef as RdbConnectorConfig,
+        connectorConfig as RdbModelConnectorConfig
+      );
+    } else {
+      code = generateApiConnectorFunctionTS(
+        modelInfo, sharedPackageName,
+        connectorDef as ApiConnectorConfig,
+        connectorConfig as ApiModelConnectorConfig
+      );
+    }
+
+    fs.writeFileSync(functionFilePath, code, "utf-8");
+    console.log(`✅ Created: ${functionFilePath}`);
+    return;
+  }
+
+  if (backendLanguage === "csharp") {
+    const functionFilePath = path.join(
+      process.cwd(),
+      functionsDir,
+      "Connectors",
+      `${modelInfo.name}ConnectorFunctions.cs`
+    );
+    fs.mkdirSync(path.dirname(functionFilePath), { recursive: true });
+
+    let code: string;
+    if (connectorDef.type === "rdb") {
+      code = generateRdbConnectorFunctionCSharp(
+        modelInfo,
+        connectorDef as RdbConnectorConfig,
+        connectorConfig as RdbModelConnectorConfig
+      );
+    } else {
+      code = generateApiConnectorFunctionCSharp(
+        modelInfo,
+        connectorDef as ApiConnectorConfig,
+        connectorConfig as ApiModelConnectorConfig
+      );
+    }
+
+    fs.writeFileSync(functionFilePath, code, "utf-8");
+    console.log(`✅ Created: ${functionFilePath}`);
+    return;
+  }
+
+  // Python
+  const blueprintsDir = path.join(process.cwd(), functionsDir, "blueprints");
+  const blueprintPath = path.join(blueprintsDir, `${modelKebab.replace(/-/g, "_")}.py`);
+  fs.mkdirSync(blueprintsDir, { recursive: true });
+
+  let result: { blueprint: string; registration: string };
+  if (connectorDef.type === "rdb") {
+    result = generateRdbConnectorFunctionPython(
+      modelInfo,
+      connectorDef as RdbConnectorConfig,
+      connectorConfig as RdbModelConnectorConfig
+    );
+  } else {
+    result = generateApiConnectorFunctionPython(
+      modelInfo,
+      connectorDef as ApiConnectorConfig,
+      connectorConfig as ApiModelConnectorConfig
+    );
+  }
+
+  fs.writeFileSync(blueprintPath, result.blueprint, "utf-8");
+  updatePythonFunctionRegistrations(path.join(process.cwd(), functionsDir, "function_app.py"), result.registration);
+  console.log(`✅ Created: ${blueprintPath}`);
+}
+
+/**
+ * コネクタモデル用 BFF ルート生成（操作制限に対応）
+ */
+async function generateConnectorBFFRoutesFiles(
+  modelInfo: ModelInfo,
+  apiDir: string,
+  sharedPackageName: string
+): Promise<void> {
+  console.log("\n🔌 Generating Connector BFF API routes...");
+
+  const modelCamel = toCamelCase(modelInfo.name);
+  const operations = modelInfo.connectorConfig!.operations;
+
+  const listRoutePath = path.join(process.cwd(), apiDir, modelCamel, "route.ts");
+  const detailRoutePath = path.join(process.cwd(), apiDir, modelCamel, "[id]", "route.ts");
+
+  fs.mkdirSync(path.dirname(listRoutePath), { recursive: true });
+  fs.mkdirSync(path.dirname(detailRoutePath), { recursive: true });
+
+  const routes = generateConnectorBFFRoutes(modelInfo, sharedPackageName, operations);
+
+  fs.writeFileSync(listRoutePath, routes.listRoute, "utf-8");
+  fs.writeFileSync(detailRoutePath, routes.detailRoute, "utf-8");
+
+  console.log(`✅ Created: ${listRoutePath}`);
+  console.log(`✅ Created: ${detailRoutePath}`);
+}
+
 async function collectModelGraph(modelPath: string, seen = new Map<string, ModelInfo>()): Promise<ModelInfo[]> {
   const resolvedPath = path.resolve(modelPath);
   if (seen.has(resolvedPath)) {

package/src/cli/index.ts

@@ -10,6 +10,7 @@ if (process.platform === 'win32') {
 import { Command } from "commander";
 import { initCommand, devCommand, devSeedsCommand, scaffoldCommand, createModelCommand } from "./commands";
 import { provisionCommand } from "./commands/provision";
+import { addConnectorCommand } from "./commands/add-connector";
 
 const program = new Command();
 
@@ -49,10 +50,12 @@ program
   .command("create-model <names...>")
   .description("Create model template files with id, createdAt, and updatedAt fields")
   .option("--models-dir <dir>", "Models directory", "shared/models")
+  .option("--connector <name>", "Associate model with a connector defined in swallowkit.config.js")
   .action((names, options) => {
     createModelCommand({
       names,
       modelsDir: options.modelsDir,
+      connector: options.connector,
     });
   });
 
@@ -71,4 +74,17 @@ program
     });
   });
 
+program
+  .command("add-connector <name>")
+  .description("Add an external data source connector configuration")
+  .requiredOption("--type <type>", "Connector type: rdb | api")
+  .option("--provider <provider>", "RDB provider: mysql | postgres | sqlserver", "mysql")
+  .action((name, options) => {
+    addConnectorCommand({
+      name,
+      type: options.type,
+      provider: options.provider,
+    });
+  });
+
 program.parse();

package/src/core/config.ts

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
-import { BackendLanguage, SwallowKitConfig } from "../types";
+import { BackendLanguage, ConnectorDefinition, SwallowKitConfig } from "../types";
 import { detectFromProject, getCommands } from "../utils/package-manager";
 
 const VALID_BACKEND_LANGUAGES: BackendLanguage[] = ["typescript", "csharp", "python"];
@@ -81,6 +81,7 @@ function mergeConfig(defaultConfig: SwallowKitConfig, userConfig: Partial<Swallo
         ...userConfig.api?.cors,
       },
     },
+    ...(userConfig.connectors ? { connectors: userConfig.connectors } : {}),
   };
 }
 
@@ -168,9 +169,21 @@ export function getFullConfig(configPath?: string): SwallowKitConfig {
   return mergeConfig(fileConfig, envConfig);
 }
 
+/**
+ * コネクタ定義を名前で取得
+ */
+export function getConnectorDefinition(connectorName: string, configPath?: string): ConnectorDefinition | undefined {
+  const config = getFullConfig(configPath);
+  return config.connectors?.[connectorName];
+}
+
 /**
  * 設定の検証
  */
+const VALID_CONNECTOR_TYPES = ["rdb", "api"];
+const VALID_RDB_PROVIDERS = ["mysql", "postgres", "sqlserver"];
+const VALID_API_AUTH_TYPES = ["apiKey", "bearer", "oauth2"];
+
 export function validateConfig(config: SwallowKitConfig): { valid: boolean; errors: string[] } {
   const errors: string[] = [];
 
@@ -188,6 +201,34 @@ export function validateConfig(config: SwallowKitConfig): { valid: boolean; erro
     errors.push("Backend language must be one of: typescript, csharp, python");
   }
 
+  // コネクタ設定の検証
+  if (config.connectors) {
+    for (const [name, connector] of Object.entries(config.connectors)) {
+      if (!VALID_CONNECTOR_TYPES.includes(connector.type)) {
+        errors.push(`Connector '${name}': type must be one of: ${VALID_CONNECTOR_TYPES.join(", ")}`);
+        continue;
+      }
+
+      if (connector.type === "rdb") {
+        if (!connector.provider || !VALID_RDB_PROVIDERS.includes(connector.provider)) {
+          errors.push(`Connector '${name}': provider must be one of: ${VALID_RDB_PROVIDERS.join(", ")}`);
+        }
+        if (!connector.connectionEnvVar) {
+          errors.push(`Connector '${name}': connectionEnvVar is required`);
+        }
+      }
+
+      if (connector.type === "api") {
+        if (!connector.baseUrlEnvVar) {
+          errors.push(`Connector '${name}': baseUrlEnvVar is required`);
+        }
+        if (connector.auth && !VALID_API_AUTH_TYPES.includes(connector.auth.type)) {
+          errors.push(`Connector '${name}': auth.type must be one of: ${VALID_API_AUTH_TYPES.join(", ")}`);
+        }
+      }
+    }
+  }
+
   return {
     valid: errors.length === 0,
     errors,