swallowkit 1.0.0-beta.5 → 1.0.0-beta.7

package/src/__tests__/fixtures.ts

@@ -0,0 +1,83 @@
+import { ModelInfo } from "../core/scaffold/model-parser";
+
+/**
+ * テスト用の基本的な ModelInfo フィクスチャ
+ */
+export function createBasicModelInfo(overrides?: Partial<ModelInfo>): ModelInfo {
+  return {
+    name: "Todo",
+    displayName: "Todo",
+    schemaName: "todoSchema",
+    filePath: "/models/todo.ts",
+    fields: [
+      { name: "id", type: "string", isOptional: false, isArray: false },
+      { name: "title", type: "string", isOptional: false, isArray: false },
+      { name: "description", type: "string", isOptional: true, isArray: false },
+      { name: "completed", type: "boolean", isOptional: false, isArray: false },
+      { name: "createdAt", type: "string", isOptional: false, isArray: false },
+      { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+    ],
+    hasId: true,
+    hasCreatedAt: true,
+    hasUpdatedAt: true,
+    nestedSchemaRefs: [],
+    ...overrides,
+  };
+}
+
+/**
+ * 外部キーを含む ModelInfo フィクスチャ
+ */
+export function createModelInfoWithForeignKey(): ModelInfo {
+  return createBasicModelInfo({
+    name: "Task",
+    displayName: "Task",
+    schemaName: "taskSchema",
+    filePath: "/models/task.ts",
+    fields: [
+      { name: "id", type: "string", isOptional: false, isArray: false },
+      { name: "title", type: "string", isOptional: false, isArray: false },
+      {
+        name: "categoryId",
+        type: "string",
+        isOptional: false,
+        isArray: false,
+        isForeignKey: true,
+        referencedModel: "Category",
+      },
+      { name: "createdAt", type: "string", isOptional: false, isArray: false },
+      { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+    ],
+  });
+}
+
+/**
+ * enum フィールドを含む ModelInfo フィクスチャ
+ */
+export function createModelInfoWithEnum(): ModelInfo {
+  return createBasicModelInfo({
+    name: "Issue",
+    displayName: "Issue",
+    schemaName: "issueSchema",
+    filePath: "/models/issue.ts",
+    fields: [
+      { name: "id", type: "string", isOptional: false, isArray: false },
+      { name: "title", type: "string", isOptional: false, isArray: false },
+      {
+        name: "status",
+        type: "string",
+        isOptional: false,
+        isArray: false,
+        enumValues: ["open", "in_progress", "closed"],
+      },
+      {
+        name: "priority",
+        type: "number",
+        isOptional: true,
+        isArray: false,
+      },
+      { name: "createdAt", type: "string", isOptional: false, isArray: false },
+      { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+    ],
+  });
+}

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

@@ -0,0 +1,101 @@
+import {
+  generateCSharpAzureFunctionsCRUD,
+  generateCompactAzureFunctionsCRUD,
+  generatePythonAzureFunctionsCRUD,
+} from "../core/scaffold/functions-generator";
+import { createBasicModelInfo, createModelInfoWithEnum } from "./fixtures";
+
+describe("generateCompactAzureFunctionsCRUD", () => {
+  it("generates correct CRUD code for a basic model", () => {
+    const model = createBasicModelInfo();
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toMatchSnapshot();
+  });
+
+  it("generates correct CRUD code for a model with enum fields", () => {
+    const model = createModelInfoWithEnum();
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toMatchSnapshot();
+  });
+
+  it("imports the correct schema from shared package", () => {
+    const model = createBasicModelInfo();
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toContain("import { todoSchema } from '@myapp/shared'");
+  });
+
+  it("uses correct container name (PascalCase + s)", () => {
+    const model = createBasicModelInfo();
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toContain("const containerName = 'Todos'");
+  });
+
+  it("registers correct route names (camelCase)", () => {
+    const model = createBasicModelInfo();
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toContain("'todo-get-all'");
+    expect(code).toContain("'todo-get-by-id'");
+    expect(code).toContain("'todo-create'");
+    expect(code).toContain("'todo-update'");
+    expect(code).toContain("'todo-delete'");
+  });
+
+  it("generates all CRUD HTTP methods", () => {
+    const model = createBasicModelInfo();
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toContain("methods: ['GET']");
+    expect(code).toContain("methods: ['POST']");
+    expect(code).toContain("methods: ['PUT']");
+    expect(code).toContain("methods: ['DELETE']");
+  });
+
+  it("uses correct route patterns", () => {
+    const model = createBasicModelInfo();
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toContain("route: 'todo'");
+    expect(code).toContain("route: 'todo/{id}'");
+  });
+
+  it("handles multi-word model names correctly", () => {
+    const model = createBasicModelInfo({
+      name: "TodoItem",
+      schemaName: "todoItemSchema",
+    });
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toContain("const containerName = 'TodoItems'");
+    expect(code).toContain("route: 'todoItem'");
+    expect(code).toContain("'todoItem-get-all'");
+  });
+
+  it("generates C# Cosmos-backed CRUD handlers", () => {
+    const model = createBasicModelInfo();
+    const code = generateCSharpAzureFunctionsCRUD(model);
+    expect(code).toContain("public sealed class TodoFunctions");
+    expect(code).toContain('[Function("todoGetAll")]');
+    expect(code).toContain('Route = "todo/{id}"');
+    expect(code).toContain("CreateCosmosClient()");
+    expect(code).toContain('new CosmosClientOptions { ConnectionMode = ConnectionMode.Gateway }');
+    expect(code).toContain('endpoint.Contains("localhost:8081", StringComparison.OrdinalIgnoreCase)');
+    expect(code).toContain("container.ReadItemStreamAsync");
+    expect(code).toContain("JsonNode.Parse(document.RootElement.GetRawText())?.AsObject()");
+    expect(code).toContain("container.CreateItemStreamAsync");
+    expect(code).toContain("container.ReplaceItemStreamAsync");
+    expect(code).toContain("payload.ToJsonString()");
+    expect(code).toContain("container.DeleteItemAsync<JsonObject>");
+  });
+
+  it("generates Python Cosmos-backed CRUD handlers", () => {
+    const model = createBasicModelInfo();
+    const generated = generatePythonAzureFunctionsCRUD(model);
+    expect(generated.registration).toContain("from blueprints.todo import bp as todo_bp");
+    expect(generated.registration).toContain("app.register_blueprint(todo_bp)");
+    expect(generated.blueprint).toContain('@bp.route(route="todo", methods=["GET"])');
+    expect(generated.blueprint).toContain("def todo_create");
+    expect(generated.blueprint).toContain("from azure.cosmos import CosmosClient, exceptions");
+    expect(generated.blueprint).toContain("container.query_items");
+    expect(generated.blueprint).toContain("container.read_item");
+    expect(generated.blueprint).toContain("container.create_item");
+    expect(generated.blueprint).toContain("container.replace_item");
+    expect(generated.blueprint).toContain("container.delete_item");
+  });
+});

package/src/__tests__/init.test.ts

@@ -0,0 +1,59 @@
+import {
+  buildCSharpFunctionsProgramSource,
+  buildCSharpFunctionsProjectSource,
+  injectSwallowKitNextConfig,
+} from "../cli/commands/init";
+
+describe("injectSwallowKitNextConfig", () => {
+  it("adds standalone settings without deprecated experimental options", () => {
+    const original = `import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  /* config options here */
+};
+
+export default nextConfig;
+`;
+
+    const updated = injectSwallowKitNextConfig(original, "sample-app");
+
+    expect(updated).toContain("output: 'standalone'");
+    expect(updated).toContain("transpilePackages: ['@sample-app/shared']");
+    expect(updated).toContain("serverExternalPackages: ['applicationinsights', 'diagnostic-channel-publishers']");
+    expect(updated).not.toContain("turbopackUseSystemTlsCerts");
+    expect(updated).not.toContain("experimental:");
+  });
+
+  it("supports JavaScript next.config format", () => {
+    const original = `const nextConfig = {
+  /* config options here */
+};
+
+module.exports = nextConfig;
+`;
+
+    const updated = injectSwallowKitNextConfig(original, "sample-app");
+
+    expect(updated).toContain("transpilePackages: ['@sample-app/shared']");
+    expect(updated).toContain("module.exports = nextConfig;");
+  });
+
+  it("generates a C# Program.cs compatible with the current worker packages", () => {
+    const source = buildCSharpFunctionsProgramSource();
+
+    expect(source).toContain("new HostBuilder()");
+    expect(source).toContain(".ConfigureFunctionsWorkerDefaults()");
+    expect(source).toContain("services.AddApplicationInsightsTelemetryWorkerService()");
+    expect(source).not.toContain("Microsoft.Azure.Functions.Worker.Builder");
+    expect(source).not.toContain("FunctionsApplication.CreateBuilder");
+    expect(source).not.toContain("ConfigureFunctionsApplicationInsights");
+  });
+
+  it("excludes nested generated bin and obj files from the C# Functions project", () => {
+    const source = buildCSharpFunctionsProjectSource();
+
+    expect(source).toContain('<Compile Remove="generated\\**\\bin\\**\\*.cs;generated\\**\\obj\\**\\*.cs" />');
+    expect(source).toContain('<EmbeddedResource Remove="generated\\**\\bin\\**;generated\\**\\obj\\**" />');
+    expect(source).toContain('<None Remove="generated\\**\\bin\\**;generated\\**\\obj\\**" />');
+  });
+});

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

@@ -0,0 +1,97 @@
+import {
+  generateBFFCallFunction,
+  generateCompactBFFRoutes,
+} from "../core/scaffold/nextjs-generator";
+import { createBasicModelInfo } from "./fixtures";
+
+describe("generateBFFCallFunction", () => {
+  it("generates call function helper code", () => {
+    const code = generateBFFCallFunction();
+    expect(code).toMatchSnapshot();
+  });
+
+  it("includes getFunctionsBaseUrl helper", () => {
+    const code = generateBFFCallFunction();
+    expect(code).toContain("getFunctionsBaseUrl");
+    expect(code).toContain("BACKEND_FUNCTIONS_BASE_URL");
+  });
+
+  it("includes callFunction export", () => {
+    const code = generateBFFCallFunction();
+    expect(code).toContain("export async function callFunction");
+  });
+
+  it("includes z.ZodSchema typings", () => {
+    const code = generateBFFCallFunction();
+    expect(code).toContain("z.ZodSchema");
+  });
+});
+
+describe("generateCompactBFFRoutes", () => {
+  it("generates list and detail routes", () => {
+    const model = createBasicModelInfo();
+    const routes = generateCompactBFFRoutes(model, "@myapp/shared");
+
+    expect(routes.listRoute).toMatchSnapshot();
+    expect(routes.detailRoute).toMatchSnapshot();
+  });
+
+  it("imports the correct schema", () => {
+    const model = createBasicModelInfo();
+    const routes = generateCompactBFFRoutes(model, "@myapp/shared");
+
+    expect(routes.listRoute).toContain(
+      "import { todoSchema } from '@myapp/shared'"
+    );
+    expect(routes.detailRoute).toContain(
+      "import { todoSchema } from '@myapp/shared'"
+    );
+  });
+
+  it("uses correct API paths (camelCase)", () => {
+    const model = createBasicModelInfo();
+    const routes = generateCompactBFFRoutes(model, "@myapp/shared");
+
+    expect(routes.listRoute).toContain("path: '/api/todo'");
+    expect(routes.detailRoute).toContain("/api/todo/");
+  });
+
+  it("list route has GET and POST handlers", () => {
+    const model = createBasicModelInfo();
+    const routes = generateCompactBFFRoutes(model, "@myapp/shared");
+
+    expect(routes.listRoute).toContain("export async function GET()");
+    expect(routes.listRoute).toContain("export async function POST(");
+  });
+
+  it("detail route has GET, PUT, and DELETE handlers", () => {
+    const model = createBasicModelInfo();
+    const routes = generateCompactBFFRoutes(model, "@myapp/shared");
+
+    expect(routes.detailRoute).toContain("export async function GET(");
+    expect(routes.detailRoute).toContain("export async function PUT(");
+    expect(routes.detailRoute).toContain("export async function DELETE(");
+  });
+
+  it("creates InputSchema that omits managed fields", () => {
+    const model = createBasicModelInfo();
+    const routes = generateCompactBFFRoutes(model, "@myapp/shared");
+
+    expect(routes.listRoute).toContain(
+      "todoSchema.omit({ id: true, createdAt: true, updatedAt: true })"
+    );
+  });
+
+  it("handles multi-word model names", () => {
+    const model = createBasicModelInfo({
+      name: "BlogPost",
+      schemaName: "blogPostSchema",
+    });
+    const routes = generateCompactBFFRoutes(model, "@myapp/shared");
+
+    expect(routes.listRoute).toContain("path: '/api/blogPost'");
+    expect(routes.listRoute).toContain(
+      "import { blogPostSchema } from '@myapp/shared'"
+    );
+  });
+});

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

@@ -0,0 +1,43 @@
+import { generateOpenApiDocument } from "../core/scaffold/openapi-generator";
+import { createBasicModelInfo } from "./fixtures";
+
+describe("generateOpenApiDocument", () => {
+  it("emits an OpenAPI document for the root model", () => {
+    const model = createBasicModelInfo();
+    const document = JSON.parse(generateOpenApiDocument([model], model));
+
+    expect(document.openapi).toBe("3.0.3");
+    expect(document.components.schemas.Todo.properties.title.type).toBe("string");
+    expect(document.paths["/api/todo"].post.requestBody.content["application/json"].schema.$ref)
+      .toBe("#/components/schemas/Todo");
+  });
+
+  it("emits nested schema references when present", () => {
+    const todo = createBasicModelInfo({
+      fields: [
+        { name: "id", type: "string", isOptional: false, isArray: false },
+        { name: "title", type: "string", isOptional: false, isArray: false },
+        {
+          name: "category",
+          type: "object",
+          isOptional: false,
+          isArray: false,
+          isNestedSchema: true,
+          nestedModelName: "Category",
+        },
+      ],
+    });
+    const category = createBasicModelInfo({
+      name: "Category",
+      schemaName: "categorySchema",
+      fields: [
+        { name: "id", type: "string", isOptional: false, isArray: false },
+        { name: "name", type: "string", isOptional: false, isArray: false },
+      ],
+    });
+
+    const document = JSON.parse(generateOpenApiDocument([todo, category], todo));
+    expect(document.components.schemas.Todo.properties.category.$ref).toBe("#/components/schemas/Category");
+    expect(document.components.schemas.Category.properties.name.type).toBe("string");
+  });
+});

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("keeps supporting files for C# model generation", () => {
+    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");
+  });
+
+  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);
+  });
+});