turbine-orm 0.11.0 → 0.12.0

package/dist/cjs/dialect.js

@@ -33,6 +33,28 @@ exports.postgresDialect = {
         const suffix = orderBy ? ` ${orderBy}` : '';
         return `COALESCE(json_agg(${jsonObjectExpr}${suffix}), ${this.emptyJsonArrayLiteral})`;
     },
+    buildReturningClause(selection = '*') {
+        return ` RETURNING ${selection}`;
+    },
+    buildInsertStatement(input) {
+        return `INSERT INTO ${input.table} (${input.columns.join(', ')}) VALUES (${input.valuePlaceholders.join(', ')})${this.buildReturningClause(input.returning)}`;
+    },
+    buildBulkInsertStatement(input) {
+        if (!input.columnArrayTypes || input.columnArrayTypes.length !== input.columns.length) {
+            throw new Error('PostgreSQL bulk insert requires one array type per column');
+        }
+        const columnArrays = input.columns.map((_, columnIndex) => input.rowValues.map((row) => row[columnIndex]));
+        const unnestArgs = input.columns.map((_, i) => `${this.paramPlaceholder(i + 1)}::${input.columnArrayTypes[i]}`);
+        let sql = `INSERT INTO ${input.table} (${input.columns.join(', ')}) SELECT * FROM UNNEST(${unnestArgs.join(', ')})`;
+        if (input.skipDuplicates)
+            sql += ' ON CONFLICT DO NOTHING';
+        return { sql: `${sql}${this.buildReturningClause(input.returning)}`, params: columnArrays };
+    },
+    buildUpsertStatement(input) {
+        return (`INSERT INTO ${input.table} (${input.insertColumns.join(', ')}) VALUES (${input.valuePlaceholders.join(', ')})` +
+            ` ON CONFLICT (${input.conflictColumns.join(', ')}) DO UPDATE SET ${input.updateSetClauses.join(', ')}` +
+            this.buildReturningClause(input.returning));
+    },
     buildInsensitiveLike(column, paramRef) {
         return `${column} ILIKE ${paramRef}`;
     },

package/dist/cjs/query/builder.js

@@ -736,7 +736,12 @@ class QueryInterface {
         const columns = entries.map(([k]) => this.toSqlColumn(k));
         const params = entries.map(([, v]) => v);
         const placeholders = entries.map((_, i) => `${this.p(i + 1)}`);
-        const sql = `INSERT INTO ${this.q(this.table)} (${columns.join(', ')}) VALUES (${placeholders.join(', ')}) RETURNING *`;
+        const sql = this.dialect.buildInsertStatement({
+            table: this.q(this.table),
+            columns,
+            valuePlaceholders: placeholders,
+            returning: '*',
+        });
         return {
             sql,
             params,
@@ -776,27 +781,24 @@ class QueryInterface {
         }
         const keys = Object.keys(args.data[0]).filter((k) => args.data[0][k] !== undefined);
         const columns = keys.map((k) => this.toColumn(k));
-        // Build column arrays for UNNEST
-        const columnArrays = keys.map(() => []);
-        for (const row of args.data) {
+        const rowValues = args.data.map((row) => {
             const record = row;
-            keys.forEach((key, i) => {
-                columnArrays[i].push(record[key]);
-            });
-        }
-        // Use actual Postgres types for array casts
+            return keys.map((key) => record[key]);
+        });
+        // Use actual Postgres types for array casts in the default PostgreSQL dialect.
         const typeCasts = columns.map((col) => this.getColumnArrayType(col));
-        const unnestArgs = columnArrays.map((_, i) => `${this.p(i + 1)}::${typeCasts[i]}`);
         const quotedColumns = columns.map((c) => this.q(c));
-        let sql = `INSERT INTO ${qt} (${quotedColumns.join(', ')}) SELECT * FROM UNNEST(${unnestArgs.join(', ')})`;
-        // skipDuplicates: add ON CONFLICT DO NOTHING
-        if (args.skipDuplicates) {
-            sql += ` ON CONFLICT DO NOTHING`;
-        }
-        sql += ` RETURNING *`;
+        const built = this.dialect.buildBulkInsertStatement({
+            table: qt,
+            columns: quotedColumns,
+            rowValues,
+            columnArrayTypes: typeCasts,
+            skipDuplicates: args.skipDuplicates,
+            returning: '*',
+        });
         return {
-            sql,
-            params: columnArrays,
+            sql: built.sql,
+            params: built.params,
             transform: (result) => result.rows.map((row) => this.parseRow(row, this.table)),
             tag: `${this.table}.createMany`,
         };
@@ -825,7 +827,7 @@ class QueryInterface {
             const whereClause = this.buildWhereClause(whereObj, freshParams);
             const whereSql = whereClause ? ` WHERE ${whereClause}` : '';
             this.assertMutationHasPredicate('update', whereSql, args.allowFullTableScan);
-            return `UPDATE ${this.q(this.table)} SET ${setClauses.join(', ')}${whereSql} RETURNING *`;
+            return `UPDATE ${this.q(this.table)} SET ${setClauses.join(', ')}${whereSql}${this.dialect.buildReturningClause('*')}`;
         });
         // On cache hit, validate predicate
         if (whereFp === '') {
@@ -874,7 +876,7 @@ class QueryInterface {
             const clause = this.buildWhereClause(whereObj, freshParams);
             const whereSql = clause ? ` WHERE ${clause}` : '';
             this.assertMutationHasPredicate('delete', whereSql, args.allowFullTableScan);
-            return `DELETE FROM ${this.q(this.table)}${whereSql} RETURNING *`;
+            return `DELETE FROM ${this.q(this.table)}${whereSql}${this.dialect.buildReturningClause('*')}`;
         });
         // On cache hit, still validate the predicate
         if (whereFp === '') {
@@ -928,9 +930,14 @@ class QueryInterface {
         });
         const updateParams = updateEntries.map(([, v]) => v);
         const params = [...createParams, ...updateParams];
-        const sql = `INSERT INTO ${this.q(this.table)} (${columns.join(', ')}) VALUES (${placeholders.join(', ')})` +
-            ` ON CONFLICT (${conflictColumns.join(', ')}) DO UPDATE SET ${setClauses.join(', ')}` +
-            ` RETURNING *`;
+        const sql = this.dialect.buildUpsertStatement({
+            table: this.q(this.table),
+            insertColumns: columns,
+            valuePlaceholders: placeholders,
+            conflictColumns,
+            updateSetClauses: setClauses,
+            returning: '*',
+        });
         return {
             sql,
             params,

package/dist/dialect.d.ts

@@ -7,6 +7,48 @@
  */
 import type { SchemaMetadata } from './schema.js';
 export type DialectName = 'postgresql' | 'mysql' | 'sqlite' | (string & {});
+export interface InsertStatementInput {
+    /** SQL-ready quoted table name. */
+    table: string;
+    /** SQL-ready quoted insert columns. */
+    columns: string[];
+    /** SQL-ready parameter placeholders/expressions for VALUES. */
+    valuePlaceholders: string[];
+    /** Optional SQL-ready RETURNING selection. */
+    returning?: string;
+}
+export interface BulkInsertStatementInput {
+    /** SQL-ready quoted table name. */
+    table: string;
+    /** SQL-ready quoted insert columns. */
+    columns: string[];
+    /** Row-major values, one inner array per inserted row. */
+    rowValues: unknown[][];
+    /** Optional SQL-ready array casts for dialects that batch by column arrays (PostgreSQL UNNEST). */
+    columnArrayTypes?: string[];
+    /** Skip duplicate rows when supported by the dialect. */
+    skipDuplicates?: boolean;
+    /** Optional SQL-ready RETURNING selection. */
+    returning?: string;
+}
+export interface BuiltStatement {
+    sql: string;
+    params: unknown[];
+}
+export interface UpsertStatementInput {
+    /** SQL-ready quoted table name. */
+    table: string;
+    /** SQL-ready quoted insert columns. */
+    insertColumns: string[];
+    /** SQL-ready parameter placeholders/expressions for VALUES. */
+    valuePlaceholders: string[];
+    /** SQL-ready quoted conflict/unique columns. */
+    conflictColumns: string[];
+    /** SQL-ready update SET clauses. */
+    updateSetClauses: string[];
+    /** Optional SQL-ready RETURNING selection. */
+    returning?: string;
+}
 export interface Dialect {
     /** Dialect identifier. */
     readonly name: DialectName;
@@ -26,6 +68,14 @@ export interface Dialect {
     buildJsonArrayAgg(jsonObjectExpr: string, orderBy?: string): string;
     /** Whether INSERT/UPDATE/DELETE support RETURNING rows. */
     readonly supportsReturning: boolean;
+    /** Build a dialect-specific RETURNING clause. Return an empty string when unsupported. */
+    buildReturningClause(selection?: string): string;
+    /** Build a single-row INSERT statement. Inputs are SQL-ready quoted fragments. */
+    buildInsertStatement(input: InsertStatementInput): string;
+    /** Build a multi-row bulk INSERT statement and its dialect-shaped params. */
+    buildBulkInsertStatement(input: BulkInsertStatementInput): BuiltStatement;
+    /** Build an upsert statement. Inputs are SQL-ready quoted fragments. */
+    buildUpsertStatement(input: UpsertStatementInput): string;
     /** Whether native ILIKE is supported. */
     readonly supportsILike: boolean;
     /** Build a case-insensitive LIKE equivalent. */

package/dist/dialect.js

@@ -30,6 +30,28 @@ export const postgresDialect = {
         const suffix = orderBy ? ` ${orderBy}` : '';
         return `COALESCE(json_agg(${jsonObjectExpr}${suffix}), ${this.emptyJsonArrayLiteral})`;
     },
+    buildReturningClause(selection = '*') {
+        return ` RETURNING ${selection}`;
+    },
+    buildInsertStatement(input) {
+        return `INSERT INTO ${input.table} (${input.columns.join(', ')}) VALUES (${input.valuePlaceholders.join(', ')})${this.buildReturningClause(input.returning)}`;
+    },
+    buildBulkInsertStatement(input) {
+        if (!input.columnArrayTypes || input.columnArrayTypes.length !== input.columns.length) {
+            throw new Error('PostgreSQL bulk insert requires one array type per column');
+        }
+        const columnArrays = input.columns.map((_, columnIndex) => input.rowValues.map((row) => row[columnIndex]));
+        const unnestArgs = input.columns.map((_, i) => `${this.paramPlaceholder(i + 1)}::${input.columnArrayTypes[i]}`);
+        let sql = `INSERT INTO ${input.table} (${input.columns.join(', ')}) SELECT * FROM UNNEST(${unnestArgs.join(', ')})`;
+        if (input.skipDuplicates)
+            sql += ' ON CONFLICT DO NOTHING';
+        return { sql: `${sql}${this.buildReturningClause(input.returning)}`, params: columnArrays };
+    },
+    buildUpsertStatement(input) {
+        return (`INSERT INTO ${input.table} (${input.insertColumns.join(', ')}) VALUES (${input.valuePlaceholders.join(', ')})` +
+            ` ON CONFLICT (${input.conflictColumns.join(', ')}) DO UPDATE SET ${input.updateSetClauses.join(', ')}` +
+            this.buildReturningClause(input.returning));
+    },
     buildInsensitiveLike(column, paramRef) {
         return `${column} ILIKE ${paramRef}`;
     },

package/dist/index.d.ts

@@ -35,7 +35,7 @@
 export type { DatabaseAdapter, IntrospectionOverrides } from './adapters/index.js';
 export { alloydb, cockroachdb, postgresql, timescale, yugabytedb } from './adapters/index.js';
 export { type Middleware, type MiddlewareNext, type MiddlewareParams, type PgCompatPool, type PgCompatPoolClient, type PgCompatQueryResult, TransactionClient, type TransactionOptions, TurbineClient, type TurbineConfig, } from './client.js';
-export type { Dialect, DialectIntrospector, DialectMigrator, DialectName, IntrospectOptions as DialectIntrospectOptions, } from './dialect.js';
+export type { BuiltStatement, BulkInsertStatementInput, Dialect, DialectIntrospector, DialectMigrator, DialectName, InsertStatementInput, IntrospectOptions as DialectIntrospectOptions, UpsertStatementInput, } from './dialect.js';
 export { postgresDialect } from './dialect.js';
 export { CheckConstraintError, CircularRelationError, ConnectionError, DeadlockError, type ErrorMessageMode, ForeignKeyError, getErrorMessageMode, MigrationError, NotFoundError, NotNullViolationError, PipelineError, type PipelineResultSlot, RelationError, SerializationFailureError, setErrorMessageMode, TimeoutError, TurbineError, TurbineErrorCode, UniqueConstraintError, ValidationError, wrapPgError, } from './errors.js';
 export { type GenerateOptions, generate } from './generate.js';

package/dist/query/builder.js

@@ -733,7 +733,12 @@ export class QueryInterface {
         const columns = entries.map(([k]) => this.toSqlColumn(k));
         const params = entries.map(([, v]) => v);
         const placeholders = entries.map((_, i) => `${this.p(i + 1)}`);
-        const sql = `INSERT INTO ${this.q(this.table)} (${columns.join(', ')}) VALUES (${placeholders.join(', ')}) RETURNING *`;
+        const sql = this.dialect.buildInsertStatement({
+            table: this.q(this.table),
+            columns,
+            valuePlaceholders: placeholders,
+            returning: '*',
+        });
         return {
             sql,
             params,
@@ -773,27 +778,24 @@ export class QueryInterface {
         }
         const keys = Object.keys(args.data[0]).filter((k) => args.data[0][k] !== undefined);
         const columns = keys.map((k) => this.toColumn(k));
-        // Build column arrays for UNNEST
-        const columnArrays = keys.map(() => []);
-        for (const row of args.data) {
+        const rowValues = args.data.map((row) => {
             const record = row;
-            keys.forEach((key, i) => {
-                columnArrays[i].push(record[key]);
-            });
-        }
-        // Use actual Postgres types for array casts
+            return keys.map((key) => record[key]);
+        });
+        // Use actual Postgres types for array casts in the default PostgreSQL dialect.
         const typeCasts = columns.map((col) => this.getColumnArrayType(col));
-        const unnestArgs = columnArrays.map((_, i) => `${this.p(i + 1)}::${typeCasts[i]}`);
         const quotedColumns = columns.map((c) => this.q(c));
-        let sql = `INSERT INTO ${qt} (${quotedColumns.join(', ')}) SELECT * FROM UNNEST(${unnestArgs.join(', ')})`;
-        // skipDuplicates: add ON CONFLICT DO NOTHING
-        if (args.skipDuplicates) {
-            sql += ` ON CONFLICT DO NOTHING`;
-        }
-        sql += ` RETURNING *`;
+        const built = this.dialect.buildBulkInsertStatement({
+            table: qt,
+            columns: quotedColumns,
+            rowValues,
+            columnArrayTypes: typeCasts,
+            skipDuplicates: args.skipDuplicates,
+            returning: '*',
+        });
         return {
-            sql,
-            params: columnArrays,
+            sql: built.sql,
+            params: built.params,
             transform: (result) => result.rows.map((row) => this.parseRow(row, this.table)),
             tag: `${this.table}.createMany`,
         };
@@ -822,7 +824,7 @@ export class QueryInterface {
             const whereClause = this.buildWhereClause(whereObj, freshParams);
             const whereSql = whereClause ? ` WHERE ${whereClause}` : '';
             this.assertMutationHasPredicate('update', whereSql, args.allowFullTableScan);
-            return `UPDATE ${this.q(this.table)} SET ${setClauses.join(', ')}${whereSql} RETURNING *`;
+            return `UPDATE ${this.q(this.table)} SET ${setClauses.join(', ')}${whereSql}${this.dialect.buildReturningClause('*')}`;
         });
         // On cache hit, validate predicate
         if (whereFp === '') {
@@ -871,7 +873,7 @@ export class QueryInterface {
             const clause = this.buildWhereClause(whereObj, freshParams);
             const whereSql = clause ? ` WHERE ${clause}` : '';
             this.assertMutationHasPredicate('delete', whereSql, args.allowFullTableScan);
-            return `DELETE FROM ${this.q(this.table)}${whereSql} RETURNING *`;
+            return `DELETE FROM ${this.q(this.table)}${whereSql}${this.dialect.buildReturningClause('*')}`;
         });
         // On cache hit, still validate the predicate
         if (whereFp === '') {
@@ -925,9 +927,14 @@ export class QueryInterface {
         });
         const updateParams = updateEntries.map(([, v]) => v);
         const params = [...createParams, ...updateParams];
-        const sql = `INSERT INTO ${this.q(this.table)} (${columns.join(', ')}) VALUES (${placeholders.join(', ')})` +
-            ` ON CONFLICT (${conflictColumns.join(', ')}) DO UPDATE SET ${setClauses.join(', ')}` +
-            ` RETURNING *`;
+        const sql = this.dialect.buildUpsertStatement({
+            table: this.q(this.table),
+            insertColumns: columns,
+            valuePlaceholders: placeholders,
+            conflictColumns,
+            updateSetClauses: setClauses,
+            returning: '*',
+        });
         return {
             sql,
             params,

package/dist/query/index.d.ts

@@ -6,7 +6,7 @@
  * former monolithic `import { … } from './query.js'`.
  */
 export type { AggregateArgs, AggregateResult, ArrayFilter, CountArgs, CreateArgs, CreateManyArgs, DeleteArgs, DeleteManyArgs, FindManyArgs, FindManyStreamArgs, FindUniqueArgs, GroupByArgs, JsonFilter, OrderDirection, RelationDescriptor, RelationFilter, TypedWithClause, UpdateArgs, UpdateInput, UpdateManyArgs, UpdateOperatorInput, UpsertArgs, WhereClause, WhereOperator, WhereValue, WithClause, WithOptions, WithResult, } from './types.js';
-export type { Dialect } from '../dialect.js';
+export type { BuiltStatement, BulkInsertStatementInput, Dialect, InsertStatementInput, UpsertStatementInput, } from '../dialect.js';
 export { postgresDialect } from '../dialect.js';
 export type { SqlCacheEntry } from './utils.js';
 export { buildCorrelation, escapeLike, escSingleQuote, fnv1a64Hex, LRUCache, OPERATOR_KEYS, quoteIdent, sqlToPreparedName, } from './utils.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Postgres-native TypeScript ORM — runs on Neon, Vercel Postgres, Cloudflare, Supabase. Streaming cursors, typed errors, single-query nested relations. 1 dependency, ~110KB",
   "type": "module",
   "exports": {