okengine 0.2.6 → 0.2.8

package/src/compiler/aot.test.ts

@@ -30,11 +30,7 @@ describe("sucrose — context inference", () => {
 
   test("detects context.body / query / headers access", () => {
     const inference = sucrose({
-      handler: ((ctx: {
-        body: unknown;
-        query: unknown;
-        headers: unknown;
-      }) => ({
+      handler: ((ctx: { body: unknown; query: unknown; headers: unknown }) => ({
         body: ctx.body,
         q: ctx.query,
         h: ctx.headers,
@@ -191,10 +187,7 @@ describe("AoT throughput ≥ 1.5× dynamic", () => {
       seats: z.number().int().min(1).max(9),
       note: z.string().max(200).optional(),
     });
-    const handler = ((input: {
-      flightId: string;
-      seats: number;
-    }) => input) as never;
+    const handler = ((input: { flightId: string; seats: number }) => input) as never;
 
     const aot = compileAot({
       method: "POST",

package/src/compiler/aot.ts

@@ -7,10 +7,7 @@
  */
 
 import type { FlowFailure } from "../kernel/errors.ts";
-import {
-  validate,
-  type SchemaInput,
-} from "../validation/standard-schema.ts";
+import { validate, type SchemaInput } from "../validation/standard-schema.ts";
 import {
   assembleInput,
   extractParts,

package/src/compiler/differential.test.ts

@@ -49,11 +49,7 @@ function generateContracts(count: number, seed = 42): GeneratedContract[] {
         method: "POST",
         path,
         schema,
-        handler: ((input: {
-          flightId: string;
-          seats: number;
-          cabin?: string;
-        }) => ({
+        handler: ((input: { flightId: string; seats: number; cabin?: string }) => ({
           ok: true,
           flightId: input.flightId,
           seats: input.seats,
@@ -140,10 +136,7 @@ function generateContracts(count: number, seed = 42): GeneratedContract[] {
         method: "POST",
         path,
         schema,
-        handler: ((input: {
-          tags: string[];
-          meta: { source: string; n: number };
-        }) => ({
+        handler: ((input: { tags: string[]; meta: { source: string; n: number } }) => ({
           count: input.tags.length,
           source: input.meta.source,
           n: input.meta.n,
@@ -188,8 +181,7 @@ async function runSample(
     request: Request,
     params: Readonly<Record<string, string>>,
   ) => Promise<
-    | { ok: true; input: unknown }
-    | { ok: false; failure: import("../kernel/errors.ts").FlowFailure }
+    { ok: true; input: unknown } | { ok: false; failure: import("../kernel/errors.ts").FlowFailure }
   >,
   handler: (...args: never[]) => unknown,
   sample: GeneratedContract["samples"][number],

package/src/compiler/dynamic.ts

@@ -37,10 +37,7 @@ export function compileDynamic(options: CompileRouteOptions): CompiledRoute {
  * @param options - Route metadata
  * @param aot - When `false`, force the dynamic path
  */
-export function compileRoute(
-  options: CompileRouteOptions,
-  aot: boolean = true,
-): CompiledRoute {
+export function compileRoute(options: CompileRouteOptions, aot: boolean = true): CompiledRoute {
   if (!aot) return compileDynamic(options);
   return compileAot(options);
 }

package/src/compiler/effects-infer.ts

@@ -105,15 +105,7 @@ const READ_METHODS = new Set([
   "find",
 ]);
 
-const WRITE_METHODS = new Set([
-  "insert",
-  "set",
-  "delete",
-  "increment",
-  "update",
-  "upsert",
-  "log",
-]);
+const WRITE_METHODS = new Set(["insert", "set", "delete", "increment", "update", "upsert", "log"]);
 
 /** Methods whose first argument is a table / collection identifier. */
 const TABLE_ARG_METHODS = new Set([
@@ -204,19 +196,13 @@ export function inferEffects(options: InferEffectsOptions): InferredEffects {
       // the sibling call that carries the table arg records the real resource.
       const leaf = resolved.methods[resolved.methods.length - 1]!;
       const hasTable = tableFromStoreChain(call) !== undefined;
-      if (
-        !hasTable &&
-        (leaf === "select" || leaf === "insert" || leaf === "update")
-      ) {
+      if (!hasTable && (leaf === "select" || leaf === "insert" || leaf === "update")) {
         continue;
       }
       // Intermediate chain links that only forward (where/values/returning)
       // still carry read/write from earlier methods — record once we have a table
       // or a terminal key-based op.
-      if (
-        !hasTable &&
-        (leaf === "where" || leaf === "values" || leaf === "returning")
-      ) {
+      if (!hasTable && (leaf === "where" || leaf === "values" || leaf === "returning")) {
         continue;
       }
       if (op === "read" || op === "both") reads.add(resolved.resource);
@@ -306,10 +292,7 @@ export function fxMemberChain(call: CallExpression): FxChain | null {
     const prop = (member.property as Identifier).name;
     methods.unshift(prop);
 
-    if (
-      member.object.type === "Identifier" &&
-      (member.object as Identifier).name === "fx"
-    ) {
+    if (member.object.type === "Identifier" && (member.object as Identifier).name === "fx") {
       rootCall = current;
       rootMethod = prop;
       break;
@@ -377,9 +360,7 @@ export function storeResourceFromCall(
   const literal = stringArg(storeArg);
   if (literal) {
     return {
-      resource: (literal.includes(":")
-        ? literal
-        : `${facet}:${literal}`) as ResourceRef,
+      resource: (literal.includes(":") ? literal : `${facet}:${literal}`) as ResourceRef,
       methods: chain.methods,
     };
   }
@@ -418,9 +399,7 @@ function tableFromStoreChain(call: CallExpression): string | undefined {
   return undefined;
 }
 
-function classifyStoreMethods(
-  methods: string[],
-): "read" | "write" | "both" | "none" {
+function classifyStoreMethods(methods: string[]): "read" | "write" | "both" | "none" {
   const ops = methods.slice(1);
   let read = false;
   let write = false;
@@ -490,9 +469,7 @@ export function stringArg(node: AstNode | undefined): string | undefined {
     const quasis = (node as AstNode & { quasis?: AstNode[] }).quasis;
     const exprs = (node as AstNode & { expressions?: AstNode[] }).expressions;
     if (quasis?.length === 1 && (exprs?.length ?? 0) === 0) {
-      const cooked = (
-        quasis[0] as AstNode & { value?: { cooked?: string } }
-      ).value?.cooked;
+      const cooked = (quasis[0] as AstNode & { value?: { cooked?: string } }).value?.cooked;
       if (typeof cooked === "string") return cooked;
     }
   }
@@ -530,10 +507,7 @@ function containsAuthUserId(root: AstNode): boolean {
     };
     if (auth.property.type !== "Identifier") return;
     if ((auth.property as Identifier).name !== "auth") return;
-    if (
-      auth.object.type === "Identifier" &&
-      (auth.object as Identifier).name === "fx"
-    ) {
+    if (auth.object.type === "Identifier" && (auth.object as Identifier).name === "fx") {
       found = true;
     }
   });

package/src/compiler/emit.ts

@@ -22,9 +22,7 @@ export interface EmitManifestOptions {
  * @param options - Path and document
  * @returns Absolute path written
  */
-export async function emitManifest(
-  options: EmitManifestOptions,
-): Promise<string> {
+export async function emitManifest(options: EmitManifestOptions): Promise<string> {
   const text = serializeManifest(options.manifest);
   await Bun.write(options.path, text);
   return options.path;

package/src/compiler/extract.test.ts

@@ -1,24 +1,15 @@
 import { describe, expect, test } from "bun:test";
 
-import {
-  deepMatch,
-  extractFromSources,
-  extractManifest,
-} from "./extract.ts";
+import { deepMatch, extractFromSources, extractManifest } from "./extract.ts";
 import { emitManifest, manifestPathIn } from "./emit.ts";
 import { serializeManifest } from "../manifest/validate.ts";
 import type { Manifest } from "../manifest/types.ts";
 
 const skyportRoot = new URL("./fixtures/skyport/", import.meta.url).pathname;
 const goldenUrl = new URL("./fixtures/skyport.expected.json", import.meta.url);
-const excerptUrl = new URL(
-  "../manifest/fixtures/skyport.excerpt.json",
-  import.meta.url,
-);
+const excerptUrl = new URL("../manifest/fixtures/skyport.excerpt.json", import.meta.url);
 
-async function loadSkyportFiles(): Promise<
-  { path: string; source: string }[]
-> {
+async function loadSkyportFiles(): Promise<{ path: string; source: string }[]> {
   const glob = new Bun.Glob("**/*.{ts,tsx}");
   const files: { path: string; source: string }[] = [];
   for await (const path of glob.scan({ cwd: skyportRoot, onlyFiles: true })) {
@@ -71,33 +62,23 @@ describe("extractManifest — five trigger types", () => {
     expect(manifest.flows?.["triggers.http"]?.trigger).toEqual({
       http: { method: "POST", path: "/orders" },
     });
-    expect(manifest.flows?.["triggers.http"]?.effects?.writes).toEqual([
-      "sql:orders",
-    ]);
+    expect(manifest.flows?.["triggers.http"]?.effects?.writes).toEqual(["sql:orders"]);
 
     expect(manifest.flows?.["triggers.every"]?.trigger).toEqual({
       every: "10m",
     });
-    expect(manifest.flows?.["triggers.every"]?.effects?.writes).toEqual([
-      "sql:links",
-    ]);
+    expect(manifest.flows?.["triggers.every"]?.effects?.writes).toEqual(["sql:links"]);
 
     expect(manifest.flows?.["triggers.signal"]?.trigger).toEqual({
       signal: "link-clicked",
     });
-    expect(manifest.flows?.["triggers.signal"]?.effects?.writes).toContain(
-      "sql:links",
-    );
-    expect(manifest.flows?.["triggers.signal"]?.effects?.emits).toContain(
-      "link-clicked",
-    );
+    expect(manifest.flows?.["triggers.signal"]?.effects?.writes).toContain("sql:links");
+    expect(manifest.flows?.["triggers.signal"]?.effects?.emits).toContain("link-clicked");
 
     expect(manifest.flows?.["triggers.cdc"]?.trigger).toEqual({
       cdc: { table: "orders", column: "status" },
     });
-    expect(manifest.flows?.["triggers.cdc"]?.effects?.writes).toEqual([
-      "sql:orders",
-    ]);
+    expect(manifest.flows?.["triggers.cdc"]?.effects?.writes).toEqual(["sql:orders"]);
 
     // internal trigger → no trigger key (call-only), or empty trigger object
     const internal = manifest.flows?.["triggers.internal"];
@@ -119,9 +100,7 @@ describe("extractManifest — fx.raw", () => {
 
     expect(manifest.flows?.["raw.unannotated"]?.cache).toBe(false);
     expect(manifest.flows?.["raw.annotated"]?.cache).toBeUndefined();
-    expect(manifest.flows?.["raw.annotated"]?.effects?.reads).toEqual([
-      "sql:orders",
-    ]);
+    expect(manifest.flows?.["raw.annotated"]?.effects?.reads).toEqual(["sql:orders"]);
   });
 });
 
@@ -175,3 +154,90 @@ describe("serializeManifest stability", () => {
     expect(again).toEqual(manifest);
   });
 });
+
+describe("extractManifest — relational with: is never expanded (path b)", () => {
+  test("findMany({ with: { daily: true } }) records no related-table effects", async () => {
+    const source = `
+import { on, flow, http, store } from "okengine";
+
+export const db = store.sql("db");
+export const links = { name: "links" };
+export const daily = { name: "daily" };
+
+export const listLinks = on(
+  http.get("/links"),
+  flow({
+    name: "rel.root",
+    do: async (_input, fx) => {
+      return fx.store(db).select().from(links);
+    },
+  }),
+);
+
+// Hypothetical RQB-shaped call. inferEffects never consults schema
+// relations, so the related table must NOT appear in effects.
+export const withDaily = on(
+  http.get("/links/with-daily"),
+  flow({
+    name: "rel.with",
+    do: async (_input, fx) => {
+      return fx.store(db).findMany({ with: { daily: true } });
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/rel.ts": source });
+
+    // Root-table read stays exact.
+    expect(manifest.flows?.["rel.root"]?.effects?.reads).toEqual(["sql:links"]);
+
+    // The with: argument is not walked — falls back to the store-level
+    // resource, never the relation target.
+    expect(manifest.flows?.["rel.with"]?.effects?.reads).toEqual(["sql:db"]);
+
+    const allEffects = Object.values(manifest.flows ?? {}).flatMap((f) => [
+      ...(f.effects?.reads ?? []),
+      ...(f.effects?.writes ?? []),
+    ]);
+    expect(allEffects).not.toContain("sql:daily");
+  });
+});
+
+describe("extractManifest — store.schema.table", () => {
+  test("extracts DeclaredColumn with PII into manifest stores", async () => {
+    const source = `
+import { store, field, id, now } from "okengine";
+
+export const notes = store.schema.table("notes", {
+  id: field.text().primaryKey().defaultFn(id),
+  title: field.text().notNull(),
+  body: field.text().notNull().pii(),
+  createdAt: field.integer().notNull().defaultFn(now),
+});
+
+export const db = store.sql("app", { schema: { notes } });
+`;
+    const manifest = await extractFromSources({
+      "src/schema.decl.ts": source,
+    });
+
+    expect(manifest.stores?.app?.facet).toBe("sql");
+    const cols = manifest.stores?.app?.tables?.notes?.columns;
+    expect(cols?.body).toMatchObject({
+      type: "text",
+      pii: true,
+      nullable: false,
+      sqlName: "body",
+    });
+    expect(cols?.createdAt).toMatchObject({
+      type: "integer",
+      sqlName: "created_at",
+      nullable: false,
+    });
+    expect(cols?.id).toMatchObject({
+      type: "text",
+      primaryKey: true,
+      sqlName: "id",
+    });
+  });
+});