turbine-orm 0.34.0 → 0.36.0

package/dist/schema-builder.js

@@ -94,6 +94,7 @@ function resolveColumn(def) {
         vectorDimensions: def.dimensions ?? null,
         isArray: def.array ?? false,
         check: def.check ?? null,
+        pii: def.pii ?? false,
     };
 }
 /** Type guard: is this index declaration a doc-field expression index? */
@@ -247,6 +248,7 @@ export class ColumnBuilder {
             vectorDimensions: null,
             isArray: false,
             check: null,
+            pii: false,
         };
     }
     serial() {
@@ -353,6 +355,10 @@ export class ColumnBuilder {
         this._config.check = expression;
         return this;
     }
+    pii() {
+        this._config.pii = true;
+        return this;
+    }
     array() {
         this._config.isArray = true;
         return this;

package/dist/schema-metadata.js

@@ -337,6 +337,10 @@ export function schemaDefToMetadata(def) {
                 arrayType: pgArrayType(base),
                 pgArrayType: pgArrayType(base),
                 ...(serial ? { isGenerated: true } : {}),
+                // PII is a code-first declaration; carry it through so query-layer
+                // default-projection exclusion and Studio redaction can honor it.
+                // Only set when true, keeping output byte-stable for untagged schemas.
+                ...(config.pii ? { pii: true } : {}),
                 ...(config.maxLength != null ? { maxLength: config.maxLength } : {}),
             };
             columns.push(col);

package/dist/schema-sql.d.ts

@@ -4,9 +4,11 @@
  * Converts a SchemaDef (from defineSchema) into executable DDL statements.
  * Also provides diff and push commands for syncing schema to a live database.
  */
+import { type DestructiveStatement } from './cli/destructive.js';
 import { type Dialect } from './dialect.js';
+import { ValidationError } from './errors.js';
 import { type ReferentialAction } from './schema.js';
-import type { SchemaDef, TableDef } from './schema-builder.js';
+import { type ColumnIndexDef, type SchemaDef, type TableDef } from './schema-builder.js';
 export interface SchemaSqlOptions {
     /** SQL dialect used for DDL generation. Defaults to PostgreSQL. */
     dialect?: Dialect;
@@ -27,6 +29,32 @@ export declare function referentialActionToSql(action: ReferentialAction): strin
  * followed by CREATE INDEX statements for foreign key columns.
  */
 export declare function schemaToSQL(schema: SchemaDef, options?: SchemaSqlOptions): string[];
+/**
+ * Compare a declared plain index against a pg_indexes `indexdef` string.
+ * Returns a human-readable description of the first mismatch (uniqueness or
+ * column list), or null when the definitions agree. Expression/partial indexes
+ * in the DB never structurally match a plain column list, which is the
+ * intended outcome: the operator gets a warning rather than a silent skip.
+ */
+export declare function describeIndexDefMismatch(idx: ColumnIndexDef, indexdef: string): string | null;
+/**
+ * Pure decision for the "index exists in the DB but is not declared" warning
+ * pass. Extracted so the scope rule is unit-testable without a live database.
+ *
+ * The pass runs only when the table opts into index management by DEFINING an
+ * `indexes` array (`indexesDefined: true`), even when that array is empty or
+ * all-doc-field: deleting the last declared index must NOT silence the pass.
+ * Tables with no `indexes` key stay silent (the user is not managing indexes
+ * there). Recognized names (declared, unique-constraint / FK-column, `*_pkey`)
+ * are never flagged; everything else in the DB yields one warning.
+ */
+export declare function undeclaredIndexWarnings(opts: {
+    tableName: string;
+    indexesDefined: boolean;
+    dbIndexNames: Iterable<string>;
+    declaredNames: ReadonlySet<string>;
+    recognizedNames: ReadonlySet<string>;
+}): string[];
 export interface AlterColumnDef {
     /** Column name in snake_case */
     column: string;
@@ -119,6 +147,14 @@ export declare function diffCheckConstraints(table: string, schemaChecks: readon
  * DDL is needed to make the database match the schema definition.
  */
 export declare function schemaDiff(schema: SchemaDef, connectionString: string): Promise<DiffResult>;
+/**
+ * Scan a set of diff statements for data-destroying operations, using the same
+ * conservative scanner (`scanDestructiveSql`) that gates `migrate up`/`down`.
+ * Push mostly emits additive DDL, but a type change surfaces as a lossy
+ * `ALTER COLUMN ... TYPE` cast, exactly the kind of silent data loss `push`
+ * must never apply without an explicit opt-in.
+ */
+export declare function findDestructivePushStatements(statements: readonly string[]): DestructiveStatement[];
 export interface PushResult {
     /** Number of statements executed */
     statementsExecuted: number;
@@ -129,15 +165,36 @@ export interface PushResult {
     /** Tables altered */
     tablesAltered: string[];
 }
+/**
+ * Thrown by {@link schemaPush} when the diff contains data-destroying statements
+ * and `allowDestructive` was not set. A typed subclass of {@link ValidationError}
+ * (same `TURBINE_E003` code, no new taxonomy entry) so callers can branch on
+ * `instanceof DestructivePushRefusal` instead of sniffing the message text. The
+ * offending statements are carried on `.destructive` for programmatic display.
+ */
+export declare class DestructivePushRefusal extends ValidationError {
+    /** The destructive statements the push refused to apply. */
+    readonly destructive: DestructiveStatement[];
+    constructor(destructive: DestructiveStatement[]);
+}
 /**
  * Push a schema definition to a live database.
  *
  * Computes the diff, then executes the resulting DDL statements in a
- * single transaction. This is a destructive operation for ADD/ALTER —
- * it will NOT drop tables or columns unless explicitly configured.
+ * single transaction. It will NOT drop tables or columns.
+ *
+ * Data-loss gate: if the diff contains a destructive statement (e.g. a lossy
+ * `ALTER COLUMN ... TYPE` cast), `schemaPush` throws a
+ * {@link DestructivePushRefusal} (a {@link ValidationError} subclass carrying
+ * the offending statements on `.destructive`) listing the statements UNLESS
+ * `allowDestructive: true` is passed. The CLI (`turbine push`) catches this and
+ * prompts for the same typed confirmation as `migrate up`; programmatic callers
+ * must opt in explicitly.
  */
 export declare function schemaPush(schema: SchemaDef, connectionString: string, options?: {
     dryRun?: boolean;
+    allowDestructive?: boolean;
+    precomputedDiff?: DiffResult;
 }): Promise<PushResult>;
 /**
  * Generate the full DDL as a single formatted string.

package/dist/schema-sql.js

@@ -5,10 +5,12 @@
  * Also provides diff and push commands for syncing schema to a live database.
  */
 import pg from 'pg';
+import { DESTRUCTIVE_KIND_LABEL, scanDestructiveSql } from './cli/destructive.js';
 import { postgresDialect } from './dialect.js';
-import { UnsupportedFeatureError } from './errors.js';
+import { UnsupportedFeatureError, ValidationError } from './errors.js';
 import { pgConfActionToReferential, stripCheckWrapper } from './introspect.js';
 import { camelToSnake } from './schema.js';
+import { isDocFieldIndexDef, } from './schema-builder.js';
 /** Map a {@link ReferentialAction} to its SQL keyword form. */
 export function referentialActionToSql(action) {
     switch (action) {
@@ -110,6 +112,11 @@ export function schemaToSQL(schema, options) {
         const indexes = generateForeignKeyIndexes(table, dialect);
         statements.push(...indexes);
     }
+    // Generate CREATE INDEX / CREATE UNIQUE INDEX for user-declared indexes.
+    for (const tableName of sorted) {
+        const table = schema.tables[tableName];
+        statements.push(...generateDeclaredIndexes(table, dialect));
+    }
     return statements;
 }
 /**
@@ -327,10 +334,16 @@ function normalizeDefault(val) {
  */
 function generateForeignKeyIndexes(table, dialect = postgresDialect) {
     const indexes = [];
+    // A declared index whose deterministic name matches the auto FK-index name
+    // takes precedence (it may be UNIQUE); emitting both would fail at apply time
+    // with "relation already exists".
+    const declared = declaredPlainIndexNames(table);
     for (const [fieldName, config] of Object.entries(table.columns)) {
         if (config.referencesTarget) {
             const snakeName = camelToSnake(fieldName);
             const indexName = `idx_${table.name}_${snakeName}`;
+            if (declared.has(indexName))
+                continue;
             indexes.push(dialect.buildCreateIndexStatement({
                 name: dialect.quoteIdentifier(indexName),
                 table: dialect.quoteIdentifier(table.name),
@@ -340,6 +353,116 @@ function generateForeignKeyIndexes(table, dialect = postgresDialect) {
     }
     return indexes;
 }
+/**
+ * The deterministic SQL index name for a declared plain (column-list) index:
+ * the user-supplied `name`, else `idx_<table>_<col1>_<col2>...`, mirroring the
+ * FK-index convention in {@link generateForeignKeyIndexes}.
+ */
+function declaredIndexName(tableName, idx) {
+    if (idx.name)
+        return idx.name;
+    const cols = idx.columns.map(camelToSnake);
+    return `idx_${tableName}_${cols.join('_')}`;
+}
+/**
+ * Compare a declared plain index against a pg_indexes `indexdef` string.
+ * Returns a human-readable description of the first mismatch (uniqueness or
+ * column list), or null when the definitions agree. Expression/partial indexes
+ * in the DB never structurally match a plain column list, which is the
+ * intended outcome: the operator gets a warning rather than a silent skip.
+ */
+export function describeIndexDefMismatch(idx, indexdef) {
+    const dbUnique = /^\s*CREATE\s+UNIQUE\s+INDEX\b/i.test(indexdef);
+    const wantUnique = idx.unique === true;
+    if (dbUnique !== wantUnique) {
+        return wantUnique
+            ? 'declared UNIQUE, existing index is not unique'
+            : 'existing index is UNIQUE, declaration is not';
+    }
+    // pg_indexes.indexdef always reads `CREATE [UNIQUE] INDEX name ON tbl
+    // USING method (col, ...) [WHERE ...]`; anchor on the USING clause so a
+    // partial index's WHERE parentheses are never mistaken for the column list.
+    const parenMatch = indexdef.match(/USING\s+\w+\s*\(([^)]*)\)/i) ?? indexdef.match(/\(([^)]*)\)/);
+    const dbCols = parenMatch
+        ? parenMatch[1].split(',').map((c) => c
+            .trim()
+            .replace(/\s+(ASC|DESC|NULLS\s+(FIRST|LAST))\b/gi, '')
+            .replace(/^"(.*)"$/, '$1')
+            .trim())
+        : [];
+    const wantCols = idx.columns.map(camelToSnake);
+    if (dbCols.length !== wantCols.length || dbCols.some((c, i) => c !== wantCols[i])) {
+        return `declared columns (${wantCols.join(', ')}) differ from existing (${dbCols.join(', ') || 'unparsed'})`;
+    }
+    if (/\bWHERE\b/i.test(indexdef))
+        return 'existing index is partial (has a WHERE clause)';
+    return null;
+}
+/**
+ * Pure decision for the "index exists in the DB but is not declared" warning
+ * pass. Extracted so the scope rule is unit-testable without a live database.
+ *
+ * The pass runs only when the table opts into index management by DEFINING an
+ * `indexes` array (`indexesDefined: true`), even when that array is empty or
+ * all-doc-field: deleting the last declared index must NOT silence the pass.
+ * Tables with no `indexes` key stay silent (the user is not managing indexes
+ * there). Recognized names (declared, unique-constraint / FK-column, `*_pkey`)
+ * are never flagged; everything else in the DB yields one warning.
+ */
+export function undeclaredIndexWarnings(opts) {
+    if (!opts.indexesDefined)
+        return [];
+    const out = [];
+    for (const dbIdxName of opts.dbIndexNames) {
+        if (opts.declaredNames.has(dbIdxName) || opts.recognizedNames.has(dbIdxName) || dbIdxName.endsWith('_pkey')) {
+            continue;
+        }
+        out.push(`index "${dbIdxName}" on "${opts.tableName}" exists in the database but is not declared in the schema. ` +
+            `Turbine does not drop indexes automatically; drop it in a manual migration if it is no longer needed.`);
+    }
+    return out;
+}
+/** The deterministic SQL names of every declared plain index on a table. */
+function declaredPlainIndexNames(table) {
+    const names = new Set();
+    for (const idx of table.indexes ?? []) {
+        if (isDocFieldIndexDef(idx) || idx.columns.length === 0)
+            continue;
+        names.add(declaredIndexName(table.name, idx));
+    }
+    return names;
+}
+/**
+ * Build the `CREATE [UNIQUE] INDEX` statement for a declared plain index.
+ * `buildCreateIndexStatement` has no `unique` hook, so unique indexes are
+ * emitted directly here (still fully identifier-quoted via the dialect).
+ */
+function buildDeclaredIndexStatement(tableName, idx, dialect) {
+    const cols = idx.columns.map(camelToSnake);
+    if (cols.length === 0)
+        return null;
+    const name = declaredIndexName(tableName, idx);
+    const quotedCols = cols.map((c) => dialect.quoteIdentifier(c)).join(', ');
+    const unique = idx.unique ? 'UNIQUE ' : '';
+    return `CREATE ${unique}INDEX ${dialect.quoteIdentifier(name)} ON ${dialect.quoteIdentifier(tableName)}(${quotedCols});`;
+}
+/**
+ * Generate `CREATE INDEX` / `CREATE UNIQUE INDEX` for a table's user-declared
+ * plain-column indexes. PowDB doc-field expression indexes ({@link DocFieldIndexDef})
+ * are skipped here (those stay PowDB-only, emitted by `powqlSchemaDDL`) and have
+ * no SQL equivalent.
+ */
+function generateDeclaredIndexes(table, dialect = postgresDialect) {
+    const out = [];
+    for (const idx of table.indexes ?? []) {
+        if (isDocFieldIndexDef(idx))
+            continue; // PowDB-only, no SQL emission
+        const stmt = buildDeclaredIndexStatement(table.name, idx, dialect);
+        if (stmt)
+            out.push(stmt);
+    }
+    return out;
+}
 /**
  * Build the `ADD CONSTRAINT ... FOREIGN KEY` statement for a FK with the given
  * referential actions. Default (`no action`) clauses are omitted, matching how
@@ -532,6 +655,16 @@ export async function schemaDiff(schema, connectionString) {
                 dbChecks[row.table_name] = [];
             dbChecks[row.table_name].push({ name: row.conname, expression: stripCheckWrapper(row.definition) });
         }
+        // Existing index NAMES per table (for the declared-index diff). Covers PK,
+        // unique-constraint, FK, and user indexes alike; the diff only ADDs declared
+        // indexes whose name is missing and never auto-drops any (see below).
+        const indexResult = await client.query(`SELECT tablename, indexname, indexdef FROM pg_indexes WHERE schemaname = 'public'`);
+        const dbIndexes = {};
+        for (const row of indexResult.rows) {
+            if (!dbIndexes[row.tablename])
+                dbIndexes[row.tablename] = new Map();
+            dbIndexes[row.tablename].set(row.indexname, row.indexdef);
+        }
         // Build a set of DDL-facing snake_case table names that the schema defines.
         const schemaDdlNames = new Set();
         for (const def of Object.values(schema.tables))
@@ -564,6 +697,8 @@ export async function schemaDiff(schema, connectionString) {
                 result.statements.push(generateCreateTable(tableDef, resolveRef, dialect));
                 const fkIndexes = generateForeignKeyIndexes(tableDef, dialect);
                 result.statements.push(...fkIndexes);
+                // User-declared indexes on a brand-new table (reversed by the DROP TABLE).
+                result.statements.push(...generateDeclaredIndexes(tableDef, dialect));
                 // Reverse: DROP TABLE (with indexes — they drop automatically)
                 result.reverseStatements.unshift(`DROP TABLE IF EXISTS ${dialect.quoteIdentifier(ddlName)} CASCADE;`);
             }
@@ -747,6 +882,67 @@ export async function schemaDiff(schema, connectionString) {
                         `To intentionally replace it, rename the constraint or drop/re-add it in a manual migration.`);
                 }
             }
+            // --- User-declared indexes (TableDef.indexes) ---
+            // ADD any declared plain index whose NAME is missing from the DB (reverse:
+            // DROP INDEX). Doc-field indexes are PowDB-only and skipped. We never
+            // auto-drop DB indexes not in the schema, matching the column-drop posture.
+            // When the table declares at least one index (the user is actively managing
+            // indexes here), unrecognized extra DB indexes are surfaced as warnings so
+            // the operator can drop them by hand if intended. Recognized = PK, unique
+            // constraint, or FK-column index names, which the schema never declares.
+            // Run the whole index-management pass whenever the table DEFINES an
+            // `indexes` array (even empty or all-doc-field): a table with an `indexes`
+            // key is one the user is actively managing, so undeclared DB indexes stay
+            // worth surfacing. Deleting the last declared index must NOT silence the
+            // warning pass. Tables with no `indexes` key stay silent (not managed).
+            const declaredPlain = (tableDef.indexes ?? []).filter((i) => !isDocFieldIndexDef(i));
+            if (tableDef.indexes !== undefined) {
+                const dbIdx = dbIndexes[tableName] ?? new Map();
+                const dbIdxNames = new Set(dbIdx.keys());
+                const declaredNames = new Set();
+                for (const idx of declaredPlain) {
+                    if (idx.columns.length === 0)
+                        continue;
+                    const name = declaredIndexName(tableName, idx);
+                    declaredNames.add(name);
+                    const existingDef = dbIdx.get(name);
+                    if (existingDef === undefined) {
+                        const stmt = buildDeclaredIndexStatement(tableName, idx, dialect);
+                        if (!stmt)
+                            continue;
+                        result.statements.push(stmt);
+                        result.reverseStatements.unshift(`DROP INDEX IF EXISTS ${dialect.quoteIdentifier(name)};`);
+                    }
+                    else {
+                        // Name matches an existing index: verify the definition agrees.
+                        // Matching is by name, so a definition drift (a declared UNIQUE
+                        // index colliding with the plain auto FK index, or a changed
+                        // column list) would otherwise be silently skipped, leaving the
+                        // declared guarantee unenforced. Warn, never drop.
+                        const mismatch = describeIndexDefMismatch(idx, existingDef);
+                        if (mismatch) {
+                            result.warnings.push(`index "${name}" on "${tableName}": the declared definition does not match the existing ` +
+                                `database index (${mismatch}). Turbine matches indexes by name and never drops them ` +
+                                `automatically; drop and recreate it in a manual migration to apply the declared definition.`);
+                        }
+                    }
+                }
+                // Recognized (never-declared) index names: unique-constraint + FK-column.
+                const recognized = new Set(Object.values(dbUniques[tableName] ?? {}));
+                for (const [fieldName, config] of Object.entries(tableDef.columns)) {
+                    if (config.referencesTarget)
+                        recognized.add(`idx_${tableName}_${camelToSnake(fieldName)}`);
+                }
+                for (const w of undeclaredIndexWarnings({
+                    tableName,
+                    indexesDefined: tableDef.indexes !== undefined,
+                    dbIndexNames: dbIdxNames,
+                    declaredNames,
+                    recognizedNames: recognized,
+                })) {
+                    result.warnings.push(w);
+                }
+            }
         }
         return result;
     }
@@ -836,15 +1032,69 @@ function defaultsMatch(schemaDefault, dbDefault) {
     const b = normalizeDbDefault(dbDefault).toLowerCase().trim();
     return a === b;
 }
+// ---------------------------------------------------------------------------
+// Schema Push — execute the diff against a live database
+// ---------------------------------------------------------------------------
+/**
+ * Scan a set of diff statements for data-destroying operations, using the same
+ * conservative scanner (`scanDestructiveSql`) that gates `migrate up`/`down`.
+ * Push mostly emits additive DDL, but a type change surfaces as a lossy
+ * `ALTER COLUMN ... TYPE` cast, exactly the kind of silent data loss `push`
+ * must never apply without an explicit opt-in.
+ */
+export function findDestructivePushStatements(statements) {
+    const hits = [];
+    for (const stmt of statements)
+        hits.push(...scanDestructiveSql(stmt));
+    return hits;
+}
+/** Format the destructive-push refusal message (mirrors the migrate gate copy). */
+function formatDestructivePushError(hits) {
+    const lines = ['[turbine] Refusing to apply schema changes containing DESTRUCTIVE statements:', ''];
+    for (const h of hits) {
+        lines.push(`  - [${h.kind}] ${h.target}: ${DESTRUCTIVE_KIND_LABEL[h.kind]}`);
+    }
+    lines.push('');
+    lines.push('Review the statements above. To proceed: run `npx turbine push` interactively');
+    lines.push('and confirm, pass --allow-destructive, or set allowDestructive: true programmatically.');
+    return lines.join('\n');
+}
+/**
+ * Thrown by {@link schemaPush} when the diff contains data-destroying statements
+ * and `allowDestructive` was not set. A typed subclass of {@link ValidationError}
+ * (same `TURBINE_E003` code, no new taxonomy entry) so callers can branch on
+ * `instanceof DestructivePushRefusal` instead of sniffing the message text. The
+ * offending statements are carried on `.destructive` for programmatic display.
+ */
+export class DestructivePushRefusal extends ValidationError {
+    /** The destructive statements the push refused to apply. */
+    destructive;
+    constructor(destructive) {
+        super(formatDestructivePushError(destructive));
+        this.name = 'DestructivePushRefusal';
+        this.destructive = destructive;
+    }
+}
 /**
  * Push a schema definition to a live database.
  *
  * Computes the diff, then executes the resulting DDL statements in a
- * single transaction. This is a destructive operation for ADD/ALTER —
- * it will NOT drop tables or columns unless explicitly configured.
+ * single transaction. It will NOT drop tables or columns.
+ *
+ * Data-loss gate: if the diff contains a destructive statement (e.g. a lossy
+ * `ALTER COLUMN ... TYPE` cast), `schemaPush` throws a
+ * {@link DestructivePushRefusal} (a {@link ValidationError} subclass carrying
+ * the offending statements on `.destructive`) listing the statements UNLESS
+ * `allowDestructive: true` is passed. The CLI (`turbine push`) catches this and
+ * prompts for the same typed confirmation as `migrate up`; programmatic callers
+ * must opt in explicitly.
  */
 export async function schemaPush(schema, connectionString, options = {}) {
-    const diff = await schemaDiff(schema, connectionString);
+    // Accept a precomputed diff so a caller (the CLI) can diff ONCE, show the
+    // plan, confirm, and apply the EXACT statements it displayed. Without this,
+    // schemaPush would re-diff on the post-confirmation retry, so a concurrent
+    // schema change between confirm and apply could alter the applied set (TOCTOU).
+    const diff = options.precomputedDiff ?? (await schemaDiff(schema, connectionString));
     const result = {
         statementsExecuted: 0,
         statements: diff.statements,
@@ -854,6 +1104,13 @@ export async function schemaPush(schema, connectionString, options = {}) {
     if (options.dryRun || diff.statements.length === 0) {
         return result;
     }
+    // Destructive-statement gate: refuse silent data loss unless opted in.
+    if (!options.allowDestructive) {
+        const destructive = findDestructivePushStatements(diff.statements);
+        if (destructive.length > 0) {
+            throw new DestructivePushRefusal(destructive);
+        }
+    }
     // Execute all statements in a transaction
     const client = new pg.Client({ connectionString });
     await client.connect();

package/dist/schema.d.ts

@@ -110,6 +110,16 @@ export interface ColumnMetadata {
      * Present only when `isGeneratedStored` is true and the catalog exposed it.
      */
     generationExpression?: string;
+    /**
+     * True when this column holds personally identifiable information (PII).
+     * Tagged in `defineSchema` (`pii: true`) and carried through generated
+     * metadata. A PII column is EXCLUDED from default projections: it comes back
+     * only when explicitly named in `select` or when the query passes
+     * `includePii: true` (full opt-in). Studio redacts PII cells by default.
+     * Optional / defaults to `false`; untagged schemas behave exactly as before.
+     * Introspection never auto-tags PII (it is a code-first declaration).
+     */
+    pii?: boolean;
     /** Whether this is an array column */
     isArray: boolean;
     /** Dialect-specific array/bulk-insert type token when needed. */

package/dist/sqlite.js

@@ -372,6 +372,9 @@ export const sqliteDialect = {
     supportsAdvisoryLock: false,
     // No FROM-clause LATERAL: the opt-in lateral pick plan is Postgres-only.
     supportsLateralJoin: false,
+    // SQLite explains a compiled query with `EXPLAIN QUERY PLAN` (four columns:
+    // id, parent, notused, detail), overriding the inherited Postgres `EXPLAIN`.
+    explainQuery: { prefix: 'EXPLAIN QUERY PLAN' },
     // json_group_array / json_object have no inline ORDER BY argument, so every
     // ordered to-many relation is forced through the inner-subquery rewrite.
     aggSupportsInlineOrderBy: false,
@@ -423,7 +426,7 @@ export const sqliteDialect = {
         return JSON.stringify(values ?? []);
     },
     buildReturningClause(selection = '*') {
-        return ` RETURNING ${selection}`;
+        return ` RETURNING ${selection === '*' ? '*' : selection.join(', ')}`;
     },
     buildInsertStatement(input) {
         return (`INSERT INTO ${input.table} (${input.columns.join(', ')}) ` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "description": "Postgres-native TypeScript ORM — runs on Neon, Vercel Postgres, Cloudflare, Supabase. Streaming cursors, typed errors, single-query nested relations. One dependency, no WASM engine",
   "type": "module",
   "exports": {
@@ -74,7 +74,7 @@
     "lint": "biome check src/",
     "lint:fix": "biome check --write src/",
     "format": "biome format --write src/",
-    "prepublishOnly": "npm run build && npm run typecheck && npm run lint && npm run test:unit",
+    "prepublishOnly": "npm run build && npm run typecheck && npm run lint && npm run test:unit && npm run size",
     "prepack": "node scripts/strip-prepare.mjs",
     "postpack": "node scripts/restore-prepare.mjs",
     "size": "size-limit",
@@ -103,8 +103,8 @@
     "@size-limit/esbuild": "^12.1.0",
     "@size-limit/file": "^12.1.0",
     "@types/node": "^26.1.0",
-    "@zvndev/powdb-client": "^0.13.0",
-    "@zvndev/powdb-embedded": "^0.13.0",
+    "@zvndev/powdb-client": "^0.15.0",
+    "@zvndev/powdb-embedded": "^0.15.0",
     "c8": "^11.0.0",
     "husky": "^9.1.7",
     "lint-staged": "^17.0.8",