@nanobpm/urban 0.16.0 → 0.16.1

package/dist/runtime/core/modules/datasource.js

@@ -48,8 +48,17 @@ export class TypeRepo {
     }
     insert(row) {
         this.assertFields(row);
-        const keys = Object.keys(row);
+        // Omit keys whose value is `undefined` so the column's own `DEFAULT`/`NULL` governs;
+        // `undefined` means "not provided", never a bound value. An explicit `null` is preserved.
+        const provided = Object.keys(row);
+        const keys = provided.filter((k) => row[k] !== undefined);
         if (keys.length === 0) {
+            // A present-but-all-undefined payload throws (parity with Table.insert): the caller
+            // meant to write those values, so silently inserting a full DEFAULT row would create
+            // an unintended record. A genuinely empty `insert({})` is the explicit "default row".
+            if (provided.length > 0) {
+                throw new Error(`insert into type "${this.typeName}": no columns to insert (all values were undefined)`);
+            }
             return this.db.run(`INSERT INTO ${this.table()} DEFAULT VALUES`, []);
         }
         const cols = keys.join(", ");

package/dist/runtime/core/modules/gateway.d.ts

@@ -59,8 +59,10 @@ export declare class Table<T extends object = Row> {
     readonly name: string;
     readonly pk: string;
     constructor(src: DataSource, name: string, pk?: string);
-    /** 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`). */
     insert(row: Partial<T>): Promise<number | bigint>;
     /** Fetch the row with the given primary key, or `undefined`. */
     get(id: unknown): Promise<T | undefined>;
@@ -70,7 +72,9 @@ export declare class Table<T extends object = Row> {
     find(where?: Partial<T>): Promise<T[]>;
     /** The first row matching an equality filter, or `undefined`. */
     findOne(where?: Partial<T>): Promise<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. */
     update(id: unknown, patch: Partial<T>): Promise<number>;
     /** Delete the row with the given primary key; returns rows changed. */
     delete(id: unknown): Promise<number>;

package/dist/runtime/core/modules/gateway.js

@@ -40,12 +40,17 @@ export class Table {
         this.name = name;
         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) {
-        const keys = Object.keys(row);
+        const provided = Object.keys(row);
+        const keys = provided.filter((k) => 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(", ");
@@ -80,9 +85,11 @@ export class Table {
         const rows = await this.#src.query(`SELECT * FROM ${quoteIdent(this.name)}${clause} LIMIT 1`, params);
         return rows[0];
     }
-    /** 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, patch) {
-        const keys = Object.keys(patch);
+        const keys = Object.keys(patch).filter((k) => patch[k] !== undefined);
         if (keys.length === 0)
             return 0;
         const set = keys.map((k) => `${quoteIdent(k)} = ?`).join(", ");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/urban",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "Urban: build and run code-first apps on Nano — runtime, derivation toolkit, and CLI in one. Author durable processes with @nanobpm/workflow (defineFlow), a typed datasource, forms, triggers and surfaces from a nano.app.json manifest, on Node or Deno.",
   "license": "Apache-2.0",
   "type": "module",
@@ -62,7 +62,7 @@
     "test:deno": "deno test -A --no-check src/"
   },
   "dependencies": {
-    "@nanobpm/nano-sdk": "^1.2.2",
+    "@nanobpm/nano-sdk": "^1.2.3",
     "@nanobpm/workflow": "^0.7.0",
     "bpmn-auto-layout": "^2.0.0-alpha.2",
     "create-urban-app": "^0.5.0"

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

@@ -60,8 +60,19 @@ export class TypeRepo {
 
   insert(row: Record<string, unknown>): { changes: number; lastInsertRowid: number | bigint } {
     this.assertFields(row);
-    const keys = Object.keys(row);
+    // Omit keys whose value is `undefined` so the column's own `DEFAULT`/`NULL` governs;
+    // `undefined` means "not provided", never a bound value. An explicit `null` is preserved.
+    const provided = Object.keys(row);
+    const keys = provided.filter((k) => row[k] !== undefined);
     if (keys.length === 0) {
+      // A present-but-all-undefined payload throws (parity with Table.insert): the caller
+      // meant to write those values, so silently inserting a full DEFAULT row would create
+      // an unintended record. A genuinely empty `insert({})` is the explicit "default row".
+      if (provided.length > 0) {
+        throw new Error(
+          `insert into type "${this.typeName}": no columns to insert (all values were undefined)`,
+        );
+      }
       return this.db.run(`INSERT INTO ${this.table()} DEFAULT VALUES`, []);
     }
     const cols = keys.join(", ");

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

@@ -162,3 +162,60 @@ test("query/exec run raw parameterised SQL", async () => {
     assert.equal(Number((rows[0] as { total: number }).total), 42);
   });
 });
+
+test("insert omits undefined-valued keys so the column DEFAULT applies", async () => {
+  await withGateway(async (src) => {
+    const orders = src.table<Order>("orders");
+    // `total` is `NOT NULL DEFAULT 0`; passing it as undefined must omit the column
+    // (not bind NULL, which would violate NOT NULL), letting the DEFAULT fill it.
+    const id = await orders.insert({ status: "new", total: undefined });
+    assert.equal((await orders.get(id))?.total, 0);
+  });
+});
+
+test("insert preserves an explicit null; omits undefined", async () => {
+  await withGateway(async (src) => {
+    await src.exec("CREATE TABLE notes (id INTEGER PRIMARY KEY, body TEXT, tag TEXT DEFAULT 'none')");
+    const notes = src.table("notes");
+    const id = await notes.insert({ body: null, tag: undefined });
+    const row = await notes.get(id);
+    assert.equal(row?.body, null); // explicit null is stored as NULL
+    assert.equal(row?.tag, "none"); // undefined omitted → column DEFAULT
+  });
+});
+
+test("update skips undefined keys and clears on explicit null", async () => {
+  await withGateway(async (src) => {
+    await src.exec("CREATE TABLE notes (id INTEGER PRIMARY KEY, body TEXT, tag TEXT DEFAULT 'none')");
+    const notes = src.table("notes");
+    const id = await notes.insert({ body: "hello", tag: "x" });
+    // tag:undefined must be left unchanged; body updated.
+    await notes.update(id, { tag: undefined, body: "world" });
+    let row = await notes.get(id);
+    assert.equal(row?.body, "world");
+    assert.equal(row?.tag, "x");
+    // explicit null clears the column.
+    await notes.update(id, { body: null });
+    row = await notes.get(id);
+    assert.equal(row?.body, null);
+    // a patch of only-undefined keys is a no-op.
+    assert.equal(await notes.update(id, { tag: undefined }), 0);
+  });
+});
+
+test("insert throws when every provided value is undefined", async () => {
+  await withGateway(async (src) => {
+    const orders = src.table<Order>("orders");
+    await assert.rejects(
+      orders.insert({ status: undefined, total: undefined }),
+      /all values were undefined/,
+    );
+  });
+});
+
+test("insert throws a distinct message for a genuinely empty row", async () => {
+  await withGateway(async (src) => {
+    const orders = src.table<Order>("orders");
+    await assert.rejects(orders.insert({} as Partial<Order>), /empty row/);
+  });
+});

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/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 });