swallowkit 1.0.0-beta.2 → 1.0.0-beta.20

package/src/__tests__/package-manager.test.ts

@@ -0,0 +1,189 @@
+import {
+  getCommands,
+  getWorkspaceConfig,
+  getCiSetupStep,
+  getAzurePipelinesSetup,
+  getBuildScript,
+  getFunctionsPrestart,
+  getFunctionsStartScript,
+  spawnArgs,
+} from "../utils/package-manager";
+
+describe("getCommands", () => {
+  describe("pnpm", () => {
+    const cmds = getCommands("pnpm");
+
+    it("returns correct name", () => {
+      expect(cmds.name).toBe("pnpm");
+    });
+
+    it("returns correct install command", () => {
+      expect(cmds.install).toBe("pnpm install");
+    });
+
+    it("returns correct ci command", () => {
+      expect(cmds.ci).toBe("pnpm install --frozen-lockfile");
+    });
+
+    it("returns correct add command", () => {
+      expect(cmds.add).toBe("pnpm add");
+    });
+
+    it("returns correct addDev command", () => {
+      expect(cmds.addDev).toBe("pnpm add -D");
+    });
+
+    it("returns correct exec command", () => {
+      expect(cmds.exec).toBe("pnpm exec");
+    });
+
+    it("returns correct dlx command", () => {
+      expect(cmds.dlx).toBe("pnpm dlx");
+    });
+
+    it("returns correct runFilter for workspace", () => {
+      expect(cmds.runFilter("shared")).toBe("pnpm run --filter shared");
+    });
+
+    it("returns --use-pnpm flag for create-next-app", () => {
+      expect(cmds.createNextAppFlag).toBe("--use-pnpm");
+    });
+  });
+
+  describe("npm", () => {
+    const cmds = getCommands("npm");
+
+    it("returns correct name", () => {
+      expect(cmds.name).toBe("npm");
+    });
+
+    it("returns correct install command", () => {
+      expect(cmds.install).toBe("npm install");
+    });
+
+    it("returns correct ci command", () => {
+      expect(cmds.ci).toBe("npm ci");
+    });
+
+    it("returns correct add command", () => {
+      expect(cmds.add).toBe("npm install");
+    });
+
+    it("returns correct addDev command", () => {
+      expect(cmds.addDev).toBe("npm install -D");
+    });
+
+    it("returns correct exec command", () => {
+      expect(cmds.exec).toBe("npx");
+    });
+
+    it("returns correct dlx command", () => {
+      expect(cmds.dlx).toBe("npx");
+    });
+
+    it("returns correct runFilter for workspace", () => {
+      expect(cmds.runFilter("shared")).toBe("npm run --workspace=shared");
+    });
+
+    it("returns null for create-next-app flag", () => {
+      expect(cmds.createNextAppFlag).toBeNull();
+    });
+  });
+});
+
+describe("getWorkspaceConfig", () => {
+  it("returns pnpm-workspace.yaml config for pnpm", () => {
+    const config = getWorkspaceConfig("pnpm", ["packages/*", "apps/*"]);
+    expect(config.type).toBe("file");
+    if (config.type === "file") {
+      expect(config.filename).toBe("pnpm-workspace.yaml");
+      expect(config.content).toContain("packages:");
+      expect(config.content).toContain("  - packages/*");
+      expect(config.content).toContain("  - apps/*");
+    }
+  });
+
+  it("returns packageJson config for npm", () => {
+    const config = getWorkspaceConfig("npm", ["packages/*", "apps/*"]);
+    expect(config.type).toBe("packageJson");
+    if (config.type === "packageJson") {
+      expect(config.field).toBe("workspaces");
+      expect(config.value).toEqual(["packages/*", "apps/*"]);
+    }
+  });
+});
+
+describe("getCiSetupStep", () => {
+  it("returns pnpm setup step for pnpm", () => {
+    const step = getCiSetupStep("pnpm");
+    expect(step).toContain("pnpm/action-setup");
+  });
+
+  it("returns empty string for npm", () => {
+    expect(getCiSetupStep("npm")).toBe("");
+  });
+});
+
+describe("getAzurePipelinesSetup", () => {
+  it("returns corepack step for pnpm", () => {
+    const step = getAzurePipelinesSetup("pnpm");
+    expect(step).toContain("corepack enable");
+    expect(step).toContain("pnpm");
+  });
+
+  it("returns empty string for npm", () => {
+    expect(getAzurePipelinesSetup("npm")).toBe("");
+  });
+});
+
+describe("getBuildScript", () => {
+  it("uses pnpm run --filter for pnpm", () => {
+    expect(getBuildScript("pnpm")).toContain("pnpm run --filter shared build");
+    expect(getBuildScript("pnpm")).toContain("fs.cpSync");
+  });
+
+  it("uses npm run --workspace for npm", () => {
+    expect(getBuildScript("npm")).toContain("npm run --workspace=shared build");
+    expect(getBuildScript("npm")).toContain("fs.cpSync");
+  });
+});
+
+describe("getFunctionsPrestart", () => {
+  it("uses pnpm run build for pnpm", () => {
+    expect(getFunctionsPrestart("pnpm")).toBe("pnpm run build");
+  });
+
+  it("uses npm run build for npm", () => {
+    expect(getFunctionsPrestart("npm")).toBe("npm run build");
+  });
+});
+
+describe("getFunctionsStartScript", () => {
+  it("uses pnpm start for pnpm", () => {
+    expect(getFunctionsStartScript("pnpm")).toContain("pnpm start");
+  });
+
+  it("uses npm start for npm", () => {
+    expect(getFunctionsStartScript("npm")).toContain("npm start");
+  });
+
+  it("uses func start for csharp backends", () => {
+    expect(getFunctionsStartScript("pnpm", "csharp")).toBe("cd functions && func start");
+  });
+
+  it("uses func start for python backends", () => {
+    expect(getFunctionsStartScript("npm", "python")).toBe("cd functions && func start");
+  });
+});
+
+describe("spawnArgs", () => {
+  it("returns cmd and args for pnpm", () => {
+    const result = spawnArgs("pnpm", ["add", "next@latest"]);
+    expect(result).toEqual({ cmd: "pnpm", args: ["add", "next@latest"] });
+  });
+
+  it("returns cmd and args for npm", () => {
+    const result = spawnArgs("npm", ["install", "next@latest"]);
+    expect(result).toEqual({ cmd: "npm", args: ["install", "next@latest"] });
+  });
+});

package/src/__tests__/scaffold.test.ts

@@ -0,0 +1,39 @@
+import * as path from "path";
+import { getCSharpSchemaArtifactPruneTargets, getOpenApiGeneratorArgs } from "../cli/commands/scaffold";
+
+describe("getOpenApiGeneratorArgs", () => {
+  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,apis=false,modelDocs=false,modelTests=false");
+  });
+
+  it("continues omitting supporting files for Python model generation", () => {
+    const args = getOpenApiGeneratorArgs("spec.json", "out", "python");
+    const globalPropertyIndex = args.indexOf("--global-property");
+
+    expect(globalPropertyIndex).toBeGreaterThanOrEqual(0);
+    expect(args[globalPropertyIndex + 1]).toBe(
+      "models,apis=false,supportingFiles=false,modelDocs=false,modelTests=false"
+    );
+  });
+
+  it("prunes extra C# artifacts that pull in unused dependencies", () => {
+    const targets = getCSharpSchemaArtifactPruneTargets("C:\\temp\\generated\\csharp-models");
+
+    expect(targets).toEqual([
+      path.join("C:\\temp\\generated\\csharp-models", "src", "SwallowKitBackendModels.Test"),
+      path.join("C:\\temp\\generated\\csharp-models", "src", "SwallowKitBackendModels", "Api"),
+      path.join("C:\\temp\\generated\\csharp-models", "src", "SwallowKitBackendModels", "Extensions"),
+    ]);
+  });
+
+  it("keeps only Option.cs from generated C# client helpers", () => {
+    const args = getOpenApiGeneratorArgs("spec.json", "out", "csharp");
+
+    expect(args).toContain("csharp");
+    expect(getCSharpSchemaArtifactPruneTargets("C:\\temp\\generated\\csharp-models")).toHaveLength(3);
+  });
+});

package/src/__tests__/string-utils.test.ts

@@ -0,0 +1,75 @@
+import { toPascalCase, toCamelCase, toKebabCase } from "../core/scaffold/model-parser";
+
+describe("toPascalCase", () => {
+  it("converts kebab-case to PascalCase", () => {
+    expect(toPascalCase("todo-item")).toBe("TodoItem");
+  });
+
+  it("converts snake_case to PascalCase", () => {
+    expect(toPascalCase("todo_item")).toBe("TodoItem");
+  });
+
+  it("handles single word", () => {
+    expect(toPascalCase("todo")).toBe("Todo");
+  });
+
+  it("handles already PascalCase (no separators)", () => {
+    expect(toPascalCase("Todo")).toBe("Todo");
+  });
+
+  it("handles multiple segments", () => {
+    expect(toPascalCase("my-cool-model")).toBe("MyCoolModel");
+  });
+
+  it("handles empty string", () => {
+    expect(toPascalCase("")).toBe("");
+  });
+});
+
+describe("toCamelCase", () => {
+  it("converts kebab-case to camelCase", () => {
+    expect(toCamelCase("todo-item")).toBe("todoItem");
+  });
+
+  it("converts snake_case to camelCase", () => {
+    expect(toCamelCase("todo_item")).toBe("todoItem");
+  });
+
+  it("handles single word", () => {
+    expect(toCamelCase("Todo")).toBe("todo");
+  });
+
+  it("handles PascalCase input (lowercases first char)", () => {
+    expect(toCamelCase("TodoItem")).toBe("todoItem");
+  });
+
+  it("handles empty string", () => {
+    expect(toCamelCase("")).toBe("");
+  });
+});
+
+describe("toKebabCase", () => {
+  it("converts PascalCase to kebab-case", () => {
+    expect(toKebabCase("TodoItem")).toBe("todo-item");
+  });
+
+  it("converts camelCase to kebab-case", () => {
+    expect(toKebabCase("todoItem")).toBe("todo-item");
+  });
+
+  it("handles single lowercase word", () => {
+    expect(toKebabCase("todo")).toBe("todo");
+  });
+
+  it("handles multiple capitals", () => {
+    expect(toKebabCase("MyCoolModel")).toBe("my-cool-model");
+  });
+
+  it("handles already kebab-case", () => {
+    expect(toKebabCase("todo-item")).toBe("todo-item");
+  });
+
+  it("handles empty string", () => {
+    expect(toKebabCase("")).toBe("");
+  });
+});

package/src/__tests__/ui-generator.test.ts

@@ -0,0 +1,144 @@
+import {
+  generateListPage,
+  generateDetailPage,
+  generateFormComponent,
+  generateNewPage,
+  generateEditPage,
+} from "../core/scaffold/ui-generator";
+import {
+  createBasicModelInfo,
+  createModelInfoWithForeignKey,
+  createModelInfoWithEnum,
+} from "./fixtures";
+
+describe("generateListPage", () => {
+  it("generates list page for basic model (snapshot)", () => {
+    const model = createBasicModelInfo();
+    const code = generateListPage(model, "@myapp/shared");
+    expect(code).toMatchSnapshot();
+  });
+
+  it("contains 'use client' directive", () => {
+    const model = createBasicModelInfo();
+    const code = generateListPage(model, "@myapp/shared");
+    expect(code).toContain("'use client'");
+  });
+
+  it("imports schema from shared package", () => {
+    const model = createBasicModelInfo();
+    const code = generateListPage(model, "@myapp/shared");
+    expect(code).toContain("@myapp/shared");
+  });
+
+  it("fetches from correct API endpoint", () => {
+    const model = createBasicModelInfo();
+    const code = generateListPage(model, "@myapp/shared");
+    expect(code).toContain("/api/todo");
+  });
+
+  it("displays up to 3 non-id fields", () => {
+    const model = createBasicModelInfo();
+    const code = generateListPage(model, "@myapp/shared");
+    // title, description, completed — first 3 non-id fields
+    expect(code).toContain("title");
+  });
+
+  it("handles foreign key fields", () => {
+    const model = createModelInfoWithForeignKey();
+    const code = generateListPage(model, "@myapp/shared");
+    expect(code).toContain("categoryId");
+  });
+});
+
+describe("generateDetailPage", () => {
+  it("generates detail page (snapshot)", () => {
+    const model = createBasicModelInfo();
+    const code = generateDetailPage(model, "@myapp/shared");
+    expect(code).toMatchSnapshot();
+  });
+
+  it("contains 'use client' directive", () => {
+    const model = createBasicModelInfo();
+    const code = generateDetailPage(model, "@myapp/shared");
+    expect(code).toContain("'use client'");
+  });
+
+  it("includes delete button", () => {
+    const model = createBasicModelInfo();
+    const code = generateDetailPage(model, "@myapp/shared");
+    expect(code).toContain("DELETE");
+  });
+});
+
+describe("generateFormComponent", () => {
+  it("generates form component (snapshot)", () => {
+    const model = createBasicModelInfo();
+    const code = generateFormComponent(model, "@myapp/shared");
+    expect(code).toMatchSnapshot();
+  });
+
+  it("generates inputs for non-managed fields", () => {
+    const model = createBasicModelInfo();
+    const code = generateFormComponent(model, "@myapp/shared");
+    // title and description should have form inputs
+    expect(code).toContain("title");
+    expect(code).toContain("description");
+  });
+
+  it("generates enum select for enum fields", () => {
+    const model = createModelInfoWithEnum();
+    const code = generateFormComponent(model, "@myapp/shared");
+    expect(code).toContain("select");
+    expect(code).toContain("open");
+    expect(code).toContain("in_progress");
+    expect(code).toContain("closed");
+  });
+
+  it("generates checkbox for boolean fields", () => {
+    const model = createBasicModelInfo();
+    const code = generateFormComponent(model, "@myapp/shared");
+    expect(code).toContain("checkbox");
+  });
+});
+
+describe("generateNewPage", () => {
+  it("generates new page (snapshot)", () => {
+    const model = createBasicModelInfo();
+    const code = generateNewPage(model);
+    expect(code).toMatchSnapshot();
+  });
+
+  it("contains form component reference", () => {
+    const model = createBasicModelInfo();
+    const code = generateNewPage(model);
+    expect(code).toContain("Form");
+  });
+
+  it("references the form component", () => {
+    const model = createBasicModelInfo();
+    const code = generateNewPage(model);
+    expect(code).toContain("TodoForm");
+    expect(code).toContain("Create New Todo");
+  });
+});
+
+describe("generateEditPage", () => {
+  it("generates edit page (snapshot)", () => {
+    const model = createBasicModelInfo();
+    const code = generateEditPage(model, "@myapp/shared");
+    expect(code).toMatchSnapshot();
+  });
+
+  it("loads existing data and passes to form", () => {
+    const model = createBasicModelInfo();
+    const code = generateEditPage(model, "@myapp/shared");
+    expect(code).toContain("initialData");
+    expect(code).toContain("isEdit={true}");
+  });
+
+  it("fetches existing data for editing", () => {
+    const model = createBasicModelInfo();
+    const code = generateEditPage(model, "@myapp/shared");
+    expect(code).toContain("/api/todo/");
+  });
+});

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");
+    }
+  });
+});