okengine 0.16.0 → 0.17.0

package/src/client-react/use-live.test.ts

@@ -0,0 +1,129 @@
+/**
+ * useLive — mount/unmount and typed event state.
+ */
+
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import { Window } from "happy-dom";
+import { act, createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { createClient } from "../client/create.ts";
+import type { AppOf, LiveSignalHandle } from "../client/types.ts";
+import { useLive } from "./index.ts";
+
+type EventsApp = AppOf<{
+  orders: {
+    events: {
+      in: { orderId: string };
+      out: { orderId: string; status: string };
+      method: "GET";
+      path: "/orders/:orderId/events";
+      live: "order-status";
+      matchKey: ["orderId"];
+      stream: true;
+    };
+  };
+}>;
+
+type Payload = { orderId: string; status: string };
+
+const orderStatus: LiveSignalHandle<Payload> = {
+  name: "order-status",
+};
+
+function sseResponse(frames: readonly unknown[], ids?: readonly string[]): Response {
+  const lines: string[] = [];
+  frames.forEach((payload, i) => {
+    const id = ids?.[i];
+    if (id !== undefined) lines.push(`id: ${id}`);
+    lines.push(`data: ${JSON.stringify(payload)}`);
+    lines.push("");
+  });
+  lines.push("data: [DONE]");
+  lines.push("");
+  return new Response(lines.join("\n"), {
+    status: 200,
+    headers: { "content-type": "text/event-stream" },
+  });
+}
+
+async function waitFor(pred: () => boolean, ms = 1_000): Promise<void> {
+  const start = Date.now();
+  while (!pred()) {
+    if (Date.now() - start > ms) throw new Error("timeout");
+    await new Promise((r) => setTimeout(r, 5));
+  }
+}
+
+describe("useLive", () => {
+  let happy: Window;
+
+  beforeEach(() => {
+    (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+    happy = new Window({ url: "http://app.test/" });
+    Object.defineProperty(globalThis, "window", {
+      value: happy,
+      configurable: true,
+      writable: true,
+    });
+    Object.defineProperty(globalThis, "document", {
+      value: happy.document,
+      configurable: true,
+      writable: true,
+    });
+  });
+
+  afterEach(() => {
+    happy.close();
+  });
+
+  test("collects events and latest; unmount stops fetches", async () => {
+    let calls = 0;
+    const payload = { orderId: "ord_1", status: "placed" as const };
+    const api = createClient<EventsApp>("http://app.test", {
+      fetch: async () => {
+        calls += 1;
+        return sseResponse([payload], ["evt-1"]);
+      },
+      $routes: {
+        orders: {
+          events: {
+            method: "GET",
+            path: "/orders/:orderId/events",
+            live: "order-status",
+            matchKey: ["orderId"],
+            stream: true,
+          },
+        },
+      },
+    });
+
+    const host = happy.document.createElement("div");
+    happy.document.body.appendChild(host);
+    const seen: { latest: Payload | null; events: Payload[] } = { latest: null, events: [] };
+
+    function Probe(): null {
+      const state = useLive(api, orderStatus, { orderId: "ord_1" });
+      seen.latest = state.latest;
+      seen.events = state.events;
+      return null;
+    }
+
+    let root: Root | undefined;
+    await act(async () => {
+      root = createRoot(host as unknown as Element);
+      root.render(createElement(Probe));
+    });
+    await waitFor(() => seen.events.length === 1);
+    expect(seen.latest).toEqual(payload);
+    expect(seen.events).toEqual([payload]);
+    expect(calls).toBe(1);
+
+    await act(async () => {
+      root?.unmount();
+    });
+    const after = calls;
+    await new Promise((r) => setTimeout(r, 200));
+    expect(calls).toBe(after);
+    host.remove();
+  });
+});

package/src/compiler/effects-infer.ts

@@ -8,6 +8,7 @@
 
 import type {
   AuthApiKeysResourceRef,
+  AuthTenantsResourceRef,
   Effects,
   PromptRef,
   ResourceRef,
@@ -146,8 +147,10 @@ const TABLE_ARG_METHODS = new Set([
  * @param options - Handler AST, bindings, and annotation flag
  */
 export function inferEffects(options: InferEffectsOptions): InferredEffects {
-  const reads = new Set<ResourceRef | SignalResourceRef | AuthApiKeysResourceRef>();
-  const writes = new Set<ResourceRef | AuthApiKeysResourceRef>();
+  const reads = new Set<
+    ResourceRef | SignalResourceRef | AuthApiKeysResourceRef | AuthTenantsResourceRef
+  >();
+  const writes = new Set<ResourceRef | AuthApiKeysResourceRef | AuthTenantsResourceRef>();
   const emits = new Set<SignalRef>();
   const sends = new Set<TemplateRef>();
   const asks = new Set<PromptRef>();
@@ -183,6 +186,12 @@ export function inferEffects(options: InferEffectsOptions): InferredEffects {
       continue;
     }
 
+    if (chain.rootMethod === "live" && call === chain.rootCall) {
+      const ref = resolveNamed(call.arguments[0], options.bindings, "signal");
+      if (ref) reads.add(`signal:${ref}`);
+      continue;
+    }
+
     if (chain.rootMethod === "send" && call === chain.rootCall) {
       const ref = resolveNamed(call.arguments[0], options.bindings, "template");
       if (ref) sends.add(ref);
@@ -221,6 +230,7 @@ export function inferEffects(options: InferEffectsOptions): InferredEffects {
     if (chain.rootMethod === "auth" && call === chain.rootCall) {
       const method = chain.methods[1];
       if (method === "listApiKeys") reads.add("auth:api-keys");
+      if (method === "listTenants" || method === "listMembers") reads.add("auth:tenants");
       if (
         method === "createApiKey" ||
         method === "revokeApiKey" ||
@@ -229,6 +239,16 @@ export function inferEffects(options: InferEffectsOptions): InferredEffects {
       ) {
         writes.add("auth:api-keys");
       }
+      if (
+        method === "switchTenant" ||
+        method === "createTenant" ||
+        method === "deleteTenant" ||
+        method === "addMember" ||
+        method === "removeMember" ||
+        method === "upsertTenantRole"
+      ) {
+        writes.add("auth:tenants");
+      }
       continue;
     }
 

package/src/compiler/extract.test.ts

@@ -337,6 +337,23 @@ export const stripeKey = vault.secret("STRIPE_KEY", {
     expect(manifest.vault?.STRIPE_KEY?.description).toBe("Payments gateway key");
   });
 
+  test("extracts live signal retention", async () => {
+    const manifest = await extractFromSources({
+      "src/signals.ts": `
+import { signal } from "okengine";
+export const orderStatus = signal("order-status", {
+  delivery: "live",
+  optional: true,
+  retention: { maxAge: "24h", maxCount: 500 },
+});
+`,
+    });
+    expect(manifest.signals?.["order-status"]?.retention).toEqual({
+      maxAge: "24h",
+      maxCount: 500,
+    });
+  });
+
   test("extracts store.kv durable onto the Manifest store", async () => {
     const manifest = await extractFromSources({
       "src/kv.ts": `
@@ -362,7 +379,6 @@ export const { list, create, get, update, remove } = bindNamedTableCrud({
   unit: "cycles",
   path: "/cycles",
   table: cycles,
-  liveList: true,
 });
 `;
     const helper = `
@@ -379,7 +395,7 @@ export function bindNamedTableCrud(spec) {
     expect(manifest.flows?.["cycles.list"]?.trigger).toEqual({
       http: { method: "GET", path: "/cycles" },
     });
-    expect(manifest.flows?.["cycles.list"]?.live).toBe(true);
+    expect(manifest.flows?.["cycles.list"]?.live).toBeUndefined();
     expect(manifest.flows?.["cycles.create"]?.trigger).toEqual({
       http: { method: "POST", path: "/cycles" },
     });
@@ -469,7 +485,7 @@ export const remove = mounted.remove;
     expect(manifest.flows?.list?.breaking).toBe(true);
   });
 
-  test("chains .gate(...) and .live() onto the five verbs", async () => {
+  test("chains .gate(...) onto the five verbs", async () => {
     const source = `
 import { on, http, store, gate } from "okengine";
 
@@ -478,7 +494,7 @@ export const db = store.sql("notes", { schema: {} });
 
 const notesR = store.resource(db, {}, {});
 
-const mounted = on(http.resource("/notes", notesR.all()).gate(member).live());
+const mounted = on(http.resource("/notes", notesR.all()).gate(member));
 
 export const list = mounted.list;
 export const create = mounted.create;
@@ -493,20 +509,18 @@ export const remove = mounted.remove;
     expect(manifest.flows?.get?.gates).toEqual(["member"]);
     expect(manifest.flows?.update?.gates).toEqual(["member"]);
     expect(manifest.flows?.remove?.gates).toEqual(["member"]);
-    expect(manifest.flows?.list?.live).toBe(true);
-    expect(manifest.flows?.get?.live).toBe(true);
+    expect(manifest.flows?.list?.live).toBeUndefined();
+    expect(manifest.flows?.get?.live).toBeUndefined();
     expect(manifest.flows?.create?.live).toBeUndefined();
-    expect(manifest.flows?.update?.live).toBeUndefined();
-    expect(manifest.flows?.remove?.live).toBeUndefined();
   });
 
-  test("chains .public().live() onto the five verbs", async () => {
+  test("chains .public() 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());
+const mounted = on(http.resource("/notes", notesR.all()).public());
 
 export const list = mounted.list;
 export const create = mounted.create;
@@ -517,7 +531,7 @@ 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?.get?.live).toBeUndefined();
     expect(manifest.flows?.create?.live).toBeUndefined();
   });
 });
@@ -672,6 +686,67 @@ export const failed = on(
   });
 });
 
+describe("extractManifest — fx.live / .live(signal)", () => {
+  test("one-arg on(http.get(path).live(signal)) stamps live + signal read", async () => {
+    const source = `
+import { on, http, gate, signal } from "okengine";
+import { z } from "zod";
+
+export const member = gate.policy("member", ({ auth }) => !!auth.verified);
+export const orderStatus = signal("order-status", {
+  delivery: "live",
+  optional: true,
+  schema: z.object({ orderId: z.string(), status: z.string() }),
+});
+
+export const events = on(http.get("/orders/:orderId/events").gate(member).live(orderStatus));
+`;
+    const manifest = await extractFromSources({ "src/flows/orders/index.ts": source });
+    const flow = manifest.flows?.["orders.events"];
+    expect(flow?.live).toBe("order-status");
+    expect(flow?.trigger).toEqual({
+      http: { method: "GET", path: "/orders/:orderId/events" },
+    });
+    expect(flow?.gates).toEqual(["member"]);
+    expect(flow?.effects?.reads).toEqual(["signal:order-status"]);
+  });
+
+  test("http.live(signal) uses GET /_oke/live/{name}", async () => {
+    const source = `
+import { on, http, gate, signal } from "okengine";
+
+export const member = gate.policy("member", ({ auth }) => !!auth.verified);
+export const orderStatus = signal("order-status", { delivery: "live", optional: true });
+
+export const firehose = on(http.live(orderStatus).gate(member));
+`;
+    const manifest = await extractFromSources({ "src/flows/orders/index.ts": source });
+    const flow = manifest.flows?.["orders.firehose"];
+    expect(flow?.live).toBe("order-status");
+    expect(flow?.trigger).toEqual({
+      http: { method: "GET", path: "/_oke/live/order-status" },
+    });
+  });
+
+  test("fx.live(signal) infers reads: [signal:<name>]", async () => {
+    const source = `
+import { on, flow, http, signal } from "okengine";
+
+export const orderStatus = signal("order-status", { delivery: "live", optional: true });
+
+export const events = on(
+  http.get("/feed").public().live(orderStatus),
+  flow("orders.events", {
+    do: (_input, fx) => fx.live(orderStatus),
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/orders.ts": source });
+    expect(manifest.flows?.["orders.events"]?.live).toBe("order-status");
+    expect(manifest.flows?.["orders.events"]?.effects?.reads).toEqual(["signal:order-status"]);
+  });
+});
+
 describe("extractManifest — channel medium binder aliasing", () => {
   test("mail.template(...) resolves through `const mail = channel.email(...)`", async () => {
     const source = `
@@ -1205,3 +1280,60 @@ export const create = flow("views.create", {
     });
   });
 });
+
+describe("extractManifest — tenancy", () => {
+  test("oke({ gate: { auth: { tenant: true }}}) stamps tenancy.enabled", async () => {
+    const source = `
+import { oke, on, flow, http, store, field } from "okengine";
+
+export const bookings = store.schema.table("bookings", {
+  id: field.text().primaryKey(),
+  tenantId: field.text().notNull(),
+}, [
+  store.schema.policy.tenant("tenant_id"),
+]);
+
+export const db = store.sql("app", { schema: { bookings } });
+
+export const ping = on(
+  http.get("/ping").public(),
+  flow("health.ping", { do: () => ({ ok: true }) }),
+);
+
+export const app = oke({
+  name: "shop",
+  gate: { auth: { tenant: true } },
+});
+`;
+    const manifest = await extractFromSources({ "src/app.ts": source });
+    expect(manifest.tenancy).toMatchObject({
+      enabled: true,
+      isolation: "row",
+      membershipRequired: false,
+    });
+    expect(manifest.flows?.["health.ping"]?.tenantScoped).toBe(true);
+    expect(manifest.stores?.app?.tables?.bookings?.policies?.tenant_tenant_id_all?.using).toContain(
+      "oke.tenant()",
+    );
+  });
+
+  test("SQL table without tenant policy or unscoped() fails loud", async () => {
+    const source = `
+import { oke, store, field } from "okengine";
+
+export const notes = store.schema.table("notes", {
+  id: field.text().primaryKey(),
+});
+
+export const db = store.sql("app", { schema: { notes } });
+
+export const app = oke({
+  name: "shop",
+  gate: { auth: { tenant: true } },
+});
+`;
+    await expect(extractFromSources({ "src/app.ts": source })).rejects.toThrow(
+      /needs store.schema.policy.tenant/,
+    );
+  });
+});