turbine-orm 0.5.0 → 0.7.1

package/dist/errors.js

@@ -0,0 +1,405 @@
+/**
+ * turbine-orm — Error types
+ *
+ * Typed errors with error codes for programmatic handling.
+ * All Turbine errors extend TurbineError which includes a `code` property.
+ */
+/** Error codes for all Turbine errors */
+export const TurbineErrorCode = {
+    NOT_FOUND: 'TURBINE_E001',
+    TIMEOUT: 'TURBINE_E002',
+    VALIDATION: 'TURBINE_E003',
+    CONNECTION: 'TURBINE_E004',
+    RELATION: 'TURBINE_E005',
+    MIGRATION: 'TURBINE_E006',
+    CIRCULAR_RELATION: 'TURBINE_E007',
+    UNIQUE_VIOLATION: 'TURBINE_E008',
+    FOREIGN_KEY_VIOLATION: 'TURBINE_E009',
+    NOT_NULL_VIOLATION: 'TURBINE_E010',
+    CHECK_VIOLATION: 'TURBINE_E011',
+    DEADLOCK_DETECTED: 'TURBINE_E012',
+    SERIALIZATION_FAILURE: 'TURBINE_E013',
+};
+/** Base error class for all Turbine errors */
+export class TurbineError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = 'TurbineError';
+        this.code = code;
+    }
+}
+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"}`).
+ */
+export function setErrorMessageMode(mode) {
+    errorMessageMode = mode;
+}
+/** Returns the current NotFoundError message mode. Exported for tests. */
+export 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.)
+ *
+ * Supports two call styles for back-compat:
+ *   - `new NotFoundError()` / `new NotFoundError('custom message')`
+ *   - `new NotFoundError({ table, where, operation, cause, message })`
+ *
+ * When called with an options object and no explicit `message`, a Prisma-style
+ * 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.
+ */
+export class NotFoundError extends TurbineError {
+    table;
+    where;
+    operation;
+    constructor(input) {
+        // Back-compat: string argument (or undefined) — replicate legacy behavior.
+        if (typeof input === 'string' || input === undefined) {
+            super(TurbineErrorCode.NOT_FOUND, input ?? 'Record not found');
+            this.name = 'NotFoundError';
+            return;
+        }
+        const { table, where, operation, cause } = input;
+        let message = input.message;
+        if (!message) {
+            if (operation && table) {
+                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 ${renderWhereForMessage(where, errorMessageMode)}` : '';
+                message = `[turbine] No record found in "${table}"${wherePart}`;
+            }
+            else {
+                message = '[turbine] Record not found';
+            }
+        }
+        super(TurbineErrorCode.NOT_FOUND, message, { cause });
+        this.name = 'NotFoundError';
+        this.table = table;
+        this.where = where;
+        this.operation = operation;
+    }
+}
+/** Thrown when a query or transaction exceeds the configured timeout */
+export class TimeoutError extends TurbineError {
+    timeoutMs;
+    constructor(timeoutMs, context = 'Query') {
+        super(TurbineErrorCode.TIMEOUT, `[turbine] ${context} timed out after ${timeoutMs}ms`);
+        this.name = 'TimeoutError';
+        this.timeoutMs = timeoutMs;
+    }
+}
+/** Thrown when query arguments fail validation (unknown column, invalid operator, etc.) */
+export class ValidationError extends TurbineError {
+    constructor(message) {
+        super(TurbineErrorCode.VALIDATION, message);
+        this.name = 'ValidationError';
+    }
+}
+/** Thrown when a database connection fails */
+export class ConnectionError extends TurbineError {
+    constructor(message) {
+        super(TurbineErrorCode.CONNECTION, message);
+        this.name = 'ConnectionError';
+    }
+}
+/** Thrown when a relation reference is invalid */
+export class RelationError extends TurbineError {
+    constructor(message) {
+        super(TurbineErrorCode.RELATION, message);
+        this.name = 'RelationError';
+    }
+}
+/** Thrown when a migration operation fails */
+export class MigrationError extends TurbineError {
+    constructor(message) {
+        super(TurbineErrorCode.MIGRATION, message);
+        this.name = 'MigrationError';
+    }
+}
+/** Thrown when circular relation nesting is detected */
+export class CircularRelationError extends TurbineError {
+    path;
+    constructor(path) {
+        super(TurbineErrorCode.CIRCULAR_RELATION, `[turbine] Circular or too-deep relation nesting detected: ${path.join(' → ')}. Maximum nesting depth is 10.`);
+        this.name = 'CircularRelationError';
+        this.path = path;
+    }
+}
+// ---------------------------------------------------------------------------
+// Database constraint violation errors
+// ---------------------------------------------------------------------------
+/**
+ * Extract the `detail` string from a pg-style error stored as `cause`.
+ * Returns undefined if the cause is not an object or has no detail.
+ */
+function detailFromCause(cause) {
+    if (!cause || typeof cause !== 'object')
+        return undefined;
+    const d = cause.detail;
+    return typeof d === 'string' && d.length > 0 ? d : undefined;
+}
+/** Thrown when a UNIQUE constraint is violated (pg code 23505) */
+export class UniqueConstraintError extends TurbineError {
+    constraint;
+    columns;
+    table;
+    constructor(opts = {}) {
+        const { constraint, columns, table, cause } = opts;
+        let message = opts.message;
+        if (!message) {
+            const constraintPart = constraint ? ` on ${constraint}` : '';
+            const columnsPart = columns && columns.length > 0 ? ` (${columns.join(', ')})` : '';
+            message = `[turbine] Unique constraint violation${constraintPart}${columnsPart}`;
+            const detail = detailFromCause(cause);
+            if (detail)
+                message += `: ${detail}`;
+        }
+        super(TurbineErrorCode.UNIQUE_VIOLATION, message, { cause });
+        this.name = 'UniqueConstraintError';
+        this.constraint = constraint;
+        this.columns = columns;
+        this.table = table;
+    }
+}
+/** Thrown when a FOREIGN KEY constraint is violated (pg code 23503) */
+export class ForeignKeyError extends TurbineError {
+    constraint;
+    table;
+    constructor(opts = {}) {
+        const { constraint, table, cause } = opts;
+        let message = opts.message;
+        if (!message) {
+            const constraintPart = constraint ? ` on ${constraint}` : '';
+            message = `[turbine] Foreign key constraint violation${constraintPart}`;
+            const detail = detailFromCause(cause);
+            if (detail)
+                message += `: ${detail}`;
+        }
+        super(TurbineErrorCode.FOREIGN_KEY_VIOLATION, message, { cause });
+        this.name = 'ForeignKeyError';
+        this.constraint = constraint;
+        this.table = table;
+    }
+}
+/** Thrown when a NOT NULL constraint is violated (pg code 23502) */
+export class NotNullViolationError extends TurbineError {
+    column;
+    table;
+    constructor(opts = {}) {
+        const { column, table, cause } = opts;
+        let message = opts.message;
+        if (!message) {
+            const columnPart = column ? ` on column "${column}"` : '';
+            message = `[turbine] NOT NULL constraint violation${columnPart}`;
+            const detail = detailFromCause(cause);
+            if (detail)
+                message += `: ${detail}`;
+        }
+        super(TurbineErrorCode.NOT_NULL_VIOLATION, message, { cause });
+        this.name = 'NotNullViolationError';
+        this.column = column;
+        this.table = table;
+    }
+}
+/**
+ * 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
+ *   }
+ * }
+ * ```
+ */
+export 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(TurbineErrorCode.DEADLOCK_DETECTED, message, { cause });
+        this.name = 'DeadlockError';
+        this.constraint = constraint;
+    }
+}
+/**
+ * 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
+ *   }
+ * }
+ * ```
+ */
+export 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(TurbineErrorCode.SERIALIZATION_FAILURE, message, { cause });
+        this.name = 'SerializationFailureError';
+    }
+}
+/** Thrown when a CHECK constraint is violated (pg code 23514) */
+export class CheckConstraintError extends TurbineError {
+    constraint;
+    table;
+    constructor(opts = {}) {
+        const { constraint, table, cause } = opts;
+        let message = opts.message;
+        if (!message) {
+            const constraintPart = constraint ? ` on ${constraint}` : '';
+            message = `[turbine] Check constraint violation${constraintPart}`;
+            const detail = detailFromCause(cause);
+            if (detail)
+                message += `: ${detail}`;
+        }
+        super(TurbineErrorCode.CHECK_VIOLATION, message, { cause });
+        this.name = 'CheckConstraintError';
+        this.constraint = constraint;
+        this.table = table;
+    }
+}
+/**
+ * Parse column names out of a pg `detail` string like:
+ *   "Key (email)=(foo@bar) already exists."
+ *   "Key (col1, col2)=(v1, v2) already exists."
+ */
+function parseColumnsFromDetail(detail) {
+    const m = detail.match(/^Key \(([^)]+)\)/);
+    if (!m)
+        return undefined;
+    return m[1].split(',').map((s) => s.trim());
+}
+/**
+ * Translate a pg driver error into a typed Turbine error.
+ * If the error doesn't match a known constraint code, returns it unchanged.
+ *
+ * Maps:
+ *   23505 (unique_violation)      -> UniqueConstraintError
+ *   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.
+ */
+export function wrapPgError(err) {
+    if (!err || typeof err !== 'object')
+        return err;
+    const e = err;
+    if (!e.code)
+        return err;
+    switch (e.code) {
+        case '23505': {
+            const cols = e.detail ? parseColumnsFromDetail(e.detail) : undefined;
+            return new UniqueConstraintError({
+                constraint: e.constraint,
+                columns: cols,
+                table: e.table,
+                cause: err,
+            });
+        }
+        case '23503':
+            return new ForeignKeyError({
+                constraint: e.constraint,
+                table: e.table,
+                cause: err,
+            });
+        case '23502':
+            return new NotNullViolationError({
+                column: e.column,
+                table: e.table,
+                cause: err,
+            });
+        case '23514':
+            return new CheckConstraintError({
+                constraint: e.constraint,
+                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;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/generate.d.ts

@@ -1,5 +1,5 @@
 /**
- * @batadata/turbine — Code generator
+ * turbine-orm — Code generator
  *
  * Takes an IntrospectedSchema and emits TypeScript files:
  *   - types.ts     — Entity interfaces, Create/Update input types
@@ -21,4 +21,10 @@ export declare function generate(options: GenerateOptions): {
     outDir: string;
     files: string[];
 };
+/**
+ * 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.
+ */
+export declare function generateTypes(schema: SchemaMetadata): string;
 //# sourceMappingURL=generate.d.ts.map

package/dist/generate.js

@@ -1,5 +1,5 @@
 /**
- * @batadata/turbine — Code generator
+ * turbine-orm — Code generator
  *
  * Takes an IntrospectedSchema and emits TypeScript files:
  *   - types.ts     — Entity interfaces, Create/Update input types
@@ -8,9 +8,9 @@
  *
  * Output goes to the specified directory (default: ./generated/turbine/).
  */
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { join, resolve, relative } from 'node:path';
-import { snakeToPascal, singularize, } from './schema.js';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import { singularize, snakeToPascal } from './schema.js';
 /** Get the TypeScript type name for a table (singularized PascalCase) */
 function entityName(tableName) {
     return snakeToPascal(singularize(tableName));
@@ -52,18 +52,41 @@ export function generate(options) {
 function generatedFileHeader() {
     return [
         '/**',
-        ' * Auto-generated by @batadata/turbine — DO NOT EDIT',
+        ' * Auto-generated by turbine-orm — DO NOT EDIT',
         ' *',
         ` * Generated at: ${new Date().toISOString()}`,
-        ' * @see https://batadata.com/docs/turbine',
+        ' * @see https://turbineorm.dev',
         ' */',
         '',
     ];
 }
-function generateTypes(schema) {
-    const lines = [
-        ...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.
+ */
+export 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 = snakeToPascal(enumName);
@@ -105,17 +128,37 @@ 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('');
-        // --- Relation types ---
+        // --- 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);
+                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('');
+            // --- Legacy per-relation interfaces (kept for backward compatibility) ---
             for (const [relName, rel] of Object.entries(table.relations)) {
                 const targetType = entityName(rel.to);
                 if (rel.type === 'hasMany') {
@@ -142,7 +185,7 @@ function generateTypes(schema) {
 function generateMetadata(schema) {
     const lines = [
         ...generatedFileHeader(),
-        "import type { SchemaMetadata } from '@batadata/turbine';",
+        "import type { SchemaMetadata } from 'turbine-orm';",
         '',
         'export const SCHEMA: SchemaMetadata = {',
         '  tables: {',
@@ -215,14 +258,55 @@ function generateIndex(schema) {
     const tableEntries = Object.values(schema.tables);
     const lines = [
         ...generatedFileHeader(),
-        "import { TurbineClient as BaseTurbineClient, QueryInterface } from '@batadata/turbine';",
-        "import type { TurbineConfig } from '@batadata/turbine';",
+        "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
-    const typeImports = tableEntries.map((t) => entityName(t.name));
+    // Import all entity types and relations maps
+    const typeImports = [];
+    for (const t of tableEntries) {
+        typeImports.push(entityName(t.name));
+        if (Object.keys(t.relations).length > 0) {
+            typeImports.push(`${entityName(t.name)}Relations`);
+        }
+    }
     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.');
@@ -246,8 +330,10 @@ function generateIndex(schema) {
     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 */`);
-        lines.push(`  declare readonly ${accessor}: QueryInterface<${typeName}>;`);
+        lines.push(`  declare readonly ${accessor}: QueryInterface<${genericArgs}>;`);
     }
     lines.push('');
     lines.push('  constructor(config?: TurbineConfig) {');
@@ -255,6 +341,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.');
@@ -296,4 +398,32 @@ 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');
+}
 //# sourceMappingURL=generate.js.map