swallowkit 1.0.0-beta.5 → 1.0.0-beta.51

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,356 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+import {
+  buildGeneratedProjectDependencies,
+  buildGeneratedProjectDevDependencies,
+  buildSharedTsConfig,
+  buildAzureSwaPipeline,
+  buildSwallowKitMcpProjectConfigSource,
+  buildGitHubSwaWorkflow,
+  buildCSharpFunctionsProgramSource,
+  buildCSharpFunctionsProjectSource,
+  buildSwallowKitConfigSource,
+  getAzureFunctionsPipeline,
+  getGitHubFunctionsWorkflow,
+  injectSwallowKitNextConfig,
+  parseIgnoredBuilds,
+  buildCosmosDbFreeTierBicepSource,
+  buildFunctionsHostKeyBicepExpression,
+  buildStaticWebAppConfigBicepSource,
+  buildTypeScriptFunctionsPackageJson,
+  createInfrastructure,
+  getStaticWebAppSku,
+  withNpmLockfileSafeManifests,
+} 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",
+      zod: "^4.0.0",
+      "@sample-app/shared": "workspace:*",
+    });
+    expect(dependencies).not.toHaveProperty("swallowkit");
+  });
+
+  it("uses npm-compatible file dependencies for the shared workspace", () => {
+    const dependencies = buildGeneratedProjectDependencies("sample-app", "npm");
+
+    expect(dependencies["@sample-app/shared"]).toBe("file:shared");
+    expect(Object.values(dependencies)).not.toContain("workspace:*");
+  });
+
+  it("uses an npm-compatible shared dependency in the Functions workspace", () => {
+    const packageJson = buildTypeScriptFunctionsPackageJson("sample-app", "npm");
+
+    expect(packageJson.dependencies["@sample-app/shared"]).toBe("file:../shared");
+    expect(Object.values(packageJson.dependencies)).not.toContain("workspace:*");
+  });
+
+  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 resolves the configured swallowkit-mcp version", () => {
+    const source = buildSwallowKitMcpProjectConfigSource();
+    const parsed = JSON.parse(source) as {
+      mcpServers: {
+        swallowkit: {
+          command: string;
+          args: string[];
+          cwd?: string;
+          env?: Record<string, string>;
+        };
+      };
+    };
+
+    expect(parsed.mcpServers.swallowkit.command).toBe("pnpm");
+    expect(parsed.mcpServers.swallowkit.args).toEqual([
+      "dlx",
+      "--package",
+      "swallowkit@${SWALLOWKIT_MCP_VERSION}",
+      "swallowkit-mcp",
+    ]);
+    expect(parsed.mcpServers.swallowkit.cwd).toBe(".");
+    expect(parsed.mcpServers.swallowkit.env).toEqual({ SWALLOWKIT_MCP_VERSION: "latest" });
+  });
+
+  it("builds an npm-based MCP config when pnpm is unavailable", () => {
+    const source = buildSwallowKitMcpProjectConfigSource("npm");
+    const parsed = JSON.parse(source);
+
+    expect(parsed.mcpServers.swallowkit.command).toBe("npx");
+    expect(parsed.mcpServers.swallowkit.args).toEqual([
+      "--yes",
+      "--package",
+      "swallowkit@${SWALLOWKIT_MCP_VERSION}",
+      "swallowkit-mcp",
+    ]);
+  });
+
+  it("temporarily rewrites workspace protocol dependencies for npm lockfile generation", async () => {
+    const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-lockfile-"));
+    fs.mkdirSync(path.join(projectDir, "shared"));
+    fs.mkdirSync(path.join(projectDir, "functions"));
+    fs.mkdirSync(path.join(projectDir, "node_modules"));
+    fs.mkdirSync(path.join(projectDir, "shared", "node_modules"));
+    fs.writeFileSync(path.join(projectDir, "node_modules", ".pnpm-marker"), "root");
+    fs.writeFileSync(path.join(projectDir, "shared", "node_modules", ".pnpm-marker"), "shared");
+
+    const rootPackageJson = {
+      name: "sample-app",
+      dependencies: {
+        "@sample-app/shared": "workspace:*",
+      },
+    };
+    const functionsPackageJson = {
+      name: "functions",
+      dependencies: {
+        "@sample-app/shared": "workspace:*",
+      },
+    };
+    const sharedPackageJson = {
+      name: "@sample-app/shared",
+    };
+
+    fs.writeFileSync(path.join(projectDir, "package.json"), JSON.stringify(rootPackageJson, null, 2));
+    fs.writeFileSync(path.join(projectDir, "functions", "package.json"), JSON.stringify(functionsPackageJson, null, 2));
+    fs.writeFileSync(path.join(projectDir, "shared", "package.json"), JSON.stringify(sharedPackageJson, null, 2));
+
+    await withNpmLockfileSafeManifests(projectDir, async () => {
+      const normalizedRoot = JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf-8"));
+      const normalizedFunctions = JSON.parse(fs.readFileSync(path.join(projectDir, "functions", "package.json"), "utf-8"));
+
+      expect(normalizedRoot.dependencies["@sample-app/shared"]).toBe("file:shared");
+      expect(normalizedFunctions.dependencies["@sample-app/shared"]).toBe("file:../shared");
+      expect(fs.existsSync(path.join(projectDir, "node_modules"))).toBe(false);
+      expect(fs.existsSync(path.join(projectDir, "shared", "node_modules"))).toBe(false);
+    });
+
+    expect(JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf-8"))).toEqual(rootPackageJson);
+    expect(JSON.parse(fs.readFileSync(path.join(projectDir, "functions", "package.json"), "utf-8"))).toEqual(functionsPackageJson);
+    expect(fs.readFileSync(path.join(projectDir, "node_modules", ".pnpm-marker"), "utf-8")).toBe("root");
+    expect(fs.readFileSync(path.join(projectDir, "shared", "node_modules", ".pnpm-marker"), "utf-8")).toBe("shared");
+  });
+});
+
+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("Static Web Apps plan", () => {
+  it("maps init plan values to Azure SKU names", () => {
+    expect(getStaticWebAppSku("free")).toBe("Free");
+    expect(getStaticWebAppSku("standard")).toBe("Standard");
+  });
+});
+
+describe("Functions host key infrastructure", () => {
+  it("reads the generated default host key without exposing a literal value", () => {
+    const expression = buildFunctionsHostKeyBicepExpression();
+    expect(expression).toContain("listKeys(");
+    expect(expression).toContain("functionKeys.default");
+    expect(expression).toContain("resourceId('Microsoft.Web/sites/host', 'func-${projectName}', 'default')");
+    expect(expression).not.toContain("functionsFlex.outputs.id");
+  });
+
+  it("passes the key to SWA through a secure module parameter", () => {
+    const source = buildStaticWebAppConfigBicepSource();
+    expect(source).toContain("@secure()");
+    expect(source).toContain("param functionsHostKey string");
+    expect(source).toContain("BACKEND_FUNCTIONS_KEY: functionsHostKey");
+    expect(source).not.toContain("output functionsHostKey");
+  });
+});
+
+describe("Infrastructure generation", () => {
+  it.each([
+    ["freetier", "free"],
+    ["serverless", "standard"],
+  ] as Array<["freetier" | "serverless", "free" | "standard"]>)(
+    "emits VNet module definitions with VNet disabled (%s)",
+    async (cosmosDbMode, swaPlan) => {
+      const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-infra-no-vnet-"));
+
+      await createInfrastructure(
+        projectDir,
+        "sample-app",
+        { cosmosDbMode, vnetOption: "none", swaPlan },
+        "typescript",
+      );
+
+      expect(fs.existsSync(path.join(projectDir, "infra", "modules", "vnet.bicep"))).toBe(true);
+      expect(fs.existsSync(path.join(projectDir, "infra", "modules", "private-endpoint-cosmos.bicep"))).toBe(true);
+
+      const mainBicep = fs.readFileSync(path.join(projectDir, "infra", "main.bicep"), "utf-8");
+      expect(mainBicep).toContain("param enableVNet bool = false");
+      expect(mainBicep).toContain("module vnet 'modules/vnet.bicep' = if (enableVNet)");
+    },
+  );
+});
+
+describe("GitHub Actions workflow generation", () => {
+  it("uses npm ci for the SWA workflow when the project was initialized with pnpm", () => {
+    const workflow = buildGitHubSwaWorkflow("npm", "pnpm");
+
+    expect(workflow).toContain("Normalize pnpm workspace for npm CI");
+    expect(workflow).toContain("root.workspaces = ['shared', 'functions']");
+    expect(workflow).toContain("replaceSharedWorkspaceDep(root, 'file:shared')");
+    expect(workflow).toContain("root.scripts.build = \"npm run --workspace=shared build");
+    expect(workflow).toContain("npm install --package-lock-only --ignore-scripts");
+    expect(workflow).toContain("npm ci && npm run build");
+    expect(workflow).not.toContain("npm install && npm run build");
+    expect(workflow).not.toContain("pnpm/action-setup");
+    expect(workflow).not.toContain("pnpm install --frozen-lockfile");
+  });
+
+  it("uses npm ci for the Functions workflow when the project was initialized with pnpm", () => {
+    const workflow = getGitHubFunctionsWorkflow("npm", "typescript", "pnpm");
+
+    expect(workflow).toContain("Normalize pnpm workspace for npm CI");
+    expect(workflow).toContain("replaceSharedWorkspaceDep(functionsPkg, 'file:../shared')");
+    expect(workflow).toContain("functionsPkg.scripts.prestart = 'npm run build'");
+    expect(workflow).toContain("npm install --package-lock-only --ignore-scripts");
+    expect(workflow).toContain("- name: Install dependencies\n        run: |\n          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 ci for the SWA pipeline when the project was initialized with pnpm", () => {
+    const pipeline = buildAzureSwaPipeline("npm", "pnpm");
+
+    expect(pipeline).toContain("Normalize pnpm workspace for npm CI");
+    expect(pipeline).toContain("root.workspaces = ['shared', 'functions']");
+    expect(pipeline).toContain("replaceSharedWorkspaceDep(root, 'file:shared')");
+    expect(pipeline).toContain("root.scripts.build = \"npm run --workspace=shared build");
+    expect(pipeline).toContain("npm install --package-lock-only --ignore-scripts");
+    expect(pipeline).toContain("npm ci");
+    expect(pipeline).not.toContain("- script: |\n      npm install\n    displayName: 'Install dependencies'");
+    expect(pipeline).toContain("npm run build");
+    expect(pipeline).not.toContain("corepack enable");
+    expect(pipeline).not.toContain("pnpm install --frozen-lockfile");
+  });
+
+  it("uses npm ci for the Functions pipeline when the project was initialized with pnpm", () => {
+    const pipeline = getAzureFunctionsPipeline("npm", "typescript", "pnpm");
+
+    expect(pipeline).toContain("Normalize pnpm workspace for npm CI");
+    expect(pipeline).toContain("replaceSharedWorkspaceDep(functionsPkg, 'file:../shared')");
+    expect(pipeline).toContain("functionsPkg.scripts.prestart = 'npm run build'");
+    expect(pipeline).toContain("npm install --package-lock-only --ignore-scripts");
+    expect(pipeline).toContain("- script: |\n      npm ci\n    displayName: 'Install workspace dependencies'");
+    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;