okengine 0.13.0 → 0.15.2

package/src/compiler/extract.test.ts

@@ -105,22 +105,24 @@ describe("extractManifest — fx.raw", () => {
 });
 
 describe("extractManifest — performance", () => {
-  test("200-flow synthetic app extracts in under 2s", async () => {
-    const sources: Record<string, string> = {};
-    const parts: string[] = [
-      `import { on, flow, http, store } from "okengine";`,
-      `export const db = store.sql("db");`,
-      `export const items = { name: "items" };`,
-      `export const app = { name: "synth" };`,
-    ];
-    // Declare oke name via a tiny app file pattern
-    sources["src/app.ts"] = `
+  test(
+    "200-flow synthetic app extracts in under 2s",
+    async () => {
+      const sources: Record<string, string> = {};
+      const parts: string[] = [
+        `import { on, flow, http, store } from "okengine";`,
+        `export const db = store.sql("db");`,
+        `export const items = { name: "items" };`,
+        `export const app = { name: "synth" };`,
+      ];
+      // Declare oke name via a tiny app file pattern
+      sources["src/app.ts"] = `
       import { oke } from "okengine";
       export const app = oke({ name: "synth200" });
     `;
 
-    for (let i = 0; i < 200; i++) {
-      parts.push(`
+      for (let i = 0; i < 200; i++) {
+        parts.push(`
 export const flow_${i} = on(
   http.get("/f/${i}"),
   flow("synth.flow_${i}", {
@@ -132,16 +134,22 @@ export const flow_${i} = on(
   }),
 );
 `);
-    }
-    sources["src/flows/all.ts"] = parts.join("\n");
-
-    const start = performance.now();
-    const manifest = await extractFromSources(sources);
-    const elapsed = performance.now() - start;
-
-    expect(Object.keys(manifest.flows ?? {}).length).toBe(200);
-    expect(elapsed).toBeLessThan(2000);
-  });
+      }
+      sources["src/flows/all.ts"] = parts.join("\n");
+
+      await extractFromSources(sources);
+      const start = performance.now();
+      const manifest = await extractFromSources(sources);
+      const elapsed = performance.now() - start;
+
+      expect(Object.keys(manifest.flows ?? {}).length).toBe(200);
+      // Local ~400ms after warmup. GHA shared runners measured ~2.9s cold.
+      // Warmup + extract exceeds Bun's 5s default (v0.15.0 tag timed out at 5.6s).
+      const budgetMs = process.env.CI ? 4_000 : 2_000;
+      expect(elapsed).toBeLessThan(budgetMs);
+    },
+    { timeout: 15_000 },
+  );
 });
 
 describe("serializeManifest stability", () => {
@@ -238,6 +246,32 @@ export const db = store.sql("app", { schema: { notes } });
     });
   });
 
+  test("extracts RLS helpers onto store.tables", async () => {
+    const source = `
+import { store, field } from "okengine";
+
+export const bookings = store.schema.table("bookings", {
+  id: field.text().primaryKey(),
+  owner: field.text().notNull(),
+}, [
+  store.schema.policy.gate("member", { for: "select" }),
+  store.schema.policy.owner("owner"),
+]);
+
+export const db = store.sql("app", { schema: { bookings } });
+`;
+    const manifest = await extractFromSources({
+      "src/schema.decl.ts": source,
+    });
+    const table = manifest.stores?.app?.tables?.bookings;
+    expect(table?.rls).toBe(true);
+    expect(table?.policies?.gate_member_select).toMatchObject({
+      for: "select",
+      using: "oke.gate() = 'member'",
+    });
+    expect(table?.policies?.owner_owner_all?.using).toContain("oke.user()");
+  });
+
   test("extracts optional description fields additively", async () => {
     const source = `
 import { store, field, signal, channel, clock, gate, vault } from "okengine";
@@ -465,6 +499,27 @@ export const remove = mounted.remove;
     expect(manifest.flows?.update?.live).toBeUndefined();
     expect(manifest.flows?.remove?.live).toBeUndefined();
   });
+
+  test("chains .public().live() onto the five verbs", async () => {
+    const source = `
+import { on, http, store } from "okengine";
+
+export const db = store.sql("notes", { schema: {} });
+const notesR = store.resource(db, {}, {});
+const mounted = on(http.resource("/notes", notesR.all()).public().live());
+
+export const list = mounted.list;
+export const create = mounted.create;
+export const get = mounted.get;
+export const update = mounted.update;
+export const remove = mounted.remove;
+`;
+    const manifest = await extractFromSources({ "src/flows/notes.ts": source });
+    expect(manifest.flows?.list?.gates).toEqual(["public"]);
+    expect(manifest.flows?.create?.gates).toEqual(["public"]);
+    expect(manifest.flows?.get?.live).toBe(true);
+    expect(manifest.flows?.create?.live).toBeUndefined();
+  });
 });
 
 describe("extractManifest — vault.config", () => {
@@ -509,7 +564,7 @@ import { on, flow, http, gate, store } from "okengine";
 export const files = store.files("uploads");
 
 export const attach = on(
-  http.post("/attach").gate.public,
+  http.post("/attach").public(),
   flow("notes.attach", {
     do: async (input, fx) => {
       await fx.store(files).put("key", input.text);
@@ -530,7 +585,7 @@ import { on, flow, http, gate, store } from "okengine";
 export const files = store.files("uploads");
 
 export const attach = on(
-  http.post("/attach").gate.public,
+  http.post("/attach").public(),
   flow("notes.attachImage", {
     do: async (input, fx) => {
       await fx.store(files).putImage("key", input.bytes);
@@ -598,6 +653,25 @@ export const expire = on(
   });
 });
 
+describe("extractManifest — fx.deadLetters", () => {
+  test("fx.deadLetters(signal) infers reads: [signal:<name>]", async () => {
+    const source = `
+import { on, flow, http, signal } from "okengine";
+
+export const notify = signal("notify", { delivery: "once" });
+
+export const failed = on(
+  http.get("/notifications/failed").public(),
+  flow("notifications.failed", {
+    do: async (input, fx) => fx.json.withQuery(await fx.deadLetters(notify), input),
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/failed.ts": source });
+    expect(manifest.flows?.["notifications.failed"]?.effects?.reads).toEqual(["signal:notify"]);
+  });
+});
+
 describe("extractManifest — channel medium binder aliasing", () => {
   test("mail.template(...) resolves through `const mail = channel.email(...)`", async () => {
     const source = `
@@ -610,7 +684,7 @@ export const noteCreatedMail = mail.template("note-created", {
 });
 
 export const onCreated = on(
-  http.post("/hook").gate.public,
+  http.post("/hook").public(),
   flow("notes.onCreated", {
     do: async (payload, fx) => {
       await fx.send(noteCreatedMail, { to: "you@localhost", data: payload });
@@ -633,7 +707,7 @@ const otp = channel.sms({});
 export const otpTemplate = otp.template("otp-code", {});
 
 export const send = on(
-  http.post("/otp").gate.public,
+  http.post("/otp").public(),
   flow("notes.sendOtp", {
     do: async (payload, fx) => {
       await fx.send(otpTemplate, { to: "+10000000000", data: payload });
@@ -716,19 +790,32 @@ export const decoy = flow("checkout.realName", {
   });
 });
 
-describe("extractManifest — .gate.public", () => {
-  test("reads the public sentinel from a member chain", async () => {
+describe("extractManifest — .public()", () => {
+  test("reads the public sentinel from .public()", async () => {
     const source = `
 import { on, flow, http } from "okengine";
 
 export const health = on(
-  http.get("/health").gate.public,
+  http.get("/health").public(),
   flow("health.check", { do: () => ({ ok: true }) }),
 );
 `;
     const manifest = await extractFromSources({ "src/flows/health.ts": source });
     expect(manifest.flows?.["health.check"]?.gates).toEqual(["public"]);
   });
+
+  test("does not treat the removed .gate.public property as attach", async () => {
+    const source = `
+import { on, flow, http } from "okengine";
+
+export const health = on(
+  http.get("/health").gate.public,
+  flow("health.check", { do: () => ({ ok: true }) }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/health.ts": source });
+    expect(manifest.flows?.["health.check"]?.gates).toBeUndefined();
+  });
 });
 
 describe("extractManifest — gate.all", () => {
@@ -776,3 +863,345 @@ export const create = on(
     expect(manifest.gates?.WRITE).toBeUndefined();
   });
 });
+
+describe("extractManifest — ai.mcpServer", () => {
+  test("stamps mcpServers and infers mcp: calls from .tool()", async () => {
+    const source = `
+import { ai, flow, on, http, vault } from "okengine";
+
+export const token = vault.secret("GITHUB_TOKEN");
+export const github = ai.mcpServer("github", {
+  url: "https://mcp.example/github",
+  auth: { bearer: token },
+  tools: ["create_issue"],
+});
+
+export const triage = on(
+  http.post("/triage"),
+  flow("support.triage", {
+    do: async (input, fx) => {
+      await fx.ask("ticket-triage", input, { tools: [github.tool("create_issue")] });
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/ai.ts": source });
+    expect(manifest.ai?.mcpServers?.github).toEqual({
+      url: "https://mcp.example/github",
+      auth: "GITHUB_TOKEN",
+      tools: ["create_issue"],
+    });
+    expect(manifest.flows?.["support.triage"]?.effects?.calls).toEqual(["mcp:github/create_issue"]);
+  });
+});
+
+describe("extractManifest — file-tree stamps", () => {
+  test("pathless http.get() in notes/[id]/get.ts infers /notes/:id and notes.get", async () => {
+    const source = `
+import { on, flow, http } from "okengine";
+export const get = on(
+  http.get().public(),
+  flow({ do: (input) => input }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/notes/[id]/get.ts": source });
+    expect(manifest.flows?.["notes.get"]?.trigger).toEqual({
+      http: { method: "GET", path: "/notes/:id" },
+    });
+  });
+
+  test("nameless flow({ do }) still appears on the Manifest", async () => {
+    const source = `
+import { flow } from "okengine";
+export const ping = flow({ do: () => ({ ok: true }) });
+`;
+    const manifest = await extractFromSources({ "src/flows/notes/ping.ts": source });
+    expect(manifest.flows?.["notes.ping"]).toBeDefined();
+  });
+
+  test("effects are identical for the same do body in a tree file vs a barrel", async () => {
+    const doBody = `
+      const rows = await fx.store(db).select().from(notes);
+      await fx.emit(noteCreated, { id: "1" });
+      await fx.call("notes.ping");
+      return rows;
+    `;
+    const barrel = `
+import { on, flow, http, store, signal } from "okengine";
+export const db = store.sql("db");
+export const notes = { name: "notes" };
+export const noteCreated = signal("note-created");
+export const get = on(
+  http.get("/notes/:id").public(),
+  flow("notes.get", {
+    do: async (_input, fx) => {${doBody}},
+  }),
+);
+`;
+    const tree = `
+import { on, flow, http, store, signal } from "okengine";
+export const db = store.sql("db");
+export const notes = { name: "notes" };
+export const noteCreated = signal("note-created");
+export const get = on(
+  http.get().public(),
+  flow({
+    do: async (_input, fx) => {${doBody}},
+  }),
+);
+`;
+    const barrelManifest = await extractFromSources({ "src/flows/notes/index.ts": barrel });
+    const treeManifest = await extractFromSources({ "src/flows/notes/[id]/get.ts": tree });
+    const barrelFx = barrelManifest.flows?.["notes.get"]?.effects;
+    const treeFx = treeManifest.flows?.["notes.get"]?.effects;
+    expect(treeFx).toEqual(barrelFx);
+    expect(treeFx?.reads).toBeDefined();
+    expect(treeFx?.emits).toBeDefined();
+    expect(treeFx?.calls).toBeDefined();
+    expect(treeFx?.reads?.length).toBeGreaterThan(0);
+    expect(treeFx?.emits?.length).toBeGreaterThan(0);
+    expect(treeFx?.calls?.length).toBeGreaterThan(0);
+  });
+});
+
+describe("extractManifest — flow in/out schema expansion", () => {
+  test("expands z.object identifiers into JSON Schema fields", async () => {
+    const source = `
+import { flow } from "okengine";
+import { z } from "zod";
+
+export const TaskCreateIn = z.object({
+  title: z.string().min(1).max(500),
+  spaceKey: z.string().min(1),
+  priority: z.number().int().min(0).max(4).optional(),
+});
+
+export const TaskCreateOut = z.object({
+  id: z.string(),
+  identifier: z.string(),
+});
+
+export const create = flow("tasks.create", {
+  in: TaskCreateIn,
+  out: TaskCreateOut,
+  do: async () => ({ id: "1", identifier: "ENG-1" }),
+});
+`;
+    const manifest = await extractFromSources({ "src/flows/tasks/shapes.ts": source });
+    expect(manifest.flows?.["tasks.create"]?.in).toEqual({
+      type: "object",
+      properties: {
+        title: { type: "string", minLength: 1, maxLength: 500 },
+        spaceKey: { type: "string", minLength: 1 },
+        priority: { type: "integer", minimum: 0, maximum: 4 },
+      },
+      required: ["title", "spaceKey"],
+    });
+    expect(manifest.flows?.["tasks.create"]?.out).toEqual({
+      type: "object",
+      properties: {
+        id: { type: "string" },
+        identifier: { type: "string" },
+      },
+      required: ["id", "identifier"],
+    });
+  });
+
+  test("expands drizzle-orm/zod createSelect/Insert/UpdateSchema from table columns", async () => {
+    const schema = `
+import { store, field, id, now } from "okengine";
+
+export const users = store.schema.table("users", {
+  id: field.text().primaryKey().defaultFn(id),
+  name: field.text().notNull(),
+  age: field.integer().notNull(),
+  bio: field.text(),
+  createdAt: field.integer().notNull().defaultFn(now),
+});
+`;
+    const flows = `
+import { flow } from "okengine";
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from "drizzle-orm/zod";
+import { users } from "../schema.decl.ts";
+
+export const userSelect = createSelectSchema(users);
+export const userInsert = createInsertSchema(users);
+export const userUpdate = createUpdateSchema(users);
+
+export const create = flow("users.create", {
+  in: userInsert,
+  out: userSelect,
+  do: async () => ({}),
+});
+
+export const patch = flow("users.patch", {
+  in: userUpdate,
+  do: async () => ({}),
+});
+`;
+    const manifest = await extractFromSources({
+      "src/schema.decl.ts": schema,
+      "src/flows/users.ts": flows,
+    });
+    const insert = manifest.flows?.["users.create"]?.in as {
+      properties?: Record<string, unknown>;
+      required?: string[];
+    };
+    expect(insert?.properties).toMatchObject({
+      name: { type: "string" },
+      age: { type: "integer" },
+      bio: { type: "string" },
+      createdAt: { type: "integer" },
+    });
+    expect(insert?.properties?.id).toBeUndefined();
+    expect(insert?.required).toEqual(["name", "age"]);
+
+    const select = manifest.flows?.["users.create"]?.out as {
+      properties?: Record<string, unknown>;
+      required?: string[];
+    };
+    expect(select?.properties?.id).toMatchObject({ type: "string", primaryKey: true });
+    expect(select?.required).toEqual(expect.arrayContaining(["id", "name", "age", "createdAt"]));
+    expect(select?.required).not.toContain("bio");
+
+    const update = manifest.flows?.["users.patch"]?.in as {
+      properties?: Record<string, unknown>;
+      required?: string[];
+    };
+    expect(update?.properties?.name).toMatchObject({ type: "string" });
+    expect(update?.properties?.id).toBeUndefined();
+    expect(update?.required).toBeUndefined();
+  });
+
+  test("expands tableZod(table).select / .insert and .pick()", async () => {
+    const schema = `
+import { store, field, id } from "okengine";
+export const spaces = store.schema.table("spaces", {
+  id: field.text().primaryKey().defaultFn(id),
+  key: field.text().notNull().unique(),
+  name: field.text().notNull(),
+  color: field.text(),
+});
+`;
+    const zod = `
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from "drizzle-orm/zod";
+export function tableZod(table) {
+  return {
+    select: createSelectSchema(table),
+    insert: createInsertSchema(table),
+    update: createUpdateSchema(table),
+  };
+}
+export const spacesZod = tableZod(spaces);
+`;
+    const flows = `
+import { flow } from "okengine";
+export const create = flow("spaces.create", {
+  in: spacesZod.insert,
+  out: spacesZod.select.pick({ id: true, key: true }),
+  do: async () => ({}),
+});
+`;
+    const manifest = await extractFromSources({
+      "src/schema.decl.ts": schema,
+      "src/db/zod.ts": zod,
+      "src/flows/spaces.ts": flows,
+    });
+    expect(manifest.flows?.["spaces.create"]?.in).toMatchObject({
+      type: "object",
+      properties: {
+        key: { type: "string", unique: true },
+        name: { type: "string" },
+        color: { type: "string" },
+      },
+      required: ["key", "name"],
+    });
+    expect(manifest.flows?.["spaces.create"]?.out).toEqual({
+      type: "object",
+      properties: {
+        id: { type: "string", primaryKey: true },
+        key: { type: "string", unique: true },
+      },
+      required: ["id", "key"],
+    });
+  });
+
+  test("bindCrud stamps createIn / out onto CRUD flows", async () => {
+    const source = `
+import { store, field, id } from "okengine";
+import { z } from "zod";
+
+export const notes = store.schema.table("notes", {
+  id: field.text().primaryKey().defaultFn(id),
+  title: field.text().notNull(),
+});
+
+const createIn = z.object({
+  title: z.string().min(1),
+});
+
+export const { list, create, get, update, remove } = bindCrud({
+  unit: "notes",
+  path: "/notes",
+  table: notes,
+  createIn,
+  out: createSelectSchema(notes),
+});
+`;
+    const manifest = await extractFromSources({ "src/flows/notes/index.ts": source });
+    expect(manifest.flows?.["notes.create"]?.in).toEqual({
+      type: "object",
+      properties: { title: { type: "string", minLength: 1 } },
+      required: ["title"],
+    });
+    expect(manifest.flows?.["notes.get"]?.out).toMatchObject({
+      type: "object",
+      properties: {
+        id: { type: "string", primaryKey: true },
+        title: { type: "string" },
+      },
+    });
+    expect(manifest.flows?.["notes.list"]?.in).toMatchObject({
+      type: "object",
+      properties: { q: { type: "string" }, limit: { type: "integer" } },
+    });
+    expect((manifest.flows?.["notes.update"]?.in as { required?: string[] }).required).toContain(
+      "id",
+    );
+  });
+
+  test("same-named createIn stays file-local (does not leak across units)", async () => {
+    const spaces = `
+import { flow } from "okengine";
+import { z } from "zod";
+const createIn = z.object({ key: z.string(), name: z.string() });
+export const create = flow("spaces.create", {
+  in: createIn,
+  do: async () => ({}),
+});
+`;
+    const views = `
+import { flow } from "okengine";
+import { z } from "zod";
+const createIn = z.object({ kind: z.enum(["list", "board"]) });
+export const create = flow("views.create", {
+  in: createIn,
+  do: async () => ({}),
+});
+`;
+    const manifest = await extractFromSources({
+      "src/flows/spaces/index.ts": spaces,
+      "src/flows/views/index.ts": views,
+    });
+    expect(manifest.flows?.["spaces.create"]?.in).toEqual({
+      type: "object",
+      properties: { key: { type: "string" }, name: { type: "string" } },
+      required: ["key", "name"],
+    });
+    expect(manifest.flows?.["views.create"]?.in).toEqual({
+      type: "object",
+      properties: { kind: { type: "string", enum: ["list", "board"] } },
+      required: ["kind"],
+    });
+  });
+});