okengine 0.17.2 → 0.18.3

package/src/compiler/extract.test.ts

@@ -272,6 +272,103 @@ export const db = store.sql("app", { schema: { bookings } });
     expect(table?.policies?.owner_owner_all?.using).toContain("oke.user()");
   });
 
+  test("extracts widened field heads and option bags into manifest columns", async () => {
+    const source = `
+import { store, field, id } from "okengine";
+
+export const events = store.schema.table("events", {
+  id: field.uuid().primaryKey().defaultFn(id),
+  status: field.varchar({ length: 64, enum: ["new", "archived"] }),
+  doc: field.jsonb(),
+  at: field.timestamp({ mode: "date", precision: 6, withTimezone: true }).notNull(),
+  day: field.date(),
+  amount: field.numeric({ precision: 12, scale: 2 }).notNull(),
+  ratio: field.numeric({ mode: "number" }),
+  span: field.interval({ fields: "day to second" }),
+  loc: field.point({ mode: "xy" }),
+  ip: field.inet(),
+  bin: field.bytea(),
+  big: field.bigserial({ mode: "bigint" }),
+  flag: field.boolean(),
+});
+
+export const db = store.sql("app", { schema: { events } });
+`;
+    const manifest = await extractFromSources({
+      "src/schema.decl.ts": source,
+    });
+    const cols = manifest.stores?.app?.tables?.events?.columns;
+
+    expect(cols?.id).toMatchObject({ type: "uuid", primaryKey: true });
+    expect(cols?.status).toMatchObject({
+      type: "varchar",
+      length: 64,
+      enumValues: ["new", "archived"],
+    });
+    expect(cols?.doc).toMatchObject({ type: "jsonb", nullable: true });
+    expect(cols?.at).toMatchObject({
+      type: "timestamp",
+      mode: "date",
+      precision: 6,
+      withTimezone: true,
+      nullable: false,
+    });
+    expect(cols?.day).toMatchObject({ type: "date", nullable: true });
+    expect(cols?.amount).toMatchObject({
+      type: "numeric",
+      precision: 12,
+      scale: 2,
+      nullable: false,
+    });
+    expect(cols?.ratio).toMatchObject({ type: "numeric", mode: "number" });
+    expect(cols?.span).toMatchObject({ type: "interval", fields: "day to second" });
+    expect(cols?.loc).toMatchObject({ type: "point", mode: "xy" });
+    expect(cols?.ip).toMatchObject({ type: "inet" });
+    expect(cols?.bin).toMatchObject({ type: "bytea" });
+    expect(cols?.big).toMatchObject({ type: "bigserial", mode: "bigint" });
+    expect(cols?.flag).toMatchObject({ type: "boolean" });
+  });
+
+  test("prepared .okid()/.now() defaults mark the column dynamic like defaultFn", async () => {
+    const source = `
+import { store, field } from "okengine";
+
+export const assets = store.schema.table("assets", {
+  id: field.text().primaryKey().okid(),
+  createdAt: field.integer().notNull().now(),
+  updatedAt: field.timestamp({ mode: "date" }),
+});
+
+export const db = store.sql("app", { schema: { assets } });
+`;
+    const manifest = await extractFromSources({
+      "src/schema.decl.ts": source,
+    });
+    const cols = manifest.stores?.app?.tables?.assets?.columns;
+    expect(cols?.id).toMatchObject({ type: "text", primaryKey: true, default: null });
+    expect(cols?.createdAt).toMatchObject({ type: "integer", nullable: false, default: null });
+  });
+
+  test("decimal head collapses to numeric in the manifest", async () => {
+    const source = `
+import { store, field } from "okengine";
+
+export const rates = store.schema.table("rates", {
+  rate: field.decimal({ precision: 6, scale: 3 }),
+});
+
+export const db = store.sql("app", { schema: { rates } });
+`;
+    const manifest = await extractFromSources({
+      "src/schema.decl.ts": source,
+    });
+    expect(manifest.stores?.app?.tables?.rates?.columns?.rate).toMatchObject({
+      type: "numeric",
+      precision: 6,
+      scale: 3,
+    });
+  });
+
   test("extracts optional description fields additively", async () => {
     const source = `
 import { store, field, signal, channel, clock, gate, vault } from "okengine";
@@ -534,6 +631,242 @@ export const remove = mounted.remove;
     expect(manifest.flows?.get?.live).toBeUndefined();
     expect(manifest.flows?.create?.live).toBeUndefined();
   });
+
+  test("live: true synthesizes the internal signal + GET /live flow", async () => {
+    const source = `
+import { on, http, store } from "okengine";
+
+export const db = store.sql("notes", { schema: {} });
+
+export const notesTable = store.schema.table("notes", {});
+const notesR = store.resource(db, notesTable, { live: true });
+
+const mounted = on(http.resource("/notes", notesR.all()));
+
+export const list = mounted.list;
+export const get = mounted.get;
+`;
+    const manifest = await extractFromSources({ "src/flows/notes.ts": source });
+
+    // Internal signal derived from the physical table.
+    expect(manifest.signals?.["oke/live/sql:notes"]?.delivery).toBe("live");
+    expect(manifest.flows?.["_live_notes"]?.trigger).toEqual({
+      http: { method: "GET", path: "/notes/live" },
+    });
+    expect(manifest.flows?.["_live_notes"]?.effects?.reads).toEqual([
+      "sql:notes",
+      "signal:oke/live/sql:notes",
+    ]);
+  });
+
+  test("live signal name follows a schema-table binding, not the JS binding", async () => {
+    const source = `
+import { on, http, store } from "okengine";
+
+export const db = store.sql("notes", { schema: {} });
+
+export const tasksTable = store.schema.table("tasks", {});
+const tasksR = store.resource(db, tasksTable, { live: true });
+const mounted = on(http.resource("/tasks", tasksR.all()));
+
+export const list = mounted.list;
+`;
+    const manifest = await extractFromSources({ "src/flows/tasks.ts": source });
+
+    expect(manifest.signals?.["oke/live/sql:tasks"]).toBeDefined();
+    expect(manifest.flows?.["_live_tasks"]?.trigger?.http?.path).toBe("/tasks/live");
+  });
+});
+
+describe("extractManifest — live guardrails (DX Pack A)", () => {
+  test("live: true without a PK column fails loud at extract", async () => {
+    const source = `
+import { on, http, store } from "okengine";
+
+export const db = store.sql("notes", { schema: {} });
+
+export const notesTable = store.schema.table(
+  "notes",
+  { body: field.text().notNull() },
+);
+const notesR = store.resource(db, notesTable, { live: true });
+const mounted = on(http.resource("/notes", notesR.all()));
+
+export const list = mounted.list;
+`;
+    expect(extractFromSources({ "src/flows/notes.ts": source })).rejects.toThrow(
+      /requires a primary key/,
+    );
+  });
+
+  test("warns when the table has no updatedAt / updated_at column", async () => {
+    const source = `
+import { on, http, store } from "okengine";
+
+export const db = store.sql("notes", { schema: {} });
+
+export const notesTable = store.schema.table(
+  "notes",
+  { id: field.text().primaryKey() },
+);
+const notesR = store.resource(db, notesTable, { live: true });
+const mounted = on(http.resource("/notes", notesR.all()));
+
+export const list = mounted.list;
+`;
+    const warnings: string[] = [];
+    const originalWarn = console.warn;
+    console.warn = (msg: unknown): void => {
+      warnings.push(String(msg));
+    };
+    try {
+      await extractFromSources({ "src/flows/notes.ts": source });
+    } finally {
+      console.warn = originalWarn;
+    }
+    expect(warnings.some((w) => w.includes("updatedAt"))).toBe(true);
+    // RLS warn also fires here — declared table carries no policies.
+    expect(warnings.some((w) => w.includes("RLS policies"))).toBe(true);
+  });
+
+  test("no updatedAt warn when a timestamp variant exists; RLS warn alone fires", async () => {
+    const source = `
+import { on, http, store } from "okengine";
+
+export const db = store.sql("notes", { schema: {} });
+
+export const notesTable = store.schema.table(
+  "notes",
+  { id: field.text().primaryKey(), updated_at: field.timestamp({ mode: "string" }).notNull() },
+);
+const notesR = store.resource(db, notesTable, { live: true });
+const mounted = on(http.resource("/notes", notesR.all()));
+
+export const list = mounted.list;
+`;
+    const warnings: string[] = [];
+    const originalWarn = console.warn;
+    console.warn = (msg: unknown): void => {
+      warnings.push(String(msg));
+    };
+    try {
+      await extractFromSources({ "src/flows/notes.ts": source });
+    } finally {
+      console.warn = originalWarn;
+    }
+    expect(warnings.some((w) => w.includes("updatedAt"))).toBe(false);
+    expect(warnings.some((w) => w.includes("RLS policies"))).toBe(true);
+  });
+
+  test("silent when the table is complete: PK + updatedAt + policies", async () => {
+    const source = `
+import { on, http, store } from "okengine";
+
+export const db = store.sql("notes", { schema: {} });
+
+export const notesTable = store.schema.table(
+  "notes",
+  { id: field.text().primaryKey(), updated_at: field.timestamp({ mode: "string" }).notNull() },
+  [store.schema.policy.gate("member")],
+);
+const notesR = store.resource(db, notesTable, { live: true });
+const mounted = on(http.resource("/notes", notesR.all()).gate(member));
+
+export const list = mounted.list;
+`;
+    const warnings: string[] = [];
+    const originalWarn = console.warn;
+    console.warn = (msg: unknown): void => {
+      warnings.push(String(msg));
+    };
+    try {
+      await extractFromSources({ "src/flows/notes.ts": source });
+    } finally {
+      console.warn = originalWarn;
+    }
+    expect(warnings).toEqual([]);
+  });
+});
+
+describe("extractManifest — manual live (.live(table) on a hand-written flow)", () => {
+  test("synthesizes the internal signal + live CustomMatch flow on the hand-written GET", async () => {
+    const source = `
+import { on, http, store, flow, liveQuery } from "okengine";
+
+export const db = store.sql("tasks", { schema: {} });
+
+export const tasksTable = store.schema.table(
+  "tasks",
+  { id: field.text().primaryKey(), updated_at: field.timestamp({ mode: "string" }).notNull() },
+  [store.schema.policy.gate("member")],
+);
+
+export const tasksLive = on(
+  http.get("/tasks/live").gate(member).live(tasksTable),
+  flow("tasks.live", {
+    in: { unknown: true },
+    do: async (_input, fx) => liveQuery(fx, tasksTable, _input),
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/tasks.ts": source });
+
+    expect(manifest.signals?.["oke/live/sql:tasks"]?.delivery).toBe("live");
+    const flow = manifest.flows?.["tasks_live"] ?? manifest.flows?.["tasks.live"];
+    expect(flow?.live).toBe("oke/live/sql:tasks");
+    expect(flow?.trigger).toEqual({ http: { method: "GET", path: "/tasks/live" } });
+    expect(flow?.gates).toEqual(["member"]);
+  });
+
+  test("guardrails fire for .live(table): no PK → extract error; missing updatedAt → warn", async () => {
+    const noPk = `
+import { on, http, store, flow, liveQuery } from "okengine";
+
+export const db = store.sql("tasks", { schema: {} });
+
+export const tasksTable = store.schema.table(
+  "tasks",
+  { body: field.text().notNull() },
+  [store.schema.policy.gate("member")],
+);
+
+export const tasksLive = on(
+  http.get("/tasks/live").gate(member).live(tasksTable),
+  flow("tasks.live", { do: async (_input, fx) => liveQuery(fx, tasksTable, _input) }),
+);
+`;
+    await expect(extractFromSources({ "src/flows/tasks.ts": noPk })).rejects.toThrow(
+      /requires a primary key/,
+    );
+
+    const warnSource = `
+import { on, http, store, flow, liveQuery } from "okengine";
+
+export const db = store.sql("tasks", { schema: {} });
+
+export const tasksTable = store.schema.table(
+  "tasks",
+  { id: field.text().primaryKey() },
+  [store.schema.policy.gate("member")],
+);
+
+export const tasksLive = on(
+  http.get("/tasks/live").gate(member).live(tasksTable),
+  flow("tasks.live", { do: async (_input, fx) => liveQuery(fx, tasksTable, _input) }),
+);
+`;
+    const warnings: string[] = [];
+    const originalWarn = console.warn;
+    console.warn = (msg: unknown): void => {
+      warnings.push(String(msg));
+    };
+    try {
+      await extractFromSources({ "src/flows/tasks.ts": warnSource });
+    } finally {
+      console.warn = originalWarn;
+    }
+    expect(warnings.some((w) => w.includes("updatedAt"))).toBe(true);
+  });
 });
 
 describe("extractManifest — vault.config", () => {
@@ -1337,3 +1670,188 @@ export const app = oke({
     );
   });
 });
+
+describe("extractManifest — project-wide store.live default", () => {
+  test("oke({ store: { live: true } }) makes new tables live by default", async () => {
+    const source = `
+import { on, http, store, field, oke } from "okengine";
+
+export const db = store.sql("app", { schema: {} });
+
+export const notes = store.schema.table("notes", {
+  id: field.text().primaryKey(),
+  updatedAt: field.integer().notNull(),
+}, [
+  store.schema.policy.owner("owner"),
+]);
+
+const notesR = store.resource(db, notes, {});
+const mounted = on(http.resource("/notes", notesR.all()));
+
+export const list = mounted.list;
+export const app = oke({
+  name: "shop",
+  store: { live: true },
+});
+`;
+    const manifest = await extractFromSources({ "src/app.ts": source });
+
+    // Manifest.store stamps the project flag.
+    expect(manifest.store).toEqual({ live: true });
+
+    // The table itself is live by default (opt-in flip, no per-table flag).
+    expect(manifest.stores?.app?.tables?.notes?.live).toBe(true);
+
+    // Resource synthesized GET /notes/live + internal signal without an explicit live: true.
+    expect(manifest.signals?.["oke/live/sql:notes"]?.delivery).toBe("live");
+    expect(manifest.flows?.["_live_notes"]?.trigger?.http?.path).toBe("/notes/live");
+  });
+
+  test("store.schema.live(false) opts a table out under the project flag", async () => {
+    const source = `
+import { on, http, store, field, oke } from "okengine";
+
+export const db = store.sql("app", { schema: {} });
+
+export const notes = store.schema.table("notes", {
+  id: field.text().primaryKey(),
+  updatedAt: field.integer().notNull(),
+}, [
+  store.schema.policy.owner("owner"),
+  store.schema.live(false),
+]);
+
+const notesR = store.resource(db, notes, {});
+const mounted = on(http.resource("/notes", notesR.all()));
+
+export const list = mounted.list;
+export const app = oke({
+  name: "shop",
+  store: { live: true },
+});
+`;
+    const manifest = await extractFromSources({ "src/app.ts": source });
+
+    expect(manifest.store).toEqual({ live: true });
+    // Opted-out table stays not live — no default flip, no synthesis.
+    expect(manifest.stores?.app?.tables?.notes?.live).toBe(false);
+    expect(manifest.signals?.["oke/live/sql:notes"]).toBeUndefined();
+    expect(manifest.flows?.["_live_notes"]).toBeUndefined();
+  });
+
+  test("live: false on the resource is equivalent to store.schema.live(false)", async () => {
+    const source = `
+import { on, http, store, field, oke } from "okengine";
+
+export const db = store.sql("app", { schema: {} });
+
+export const notes = store.schema.table("notes", {
+  id: field.text().primaryKey(),
+  updatedAt: field.integer().notNull(),
+}, [
+  store.schema.policy.owner("owner"),
+]);
+
+const notesR = store.resource(db, notes, { live: false });
+const mounted = on(http.resource("/notes", notesR.all()));
+
+export const list = mounted.list;
+export const app = oke({
+  name: "shop",
+  store: { live: true },
+});
+`;
+    const manifest = await extractFromSources({ "src/app.ts": source });
+
+    // The table-level default applies (live-by-default project-wide); only
+    // this mount's /live route is suppressed by the resource opt-out.
+    expect(manifest.stores?.app?.tables?.notes?.live).toBe(true);
+    expect(manifest.signals?.["oke/live/sql:notes"]?.delivery).toBe("live");
+    expect(manifest.flows?.["_live_notes"]).toBeUndefined();
+  });
+
+  test("explicit live: true wins over store.schema.live(false)", async () => {
+    const source = `
+import { on, http, store, field, oke } from "okengine";
+
+export const db = store.sql("app", { schema: {} });
+
+export const notes = store.schema.table("notes", {
+  id: field.text().primaryKey(),
+  updatedAt: field.integer().notNull(),
+}, [
+  store.schema.policy.owner("owner"),
+  store.schema.live(false),
+]);
+
+const notesR = store.resource(db, notes, { live: true });
+const mounted = on(http.resource("/notes", notesR.all()));
+
+export const list = mounted.list;
+export const app = oke({
+  name: "shop",
+  store: { live: true },
+});
+`;
+    const manifest = await extractFromSources({ "src/app.ts": source });
+
+    // The explicit opt-in is separate from the default flip — it still wins.
+    expect(manifest.stores?.app?.tables?.notes?.live).toBe(false);
+    expect(manifest.signals?.["oke/live/sql:notes"]?.delivery).toBe("live");
+    expect(manifest.flows?.["_live_notes"]?.trigger?.http?.path).toBe("/notes/live");
+  });
+
+  test("without the flag, an omitted live stays today's explicit-only behavior", async () => {
+    const source = `
+import { on, http, store, field } from "okengine";
+
+export const db = store.sql("app", { schema: {} });
+
+export const notes = store.schema.table("notes", {
+  id: field.text().primaryKey(),
+  updatedAt: field.integer().notNull(),
+}, [
+  store.schema.policy.owner("owner"),
+]);
+
+const notesR = store.resource(db, notes, {});
+const mounted = on(http.resource("/notes", notesR.all()));
+
+export const list = mounted.list;
+export const app = oke({
+  name: "shop",
+});
+`;
+    const manifest = await extractFromSources({ "src/app.ts": source });
+
+    expect(manifest.store).toBeUndefined();
+    // Table not live, resource without live: true synthesizes nothing.
+    expect(manifest.stores?.app?.tables?.notes?.live).toBeUndefined();
+    expect(manifest.signals?.["oke/live/sql:notes"]).toBeUndefined();
+    expect(manifest.flows?.["_live_notes"]).toBeUndefined();
+  });
+
+  test("the project default fires the same DX Pack A guardrails as explicit live: true", async () => {
+    const source = `
+import { on, http, store, field, oke } from "okengine";
+
+export const db = store.sql("app", { schema: {} });
+
+export const notes = store.schema.table("notes", {
+  body: field.text().notNull(),
+});
+
+const notesR = store.resource(db, notes, {});
+const mounted = on(http.resource("/notes", notesR.all()));
+
+export const list = mounted.list;
+export const app = oke({
+  name: "shop",
+  store: { live: true },
+});
+`;
+    await expect(extractFromSources({ "src/app.ts": source })).rejects.toThrow(
+      /requires a primary key/,
+    );
+  });
+});