turbine-orm 0.11.0 → 0.13.0

package/dist/cli/migrate.js

@@ -16,27 +16,21 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from
 import { join } from 'node:path';
 import pg from 'pg';
 import { postgresql } from '../adapters/index.js';
+import { postgresDialect } from '../dialect.js';
 import { MigrationError } from '../errors.js';
-import { quoteIdent } from '../query/index.js';
 // ---------------------------------------------------------------------------
 // Tracking table management
 // ---------------------------------------------------------------------------
 const TRACKING_TABLE = '_turbine_migrations';
-const QUOTED_TRACKING_TABLE = quoteIdent(TRACKING_TABLE);
-const CREATE_TRACKING_TABLE = `
-  CREATE TABLE IF NOT EXISTS ${QUOTED_TRACKING_TABLE} (
-    id SERIAL PRIMARY KEY,
-    name TEXT NOT NULL UNIQUE,
-    checksum TEXT NOT NULL,
-    applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-  );
-`;
-async function ensureTrackingTable(client) {
-    await client.query(CREATE_TRACKING_TABLE);
+function quotedTrackingTable(dialect) {
+    return dialect.quoteIdentifier(TRACKING_TABLE);
+}
+async function ensureTrackingTable(client, dialect = postgresDialect) {
+    await client.query(dialect.buildMigrationTrackingTable(quotedTrackingTable(dialect)));
 }
-async function getAppliedMigrations(client) {
-    await ensureTrackingTable(client);
-    const result = await client.query(`SELECT id, name, applied_at, checksum FROM ${QUOTED_TRACKING_TABLE} ORDER BY id ASC`);
+async function getAppliedMigrations(client, dialect = postgresDialect) {
+    await ensureTrackingTable(client, dialect);
+    const result = await client.query(dialect.buildMigrationSelectApplied(quotedTrackingTable(dialect)));
     return result.rows;
 }
 // ---------------------------------------------------------------------------
@@ -248,8 +242,8 @@ async function releaseLock(client, lockId, adapter) {
  * Validate that applied migration files have not been modified or deleted since they were run.
  * Returns an array of mismatched migrations (empty if all are clean).
  */
-async function validateChecksums(client, migrationsDir) {
-    const applied = await getAppliedMigrations(client);
+async function validateChecksums(client, migrationsDir, dialect = postgresDialect) {
+    const applied = await getAppliedMigrations(client, dialect);
     const allFiles = listMigrationFiles(migrationsDir);
     const fileMap = new Map(allFiles.map((f) => [f.name, f]));
     const mismatches = [];
@@ -269,7 +263,7 @@ async function validateChecksums(client, migrationsDir) {
         if (currentHash !== migration.checksum) {
             // Auto-upgrade legacy djb2 checksums to SHA-256 without flagging as modified
             if (isLegacyChecksum(migration.checksum)) {
-                await client.query(`UPDATE ${QUOTED_TRACKING_TABLE} SET checksum = $1 WHERE name = $2`, [
+                await client.query(dialect.buildMigrationUpdateChecksum(quotedTrackingTable(dialect)), [
                     currentHash,
                     migration.name,
                 ]);
@@ -304,6 +298,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
     await client.connect();
     // Treat `force` as an alias for `allowDrift` for backwards compatibility.
     const allowDrift = options?.allowDrift === true || options?.force === true;
+    const dialect = options?.dialect ?? postgresDialect;
     try {
         // Derive an advisory lock ID per-database so concurrent migrations in
         // sibling databases on the same Postgres cluster do not contend.
@@ -317,7 +312,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
             throw new MigrationError('[turbine] Could not acquire migration lock — another migration is already running');
         }
         try {
-            await ensureTrackingTable(client);
+            await ensureTrackingTable(client, dialect);
             // Validate checksums of already-applied migrations.
             // Drift = an APPLIED migration's on-disk file has changed (or been deleted)
             // since it was run. Either situation means the database state and the
@@ -325,7 +320,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
             // Users can pass `allowDrift: true` (CLI: `--allow-drift`) to force past
             // the block when they are intentionally rewriting history.
             if (!allowDrift) {
-                const mismatches = await validateChecksums(client, migrationsDir);
+                const mismatches = await validateChecksums(client, migrationsDir, dialect);
                 if (mismatches.length > 0) {
                     const modified = mismatches.filter((m) => m.type === 'modified');
                     const missing = mismatches.filter((m) => m.type === 'missing');
@@ -349,7 +344,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
                     throw new MigrationError(lines.join('\n'));
                 }
             }
-            const applied = await getAppliedMigrations(client);
+            const applied = await getAppliedMigrations(client, dialect);
             const appliedNames = new Set(applied.map((m) => m.name));
             const allFiles = listMigrationFiles(migrationsDir);
             let pending = allFiles.filter((f) => !appliedNames.has(f.name));
@@ -369,7 +364,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
                 try {
                     await client.query('BEGIN');
                     await client.query(up);
-                    await client.query(`INSERT INTO ${QUOTED_TRACKING_TABLE} (name, checksum) VALUES ($1, $2) ON CONFLICT (name) DO NOTHING`, [file.name, hash]);
+                    await client.query(dialect.buildMigrationInsertApplied(quotedTrackingTable(dialect)), [file.name, hash]);
                     await client.query('COMMIT');
                     results.push(file);
                 }
@@ -402,6 +397,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
 export async function migrateDown(connectionString, migrationsDir, options) {
     const client = new pg.Client({ connectionString });
     await client.connect();
+    const dialect = options?.dialect ?? postgresDialect;
     try {
         // Derive a per-database advisory lock ID so concurrent migrations in
         // sibling databases on the same cluster do not contend.
@@ -413,8 +409,8 @@ export async function migrateDown(connectionString, migrationsDir, options) {
             throw new MigrationError('[turbine] Could not acquire migration lock — another migration is already running');
         }
         try {
-            await ensureTrackingTable(client);
-            const applied = await getAppliedMigrations(client);
+            await ensureTrackingTable(client, dialect);
+            const applied = await getAppliedMigrations(client, dialect);
             if (applied.length === 0) {
                 return { rolledBack: [], errors: [] };
             }
@@ -441,7 +437,7 @@ export async function migrateDown(connectionString, migrationsDir, options) {
                 try {
                     await client.query('BEGIN');
                     await client.query(down);
-                    await client.query(`DELETE FROM ${QUOTED_TRACKING_TABLE} WHERE name = $1`, [migration.name]);
+                    await client.query(dialect.buildMigrationDeleteApplied(quotedTrackingTable(dialect)), [migration.name]);
                     await client.query('COMMIT');
                     results.push(file);
                 }
@@ -466,12 +462,13 @@ export async function migrateDown(connectionString, migrationsDir, options) {
  * Get the status of all migrations (applied vs pending).
  * Includes checksum validation for applied migrations.
  */
-export async function migrateStatus(connectionString, migrationsDir) {
+export async function migrateStatus(connectionString, migrationsDir, options) {
     const client = new pg.Client({ connectionString });
     await client.connect();
+    const dialect = options?.dialect ?? postgresDialect;
     try {
-        await ensureTrackingTable(client);
-        const applied = await getAppliedMigrations(client);
+        await ensureTrackingTable(client, dialect);
+        const applied = await getAppliedMigrations(client, dialect);
         const appliedMap = new Map(applied.map((m) => [m.name, m]));
         const allFiles = listMigrationFiles(migrationsDir);
         return allFiles.map((file) => {

package/dist/dialect.d.ts

@@ -7,6 +7,85 @@
  */
 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 ColumnTypeInput {
+    /** Schema-builder column type name (PostgreSQL-native in the root package). */
+    type: string;
+    /** Optional VARCHAR length. */
+    maxLength?: number | null;
+}
+export interface ColumnDefinitionInput extends ColumnTypeInput {
+    /** SQL-ready quoted column name. */
+    name: string;
+    /** Whether this column is a single-column primary key. */
+    primaryKey?: boolean;
+    /** Whether this column is unique. Ignored when primaryKey is true. */
+    unique?: boolean;
+    /** Whether this column is NOT NULL. */
+    notNull?: boolean;
+    /** SQL-ready default expression. */
+    defaultValue?: string;
+    /** SQL-ready REFERENCES clause without the leading REFERENCES keyword. */
+    references?: {
+        table: string;
+        column: string;
+    };
+}
+export interface CreateTableStatementInput {
+    /** SQL-ready quoted table name. */
+    table: string;
+    /** SQL-ready column and table constraints. */
+    definitions: string[];
+}
+export interface CreateIndexStatementInput {
+    /** SQL-ready quoted index name. */
+    name: string;
+    /** SQL-ready quoted table name. */
+    table: string;
+    /** SQL-ready quoted index columns. */
+    columns: string[];
+}
 export interface Dialect {
     /** Dialect identifier. */
     readonly name: DialectName;
@@ -26,6 +105,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. */
@@ -42,6 +129,26 @@ export interface Dialect {
     typeToTypeScript(dialectType: string, nullable: boolean): string;
     /** Optional array-cast hook for bulk insert implementations. */
     arrayType?(baseType: string): string;
+    /** Map a schema-builder column type to dialect DDL. */
+    buildColumnType(input: ColumnTypeInput): string;
+    /** Build a column definition line for CREATE/ALTER TABLE. */
+    buildColumnDefinition(input: ColumnDefinitionInput): string;
+    /** Build a table-level PRIMARY KEY constraint. */
+    buildPrimaryKeyConstraint(columns: string[]): string;
+    /** Build a CREATE TABLE statement from SQL-ready definitions. */
+    buildCreateTableStatement(input: CreateTableStatementInput): string;
+    /** Build a CREATE INDEX statement. */
+    buildCreateIndexStatement(input: CreateIndexStatementInput): string;
+    /** Build the migration tracking table DDL. */
+    buildMigrationTrackingTable(table: string): string;
+    /** Build the query that reads applied migrations. */
+    buildMigrationSelectApplied(table: string): string;
+    /** Build the query that updates an applied migration checksum. */
+    buildMigrationUpdateChecksum(table: string): string;
+    /** Build the query that records an applied migration. */
+    buildMigrationInsertApplied(table: string): string;
+    /** Build the query that deletes a rolled-back migration record. */
+    buildMigrationDeleteApplied(table: string): string;
 }
 export interface DialectIntrospector {
     introspect(options: IntrospectOptions): Promise<SchemaMetadata>;

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}`;
     },
@@ -51,5 +73,57 @@ export const postgresDialect = {
         // This hook is the package boundary MySQL/SQLite implementations will fill.
         return 'unknown';
     },
+    buildColumnType(input) {
+        if (input.type === 'VARCHAR' && input.maxLength != null) {
+            return `VARCHAR(${input.maxLength})`;
+        }
+        return input.type;
+    },
+    buildColumnDefinition(input) {
+        const parts = [input.name, this.buildColumnType(input)];
+        if (input.primaryKey)
+            parts.push('PRIMARY KEY');
+        if (input.unique && !input.primaryKey)
+            parts.push('UNIQUE');
+        if (input.notNull)
+            parts.push('NOT NULL');
+        if (input.defaultValue != null)
+            parts.push(`DEFAULT ${input.defaultValue}`);
+        if (input.references)
+            parts.push(`REFERENCES ${input.references.table}(${input.references.column})`);
+        return parts.join(' ');
+    },
+    buildPrimaryKeyConstraint(columns) {
+        return `PRIMARY KEY (${columns.join(', ')})`;
+    },
+    buildCreateTableStatement(input) {
+        const body = input.definitions.map((d) => `    ${d}`).join(',\n');
+        return `CREATE TABLE ${input.table} (\n${body}\n);`;
+    },
+    buildCreateIndexStatement(input) {
+        return `CREATE INDEX ${input.name} ON ${input.table}(${input.columns.join(', ')});`;
+    },
+    buildMigrationTrackingTable(table) {
+        return `
+  CREATE TABLE IF NOT EXISTS ${table} (
+    id SERIAL PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    checksum TEXT NOT NULL,
+    applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+`;
+    },
+    buildMigrationSelectApplied(table) {
+        return `SELECT id, name, applied_at, checksum FROM ${table} ORDER BY id ASC`;
+    },
+    buildMigrationUpdateChecksum(table) {
+        return `UPDATE ${table} SET checksum = ${this.paramPlaceholder(1)} WHERE name = ${this.paramPlaceholder(2)}`;
+    },
+    buildMigrationInsertApplied(table) {
+        return `INSERT INTO ${table} (name, checksum) VALUES (${this.paramPlaceholder(1)}, ${this.paramPlaceholder(2)}) ON CONFLICT (name) DO NOTHING`;
+    },
+    buildMigrationDeleteApplied(table) {
+        return `DELETE FROM ${table} WHERE name = ${this.paramPlaceholder(1)}`;
+    },
 };
 //# sourceMappingURL=dialect.js.map

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, ColumnDefinitionInput, ColumnTypeInput, CreateIndexStatementInput, CreateTableStatementInput, 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';
@@ -45,6 +45,6 @@ export { type AggregateArgs, type AggregateResult, type ArrayFilter, type CountA
 export type { ColumnMetadata, IndexMetadata, RelationDef, SchemaMetadata, TableMetadata, } from './schema.js';
 export { camelToSnake, isDateType, normalizeKeyColumns, pgArrayType, pgTypeToTs, singularize, snakeToCamel, snakeToPascal, } from './schema.js';
 export { ColumnBuilder, type ColumnConfig, type ColumnDef, type ColumnType, type ColumnTypeName, column, defineSchema, type SchemaDef, type TableDef, table, } from './schema-builder.js';
-export { type AlterColumnDef, type AlterDef, type DiffResult, type PushResult, schemaDiff, schemaPush, schemaToSQL, schemaToSQLString, } from './schema-sql.js';
+export { type AlterColumnDef, type AlterDef, type DiffResult, type PushResult, type SchemaSqlOptions, schemaDiff, schemaPush, schemaToSQL, schemaToSQLString, } from './schema-sql.js';
 export { type TurbineHttpOptions, turbineHttp } from './serverless.js';
 //# sourceMappingURL=index.d.ts.map

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, ColumnDefinitionInput, ColumnTypeInput, CreateIndexStatementInput, CreateTableStatementInput, 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/dist/schema-sql.d.ts

@@ -4,14 +4,19 @@
  * Converts a SchemaDef (from defineSchema) into executable DDL statements.
  * Also provides diff and push commands for syncing schema to a live database.
  */
+import { type Dialect } from './dialect.js';
 import type { SchemaDef, TableDef } from './schema-builder.js';
+export interface SchemaSqlOptions {
+    /** SQL dialect used for DDL generation. Defaults to PostgreSQL. */
+    dialect?: Dialect;
+}
 /**
  * Convert a SchemaDef into an ordered array of SQL DDL statements.
  *
  * Returns CREATE TABLE statements (in dependency order based on references)
  * followed by CREATE INDEX statements for foreign key columns.
  */
-export declare function schemaToSQL(schema: SchemaDef): string[];
+export declare function schemaToSQL(schema: SchemaDef, options?: SchemaSqlOptions): string[];
 export interface AlterColumnDef {
     /** Column name in snake_case */
     column: string;
@@ -71,5 +76,5 @@ export declare function schemaPush(schema: SchemaDef, connectionString: string,
  * Generate the full DDL as a single formatted string.
  * Useful for printing or saving to a .sql file.
  */
-export declare function schemaToSQLString(schema: SchemaDef): string;
+export declare function schemaToSQLString(schema: SchemaDef, options?: SchemaSqlOptions): string;
 //# sourceMappingURL=schema-sql.d.ts.map