turbine-orm 0.21.0 → 0.23.0

package/README.md

@@ -771,9 +771,9 @@ When Turbine receives an external pool, `db.disconnect()` is a no-op: the caller
 
 ## Database engines
 
-Turbine is **Postgres-first** — `import { TurbineClient } from 'turbine-orm'` targets PostgreSQL, and the safety bundle above is built around it. When you need another database, the same typed API runs on **SQLite**, **MySQL 8**, and **SQL Server** through subpath exports. Multi-engine is *additive*, not a pivot: pick the engine that fits, keep the same `findMany` / `with` / `where` API.
+Turbine is **Postgres-first** — `import { TurbineClient } from 'turbine-orm'` targets PostgreSQL, and the safety bundle above is built around it. When you need another database, the same typed API runs on **SQLite**, **MySQL 8**, and **SQL Server** through subpath exports — plus **PowDB**, a single-node embedded database with its own query language (PowQL). Multi-engine is *additive*, not a pivot: pick the engine that fits, keep the same `findMany` / `with` / `where` API.
 
-The root install stays one dependency (`pg`). Each engine's driver is its own concern: SQLite needs nothing (Node's built-in `node:sqlite`), MySQL and SQL Server use **optional peer dependencies** you install only if you use them.
+Two engines run **in-process** (no server): **SQLite** (always — there is no SQLite wire protocol) and **PowDB**, which uniquely runs *both* in-process (embedded) *and* over a network client against the same data. The root install stays one dependency (`pg`). Each engine's driver is its own concern: SQLite needs nothing (Node's built-in `node:sqlite`), while MySQL, SQL Server, and PowDB use **optional peer dependencies** you install only if you use them.
 
 ```bash
 # SQLite — zero extra deps (Node >= 22.5, built-in node:sqlite)
@@ -784,6 +784,10 @@ npm install turbine-orm mysql2
 
 # SQL Server 2016+ — optional peer
 npm install turbine-orm mssql
+
+# PowDB — optional peer; embedded (in-process) or networked transport
+npm install turbine-orm @zvndev/powdb-embedded   # in-process
+npm install turbine-orm @zvndev/powdb-client     # networked
 ```
 
 Each engine ships a factory that returns the same `TurbineClient`:
@@ -813,6 +817,17 @@ import { SCHEMA } from './generated/turbine/metadata.js';
 const db = await turbineMssql('mssql://sa:Passw0rd!@localhost:1433/app', SCHEMA);
 ```
 
+```ts
+// PowDB — async; embedded (in-process) or networked. Schema is code-defined (no introspection).
+import { turbinePowDB } from 'turbine-orm/powdb';
+import { schema } from './schema.js'; // defineSchema({...})
+
+// Embedded, in-process — syncMode 'normal' makes writes beat SQLite:
+const db = await turbinePowDB({ embedded: './data', syncMode: 'normal' }, schema);
+// …or networked against a running powdb-server:
+// const db = await turbinePowDB('powdb://127.0.0.1:7070', schema);
+```
+
 ### Capability matrix
 
 Everything is honest about what ports and what doesn't. Features marked **PG-only** throw a typed `UnsupportedFeatureError` (`TURBINE_E017`) on other engines rather than silently degrading.
@@ -831,6 +846,8 @@ Everything is honest about what ports and what doesn't. Features marked **PG-onl
 
 **Engine notes:** SQLite uses `RETURNING` (≥ 3.35) just like Postgres. MySQL has no `RETURNING`, so writes re-`SELECT` the affected row and **`createMany` returns `[]`** (the rows ARE inserted — re-query if you need them). SQL Server returns rows via `OUTPUT`/`MERGE`; `DISTINCT ON` is Postgres-only. Only Postgres streams via a true cursor (constant memory); the other engines' `findManyStream` materializes the result then yields it in batches. Optimistic locking throws `OptimisticLockError` on all engines (on MySQL the conflict is detected from the version-checked UPDATE's affected-row count). The `turbine` CLI (`generate`, `migrate`) is currently PostgreSQL-only — point the engine factories at a hand-written or programmatically introspected `SCHEMA`.
 
+**PowDB** speaks its own non-SQL query language (PowQL), so it sits outside the SQL matrix above. It uses `reselect` writes with client-assigned UUID PKs, N+1 relation loaders (no `json_agg`), single-writer transactions (no nesting), and `defineSchema` (no introspection). Embedded `syncMode: 'normal'` writes beat SQLite; the networked transport runs the same data over a socket. many-to-many, nested writes, composite keys, cursor streaming, and the Postgres-only trio throw `UnsupportedFeatureError`. Full details: **[turbineorm.dev/engines#powdb](https://turbineorm.dev/engines#powdb)**.
+
 Full setup, signatures, and the complete support matrix: **[turbineorm.dev/engines](https://turbineorm.dev/engines)**.
 
 ## Configuration

package/dist/cjs/client.js

@@ -120,7 +120,9 @@ class TransactionClient {
             // We use a proxy pool that routes queries through the transaction client
             const txPool = this.createTxPool();
             const txOpts = { ...this.queryOptions, _txScoped: true };
-            qi = new index_js_1.QueryInterface(txPool, name, this.schema, this.middlewares, txOpts);
+            qi = txOpts.queryInterfaceFactory
+                ? txOpts.queryInterfaceFactory(txPool, name, this.schema, this.middlewares, txOpts)
+                : new index_js_1.QueryInterface(txPool, name, this.schema, this.middlewares, txOpts);
             this.tableCache.set(name, qi);
         }
         return qi;
@@ -262,6 +264,11 @@ class TurbineClient {
             preparedStatements: envDisablePrepared ? false : (config.preparedStatements ?? !config.pool),
             sqlCache: config.sqlCache ?? true,
             dialect: config.dialect,
+            // Non-SQL backends (PowDB) inject a factory that builds their own query
+            // interface (PowqlInterface) instead of the SQL QueryInterface. SQL engines
+            // never set this, so `table()` keeps constructing `new QueryInterface`.
+            queryInterfaceFactory: config
+                .queryInterfaceFactory,
             _onQuery: (event) => {
                 if (this.queryListeners.size === 0)
                     return;
@@ -413,7 +420,9 @@ class TurbineClient {
     table(name) {
         let qi = this.tableCache.get(name);
         if (!qi) {
-            qi = new index_js_1.QueryInterface(this.pool, name, this.schema, this.middlewares, this.queryOptions);
+            qi = this.queryOptions?.queryInterfaceFactory
+                ? this.queryOptions.queryInterfaceFactory(this.pool, name, this.schema, this.middlewares, this.queryOptions)
+                : new index_js_1.QueryInterface(this.pool, name, this.schema, this.middlewares, this.queryOptions);
             this.tableCache.set(name, qi);
         }
         return qi;

package/dist/cjs/generate.js

@@ -508,6 +508,10 @@ function serializeColumn(col) {
         `arrayType: '${escSQ(col.arrayType ?? col.pgArrayType)}'`,
         `pgArrayType: '${escSQ(col.pgArrayType)}'`,
     ];
+    // Emit isGenerated only when set (server-generated serial/identity), so the
+    // output stays byte-identical for the common client-default columns.
+    if (col.isGenerated)
+        parts.push(`isGenerated: true`);
     if (col.maxLength !== undefined)
         parts.push(`maxLength: ${col.maxLength}`);
     return `{ ${parts.join(', ')} }`;

package/dist/cjs/introspect.js

@@ -35,6 +35,7 @@ const SQL_COLUMNS = `
     data_type,
     is_nullable,
     column_default,
+    is_identity,
     ordinal_position,
     character_maximum_length
   FROM information_schema.columns
@@ -170,6 +171,11 @@ async function introspectPostgresCatalog(options) {
                     (0, schema_js_1.pgTypeToTs)(isArray ? dialectType : baseType, isNullable),
                 nullable: isNullable,
                 hasDefault: row.column_default !== null,
+                // Server-generated = a sequence default (serial/BIGSERIAL → nextval(…))
+                // or an IDENTITY column. Distinct from a client-side default expression
+                // (gen_random_uuid(), now()), which Turbine must still synthesize.
+                isGenerated: (typeof row.column_default === 'string' && row.column_default.includes('nextval(')) ||
+                    row.is_identity === 'YES',
                 isArray,
                 arrayType,
                 pgArrayType: arrayType,