turbine-orm 0.7.0 → 0.8.0

package/dist/cjs/client.js

@@ -134,9 +134,15 @@ class TransactionClient {
         // Return a minimal pool-compatible object that routes queries
         // through the transaction client
         return {
-            query: async (text, values) => {
+            query: async (textOrConfig, values) => {
                 try {
-                    return await client.query(text, values);
+                    if (typeof textOrConfig === 'string') {
+                        return await client.query(textOrConfig, values);
+                    }
+                    // Object form for prepared statements: { name, text, values }
+                    // pg.PoolClient.query accepts QueryConfig but the overloads make TS
+                    // unhappy with the union, so we cast through unknown.
+                    return await client.query(textOrConfig);
                 }
                 catch (err) {
                     throw (0, errors_js_1.wrapPgError)(err);
@@ -191,10 +197,19 @@ class TurbineClient {
         }
         this.logging = config.logging ?? false;
         this.schema = schema;
+        // Respect env var kill switch
+        const envDisablePrepared = typeof process !== 'undefined' && process.env?.TURBINE_DISABLE_PREPARED === '1';
         this.queryOptions = {
             defaultLimit: config.defaultLimit,
             warnOnUnlimited: config.warnOnUnlimited,
+            preparedStatements: envDisablePrepared ? false : (config.preparedStatements ?? !config.pool),
+            sqlCache: config.sqlCache ?? true,
         };
+        // Apply NotFoundError message redaction mode (default: safe — values are
+        // stripped from messages to avoid leaking PII into error logs).
+        if (config.errorMessages) {
+            (0, errors_js_1.setErrorMessageMode)(config.errorMessages);
+        }
         if (config.pool) {
             // External pool — use directly. Turbine doesn't manage its lifecycle.
             this.pool = config.pool;
@@ -302,13 +317,41 @@ class TurbineClient {
     /**
      * Execute multiple queries in a single database round-trip.
      *
-     * Pass the result of any `.build*()` method on a table accessor.
+     * Two call styles:
+     *   - `db.pipeline(q1, q2, q3)` — rest params (backward-compatible)
+     *   - `db.pipeline([q1, q2, q3], { transactional: false })` — array + options
+     *
+     * On pg.Pool-backed connections with TCP, this uses the real Postgres
+     * extended-query pipeline protocol (one TCP flush, one round-trip).
+     * On HTTP-based drivers it falls back to sequential execution.
      */
-    async pipeline(...queries) {
+    async pipeline(...args) {
+        let queries;
+        let options;
+        // Detect which overload was used
+        if (args.length > 0 &&
+            Array.isArray(args[0]) &&
+            args[0].every((item) => item && typeof item === 'object' && 'sql' in item)) {
+            // Array form: pipeline([q1, q2], opts?)
+            queries = args[0];
+            options = args[1];
+        }
+        else {
+            // Rest-param form: pipeline(q1, q2, q3)
+            queries = args;
+        }
         if (this.logging) {
             console.log(`[turbine] Pipeline: ${queries.length} queries — ${queries.map((q) => q.tag).join(', ')}`);
         }
-        return (0, pipeline_js_1.executePipeline)(this.pool, queries);
+        return (0, pipeline_js_1.executePipeline)(this.pool, queries, options);
+    }
+    /**
+     * Check whether the underlying pool supports the real pipeline protocol.
+     * Returns `true` for standard pg.Pool TCP connections, `false` for HTTP
+     * drivers (Neon HTTP, Vercel Postgres, etc.) and mock pools.
+     */
+    async pipelineSupported() {
+        return (0, pipeline_js_1.pipelineSupported)(this.pool);
     }
     // -------------------------------------------------------------------------
     // Raw SQL — tagged template literal escape hatch
@@ -399,6 +442,24 @@ class TurbineClient {
     async $transaction(fn, options) {
         const client = await this.pool.connect();
         const timeout = options?.timeout;
+        /**
+         * Track whether the connection has already been released so the finally
+         * block doesn't double-release. When a timeout fires we destroy the
+         * connection eagerly to abort the in-flight backend query.
+         */
+        let released = false;
+        const releaseOnce = (err) => {
+            if (released)
+                return;
+            released = true;
+            try {
+                client.release(err);
+            }
+            catch {
+                // pg may throw if the client is already released — swallow.
+            }
+        };
+        let timedOut = false;
         try {
             // BEGIN with optional isolation level
             let beginSQL = 'BEGIN';
@@ -422,10 +483,22 @@ class TurbineClient {
             }
             let result;
             if (timeout) {
-                // Race between the function and a timeout
+                // Race between the function and a timeout. If the timeout fires we
+                // need to actually abort the in-flight query — otherwise the backend
+                // keeps running until pg's own timeout, holding a pool slot the whole
+                // time. The simplest reliable cancellation is to destroy the
+                // connection: passing a truthy argument to client.release() tells the
+                // pg pool to discard the client (its socket is closed, which causes
+                // Postgres to abort the active query and roll back the transaction).
+                // The pool will spin up a fresh connection on the next checkout.
                 let timer;
                 const timeoutPromise = new Promise((_, reject) => {
                     timer = setTimeout(() => {
+                        timedOut = true;
+                        // Destroy the connection to abort the in-flight backend query.
+                        // We do this BEFORE rejecting so the socket is gone by the time
+                        // the caller's catch block runs.
+                        releaseOnce(new Error('[turbine] Transaction timeout — connection destroyed'));
                         reject(new errors_js_1.TimeoutError(timeout, 'Transaction'));
                     }, timeout);
                 });
@@ -446,14 +519,25 @@ class TurbineClient {
             return result;
         }
         catch (err) {
-            await client.query('ROLLBACK');
+            // If the timeout fired we already destroyed the connection — issuing a
+            // ROLLBACK on a released client would throw "Client has already been
+            // released". Skip the rollback in that case (the backend rolled back
+            // when its socket was closed).
+            if (!timedOut && !released) {
+                try {
+                    await client.query('ROLLBACK');
+                }
+                catch {
+                    // Best-effort rollback — the connection may have died mid-query.
+                }
+            }
             if (this.logging) {
                 console.log('[turbine] Transaction rolled back');
             }
             throw err;
         }
         finally {
-            client.release();
+            releaseOnce();
         }
     }
     // -------------------------------------------------------------------------

package/dist/cjs/errors.js

@@ -6,7 +6,9 @@
  * All Turbine errors extend TurbineError which includes a `code` property.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CheckConstraintError = exports.NotNullViolationError = exports.ForeignKeyError = exports.UniqueConstraintError = exports.CircularRelationError = exports.MigrationError = exports.RelationError = exports.ConnectionError = exports.ValidationError = exports.TimeoutError = exports.NotFoundError = exports.TurbineError = exports.TurbineErrorCode = void 0;
+exports.PipelineError = exports.CheckConstraintError = exports.SerializationFailureError = exports.DeadlockError = exports.NotNullViolationError = exports.ForeignKeyError = exports.UniqueConstraintError = exports.CircularRelationError = exports.MigrationError = exports.RelationError = exports.ConnectionError = exports.ValidationError = exports.TimeoutError = exports.NotFoundError = exports.TurbineError = exports.TurbineErrorCode = void 0;
+exports.setErrorMessageMode = setErrorMessageMode;
+exports.getErrorMessageMode = getErrorMessageMode;
 exports.wrapPgError = wrapPgError;
 /** Error codes for all Turbine errors */
 exports.TurbineErrorCode = {
@@ -21,6 +23,9 @@ exports.TurbineErrorCode = {
     FOREIGN_KEY_VIOLATION: 'TURBINE_E009',
     NOT_NULL_VIOLATION: 'TURBINE_E010',
     CHECK_VIOLATION: 'TURBINE_E011',
+    DEADLOCK_DETECTED: 'TURBINE_E012',
+    SERIALIZATION_FAILURE: 'TURBINE_E013',
+    PIPELINE: 'TURBINE_E014',
 };
 /** Base error class for all Turbine errors */
 class TurbineError extends Error {
@@ -32,6 +37,47 @@ class TurbineError extends Error {
     }
 }
 exports.TurbineError = TurbineError;
+let errorMessageMode = 'safe';
+/**
+ * Set the global NotFoundError message mode. Called from the TurbineClient
+ * constructor when `TurbineConfig.errorMessages` is provided.
+ *
+ *   - `'safe'`    (default): the message includes only the keys of the where
+ *     clause (e.g. `where: { id, email }`). Values are redacted.
+ *   - `'verbose'`: the message includes the full JSON-serialized where
+ *     clause (e.g. `where: {"id":1,"email":"alice@x.com"}`).
+ */
+function setErrorMessageMode(mode) {
+    errorMessageMode = mode;
+}
+/** Returns the current NotFoundError message mode. Exported for tests. */
+function getErrorMessageMode() {
+    return errorMessageMode;
+}
+/**
+ * Render a `where` clause for error messages. In 'safe' mode (the default),
+ * only the keys are shown; values are stripped to avoid leaking PII into logs.
+ * Nested AND/OR/NOT combinators are recursively rendered.
+ */
+function renderWhereForMessage(where, mode) {
+    if (mode === 'verbose') {
+        try {
+            return JSON.stringify(where);
+        }
+        catch {
+            return '[unserializable]';
+        }
+    }
+    // safe mode: keys only
+    if (where === null || where === undefined)
+        return '';
+    if (typeof where !== 'object')
+        return '';
+    const keys = Object.keys(where);
+    if (keys.length === 0)
+        return '{}';
+    return `{ ${keys.join(', ')} }`;
+}
 /**
  * Thrown when a record is not found (findUniqueOrThrow, findFirstOrThrow,
  * update/delete against a non-matching row, etc.)
@@ -41,8 +87,16 @@ exports.TurbineError = TurbineError;
  *   - `new NotFoundError({ table, where, operation, cause, message })`
  *
  * When called with an options object and no explicit `message`, a Prisma-style
- * message is built automatically, e.g.:
+ * message is built automatically. By default, only the where-clause keys are
+ * shown to avoid leaking PII into logs:
+ *   `[turbine] findUniqueOrThrow on "users" found no record matching where: { id }`
+ *
+ * Set `setErrorMessageMode('verbose')` (or pass `errorMessages: 'verbose'` to
+ * the TurbineClient constructor) to include the full where values:
  *   `[turbine] findUniqueOrThrow on "users" found no record matching where: {"id":1}`
+ *
+ * The full `where` object, `table`, and `operation` are always available as
+ * structured properties on the error instance regardless of mode.
  */
 class NotFoundError extends TurbineError {
     table;
@@ -59,11 +113,11 @@ class NotFoundError extends TurbineError {
         let message = input.message;
         if (!message) {
             if (operation && table) {
-                const wherePart = where !== undefined ? ` matching where: ${JSON.stringify(where)}` : '';
+                const wherePart = where !== undefined ? ` matching where: ${renderWhereForMessage(where, errorMessageMode)}` : '';
                 message = `[turbine] ${operation} on "${table}" found no record${wherePart}`;
             }
             else if (table) {
-                const wherePart = where !== undefined ? ` matching where ${JSON.stringify(where)}` : '';
+                const wherePart = where !== undefined ? ` matching where ${renderWhereForMessage(where, errorMessageMode)}` : '';
                 message = `[turbine] No record found in "${table}"${wherePart}`;
             }
             else {
@@ -209,6 +263,73 @@ class NotNullViolationError extends TurbineError {
     }
 }
 exports.NotNullViolationError = NotNullViolationError;
+/**
+ * Thrown when Postgres detects a deadlock (pg code 40P01).
+ *
+ * This error is **retryable** — when caught, callers can safely retry the
+ * transaction (typically with backoff). Catch it explicitly:
+ *
+ * ```ts
+ * try {
+ *   await db.$transaction(async (tx) => { ... });
+ * } catch (err) {
+ *   if (err instanceof DeadlockError) {
+ *     // safe to retry
+ *   }
+ * }
+ * ```
+ */
+class DeadlockError extends TurbineError {
+    /** Marks this error as safe to retry */
+    isRetryable = true;
+    constraint;
+    constructor(opts = {}) {
+        const { constraint, cause } = opts;
+        let message = opts.message;
+        if (!message) {
+            const pgMessage = cause?.message;
+            message = pgMessage ? `[turbine] Deadlock detected: ${pgMessage}` : '[turbine] Deadlock detected';
+        }
+        super(exports.TurbineErrorCode.DEADLOCK_DETECTED, message, { cause });
+        this.name = 'DeadlockError';
+        this.constraint = constraint;
+    }
+}
+exports.DeadlockError = DeadlockError;
+/**
+ * Thrown when a Serializable transaction fails due to a serialization
+ * conflict (pg code 40001 — `could not serialize access due to ...`).
+ *
+ * This error is **retryable** — by Postgres documentation, the recommended
+ * response is to re-run the entire transaction. Catch it explicitly:
+ *
+ * ```ts
+ * try {
+ *   await db.$transaction(async (tx) => { ... }, { isolationLevel: 'Serializable' });
+ * } catch (err) {
+ *   if (err instanceof SerializationFailureError) {
+ *     // safe to retry the whole transaction
+ *   }
+ * }
+ * ```
+ */
+class SerializationFailureError extends TurbineError {
+    /** Marks this error as safe to retry */
+    isRetryable = true;
+    constructor(opts = {}) {
+        const { cause } = opts;
+        let message = opts.message;
+        if (!message) {
+            const pgMessage = cause?.message;
+            message = pgMessage
+                ? `[turbine] Serializable transaction conflict: ${pgMessage}`
+                : '[turbine] Serializable transaction conflict';
+        }
+        super(exports.TurbineErrorCode.SERIALIZATION_FAILURE, message, { cause });
+        this.name = 'SerializationFailureError';
+    }
+}
+exports.SerializationFailureError = SerializationFailureError;
 /** Thrown when a CHECK constraint is violated (pg code 23514) */
 class CheckConstraintError extends TurbineError {
     constraint;
@@ -230,6 +351,47 @@ class CheckConstraintError extends TurbineError {
     }
 }
 exports.CheckConstraintError = CheckConstraintError;
+/**
+ * Thrown when a non-transactional pipeline has partial failures.
+ *
+ * In non-transactional mode (`{ transactional: false }`), each query executes
+ * independently. If one or more queries fail, the pipeline rejects with a
+ * `PipelineError` that carries per-query results so callers can inspect which
+ * succeeded and which failed.
+ *
+ * ```ts
+ * try {
+ *   await db.pipeline([q1, q2, q3], { transactional: false });
+ * } catch (err) {
+ *   if (err instanceof PipelineError) {
+ *     for (const slot of err.results) {
+ *       if (slot.status === 'error') console.error(slot.error);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+class PipelineError extends TurbineError {
+    /** Per-query results: each slot is either `{status:'ok', value}` or `{status:'error', error}` */
+    results;
+    /** Zero-based index of the first query that failed */
+    failedIndex;
+    /** Tag of the first query that failed (from DeferredQuery.tag) */
+    failedTag;
+    constructor(opts) {
+        const { results, failedIndex, failedTag, cause } = opts;
+        const failedCount = results.filter((r) => r.status === 'error').length;
+        const message = opts.message ??
+            `[turbine] Pipeline completed with ${failedCount} error(s) out of ${results.length} queries` +
+                (failedTag ? ` (first failure: ${failedTag} at index ${failedIndex})` : '');
+        super(exports.TurbineErrorCode.PIPELINE, message, { cause });
+        this.name = 'PipelineError';
+        this.results = results;
+        this.failedIndex = failedIndex;
+        this.failedTag = failedTag;
+    }
+}
+exports.PipelineError = PipelineError;
 /**
  * Parse column names out of a pg `detail` string like:
  *   "Key (email)=(foo@bar) already exists."
@@ -250,6 +412,8 @@ function parseColumnsFromDetail(detail) {
  *   23503 (foreign_key_violation) -> ForeignKeyError
  *   23502 (not_null_violation)    -> NotNullViolationError
  *   23514 (check_violation)       -> CheckConstraintError
+ *   40P01 (deadlock_detected)     -> DeadlockError       (retryable)
+ *   40001 (serialization_failure) -> SerializationFailureError (retryable)
  *
  * The original pg error is preserved as `.cause` on the wrapped error.
  */
@@ -287,6 +451,15 @@ function wrapPgError(err) {
                 table: e.table,
                 cause: err,
             });
+        case '40P01':
+            return new DeadlockError({
+                constraint: e.constraint,
+                cause: err,
+            });
+        case '40001':
+            return new SerializationFailureError({
+                cause: err,
+            });
         default:
             return err;
     }

package/dist/cjs/generate.js

@@ -11,6 +11,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generate = generate;
+exports.generateTypes = generateTypes;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const schema_js_1 = require("./schema.js");
@@ -63,8 +64,33 @@ function generatedFileHeader() {
         '',
     ];
 }
+/**
+ * Generate the contents of `types.ts` (entity interfaces, *Create / *Update,
+ * and *Relations brand-field interfaces). Exported so tests can pin the
+ * generator output without writing files to disk.
+ */
 function generateTypes(schema) {
     const lines = [...generatedFileHeader()];
+    // We import UpdateOperatorInput so generated *Update types can express
+    // atomic increment / decrement / multiply / divide / set operators on
+    // numeric columns (TASK-3.4).
+    //
+    // RelationDescriptor is the brand-field interface that lets `WithResult`
+    // recurse through nested `with` clauses at any depth. The generator emits
+    // each `*Relations` member as a `RelationDescriptor<Target, Cardinality,
+    // TargetRelations>` so users get full deep `with`-clause type inference
+    // out of the box (TASK-2.1).
+    lines.push("import type { RelationDescriptor, UpdateOperatorInput } from 'turbine-orm';");
+    lines.push('');
+    // Pre-compute which tables have relations so we know whether to thread
+    // `${TargetType}Relations` (for deep inference) or `{}` (the no-relations
+    // default) into each `RelationDescriptor`. Built once up-front because
+    // relations can point at tables we haven't iterated to yet.
+    const tablesWithRelations = new Set();
+    for (const t of Object.values(schema.tables)) {
+        if (Object.keys(t.relations).length > 0)
+            tablesWithRelations.add(t.name);
+    }
     // Generate enum types
     for (const [enumName, labels] of Object.entries(schema.enums)) {
         const typeName = (0, schema_js_1.snakeToPascal)(enumName);
@@ -106,27 +132,33 @@ function generateTypes(schema) {
         lines.push('};');
         lines.push('');
         // --- Update input type (all fields optional except PK) ---
+        // Numeric columns additionally accept `UpdateOperatorInput<number>` so
+        // users can write `{ viewCount: { increment: 1 } }` without an `as any`.
         const nonPkCols = table.columns.filter((c) => !table.primaryKey.includes(c.name));
         lines.push(`/** Input type for updating a row in \`${table.name}\` */`);
         lines.push(`export type ${typeName}Update = {`);
         for (const col of nonPkCols) {
-            lines.push(`  ${col.field}?: ${col.tsType};`);
+            lines.push(`  ${col.field}?: ${updateFieldType(col.tsType)};`);
         }
         lines.push('};');
         lines.push('');
         // --- Relations map (for type-safe `with` clauses) ---
+        //
+        // Each relation is emitted as a `RelationDescriptor<Target, Cardinality,
+        // TargetRelations>` brand-field interface. This is what enables the
+        // recursive `WithResult` type to walk through nested `with` clauses at
+        // any depth — `RelationRelations<R[K]>` reads the third type parameter
+        // and threads it into the next recursion step. If the target table has
+        // no relations of its own, the descriptor uses `{}` (the default).
         const hasRelations = Object.keys(table.relations).length > 0;
         if (hasRelations) {
             lines.push(`/** Available relations for the \`${table.name}\` table */`);
             lines.push(`export interface ${typeName}Relations {`);
             for (const [relName, rel] of Object.entries(table.relations)) {
                 const targetType = entityName(rel.to);
-                if (rel.type === 'hasMany') {
-                    lines.push(`  ${relName}: ${targetType}[];`);
-                }
-                else {
-                    lines.push(`  ${relName}: ${targetType} | null;`);
-                }
+                const cardinality = rel.type === 'hasMany' ? "'many'" : "'one'";
+                const targetRelations = tablesWithRelations.has(rel.to) ? `${targetType}Relations` : '{}';
+                lines.push(`  ${relName}: RelationDescriptor<${targetType}, ${cardinality}, ${targetRelations}>;`);
             }
             lines.push('}');
             lines.push('');
@@ -230,8 +262,8 @@ function generateIndex(schema) {
     const tableEntries = Object.values(schema.tables);
     const lines = [
         ...generatedFileHeader(),
-        "import { TurbineClient as BaseTurbineClient, QueryInterface } from 'turbine-orm';",
-        "import type { TurbineConfig } from 'turbine-orm';",
+        "import { TurbineClient as BaseTurbineClient, TransactionClient as BaseTransactionClient, QueryInterface } from 'turbine-orm';",
+        "import type { TurbineConfig, TransactionOptions } from 'turbine-orm';",
         "import { SCHEMA } from './metadata.js';",
     ];
     // Import all entity types and relations maps
@@ -244,6 +276,41 @@ function generateIndex(schema) {
     }
     lines.push(`import type { ${typeImports.join(', ')} } from './types.js';`);
     lines.push('');
+    // -------------------------------------------------------------------------
+    // TypedTransactionClient — same typed table accessors as TurbineClient,
+    // but scoped to a single transaction connection. The runtime instance is
+    // an ordinary `TransactionClient` from turbine-orm; this declaration just
+    // teaches TypeScript about the auto-attached accessors so users get
+    // autocomplete inside `db.$transaction(async (tx) => tx.users.create(...))`.
+    // -------------------------------------------------------------------------
+    lines.push('/**');
+    lines.push(' * Transaction-scoped client with the same typed table accessors as TurbineClient.');
+    lines.push(' * Created automatically by `db.$transaction(async (tx) => ...)` — never instantiate');
+    lines.push(' * directly. All queries run on a dedicated connection within a BEGIN/COMMIT block.');
+    lines.push(' */');
+    lines.push('export class TypedTransactionClient extends BaseTransactionClient {');
+    for (const table of tableEntries) {
+        const typeName = entityName(table.name);
+        const accessor = snakeToCamelStr(table.name);
+        const hasRelations = Object.keys(table.relations).length > 0;
+        const genericArgs = hasRelations ? `${typeName}, ${typeName}Relations` : typeName;
+        lines.push(`  /** Query interface for the \`${table.name}\` table (transaction-scoped) */`);
+        lines.push(`  declare readonly ${accessor}: QueryInterface<${genericArgs}>;`);
+    }
+    lines.push('}');
+    lines.push('');
+    // Augment the class with a typed `$transaction` overload via interface
+    // merging. This adds an additional callable signature whose callback
+    // parameter is narrowed to `TypedTransactionClient`, while the base
+    // signature (callback parameter `BaseTransactionClient`) remains valid.
+    lines.push('export interface TypedTransactionClient {');
+    lines.push('  /**');
+    lines.push('   * Nested transaction via SAVEPOINT. The callback receives a typed');
+    lines.push('   * `TypedTransactionClient` so all table accessors auto-complete.');
+    lines.push('   */');
+    lines.push('  $transaction<R>(fn: (tx: TypedTransactionClient) => Promise<R>): Promise<R>;');
+    lines.push('}');
+    lines.push('');
     // Generate the client class with JSDoc
     lines.push('/**');
     lines.push(' * Generated Turbine client with typed table accessors.');
@@ -278,6 +345,22 @@ function generateIndex(schema) {
     lines.push('  }');
     lines.push('}');
     lines.push('');
+    // Augment TurbineClient via interface merging with a typed $transaction
+    // overload. The callback parameter is narrowed to `TypedTransactionClient`
+    // so users get autocomplete on `tx.users`, `tx.posts`, etc. The base
+    // signature (callback parameter `BaseTransactionClient`) remains valid as
+    // an overload, so prior usage continues to typecheck.
+    lines.push('export interface TurbineClient {');
+    lines.push('  /**');
+    lines.push('   * Run a callback inside a transaction. The callback receives a typed');
+    lines.push('   * `TypedTransactionClient` with autocompletion for every table accessor.');
+    lines.push('   */');
+    lines.push('  $transaction<R>(');
+    lines.push('    fn: (tx: TypedTransactionClient) => Promise<R>,');
+    lines.push('    options?: TransactionOptions,');
+    lines.push('  ): Promise<R>;');
+    lines.push('}');
+    lines.push('');
     // Factory function with JSDoc
     lines.push('/**');
     lines.push(' * Create a new Turbine client instance.');
@@ -319,3 +402,31 @@ function quoteIfNeeded(s) {
 function snakeToCamelStr(s) {
     return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
 }
+/**
+ * Build the update-input field type for a column. Numeric columns become
+ * `T | UpdateOperatorInput<number> | null?` so users can write atomic
+ * operators (`{ increment: 1 }`, `{ multiply: 2 }`, etc.) without casts.
+ *
+ * The check is purely structural — if the column's TS type contains
+ * `'number'` (e.g. `number`, `number | null`), it's eligible. Other
+ * scalar types (`string`, `boolean`, `Date`, `unknown`, `Buffer`,
+ * `Date | null`, etc.) pass through unchanged.
+ */
+function updateFieldType(tsType) {
+    // Strip parens for the regex check; preserve the original string in the output.
+    if (containsNumberType(tsType)) {
+        return `${tsType} | UpdateOperatorInput<number>`;
+    }
+    return tsType;
+}
+/**
+ * Detect whether a TypeScript type expression contains the `number` primitive
+ * as a top-level union member. Conservative on purpose — only matches
+ * `number`, `number | null`, `null | number`, etc., not `number[]` or
+ * `Record<string, number>`.
+ */
+function containsNumberType(tsType) {
+    // Tokenize on `|` and check each member.
+    const parts = tsType.split('|').map((p) => p.trim());
+    return parts.some((p) => p === 'number');
+}

package/dist/cjs/index.js

@@ -34,7 +34,7 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.turbineHttp = exports.schemaToSQLString = exports.schemaToSQL = exports.schemaPush = exports.schemaDiff = exports.table = exports.defineSchema = exports.column = exports.ColumnBuilder = exports.snakeToPascal = exports.snakeToCamel = exports.singularize = exports.pgTypeToTs = exports.pgArrayType = exports.isDateType = exports.camelToSnake = exports.QueryInterface = exports.executePipeline = exports.introspect = exports.generate = exports.wrapPgError = exports.ValidationError = exports.UniqueConstraintError = exports.TurbineErrorCode = exports.TurbineError = exports.TimeoutError = exports.RelationError = exports.NotNullViolationError = exports.NotFoundError = exports.MigrationError = exports.ForeignKeyError = exports.ConnectionError = exports.CircularRelationError = exports.CheckConstraintError = exports.TurbineClient = exports.TransactionClient = void 0;
+exports.turbineHttp = exports.schemaToSQLString = exports.schemaToSQL = exports.schemaPush = exports.schemaDiff = exports.table = exports.defineSchema = exports.column = exports.ColumnBuilder = exports.snakeToPascal = exports.snakeToCamel = exports.singularize = exports.pgTypeToTs = exports.pgArrayType = exports.isDateType = exports.camelToSnake = exports.QueryInterface = exports.pipelineSupported = exports.executePipeline = exports.introspect = exports.generate = exports.wrapPgError = exports.ValidationError = exports.UniqueConstraintError = exports.TurbineErrorCode = exports.TurbineError = exports.TimeoutError = exports.setErrorMessageMode = exports.SerializationFailureError = exports.RelationError = exports.PipelineError = exports.NotNullViolationError = exports.NotFoundError = exports.MigrationError = exports.getErrorMessageMode = exports.ForeignKeyError = exports.DeadlockError = exports.ConnectionError = exports.CircularRelationError = exports.CheckConstraintError = exports.TurbineClient = exports.TransactionClient = void 0;
 // Client
 var client_js_1 = require("./client.js");
 Object.defineProperty(exports, "TransactionClient", { enumerable: true, get: function () { return client_js_1.TransactionClient; } });
@@ -44,11 +44,16 @@ var errors_js_1 = require("./errors.js");
 Object.defineProperty(exports, "CheckConstraintError", { enumerable: true, get: function () { return errors_js_1.CheckConstraintError; } });
 Object.defineProperty(exports, "CircularRelationError", { enumerable: true, get: function () { return errors_js_1.CircularRelationError; } });
 Object.defineProperty(exports, "ConnectionError", { enumerable: true, get: function () { return errors_js_1.ConnectionError; } });
+Object.defineProperty(exports, "DeadlockError", { enumerable: true, get: function () { return errors_js_1.DeadlockError; } });
 Object.defineProperty(exports, "ForeignKeyError", { enumerable: true, get: function () { return errors_js_1.ForeignKeyError; } });
+Object.defineProperty(exports, "getErrorMessageMode", { enumerable: true, get: function () { return errors_js_1.getErrorMessageMode; } });
 Object.defineProperty(exports, "MigrationError", { enumerable: true, get: function () { return errors_js_1.MigrationError; } });
 Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return errors_js_1.NotFoundError; } });
 Object.defineProperty(exports, "NotNullViolationError", { enumerable: true, get: function () { return errors_js_1.NotNullViolationError; } });
+Object.defineProperty(exports, "PipelineError", { enumerable: true, get: function () { return errors_js_1.PipelineError; } });
 Object.defineProperty(exports, "RelationError", { enumerable: true, get: function () { return errors_js_1.RelationError; } });
+Object.defineProperty(exports, "SerializationFailureError", { enumerable: true, get: function () { return errors_js_1.SerializationFailureError; } });
+Object.defineProperty(exports, "setErrorMessageMode", { enumerable: true, get: function () { return errors_js_1.setErrorMessageMode; } });
 Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_js_1.TimeoutError; } });
 Object.defineProperty(exports, "TurbineError", { enumerable: true, get: function () { return errors_js_1.TurbineError; } });
 Object.defineProperty(exports, "TurbineErrorCode", { enumerable: true, get: function () { return errors_js_1.TurbineErrorCode; } });
@@ -64,6 +69,7 @@ Object.defineProperty(exports, "introspect", { enumerable: true, get: function (
 // Pipeline
 var pipeline_js_1 = require("./pipeline.js");
 Object.defineProperty(exports, "executePipeline", { enumerable: true, get: function () { return pipeline_js_1.executePipeline; } });
+Object.defineProperty(exports, "pipelineSupported", { enumerable: true, get: function () { return pipeline_js_1.pipelineSupported; } });
 // Query builder
 var query_js_1 = require("./query.js");
 Object.defineProperty(exports, "QueryInterface", { enumerable: true, get: function () { return query_js_1.QueryInterface; } });