@nanobpm/urban 0.16.0 → 0.17.0

package/src/runtime/core/modules/gateway.ts

@@ -100,12 +100,19 @@ export class Table<T extends object = Row> {
     this.pk = pk;
   }
 
-  /** Insert one row (only the present keys are written); returns the new primary-key value
-   * (the inserted rowid for an INTEGER PRIMARY KEY). */
+  /** Insert one row; returns the new primary-key value (the inserted rowid for an INTEGER
+   * PRIMARY KEY). Keys whose value is `undefined` are omitted, so the table's own column
+   * `DEFAULT`/`NULL` governs — `undefined` means "not provided, let the schema decide", never
+   * a bound value. An explicit `null` is preserved (it stores `NULL`). */
   async insert(row: Partial<T>): Promise<number | bigint> {
-    const keys = Object.keys(row);
+    const provided = Object.keys(row);
+    const keys = provided.filter((k) => (row as Row)[k] !== undefined);
     if (keys.length === 0) {
-      throw new Error(`Table(${this.name}).insert: no columns to insert`);
+      throw new Error(
+        provided.length === 0
+          ? `Table(${this.name}).insert: no columns to insert (empty row)`
+          : `Table(${this.name}).insert: no columns to insert (all values were undefined)`,
+      );
     }
     const cols = keys.map(quoteIdent).join(", ");
     const ph = keys.map(() => "?").join(", ");
@@ -158,9 +165,11 @@ export class Table<T extends object = Row> {
     return rows[0] as T | undefined;
   }
 
-  /** Patch the row with the given primary key; returns rows changed. */
+  /** Patch the row with the given primary key; returns rows changed. Keys whose value is
+   * `undefined` are skipped (that column is left unchanged); an explicit `null` clears the
+   * column to `NULL`. A patch with no defined keys is a no-op. */
   async update(id: unknown, patch: Partial<T>): Promise<number> {
-    const keys = Object.keys(patch);
+    const keys = Object.keys(patch).filter((k) => (patch as Row)[k] !== undefined);
     if (keys.length === 0) return 0;
     const set = keys.map((k) => `${quoteIdent(k)} = ?`).join(", ");
     const r = await this.#src.exec(

package/src/runtime/core/modules/triggers.test.ts

@@ -2,7 +2,7 @@ import { test } from "node:test";
 import assert from "node:assert/strict";
 import type { AppApi, RuntimeContext } from "../context.ts";
 import type { HttpRequest } from "../host.ts";
-import type { TriggerDecl } from "../manifest.ts";
+import type { Trigger } from "../manifest.ts";
 import { makeRouter } from "../router.ts";
 import { evalCorrelation, mountTriggers, runTriggerAction, type SchedulerDeps } from "./triggers.ts";
 
@@ -33,7 +33,7 @@ function fakeApp(): { app: AppApi; calls: EngineCall[]; logs: Array<{ level: str
   return { app, calls, logs };
 }
 
-function fakeCtx(triggers: TriggerDecl[]): { ctx: RuntimeContext; hostLogs: Array<{ level: string; msg: string }> } {
+function fakeCtx(triggers: Trigger[]): { ctx: RuntimeContext; hostLogs: Array<{ level: string; msg: string }> } {
   const hostLogs: Array<{ level: string; msg: string }> = [];
   const ctx = {
     root: "/app",
@@ -113,6 +113,8 @@ test("evalCorrelation returns undefined for a non-scalar result", () => {
 
 test("runTriggerAction starts a process with action.variables", async () => {
   const { app, calls } = fakeApp();
+  // The manifest surface types `variables` as a FEEL string; the runtime helper
+  // (runTriggerAction/resolveActionVariables) also accepts an inline object literal.
   const res = await runTriggerAction(app, { start: "proc-1", variables: { a: 1 } }, {
     body: { ignored: true },
     headers: {},
@@ -207,7 +209,7 @@ test("cron trigger with an invalid spec logs an error and does not schedule", ()
 
 test("cron trigger with no actionable action is not scheduled", () => {
   const { app, logs } = fakeApp();
-  const { ctx } = fakeCtx([{ id: "noop", type: "cron", spec: "0 6 * * *" }]);
+  const { ctx } = fakeCtx([{ id: "noop", type: "cron", spec: "0 6 * * *", action: {} }]);
   const sched = fakeScheduler(0);
   const handle = mountTriggers(ctx, app, sched);
   assert.equal(sched.pending(), 0);

package/src/runtime/core/modules/triggers.ts

@@ -6,7 +6,7 @@
 import type { AppApi, Mounted, RuntimeContext } from "../context.ts";
 import type { HttpRequest } from "../host.ts";
 import { json, normalizeRoutePath, type Route } from "../router.ts";
-import type { TriggerDecl } from "../manifest.ts";
+import type { Trigger } from "../manifest.ts";
 import { nextCronFire, parseCron } from "./cron.ts";
 
 export interface TriggersHandle extends Mounted {
@@ -112,9 +112,23 @@ function headerRecord(req: HttpRequest): Record<string, string> {
  * of `correlationKey`/`variables`; cron passes a minimal `{ firedAt }` body. Returns what
  * was done.
  */
+/**
+ * The trigger action as the *runtime* helper reads it: the fields `runTriggerAction`
+ * consumes, with `variables` permitting an inline object literal as well as a FEEL string.
+ * The manifest surface keeps `variables` string-only (a FEEL expression);
+ * `resolveActionVariables` tolerates both, so this shape matches runtime behaviour without
+ * loosening the schema. A locked `Trigger["action"]` is assignable to it.
+ */
+export interface RuntimeTriggerAction {
+  start?: string;
+  message?: string;
+  correlationKey?: string;
+  variables?: string | Record<string, unknown>;
+}
+
 export async function runTriggerAction(
   app: AppApi,
-  action: TriggerDecl["action"],
+  action: RuntimeTriggerAction | undefined,
   scope: Scope,
 ): Promise<{ kind: "start" | "message" | "none"; target?: string; correlationKey?: string }> {
   if (!action) return { kind: "none" };
@@ -161,7 +175,7 @@ export function mountTriggers(
   let stopped = false;
 
   // Arm a cron trigger: compute the next UTC fire, sleep until it, fire the action, repeat.
-  const armCron = (trig: TriggerDecl): void => {
+  const armCron = (trig: Trigger): void => {
     const spec = trig.spec;
     if (!spec) {
       ctx.host.log("warn", `trigger "${trig.id}": cron trigger has no spec, skipped`);
@@ -241,7 +255,7 @@ export function mountTriggers(
     arm();
   };
 
-  for (const trig of (ctx.manifest.triggers ?? []) as TriggerDecl[]) {
+  for (const trig of (ctx.manifest.triggers ?? []) as Trigger[]) {
     if (trig.type === "cron") {
       armCron(trig);
       continue;

package/src/runtime/core/modules/workers.ts

@@ -4,7 +4,7 @@
 
 import type { AppApi, Mounted, RuntimeContext } from "../context.ts";
 import type { EngineJob, JobHandler, WorkerSubscription } from "../host.ts";
-import { workerJobType, type WorkerDecl } from "../manifest.ts";
+import { workerJobType, type Worker } from "../manifest.ts";
 import { type DecisionEvaluator, type LlmRuntime, runLlmJob } from "./llm.ts";
 
 /** The subset of the engine SDK the LLM decision-rails need: evaluate a DMN decision,
@@ -106,7 +106,7 @@ export async function mountWorkers(ctx: RuntimeContext, app: AppApi): Promise<Wo
     return mod;
   };
 
-  for (const decl of decls as WorkerDecl[]) {
+  for (const decl of decls as Worker[]) {
     const jobType = workerJobType(decl);
     if (!jobType) continue;
     if (!decl.handler) {

package/src/runtime/core/runtime.test.ts

@@ -152,6 +152,12 @@ test("runtime materializes the manifest end-to-end against a fake engine", async
 
     // field-drift guard
     assert.throws(() => app.data!.repo("task").insert({ bogus: 1 }));
+    // all-declared-but-undefined payload throws (parity with Table.insert): the caller
+    // meant to write those columns, so we don't silently insert a DEFAULT VALUES row.
+    assert.throws(
+      () => app.data!.repo("task").insert({ title: undefined, status: undefined }),
+      /all values were undefined/,
+    );
   } finally {
     await app.stop();
     await rm(dir, { recursive: true, force: true });

package/src/runtime/core/validate.ts

@@ -1,13 +1,14 @@
-// Manifest validation. We deliberately avoid a heavyweight JSON-Schema engine here to
-// keep core dependency-free and runtime-agnostic. Instead we drive validation *from* the
-// vendored nano-app.schema.json (the ADR 0027 source of truth) for the top-level envelope
-// — required keys, allowed keys (additionalProperties:false), the schemaVersion const, and
-// the id slug pattern — and then layer the runtime's binding rules (a worker needs a
-// handler, a data source needs driver+url, a typed table needs fields, a trigger needs
-// id+type). Reading the schema means the envelope check tracks the schema and can't drift
-// from it silently.
+// Manifest validation. We deliberately avoid a heavyweight JSON-Schema engine here to keep
+// core lean and runtime-agnostic. Instead we drive validation *from* the canonical
+// nano-app.schema.json (the ADR 0027 source of truth, imported from the
+// @nanobpm/nano-app-schema package) for the top-level envelope — required keys, allowed keys
+// (additionalProperties:false), the schemaVersion const, and the id slug pattern — and then
+// layer the runtime's binding rules (a worker needs a handler, a data source needs
+// driver+url, a typed table needs fields, a trigger needs id+type). Importing the shared
+// schema JSON means the envelope check tracks the published schema and can't drift from it
+// silently — the whole point of consuming the package rather than vendoring a copy.
 
-import schema from "../schema/nano-app.schema.json" with { type: "json" };
+import schema from "@nanobpm/nano-app-schema/schema" with { type: "json" };
 import { workerJobType, type AppManifest } from "./manifest.ts";
 
 export interface ValidationIssue {
@@ -73,7 +74,7 @@ export function collectManifestIssues(m: unknown): ValidationIssue[] {
   if (Array.isArray(man.workers)) {
     man.workers.forEach((w, i) => {
       if (!workerJobType(w)) {
-        issues.push({ path: `workers[${i}]`, message: "missing taskType/type" });
+        issues.push({ path: `workers[${i}]`, message: "missing taskType" });
       }
       // The schema allows a worker backed by either a `handler` file or an `llm`
       // binding (oneOf). Require exactly one — don't force `handler`.

package/src/runtime/index.ts

@@ -19,13 +19,16 @@ export {
 export type {
   ActionDecl,
   AppManifest,
+  ChatSurface,
   DataSource,
+  DomainField,
   DomainType,
   LlmBinding,
-  SurfaceDecl,
-  TriggerDecl,
-  TypeField,
-  WorkerDecl,
+  PagesSurface,
+  Surfaces,
+  TaskInboxSurface,
+  Trigger,
+  Worker,
 } from "./core/manifest.ts";
 
 // Validation