@cosmicdrift/kumiko-framework 1.0.0 → 2.0.0

package/src/engine/feature-ast/__tests__/patch.test.ts

@@ -301,21 +301,47 @@ describe("patch coverage for the remaining pattern-kinds", () => {
     expect(parseSourceFile(sf).patterns.find((p) => p.kind === "authClaims")).toBeUndefined();
   });
 
-  test("add + remove via PatternId for eventMigration (event+versions key)", () => {
+  test("add + remove via PatternId for defineEvent with migrations", () => {
     const sf = makeSourceFile(STARTER);
-    createFeaturePatcher(sf).addEventMigration({
-      event: "itemCreated",
-      fromVersion: 1,
-      toVersion: 2,
-      transformSource: "(old) => old",
+    createFeaturePatcher(sf).addDefineEvent({
+      name: "itemCreated",
+      schemaSource: "z.object({ id: z.string() })",
+      version: 2,
+      migrations: { "1": "(old) => old" },
     });
-    removePattern(sf, {
-      kind: "eventMigration",
-      eventName: "itemCreated",
-      fromVersion: 1,
-      toVersion: 2,
+    removePattern(sf, { kind: "defineEvent", eventName: "itemCreated" });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "defineEvent")).toBeUndefined();
+  });
+
+  test("add + remove via PatternId for nav (id key)", () => {
+    const sf = makeSourceFile(STARTER);
+    createFeaturePatcher(sf).addNav({
+      definition: { id: "items", label: "Items", screen: "inventory:screen:list" },
+    });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "nav")).toBeDefined();
+    removePattern(sf, { kind: "nav", id: "items" });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "nav")).toBeUndefined();
+  });
+
+  test("add + remove via PatternId for workspace (id key)", () => {
+    const sf = makeSourceFile(STARTER);
+    createFeaturePatcher(sf).addWorkspace({ definition: { id: "admin", label: "Admin" } });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "workspace")).toBeDefined();
+    removePattern(sf, { kind: "workspace", id: "admin" });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "workspace")).toBeUndefined();
+  });
+
+  test("add + remove via PatternId for extendsRegistrar (extensionName key)", () => {
+    const sf = makeSourceFile(STARTER);
+    addPattern(sf, {
+      kind: "extendsRegistrar",
+      source: SAMPLE_LOC,
+      extensionName: "auditLog",
+      defBody: { ...SAMPLE_LOC, raw: "{ hooks: {} }" },
     });
-    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "eventMigration")).toBeUndefined();
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "extendsRegistrar")).toBeDefined();
+    removePattern(sf, { kind: "extendsRegistrar", extensionName: "auditLog" });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "extendsRegistrar")).toBeUndefined();
   });
 });
 
@@ -358,3 +384,171 @@ defineFeature("legacy", (r) => {
     expect(text).not.toContain('r.entity("item"');
   });
 });
+
+describe("addPattern — error paths", () => {
+  test("throws when no defineFeature call is present", () => {
+    const sf = makeSourceFile("export const x = 1;");
+    expect(() => addPattern(sf, newSecretPattern)).toThrow(/no defineFeature/);
+  });
+});
+
+describe("callMatchesId — positional and object-form lookups", () => {
+  const LEGACY = `
+import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+
+defineFeature("legacy", (r) => {
+  r.relation("task", "owner", { kind: "belongsTo", to: "user" });
+
+  r.hook("postSave", "task", () => {});
+
+  r.hook("preDelete", { allOf: "task" }, () => {});
+
+  r.job("nightly", { trigger: { cron: "0 0 * * *" } }, async () => {});
+
+  r.writeHandler("task:create", z.object({}), async () => ({}));
+
+  r.queryHandler("task:list", z.object({}), async () => []);
+
+  r.notification("taskCreated", {
+    trigger: { on: "task" },
+    recipient: () => ({}),
+    data: () => ({}),
+  });
+});
+`;
+
+  test("removePattern finds a positional relation by entity+name", () => {
+    const sf = makeSourceFile(LEGACY);
+    removePattern(sf, { kind: "relation", entityName: "task", relationName: "owner" });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "relation")).toBeUndefined();
+  });
+
+  test("removePattern finds a positional hook by type+string target", () => {
+    const sf = makeSourceFile(LEGACY);
+    removePattern(sf, { kind: "hook", hookType: "postSave", target: "task" });
+    expect(parseSourceFile(sf).patterns.filter((p) => p.kind === "hook")).toHaveLength(1);
+  });
+
+  test("removePattern finds a positional hook with an allOf target", () => {
+    const sf = makeSourceFile(LEGACY);
+    removePattern(sf, { kind: "hook", hookType: "preDelete", target: { allOf: "task" } });
+    expect(parseSourceFile(sf).patterns.filter((p) => p.kind === "hook")).toHaveLength(1);
+  });
+
+  test("removePattern finds a positional job by name", () => {
+    const sf = makeSourceFile(LEGACY);
+    removePattern(sf, { kind: "job", jobName: "nightly" });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "job")).toBeUndefined();
+  });
+
+  test("removePattern finds a writeHandler by positional name", () => {
+    const sf = makeSourceFile(LEGACY);
+    removePattern(sf, { kind: "writeHandler", handlerName: "task:create" });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "writeHandler")).toBeUndefined();
+  });
+
+  test("removePattern finds a queryHandler by positional name", () => {
+    const sf = makeSourceFile(LEGACY);
+    removePattern(sf, { kind: "queryHandler", handlerName: "task:list" });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "queryHandler")).toBeUndefined();
+  });
+
+  test("removePattern finds a positional notification by name", () => {
+    const sf = makeSourceFile(LEGACY);
+    removePattern(sf, { kind: "notification", notificationName: "taskCreated" });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "notification")).toBeUndefined();
+  });
+});
+
+describe("removePattern — blank-line collapse", () => {
+  test("removing an appended pattern collapses the preceding blank line", () => {
+    const sf = makeSourceFile(STARTER);
+    addPattern(sf, newSecretPattern);
+    const linesBefore = sf.getFullText().split("\n").length;
+    removePattern(sf, { kind: "secret", shortName: "stripeKey" });
+    const linesAfter = sf.getFullText().split("\n").length;
+    expect(linesAfter).toBeLessThan(linesBefore);
+    expect(parseSourceFile(sf).patterns.map((p) => p.kind)).toEqual(["entity", "metric"]);
+  });
+});
+
+describe("replacePattern — object-form hook with allOf target", () => {
+  test("replaces an object-form hook registered with an allOf target", () => {
+    const file = `
+import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+
+defineFeature("hooks", (r) => {
+  r.hook({ type: "postSave", target: { allOf: "task" }, handler: () => {} });
+});
+`;
+    const sf = makeSourceFile(file);
+    replacePattern(
+      sf,
+      { kind: "hook", hookType: "postSave", target: { allOf: "task" } },
+      {
+        kind: "hook",
+        source: SAMPLE_LOC,
+        hookType: "postSave",
+        target: { allOf: "task" },
+        fnBody: { ...SAMPLE_LOC, raw: "() => { /* updated */ }" },
+      },
+    );
+    expect(sf.getFullText()).toContain("/* updated */");
+  });
+});
+describe("callMatchesId — object-form lookups", () => {
+  const OBJECT_FORM = `
+import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+
+defineFeature("object", (r) => {
+  r.relation({ entity: "task", name: "owner", kind: "belongsTo", to: "user" });
+
+  r.job({ name: "nightly", trigger: { cron: "0 0 * * *" }, handler: async () => {} });
+
+  r.useExtension({ name: "audit", entity: "task" });
+
+  r.writeHandler({
+    name: "task:create",
+    schema: z.object({}),
+    handler: async () => ({}),
+  });
+
+  r.notification({
+    name: "taskCreated",
+    trigger: { on: "task" },
+    recipient: () => ({}),
+    data: () => ({}),
+  });
+});
+`;
+
+  test("removePattern finds an object-form relation", () => {
+    const sf = makeSourceFile(OBJECT_FORM);
+    removePattern(sf, { kind: "relation", entityName: "task", relationName: "owner" });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "relation")).toBeUndefined();
+  });
+
+  test("removePattern finds an object-form job", () => {
+    const sf = makeSourceFile(OBJECT_FORM);
+    removePattern(sf, { kind: "job", jobName: "nightly" });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "job")).toBeUndefined();
+  });
+
+  test("removePattern finds an object-form useExtension", () => {
+    const sf = makeSourceFile(OBJECT_FORM);
+    removePattern(sf, { kind: "useExtension", extensionName: "audit", entityName: "task" });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "useExtension")).toBeUndefined();
+  });
+
+  test("removePattern finds an object-form writeHandler", () => {
+    const sf = makeSourceFile(OBJECT_FORM);
+    removePattern(sf, { kind: "writeHandler", handlerName: "task:create" });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "writeHandler")).toBeUndefined();
+  });
+
+  test("removePattern finds an object-form notification", () => {
+    const sf = makeSourceFile(OBJECT_FORM);
+    removePattern(sf, { kind: "notification", notificationName: "taskCreated" });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "notification")).toBeUndefined();
+  });
+});

package/src/engine/feature-ast/__tests__/patcher.test.ts

@@ -120,7 +120,7 @@ describe("FeaturePatcher — typed add helpers for mixed (closure-bearing) patte
     expect(pattern?.kind).toBe("writeHandler");
     if (pattern?.kind === "writeHandler") {
       expect(pattern.handlerName).toBe("task:create");
-      expect(pattern.handlerBody.raw).toContain("isSuccess: true");
+      expect(pattern.handlerBody?.raw).toContain("isSuccess: true");
       expect(pattern.access).toMatchObject({ roles: ["user"] });
     }
   });
@@ -157,48 +157,38 @@ describe("FeaturePatcher — typed add helpers for mixed (closure-bearing) patte
     });
   });
 
-  test("addEntityHook routes type + entity correctly", () => {
+  test("addHook routes entity-wide { allOf } target correctly", () => {
     const sf = makeSourceFile(STARTER);
-    createFeaturePatcher(sf).addEntityHook({
+    createFeaturePatcher(sf).addHook({
       type: "postDelete",
-      entity: "task",
+      target: { allOf: "task" },
       handlerSource: "async (event, ctx) => { /* cleanup */ }",
     });
     const result = parseSourceFile(sf);
     expect(result.patterns[0]).toMatchObject({
-      kind: "entityHook",
+      kind: "hook",
       hookType: "postDelete",
-      entityName: "task",
+      target: { allOf: "task" },
     });
   });
 
-  test("addDefineEvent + addEventMigration form a complete event-versioning chain", () => {
+  test("addDefineEvent with migrations forms a complete event-versioning chain", () => {
     const sf = makeSourceFile(STARTER);
     const p = createFeaturePatcher(sf);
     p.addDefineEvent({
       name: "stepCompleted",
       schemaSource: "z.object({ id: z.string() })",
       version: 2,
-    });
-    p.addEventMigration({
-      event: "stepCompleted",
-      fromVersion: 1,
-      toVersion: 2,
-      transformSource: '(old) => ({ id: old.id ?? "" })',
+      migrations: { "1": '(old) => ({ id: old.id ?? "" })' },
     });
     const result = parseSourceFile(sf);
     expect(result.errors).toEqual([]);
-    expect(result.patterns).toHaveLength(2);
+    expect(result.patterns).toHaveLength(1);
     expect(result.patterns[0]).toMatchObject({
       kind: "defineEvent",
       eventName: "stepCompleted",
       version: 2,
-    });
-    expect(result.patterns[1]).toMatchObject({
-      kind: "eventMigration",
-      eventName: "stepCompleted",
-      fromVersion: 1,
-      toVersion: 2,
+      migrations: { "1": expect.anything() },
     });
   });
 });
@@ -452,9 +442,15 @@ defineFeature("tasks", (r) => {
       handlerSource: "async (q, ctx) => []",
       access: { openToAll: true },
     });
-    p.addEntityHook({
+    p.addStreamHandler({
+      name: "task:stream",
+      schemaSource: "z.object({ prompt: z.string() })",
+      handlerSource: 'async function* (input, ctx) { yield "token"; }',
+      access: { roles: ["user"] },
+    });
+    p.addHook({
       type: "postDelete",
-      entity: "task",
+      target: { allOf: "task" },
       handlerSource: "async (event, ctx) => { /* cascade-clean */ }",
     });
     const result = parseSourceFile(sf);
@@ -463,7 +459,8 @@ defineFeature("tasks", (r) => {
       "entity",
       "writeHandler",
       "queryHandler",
-      "entityHook",
+      "streamHandler",
+      "hook",
     ]);
   });
 });