@rigkit/engine 0.2.6 → 0.2.8

package/src/engine.test.ts

@@ -28,7 +28,7 @@ describe("DevMachineEngine workflow runtime", () => {
         });
 
         const base = app.sequence("base").task("first", async ({ step, test }) => {
-          step.log("preparing base\\n", { label: "setup" });
+          console.log("preparing base");
           const vm = await test.createVm();
           await vm.exec("touch /tmp/first", { name: "touch first" });
           if (!(await vm.exists("/tmp/first"))) throw new Error("first was not created");
@@ -138,8 +138,7 @@ describe("DevMachineEngine workflow runtime", () => {
       type: "log.output",
       nodePath: "base.first",
       stream: "info",
-      label: "setup",
-      data: "preparing base\n",
+      data: "preparing base",
     });
     expect(provider.snapshots).toHaveLength(2);
     expect(engine.listNodeRuns()).toHaveLength(4);
@@ -502,6 +501,165 @@ describe("DevMachineEngine workflow runtime", () => {
     expect(second.listNodeRuns()).toHaveLength(2);
   });
 
+  test("stores globally scoped sequence runs in fragment state and busts downstream local cache", async () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-global-fragment-"));
+    const statePath = join(projectDir, ".rigkit", "state.sqlite");
+    const fragmentRoot = join(projectDir, "fragments");
+    mkdirSync(join(projectDir, ".rigkit"));
+
+    const writeConfig = (configPath: string, value: string) =>
+      writeFileSync(
+        configPath,
+        `
+          import { sequence } from "${import.meta.dir}/index.ts";
+
+          const deps = sequence("deps")
+            .configure({ value: "${value}" })
+            .task("prepare", async ({ config }) => ({ ctx: { value: String(config.value) } }))
+            .global();
+
+          export default sequence("site")
+            .add(deps)
+            .task("install", async ({ step }) => ({ ctx: { installed: step.ctx.value } }));
+        `,
+      );
+
+    const firstConfigPath = join(projectDir, "rig.one.config.ts");
+    const secondConfigPath = join(projectDir, "rig.two.config.ts");
+    writeConfig(firstConfigPath, "one");
+    writeConfig(secondConfigPath, "two");
+
+    const engineOptions = {
+      projectDir,
+      statePath,
+      globalFragmentStateLocator: (fragment: { hash: string }) => ({
+        statePath: join(fragmentRoot, fragment.hash, "state.sqlite"),
+      }),
+    };
+
+    const first = await createDevMachineEngine({ ...engineOptions, configPath: firstConfigPath });
+    await first.load();
+    await first.apply();
+    expect((await first.plan()).cachedNodeCount).toBe(2);
+    expect(first.listNodeRuns().map((run) => run.nodePath)).toEqual(["install"]);
+
+    const fragmentHashes = readdirSync(fragmentRoot);
+    expect(fragmentHashes).toHaveLength(1);
+    const fragmentDb = new Database(join(fragmentRoot, fragmentHashes[0]!, "state.sqlite"));
+    const fragmentRuns = fragmentDb
+      .query<{ node_path: string }, []>("select node_path from workflow_node_runs order by node_path")
+      .all();
+    fragmentDb.close();
+    expect(fragmentRuns.map((run) => run.node_path)).toEqual(["deps.prepare"]);
+
+    const cache = await first.listCache();
+    expect(cache.entries.map((entry) => entry.scope).sort()).toEqual(["global", "local"]);
+
+    const second = await createDevMachineEngine({ ...engineOptions, configPath: secondConfigPath });
+    await second.load();
+    const changed = await second.plan();
+    expect(changed.cachedNodeCount).toBe(0);
+
+    const reapplied = await second.apply();
+    expect(reapplied.context.installed).toBe("two");
+    expect(readdirSync(fragmentRoot)).toHaveLength(2);
+  });
+
+  test("allows a later local task to invalidate an earlier global fragment task", async () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-global-invalidates-"));
+    const statePath = join(projectDir, ".rigkit", "state.sqlite");
+    const fragmentRoot = join(projectDir, "fragments");
+    mkdirSync(join(projectDir, ".rigkit"));
+
+    const previous = {
+      installCount: process.env.RIGKIT_GLOBAL_INSTALL_COUNT,
+      authCount: process.env.RIGKIT_GLOBAL_AUTH_COUNT,
+      repoCount: process.env.RIGKIT_LOCAL_REPO_COUNT,
+      checkCount: process.env.RIGKIT_LOCAL_CHECK_COUNT,
+      forceReauth: process.env.RIGKIT_FORCE_GLOBAL_REAUTH,
+    };
+    process.env.RIGKIT_GLOBAL_INSTALL_COUNT = "0";
+    process.env.RIGKIT_GLOBAL_AUTH_COUNT = "0";
+    process.env.RIGKIT_LOCAL_REPO_COUNT = "0";
+    process.env.RIGKIT_LOCAL_CHECK_COUNT = "0";
+    process.env.RIGKIT_FORCE_GLOBAL_REAUTH = "0";
+
+    writeFileSync(
+      join(projectDir, "rig.config.ts"),
+      `
+        import { sequence } from "${import.meta.dir}/index.ts";
+
+        const base = sequence("base")
+          .task("install", async () => {
+            const count = Number(process.env.RIGKIT_GLOBAL_INSTALL_COUNT ?? "0") + 1;
+            process.env.RIGKIT_GLOBAL_INSTALL_COUNT = String(count);
+            return { ctx: { installed: "install-" + count } };
+          })
+          .task("auth", async ({ step }) => {
+            const count = Number(process.env.RIGKIT_GLOBAL_AUTH_COUNT ?? "0") + 1;
+            process.env.RIGKIT_GLOBAL_AUTH_COUNT = String(count);
+            return { ctx: { ...step.ctx, token: "token-" + count } };
+          })
+          .global();
+
+        const repo = sequence("repo")
+          .task("clone", async ({ step }) => {
+            const count = Number(process.env.RIGKIT_LOCAL_REPO_COUNT ?? "0") + 1;
+            process.env.RIGKIT_LOCAL_REPO_COUNT = String(count);
+            return { ctx: { ...step.ctx, repoToken: step.ctx.token, repoCount: count } };
+          });
+
+        export default sequence("root")
+          .add(base)
+          .add(repo)
+          .task("check-auth", { cacheTTL: 0 }, async ({ step }) => {
+            const count = Number(process.env.RIGKIT_LOCAL_CHECK_COUNT ?? "0") + 1;
+            process.env.RIGKIT_LOCAL_CHECK_COUNT = String(count);
+            if (process.env.RIGKIT_FORCE_GLOBAL_REAUTH === "1") {
+              process.env.RIGKIT_FORCE_GLOBAL_REAUTH = "0";
+              return step.invalidate("auth");
+            }
+            return { ctx: step.ctx };
+          });
+      `,
+    );
+
+    try {
+      const engine = await createDevMachineEngine({
+        projectDir,
+        statePath,
+        globalFragmentStateLocator: (fragment: { hash: string }) => ({
+          statePath: join(fragmentRoot, fragment.hash, "state.sqlite"),
+        }),
+      });
+      await engine.load();
+
+      const first = await engine.apply();
+      expect(first.context.token).toBe("token-1");
+      expect(first.context.repoToken).toBe("token-1");
+      expect(process.env.RIGKIT_GLOBAL_INSTALL_COUNT).toBe("1");
+      expect(process.env.RIGKIT_GLOBAL_AUTH_COUNT).toBe("1");
+      expect(process.env.RIGKIT_LOCAL_REPO_COUNT).toBe("1");
+      expect(process.env.RIGKIT_LOCAL_CHECK_COUNT).toBe("1");
+
+      process.env.RIGKIT_FORCE_GLOBAL_REAUTH = "1";
+      const second = await engine.apply();
+      expect(second.context.token).toBe("token-2");
+      expect(second.context.repoToken).toBe("token-2");
+      expect(process.env.RIGKIT_GLOBAL_INSTALL_COUNT).toBe("1");
+      expect(process.env.RIGKIT_GLOBAL_AUTH_COUNT).toBe("2");
+      expect(process.env.RIGKIT_LOCAL_REPO_COUNT).toBe("2");
+      expect(process.env.RIGKIT_LOCAL_CHECK_COUNT).toBe("3");
+      expect(readdirSync(fragmentRoot)).toHaveLength(1);
+    } finally {
+      restoreEnv("RIGKIT_GLOBAL_INSTALL_COUNT", previous.installCount);
+      restoreEnv("RIGKIT_GLOBAL_AUTH_COUNT", previous.authCount);
+      restoreEnv("RIGKIT_LOCAL_REPO_COUNT", previous.repoCount);
+      restoreEnv("RIGKIT_LOCAL_CHECK_COUNT", previous.checkCount);
+      restoreEnv("RIGKIT_FORCE_GLOBAL_REAUTH", previous.forceReauth);
+    }
+  });
+
   test("stores provider JSON state in Rigkit-owned provider storage", async () => {
     const projectDir = mkdtempSync(join(tmpdir(), "rigkit-"));
     const plugin: BaseProviderPlugin = {