swallowkit 1.1.1 → 2.0.0-alpha.1

package/src/__tests__/init.test.ts

@@ -40,6 +40,8 @@ export default nextConfig;
     const updated = injectSwallowKitNextConfig(original, "sample-app");
 
     expect(updated).toContain("output: 'standalone'");
+    expect(updated).toContain("cacheComponents: false");
+    expect(updated).not.toContain("partialPrefetching");
     expect(updated).toContain("agentRules: false");
     expect(updated).toContain("transpilePackages: ['@sample-app/shared']");
     expect(updated).toContain("serverExternalPackages: ['applicationinsights', 'diagnostic-channel-publishers']");
@@ -60,6 +62,26 @@ module.exports = nextConfig;
     expect(updated).toContain("transpilePackages: ['@sample-app/shared']");
     expect(updated).toContain("agentRules: false");
     expect(updated).toContain("module.exports = nextConfig;");
+    expect(updated).toContain("cacheComponents: false");
+  });
+
+  it.each([true, false])("disables create-next-app Cache Components without duplicate keys (initially %s)", (enabled) => {
+    const original = `import type { NextConfig } from 'next';
+const nextConfig: NextConfig = {
+  cacheComponents: ${enabled},
+  partialPrefetching: true,
+  reactCompiler: true,
+};
+export default nextConfig;
+`;
+    const updated = injectSwallowKitNextConfig(original, "sample-app");
+    expect(updated).toContain("cacheComponents: false");
+    expect(updated).not.toContain("cacheComponents: true");
+    expect(updated).toContain("partialPrefetching: false");
+    expect(updated.match(/\bpartialPrefetching\s*:/g)).toHaveLength(1);
+    expect(updated.match(/\bcacheComponents\s*:/g)).toHaveLength(1);
+    expect(updated).toContain("reactCompiler: true");
+    expect(updated).toContain("output: 'standalone'");
   });
 
   it("generates a C# Program.cs compatible with the current worker packages", () => {
@@ -411,11 +433,13 @@ describe("SWA npm compatibility with pnpm projects", () => {
         scripts: { prestart: "pnpm run build" },
       });
       const env = { ...process.env, npm_config_cache: path.join(dir, "cache") };
+      const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
+      const npmOptions = { cwd: dir, env, encoding: "utf8" as const, shell: process.platform === "win32" };
       // setup-node's npm cache lookup is an npm command too, before any install.
-      const cacheBefore = spawnSync("npm", ["config", "get", "cache"], { cwd: dir, env, encoding: "utf8" });
+      const cacheBefore = spawnSync(npmCommand, ["config", "get", "cache"], npmOptions);
       expect(cacheBefore.status).not.toBe(0);
       expect(cacheBefore.stderr).toContain("EBADDEVENGINES");
-      const before = spawnSync("npm", ["run", "probe"], { cwd: dir, env, encoding: "utf8" });
+      const before = spawnSync(npmCommand, ["run", "probe"], npmOptions);
       expect(before.status).not.toBe(0);
       expect(before.stderr).toContain("EBADDEVENGINES");
 
@@ -430,7 +454,7 @@ describe("SWA npm compatibility with pnpm projects", () => {
       }
       const runtimeCommand = workflow.match(/node -e "const fs=require\('fs'\);const p=JSON.parse[^\n]+/);
       expect(runtimeCommand).not.toBeNull();
-      execFileSync("bash", ["-c", runtimeCommand![0]], { cwd: dir });
+      execFileSync(process.execPath, ["-e", runtimeCommand![0].slice('node -e "'.length, -1)], { cwd: dir });
       const match = workflow.match(/node <<'NODE'\n([\s\S]*?)\n\s+NODE/);
       expect(match).not.toBeNull();
       execFileSync(process.execPath, ["-e", match![1]], { cwd: dir });
@@ -441,9 +465,9 @@ describe("SWA npm compatibility with pnpm projects", () => {
       expect(normalized.devEngines.runtime.version).toBe(">=22.14.0");
       expect(normalized.workspaces).toEqual(hasFunctions ? ["shared", "functions"] : ["shared"]);
       expect(normalized.dependencies["@sample/shared"]).toBe("file:shared");
-      const cacheAfter = execFileSync("npm", ["config", "get", "cache"], { cwd: dir, env, encoding: "utf8" });
+      const cacheAfter = execFileSync(npmCommand, ["config", "get", "cache"], npmOptions);
       expect(cacheAfter.trim()).toBe(env.npm_config_cache);
-      const after = execFileSync("npm", ["run", "probe"], { cwd: dir, env, encoding: "utf8" });
+      const after = execFileSync(npmCommand, ["run", "probe"], npmOptions);
       expect(after).toContain("npm/");
     } finally {
       fs.rmSync(dir, { recursive: true, force: true });

package/src/__tests__/plan-apply.test.ts

@@ -83,6 +83,19 @@ function createInfrastructureFixture(rootDir: string): void {
   writeFile(path.join(rootDir, "infra", "modules", "cosmosdb.bicep"), "// baseline cosmos\n");
 }
 
+function addLegacyContainerToInfrastructure(rootDir: string, modelKebab: string): void {
+  const containerPath = `containers/${modelKebab}-container.bicep`;
+  fs.appendFileSync(
+    path.join(rootDir, "infra", "main.bicep"),
+    `\nmodule ${modelKebab.replace(/-([a-z])/g, (_, letter: string) => letter.toUpperCase())}Container '${containerPath}' = {\n  name: '${modelKebab}-container'\n}\n`,
+    "utf-8"
+  );
+  writeFile(
+    path.join(rootDir, "infra", containerPath),
+    "param partitionKeyPath string = '/id'\n\nresource container 'Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers@2023-11-15' = {\n  name: 'Todos'\n}\n"
+  );
+}
+
 function createNativeBackendFixture(rootDir: string, backendLanguage: "csharp" | "python"): void {
   createProjectFixture(rootDir);
   writeFile(
@@ -254,6 +267,94 @@ describe("plan / apply / drift / verify machine commands", () => {
     ]);
   });
 
+  it("updates baseline-owned model artifacts without creating a second container migration", async () => {
+    createNativeBackendFixture(tempDir, "csharp");
+    writeFile(path.join(tempDir, "shared", "models", "answer-record.ts"), createModelSource("AnswerRecord"));
+    createInfrastructureFixture(tempDir);
+    addLegacyContainerToInfrastructure(tempDir, "answer-record");
+    const original = initializeLegacyMigrations(tempDir);
+    const restoreCodegenMocks = mockSuccessfulNativeCodegen();
+
+    try {
+      const baselineModelApply = await runMachine(machineArgs("apply", "scaffold", "answer-record"));
+      expect(baselineModelApply.exitCode).toBe(0);
+      expect(loadMigrationManifest(tempDir).migrations).toEqual([]);
+
+      writeFile(
+        path.join(tempDir, "shared", "models", "written-mock-session.ts"),
+        createModelSource("WrittenMockSession")
+      );
+      const newModelApply = await runMachine(machineArgs("apply", "scaffold", "written-mock-session"));
+      expect(newModelApply.exitCode).toBe(0);
+      expect(loadMigrationManifest(tempDir).migrations).toEqual([
+        expect.objectContaining({
+          version: 1,
+          slug: "create-written-mock-session-container",
+          sourceModel: "WrittenMockSession",
+        }),
+      ]);
+
+      writeFile(
+        path.join(tempDir, "shared", "models", "answer-record.ts"),
+        createModelSource("AnswerRecord", "\n  writtenMockSessionId: z.string().optional(),")
+      );
+      const plan = await runMachine(machineArgs("plan", "scaffold", "answer-record"));
+
+      expect(plan.exitCode).toBe(0);
+      expect(plan.response.ok).toBe(true);
+      expect(plan.response.data.operations).toEqual(expect.arrayContaining([
+        expect.objectContaining({ path: "functions/openapi/answer-record.openapi.json", action: "update" }),
+        expect.objectContaining({
+          path: "functions/generated/csharp-models/src/SwallowKitBackendModels/Model/AnswerRecord.cs",
+          action: "update",
+        }),
+        expect.objectContaining({ path: "app/answer-record/_components/AnswerRecordForm.tsx", action: "update" }),
+      ]));
+      expect(plan.response.data.operations).not.toEqual(expect.arrayContaining([
+        expect.objectContaining({ path: expect.stringContaining("infra/migrations/0002-") }),
+      ]));
+      expect(plan.response.data.operations).not.toEqual(expect.arrayContaining([
+        expect.objectContaining({ path: MIGRATION_MANIFEST_PATH.replace(/\\/g, "/") }),
+      ]));
+
+      const apply = await runMachine(machineArgs("apply", "scaffold", "--plan", plan.response.data.planId));
+      expect(apply.exitCode).toBe(0);
+      const updated = loadMigrationManifest(tempDir);
+      expect(updated.migrations).toHaveLength(1);
+      expect(updated.baseline).toEqual(original.baseline);
+
+      const verify = await runMachine(machineArgs("verify", "project", "--checks", "structure,drift"));
+      expect(verify.exitCode).toBe(0);
+      expect(verify.response.ok).toBe(true);
+      expect(verify.response.data.summary.done).toBe(true);
+    } finally {
+      restoreCodegenMocks();
+    }
+  });
+
+  it("requires an explicit migration when a baseline-owned container partition key changes", async () => {
+    createProjectFixture(tempDir);
+    writeFile(
+      path.join(tempDir, "shared", "models", "todo.ts"),
+      `${createModelSource("Todo")}\nexport const partitionKey = '/tenantId';\n`
+    );
+    createInfrastructureFixture(tempDir);
+    addLegacyContainerToInfrastructure(tempDir, "todo");
+    initializeLegacyMigrations(tempDir);
+
+    const plan = await runMachine(machineArgs("plan", "scaffold", "todo", "--api-only"));
+
+    expect(plan.exitCode).toBe(1);
+    expect(plan.response.ok).toBe(false);
+    expect(plan.response.status).toBe("blocked");
+    expect(plan.response.error.code).toBe("baseline-container-configuration-change");
+    expect(plan.response.error.details).toEqual(expect.objectContaining({
+      baselinePartitionKey: "/id",
+      requestedPartitionKey: "/tenantId",
+    }));
+    expect(fs.existsSync(path.join(tempDir, "infra", "migrations", "0001-create-todo-container"))).toBe(false);
+  });
+
   it("uses the same approval-free manifest update for a non-legacy project", async () => {
     createProjectFixture(tempDir);
     createInfrastructureFixture(tempDir);