okengine 0.2.6 → 0.3.2

package/src/compiler/fixtures/skyport/oke.config.ts

@@ -2,15 +2,15 @@ import { defineConfig } from "okengine/config";
 
 export default defineConfig({
   drivers: {
-    prod: ["postgres", "redis", "s3", "smtp", "sops", "anthropic", "pgvector"],
+    prod: ["postgres", "redis", "s3", "smtp", "openbao", "anthropic", "pgvector"],
     store: {
-      sql: { dev: "sqlite", prod: { driver: "postgres" } },
+      sql: { local: "sqlite", prod: { driver: "postgres" } },
       kv: { prod: "redis" },
       files: { prod: "s3" },
       index: { prod: "pgvector" },
     },
     signal: { prod: "postgres" },
-    vault: { prod: "sops" },
+    vault: { prod: "openbao" },
     channel: { email: { prod: "smtp" } },
     ai: { prod: { driver: "anthropic" } },
   },

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

@@ -10,8 +10,8 @@ const BookingOut = { name: "BookingOut" };
 const FlightFull = { name: "FlightFull" };
 
 // Padding so `flow(` lands on line 18 (spec excerpt source path).
-
-
+void 0;
+void 0;
 
 export const create = on(
   http.post("/bookings").gate(member, canBook, fair),
@@ -39,7 +39,11 @@ export const mine = on(
     name: "bookings.mine",
     live: true,
     do: (_, fx) =>
-      fx.store(db).select().from(bookings).where(eq(bookings.userId as never, fx.auth.userId)),
+      fx
+        .store(db)
+        .select()
+        .from(bookings)
+        .where(eq(bookings.userId as never, fx.auth.userId)),
   }),
 );
 

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

@@ -5,9 +5,7 @@ export const chargeBooking = flow({
   name: "payments.chargeBooking",
   durable: true,
   do: async ({ orderId }, fx) => {
-    const intent = await fx.step("create-intent", () =>
-      fx.vault(stripeKey),
-    );
+    const intent = await fx.step("create-intent", () => fx.vault(stripeKey));
     await fx.clock.sleep("verify-window", "2m");
     return fx.step("confirm", () => intent);
   },

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

@@ -13,7 +13,10 @@ export const createTicket = on(
     do: async (input, fx) => {
       const t = await fx.ask(triage, input);
       const id = fx.id();
-      await fx.store(db).insert(tickets).values({ id, ...input, ...t });
+      await fx
+        .store(db)
+        .insert(tickets)
+        .values({ id, ...input, ...t });
       return { id, urgency: t.urgency };
     },
   }),

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

@@ -9,27 +9,14 @@
           "path": "/bookings"
         }
       },
-      "gates": [
-        "member",
-        "booking:create",
-        "rate:sliding-window-counter:300/1m"
-      ],
+      "gates": ["member", "booking:create", "rate:sliding-window-counter:300/1m"],
       "in": "…",
       "out": "…",
-      "errors": [
-        "FlightFull"
-      ],
+      "errors": ["FlightFull"],
       "effects": {
-        "reads": [
-          "sql:bookings"
-        ],
-        "writes": [
-          "sql:bookings"
-        ],
-        "emits": [
-          "order-placed",
-          "seat-feed"
-        ],
+        "reads": ["sql:bookings"],
+        "writes": ["sql:bookings"],
+        "emits": ["order-placed", "seat-feed"],
         "secrets": []
       },
       "source": "src/flows/bookings/index.ts:18",
@@ -43,11 +30,9 @@
     },
     "bookings.getBooking": {
       "effects": {
-        "reads": [
-          "sql:bookings"
-        ]
+        "reads": ["sql:bookings"]
       },
-      "source": "src/flows/bookings/index.ts:46"
+      "source": "src/flows/bookings/index.ts:50"
     },
     "bookings.mine": {
       "trigger": {
@@ -56,13 +41,9 @@
           "path": "/bookings"
         }
       },
-      "gates": [
-        "member"
-      ],
+      "gates": ["member"],
       "effects": {
-        "reads": [
-          "sql:bookings"
-        ]
+        "reads": ["sql:bookings"]
       },
       "source": "src/flows/bookings/index.ts:38",
       "live": true,
@@ -70,27 +51,18 @@
     },
     "bookings.refundBooking": {
       "effects": {
-        "reads": [
-          "sql:bookings"
-        ],
-        "writes": [
-          "sql:bookings"
-        ]
+        "reads": ["sql:bookings"],
+        "writes": ["sql:bookings"]
       },
-      "source": "src/flows/bookings/index.ts:51"
+      "source": "src/flows/bookings/index.ts:55"
     },
     "payments.chargeBooking": {
       "effects": {
-        "secrets": [
-          "STRIPE_KEY"
-        ]
+        "secrets": ["STRIPE_KEY"]
       },
       "source": "src/flows/payments/index.ts:4",
       "durable": true,
-      "steps": [
-        "create-intent",
-        "confirm"
-      ]
+      "steps": ["create-intent", "confirm"]
     },
     "support.createTicket": {
       "trigger": {
@@ -99,16 +71,10 @@
           "path": "/tickets"
         }
       },
-      "gates": [
-        "member"
-      ],
+      "gates": ["member"],
       "effects": {
-        "writes": [
-          "sql:tickets"
-        ],
-        "asks": [
-          "ticket-triage@3"
-        ]
+        "writes": ["sql:tickets"],
+        "asks": ["ticket-triage@3"]
       },
       "source": "src/flows/support/index.ts:9",
       "nondeterministic": true,
@@ -137,9 +103,7 @@
   "gates": {
     "booking:create": {
       "kind": "policy",
-      "roles": [
-        "booking:create"
-      ]
+      "roles": ["booking:create"]
     },
     "fair": {
       "kind": "rate",
@@ -150,9 +114,7 @@
     },
     "member": {
       "kind": "policy",
-      "roles": [
-        "member"
-      ]
+      "roles": ["member"]
     }
   },
   "vault": {
@@ -164,10 +126,7 @@
   "channels": {
     "booking-confirmed": {
       "medium": "email",
-      "locales": [
-        "en",
-        "ar"
-      ]
+      "locales": ["en", "ar"]
     }
   },
   "ai": {
@@ -188,10 +147,7 @@
     },
     "agents": {
       "support": {
-        "tools": [
-          "bookings.getBooking",
-          "bookings.refundBooking"
-        ],
+        "tools": ["bookings.getBooking", "bookings.refundBooking"],
         "maxSteps": 6
       }
     }
@@ -202,31 +158,17 @@
         "availability": "99.5%"
       },
       "composes": "99.6%",
-      "flows": [
-        "bookings.create",
-        "payments.chargeBooking"
-      ]
+      "flows": ["bookings.create", "payments.chargeBooking"]
     }
   },
   "drivers": {
-    "prod": [
-      "postgres",
-      "redis",
-      "s3",
-      "smtp",
-      "sops",
-      "anthropic",
-      "pgvector"
-    ]
+    "prod": ["postgres", "redis", "s3", "smtp", "openbao", "anthropic", "pgvector"]
   },
   "tenancy": {
     "isolation": "row"
   },
   "i18n": {
-    "locales": [
-      "en",
-      "ar"
-    ],
+    "locales": ["en", "ar"],
     "default": "ar",
     "dir": {
       "ar": "rtl"
@@ -238,4 +180,3 @@
     "store.kv": "valkey/valkey:8-alpine"
   }
 }
-

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

@@ -51,8 +51,7 @@ on(
   table("orders").changed("status"),
   flow({
     name: "triggers.cdc",
-    do: ({ before, after }, fx) =>
-      fx.store(db).insert(orders).values({ before, after }),
+    do: ({ before, after }, fx) => fx.store(db).insert(orders).values({ before, after }),
   }),
 );
 

package/src/compiler/http-parse.ts

@@ -53,10 +53,7 @@ export function emptyInference(): MutableInference {
  * @param into - Accumulator
  * @param next - Flags to merge
  */
-export function mergeInference(
-  into: MutableInference,
-  next: ContextInference,
-): MutableInference {
+export function mergeInference(into: MutableInference, next: ContextInference): MutableInference {
   into.body = into.body || next.body;
   into.query = into.query || next.query;
   into.params = into.params || next.params;
@@ -160,11 +157,7 @@ export function assembleInput(parts: InputParts): unknown {
   }
 
   if (parts.body !== undefined) {
-    if (
-      typeof parts.body === "object" &&
-      parts.body !== null &&
-      !Array.isArray(parts.body)
-    ) {
+    if (typeof parts.body === "object" && parts.body !== null && !Array.isArray(parts.body)) {
       Object.assign(out, parts.body as Record<string, unknown>);
     } else {
       out.body = parts.body;

package/src/compiler/index.ts

@@ -14,11 +14,7 @@ export {
   type SucroseOptions,
 } from "./aot.ts";
 
-export {
-  compileDynamic,
-  compileRoute,
-  FULL_INFERENCE,
-} from "./dynamic.ts";
+export { compileDynamic, compileRoute, FULL_INFERENCE } from "./dynamic.ts";
 
 export {
   assembleInput,

package/src/compiler/response.ts

@@ -5,6 +5,7 @@
  */
 
 import type { FlowFailure } from "../kernel/errors.ts";
+import { isJsonResult } from "../kernel/fx.ts";
 import { isFlowFailure } from "../kernel/hooks.ts";
 import { VALIDATION_ERROR_CODE } from "../validation/standard-schema.ts";
 
@@ -12,6 +13,7 @@ import { VALIDATION_ERROR_CODE } from "../validation/standard-schema.ts";
 export interface SuccessEnvelope {
   readonly data: unknown;
   readonly error: null;
+  readonly meta?: Record<string, unknown>;
 }
 
 /** Failure envelope. */
@@ -45,16 +47,24 @@ export function statusForFailure(failure: FlowFailure): number {
 
 /**
  * Encode a successful output as JSON `{ data, error: null }`.
+ * An `fx.json` carrier overrides status (`create` → 201) and attaches
+ * top-level `meta` (Stripe-style envelope).
  *
  * @param output - Handler output (`undefined` → 204)
  */
 export function encodeSuccess(output: unknown): Response {
+  if (isJsonResult(output)) {
+    if (output.status === 204) {
+      return new Response(null, { status: 204 });
+    }
+    const body: SuccessEnvelope = { data: output.value, error: null };
+    const envelope = output.meta === undefined ? body : { ...body, meta: output.meta };
+    return Response.json(envelope, { status: output.status });
+  }
   if (output === undefined) {
     return new Response(null, { status: 204 });
   }
-  return Response.json(
-    { data: output, error: null } satisfies SuccessEnvelope,
-  );
+  return Response.json({ data: output, error: null } satisfies SuccessEnvelope);
 }
 
 /**
@@ -63,10 +73,9 @@ export function encodeSuccess(output: unknown): Response {
  * @param failure - Flow-boundary failure
  */
 export function encodeFailure(failure: FlowFailure): Response {
-  return Response.json(
-    { data: null, error: failure.error } satisfies FailureEnvelope,
-    { status: statusForFailure(failure) },
-  );
+  return Response.json({ data: null, error: failure.error } satisfies FailureEnvelope, {
+    status: statusForFailure(failure),
+  });
 }
 
 /**

package/src/compiler/sucrose.ts

@@ -15,13 +15,7 @@ import {
 } from "./http-parse.ts";
 
 /** Context property names sucrose tracks. */
-const CONTEXT_KEYS = [
-  "body",
-  "query",
-  "params",
-  "headers",
-  "cookie",
-] as const;
+const CONTEXT_KEYS = ["body", "query", "params", "headers", "cookie"] as const;
 
 type ContextKey = (typeof CONTEXT_KEYS)[number];
 
@@ -58,8 +52,7 @@ export function sucrose(options: SucroseOptions): ContextInference {
   }
 
   const method = (options.method ?? "GET").toUpperCase();
-  const bodyMethod =
-    method !== "GET" && method !== "HEAD" && method !== "DELETE";
+  const bodyMethod = method !== "GET" && method !== "HEAD" && method !== "DELETE";
 
   // OKE handlers receive assembled input as arg0 — body methods always
   // parse JSON. AoT still drops query/headers/cookie when unused.
@@ -121,13 +114,12 @@ export function analyseFunction(
   inferFromDestructure(parameter, inference);
 }
 
-function splitFunction(
-  source: string,
-): { parameter: string | undefined; body: string | undefined } {
+function splitFunction(source: string): {
+  parameter: string | undefined;
+  body: string | undefined;
+} {
   // async (a, b) => … | (a) => … | function (a, b) { … }
-  const arrow = source.match(
-    /^(?:async\s*)?(?:\(([^)]*)\)|([a-zA-Z_$][\w$]*))\s*=>\s*([\s\S]*)$/,
-  );
+  const arrow = source.match(/^(?:async\s*)?(?:\(([^)]*)\)|([a-zA-Z_$][\w$]*))\s*=>\s*([\s\S]*)$/);
   if (arrow) {
     return {
       parameter: (arrow[1] ?? arrow[2] ?? "").trim(),
@@ -177,11 +169,7 @@ function collectAliases(parameter: string, body: string): string[] {
   return aliases;
 }
 
-function inferFromAlias(
-  alias: string,
-  body: string,
-  inference: MutableInference,
-): void {
+function inferFromAlias(alias: string, body: string, inference: MutableInference): void {
   for (const key of CONTEXT_KEYS) {
     if (inference[key]) continue;
     const access = new RegExp(
@@ -193,10 +181,7 @@ function inferFromAlias(
   }
 }
 
-function inferFromDestructure(
-  parameter: string,
-  inference: MutableInference,
-): void {
+function inferFromDestructure(parameter: string, inference: MutableInference): void {
   if (!parameter.includes("{")) return;
   for (const key of CONTEXT_KEYS) {
     const re = new RegExp(`\\b${key}\\b`);
@@ -206,10 +191,7 @@ function inferFromDestructure(
   }
 }
 
-function isContextPassedToFunction(
-  aliases: readonly string[],
-  body: string,
-): boolean {
+function isContextPassedToFunction(aliases: readonly string[], body: string): boolean {
   for (const alias of aliases) {
     if (alias.length === 0) continue;
     // Word-boundary safe: `(…, alias, …)` or `(alias)` as a complete argument
@@ -218,9 +200,7 @@ function isContextPassedToFunction(
     );
     if (re.test(body)) return true;
     // shorthand: fn(alias)
-    const exact = new RegExp(
-      `\\(\\s*${escapeRegExp(alias)}\\s*\\)`,
-    );
+    const exact = new RegExp(`\\(\\s*${escapeRegExp(alias)}\\s*\\)`);
     if (exact.test(body)) return true;
   }
   return false;

package/src/config/define-config.test.ts

@@ -1,61 +1,82 @@
 /**
- * `defineConfig` fills missing `stack` pins from `prod`.
+ * `defineConfig` fills missing `docker` pins from `prod` and normalizes legacy keys.
  */
 
 import { describe, expect, test } from "bun:test";
-import { defineConfig, fillStackFromProd } from "./index.ts";
+import { defineConfig, fillDockerFromProd, normalizeEnvDriverMap } from "./index.ts";
 
-describe("fillStackFromProd / defineConfig", () => {
-  test("copies prod onto stack when stack is omitted", () => {
-    const filled = fillStackFromProd({
-      dev: "sqlite",
+describe("fillDockerFromProd / defineConfig", () => {
+  test("copies prod onto docker when docker is omitted", () => {
+    const filled = fillDockerFromProd({
+      local: "sqlite",
       prod: "postgres",
     });
-    expect(filled?.stack).toBe("postgres");
-    expect(filled?.dev).toBe("sqlite");
+    expect(filled?.docker).toBe("postgres");
+    expect(filled?.local).toBe("sqlite");
   });
 
-  test("does not overwrite an explicit stack pin", () => {
+  test("does not overwrite an explicit docker pin", () => {
     expect(
-      fillStackFromProd({
-        dev: "sqlite",
-        stack: "memory",
+      fillDockerFromProd({
+        local: "sqlite",
+        docker: "memory",
         prod: "postgres",
-      })?.stack,
+      })?.docker,
     ).toBe("memory");
   });
 
-  test("vault sops → stack dotenv", () => {
-    expect(
-      fillStackFromProd({ dev: "dotenv", prod: "sops" }, { vault: true })
-        ?.stack,
-    ).toBe("dotenv");
+  test("vault prod → docker copies the prod driver", () => {
+    expect(fillDockerFromProd({ local: "dotenv", prod: "openbao" })?.docker).toBe("openbao");
   });
 
   test("defineConfig fills every element from prod", () => {
     const cfg = defineConfig({
       drivers: {
         store: {
-          sql: { dev: "sqlite", prod: "postgres" },
-          kv: { dev: "memory", prod: "redis" },
-          files: { dev: "fs", prod: "s3" },
+          sql: { local: "sqlite", prod: "postgres" },
+          kv: { local: "memory", prod: "redis" },
+          files: { local: "fs", prod: "s3" },
         },
-        signal: { dev: "memory", prod: "postgres" },
-        clock: { dev: "memory", prod: "postgres" },
-        vault: { dev: "dotenv", prod: "sops" },
+        signal: { local: "memory", prod: "postgres" },
+        clock: { local: "memory", prod: "postgres" },
+        vault: { local: "dotenv", prod: "openbao" },
         channel: {
-          email: { dev: "console", prod: "smtp" },
+          email: { local: "console", prod: "smtp" },
+        },
+        ai: { local: "mock", prod: "anthropic" },
+      },
+    });
+    expect(cfg.drivers?.store?.sql?.docker).toBe("postgres");
+    expect(cfg.drivers?.store?.kv?.docker).toBe("redis");
+    expect(cfg.drivers?.store?.files?.docker).toBe("s3");
+    expect(cfg.drivers?.signal?.docker).toBe("postgres");
+    expect(cfg.drivers?.clock?.docker).toBe("postgres");
+    expect(cfg.drivers?.vault?.docker).toBe("openbao");
+    expect(cfg.drivers?.channel?.email?.docker).toBe("smtp");
+    expect(cfg.drivers?.ai?.docker).toBe("anthropic");
+  });
+
+  test("normalizeEnvDriverMap maps legacy keys", () => {
+    const normalized = normalizeEnvDriverMap({
+      dev: "sqlite",
+      stack: "postgres",
+      prod: "postgres",
+    });
+    expect(normalized?.local).toBe("sqlite");
+    expect(normalized?.docker).toBe("postgres");
+    expect((normalized as { dev?: string } | undefined)?.dev).toBeUndefined();
+    expect((normalized as { stack?: string } | undefined)?.stack).toBeUndefined();
+  });
+
+  test("defineConfig accepts legacy driver-map keys", () => {
+    const cfg = defineConfig({
+      drivers: {
+        store: {
+          sql: { dev: "sqlite", stack: "postgres", prod: "postgres" } as never,
         },
-        ai: { dev: "mock", prod: "anthropic" },
       },
     });
-    expect(cfg.drivers?.store?.sql?.stack).toBe("postgres");
-    expect(cfg.drivers?.store?.kv?.stack).toBe("redis");
-    expect(cfg.drivers?.store?.files?.stack).toBe("s3");
-    expect(cfg.drivers?.signal?.stack).toBe("postgres");
-    expect(cfg.drivers?.clock?.stack).toBe("postgres");
-    expect(cfg.drivers?.vault?.stack).toBe("dotenv");
-    expect(cfg.drivers?.channel?.email?.stack).toBe("smtp");
-    expect(cfg.drivers?.ai?.stack).toBe("anthropic");
+    expect(cfg.drivers?.store?.sql?.local).toBe("sqlite");
+    expect(cfg.drivers?.store?.sql?.docker).toBe("postgres");
   });
 });