okengine 0.10.1 → 0.10.3

package/src/compiler/extract.ts

@@ -1022,8 +1022,20 @@ function collectConfig(opts: AstNode | undefined, scope: ProjectScope): void {
   const images = objectProp(opts, "images");
   if (images) {
     const map: Record<string, string> = {};
+    // Nested like `drivers`: `store.*` / `channel.*` flatten to dotted keys;
+    // everything else (`vault`, `ai`, `pgdog`, `proxy`) is already flat.
+    for (const nestKey of ["store", "channel"] as const) {
+      const nested = objectProp(images, nestKey);
+      if (!nested || nested.type !== "ObjectExpression") continue;
+      for (const prop of objectProperties(nested)) {
+        const key = propKey(prop);
+        const val = stringArg((prop as AstNode & { value?: AstNode }).value);
+        if (key && val) map[`${nestKey}.${key}`] = val;
+      }
+    }
     for (const prop of objectProperties(images)) {
       const key = propKey(prop);
+      if (key === "store" || key === "channel") continue;
       const val = stringArg((prop as AstNode & { value?: AstNode }).value);
       if (key && val) map[key] = val;
     }
@@ -1159,11 +1171,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 +1244,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/oke.config.ts

@@ -15,8 +15,10 @@ export default defineConfig({
     ai: { prod: { driver: "anthropic" } },
   },
   images: {
-    "store.sql": "pgvector/pgvector:pg17",
-    "store.kv": "valkey/valkey:8-alpine",
+    store: {
+      sql: "pgvector/pgvector:pg17",
+      kv: "valkey/valkey:8-alpine",
+    },
   },
   i18n: { locales: ["en", "ar"], default: "ar", dir: { ar: "rtl" } },
   tenancy: { isolation: "row" },

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,111 @@
+/**
+ * `.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 { mkdir, readdir, rename, writeFile } 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";
+
+/** Filename of the on-disk `.adopt()` barrel under the flows directory. */
+export const ADOPT_BARREL_FILE = "generated.ts";
+
+/** A folder name usable as an `export * as <name>` binding. */
+const VALID_UNIT_NAME = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+
+/**
+ * Write the adopt barrel atomically: `generated.ts.tmp` → rename to
+ * `generated.ts`. Concurrent readers (e.g. `bun --hot` racing a save) never
+ * observe a torn/partial file — plain `writeFile` on the destination would
+ * truncate first.
+ *
+ * @param rootDir - Project root
+ * @param source - Full barrel source from {@link generateAdoptBarrel}
+ * @param flowsDir - Flows directory relative to root (default `"src/flows"`)
+ */
+export async function writeAdoptBarrel(
+  rootDir: string,
+  source: string,
+  flowsDir = "src/flows",
+): Promise<void> {
+  const dir = join(rootDir, flowsDir);
+  const target = join(dir, ADOPT_BARREL_FILE);
+  const tmp = `${target}.tmp`;
+  await mkdir(dir, { recursive: true });
+  await writeFile(tmp, source);
+  await rename(tmp, target);
+}
+
+/**
+ * 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/config/driver-defaults.test.ts

@@ -0,0 +1,122 @@
+/**
+ * Driver-map defaults — per-key merge onto the real established defaults,
+ * never a whole-object replace and never leaking across driver maps.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { mergeEnvDriverMap } from "./index.ts";
+import {
+  CHANNEL_EMAIL_DEFAULTS,
+  CHANNEL_SMS_DEFAULTS,
+  CLOCK_DEFAULTS,
+  JOURNAL_DEFAULTS,
+  resolveEffectiveDrivers,
+  SIGNAL_DEFAULTS,
+  STORE_FILES_DEFAULTS,
+  STORE_KV_DEFAULTS,
+  STORE_SQL_DEFAULTS,
+  VAULT_DEFAULTS,
+} from "./driver-defaults.ts";
+
+describe("mergeEnvDriverMap", () => {
+  test("an unset key keeps the real default, not a sibling key's value", () => {
+    const merged = mergeEnvDriverMap({ local: "pglite" }, STORE_SQL_DEFAULTS);
+    expect(merged).toEqual({
+      local: "pglite",
+      docker: "postgres",
+      test: "memory",
+      prod: "postgres",
+    });
+  });
+
+  test("undefined override yields the untouched default map", () => {
+    expect(mergeEnvDriverMap(undefined, STORE_KV_DEFAULTS)).toEqual(STORE_KV_DEFAULTS);
+  });
+
+  test("a fully-specified override wins on every key", () => {
+    const override = { local: "a", docker: "b", test: "c", prod: "d" };
+    expect(mergeEnvDriverMap(override, STORE_SQL_DEFAULTS)).toEqual(override);
+  });
+});
+
+describe("resolveEffectiveDrivers — the drivers.store.sql.local discussion scenario", () => {
+  test("`{ store: { sql: { local: 'pglite' } } }` resolves sql to the real map, pglite only on local", () => {
+    const effective = resolveEffectiveDrivers({
+      store: { sql: { local: "pglite" } },
+    });
+
+    expect(effective.store.sql).toEqual({
+      local: "pglite",
+      docker: "postgres",
+      test: "memory",
+      prod: "postgres",
+    });
+  });
+
+  test("every other driver stays at its full, real, untouched default map", () => {
+    const effective = resolveEffectiveDrivers({
+      store: { sql: { local: "pglite" } },
+    });
+
+    expect(effective.store.kv).toEqual(STORE_KV_DEFAULTS);
+    expect(effective.store.files).toEqual(STORE_FILES_DEFAULTS);
+    expect(effective.signal).toEqual(SIGNAL_DEFAULTS);
+    expect(effective.clock).toEqual(CLOCK_DEFAULTS);
+    expect(effective.journal).toEqual(JOURNAL_DEFAULTS);
+    expect(effective.vault).toEqual(VAULT_DEFAULTS);
+    expect(effective.channel.email).toEqual(CHANNEL_EMAIL_DEFAULTS);
+    expect(effective.channel.sms).toEqual(CHANNEL_SMS_DEFAULTS);
+  });
+
+  test("overriding one driver's map has zero effect on a sibling driver's defaults", () => {
+    const effective = resolveEffectiveDrivers({
+      store: { kv: { local: "redis" } },
+    });
+
+    // The overridden driver (kv) reflects the override on its one set key.
+    expect(effective.store.kv).toEqual({
+      local: "redis",
+      docker: "redis",
+      test: "memory",
+      prod: "redis",
+    });
+    // sql / files (same element, different facet) stay fully at real defaults.
+    expect(effective.store.sql).toEqual(STORE_SQL_DEFAULTS);
+    expect(effective.store.files).toEqual(STORE_FILES_DEFAULTS);
+    // Unrelated elements stay fully at real defaults too.
+    expect(effective.signal).toEqual(SIGNAL_DEFAULTS);
+    expect(effective.vault).toEqual(VAULT_DEFAULTS);
+  });
+
+  test("overriding one env key leaves the other three at real defaults for that driver", () => {
+    const effective = resolveEffectiveDrivers({
+      vault: { local: "keychain" },
+    });
+
+    expect(effective.vault).toEqual({
+      local: "keychain",
+      docker: "env",
+      test: "memory",
+      prod: "env",
+    });
+  });
+
+  test("no drivers config at all yields the real, untouched defaults for every map", () => {
+    const effective = resolveEffectiveDrivers(undefined);
+    expect(effective).toEqual({
+      store: {
+        sql: STORE_SQL_DEFAULTS,
+        kv: STORE_KV_DEFAULTS,
+        files: STORE_FILES_DEFAULTS,
+      },
+      signal: SIGNAL_DEFAULTS,
+      clock: CLOCK_DEFAULTS,
+      journal: JOURNAL_DEFAULTS,
+      vault: VAULT_DEFAULTS,
+      channel: {
+        email: CHANNEL_EMAIL_DEFAULTS,
+        sms: CHANNEL_SMS_DEFAULTS,
+      },
+    });
+  });
+});