@zerotal/orm 1.7.0 → 1.7.3

package/CHANGELOG.md

@@ -6,6 +6,66 @@ follows the Zerotal monorepo's unified versioning.
 
 **Maturity: `stable`**
 
+## [Unreleased]
+
+### Fixed
+
+- **A boolean column could not hold a boolean on PostgreSQL.** `table.boolean()` compiled to
+  `INTEGER` on every engine — correct on SQLite, which has no boolean type, and rejected outright
+  by PostgreSQL: `column "…" is of type integer but expression is of type boolean` (42804) on the
+  first insert, and again on any `where(column, true)`. `DEFAULT` clauses failed the same way, a
+  boolean default having been serialised to `1`. The storage type now comes from the dialect, as
+  the auto-increment column already did. SQLite and MySQL are unchanged; existing PostgreSQL
+  tables keep their integer columns until a migration alters them. Found by the new smoke suite
+  that runs the ORM against a real PostgreSQL in CI.
+
+- **A seeder that failed partway left its rows behind.** `Seeder.call()` has always wrapped
+  _composed_ seeders in a transaction, so a `DatabaseSeeder` that delegates was atomic and one that
+  does its work inline — which is most of them — was not. A failure on the fourth table committed
+  the first three, so the obvious next move, running it again, died on a unique constraint, and the
+  only way out was `migrate:fresh`. Migrations became transactional in 1.7.0; this closes the
+  asymmetry.
+
+  `db:seed` now wraps the whole run. Nesting is safe — `DB.transaction` opens a `SAVEPOINT` when one
+  is already open, so an inner `call()` still rolls back independently. The wrapper is skipped when
+  no connection is bound, because a seeder is not obliged to touch the database and an app that has
+  not configured one should not fail to seed over a transaction it never needed.
+
+### Fixed
+
+- **`DatabaseProvider` now runs in `worker`, so `zt queue:work` can boot.** It did not, and the
+  consequence was total rather than partial: `QueueProvider` _does_ run in `worker`, the
+  queue's own default driver is `sqlite`, and so the worker asked for a connection this
+  provider had not made and died on startup —
+
+  ```
+  error: [Zerotal ORM] No database connection. Is DatabaseProvider registered?
+  ```
+
+  — while it plainly was registered.
+
+  It was never only the queue. Nine providers run in `worker` — notifications, audit, media,
+  tenancy, scheduler among them — and a job exists to do work with models. `AuthProvider` and
+  `SessionProvider` are absent from `worker` correctly, having neither a request nor a
+  session; the ORM being absent was an oversight, dating to 1.0.2.
+
+  Found building the first cookbook app, whose first queued job could not run.
+
+- **Relation keys now accept the JS spelling, like every other identifier.** The convention is
+  camelCase in the application and snake_case in the database, converted on the way through —
+  and relation keys were the one place it did not happen. `@hasMany(() => Issue, { foreignKey:
+"projectId" })` type-checked and then emitted `no such column: issues.projectId`, with the
+  error naming a column rather than the relation that produced it.
+
+  `_relationSubquery()` builds its subquery with a plain `QueryBuilder`, and the `_column()`
+  hook that converts is an override on `ModelQueryBuilder`, so nothing was converting these.
+  The keys are now converted where they are qualified, which covers `withCount`, `withSum`,
+  `has`/`whereHas` and `withExists` for `hasMany`, `belongsTo`, `manyToMany` and the morph
+  relations. Both spellings resolve to the column, so apps already passing `project_id` are
+  unaffected.
+
+  Found building the first cookbook app, where a project list would not count its issues.
+
 ## [1.7.0] — 2026-08-16
 
 ### Fixed

package/api-surface.md

@@ -182,7 +182,7 @@ class Cast = {
 }
 
 class ColumnBuilder = {
-  new <Locked extends string = never>(name: string, _sqlType: string, isPrimary?: boolean, isAutoIncrement?: boolean): ColumnBuilder<Locked>
+  new <Locked extends string = never>(name: string, _sqlType: string, isPrimary?: boolean, isAutoIncrement?: boolean, _isBoolean?: boolean): ColumnBuilder<Locked>
   after: (_column: string) => ColumnBuilder<Locked>
   alter: () => ColumnBuilder<Locked>
   before: (_column: string) => ColumnBuilder<Locked>
@@ -566,9 +566,11 @@ class MysqlDialect = {
   advisoryLockSql: (key: number) => DialectQuery
   advisoryUnlockSql: (key: number) => DialectQuery
   autoIncrementColumn: (column: string) => string
+  booleanLiteral: (value: boolean) => string
   dateExpr: (part: DatePart, column: string) => string
   hasColumnSql: (table: string, column: string) => DialectQuery
   hasTableSql: (table: string) => DialectQuery
+  readonly booleanType: 'INTEGER'
   readonly name: 'mysql'
   readonly supportsAdvisoryLocks: true
   readonly supportsTransactionalDdl: false
@@ -605,9 +607,11 @@ class PostgresDialect = {
   advisoryLockSql: (key: number) => DialectQuery
   advisoryUnlockSql: (key: number) => DialectQuery
   autoIncrementColumn: (column: string) => string
+  booleanLiteral: (value: boolean) => string
   dateExpr: (part: DatePart, column: string) => string
   hasColumnSql: (table: string, column: string) => DialectQuery
   hasTableSql: (table: string) => DialectQuery
+  readonly booleanType: 'BOOLEAN'
   readonly name: 'postgres'
   readonly supportsAdvisoryLocks: true
   readonly supportsTransactionalDdl: true
@@ -742,9 +746,11 @@ class SqliteDialect = {
   advisoryLockSql: () => DialectQuery | null
   advisoryUnlockSql: () => DialectQuery | null
   autoIncrementColumn: (column: string) => string
+  booleanLiteral: (value: boolean) => string
   dateExpr: (part: DatePart, column: string) => string
   hasColumnSql: (table: string, column: string) => DialectQuery
   hasTableSql: (table: string) => DialectQuery
+  readonly booleanType: 'INTEGER'
   readonly name: 'sqlite'
   readonly supportsAdvisoryLocks: false
   readonly supportsTransactionalDdl: true
@@ -1260,9 +1266,11 @@ interface SqlDialect = {
   advisoryLockSql: (key: number) => DialectQuery | null
   advisoryUnlockSql: (key: number) => DialectQuery | null
   autoIncrementColumn: (column: string) => string
+  booleanLiteral: (value: boolean) => string
   dateExpr: (part: DatePart, column: string) => string
   hasColumnSql: (table: string, column: string) => DialectQuery
   hasTableSql: (table: string) => DialectQuery
+  readonly booleanType: string
   readonly name: DialectName
   readonly supportsAdvisoryLocks: boolean
   readonly supportsTransactionalDdl: boolean

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zerotal/orm",
-  "version": "1.7.0",
+  "version": "1.7.3",
   "license": "MIT",
   "maturity": "stable",
   "private": false,
@@ -31,8 +31,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@zerotal/core": "1.7.0",
-    "@zerotal/validator": "1.7.0"
+    "@zerotal/core": "1.7.3",
+    "@zerotal/validator": "1.7.3"
   },
   "devDependencies": {
     "typescript": "^5.8.0"

package/src/commands/_runSeeders.ts

@@ -1,4 +1,5 @@
 import type { Seeder } from "../seeding/Seeder.ts";
+import { DB, _getDbConnectionOverride } from "../db/DB.ts";
 
 /**
  * What running the app's seeders came to.
@@ -27,6 +28,30 @@ export type SeedOutcome =
  *
  * @internal
  */
+/**
+ * Run `body` inside a transaction when there is a database to have one on.
+ *
+ * A seeder is not obliged to touch the database — it may write fixtures to disk,
+ * prime a cache, or call an API — and an app that has not bound a connection
+ * should not fail to seed because of a transaction it never needed. So the
+ * wrapper is conditional: with a connection, the whole seed is atomic; without,
+ * `body` runs exactly as it used to.
+ */
+async function _inTransaction(body: () => Promise<void>): Promise<void> {
+  let connected = _getDbConnectionOverride() !== null;
+  if (!connected) {
+    // No override — ask the container, which throws when nothing is bound.
+    try {
+      const { _getConnection } = await import("../db/DB.ts");
+      connected = _getConnection() !== undefined;
+    } catch {
+      connected = false;
+    }
+  }
+  if (!connected) return body();
+  await DB.transaction(body);
+}
+
 export async function runSeeders(cwd: string = process.cwd()): Promise<SeedOutcome> {
   const seederPath = `${cwd}/database/seeders/DatabaseSeeder.ts`;
 
@@ -42,7 +67,9 @@ export async function runSeeders(cwd: string = process.cwd()): Promise<SeedOutco
       if (!seed) {
         return { status: "invalid", message: "Seeder index must export a default async function." };
       }
-      await seed();
+      await _inTransaction(async () => {
+        await seed();
+      });
       return { status: "seeded" };
     } catch (error) {
       return { status: "failed", message: error instanceof Error ? error.message : String(error) };
@@ -63,7 +90,20 @@ export async function runSeeders(cwd: string = process.cwd()): Promise<SeedOutco
       };
     }
 
-    await new SeederClass().run();
+    // One transaction around the whole seed.
+    //
+    // `Seeder.call()` has always wrapped *composed* seeders, so a DatabaseSeeder
+    // that delegates was atomic and one that does its work inline — which is
+    // most of them — was not. A failure halfway left its rows committed, so the
+    // obvious next move, running it again, died on a unique constraint and the
+    // only way out was `migrate:fresh`. Migrations became transactional in
+    // 1.7.0; this closes the asymmetry.
+    //
+    // Nesting is safe: `DB.transaction` opens a SAVEPOINT when one is already
+    // open, so an inner `call()` still rolls back independently.
+    await _inTransaction(async () => {
+      await new SeederClass().run();
+    });
     return { status: "seeded" };
   } catch (error) {
     return { status: "failed", message: error instanceof Error ? error.message : String(error) };

package/src/db/dialects/MysqlDialect.ts

@@ -51,6 +51,13 @@ export class MysqlDialect implements SqlDialect {
     return `${column} INT AUTO_INCREMENT PRIMARY KEY`;
   }
 
+  // MySQL BOOLEAN is a synonym for TINYINT(1) and INTEGER accepts 0/1 all the same.
+  readonly booleanType = "INTEGER";
+
+  booleanLiteral(value: boolean): string {
+    return value ? "1" : "0";
+  }
+
   advisoryLockSql(key: number): DialectQuery {
     return { sql: `SELECT GET_LOCK(?, -1)`, params: [`zerotal_lock_${key}`] };
   }

package/src/db/dialects/PostgresDialect.ts

@@ -48,6 +48,12 @@ export class PostgresDialect implements SqlDialect {
     return `${column} INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY`;
   }
 
+  readonly booleanType = "BOOLEAN";
+
+  booleanLiteral(value: boolean): string {
+    return value ? "TRUE" : "FALSE";
+  }
+
   advisoryLockSql(key: number): DialectQuery {
     return { sql: `SELECT pg_advisory_lock(?)`, params: [key] };
   }

package/src/db/dialects/SqliteDialect.ts

@@ -48,6 +48,13 @@ export class SqliteDialect implements SqlDialect {
     return `${column} INTEGER PRIMARY KEY AUTOINCREMENT`;
   }
 
+  // SQLite has no boolean type — 0/1 in an INTEGER is the storage class it uses.
+  readonly booleanType = "INTEGER";
+
+  booleanLiteral(value: boolean): string {
+    return value ? "1" : "0";
+  }
+
   advisoryLockSql(): DialectQuery | null {
     return null;
   }

package/src/db/dialects/types.ts

@@ -56,6 +56,26 @@ export interface SqlDialect {
    */
   autoIncrementColumn(column: string): string;
 
+  /**
+   * The column type a portable `table.boolean()` compiles to.
+   *
+   * SQLite has no boolean type and stores 0/1 in an `INTEGER`, which is why the
+   * Blueprint emitted `INTEGER` for every engine. PostgreSQL has a real `boolean`
+   * and refuses to compare or assign one against an integer column, so a table
+   * built that way rejected its own booleans — `column "active" is of type integer
+   * but expression is of type boolean` (SQLSTATE 42804) on the first insert, and
+   * again on any `where("active", true)`. Nothing caught it because no test
+   * executed the DDL against a server; `postgres.smoke.test.ts` now does.
+   *
+   * MySQL keeps `INTEGER`: its `BOOLEAN` is a synonym for `TINYINT(1)` and it
+   * accepts 0/1 either way, so there is no defect there to fix and no reason to
+   * churn the DDL of an engine no CI job covers.
+   */
+  readonly booleanType: string;
+
+  /** A boolean as this engine spells it in a `DEFAULT` clause. */
+  booleanLiteral(value: boolean): string;
+
   /** Whether the engine supports application-level advisory locks. */
   readonly supportsAdvisoryLocks: boolean;
 

package/src/model/ModelQueryBuilder.ts

@@ -813,26 +813,36 @@ export class ModelQueryBuilder<M extends BaseModel> extends QueryBuilder {
       );
     }
 
+    // Relation keys carry the *JS* spelling — `@hasMany(Issue, { foreignKey:
+    // "projectId" })` — because that is the convention everywhere else: camelCase
+    // in the application, snake_case in the database, converted on the way
+    // through. `_column()` does that conversion, but it is an override on
+    // *this* class and the subquery below is a plain `QueryBuilder`, so nothing
+    // was converting these. The result was a correct-looking decorator emitting
+    // `no such column: issues.projectId`, with the error naming a column rather
+    // than the relation that produced it.
+    const col = (table: string, key: string): string => `${table}.${_toSnakeColumn(key)}`;
+
     if (meta.type === "manyToMany") {
       const relTable = Related.table;
       sub = new QueryBuilder(meta.pivotTable!, this._sql)
         .join(
           relTable,
-          `${relTable}.${Related.primaryKey}`,
+          col(relTable, Related.primaryKey),
           "=",
-          `${meta.pivotTable}.${meta.pivotRelatedKey}`,
+          col(meta.pivotTable!, meta.pivotRelatedKey!),
         )
-        .whereColumn(`${meta.pivotTable}.${meta.pivotForeignKey}`, `${main}.${meta.localKey}`);
+        .whereColumn(col(meta.pivotTable!, meta.pivotForeignKey!), col(main, meta.localKey!));
       if (Related.softDeletes) sub.whereNull(`${relTable}.deleted_at`);
     } else {
       const relTable = Related.table;
       sub = new QueryBuilder(relTable, this._sql);
       if (meta.type === "belongsTo") {
-        sub.whereColumn(`${relTable}.${meta.localKey}`, `${main}.${meta.foreignKey}`);
+        sub.whereColumn(col(relTable, meta.localKey!), col(main, meta.foreignKey!));
       } else {
-        sub.whereColumn(`${relTable}.${meta.foreignKey}`, `${main}.${meta.localKey}`);
+        sub.whereColumn(col(relTable, meta.foreignKey!), col(main, meta.localKey!));
         if (meta.type === "morphMany" || meta.type === "morphOne") {
-          sub.where(`${relTable}.${meta.morphTypeColumn}`, this._ModelClass.name);
+          sub.where(col(relTable, meta.morphTypeColumn!), this._ModelClass.name);
         }
       }
       if (Related.softDeletes) sub.whereNull(`${relTable}.deleted_at`);

package/src/provider/DatabaseProvider.ts

@@ -51,8 +51,22 @@ declare module "@zerotal/core" {
  */
 export class DatabaseProvider extends ServiceProvider {
   static override provides = ["db"] as const;
+  /**
+   * Every mode, `worker` included.
+   *
+   * `worker` was missing until 1.7.1, which meant `bun zt queue:work` could not
+   * boot at all: the queue's own default driver is `sqlite`, `QueueProvider`
+   * does run in `worker`, and it asks for a connection this provider had not
+   * made — so the worker died on startup with "No database connection. Is
+   * DatabaseProvider registered?" while it plainly was.
+   *
+   * It was never only the queue. Nine providers run in `worker` — notifications,
+   * audit, media, tenancy, scheduler among them — and a job exists to do work
+   * with models. A worker without a database is a worker that cannot do the
+   * thing workers are for.
+   */
   // Use an explicit mutable array type to satisfy ServiceProvider's static property constraint.
-  static override environments: AppEnvironment[] = ["web", "console", "test", "repl"];
+  static override environments: AppEnvironment[] = ["web", "console", "worker", "test", "repl"];
 
   private _disposeObservability: (() => void) | undefined = undefined;
 

package/src/schema/Blueprint.ts

@@ -314,12 +314,15 @@ export class Blueprint {
   // ── Boolean ───────────────────────────────────────────────────────────────
 
   /**
-   * Boolean column. Stored as `INTEGER` (0 / 1); JS booleans passed to
-   * {@link ColumnBuilder.default} serialise to `1` / `0`.
+   * Boolean column. The storage type is the engine's: `INTEGER` holding 0 / 1 on
+   * SQLite and MySQL, a real `BOOLEAN` on PostgreSQL — which rejects the integer
+   * form for both assignment and comparison, so emitting `INTEGER` everywhere
+   * built a column that would not take its own booleans. JS booleans passed to
+   * {@link ColumnBuilder.default} follow the same engine's spelling.
    * @category Column types
    */
   boolean(name: string): ColumnBuilder {
-    return this._add(new ColumnBuilder(name, "INTEGER"));
+    return this._add(new ColumnBuilder(name, "INTEGER", false, false, true));
   }
 
   // ── Date / time columns ───────────────────────────────────────────────────

package/src/schema/ColumnDefinition.ts

@@ -64,6 +64,11 @@ export class ColumnBuilder<Locked extends string = never> {
     private _sqlType: string,
     isPrimary = false,
     isAutoIncrement = false,
+    /**
+     * Logically a boolean, whatever `_sqlType` says. The engine decides the
+     * storage type at compile time — see {@link SqlDialect.booleanType}.
+     */
+    private _isBoolean = false,
   ) {
     this._isPrimary = isPrimary;
     this._isAutoIncr = isAutoIncrement;
@@ -324,13 +329,16 @@ export class ColumnBuilder<Locked extends string = never> {
     // PostgreSQL a syntax error and against MySQL a 1064.
     if (this._isAutoIncr) return getDialect(dialect).autoIncrementColumn(this.name);
 
-    const parts: string[] = [`${this.name} ${this._sqlType}`];
+    // A boolean's storage type is the engine's to choose: SQLite stores 0/1 in an
+    // INTEGER, PostgreSQL has a real one and rejects the integer form outright.
+    const sqlType = this._isBoolean ? getDialect(dialect).booleanType : this._sqlType;
+    const parts: string[] = [`${this.name} ${sqlType}`];
 
     if (this._isPrimary) parts.push("PRIMARY KEY");
     if (!this._isNullable && !this._isPrimary) parts.push("NOT NULL");
 
     if (this._useCurrent) parts.push("DEFAULT CURRENT_TIMESTAMP");
-    else if (this._hasDefault) parts.push(`DEFAULT ${this._serializeDefault()}`);
+    else if (this._hasDefault) parts.push(`DEFAULT ${this._serializeDefault(dialect)}`);
 
     if (this._isUnique) parts.push("UNIQUE");
     if (this._check) parts.push(`CHECK (${this._check})`);
@@ -340,10 +348,11 @@ export class ColumnBuilder<Locked extends string = never> {
     return parts.join(" ");
   }
 
-  private _serializeDefault(): string {
+  private _serializeDefault(dialect: DialectName = "sqlite"): string {
     const v = this._default;
     if (v === null) return "NULL";
-    if (typeof v === "boolean") return v ? "1" : "0";
+    // `DEFAULT 1` on a PostgreSQL boolean column is the same 42804 the value itself hit.
+    if (typeof v === "boolean") return getDialect(dialect).booleanLiteral(v);
     if (typeof v === "string") return `'${v.replace(/'/g, "''")}'`;
     return String(v);
   }