okengine 0.10.1 → 0.10.2

package/src/compiler/extract.test.ts

@@ -123,8 +123,7 @@ describe("extractManifest — performance", () => {
       parts.push(`
 export const flow_${i} = on(
   http.get("/f/${i}"),
-  flow({
-    name: "synth.flow_${i}",
+  flow("synth.flow_${i}", {
     do: async (input, fx) => {
       await fx.store(db).insert(items).values(input);
       const rows = await fx.store(db).select().from(items);
@@ -166,8 +165,7 @@ export const daily = { name: "daily" };
 
 export const listLinks = on(
   http.get("/links"),
-  flow({
-    name: "rel.root",
+  flow("rel.root", {
     do: async (_input, fx) => {
       return fx.store(db).select().from(links);
     },
@@ -178,8 +176,7 @@ export const listLinks = on(
 // relations, so the related table must NOT appear in effects.
 export const withDaily = on(
   http.get("/links/with-daily"),
-  flow({
-    name: "rel.with",
+  flow("rel.with", {
     do: async (_input, fx) => {
       return fx.store(db).findMany({ with: { daily: true } });
     },
@@ -354,9 +351,7 @@ export const files = store.files("uploads");
 
 export const attach = on(
   http.post("/attach").gate(gate.public),
-  flow({
-    name: "notes.attach",
-    unit: "notes",
+  flow("notes.attach", {
     do: async (input, fx) => {
       await fx.store(files).put("key", input.text);
       return { ok: true };
@@ -377,9 +372,7 @@ export const files = store.files("uploads");
 
 export const attach = on(
   http.post("/attach").gate(gate.public),
-  flow({
-    name: "notes.attachImage",
-    unit: "notes",
+  flow("notes.attachImage", {
     do: async (input, fx) => {
       await fx.store(files).putImage("key", input.bytes);
       return { ok: true };
@@ -400,9 +393,7 @@ export const files = store.files("uploads");
 
 export const sweep = on(
   every("1d"),
-  flow({
-    name: "notes.sweep",
-    unit: "notes",
+  flow("notes.sweep", {
     do: async (_input, fx) => {
       const keys = await fx.store(files).list();
       return { count: keys.length };
@@ -429,9 +420,7 @@ export const noteCreatedMail = mail.template("note-created", {
 
 export const onCreated = on(
   http.post("/hook").gate(gate.public),
-  flow({
-    name: "notes.onCreated",
-    unit: "notes",
+  flow("notes.onCreated", {
     do: async (payload, fx) => {
       await fx.send(noteCreatedMail, { to: "you@localhost", data: payload });
     },
@@ -454,9 +443,7 @@ export const otpTemplate = otp.template("otp-code", {});
 
 export const send = on(
   http.post("/otp").gate(gate.public),
-  flow({
-    name: "notes.sendOtp",
-    unit: "notes",
+  flow("notes.sendOtp", {
     do: async (payload, fx) => {
       await fx.send(otpTemplate, { to: "+10000000000", data: payload });
     },
@@ -469,3 +456,71 @@ export const send = on(
     expect(manifest.channels?.["otp-code"]?.medium).toBe("sms");
   });
 });
+
+describe("extractManifest — flow(name, options) positional signature", () => {
+  test("bare flow(name, {...}) extracts name, in, out, effects", async () => {
+    const source = `
+import { flow } from "okengine";
+
+export const chargeOrder = flow("checkout.chargeOrder", {
+  in: ChargeIn,
+  out: ChargeOut,
+  effects: { reads: ["sql:orders"], writes: ["sql:orders"] },
+  do: async (input, fx) => {
+    return { ok: true };
+  },
+});
+`;
+    const manifest = await extractFromSources({ "src/flows/checkout.ts": source });
+
+    expect(manifest.flows?.["checkout.chargeOrder"]).toBeDefined();
+    expect(manifest.flows?.["checkout.chargeOrder"]?.in).toBeDefined();
+    expect(manifest.flows?.["checkout.chargeOrder"]?.out).toBeDefined();
+    expect(manifest.flows?.["checkout.chargeOrder"]?.effects?.reads).toEqual(["sql:orders"]);
+    expect(manifest.flows?.["checkout.chargeOrder"]?.effects?.writes).toEqual(["sql:orders"]);
+  });
+
+  test("on(trigger, flow(name, {...})) extracts the same shape as bare flow()", async () => {
+    const source = `
+import { on, http, flow } from "okengine";
+
+export const getOrder = on(
+  http.get("/orders/:id"),
+  flow("checkout.getOrder", {
+    out: OrderOut,
+    effects: { reads: ["sql:orders"] },
+    do: async (input, fx) => {
+      return { id: input.id };
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/checkout.ts": source });
+
+    expect(manifest.flows?.["checkout.getOrder"]).toBeDefined();
+    expect(manifest.flows?.["checkout.getOrder"]?.trigger?.http?.method).toBe("GET");
+    expect(manifest.flows?.["checkout.getOrder"]?.out).toBeDefined();
+    expect(manifest.flows?.["checkout.getOrder"]?.effects?.reads).toEqual(["sql:orders"]);
+  });
+
+  test("a stray `name:` key inside the options object is ignored — the positional arg wins", async () => {
+    // Regression guard for the exact class of AST-shape assumption that broke
+    // silently before (channel-alias tracking, `.put()` inference): the
+    // compiler must read the flow's identity from the first positional
+    // argument, never from a `name` property on the options object, even
+    // when one happens to be present.
+    const source = `
+import { flow } from "okengine";
+
+export const decoy = flow("checkout.realName", {
+  name: "checkout.decoyName",
+  effects: { reads: ["sql:orders"] },
+  do: async () => ({ ok: true }),
+});
+`;
+    const manifest = await extractFromSources({ "src/flows/checkout.ts": source });
+
+    expect(manifest.flows?.["checkout.realName"]).toBeDefined();
+    expect(manifest.flows?.["checkout.decoyName"]).toBeUndefined();
+  });
+});

package/src/compiler/extract.ts

@@ -1159,11 +1159,11 @@ function registerFlow(args: {
   scope: ProjectScope;
   exportName: string | undefined;
 }): void {
-  const opts = objectArg(args.flowCall.arguments[0]);
+  const opts = objectArg(args.flowCall.arguments[1]);
   if (!opts) return;
 
   const name =
-    stringProp(opts, "name") ??
+    stringArg(args.flowCall.arguments[0]) ??
     args.exportName ??
     `flow_${Object.keys(args.scope.flows).length + 1}`;
 
@@ -1232,7 +1232,7 @@ function registerFlow(args: {
   const errors = parseErrors(objectProp(opts, "errors"));
   if (errors) flow.errors = errors;
 
-  if (effects && Object.keys(effects).length > 0) flow.effects = effects;
+  if (effects) flow.effects = effects;
 
   const line = lineAt(args.file.source, args.flowCall.start ?? 0);
   flow.source = `${args.file.path}:${line}`;

package/src/compiler/fixtures/raw/raw-unannotated.ts

@@ -5,8 +5,7 @@ import { on, flow, http } from "okengine";
  */
 export const escapeHatch = on(
   http.get("/raw"),
-  flow({
-    name: "raw.unannotated",
+  flow("raw.unannotated", {
     do: async (_, fx) => {
       return fx.raw("select 1");
     },
@@ -18,8 +17,7 @@ export const escapeHatch = on(
  */
 export const annotated = on(
   http.get("/raw-ok"),
-  flow({
-    name: "raw.annotated",
+  flow("raw.annotated", {
     effects: { reads: ["sql:orders"] },
     do: async (_, fx) => {
       return fx.raw("select * from orders");

package/src/compiler/fixtures/skyport/src/flows/bookings/index.ts

@@ -15,8 +15,7 @@ void 0;
 
 export const create = on(
   http.post("/bookings").gate(member, canBook, fair),
-  flow({
-    name: "bookings.create",
+  flow("bookings.create", {
     in: BookingIn,
     out: BookingOut,
     errors: { FlightFull },
@@ -35,8 +34,7 @@ export const create = on(
 
 export const mine = on(
   http.get("/bookings").gate(member).live(),
-  flow({
-    name: "bookings.mine",
+  flow("bookings.mine", {
     live: true,
     do: (_, fx) =>
       fx
@@ -47,13 +45,11 @@ export const mine = on(
   }),
 );
 
-export const getBooking = flow({
-  name: "bookings.getBooking",
+export const getBooking = flow("bookings.getBooking", {
   do: ({ id }, fx) => fx.store(db).findById(bookings, id),
 });
 
-export const refundBooking = flow({
-  name: "bookings.refundBooking",
+export const refundBooking = flow("bookings.refundBooking", {
   do: async ({ id }, fx) => {
     await fx.store(db).update(bookings).set({ status: "refunded" }).where({ id });
     return fx.store(db).findById(bookings, id);

package/src/compiler/fixtures/skyport/src/flows/payments/index.ts

@@ -1,8 +1,7 @@
 import { flow } from "okengine";
 import { stripeKey } from "../../vault.ts";
 
-export const chargeBooking = flow({
-  name: "payments.chargeBooking",
+export const chargeBooking = flow("payments.chargeBooking", {
   durable: true,
   do: async ({ orderId }, fx) => {
     // Journal only serializable step values — a Redacted is not journaled.

package/src/compiler/fixtures/skyport/src/flows/support/index.ts

@@ -6,8 +6,7 @@ import { tickets } from "../../schema.ts";
 
 export const createTicket = on(
   http.post("/tickets").gate(member),
-  flow({
-    name: "support.createTicket",
+  flow("support.createTicket", {
     pii: "masked",
     cost: { estimatePerCall: 0.011, budget: 0.02 },
     do: async (input, fx) => {

package/src/compiler/fixtures/skyport.expected.json

@@ -32,7 +32,7 @@
       "effects": {
         "reads": ["sql:bookings"]
       },
-      "source": "src/flows/bookings/index.ts:50"
+      "source": "src/flows/bookings/index.ts:48"
     },
     "bookings.mine": {
       "trigger": {
@@ -45,7 +45,7 @@
       "effects": {
         "reads": ["sql:bookings"]
       },
-      "source": "src/flows/bookings/index.ts:38",
+      "source": "src/flows/bookings/index.ts:37",
       "live": true,
       "cacheKeys": "computed:sql:bookings/userId"
     },
@@ -54,7 +54,7 @@
         "reads": ["sql:bookings"],
         "writes": ["sql:bookings"]
       },
-      "source": "src/flows/bookings/index.ts:55"
+      "source": "src/flows/bookings/index.ts:52"
     },
     "payments.chargeBooking": {
       "effects": {

package/src/compiler/fixtures/triggers/five-triggers.ts

@@ -16,8 +16,7 @@ export const linkClicked = signal("link-clicked", {
 // ① HTTP
 export const create = on(
   http.post("/orders"),
-  flow({
-    name: "triggers.http",
+  flow("triggers.http", {
     do: async (input, fx) => {
       await fx.store(db).insert(orders).values(input);
       return { ok: true };
@@ -28,8 +27,7 @@ export const create = on(
 // ② CLOCK / every
 on(
   every("10m"),
-  flow({
-    name: "triggers.every",
+  flow("triggers.every", {
     do: (_, fx) => fx.store(db).delete(links).where({ createdAt: 0 }),
   }),
 );
@@ -37,8 +35,7 @@ on(
 // ③ SIGNAL
 on(
   linkClicked,
-  flow({
-    name: "triggers.signal",
+  flow("triggers.signal", {
     do: async ({ code }, fx) => {
       const clicks = await fx.store(db).increment(links, code, "clicks");
       await fx.emit(linkClicked, { code, clicks });
@@ -49,8 +46,7 @@ on(
 // ④ CDC
 on(
   table("orders").changed("status"),
-  flow({
-    name: "triggers.cdc",
+  flow("triggers.cdc", {
     do: ({ before, after }, fx) => fx.store(db).insert(orders).values({ before, after }),
   }),
 );
@@ -58,8 +54,7 @@ on(
 // ⑤ INTERNAL / call-only
 export const stats = on(
   internal,
-  flow({
-    name: "triggers.internal",
+  flow("triggers.internal", {
     do: async ({ code }, fx) => {
       const [row] = await fx.store(db).select().from(links).where({ code });
       return row?.clicks ?? 0;

package/src/compiler/generate-adopt.test.ts

@@ -0,0 +1,85 @@
+/**
+ * `.adopt()` barrel generator — real filesystem before/after proofs.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { generateAdoptBarrel } from "./generate-adopt.ts";
+
+async function makeUnit(root: string, name: string, withIndex = true): Promise<void> {
+  const dir = join(root, "src/flows", name);
+  await mkdir(dir, { recursive: true });
+  if (withIndex) await writeFile(join(dir, "index.ts"), "export const nothing = 1;\n");
+}
+
+describe("generateAdoptBarrel", () => {
+  test("emits one `export * as <unit>` per flows folder with an index.ts barrel", async () => {
+    const root = await mkdtemp(join(tmpdir(), "oke-adopt-gen-"));
+    try {
+      await makeUnit(root, "notes");
+      await makeUnit(root, "main");
+      const result = await generateAdoptBarrel({ rootDir: root });
+      expect(result.units).toEqual(["main", "notes"]);
+      expect(result.source).toContain('export * as main from "./main/index.ts";');
+      expect(result.source).toContain('export * as notes from "./notes/index.ts";');
+      expect(result.skipped).toEqual([]);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test("skips a unit folder with no index.ts barrel (never crashes)", async () => {
+    const root = await mkdtemp(join(tmpdir(), "oke-adopt-gen-"));
+    try {
+      await makeUnit(root, "notes");
+      await makeUnit(root, "scratch", false);
+      const result = await generateAdoptBarrel({ rootDir: root });
+      expect(result.units).toEqual(["notes"]);
+      expect(result.skipped).toEqual(["scratch"]);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test("missing flows directory yields an empty barrel, never throws", async () => {
+    const root = await mkdtemp(join(tmpdir(), "oke-adopt-gen-"));
+    try {
+      const result = await generateAdoptBarrel({ rootDir: root });
+      expect(result.units).toEqual([]);
+      expect(result.source).toContain("AUTO-GENERATED");
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test("real before/after: generated barrel matches the hand-written form it replaces", async () => {
+    const root = await mkdtemp(join(tmpdir(), "oke-adopt-gen-"));
+    try {
+      await mkdir(join(root, "src/flows/main"), { recursive: true });
+      await mkdir(join(root, "src/flows/notes"), { recursive: true });
+      await writeFile(join(root, "src/flows/main/index.ts"), 'export const root = "main-flow";\n');
+      await writeFile(
+        join(root, "src/flows/notes/index.ts"),
+        'export const create = "notes-flow";\n',
+      );
+      const result = await generateAdoptBarrel({ rootDir: root });
+      const generatedPath = join(root, "src/flows/generated.ts");
+      await writeFile(generatedPath, result.source);
+
+      // Same shape as `import * as main from "./flows/main"; import * as
+      // notes from "./flows/notes"; .adopt({ main, notes })` — a namespace
+      // object keyed by unit, one key per flows folder, real modules loaded.
+      const generatedModule = (await import(generatedPath)) as {
+        main: { root: string };
+        notes: { create: string };
+      };
+      expect(Object.keys(generatedModule).sort()).toEqual(["main", "notes"]);
+      expect(generatedModule.main.root).toBe("main-flow");
+      expect(generatedModule.notes.create).toBe("notes-flow");
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});

package/src/compiler/generate-adopt.ts

@@ -0,0 +1,85 @@
+/**
+ * `.adopt()` route-barrel generator — the disk-file alternative to a
+ * virtual-module Bun plugin (investigated and rejected: `Bun.plugin()`'s
+ * `onResolve` is never invoked for an unresolvable specifier during a plain
+ * runtime `import()`, so `oke dev` and `oke build` would resolve a virtual
+ * module differently — measured, not assumed).
+ *
+ * A real file on disk is an ordinary import: identical resolution under
+ * `oke dev`'s runtime `import()` and `oke build`'s `Bun.build()`. Convention
+ * (validated against every current example app — both `create-oke`
+ * templates and the `skyport` compiler fixture, 7/7): every unit under
+ * `<rootDir>/src/flows/*` has an `index.ts` barrel.
+ */
+
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+/** Options for {@link generateAdoptBarrel}. */
+export interface GenerateAdoptBarrelOptions {
+  /** Project root (contains `src/flows`). */
+  readonly rootDir: string;
+  /** Flows directory relative to {@link rootDir} (default `"src/flows"`). */
+  readonly flowsDir?: string;
+}
+
+/** Generated barrel source plus the unit names it covers. */
+export interface AdoptBarrelResult {
+  /** Full `.ts` source — write verbatim to the generated file. */
+  readonly source: string;
+  /** Unit (folder) names included, sorted. */
+  readonly units: readonly string[];
+  /** Folders under `flowsDir` skipped for lacking an `index.ts` barrel. */
+  readonly skipped: readonly string[];
+}
+
+const GENERATED_HEADER =
+  "// AUTO-GENERATED by `oke dev` / `oke build` — do not edit by hand.\n" +
+  "// Regenerated from every `src/flows/<unit>/index.ts` unit folder.\n";
+
+/** A folder name usable as an `export * as <name>` binding. */
+const VALID_UNIT_NAME = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+
+/**
+ * Scan `<rootDir>/<flowsDir>/*` and emit a barrel re-exporting every unit
+ * folder's `index.ts` under its folder name — the same shape
+ * `.adopt({ main, notes })` already takes by hand.
+ *
+ * Never throws: a missing/unreadable flows directory yields an empty
+ * barrel, same posture as the rest of the lazy AoT tooling (best-effort,
+ * boot-time checks are what enforce staleness — see
+ * `assertAdoptBarrelFresh` in `kernel/boot.ts`).
+ *
+ * @param options - Root dir / flows dir override
+ */
+export async function generateAdoptBarrel(
+  options: GenerateAdoptBarrelOptions,
+): Promise<AdoptBarrelResult> {
+  const flowsDir = options.flowsDir ?? "src/flows";
+  const abs = join(options.rootDir, flowsDir);
+
+  const units: string[] = [];
+  const skipped: string[] = [];
+  try {
+    const dirents = await readdir(abs, { withFileTypes: true });
+    for (const d of dirents.sort((a, b) => a.name.localeCompare(b.name))) {
+      if (!d.isDirectory()) continue;
+      const hasBarrel = await Bun.file(join(abs, d.name, "index.ts")).exists();
+      if (!hasBarrel) {
+        skipped.push(d.name);
+        continue;
+      }
+      if (!VALID_UNIT_NAME.test(d.name)) {
+        skipped.push(d.name);
+        continue;
+      }
+      units.push(d.name);
+    }
+  } catch {
+    // Missing flows dir — empty barrel, not a throw (mirrors extractManifest).
+  }
+
+  const lines = units.map((u) => `export * as ${u} from "./${u}/index.ts";`);
+  const source = lines.length > 0 ? `${GENERATED_HEADER}${lines.join("\n")}\n` : GENERATED_HEADER;
+  return { source, units, skipped };
+}

package/src/console/server/dry-run.audit.test.ts

@@ -95,7 +95,7 @@ describe("console dry-run / preview audit", () => {
 
   test("Channels preview is locale template rendering, not dry-run mutation", async () => {
     const flows = await Bun.file(`${import.meta.dir}/flows.ts`).text();
-    const previewIdx = flows.indexOf('name: "console.channel.preview"');
+    const previewIdx = flows.indexOf('flow("console.channel.preview"');
     expect(previewIdx).toBeGreaterThan(0);
     const slice = flows.slice(previewIdx, previewIdx + 800);
     expect(slice).not.toContain("withDryRun");
@@ -104,7 +104,7 @@ describe("console dry-run / preview audit", () => {
 
   test("Traces dryRun is metadata / logging, not withDryRun execution", async () => {
     const flows = await Bun.file(`${import.meta.dir}/flows.ts`).text();
-    const idx = flows.indexOf('name: "console.traces.replay"');
+    const idx = flows.indexOf('flow("console.traces.replay"');
     expect(idx).toBeGreaterThan(0);
     const slice = flows.slice(idx, idx + 500);
     expect(slice).not.toContain("withDryRun");