swallowkit 1.0.0-beta.4 → 1.0.0-beta.41

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

@@ -0,0 +1,237 @@
+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 TodoCrudFunctions");
+    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");
+  });
+
+  // --- Custom Partition Key Tests ---
+
+  describe("custom partition key (TS)", () => {
+    it("uses input binding when partitionKey is /id (default)", () => {
+      const model = createBasicModelInfo({ partitionKey: "/id" });
+      const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+      expect(code).toContain("partitionKey: '{id}'");
+      expect(code).toContain("container.item(id, id).delete()");
+    });
+
+    it("uses SDK direct call when partitionKey is not /id", () => {
+      const model = createBasicModelInfo({
+        partitionKey: "/tenantId",
+        fields: [
+          { name: "id", type: "string", isOptional: false, isArray: false },
+          { name: "tenantId", type: "string", isOptional: false, isArray: false },
+          { name: "title", type: "string", isOptional: false, isArray: false },
+          { name: "createdAt", type: "string", isOptional: false, isArray: false },
+          { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+        ],
+      });
+      const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+
+      // Should NOT have input binding with partitionKey
+      expect(code).not.toContain("partitionKey: '{id}'");
+      // getById should use SDK query
+      expect(code).toContain("custom partition key");
+      expect(code).toContain("SELECT * FROM c WHERE c.id = @id");
+      // delete should read doc first to get PK value
+      expect(code).toContain("resources[0].tenantId");
+      expect(code).toContain("container.item(id, pkValue).delete()");
+    });
+
+    it("generates snapshot for custom partition key TS", () => {
+      const model = createBasicModelInfo({
+        partitionKey: "/tenantId",
+        fields: [
+          { name: "id", type: "string", isOptional: false, isArray: false },
+          { name: "tenantId", type: "string", isOptional: false, isArray: false },
+          { name: "title", type: "string", isOptional: false, isArray: false },
+          { name: "createdAt", type: "string", isOptional: false, isArray: false },
+          { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+        ],
+      });
+      const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+      expect(code).toMatchSnapshot();
+    });
+  });
+
+  describe("custom partition key (C#)", () => {
+    it("uses ReadItemStreamAsync when partitionKey is /id", () => {
+      const model = createBasicModelInfo({ partitionKey: "/id" });
+      const code = generateCSharpAzureFunctionsCRUD(model);
+      expect(code).toContain("ReadItemStreamAsync(id, new PartitionKey(id))");
+      expect(code).toContain("DeleteItemAsync<JsonObject>(id, new PartitionKey(id))");
+    });
+
+    it("uses query when partitionKey is not /id", () => {
+      const model = createBasicModelInfo({
+        partitionKey: "/tenantId",
+        fields: [
+          { name: "id", type: "string", isOptional: false, isArray: false },
+          { name: "tenantId", type: "string", isOptional: false, isArray: false },
+          { name: "title", type: "string", isOptional: false, isArray: false },
+          { name: "createdAt", type: "string", isOptional: false, isArray: false },
+          { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+        ],
+      });
+      const code = generateCSharpAzureFunctionsCRUD(model);
+      // ReadCosmosItemAsync should use query instead of point read
+      expect(code).toContain("GetItemQueryStreamIterator(query)");
+      expect(code).not.toContain("ReadItemStreamAsync(id, new PartitionKey(id))");
+      // Delete should read doc first for PK value
+      expect(code).toContain('existing["tenantId"]');
+    });
+
+    it("generates snapshot for custom partition key C#", () => {
+      const model = createBasicModelInfo({
+        partitionKey: "/tenantId",
+        fields: [
+          { name: "id", type: "string", isOptional: false, isArray: false },
+          { name: "tenantId", type: "string", isOptional: false, isArray: false },
+          { name: "title", type: "string", isOptional: false, isArray: false },
+          { name: "createdAt", type: "string", isOptional: false, isArray: false },
+          { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+        ],
+      });
+      const code = generateCSharpAzureFunctionsCRUD(model);
+      expect(code).toMatchSnapshot();
+    });
+  });
+
+  describe("custom partition key (Python)", () => {
+    it("uses read_item with partition_key=item_id when partitionKey is /id", () => {
+      const model = createBasicModelInfo({ partitionKey: "/id" });
+      const generated = generatePythonAzureFunctionsCRUD(model);
+      expect(generated.blueprint).toContain("partition_key=item_id");
+    });
+
+    it("uses cross-partition query when partitionKey is not /id", () => {
+      const model = createBasicModelInfo({
+        partitionKey: "/tenantId",
+        fields: [
+          { name: "id", type: "string", isOptional: false, isArray: false },
+          { name: "tenantId", type: "string", isOptional: false, isArray: false },
+          { name: "title", type: "string", isOptional: false, isArray: false },
+          { name: "createdAt", type: "string", isOptional: false, isArray: false },
+          { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+        ],
+      });
+      const generated = generatePythonAzureFunctionsCRUD(model);
+      // Should not use direct read_item with partition_key=item_id
+      expect(generated.blueprint).not.toContain("partition_key=item_id");
+      // Should use cross-partition query
+      expect(generated.blueprint).toContain("enable_cross_partition_query=True");
+      expect(generated.blueprint).toContain('SELECT * FROM c WHERE c.id = @id');
+      // Delete should get PK value from document
+      expect(generated.blueprint).toContain('.get("tenantId")');
+    });
+
+    it("generates snapshot for custom partition key Python", () => {
+      const model = createBasicModelInfo({
+        partitionKey: "/tenantId",
+        fields: [
+          { name: "id", type: "string", isOptional: false, isArray: false },
+          { name: "tenantId", type: "string", isOptional: false, isArray: false },
+          { name: "title", type: "string", isOptional: false, isArray: false },
+          { name: "createdAt", type: "string", isOptional: false, isArray: false },
+          { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+        ],
+      });
+      const generated = generatePythonAzureFunctionsCRUD(model);
+      expect(generated.blueprint).toMatchSnapshot();
+    });
+  });
+});

package/src/__tests__/init.test.ts

@@ -0,0 +1,201 @@
+import {
+  buildGeneratedProjectDependencies,
+  buildGeneratedProjectDevDependencies,
+  buildSharedTsConfig,
+  buildAzureSwaPipeline,
+  buildSwallowKitMcpProjectConfigSource,
+  buildGitHubSwaWorkflow,
+  buildCSharpFunctionsProgramSource,
+  buildCSharpFunctionsProjectSource,
+  buildSwallowKitConfigSource,
+  getAzureFunctionsPipeline,
+  getGitHubFunctionsWorkflow,
+  injectSwallowKitNextConfig,
+  parseIgnoredBuilds,
+  buildCosmosDbFreeTierBicepSource,
+} 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).toContain("services.ConfigureFunctionsApplicationInsights()");
+    expect(source).toContain("Microsoft.Azure.Functions.Worker.ApplicationInsights");
+    expect(source).not.toContain("Microsoft.Azure.Functions.Worker.Builder");
+    expect(source).not.toContain("FunctionsApplication.CreateBuilder");
+  });
+
+  it("excludes nested generated bin and obj files from the C# Functions project", () => {
+    const source = buildCSharpFunctionsProjectSource();
+
+    expect(source).toContain("<TargetFramework>net10.0</TargetFramework>");
+    expect(source).toContain('Version="2.52.0"');
+    expect(source).toContain('Version="3.3.0"');
+    expect(source).toContain('Version="2.0.7"');
+    expect(source).toContain('Version="2.50.0"');
+    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("builds shared tsconfig with non-deprecated module resolution settings", () => {
+    const tsconfig = buildSharedTsConfig();
+
+    expect(tsconfig.compilerOptions.module).toBe("Node16");
+    expect(tsconfig.compilerOptions.moduleResolution).toBe("node16");
+  });
+
+  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": "workspace:*",
+    });
+    expect(dependencies).not.toHaveProperty("swallowkit");
+  });
+
+  it("adds swallowkit as a generated project devDependency", () => {
+    const devDependencies = buildGeneratedProjectDevDependencies();
+
+    expect(devDependencies).toEqual({
+      swallowkit: expect.stringMatching(/.+/),
+    });
+  });
+
+  it("builds a project-scoped MCP config that launches the local swallowkit-mcp entrypoint", () => {
+    const source = buildSwallowKitMcpProjectConfigSource();
+    const parsed = JSON.parse(source) as {
+      mcpServers: {
+        swallowkit: {
+          command: string;
+          args: string[];
+          cwd?: string;
+        };
+      };
+    };
+
+    expect(parsed.mcpServers.swallowkit.command).toBe("node");
+    expect(parsed.mcpServers.swallowkit.args).toEqual([
+      expect.stringMatching(/^\.\/node_modules\/swallowkit\/dist\/mcp\/index\.js$/),
+    ]);
+    expect(parsed.mcpServers.swallowkit.cwd).toBe(".");
+  });
+});
+
+describe("parseIgnoredBuilds", () => {
+  it("extracts package names from the pnpm warning line", () => {
+    const output = [
+      "WARN  Issues with peer dependencies found",
+      " ERR_PNPM_IGNORED_BUILDS  Ignored build scripts: sharp@0.34.5, unrs-resolver@1.12.2",
+      "run pnpm approve-builds",
+    ].join("\n");
+    expect(parseIgnoredBuilds(output)).toEqual(["sharp", "unrs-resolver"]);
+  });
+
+  it("handles scoped packages and de-duplicates entries", () => {
+    const output = "Ignored build scripts: @scope/pkg@1.0.0, sharp@0.34.5, sharp@0.34.5";
+    expect(parseIgnoredBuilds(output)).toEqual(["@scope/pkg", "sharp"]);
+  });
+
+  it("returns an empty array when no warning is present", () => {
+    expect(parseIgnoredBuilds("everything is fine")).toEqual([]);
+  });
+});
+
+describe("buildCosmosDbFreeTierBicepSource", () => {
+  it("keeps database-level shared throughput at 1000 RU/s for Free Tier", () => {
+    const source = buildCosmosDbFreeTierBicepSource();
+
+    expect(source).toContain("throughput: 1000");
+    expect(source).not.toContain("containers");
+  });
+});
+
+describe("GitHub Actions workflow generation", () => {
+  it("uses npm install for the SWA workflow when the project was initialized with pnpm", () => {
+    const workflow = buildGitHubSwaWorkflow("npm", "pnpm");
+
+    expect(workflow).toContain("npm install && npm run build");
+    expect(workflow).not.toContain("npm ci && npm run build");
+    expect(workflow).not.toContain("pnpm/action-setup");
+    expect(workflow).not.toContain("pnpm install --frozen-lockfile");
+  });
+
+  it("uses npm install for the Functions workflow when the project was initialized with pnpm", () => {
+    const workflow = getGitHubFunctionsWorkflow("npm", "typescript", "pnpm");
+
+    expect(workflow).toContain("npm install");
+    expect(workflow).not.toContain("npm ci");
+    expect(workflow).toContain("npm run --workspace=shared build");
+    expect(workflow).toContain("npm run --workspace=functions build");
+    expect(workflow).not.toContain("pnpm/action-setup");
+    expect(workflow).not.toContain("pnpm install --frozen-lockfile");
+  });
+
+  it("uses npm install for the SWA pipeline when the project was initialized with pnpm", () => {
+    const pipeline = buildAzureSwaPipeline("npm", "pnpm");
+
+    expect(pipeline).toContain("npm install");
+    expect(pipeline).not.toContain("npm ci");
+    expect(pipeline).toContain("npm run build");
+    expect(pipeline).not.toContain("corepack enable");
+    expect(pipeline).not.toContain("pnpm install --frozen-lockfile");
+  });
+
+  it("uses npm install for the Functions pipeline when the project was initialized with pnpm", () => {
+    const pipeline = getAzureFunctionsPipeline("npm", "typescript", "pnpm");
+
+    expect(pipeline).toContain("npm install");
+    expect(pipeline).not.toContain("npm ci");
+    expect(pipeline).toContain("npm run --workspace=shared build");
+    expect(pipeline).toContain("npm run --workspace=functions build");
+    expect(pipeline).not.toContain("corepack enable");
+    expect(pipeline).not.toContain("pnpm install --frozen-lockfile");
+  });
+});

package/src/__tests__/jest-globals.d.ts

@@ -0,0 +1,8 @@
+declare const describe: typeof import("@jest/globals").describe;
+declare const it: typeof import("@jest/globals").it;
+declare const expect: typeof import("@jest/globals").expect;
+declare const beforeAll: typeof import("@jest/globals").beforeAll;
+declare const afterAll: typeof import("@jest/globals").afterAll;
+declare const beforeEach: typeof import("@jest/globals").beforeEach;
+declare const afterEach: typeof import("@jest/globals").afterEach;
+declare const jest: typeof import("@jest/globals").jest;