okengine 0.9.1 → 0.10.1

package/src/compiler/effects-infer.ts

@@ -15,6 +15,7 @@ import type {
   TemplateRef,
   FlowRef,
 } from "../manifest/types.ts";
+import { sqlTableRef } from "../manifest/sql-resource.ts";
 
 /** Minimal ESTree-shaped nodes produced by oxc-parser. */
 export interface AstNode {
@@ -54,6 +55,7 @@ export interface InferBinding {
     | "template"
     | "flow"
     | "embed"
+    | "table"
     | "unknown";
   /** Resolved resource / name. */
   readonly ref: string;
@@ -103,9 +105,20 @@ const READ_METHODS = new Set([
   "findMany",
   "findFirst",
   "find",
+  "list",
 ]);
 
-const WRITE_METHODS = new Set(["insert", "set", "delete", "increment", "update", "upsert", "log"]);
+const WRITE_METHODS = new Set([
+  "insert",
+  "set",
+  "delete",
+  "increment",
+  "update",
+  "upsert",
+  "log",
+  "put",
+  "putImage",
+]);
 
 /** Methods whose first argument is a table / collection identifier. */
 const TABLE_ARG_METHODS = new Set([
@@ -203,7 +216,7 @@ export function inferEffects(options: InferEffectsOptions): InferredEffects {
       // Skip incomplete chains (`select` before `.from`, `insert` before table) —
       // 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;
+      const hasTable = tableFromStoreChain(call, options.bindings) !== undefined;
       if (!hasTable && (leaf === "select" || leaf === "insert" || leaf === "update")) {
         continue;
       }
@@ -352,11 +365,14 @@ export function storeResourceFromCall(
   const storeBinding = resolveBinding(storeArg, bindings);
   const facet = storeBinding?.facet ?? "sql";
 
-  const table = tableFromStoreChain(call);
+  const table = tableFromStoreChain(call, bindings);
 
   if (table) {
     return {
-      resource: `${facet}:${table}` as ResourceRef,
+      // sql:<table> is the shared naming convention with the kernel's
+      // runtime capability gate (see ../manifest/sql-resource.ts) — table
+      // args only ever occur on sql-facet methods in practice.
+      resource: (facet === "sql" ? sqlTableRef(table) : `${facet}:${table}`) as ResourceRef,
       methods: chain.methods,
     };
   }
@@ -382,11 +398,21 @@ export function storeResourceFromCall(
 }
 
 /**
- * Walk an `fx.store(…).a().b(table)` chain and return the table identifier.
+ * Walk an `fx.store(…).a().b(table)` chain and return the declared table
+ * name — resolved through a registered `table` binding (the real string
+ * passed to `store.schema.table(name, …)`) when the argument is one, so a
+ * JS binding named differently from its declared table (`const notesTable
+ * = store.schema.table("notes", …)`) still resolves to `"notes"`, matching
+ * what the kernel reads off the live table object at call time. Falls back
+ * to the raw identifier text otherwise.
  *
  * @param call - Any call in the chain
+ * @param bindings - Scope bindings
  */
-function tableFromStoreChain(call: CallExpression): string | undefined {
+function tableFromStoreChain(
+  call: CallExpression,
+  bindings: ReadonlyMap<string, InferBinding>,
+): string | undefined {
   let current: AstNode | undefined = call;
   while (current && current.type === "CallExpression") {
     const c = current as CallExpression;
@@ -394,8 +420,11 @@ function tableFromStoreChain(call: CallExpression): string | undefined {
     if (!link || link.rootMethod !== "store") break;
     const leaf = link.methods[link.methods.length - 1]!;
     if (TABLE_ARG_METHODS.has(leaf)) {
-      const table = identifierName(c.arguments[0]);
-      if (table) return table;
+      const id = identifierName(c.arguments[0]);
+      if (id) {
+        const binding = bindings.get(id);
+        return binding?.kind === "table" ? binding.ref : id;
+      }
     }
     const callee = c.callee;
     if (callee.type === "MemberExpression") {

package/src/compiler/extract.test.ts

@@ -344,3 +344,128 @@ export const remove = mounted.remove;
     expect(manifest.flows?.list?.breaking).toBe(true);
   });
 });
+
+describe("extractManifest — files-store write methods", () => {
+  test("fx.store(files).put(...) infers a write, unannotated", async () => {
+    const source = `
+import { on, flow, http, gate, store } from "okengine";
+
+export const files = store.files("uploads");
+
+export const attach = on(
+  http.post("/attach").gate(gate.public),
+  flow({
+    name: "notes.attach",
+    unit: "notes",
+    do: async (input, fx) => {
+      await fx.store(files).put("key", input.text);
+      return { ok: true };
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/attach.ts": source });
+
+    expect(manifest.flows?.["notes.attach"]?.effects?.writes).toEqual(["files:uploads"]);
+  });
+
+  test("fx.store(files).putImage(...) infers a write, unannotated", async () => {
+    const source = `
+import { on, flow, http, gate, store } from "okengine";
+
+export const files = store.files("uploads");
+
+export const attach = on(
+  http.post("/attach").gate(gate.public),
+  flow({
+    name: "notes.attachImage",
+    unit: "notes",
+    do: async (input, fx) => {
+      await fx.store(files).putImage("key", input.bytes);
+      return { ok: true };
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/attach.ts": source });
+
+    expect(manifest.flows?.["notes.attachImage"]?.effects?.writes).toEqual(["files:uploads"]);
+  });
+
+  test("fx.store(files).list(...) infers a read, unannotated", async () => {
+    const source = `
+import { on, flow, every, store } from "okengine";
+
+export const files = store.files("uploads");
+
+export const sweep = on(
+  every("1d"),
+  flow({
+    name: "notes.sweep",
+    unit: "notes",
+    do: async (_input, fx) => {
+      const keys = await fx.store(files).list();
+      return { count: keys.length };
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/sweep.ts": source });
+
+    expect(manifest.flows?.["notes.sweep"]?.effects?.reads).toEqual(["files:uploads"]);
+  });
+});
+
+describe("extractManifest — channel medium binder aliasing", () => {
+  test("mail.template(...) resolves through `const mail = channel.email(...)`", async () => {
+    const source = `
+import { on, flow, http, gate, channel } from "okengine";
+
+const mail = channel.email({ from: "Notes <notes@localhost>" });
+
+export const noteCreatedMail = mail.template("note-created", {
+  locales: ["en", "ar"],
+});
+
+export const onCreated = on(
+  http.post("/hook").gate(gate.public),
+  flow({
+    name: "notes.onCreated",
+    unit: "notes",
+    do: async (payload, fx) => {
+      await fx.send(noteCreatedMail, { to: "you@localhost", data: payload });
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/notes.ts": source });
+
+    expect(manifest.flows?.["notes.onCreated"]?.effects?.sends).toEqual(["note-created"]);
+    expect(manifest.channels?.["note-created"]?.medium).toBe("email");
+  });
+
+  test("sms medium binder alias carries its medium (not defaulted to email)", async () => {
+    const source = `
+import { on, flow, http, gate, channel } from "okengine";
+
+const otp = channel.sms({});
+
+export const otpTemplate = otp.template("otp-code", {});
+
+export const send = on(
+  http.post("/otp").gate(gate.public),
+  flow({
+    name: "notes.sendOtp",
+    unit: "notes",
+    do: async (payload, fx) => {
+      await fx.send(otpTemplate, { to: "+10000000000", data: payload });
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/otp.ts": source });
+
+    expect(manifest.flows?.["notes.sendOtp"]?.effects?.sends).toEqual(["otp-code"]);
+    expect(manifest.channels?.["otp-code"]?.medium).toBe("sms");
+  });
+});

package/src/compiler/extract.ts

@@ -14,6 +14,7 @@ import type {
   AiModel,
   AiPrompt,
   Channel,
+  ChannelMedium,
   Clock,
   DeclaredColumn,
   Effects,
@@ -22,6 +23,7 @@ import type {
   Journey,
   Manifest,
   RateStrategy,
+  ResourceRef,
   SecretContract,
   Signal,
   SignalDelivery,
@@ -93,6 +95,8 @@ interface ProjectScope {
     string,
     { storeName: string; storeRef: string; unit?: string; breaking?: boolean }
   >;
+  /** Local binding name → medium, for `const x = channel.email(…)` binders. */
+  channelMediumBindings: Map<string, ChannelMedium>;
 }
 
 /**
@@ -122,6 +126,7 @@ export async function extractManifest(options: ExtractManifestOptions = {}): Pro
     flows: {},
     flowExports: new Map(),
     resources: new Map(),
+    channelMediumBindings: new Map(),
   };
 
   const parsed = files.map((file) => {
@@ -328,7 +333,14 @@ function collectSchemaTable(call: CallExpression, program: AstNode, scope: Proje
   const entry = { name: tableName, columns };
   scope.schemaTables.set(tableName, entry);
   const bindingName = enclosingConstName(call, program);
-  if (bindingName) scope.schemaTables.set(bindingName, entry);
+  if (bindingName) {
+    scope.schemaTables.set(bindingName, entry);
+    // Declared table name, not the JS binding — resolved by
+    // tableFromStoreChain so `const notesTable = store.schema.table("notes",
+    // …)` still infers "sql:notes", matching what the kernel reads off the
+    // live table object (see ../manifest/sql-resource.ts).
+    scope.bindings.set(bindingName, { kind: "table", ref: tableName });
+  }
 }
 
 function attachSchemaOption(
@@ -583,6 +595,8 @@ function camelToSnakeKey(key: string): string {
     .toLowerCase();
 }
 
+const CHANNEL_MEDIUM_METHODS = new Set(["email", "sms", "whatsapp", "push"]);
+
 function visitDeclarationCall(call: CallExpression, program: AstNode, scope: ProjectScope): void {
   const callee = call.callee;
 
@@ -717,7 +731,17 @@ function visitDeclarationCall(call: CallExpression, program: AstNode, scope: Pro
       }
     }
 
-    if (obj === "channel" && prop === "template") {
+    // channel.email(…) / .sms(…) / .whatsapp(…) / .push(…) — medium binder,
+    // usually held in a local const and called later as `mail.template(…)`.
+    if (obj === "channel" && prop && CHANNEL_MEDIUM_METHODS.has(prop)) {
+      const bindingName = enclosingConstName(call, program);
+      if (bindingName) {
+        scope.channelMediumBindings.set(bindingName, prop as ChannelMedium);
+      }
+    }
+
+    const boundMedium = obj ? scope.channelMediumBindings.get(obj) : undefined;
+    if ((obj === "channel" && prop === "template") || (prop === "template" && boundMedium)) {
       const templateName = stringArg(call.arguments[0]);
       const opts = objectArg(call.arguments[1]);
       if (templateName) {
@@ -725,7 +749,9 @@ function visitDeclarationCall(call: CallExpression, program: AstNode, scope: Pro
         const locales = stringArrayProp(opts, "locales");
         const description = stringProp(opts, "description");
         scope.channels[templateName] = {
-          ...(medium ? { medium: medium as Channel["medium"] } : { medium: "email" }),
+          ...(medium
+            ? { medium: medium as Channel["medium"] }
+            : { medium: boundMedium ?? "email" }),
           ...(locales ? { locales } : {}),
           ...(description ? { description } : {}),
         };
@@ -1333,9 +1359,8 @@ function registerResourceMount(
   const resource = baseName ? scope.resources.get(baseName) : undefined;
 
   const unit = resource?.unit;
-  const storeRef = resource?.storeRef as Effects["reads"] extends readonly (infer R)[] | undefined
-    ? R
-    : never;
+  const storeRef: ResourceRef | undefined =
+    resource?.storeRef !== undefined ? (resource.storeRef as ResourceRef) : undefined;
   const effects: Effects | undefined = storeRef
     ? { reads: [storeRef], writes: [storeRef] }
     : undefined;

package/src/config/index.ts

@@ -155,13 +155,13 @@ export interface DbConfig {
   /**
    * Abstract schema declare module (`store.schema.table` exports).
    * When present, `oke db` emits Drizzle into {@link generated} before sync.
-   * Default `"src/schema.decl.ts"` (emit skipped if the file is absent).
+   * Default `"src/db/schema.decl.ts"` (legacy `"src/schema.decl.ts"` still resolved).
    */
   readonly declare?: string;
   /**
    * Generated Drizzle schema path written from abstract decls.
-   * Default `"src/schema.generated.ts"`. Point `drizzle.config.ts` `schema`
-   * at this file when using the abstract path.
+   * Default `"src/db/schema.generated.ts"` (legacy `"src/schema.generated.ts"`).
+   * Point `drizzle.config.ts` `schema` at this file when using the abstract path.
    */
   readonly generated?: string;
   /**

package/src/console/server/claim.ts

@@ -58,7 +58,9 @@ export function mintClaimCode(now: () => number = Date.now): ClaimCodeState {
  */
 export function printClaimCodeOnce(
   state: ClaimCodeState,
-  write: (line: string) => void = (line) => console.log(line),
+  write: (line: string) => void = (line) => {
+    process.stdout.write(line);
+  },
 ): void {
   if (state.printed) return;
   state.printed = true;