okengine 0.1.4

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

@@ -0,0 +1,28 @@
+import { on, flow, http } from "okengine";
+
+/**
+ * `fx.raw` without an explicit `effects` annotation → cache-ineligible.
+ */
+export const escapeHatch = on(
+  http.get("/raw"),
+  flow({
+    name: "raw.unannotated",
+    do: async (_, fx) => {
+      return fx.raw("select 1");
+    },
+  }),
+);
+
+/**
+ * `fx.raw` with explicit effects stays cache-eligible (no cache: false).
+ */
+export const annotated = on(
+  http.get("/raw-ok"),
+  flow({
+    name: "raw.annotated",
+    effects: { reads: ["sql:orders"] },
+    do: async (_, fx) => {
+      return fx.raw("select * from orders");
+    },
+  }),
+);

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

@@ -0,0 +1,24 @@
+import { defineConfig } from "okengine/config";
+
+export default defineConfig({
+  drivers: {
+    prod: ["postgres", "redis", "s3", "smtp", "sops", "anthropic", "pgvector"],
+    store: {
+      sql: { dev: "sqlite", prod: { driver: "postgres" } },
+      kv: { prod: "redis" },
+      files: { prod: "s3" },
+      index: { prod: "pgvector" },
+    },
+    signal: { prod: "postgres" },
+    vault: { prod: "sops" },
+    channel: { email: { prod: "smtp" } },
+    ai: { prod: { driver: "anthropic" } },
+  },
+  images: {
+    "store.sql": "pgvector/pgvector:pg17",
+    "store.kv": "valkey/valkey:8-alpine",
+  },
+  i18n: { locales: ["en", "ar"], default: "ar", dir: { ar: "rtl" } },
+  tenancy: { isolation: "row" },
+  topology: "monolith",
+});

package/src/compiler/fixtures/skyport/src/ai.ts

@@ -0,0 +1,15 @@
+import { ai } from "okengine";
+import { getBooking, refundBooking } from "./flows/bookings/index.ts";
+
+export const smart = ai.model("smart", { provider: "anthropic", tier: "opus" });
+
+export const triage = smart.prompt("ticket-triage", {
+  version: 3,
+  evals: "./evals/triage.jsonl",
+  budget: { maxCostPerCall: 0.02 },
+});
+
+export const support = ai.agent("support", {
+  tools: [getBooking, refundBooking],
+  maxSteps: 6,
+});

package/src/compiler/fixtures/skyport/src/app.ts

@@ -0,0 +1,10 @@
+import { oke } from "okengine";
+import "./flows/bookings/index.ts";
+import "./flows/payments/index.ts";
+import "./flows/support/index.ts";
+import "./ai.ts";
+import "./channels.ts";
+import "./gates.ts";
+import "./journeys.ts";
+
+export const app = oke({ name: "skyport" });

package/src/compiler/fixtures/skyport/src/channels.ts

@@ -0,0 +1,6 @@
+import { channel } from "okengine";
+
+export const bookingConfirmed = channel.template("booking-confirmed", {
+  medium: "email",
+  locales: ["en", "ar"],
+});

package/src/compiler/fixtures/skyport/src/core.ts

@@ -0,0 +1,3 @@
+import { store } from "okengine";
+
+export const db = store.sql("db");

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

@@ -0,0 +1,57 @@
+import { on, flow, http } from "okengine";
+import { eq } from "drizzle-orm";
+import { db } from "../../core.ts";
+import { member, canBook, fair } from "../../gates.ts";
+import { bookings } from "../../schema.ts";
+import { orderPlaced, seatFeed } from "./signals.ts";
+
+const BookingIn = { name: "BookingIn" };
+const BookingOut = { name: "BookingOut" };
+const FlightFull = { name: "FlightFull" };
+
+// Padding so `flow(` lands on line 18 (spec excerpt source path).
+
+
+
+export const create = on(
+  http.post("/bookings").gate(member, canBook, fair),
+  flow({
+    name: "bookings.create",
+    in: BookingIn,
+    out: BookingOut,
+    errors: { FlightFull },
+    slo: { availability: "99.9%", latency: { p99: "200ms" } },
+    plane: "user",
+    do: async (input, fx) => {
+      const left = await fx.store(db).select().from(bookings);
+      if (!left) return fx.fail("FlightFull", {});
+      await fx.store(db).insert(bookings).values(input);
+      await fx.emit(orderPlaced, { id: "1" });
+      await fx.emit(seatFeed, {});
+      return { id: fx.id() };
+    },
+  }),
+);
+
+export const mine = on(
+  http.get("/bookings").gate(member).live(),
+  flow({
+    name: "bookings.mine",
+    live: true,
+    do: (_, fx) =>
+      fx.store(db).select().from(bookings).where(eq(bookings.userId as never, fx.auth.userId)),
+  }),
+);
+
+export const getBooking = flow({
+  name: "bookings.getBooking",
+  do: ({ id }, fx) => fx.store(db).findById(bookings, id),
+});
+
+export const refundBooking = flow({
+  name: "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/bookings/signals.ts

@@ -0,0 +1,11 @@
+import { signal } from "okengine";
+
+export const orderPlaced = signal("order-placed", {
+  delivery: "once",
+  retries: 5,
+  deadLetter: true,
+});
+
+export const seatFeed = signal("seat-feed", {
+  delivery: "live",
+});

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

@@ -0,0 +1,14 @@
+import { flow } from "okengine";
+import { stripeKey } from "../../vault.ts";
+
+export const chargeBooking = flow({
+  name: "payments.chargeBooking",
+  durable: true,
+  do: async ({ orderId }, fx) => {
+    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

@@ -0,0 +1,20 @@
+import { on, flow, http } from "okengine";
+import { triage } from "../../ai.ts";
+import { member } from "../../gates.ts";
+import { db } from "../../core.ts";
+import { tickets } from "../../schema.ts";
+
+export const createTicket = on(
+  http.post("/tickets").gate(member),
+  flow({
+    name: "support.createTicket",
+    pii: "masked",
+    cost: { estimatePerCall: 0.011, budget: 0.02 },
+    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 });
+      return { id, urgency: t.urgency };
+    },
+  }),
+);

package/src/compiler/fixtures/skyport/src/gates.ts

@@ -0,0 +1,14 @@
+import { gate } from "okengine";
+
+export const member = gate.policy("member", ({ auth }) => !!auth?.verified);
+
+export const canBook = gate.policy("booking:create", ({ auth }) =>
+  auth.scopes.has("booking:create"),
+);
+
+export const fair = gate.rate({
+  strategy: "sliding-window-counter",
+  max: 300,
+  per: "1m",
+  keyBy: "user",
+});

package/src/compiler/fixtures/skyport/src/journeys.ts

@@ -0,0 +1,9 @@
+import { journey } from "okengine";
+import { create } from "./flows/bookings/index.ts";
+import { chargeBooking } from "./flows/payments/index.ts";
+
+journey("book-a-flight", {
+  path: [create, chargeBooking],
+  slo: { availability: "99.5%" },
+  composes: "99.6%",
+});

package/src/compiler/fixtures/skyport/src/schema.ts

@@ -0,0 +1,3 @@
+/** Table handles used by effect inference (identifiers → sql:name). */
+export const bookings = { name: "bookings" };
+export const tickets = { name: "tickets" };

package/src/compiler/fixtures/skyport/src/vault.ts

@@ -0,0 +1,6 @@
+import { vault } from "okengine";
+
+export const stripeKey = vault("STRIPE_KEY", {
+  description: "Payments gateway key",
+  rotate: "90d",
+});

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

@@ -0,0 +1,241 @@
+{
+  "oke": "1.0",
+  "app": "skyport",
+  "flows": {
+    "bookings.create": {
+      "trigger": {
+        "http": {
+          "method": "POST",
+          "path": "/bookings"
+        }
+      },
+      "gates": [
+        "member",
+        "booking:create",
+        "rate:sliding-window-counter:300/1m"
+      ],
+      "in": "…",
+      "out": "…",
+      "errors": [
+        "FlightFull"
+      ],
+      "effects": {
+        "reads": [
+          "sql:bookings"
+        ],
+        "writes": [
+          "sql:bookings"
+        ],
+        "emits": [
+          "order-placed",
+          "seat-feed"
+        ],
+        "secrets": []
+      },
+      "source": "src/flows/bookings/index.ts:18",
+      "slo": {
+        "availability": "99.9%",
+        "latency": {
+          "p99": "200ms"
+        }
+      },
+      "plane": "user"
+    },
+    "bookings.getBooking": {
+      "effects": {
+        "reads": [
+          "sql:bookings"
+        ]
+      },
+      "source": "src/flows/bookings/index.ts:46"
+    },
+    "bookings.mine": {
+      "trigger": {
+        "http": {
+          "method": "GET",
+          "path": "/bookings"
+        }
+      },
+      "gates": [
+        "member"
+      ],
+      "effects": {
+        "reads": [
+          "sql:bookings"
+        ]
+      },
+      "source": "src/flows/bookings/index.ts:38",
+      "live": true,
+      "cacheKeys": "computed:sql:bookings/userId"
+    },
+    "bookings.refundBooking": {
+      "effects": {
+        "reads": [
+          "sql:bookings"
+        ],
+        "writes": [
+          "sql:bookings"
+        ]
+      },
+      "source": "src/flows/bookings/index.ts:51"
+    },
+    "payments.chargeBooking": {
+      "effects": {
+        "secrets": [
+          "STRIPE_KEY"
+        ]
+      },
+      "source": "src/flows/payments/index.ts:4",
+      "durable": true,
+      "steps": [
+        "create-intent",
+        "confirm"
+      ]
+    },
+    "support.createTicket": {
+      "trigger": {
+        "http": {
+          "method": "POST",
+          "path": "/tickets"
+        }
+      },
+      "gates": [
+        "member"
+      ],
+      "effects": {
+        "writes": [
+          "sql:tickets"
+        ],
+        "asks": [
+          "ticket-triage@3"
+        ]
+      },
+      "source": "src/flows/support/index.ts:9",
+      "nondeterministic": true,
+      "cost": {
+        "estimatePerCall": 0.011,
+        "budget": 0.02
+      },
+      "pii": "masked"
+    }
+  },
+  "signals": {
+    "order-placed": {
+      "delivery": "once",
+      "retries": 5,
+      "deadLetter": true
+    },
+    "seat-feed": {
+      "delivery": "live"
+    }
+  },
+  "stores": {
+    "db": {
+      "facet": "sql"
+    }
+  },
+  "gates": {
+    "booking:create": {
+      "kind": "policy",
+      "roles": [
+        "booking:create"
+      ]
+    },
+    "fair": {
+      "kind": "rate",
+      "strategy": "sliding-window-counter",
+      "max": 300,
+      "per": "1m",
+      "keyBy": "user"
+    },
+    "member": {
+      "kind": "policy",
+      "roles": [
+        "member"
+      ]
+    }
+  },
+  "vault": {
+    "STRIPE_KEY": {
+      "description": "Payments gateway key",
+      "rotate": "90d"
+    }
+  },
+  "channels": {
+    "booking-confirmed": {
+      "medium": "email",
+      "locales": [
+        "en",
+        "ar"
+      ]
+    }
+  },
+  "ai": {
+    "models": {
+      "smart": {
+        "provider": "anthropic",
+        "tier": "opus"
+      }
+    },
+    "prompts": {
+      "ticket-triage": {
+        "version": 3,
+        "evals": "./evals/triage.jsonl",
+        "budget": {
+          "maxCostPerCall": 0.02
+        }
+      }
+    },
+    "agents": {
+      "support": {
+        "tools": [
+          "bookings.getBooking",
+          "bookings.refundBooking"
+        ],
+        "maxSteps": 6
+      }
+    }
+  },
+  "journeys": {
+    "book-a-flight": {
+      "slo": {
+        "availability": "99.5%"
+      },
+      "composes": "99.6%",
+      "flows": [
+        "bookings.create",
+        "payments.chargeBooking"
+      ]
+    }
+  },
+  "drivers": {
+    "prod": [
+      "postgres",
+      "redis",
+      "s3",
+      "smtp",
+      "sops",
+      "anthropic",
+      "pgvector"
+    ]
+  },
+  "tenancy": {
+    "isolation": "row"
+  },
+  "i18n": {
+    "locales": [
+      "en",
+      "ar"
+    ],
+    "default": "ar",
+    "dir": {
+      "ar": "rtl"
+    }
+  },
+  "topology": "monolith",
+  "images": {
+    "store.sql": "pgvector/pgvector:pg17",
+    "store.kv": "valkey/valkey:8-alpine"
+  }
+}
+

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

@@ -0,0 +1,69 @@
+/**
+ * All five trigger kinds — effects inferred through `fx` for each.
+ */
+import { on, flow, http, every, internal, table, signal, store } from "okengine";
+
+export const db = store.sql("db");
+export const orders = { name: "orders" };
+export const links = { name: "links" };
+
+export const linkClicked = signal("link-clicked", {
+  delivery: "once",
+  retries: 3,
+  deadLetter: true,
+});
+
+// ① HTTP
+export const create = on(
+  http.post("/orders"),
+  flow({
+    name: "triggers.http",
+    do: async (input, fx) => {
+      await fx.store(db).insert(orders).values(input);
+      return { ok: true };
+    },
+  }),
+);
+
+// ② CLOCK / every
+on(
+  every("10m"),
+  flow({
+    name: "triggers.every",
+    do: (_, fx) => fx.store(db).delete(links).where({ createdAt: 0 }),
+  }),
+);
+
+// ③ SIGNAL
+on(
+  linkClicked,
+  flow({
+    name: "triggers.signal",
+    do: async ({ code }, fx) => {
+      const clicks = await fx.store(db).increment(links, code, "clicks");
+      await fx.emit(linkClicked, { code, clicks });
+    },
+  }),
+);
+
+// ④ CDC
+on(
+  table("orders").changed("status"),
+  flow({
+    name: "triggers.cdc",
+    do: ({ before, after }, fx) =>
+      fx.store(db).insert(orders).values({ before, after }),
+  }),
+);
+
+// ⑤ INTERNAL / call-only
+export const stats = on(
+  internal,
+  flow({
+    name: "triggers.internal",
+    do: async ({ code }, fx) => {
+      const [row] = await fx.store(db).select().from(links).where({ code });
+      return row?.clicks ?? 0;
+    },
+  }),
+);