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

package/src/__tests__/connector-model-bff.test.ts

@@ -0,0 +1,162 @@
+/**
+ * コネクタ関連のモデルパーサーおよびBFFジェネレーターのテスト
+ */
+
+import { parseConnectorConfig } from "../core/scaffold/model-parser";
+import { generateConnectorBFFRoutes } from "../core/scaffold/nextjs-generator";
+import {
+  createRdbConnectorModelInfo,
+  createApiConnectorModelInfo,
+} from "./fixtures";
+
+// ─── parseConnectorConfig ───────────────────────────────────
+
+describe("parseConnectorConfig", () => {
+  it("parses RDB connector config from model content", () => {
+    const content = `
+import { z } from 'zod/v4';
+export const User = z.object({ id: z.string(), name: z.string() });
+export type User = z.infer<typeof User>;
+export const displayName = 'User';
+
+export const connectorConfig = {
+  connector: 'mysql',
+  operations: ['getAll', 'getById'] as const,
+  table: 'users',
+  idColumn: 'id',
+};
+`;
+    const result = parseConnectorConfig(content);
+    expect(result).toBeDefined();
+    expect(result!.connector).toBe("mysql");
+    expect(result!.operations).toEqual(["getAll", "getById"]);
+    expect((result as any).table).toBe("users");
+    expect((result as any).idColumn).toBe("id");
+  });
+
+  it("parses API connector config from model content", () => {
+    const content = `
+export const connectorConfig = {
+  connector: 'backlog',
+  operations: ['getAll', 'getById', 'create', 'update'] as const,
+  endpoints: {
+    getAll: 'GET /issues',
+    getById: 'GET /issues/{id}',
+    create: 'POST /issues',
+    update: 'PATCH /issues/{id}',
+  },
+};
+`;
+    const result = parseConnectorConfig(content);
+    expect(result).toBeDefined();
+    expect(result!.connector).toBe("backlog");
+    expect(result!.operations).toEqual(["getAll", "getById", "create", "update"]);
+    expect((result as any).endpoints).toEqual({
+      getAll: "GET /issues",
+      getById: "GET /issues/{id}",
+      create: "POST /issues",
+      update: "PATCH /issues/{id}",
+    });
+  });
+
+  it("returns undefined when no connectorConfig export exists", () => {
+    const content = `
+export const Todo = z.object({ id: z.string() });
+export type Todo = z.infer<typeof Todo>;
+export const displayName = 'Todo';
+`;
+    const result = parseConnectorConfig(content);
+    expect(result).toBeUndefined();
+  });
+
+  it("returns undefined when connector name is missing", () => {
+    const content = `
+export const connectorConfig = {
+  operations: ['getAll'],
+};
+`;
+    const result = parseConnectorConfig(content);
+    expect(result).toBeUndefined();
+  });
+
+  it("handles single quotes and double quotes", () => {
+    const content = `
+export const connectorConfig = {
+  connector: "postgres",
+  operations: ["getAll", "getById"] as const,
+  table: "items",
+};
+`;
+    const result = parseConnectorConfig(content);
+    expect(result).toBeDefined();
+    expect(result!.connector).toBe("postgres");
+    expect((result as any).table).toBe("items");
+  });
+
+  it("handles API connector without endpoints", () => {
+    const content = `
+export const connectorConfig = {
+  connector: 'external-api',
+  operations: ['getAll'] as const,
+};
+`;
+    const result = parseConnectorConfig(content);
+    expect(result).toBeDefined();
+    expect(result!.connector).toBe("external-api");
+    expect(result!.operations).toEqual(["getAll"]);
+    expect((result as any).table).toBeUndefined();
+    expect((result as any).endpoints).toBeUndefined();
+  });
+});
+
+// ─── generateConnectorBFFRoutes ─────────────────────────────
+
+describe("generateConnectorBFFRoutes", () => {
+  it("generates read-only BFF routes for RDB connector", () => {
+    const model = createRdbConnectorModelInfo();
+    const routes = generateConnectorBFFRoutes(model, "@myapp/shared", ["getAll", "getById"]);
+
+    expect(routes.listRoute).toContain("export async function GET");
+    expect(routes.listRoute).toContain("/api/user");
+    expect(routes.listRoute).not.toContain("export async function POST");
+
+    expect(routes.detailRoute).toContain("export async function GET");
+    expect(routes.detailRoute).not.toContain("export async function PUT");
+    expect(routes.detailRoute).not.toContain("export async function DELETE");
+  });
+
+  it("generates read-write BFF routes for API connector", () => {
+    const model = createApiConnectorModelInfo();
+    const routes = generateConnectorBFFRoutes(model, "@myapp/shared", ["getAll", "getById", "create", "update"]);
+
+    expect(routes.listRoute).toContain("export async function GET");
+    expect(routes.listRoute).toContain("export async function POST");
+
+    expect(routes.detailRoute).toContain("export async function GET");
+    expect(routes.detailRoute).toContain("export async function PUT");
+  });
+
+  it("does not generate DELETE route when delete is not in operations", () => {
+    const model = createApiConnectorModelInfo();
+    const routes = generateConnectorBFFRoutes(model, "@myapp/shared", ["getAll", "getById", "create", "update"]);
+
+    expect(routes.detailRoute).not.toContain("export async function DELETE");
+  });
+
+  it("uses correct route paths based on model name", () => {
+    const model = createApiConnectorModelInfo();
+    const routes = generateConnectorBFFRoutes(model, "@myapp/shared", ["getAll", "getById"]);
+
+    // BacklogIssue → backlogIssue route
+    expect(routes.listRoute).toContain("backlogIssue");
+    expect(routes.detailRoute).toContain("backlogIssue");
+  });
+
+  it("imports from shared package", () => {
+    const model = createRdbConnectorModelInfo();
+    const routes = generateConnectorBFFRoutes(model, "@myapp/shared", ["getAll", "getById"]);
+
+    expect(routes.listRoute).toContain("@myapp/shared");
+    expect(routes.detailRoute).toContain("@myapp/shared");
+  });
+});

package/src/__tests__/fixtures.ts

@@ -25,6 +25,66 @@ export function createBasicModelInfo(overrides?: Partial<ModelInfo>): ModelInfo
   };
 }
 
+/**
+ * RDB コネクタ (read-only) 付きの ModelInfo フィクスチャ
+ */
+export function createRdbConnectorModelInfo(overrides?: Partial<ModelInfo>): ModelInfo {
+  return createBasicModelInfo({
+    name: "User",
+    displayName: "User",
+    schemaName: "userSchema",
+    filePath: "/models/user.ts",
+    fields: [
+      { name: "id", type: "string", isOptional: false, isArray: false },
+      { name: "employeeCode", type: "string", isOptional: false, isArray: false },
+      { name: "name", type: "string", isOptional: false, isArray: false },
+      { name: "email", type: "string", isOptional: false, isArray: false },
+      { name: "department", type: "string", isOptional: true, isArray: false },
+      { name: "createdAt", type: "string", isOptional: true, isArray: false },
+      { name: "updatedAt", type: "string", isOptional: true, isArray: false },
+    ],
+    connectorConfig: {
+      connector: "mysql",
+      operations: ["getAll", "getById"],
+      table: "users",
+      idColumn: "id",
+    },
+    ...overrides,
+  });
+}
+
+/**
+ * API コネクタ (read-write) 付きの ModelInfo フィクスチャ
+ */
+export function createApiConnectorModelInfo(overrides?: Partial<ModelInfo>): ModelInfo {
+  return createBasicModelInfo({
+    name: "BacklogIssue",
+    displayName: "BacklogIssue",
+    schemaName: "backlogIssueSchema",
+    filePath: "/models/backlog-issue.ts",
+    fields: [
+      { name: "id", type: "string", isOptional: false, isArray: false },
+      { name: "projectId", type: "string", isOptional: false, isArray: false },
+      { name: "issueKey", type: "string", isOptional: false, isArray: false },
+      { name: "summary", type: "string", isOptional: false, isArray: false },
+      { name: "description", type: "string", isOptional: true, isArray: false },
+      { name: "createdAt", type: "string", isOptional: true, isArray: false },
+      { name: "updatedAt", type: "string", isOptional: true, isArray: false },
+    ],
+    connectorConfig: {
+      connector: "backlog",
+      operations: ["getAll", "getById", "create", "update"],
+      endpoints: {
+        getAll: "GET /issues",
+        getById: "GET /issues/{id}",
+        create: "POST /issues",
+        update: "PATCH /issues/{id}",
+      },
+    },
+    ...overrides,
+  });
+}
+
 /**
  * 外部キーを含む ModelInfo フィクスチャ
  */

package/src/__tests__/scaffold.test.ts

@@ -2,12 +2,12 @@ import * as path from "path";
 import { getCSharpSchemaArtifactPruneTargets, getOpenApiGeneratorArgs } from "../cli/commands/scaffold";
 
 describe("getOpenApiGeneratorArgs", () => {
-  it("keeps supporting files for C# model generation", () => {
+  it("omits supportingFiles for C# model generation to avoid Polly version conflicts", () => {
     const args = getOpenApiGeneratorArgs("spec.json", "out", "csharp");
     const globalPropertyIndex = args.indexOf("--global-property");
 
     expect(globalPropertyIndex).toBeGreaterThanOrEqual(0);
-    expect(args[globalPropertyIndex + 1]).toBe("models,supportingFiles,apis=false,modelDocs=false,modelTests=false");
+    expect(args[globalPropertyIndex + 1]).toBe("models,apis=false,modelDocs=false,modelTests=false");
   });
 
   it("continues omitting supporting files for Python model generation", () => {

package/src/__tests__/zod-mock-generator.test.ts

@@ -0,0 +1,132 @@
+/**
+ * Zod モックデータジェネレーターのテスト
+ */
+
+import { generateMockDocument, generateMockDocuments } from "../core/mock/zod-mock-generator";
+import {
+  createBasicModelInfo,
+  createRdbConnectorModelInfo,
+  createApiConnectorModelInfo,
+  createModelInfoWithEnum,
+} from "./fixtures";
+
+describe("generateMockDocument", () => {
+  it("generates a document with all model fields", () => {
+    const model = createBasicModelInfo();
+    const doc = generateMockDocument(model, 1);
+
+    expect(doc).toHaveProperty("id");
+    expect(doc).toHaveProperty("title");
+    expect(doc).toHaveProperty("description");
+    expect(doc).toHaveProperty("completed");
+    expect(doc).toHaveProperty("createdAt");
+    expect(doc).toHaveProperty("updatedAt");
+  });
+
+  it("generates id using model name and index", () => {
+    const model = createBasicModelInfo();
+    const doc = generateMockDocument(model, 1);
+    expect(doc.id).toBe("todo-001");
+  });
+
+  it("generates different values for different indices", () => {
+    const model = createBasicModelInfo();
+    const doc1 = generateMockDocument(model, 1);
+    const doc2 = generateMockDocument(model, 2);
+    expect(doc1.id).not.toBe(doc2.id);
+    expect(doc1.title).not.toBe(doc2.title);
+  });
+
+  it("generates boolean fields with alternating values", () => {
+    const model = createBasicModelInfo();
+    const doc1 = generateMockDocument(model, 1);
+    const doc2 = generateMockDocument(model, 2);
+    expect(typeof doc1.completed).toBe("boolean");
+    expect(doc1.completed).not.toBe(doc2.completed);
+  });
+
+  it("generates ISO date strings for *At fields", () => {
+    const model = createBasicModelInfo();
+    const doc = generateMockDocument(model, 1);
+    expect(typeof doc.createdAt).toBe("string");
+    // Should be parseable as ISO date
+    expect(new Date(doc.createdAt as string).toISOString()).toBe(doc.createdAt);
+  });
+
+  it("generates string values for title fields", () => {
+    const model = createBasicModelInfo();
+    const doc = generateMockDocument(model, 1);
+    expect(typeof doc.title).toBe("string");
+    expect(doc.title).toContain("1");
+  });
+
+  it("handles optional string fields", () => {
+    const model = createBasicModelInfo();
+    const doc = generateMockDocument(model, 1);
+    // description is optional but still gets a value for mock data
+    expect(typeof doc.description).toBe("string");
+  });
+
+  it("generates email-like values for email fields", () => {
+    const model = createRdbConnectorModelInfo();
+    const doc = generateMockDocument(model, 1);
+    expect(doc.email).toContain("@example.com");
+  });
+
+  it("generates department values for department fields", () => {
+    const model = createRdbConnectorModelInfo();
+    const doc = generateMockDocument(model, 1);
+    expect(typeof doc.department).toBe("string");
+    // Should be one of the department names
+    expect(["Engineering", "Sales", "Marketing", "Support", "HR"]).toContain(doc.department);
+  });
+
+  it("cycles enum values across indices", () => {
+    const model = createModelInfoWithEnum();
+    const doc1 = generateMockDocument(model, 1);
+    const doc2 = generateMockDocument(model, 2);
+    const doc3 = generateMockDocument(model, 3);
+    expect(doc1.status).toBe("open");
+    expect(doc2.status).toBe("in_progress");
+    expect(doc3.status).toBe("closed");
+  });
+
+  it("generates foreign key references for *Id fields", () => {
+    const model = createApiConnectorModelInfo();
+    const doc = generateMockDocument(model, 1);
+    expect(typeof doc.projectId).toBe("string");
+    expect(doc.projectId).toContain("project-");
+  });
+});
+
+describe("generateMockDocuments", () => {
+  it("generates the specified number of documents", () => {
+    const model = createBasicModelInfo();
+    const docs = generateMockDocuments(model, 3);
+    expect(docs).toHaveLength(3);
+  });
+
+  it("defaults to 5 documents", () => {
+    const model = createBasicModelInfo();
+    const docs = generateMockDocuments(model);
+    expect(docs).toHaveLength(5);
+  });
+
+  it("generates unique ids for each document", () => {
+    const model = createBasicModelInfo();
+    const docs = generateMockDocuments(model, 5);
+    const ids = docs.map((d) => d.id);
+    const uniqueIds = new Set(ids);
+    expect(uniqueIds.size).toBe(5);
+  });
+
+  it("works with connector models", () => {
+    const model = createRdbConnectorModelInfo();
+    const docs = generateMockDocuments(model, 3);
+    expect(docs).toHaveLength(3);
+    // All should have email fields with @example.com
+    for (const doc of docs) {
+      expect(doc.email).toContain("@example.com");
+    }
+  });
+});

package/src/cli/commands/add-connector.ts

@@ -0,0 +1,157 @@
+/**
+ * SwallowKit Add-Connector コマンド
+ * swallowkit.config.js にコネクタ設定を追加する
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { ensureSwallowKitProject } from "../../core/config";
+import { ConnectorDefinition } from "../../types";
+
+interface AddConnectorOptions {
+  name: string;
+  type: "rdb" | "api";
+  provider?: "mysql" | "postgres" | "sqlserver";
+}
+
+/**
+ * add-connector コマンド
+ */
+export async function addConnectorCommand(options: AddConnectorOptions) {
+  ensureSwallowKitProject("add-connector");
+
+  console.log(`🔌 SwallowKit Add-Connector: Adding '${options.name}' connector...\n`);
+
+  const configPath = findConfigFile();
+  if (!configPath) {
+    console.error("❌ swallowkit.config.js not found. Run 'swallowkit init' first.");
+    process.exit(1);
+  }
+
+  // Build connector definition
+  const connectorDef = buildConnectorDefinition(options);
+
+  // Update config file
+  updateConfigWithConnector(configPath, options.name, connectorDef, options);
+
+  console.log(`\n✅ Connector '${options.name}' added successfully!`);
+  console.log("\n📝 Next steps:");
+  console.log(`  1. Review the connector settings in ${configPath}`);
+  console.log(`  2. Set the required environment variables in functions/local.settings.json`);
+  console.log(`  3. Create models with: npx swallowkit create-model <name> --connector=${options.name}`);
+}
+
+function findConfigFile(): string | null {
+  const candidates = ["swallowkit.config.js", "swallowkit.config.json", ".swallowkitrc.json"];
+  for (const candidate of candidates) {
+    const fullPath = path.resolve(process.cwd(), candidate);
+    if (fs.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+
+function buildConnectorDefinition(options: AddConnectorOptions): ConnectorDefinition {
+  const name = options.name.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+
+  if (options.type === "rdb") {
+    return {
+      type: "rdb",
+      provider: options.provider || "mysql",
+      connectionEnvVar: `${name}_CONNECTION_STRING`,
+    };
+  }
+
+  return {
+    type: "api",
+    baseUrlEnvVar: `${name}_API_BASE_URL`,
+    auth: {
+      type: "apiKey",
+      envVar: `${name}_API_KEY`,
+      placement: "query",
+      paramName: "apiKey",
+    },
+  };
+}
+
+/**
+ * swallowkit.config.js にコネクタ設定を追加
+ */
+export function updateConfigWithConnector(
+  configPath: string,
+  connectorName: string,
+  connectorDef: ConnectorDefinition,
+  options: AddConnectorOptions
+): void {
+  const content = fs.readFileSync(configPath, "utf-8");
+
+  if (configPath.endsWith(".json")) {
+    // JSON config
+    const config = JSON.parse(content);
+    if (!config.connectors) {
+      config.connectors = {};
+    }
+    config.connectors[connectorName] = connectorDef;
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+    console.log(`✅ Updated: ${configPath}`);
+    return;
+  }
+
+  // JS config — append connectors section
+  if (content.includes("connectors:") || content.includes("connectors :")) {
+    console.log(`⚠️  'connectors' section already exists in ${configPath}. Please add the connector manually:`);
+    console.log(formatConnectorSnippet(connectorName, connectorDef, options));
+    return;
+  }
+
+  // Find the last property before the closing of module.exports
+  const closingBraceIdx = content.lastIndexOf("}");
+  if (closingBraceIdx === -1) {
+    console.error("❌ Could not parse config file structure. Please add the connector manually:");
+    console.log(formatConnectorSnippet(connectorName, connectorDef, options));
+    return;
+  }
+
+  // Check if we need a comma before inserting
+  const beforeClosing = content.substring(0, closingBraceIdx).trimEnd();
+  const needsComma = !beforeClosing.endsWith(",") && !beforeClosing.endsWith("{");
+
+  const connectorBlock = generateConnectorJSBlock(connectorName, connectorDef, options);
+  const insertion = `${needsComma ? "," : ""}\n  // コネクタ定義\n  connectors: {\n${connectorBlock}\n  },\n`;
+
+  const newContent = content.substring(0, closingBraceIdx) + insertion + content.substring(closingBraceIdx);
+  fs.writeFileSync(configPath, newContent, "utf-8");
+  console.log(`✅ Updated: ${configPath}`);
+}
+
+function generateConnectorJSBlock(name: string, def: ConnectorDefinition, options: AddConnectorOptions): string {
+  if (def.type === "rdb") {
+    return `    ${name}: {
+      type: 'rdb',
+      provider: '${(def as any).provider}',
+      connectionEnvVar: '${def.connectionEnvVar}',
+    },`;
+  }
+
+  const apiDef = def as any;
+  let authBlock = "";
+  if (apiDef.auth) {
+    authBlock = `
+      auth: {
+        type: '${apiDef.auth.type}',
+        envVar: '${apiDef.auth.envVar}',
+        placement: '${apiDef.auth.placement || "query"}',
+        paramName: '${apiDef.auth.paramName || "apiKey"}',
+      },`;
+  }
+
+  return `    ${name}: {
+      type: 'api',
+      baseUrlEnvVar: '${apiDef.baseUrlEnvVar}',${authBlock}
+    },`;
+}
+
+function formatConnectorSnippet(name: string, def: ConnectorDefinition, options: AddConnectorOptions): string {
+  return `\n  ${name}: ${JSON.stringify(def, null, 4)}\n`;
+}

package/src/cli/commands/create-model.ts

@@ -7,12 +7,13 @@ import * as fs from "fs";
 import * as path from "path";
 import * as readline from "readline";
 import { toPascalCase } from "../../core/scaffold/model-parser";
-import { ensureSwallowKitProject } from "../../core/config";
+import { ensureSwallowKitProject, loadConfig } from "../../core/config";
 import { detectFromProject, getCommands } from "../../utils/package-manager";
 
 interface CreateModelOptions {
   names: string[]; // モデル名のリスト（例: ["todo", "user", "post"]）
   modelsDir?: string; // モデルディレクトリ（デフォルト: "shared/models"）
+  connector?: string; // コネクタ名（例: "mysql", "backlog"）
 }
 
 /**
@@ -38,6 +39,58 @@ export const displayName = '${pascalName}';
 `;
 }
 
+/**
+ * コネクタ付きモデルテンプレートを生成
+ */
+function generateConnectorModelTemplate(modelName: string, connectorName: string, connectorType: 'rdb' | 'api'): string {
+  const pascalName = toPascalCase(modelName);
+  const kebabName = modelName.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+  const pluralName = kebabName + 's';
+
+  const schema = `import { z } from 'zod/v4';
+
+// ${pascalName} model (Zod official pattern: same name for value and type)
+export const ${pascalName} = z.object({
+  id: z.string(),
+  name: z.string().min(1),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+
+export type ${pascalName} = z.infer<typeof ${pascalName}>;
+
+// Display name for UI
+export const displayName = '${pascalName}';
+`;
+
+  if (connectorType === 'rdb') {
+    return schema + `
+// SwallowKit Connector Metadata
+export const connectorConfig = {
+  connector: '${connectorName}',
+  operations: ['getAll', 'getById'] as const,
+  table: '${pluralName}',
+  idColumn: 'id',
+};
+`;
+  }
+
+  // API connector
+  return schema + `
+// SwallowKit Connector Metadata
+export const connectorConfig = {
+  connector: '${connectorName}',
+  operations: ['getAll', 'getById', 'create', 'update'] as const,
+  endpoints: {
+    getAll: 'GET /${pluralName}',
+    getById: 'GET /${pluralName}/{id}',
+    create: 'POST /${pluralName}',
+    update: 'PATCH /${pluralName}/{id}',
+  },
+};
+`;
+}
+
 /**
  * ユーザーに確認を求める
  */
@@ -64,6 +117,21 @@ export async function createModelCommand(options: CreateModelOptions) {
 
   console.log("🏗️  SwallowKit Create-Model: Generating model templates...\n");
 
+  // コネクタ指定時はコネクタの存在を検証
+  let connectorType: 'rdb' | 'api' | undefined;
+  if (options.connector) {
+    const config = loadConfig();
+    const connectorDef = config.connectors?.[options.connector];
+    if (!connectorDef) {
+      console.error(`❌ Connector '${options.connector}' not found in swallowkit.config.js.`);
+      console.error(`   Available connectors: ${Object.keys(config.connectors || {}).join(', ') || '(none)'}`);
+      console.error(`   Run 'swallowkit add-connector ${options.connector} --type=<rdb|api>' first.`);
+      process.exit(1);
+    }
+    connectorType = connectorDef.type;
+    console.log(`🔌 Using connector: ${options.connector} (${connectorType})\n`);
+  }
+
   const modelsDir = options.modelsDir || "shared/models";
   
   // shared/models ディレクトリが存在しなければ作成
@@ -94,7 +162,9 @@ export async function createModelCommand(options: CreateModelOptions) {
     }
 
     // モデルファイルを生成
-    const content = generateModelTemplate(name);
+    const content = options.connector && connectorType
+      ? generateConnectorModelTemplate(name, options.connector, connectorType)
+      : generateModelTemplate(name);
     fs.writeFileSync(filePath, content);
     console.log(`✅ Created: ${filePath}`);
     created.push(kebabName);