turbine-orm 0.51.0 → 0.52.0

package/dist/client.d.ts

@@ -180,7 +180,19 @@ export interface TurbineConfig {
      * owns the pool) and when coercing nested-relation JSON dates. This is the
      * Prisma/Rails/Django convention and makes results independent of the
      * server's local time zone. Default: `true`. Set `false` for the legacy
-     * local-time interpretation.
+     * local-time interpretation, which also turns off the matching WRITE-side
+     * rewrite (a bound `Date` on a zone-less `date` / `timestamp` column is then
+     * serialized by the driver in the process's zone).
+     *
+     * PER PROCESS, NOT PER CLIENT. The read half is a pg type parser, and
+     * `pg.types.setTypeParser` installs one parser per OID for the whole
+     * process. The first Turbine-owned client settles it for every later one, so
+     * constructing a second client with the OPPOSITE value throws a
+     * `ValidationError` rather than handing back a client whose writes and reads
+     * disagree. Give every client in the process the same value, or isolate the
+     * odd one in its own process. Clients on an EXTERNAL pool never register a
+     * parser and never take part in the check: they inherit whatever parser
+     * configuration the caller's driver has.
      */
     utcTimestamps?: boolean;
     /**
@@ -297,6 +309,23 @@ export interface TurbineConfig {
      * programmatic access regardless of mode.
      */
     errorMessages?: ErrorMessageMode;
+    /**
+     * Whether `$on('query')` listeners receive the real bound parameter values.
+     *
+     * Off by default: every entry of `event.params` is replaced with
+     * `'[REDACTED]'` before any listener sees it, so query logs cannot carry
+     * user data into a log sink.
+     *
+     * This is an alias with a discoverable name, NOT a second switch. The
+     * redaction has always been governed by {@link errorMessages}, which nobody
+     * looks under when they want to see query params. Resolution order, single
+     * source of truth: when `logQueryParams` is set it decides; otherwise
+     * `errorMessages: 'verbose'` reveals params exactly as it did before. So
+     * `logQueryParams: true` with `errorMessages: 'safe'` shows params in query
+     * events while keeping error MESSAGES redacted, which is the combination
+     * that was previously unreachable.
+     */
+    logQueryParams?: boolean;
     /**
      * Enable prepared statements. Queries are submitted with `{ name, text, values }`
      * to the pg driver, which caches the parse+plan on the server per connection.
@@ -470,6 +499,34 @@ export declare class TransactionClient {
      * Execute a raw SQL query within this transaction.
      */
     raw<T extends Record<string, unknown> = Record<string, unknown>>(strings: TemplateStringsArray, ...values: unknown[]): Promise<T[]>;
+    /**
+     * @internal The `turbine-orm/prisma-compat` adapter's transaction seam. NOT
+     * application API: use {@link raw}, whose tagged template makes concatenating
+     * a value into the SQL text impossible. This method takes the SQL text as a
+     * plain string, so the escaping discipline moves to the caller, which is
+     * exactly the property the typed-SQL escape hatch exists to remove. It is
+     * documented and kept structurally stable only because the compat adapter
+     * detects it by shape (`typeof tx.rawQuery === 'function'`) and refuses to
+     * run compat raw SQL on a pool connection when it is missing.
+     *
+     * Execute an already-parameterized statement on THIS transaction's own
+     * connection, returning the driver's `{ rows, rowCount }` pair. It differs
+     * from {@link raw} in two ways the adapter needs: it takes a prebuilt
+     * `(text, params)` pair rather than a tagged template (the placeholder
+     * numbering is the caller's, so nested `Prisma.sql` fragments can be
+     * flattened first), and it surfaces `rowCount` so an `$executeRaw`-style call
+     * can report affected rows.
+     *
+     * The statement runs on the transaction's dedicated connection, so it is
+     * inside the same BEGIN/COMMIT (and any active SAVEPOINT) as every other
+     * statement in the callback. Driver errors are translated by `wrapPgError`,
+     * exactly as pool-scoped and table-scoped queries are. Like {@link raw}, it
+     * emits no `$on('query')` event and runs no middleware.
+     */
+    rawQuery<T extends object = Record<string, unknown>>(text: string, params?: readonly unknown[]): Promise<{
+        rows: T[];
+        rowCount: number | null;
+    }>;
     /**
      * Create a pool-like wrapper around the transaction client.
      * This allows QueryInterface to work with the transaction connection
@@ -487,7 +544,19 @@ export declare class TurbineClient {
     /** The schema metadata this client was built from */
     readonly schema: SchemaMetadata;
     private static int8ParserRegistered;
-    private static utcTimestampParserRegistered;
+    /**
+     * The `utcTimestamps` value the FIRST Turbine-owned pool in this process
+     * settled the OID 1114 read parser on, or `undefined` while no Turbine-owned
+     * client has been constructed yet.
+     *
+     * `pg.types.setTypeParser` is process-global by nature: there is one parser
+     * per OID for the whole pg module, so the READ side of `utcTimestamps` cannot
+     * be per client the way the WRITE side is. Recording the settled value (not
+     * just "registered yes/no") is what lets the constructor detect a second
+     * client asking for the opposite and refuse it, instead of handing back a
+     * client whose reads and writes disagree. See {@link assertUtcTimestampsAgree}.
+     */
+    private static utcTimestampParserMode;
     private readonly logging;
     /** Active SQL dialect, owns transaction keywords, set_config, raw-SQL placeholders, capability flags. */
     private readonly dialect;
@@ -496,6 +565,8 @@ export declare class TurbineClient {
     private readonly queryListeners;
     private queryOptions;
     private readonly errorMessagesSafe;
+    /** Whether `$on('query')` events carry real params (see `logQueryParams`). */
+    private readonly queryParamsVisible;
     /** True when Turbine created the pool and is responsible for tearing it down */
     private readonly ownsPool;
     /** Active LISTEN subscriptions, torn down on disconnect() so it never hangs */
@@ -520,6 +591,39 @@ export declare class TurbineClient {
     /** Lazily-built, cached primary-only view returned by {@link $primary}. */
     private primaryView?;
     constructor(config: TurbineConfig | undefined, schema: SchemaMetadata);
+    /**
+     * Refuse a `utcTimestamps` value that contradicts the one the process-global
+     * OID 1114 read parser was already settled on.
+     *
+     * The flag has two halves. The WRITE half is per client: a bound `Date` on a
+     * zone-less `date` / `timestamp` column is rewritten to a UTC literal unless
+     * the owning client opted out (`coerceWriteValue` in query/writes.ts). The
+     * READ half is the pg type parser for OID 1114, and `pg.types.setTypeParser`
+     * installs ONE parser per OID for the whole process, shared by every pool,
+     * every raw query, and any other library using the same pg module. There is
+     * no per-pool parser hook to bind it to, and moving the coercion into
+     * `parseRow` instead would leave every non-ORM read (raw SQL, `client.sql`,
+     * a caller's own `pool.query`) on the driver's value while changing the
+     * default path's output type, so the read half stays process-wide.
+     *
+     * That makes the mixed shape unserveable rather than merely awkward: the
+     * second client would write local calendar fields and read them back as UTC
+     * (or the reverse), so its own round trip is off by the process offset.
+     * A client that silently does not round-trip is the worst of the three
+     * outcomes, so construction fails with the two ways out.
+     *
+     * Only Turbine-owned pools take part. An external pool (Neon, Vercel
+     * Postgres, Hyperdrive) inherits the caller's parser configuration and
+     * Turbine never registers on its behalf, so it has no read half to contradict.
+     */
+    private static assertUtcTimestampsAgree;
+    /**
+     * @internal Test-only: forget the process-global `utcTimestamps` decision so
+     * one process can exercise both mismatch directions. It does NOT restore the
+     * pg parser (parser registration is not reversible), so reads stay on
+     * whichever parser was installed first.
+     */
+    static resetUtcTimestampsForTests(): void;
     /**
      * Register a middleware function that runs around every query.
      *

package/dist/client.js

@@ -191,6 +191,39 @@ export class TransactionClient {
             throw wrapPgError(err);
         }
     }
+    /**
+     * @internal The `turbine-orm/prisma-compat` adapter's transaction seam. NOT
+     * application API: use {@link raw}, whose tagged template makes concatenating
+     * a value into the SQL text impossible. This method takes the SQL text as a
+     * plain string, so the escaping discipline moves to the caller, which is
+     * exactly the property the typed-SQL escape hatch exists to remove. It is
+     * documented and kept structurally stable only because the compat adapter
+     * detects it by shape (`typeof tx.rawQuery === 'function'`) and refuses to
+     * run compat raw SQL on a pool connection when it is missing.
+     *
+     * Execute an already-parameterized statement on THIS transaction's own
+     * connection, returning the driver's `{ rows, rowCount }` pair. It differs
+     * from {@link raw} in two ways the adapter needs: it takes a prebuilt
+     * `(text, params)` pair rather than a tagged template (the placeholder
+     * numbering is the caller's, so nested `Prisma.sql` fragments can be
+     * flattened first), and it surfaces `rowCount` so an `$executeRaw`-style call
+     * can report affected rows.
+     *
+     * The statement runs on the transaction's dedicated connection, so it is
+     * inside the same BEGIN/COMMIT (and any active SAVEPOINT) as every other
+     * statement in the callback. Driver errors are translated by `wrapPgError`,
+     * exactly as pool-scoped and table-scoped queries are. Like {@link raw}, it
+     * emits no `$on('query')` event and runs no middleware.
+     */
+    async rawQuery(text, params = []) {
+        try {
+            const result = await this.client.query(text, params);
+            return { rows: result.rows, rowCount: result.rowCount };
+        }
+        catch (err) {
+            throw wrapPgError(err);
+        }
+    }
     /**
      * Create a pool-like wrapper around the transaction client.
      * This allows QueryInterface to work with the transaction connection
@@ -240,7 +273,19 @@ export class TurbineClient {
     /** The schema metadata this client was built from */
     schema;
     static int8ParserRegistered = false;
-    static utcTimestampParserRegistered = false;
+    /**
+     * The `utcTimestamps` value the FIRST Turbine-owned pool in this process
+     * settled the OID 1114 read parser on, or `undefined` while no Turbine-owned
+     * client has been constructed yet.
+     *
+     * `pg.types.setTypeParser` is process-global by nature: there is one parser
+     * per OID for the whole pg module, so the READ side of `utcTimestamps` cannot
+     * be per client the way the WRITE side is. Recording the settled value (not
+     * just "registered yes/no") is what lets the constructor detect a second
+     * client asking for the opposite and refuse it, instead of handing back a
+     * client whose reads and writes disagree. See {@link assertUtcTimestampsAgree}.
+     */
+    static utcTimestampParserMode;
     logging;
     /** Active SQL dialect, owns transaction keywords, set_config, raw-SQL placeholders, capability flags. */
     dialect;
@@ -249,6 +294,8 @@ export class TurbineClient {
     queryListeners = new Set();
     queryOptions;
     errorMessagesSafe;
+    /** Whether `$on('query')` events carry real params (see `logQueryParams`). */
+    queryParamsVisible;
     /** True when Turbine created the pool and is responsible for tearing it down */
     ownsPool = true;
     /** Active LISTEN subscriptions, torn down on disconnect() so it never hangs */
@@ -284,6 +331,7 @@ export class TurbineClient {
             this.logging = parent.logging;
             this.dialect = parent.dialect;
             this.errorMessagesSafe = parent.errorMessagesSafe;
+            this.queryParamsVisible = parent.queryParamsVisible;
             this.queryOptions = parent.queryOptions;
             this.middlewares = parent.middlewares; // shared reference: $use on parent flows through
             this.pool = parent.pool;
@@ -367,9 +415,18 @@ export class TurbineClient {
         // ORM convention (Prisma, Rails, Django), and the only interpretation
         // that round-trips what Postgres stores, is UTC. Same ownership rule as
         // the int8 parser: never mutate parser state on external pools.
-        if (ownsAnyPool && config.utcTimestamps !== false && !TurbineClient.utcTimestampParserRegistered) {
-            pg.types.setTypeParser(1114, (val) => new Date(`${val.replace(' ', 'T')}Z`));
-            TurbineClient.utcTimestampParserRegistered = true;
+        //
+        // Read registration is process-global and one-shot; the WRITE side of the
+        // same flag is per client (query/writes.ts). Two clients disagreeing about
+        // it therefore cannot both be served, so the disagreement is refused here
+        // rather than resolved silently into a client that does not round-trip.
+        if (ownsAnyPool) {
+            const wantUtcTimestamps = config.utcTimestamps !== false;
+            TurbineClient.assertUtcTimestampsAgree(wantUtcTimestamps);
+            if (wantUtcTimestamps && TurbineClient.utcTimestampParserMode === undefined) {
+                pg.types.setTypeParser(1114, (val) => new Date(`${val.replace(' ', 'T')}Z`));
+            }
+            TurbineClient.utcTimestampParserMode = wantUtcTimestamps;
         }
         this.logging = config.logging ?? false;
         this.dialect = config.dialect ?? postgresDialect;
@@ -377,6 +434,10 @@ export class TurbineClient {
         // Respect env var kill switch
         const envDisablePrepared = typeof process !== 'undefined' && process.env?.TURBINE_DISABLE_PREPARED === '1';
         this.errorMessagesSafe = (config.errorMessages ?? 'safe') === 'safe';
+        // Query-event param visibility. One derived boolean, so the two config
+        // spellings can never disagree: `logQueryParams` wins when set, otherwise
+        // `errorMessages` keeps deciding exactly as it always has.
+        this.queryParamsVisible = config.logQueryParams ?? !this.errorMessagesSafe;
         this.queryOptions = {
             defaultLimit: config.defaultLimit,
             warnOnUnlimited: config.warnOnUnlimited,
@@ -401,7 +462,7 @@ export class TurbineClient {
             _onQuery: (event) => {
                 if (this.queryListeners.size === 0)
                     return;
-                const emitted = this.errorMessagesSafe ? { ...event, params: event.params.map(() => '[REDACTED]') } : event;
+                const emitted = this.queryParamsVisible ? event : { ...event, params: event.params.map(() => '[REDACTED]') };
                 for (const listener of this.queryListeners) {
                     try {
                         listener(emitted);
@@ -514,6 +575,51 @@ export class TurbineClient {
             this.$observe({ connectionString: observeUrl }).catch(() => { });
         }
     }
+    /**
+     * Refuse a `utcTimestamps` value that contradicts the one the process-global
+     * OID 1114 read parser was already settled on.
+     *
+     * The flag has two halves. The WRITE half is per client: a bound `Date` on a
+     * zone-less `date` / `timestamp` column is rewritten to a UTC literal unless
+     * the owning client opted out (`coerceWriteValue` in query/writes.ts). The
+     * READ half is the pg type parser for OID 1114, and `pg.types.setTypeParser`
+     * installs ONE parser per OID for the whole process, shared by every pool,
+     * every raw query, and any other library using the same pg module. There is
+     * no per-pool parser hook to bind it to, and moving the coercion into
+     * `parseRow` instead would leave every non-ORM read (raw SQL, `client.sql`,
+     * a caller's own `pool.query`) on the driver's value while changing the
+     * default path's output type, so the read half stays process-wide.
+     *
+     * That makes the mixed shape unserveable rather than merely awkward: the
+     * second client would write local calendar fields and read them back as UTC
+     * (or the reverse), so its own round trip is off by the process offset.
+     * A client that silently does not round-trip is the worst of the three
+     * outcomes, so construction fails with the two ways out.
+     *
+     * Only Turbine-owned pools take part. An external pool (Neon, Vercel
+     * Postgres, Hyperdrive) inherits the caller's parser configuration and
+     * Turbine never registers on its behalf, so it has no read half to contradict.
+     */
+    static assertUtcTimestampsAgree(want) {
+        const settled = TurbineClient.utcTimestampParserMode;
+        if (settled === undefined || settled === want)
+            return;
+        throw new ValidationError(`[turbine] utcTimestamps: ${want} conflicts with utcTimestamps: ${settled}, which an earlier TurbineClient ` +
+            'in this process already applied. The timestamp READ parser (pg OID 1114) is process-global, so it cannot ' +
+            'differ per client, while the WRITE side is per client. Serving both values would give this client a ' +
+            `${want ? 'UTC write' : 'local write'} and a ${settled ? 'UTC read' : 'local read'}, so every zone-less ` +
+            '`timestamp` it writes would read back shifted by the process offset. Give every TurbineClient in this ' +
+            'process the same `utcTimestamps` value, or run the odd one out in its own process.');
+    }
+    /**
+     * @internal Test-only: forget the process-global `utcTimestamps` decision so
+     * one process can exercise both mismatch directions. It does NOT restore the
+     * pg parser (parser registration is not reversible), so reads stay on
+     * whichever parser was installed first.
+     */
+    static resetUtcTimestampsForTests() {
+        TurbineClient.utcTimestampParserMode = undefined;
+    }
     // -------------------------------------------------------------------------
     // Middleware, intercept all queries
     // -------------------------------------------------------------------------

package/dist/dialect.d.ts

@@ -52,6 +52,20 @@ export interface BulkInsertStatementInput {
      */
     requireRowValues?: boolean;
 }
+export interface DefaultValuesInsertStatementInput {
+    /** SQL-ready quoted table name. */
+    table: string;
+    /**
+     * How many all-defaults rows to insert. Always a positive integer (the length
+     * of the caller's `data` array), never a user-supplied value, so a dialect may
+     * render it as a literal.
+     */
+    rowCount: number;
+    /** Skip duplicate rows when supported by the dialect. */
+    skipDuplicates?: boolean;
+    /** Optional SQL-ready RETURNING selection. */
+    returning?: ReturningSelection;
+}
 /**
  * The cast/decode pair for one JSON-divergent column type. See
  * {@link Dialect.jsonWireRule}. The two halves MUST agree: a cast with no
@@ -382,6 +396,25 @@ export interface Dialect {
     buildInsertStatement(input: InsertStatementInput): string;
     /** Build a multi-row bulk INSERT statement and its dialect-shaped params. */
     buildBulkInsertStatement(input: BulkInsertStatementInput): BuiltStatement;
+    /**
+     * Build an INSERT that binds NO column values, so every column takes its
+     * declared default: `create({ data: {} })` and `createMany({ data: [{}, …] })`.
+     *
+     * The naive `INSERT INTO t () VALUES ()` the column-driven builders produce for
+     * an empty `data` is a syntax error on every engine but MySQL, and an empty
+     * `data` object is easy to reach honestly (a handler that assembles its payload
+     * from optional request fields, against a table where every column has a
+     * default or is nullable). The correct statement differs per engine, so it
+     * lives here rather than as an engine test in the write builders.
+     *
+     * Implementations MUST honor `rowCount`, and MUST throw an
+     * {@link UnsupportedFeatureError} naming the engine when the engine cannot
+     * express the requested shape (several engines have a single-row-only
+     * `DEFAULT VALUES` and no multi-row equivalent) rather than emitting SQL the
+     * database will reject. Optional: a dialect that omits it raises E017 for both
+     * shapes.
+     */
+    buildDefaultValuesInsertStatement?(input: DefaultValuesInsertStatementInput): string;
     /** Build an upsert statement. Inputs are SQL-ready quoted fragments. */
     buildUpsertStatement(input: UpsertStatementInput): string;
     /** Whether native ILIKE is supported. */

package/dist/dialect.js

@@ -110,6 +110,20 @@ export const postgresDialect = {
             sql += ' ON CONFLICT DO NOTHING';
         return { sql: `${sql}${this.buildReturningClause(input.returning)}`, params: columnArrays };
     },
+    buildDefaultValuesInsertStatement(input) {
+        const conflict = input.skipDuplicates ? ' ON CONFLICT DO NOTHING' : '';
+        if (input.rowCount === 1) {
+            return `INSERT INTO ${input.table} DEFAULT VALUES${conflict}${this.buildReturningClause(input.returning)}`;
+        }
+        // N all-defaults rows: `DEFAULT VALUES` is single-row only, so feed the
+        // INSERT a zero-column SELECT of N source rows instead. Every column still
+        // takes its default (nothing is projected into the INSERT), and unlike
+        // `VALUES (DEFAULT), (DEFAULT)` it does not depend on the table's first
+        // column accepting the DEFAULT keyword. `rowCount` is the caller's array
+        // length, so the literal is an internal integer, not a bound user value.
+        return (`INSERT INTO ${input.table} SELECT FROM generate_series(1, ${input.rowCount})` +
+            `${conflict}${this.buildReturningClause(input.returning)}`);
+    },
     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(', ')}` +

package/dist/engine-config.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Shared client-config seam for the non-Postgres engine factories
+ * (`turbine-orm/sqlite`, `turbine-orm/mysql`, `turbine-orm/mssql`).
+ *
+ * Each factory builds its own driver pool and then hands a {@link TurbineConfig}
+ * to `TurbineClient`. Historically each one listed the config keys it forwarded
+ * by hand, which made the forwarded set an ALLOWLIST: every option added to
+ * `TurbineConfig` afterwards silently became unreachable on three engines until
+ * someone remembered to edit three literals (that is exactly how `errorMessages`
+ * and later `logQueryParams` ended up Postgres-only).
+ *
+ * {@link EngineClientConfig} inverts the default. Every `TurbineConfig` field is
+ * forwarded EXCEPT the ones listed below, so a new client option is engine-wide
+ * the day it lands and only a deliberate `Omit` entry can take it away again.
+ * Each engine's options interface extends this type and its factory spreads the
+ * config through verbatim.
+ */
+import type { TurbineConfig } from './client.js';
+/**
+ * `TurbineConfig` keys an engine factory does NOT forward. Every exclusion is
+ * deliberate; nothing else about `TurbineConfig` is engine-specific.
+ *
+ *   - `pool`, `dialect`, `preparedStatements`: owned by the factory. It binds
+ *     the driver pool and its dialect, and pins prepared statements off (these
+ *     drivers cache plans themselves). Letting a caller set them would unbind
+ *     the engine from its own SQL.
+ *   - `connectionString`, `host`, `port`, `database`, `user`, `password`, `ssl`,
+ *     `poolSize`, `idleTimeoutMs`, `connectionTimeoutMs`, `max`,
+ *     `idleTimeoutMillis`, `connectionTimeoutMillis`: pg connection and
+ *     pool-tuning fields, ignored by `TurbineClient` whenever `pool` is set (it
+ *     always is here). Each engine takes its connection target as its first
+ *     argument instead, in that driver's own vocabulary.
+ *   - `replicas`: entries are Postgres connection strings or pg-compatible
+ *     pools, which `TurbineClient` opens as `pg.Pool`s. There is no engine
+ *     equivalent to route reads to.
+ *
+ * Everything else is forwarded, including options that are Postgres-only by
+ * CAPABILITY rather than by plumbing (`jsonEncoding: 'positional'`). Those throw
+ * a typed `UnsupportedFeatureError` (E017) when used, which is a better answer
+ * than an option the type system says does not exist.
+ */
+type EngineOwnedConfigKey = 'pool' | 'dialect' | 'preparedStatements' | 'connectionString' | 'host' | 'port' | 'database' | 'user' | 'password' | 'ssl' | 'poolSize' | 'idleTimeoutMs' | 'connectionTimeoutMs' | 'max' | 'idleTimeoutMillis' | 'connectionTimeoutMillis' | 'replicas';
+/**
+ * The client-level options every engine factory accepts and forwards to
+ * `TurbineClient` unchanged: all of {@link TurbineConfig} minus the connection
+ * and dialect plumbing the factory owns (see {@link EngineOwnedConfigKey}).
+ */
+export type EngineClientConfig = Omit<TurbineConfig, EngineOwnedConfigKey>;
+export {};

package/dist/engine-config.js

@@ -0,0 +1,18 @@
+/**
+ * Shared client-config seam for the non-Postgres engine factories
+ * (`turbine-orm/sqlite`, `turbine-orm/mysql`, `turbine-orm/mssql`).
+ *
+ * Each factory builds its own driver pool and then hands a {@link TurbineConfig}
+ * to `TurbineClient`. Historically each one listed the config keys it forwarded
+ * by hand, which made the forwarded set an ALLOWLIST: every option added to
+ * `TurbineConfig` afterwards silently became unreachable on three engines until
+ * someone remembered to edit three literals (that is exactly how `errorMessages`
+ * and later `logQueryParams` ended up Postgres-only).
+ *
+ * {@link EngineClientConfig} inverts the default. Every `TurbineConfig` field is
+ * forwarded EXCEPT the ones listed below, so a new client option is engine-wide
+ * the day it lands and only a deliberate `Omit` entry can take it away again.
+ * Each engine's options interface extends this type and its factory spreads the
+ * config through verbatim.
+ */
+export {};

package/dist/index.d.ts

@@ -43,7 +43,7 @@ export { type IntrospectOptions, introspect } from './introspect.js';
 export { executeNestedCreate, executeNestedUpdate, hasRelationFields, type NestedWriteContext, } from './nested-write.js';
 export { HttpJsonSink, type HttpJsonSinkOptions, type MetricsFlushBatch, type MetricsFlushRow, type ObserveConfig, type ObserveHandle, type ObserveSink, PgMetricsSink, type PgMetricsSinkOptions, } from './observe.js';
 export { executePipeline, type PipelineOptions, type PipelineResults, pipelineSupported } from './pipeline.js';
-export { type AggregateArgs, type AggregateResult, type ArrayFilter, AUTO_ASSUMED_ROUND_TRIP_MS, AUTO_JOIN_PENALTY_MS_PER_ROW, AUTO_TO_ONE_JOIN_MAX_ROWS, AUTO_TO_ONE_JOIN_ROWS_MAX, AUTO_TO_ONE_JOIN_ROWS_MIN, type ColumnRef, type ConnectOrCreateOp, type CountArgs, type CreateArgs, type CreateDataInput, type CreateManyArgs, type DeferredQuery, type DeleteArgs, type DeleteManyArgs, type FieldResult, type FindManyArgs, type FindManyStreamArgs, type FindUniqueArgs, type GlobalFilters, type GroupByAggregateSpec, type GroupByArgs, type GroupByDistinctOn, type GroupByResult, type HavingClause, type JsonFilter, type JsonPathAggregateTarget, type JsonPathGroupKey, type JsonPathOrderBy, type MiddlewareFn, type NestedCreateOp, type NestedUpdateOp, type NestedUpdateOpItem, type NestedUpsertOpItem, type OmitResult, type OrderByClause, type OrderByObject, type OrderDirection, type QueryEvent, type QueryEventListener, QueryInterface, type QueryResult, type RelationDescriptor, type RelationFilter, type RelationLoadStrategy, type RelationPickBy, type RelationPickOrderBy, type SelectResult, type SkipGlobalFilters, type TextSearchFilter, type TypedWithClause, type UpdateArgs, type UpdateDataInput, type UpdateInput, type UpdateManyArgs, type UpdateOperatorInput, type UpsertArgs, type VectorDistanceFilter, type VectorFilter, type VectorMetric, type VectorOrderBy, type VectorOrderByDistance, type WhereClause, type WhereOperator, type WhereValue, type WithClause, type WithOptions, type WithOrderByObject, type WithResult, } from './query/index.js';
+export { type AggregateArgs, type AggregateResult, type ArrayFilter, AUTO_ASSUMED_ROUND_TRIP_MS, AUTO_COUNT_BATCH_MIN_PARENT_ROWS, AUTO_JOIN_PENALTY_MS_PER_ROW, AUTO_TO_ONE_JOIN_MAX_ROWS, AUTO_TO_ONE_JOIN_ROWS_MAX, AUTO_TO_ONE_JOIN_ROWS_MIN, type ColumnRef, type ConnectOrCreateOp, type CountArgs, type CreateArgs, type CreateDataInput, type CreateManyArgs, type DeferredQuery, type DeleteArgs, type DeleteManyArgs, type FieldResult, type FindManyArgs, type FindManyStreamArgs, type FindUniqueArgs, type GlobalFilters, type GroupByAggregateSpec, type GroupByArgs, type GroupByDistinctOn, type GroupByResult, type HavingClause, type JsonFilter, type JsonPathAggregateTarget, type JsonPathGroupKey, type JsonPathOrderBy, type MiddlewareFn, type NestedCreateOp, type NestedUpdateOp, type NestedUpdateOpItem, type NestedUpsertOpItem, type OmitResult, type OrderByClause, type OrderByObject, type OrderDirection, type QueryEvent, type QueryEventListener, QueryInterface, type QueryResult, type RelationDescriptor, type RelationFilter, type RelationLoadStrategy, type RelationPickBy, type RelationPickOrderBy, type SelectResult, type SkipGlobalFilters, type TextSearchFilter, type TypedWithClause, type UpdateArgs, type UpdateDataInput, type UpdateInput, type UpdateManyArgs, type UpdateOperatorInput, type UpsertArgs, type VectorDistanceFilter, type VectorFilter, type VectorMetric, type VectorOrderBy, type VectorOrderByDistance, type WhereClause, type WhereOperator, type WhereValue, type WithClause, type WithOptions, type WithOrderByObject, type WithResult, } from './query/index.js';
 export { type ActiveSubscription, type NotificationHandler, type Subscription, validateChannel } from './realtime.js';
 export type { CheckMetadata, ColumnMetadata, IndexMetadata, PrismaCompatMap, PrismaModelMap, PrismaRelationMap, ReferentialAction, RelationDef, SchemaMetadata, TableMetadata, } from './schema.js';
 export { camelToSnake, isDateType, normalizeKeyColumns, pgArrayType, pgTypeToTs, singularize, snakeToCamel, snakeToPascal, withDbFieldNames, } from './schema.js';

package/dist/index.js

@@ -49,7 +49,7 @@ export { HttpJsonSink, PgMetricsSink, } from './observe.js';
 // Pipeline
 export { executePipeline, pipelineSupported } from './pipeline.js';
 // Query builder
-export { AUTO_ASSUMED_ROUND_TRIP_MS, AUTO_JOIN_PENALTY_MS_PER_ROW, AUTO_TO_ONE_JOIN_MAX_ROWS, AUTO_TO_ONE_JOIN_ROWS_MAX, AUTO_TO_ONE_JOIN_ROWS_MIN, QueryInterface, } from './query/index.js';
+export { AUTO_ASSUMED_ROUND_TRIP_MS, AUTO_COUNT_BATCH_MIN_PARENT_ROWS, AUTO_JOIN_PENALTY_MS_PER_ROW, AUTO_TO_ONE_JOIN_MAX_ROWS, AUTO_TO_ONE_JOIN_ROWS_MAX, AUTO_TO_ONE_JOIN_ROWS_MIN, QueryInterface, } from './query/index.js';
 // Realtime, LISTEN/NOTIFY pub/sub
 export { validateChannel } from './realtime.js';
 // Schema utilities

package/dist/mssql.d.ts

@@ -89,8 +89,9 @@
  * await db.disconnect();
  * ```
  */
-import { type PgCompatPool, type PgCompatPoolClient, TurbineClient, type TurbineConfig } from './client.js';
+import { type PgCompatPool, type PgCompatPoolClient, TurbineClient } from './client.js';
 import { type Dialect, type IntrospectOptions } from './dialect.js';
+import type { EngineClientConfig } from './engine-config.js';
 import { type SchemaMetadata } from './schema.js';
 interface MssqlRequest {
     input(name: string, value: unknown): MssqlRequest;
@@ -204,8 +205,12 @@ interface MssqlConnectionConfig {
         trustServerCertificate?: boolean;
     };
 }
-/** Options for {@link turbineMssql}. Mirrors the relevant {@link TurbineConfig} fields. */
-export interface TurbineMssqlOptions extends Pick<TurbineConfig, 'logging' | 'defaultLimit' | 'warnOnUnlimited'> {
+/**
+ * Options for {@link turbineMssql}: every client-level `TurbineConfig` field the
+ * engine can honour (see {@link EngineClientConfig}) plus the SQL Server schema
+ * below.
+ */
+export interface TurbineMssqlOptions extends EngineClientConfig {
     /** SQL Server schema for introspection / DDL (default `dbo`). */
     schema?: string;
 }

package/dist/mssql.js

@@ -592,6 +592,22 @@ export const mssqlDialect = {
             params: input.rowValues.flat(),
         };
     },
+    buildDefaultValuesInsertStatement(input) {
+        // T-SQL puts OUTPUT between the (absent) column list and the value source,
+        // so `DEFAULT VALUES` follows it, exactly like the VALUES form above.
+        if (input.skipDuplicates) {
+            throw new UnsupportedFeatureError('createMany({ skipDuplicates: true })', 'mssql', 'SQL Server has no ON CONFLICT DO NOTHING equivalent, pre-filter conflicting rows or use a MERGE.');
+        }
+        // `DEFAULT VALUES` is single-row only in T-SQL, and the multi-row VALUES
+        // form needs one DEFAULT keyword per column, which rows of pure defaults
+        // do not name.
+        if (input.rowCount !== 1) {
+            throw new UnsupportedFeatureError(`createMany with ${input.rowCount} empty data rows`, 'mssql', 'SQL Server INSERT … DEFAULT VALUES inserts a single row and has no multi-row form; ' +
+                'issue one create({ data: {} }) per row.');
+        }
+        const out = mssqlOutput(input.returning, 'INSERTED');
+        return `INSERT INTO ${input.table}${out} DEFAULT VALUES`;
+    },
     buildUpsertStatement(input) {
         // MERGE is the SQL Server upsert. The MERGE statement MUST end with `;`.
         // CONCURRENCY CAVEAT: MERGE is not a substitute for a UNIQUE/PK constraint -
@@ -1280,13 +1296,16 @@ export async function turbineMssql(target, schema, options = {}) {
             throw err;
         // A non-version probe failure (permissions, etc.) should not block startup.
     }
+    // Everything that is not a SQL Server introspection option is client config
+    // and rides through untouched, so a new TurbineConfig option works here the
+    // day it lands. The engine-owned keys come last, so no caller can unbind the
+    // dialect.
+    const { schema: _dbSchema, ...clientConfig } = options;
     const client = new TurbineClient({
+        ...clientConfig,
         pool,
         dialect: mssqlDialect,
         preparedStatements: false,
-        logging: options.logging,
-        defaultLimit: options.defaultLimit,
-        warnOnUnlimited: options.warnOnUnlimited,
     }, schema);
     if (owns) {
         // Turbine built this pool, so disconnect()/end() must close it. External pools

package/dist/mysql.d.ts

@@ -62,8 +62,9 @@
  * await db.disconnect();
  * ```
  */
-import { type PgCompatPool, type PgCompatPoolClient, TurbineClient, type TurbineConfig } from './client.js';
+import { type PgCompatPool, type PgCompatPoolClient, TurbineClient } from './client.js';
 import { type Dialect, type IntrospectOptions } from './dialect.js';
+import type { EngineClientConfig } from './engine-config.js';
 import { type SchemaMetadata } from './schema.js';
 /** mysql2's `[result, fields]` tuple. `result` is rows (SELECT) or a header (write). */
 type Mysql2Result = [unknown, unknown];
@@ -145,8 +146,11 @@ interface MysqlConnectionConfig {
     password?: string;
     database?: string;
 }
-/** Options for {@link turbineMysql}. Mirrors the relevant {@link TurbineConfig} fields. */
-export interface TurbineMysqlOptions extends Pick<TurbineConfig, 'logging' | 'defaultLimit' | 'warnOnUnlimited'> {
+/**
+ * Options for {@link turbineMysql}: every client-level `TurbineConfig` field the
+ * engine can honour (see {@link EngineClientConfig}) plus the pool size below.
+ */
+export interface TurbineMysqlOptions extends EngineClientConfig {
     /** Maximum number of pooled connections (when Turbine builds the pool). Default: 10. */
     connectionLimit?: number;
 }

package/dist/mysql.js

@@ -513,6 +513,20 @@ export const mysqlDialect = {
             params: input.rowValues.flat(),
         };
     },
+    buildDefaultValuesInsertStatement(input) {
+        // MySQL is the one engine whose empty `VALUES ()` tuple is legal, and it
+        // repeats for any row count, so this is the same statement the column-driven
+        // builders already emitted for an empty `data`.
+        if (input.skipDuplicates) {
+            // `ON DUPLICATE KEY UPDATE` needs a column to assign, and there is no
+            // column here. `INSERT IGNORE` would swallow unrelated errors too, so
+            // refuse rather than quietly change what the flag means.
+            throw new UnsupportedFeatureError('createMany({ data: [{}, …], skipDuplicates: true })', 'mysql', 'MySQL ON DUPLICATE KEY UPDATE needs a column assignment, and rows of pure defaults name none; ' +
+                'supply the conflict column in each row.');
+        }
+        const tuples = Array.from({ length: input.rowCount }, () => '()').join(', ');
+        return `INSERT INTO ${input.table} () VALUES ${tuples}`;
+    },
     buildUpsertStatement(input) {
         // MySQL ignores the explicit conflict target, ON DUPLICATE KEY UPDATE keys
         // off the table's PK/unique indexes. The `where`-derived conflictColumns
@@ -963,13 +977,16 @@ export async function turbineMysql(target, schema, options = {}) {
     // Probe the server version (fail fast on MySQL < 8.0 / MariaDB).
     const versionRows = (await pool.query('SELECT VERSION() AS v')).rows;
     assertSupportedVersion(String(versionRows[0]?.v ?? ''));
+    // Everything that is not a pool-construction option is client config and
+    // rides through untouched, so a new TurbineConfig option works here the day
+    // it lands. The engine-owned keys come last, so no caller can unbind the
+    // dialect.
+    const { connectionLimit: _connectionLimit, ...clientConfig } = options;
     const client = new TurbineClient({
+        ...clientConfig,
         pool,
         dialect: mysqlDialect,
         preparedStatements: false,
-        logging: options.logging,
-        defaultLimit: options.defaultLimit,
-        warnOnUnlimited: options.warnOnUnlimited,
     }, schema);
     if (owns) {
         // Turbine built this pool, so disconnect()/end() must close it. External