swallowkit 0.4.0-beta.3 → 1.0.0-beta.10

package/src/__tests__/dev-seeds.test.ts

@@ -0,0 +1,112 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { createBasicModelInfo } from "./fixtures";
+import {
+  buildSeedTemplateDocument,
+  getContainerNameForModel,
+  loadDevSeedFiles,
+  normalizeSeedIdentifier,
+  parseSeedDocuments,
+} from "../cli/commands/dev-seeds";
+
+describe("dev seed helpers", () => {
+  const originalCwd = process.cwd();
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-dev-seeds-"));
+    process.chdir(tempDir);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("builds Cosmos container names from model names", () => {
+    expect(getContainerNameForModel(createBasicModelInfo())).toBe("Todos");
+  });
+
+  it("normalizes seed identifiers across common naming styles", () => {
+    expect(normalizeSeedIdentifier("todo-items")).toBe("todoitems");
+    expect(normalizeSeedIdentifier("Todo_Items")).toBe("todoitems");
+    expect(normalizeSeedIdentifier("todoSchema")).toBe("todoschema");
+  });
+
+  it("wraps a single JSON object into a document array", () => {
+    expect(parseSeedDocuments('{"id":"todo-001","title":"Hello"}', "todo.json")).toEqual([
+      { id: "todo-001", title: "Hello" },
+    ]);
+  });
+
+  it("loads matching seed files for an environment", async () => {
+    const seedsDir = path.join(tempDir, "dev-seeds", "local");
+    fs.mkdirSync(seedsDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(seedsDir, "todo.json"),
+      JSON.stringify([{ id: "todo-001", title: "First task" }], null, 2),
+      "utf-8"
+    );
+    fs.writeFileSync(
+      path.join(seedsDir, "ignored.json"),
+      JSON.stringify([{ id: "ignored-001" }], null, 2),
+      "utf-8"
+    );
+
+    const loaded = await loadDevSeedFiles("local", [createBasicModelInfo()]);
+
+    expect(loaded).toHaveLength(1);
+    expect(loaded[0]).toMatchObject({
+      containerName: "Todos",
+      documents: [{ id: "todo-001", title: "First task" }],
+    });
+  });
+
+  it("rejects seed documents without ids", async () => {
+    const seedsDir = path.join(tempDir, "dev-seeds", "local");
+    fs.mkdirSync(seedsDir, { recursive: true });
+    fs.writeFileSync(path.join(seedsDir, "todo.json"), JSON.stringify([{ title: "Missing id" }], null, 2), "utf-8");
+
+    await expect(loadDevSeedFiles("local", [createBasicModelInfo()])).rejects.toThrow(/non-empty string id/);
+  });
+
+  it("builds nested template documents from related schemas", () => {
+    const category = createBasicModelInfo({
+      name: "Category",
+      displayName: "Category",
+      schemaName: "categorySchema",
+      filePath: "/models/category.ts",
+      fields: [
+        { name: "id", type: "string", isOptional: false, isArray: false },
+        { name: "name", type: "string", isOptional: false, isArray: false },
+      ],
+      hasCreatedAt: false,
+      hasUpdatedAt: false,
+    });
+    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: true,
+          isArray: false,
+          isNestedSchema: true,
+          nestedModelName: "Category",
+          nestedSchemaName: "categorySchema",
+        },
+      ],
+    });
+
+    expect(buildSeedTemplateDocument(todo, [todo, category])).toEqual({
+      id: "todo-001",
+      title: "todo-title-sample",
+      category: {
+        id: "category-001",
+        name: "category-name-sample",
+      },
+    });
+  });
+});

package/src/__tests__/dev.test.ts

@@ -0,0 +1,42 @@
+import * as path from "path";
+import {
+  buildFunctionsStartArgs,
+  buildNextDevArgs,
+  buildPythonFunctionsEnv,
+  getPythonVirtualEnvPaths,
+} from "../cli/commands/dev";
+
+describe("dev command helpers", () => {
+  it("passes the requested port to Azure Functions Core Tools", () => {
+    expect(buildFunctionsStartArgs("7076")).toEqual(["start", "--port", "7076"]);
+  });
+
+  it("uses webpack mode for npm-based Next.js dev", () => {
+    expect(buildNextDevArgs("npm", "3012")).toEqual(["next", "dev", "--port", "3012", "--webpack"]);
+  });
+
+  it("uses pnpm exec for pnpm-based Next.js dev", () => {
+    expect(buildNextDevArgs("pnpm", "3012")).toEqual(["exec", "next", "dev", "--port", "3012", "--webpack"]);
+  });
+
+  it("builds Python virtual environment paths under functions/.venv", () => {
+    const functionsDir = path.join("C:\\repo", "functions");
+    const paths = getPythonVirtualEnvPaths(functionsDir);
+
+    expect(paths.venvDir).toBe(path.join(functionsDir, ".venv"));
+    expect(paths.binDir.endsWith(process.platform === "win32" ? path.join(".venv", "Scripts") : path.join(".venv", "bin"))).toBe(true);
+    expect(paths.pythonExecutable.endsWith(process.platform === "win32" ? path.join("Scripts", "python.exe") : path.join("bin", "python"))).toBe(true);
+  });
+
+  it("injects Python virtual environment settings for Functions", () => {
+    const functionsDir = path.join("C:\\repo", "functions");
+    const env = buildPythonFunctionsEnv({ PATH: "C:\\Windows\\System32" }, functionsDir);
+    const expectedBinDir = getPythonVirtualEnvPaths(functionsDir).binDir;
+
+    expect(env.VIRTUAL_ENV).toBe(path.join(functionsDir, ".venv"));
+    expect(env.languageWorkers__python__defaultExecutablePath).toBe(
+      getPythonVirtualEnvPaths(functionsDir).pythonExecutable
+    );
+    expect(env.PATH?.startsWith(`${expectedBinDir}${path.delimiter}`)).toBe(true);
+  });
+});

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,80 @@
+import {
+  buildGeneratedProjectDependencies,
+  buildCSharpFunctionsProgramSource,
+  buildCSharpFunctionsProjectSource,
+  buildSwallowKitConfigSource,
+  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\\**" />');
+  });
+
+  it("builds swallowkit.config.js without a local swallowkit package type import", () => {
+    const source = buildSwallowKitConfigSource("typescript");
+
+    expect(source).toContain("language: 'typescript'");
+    expect(source).toContain("baseUrl: process.env.BACKEND_FUNCTIONS_BASE_URL");
+    expect(source).not.toContain("import('swallowkit').SwallowKitConfig");
+  });
+
+  it("does not add swallowkit as a generated project dependency", () => {
+    const dependencies = buildGeneratedProjectDependencies("sample-app");
+
+    expect(dependencies).toEqual({
+      "@azure/cosmos": "^4.0.0",
+      applicationinsights: "^3.3.0",
+      "@sample-app/shared": "*",
+    });
+    expect(dependencies).not.toHaveProperty("swallowkit");
+  });
+});

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