turbine-orm 0.14.0 → 0.15.0

package/dist/cjs/query/builder.js

@@ -11,10 +11,44 @@
  * Schema-driven: all column names, types, and relations come from introspected
  * metadata — nothing is hardcoded.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryInterface = void 0;
 const dialect_js_1 = require("../dialect.js");
 const errors_js_1 = require("../errors.js");
+const nested_write_js_1 = require("../nested-write.js");
 const schema_js_1 = require("../schema.js");
 const utils_js_1 = require("./utils.js");
 // ---------------------------------------------------------------------------
@@ -100,6 +134,28 @@ function findArrayUniqueKey(value) {
     }
     return null;
 }
+/** Known text search operator keys */
+const TEXT_SEARCH_KEYS = new Set(['search', 'config']);
+/** Check if a value is a TextSearchFilter object */
+function isTextSearchFilter(value) {
+    if (value === null ||
+        value === undefined ||
+        typeof value !== 'object' ||
+        Array.isArray(value) ||
+        value instanceof Date) {
+        return false;
+    }
+    const keys = Object.keys(value);
+    // Must have 'search' key and only known text search keys
+    return keys.includes('search') && keys.every((k) => TEXT_SEARCH_KEYS.has(k));
+}
+/**
+ * Validate a text search config name. Only alphanumeric characters and
+ * underscores are allowed to prevent SQL injection via the config parameter.
+ */
+function validateTextSearchConfig(config) {
+    return /^[a-zA-Z0-9_]+$/.test(config);
+}
 // biome-ignore lint/complexity/noBannedTypes: {} means "no relations known" — intentional for untyped table access
 class QueryInterface {
     pool;
@@ -131,6 +187,10 @@ class QueryInterface {
     columnArrayTypeMap;
     /** Tracks tables that have already triggered a deep-with warning (one-time) */
     deepWithWarned = new Set();
+    /** True when this QI runs inside an active transaction (set via _txScoped option). */
+    txScoped;
+    /** Original options reference — forwarded to child QIs in nested writes. */
+    options;
     constructor(pool, table, schema, middlewares, options) {
         this.pool = pool;
         this.table = table;
@@ -149,6 +209,8 @@ class QueryInterface {
         this.preparedStatementsEnabled = options?.preparedStatements ?? true;
         this.sqlCacheEnabled = options?.sqlCache !== false;
         this.dialect = options?.dialect ?? dialect_js_1.postgresDialect;
+        this.txScoped = options?._txScoped ?? false;
+        this.options = options;
         // Pre-compute column type lookup maps (TASK-26)
         this.columnPgTypeMap = new Map();
         this.columnArrayTypeMap = new Map();
@@ -726,6 +788,9 @@ class QueryInterface {
     // -------------------------------------------------------------------------
     async create(args) {
         return this.executeWithMiddleware('create', args, async () => {
+            if ((0, nested_write_js_1.hasRelationFields)(args.data, this.tableMeta)) {
+                return this.nestedCreate(args);
+            }
             const deferred = this.buildCreate(args);
             const result = await this.queryWithTimeout(deferred.sql, deferred.params, args.timeout, deferred.preparedName);
             return deferred.transform(result);
@@ -808,6 +873,9 @@ class QueryInterface {
     // -------------------------------------------------------------------------
     async update(args) {
         return this.executeWithMiddleware('update', args, async () => {
+            if ((0, nested_write_js_1.hasRelationFields)(args.data, this.tableMeta)) {
+                return this.nestedUpdate(args);
+            }
             const deferred = this.buildUpdate(args);
             const result = await this.queryWithTimeout(deferred.sql, deferred.params, args.timeout, deferred.preparedName);
             return deferred.transform(result);
@@ -816,32 +884,62 @@ class QueryInterface {
     buildUpdate(args) {
         const dataObj = args.data;
         const whereObj = args.where;
+        const lock = args.optimisticLock;
         const setFp = this.fingerprintSet(dataObj);
         const whereFp = this.fingerprintWhere(whereObj);
-        const ck = `u:${setFp}|${whereFp}`;
+        const ck = lock ? null : `u:${setFp}|${whereFp}`;
         const params = [];
-        const entry = this.acquireSql(ck, () => {
+        const buildSql = () => {
             const freshParams = [];
             const setEntries = Object.entries(dataObj).filter(([, v]) => v !== undefined);
             const setClauses = setEntries.map(([k, v]) => this.buildSetClause(k, v, freshParams));
+            if (lock) {
+                const versionCol = this.toSqlColumn(lock.field);
+                setClauses.push(`${versionCol} = ${versionCol} + 1`);
+            }
             const whereClause = this.buildWhereClause(whereObj, freshParams);
-            const whereSql = whereClause ? ` WHERE ${whereClause}` : '';
+            let whereSql = whereClause ? ` WHERE ${whereClause}` : '';
+            if (lock) {
+                const versionCol = this.toSqlColumn(lock.field);
+                freshParams.push(lock.expected);
+                const versionCheck = `${versionCol} = ${this.p(freshParams.length)}`;
+                whereSql = whereSql ? `${whereSql} AND ${versionCheck}` : ` WHERE ${versionCheck}`;
+            }
             this.assertMutationHasPredicate('update', whereSql, args.allowFullTableScan);
             return `UPDATE ${this.q(this.table)} SET ${setClauses.join(', ')}${whereSql}${this.dialect.buildReturningClause('*')}`;
-        });
-        // On cache hit, validate predicate
-        if (whereFp === '') {
-            this.assertMutationHasPredicate('update', '', args.allowFullTableScan);
+        };
+        let sql;
+        let preparedName;
+        if (ck) {
+            const entry = this.acquireSql(ck, buildSql);
+            sql = entry.sql;
+            preparedName = entry.name;
+            if (whereFp === '') {
+                this.assertMutationHasPredicate('update', '', args.allowFullTableScan);
+            }
         }
-        // Collect params: SET first, then WHERE (same order as fresh build)
+        else {
+            sql = buildSql();
+        }
+        // Collect params: SET first, then WHERE, then version check (same order as fresh build)
         this.collectSetParams(dataObj, params);
         this.collectWhereParams(whereObj, params);
+        if (lock) {
+            params.push(lock.expected);
+        }
         return {
-            sql: entry.sql,
+            sql,
             params,
             transform: (result) => {
                 const row = result.rows[0];
                 if (!row) {
+                    if (lock) {
+                        throw new errors_js_1.OptimisticLockError({
+                            table: this.table,
+                            versionField: lock.field,
+                            expectedVersion: lock.expected,
+                        });
+                    }
                     throw new errors_js_1.NotFoundError({
                         table: this.table,
                         where: args.where,
@@ -851,7 +949,75 @@ class QueryInterface {
                 return this.parseRow(row, this.table);
             },
             tag: `${this.table}.update`,
-            preparedName: entry.name,
+            preparedName,
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Nested write helpers (shared by create + update)
+    // -------------------------------------------------------------------------
+    async nestedCreate(args) {
+        const data = args.data;
+        if (this.txScoped) {
+            const ctx = this.buildNestedCtx();
+            return (0, nested_write_js_1.executeNestedCreate)(ctx, this.table, data);
+        }
+        return this.runInImplicitTx(async (ctx) => {
+            const result = await (0, nested_write_js_1.executeNestedCreate)(ctx, this.table, data);
+            return result;
+        });
+    }
+    async nestedUpdate(args) {
+        const data = args.data;
+        const where = args.where;
+        if (this.txScoped) {
+            const ctx = this.buildNestedCtx();
+            return (0, nested_write_js_1.executeNestedUpdate)(ctx, this.table, where, data);
+        }
+        return this.runInImplicitTx(async (ctx) => {
+            const result = await (0, nested_write_js_1.executeNestedUpdate)(ctx, this.table, where, data);
+            return result;
+        });
+    }
+    async runInImplicitTx(fn) {
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            const { TransactionClient } = await Promise.resolve().then(() => __importStar(require('../client.js')));
+            // biome-ignore lint/suspicious/noExplicitAny: MiddlewareFn and Middleware are structurally identical
+            const tx = new TransactionClient(client, this.schema, this.middlewares, this.options);
+            // biome-ignore lint/suspicious/noExplicitAny: TransactionClient satisfies NestedWriteContext['tx'] at runtime
+            const ctx = { schema: this.schema, tx: tx };
+            const result = await fn(ctx);
+            await client.query('COMMIT');
+            return result;
+        }
+        catch (err) {
+            try {
+                await client.query('ROLLBACK');
+            }
+            catch {
+                // Best-effort rollback — connection may have died.
+            }
+            throw err;
+        }
+        finally {
+            client.release();
+        }
+    }
+    buildNestedCtx() {
+        const pool = this.pool;
+        const schema = this.schema;
+        const middlewares = this.middlewares;
+        const opts = { ...this.options, _txScoped: true };
+        return {
+            schema,
+            tx: this.makeTxProxy(pool, schema, middlewares, opts),
+        };
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: bridges MiddlewareFn[] ↔ Middleware[] and QI ↔ NestedWriteContext type gap
+    makeTxProxy(pool, schema, middlewares, opts) {
+        return {
+            table: (name) => new QueryInterface(pool, name, schema, middlewares, opts),
         };
     }
     // -------------------------------------------------------------------------
@@ -1541,6 +1707,12 @@ class QueryInterface {
                 parts.push(`${key}:arr(${this.fingerprintArrayFilter(value)})`);
                 continue;
             }
+            // Text search filter
+            if (typeof value === 'object' && !Array.isArray(value) && isTextSearchFilter(value)) {
+                const cfg = value.config ?? 'english';
+                parts.push(`${key}:fts(${cfg})`);
+                continue;
+            }
             // Plain equality
             parts.push(`${key}:eq`);
         }
@@ -1656,6 +1828,11 @@ class QueryInterface {
                     continue;
                 }
             }
+            // Text search filter
+            if (typeof value === 'object' && !Array.isArray(value) && isTextSearchFilter(value)) {
+                params.push(value.search);
+                continue;
+            }
             // Operator objects
             if (isWhereOperator(value)) {
                 this.collectOperatorParams(value, params);
@@ -2030,6 +2207,12 @@ class QueryInterface {
                         `(actual type: ${colType}); cannot apply array operator '${arrayKey}'.`);
                 }
             }
+            // Handle full-text search filter
+            if (typeof value === 'object' && !Array.isArray(value) && isTextSearchFilter(value)) {
+                const tsClause = this.buildTextSearchClause(column, value, params);
+                andClauses.push(tsClause);
+                continue;
+            }
             // Handle operator objects
             if (isWhereOperator(value)) {
                 const opClauses = this.buildOperatorClauses(column, value, params);
@@ -2672,6 +2855,18 @@ class QueryInterface {
         }
         return clauses;
     }
+    /**
+     * Build SQL clause for full-text search using to_tsvector @@ to_tsquery.
+     * The config name is validated to prevent injection (only alphanumeric + underscore).
+     */
+    buildTextSearchClause(column, filter, params) {
+        const config = filter.config ?? 'english';
+        if (!validateTextSearchConfig(config)) {
+            throw new errors_js_1.ValidationError(`[turbine] Invalid text search config "${config}": only alphanumeric characters and underscores are allowed.`);
+        }
+        params.push(filter.search);
+        return `to_tsvector('${config}', ${column}) @@ to_tsquery('${config}', ${this.p(params.length)})`;
+    }
     /**
      * Get the Postgres array type for a column (used by UNNEST in createMany).
      * Uses pre-computed Map for O(1) lookup instead of linear scan.

package/dist/cli/studio.d.ts

@@ -45,8 +45,16 @@ export interface StudioContext {
     options: StudioOptions;
     authToken: string;
     stateDir: string;
-    /** Resolved statement timeout SQL string (adapter-aware). */
-    statementTimeoutSQL: string;
+    /** Resolved statement timeout (adapter-aware) — parameterized SQL + values. */
+    statementTimeout: {
+        sql: string;
+        params: unknown[];
+    };
+    /** Rate limiter state — tracks requests per authenticated session. */
+    rateLimiter: Map<string, {
+        count: number;
+        resetAt: number;
+    }>;
 }
 /**
  * Start the Studio server. Returns a handle with the session token, a pre-built

package/dist/cli/studio.js

@@ -59,8 +59,12 @@ export async function startStudio(options) {
     });
     const authToken = randomBytes(24).toString('hex');
     const stateDir = pathResolve(options.stateDir ?? '.turbine');
-    const statementTimeoutSQL = options.adapter?.statementTimeout?.(30) ?? `SET LOCAL statement_timeout = '30s'`;
-    const ctx = { pool, metadata, options, authToken, stateDir, statementTimeoutSQL };
+    const statementTimeout = options.adapter?.statementTimeout?.(30) ?? {
+        sql: `SET LOCAL statement_timeout = $1`,
+        params: ['30s'],
+    };
+    const rateLimiter = new Map();
+    const ctx = { pool, metadata, options, authToken, stateDir, statementTimeout, rateLimiter };
     const server = createServer((req, res) => {
         handleRequest(req, res, ctx).catch((err) => {
             sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
@@ -137,6 +141,14 @@ async function handleRequest(req, res, ctx) {
         sendJson(res, 401, { error: 'unauthorized — use the URL printed in the terminal' });
         return;
     }
+    // Rate limiting — 100 requests per 60 seconds per authenticated session.
+    const rateLimitResult = checkRateLimit(ctx.rateLimiter, ctx.authToken);
+    if (!rateLimitResult.allowed) {
+        const retryAfter = Math.ceil((rateLimitResult.resetAt - Date.now()) / 1000);
+        res.setHeader('Retry-After', String(retryAfter));
+        sendJson(res, 429, { error: 'Rate limit exceeded', retryAfter });
+        return;
+    }
     if (pathname === '/api/schema' && req.method === 'GET') {
         return apiSchema(res, ctx);
     }
@@ -177,6 +189,26 @@ function isAuthorized(req, expectedToken) {
     }
     return false;
 }
+// ---------------------------------------------------------------------------
+// Rate limiting
+// ---------------------------------------------------------------------------
+const RATE_LIMIT_WINDOW_MS = 60_000; // 60 seconds
+const RATE_LIMIT_MAX_REQUESTS = 100;
+function checkRateLimit(limiter, token) {
+    const now = Date.now();
+    const entry = limiter.get(token);
+    if (!entry || now >= entry.resetAt) {
+        // Start a new window
+        const resetAt = now + RATE_LIMIT_WINDOW_MS;
+        limiter.set(token, { count: 1, resetAt });
+        return { allowed: true, resetAt };
+    }
+    entry.count++;
+    if (entry.count > RATE_LIMIT_MAX_REQUESTS) {
+        return { allowed: false, resetAt: entry.resetAt };
+    }
+    return { allowed: true, resetAt: entry.resetAt };
+}
 function constantTimeEqual(a, b) {
     if (a.length !== b.length)
         return false;
@@ -262,7 +294,7 @@ export async function apiTableRows(res, ctx, rawTableName, params) {
     let mainWhere = '';
     if (hasSearch && pattern !== null) {
         mainValues.push(pattern);
-        const conds = textColumns.map((c) => `${quoteIdent(c)} ILIKE $3`);
+        const conds = textColumns.map((c) => `${quoteIdent(c)} ILIKE $3 ESCAPE '\\'`);
         mainWhere = `WHERE (${conds.join(' OR ')})`;
     }
     // Count query: $1 = pattern (if search)
@@ -270,7 +302,7 @@ export async function apiTableRows(res, ctx, rawTableName, params) {
     let countWhere = '';
     if (hasSearch && pattern !== null) {
         countValues.push(pattern);
-        const conds = textColumns.map((c) => `${quoteIdent(c)} ILIKE $1`);
+        const conds = textColumns.map((c) => `${quoteIdent(c)} ILIKE $1 ESCAPE '\\'`);
         countWhere = `WHERE (${conds.join(' OR ')})`;
     }
     const qualifiedTable = `${quoteIdent(ctx.options.schema)}.${quoteIdent(table.name)}`;
@@ -279,7 +311,7 @@ export async function apiTableRows(res, ctx, rawTableName, params) {
     const client = await ctx.pool.connect();
     try {
         await client.query('BEGIN READ ONLY');
-        await client.query(ctx.statementTimeoutSQL);
+        await client.query(ctx.statementTimeout.sql, ctx.statementTimeout.params);
         const result = await client.query(sql, mainValues);
         const countResult = await client.query(countSql, countValues);
         await client.query('COMMIT');
@@ -336,6 +368,10 @@ async function apiQuery(req, res, ctx) {
         sendJson(res, 400, { error: 'missing sql' });
         return;
     }
+    if (rawSql.length > 10_000) {
+        sendJson(res, 400, { error: 'query too long — maximum 10,000 characters allowed' });
+        return;
+    }
     if (!isReadOnlyStatement(rawSql)) {
         sendJson(res, 400, {
             error: 'only SELECT / WITH statements are allowed in Studio — use the CLI for writes',
@@ -345,7 +381,7 @@ async function apiQuery(req, res, ctx) {
     const client = await ctx.pool.connect();
     try {
         await client.query('BEGIN READ ONLY');
-        await client.query(ctx.statementTimeoutSQL);
+        await client.query(ctx.statementTimeout.sql, ctx.statementTimeout.params);
         const started = Date.now();
         const result = await client.query(rawSql);
         const elapsedMs = Date.now() - started;
@@ -397,7 +433,7 @@ export async function apiBuilder(req, res, ctx) {
     const client = await ctx.pool.connect();
     try {
         await client.query('BEGIN READ ONLY');
-        await client.query(ctx.statementTimeoutSQL);
+        await client.query(ctx.statementTimeout.sql, ctx.statementTimeout.params);
         const started = Date.now();
         const result = await client.query(deferred.sql, deferred.params);
         const elapsedMs = Date.now() - started;
@@ -593,6 +629,7 @@ function sendJson(res, status, body) {
         'Cache-Control': 'no-store',
         'X-Content-Type-Options': 'nosniff',
         'Referrer-Policy': 'no-referrer',
+        'Content-Security-Policy': "default-src 'none'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self'; font-src 'self'; frame-ancestors 'none'",
     });
     res.end(payload);
 }
@@ -611,6 +648,7 @@ function sendHtml(res, status, body) {
         'X-Content-Type-Options': 'nosniff',
         'X-Frame-Options': 'DENY',
         'Referrer-Policy': 'no-referrer',
+        'Content-Security-Policy': "default-src 'none'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self'; font-src 'self'; frame-ancestors 'none'",
     });
     res.end(body);
 }

package/dist/client.d.ts

@@ -27,6 +27,13 @@ import { type ErrorMessageMode } from './errors.js';
 import { type PipelineOptions, type PipelineResults } from './pipeline.js';
 import { type DeferredQuery, QueryInterface, type QueryInterfaceOptions } from './query/index.js';
 import type { SchemaMetadata } from './schema.js';
+export interface RetryOptions {
+    maxAttempts?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    onRetry?: (error: unknown, attempt: number) => void;
+}
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
 /**
  * Minimal pg-compatible query result.
  * `pg.Pool`, `@neondatabase/serverless` Pool, `@vercel/postgres` Pool and
@@ -316,6 +323,22 @@ export declare class TurbineClient {
      * ```
      */
     $transaction<R>(fn: (tx: TransactionClient) => Promise<R>, options?: TransactionOptions): Promise<R>;
+    /**
+     * Execute an async function with automatic retry on retryable errors.
+     *
+     * Only errors with `isRetryable === true` (DeadlockError, SerializationFailureError)
+     * are retried. Uses exponential backoff with jitter.
+     *
+     * @example
+     * ```ts
+     * const result = await db.$retry(() =>
+     *   db.$transaction(async (tx) => {
+     *     // ... serializable transaction logic
+     *   }, { isolationLevel: 'Serializable' })
+     * );
+     * ```
+     */
+    $retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
     /**
      * Test the database connection.
      * Throws if the connection fails.

package/dist/client.js

@@ -25,6 +25,30 @@ import pg from 'pg';
 import { setErrorMessageMode, TimeoutError, wrapPgError } from './errors.js';
 import { executePipeline, pipelineSupported } from './pipeline.js';
 import { QueryInterface } from './query/index.js';
+export async function withRetry(fn, options) {
+    const maxAttempts = options?.maxAttempts ?? 3;
+    const baseDelay = options?.baseDelay ?? 50;
+    const maxDelay = options?.maxDelay ?? 5000;
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastError = err;
+            const isRetryable = err &&
+                typeof err === 'object' &&
+                'isRetryable' in err &&
+                err.isRetryable === true;
+            if (!isRetryable || attempt === maxAttempts - 1)
+                throw err;
+            options?.onRetry?.(err, attempt + 1);
+            const delay = Math.min(baseDelay * 2 ** attempt + Math.random() * baseDelay, maxDelay);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+    throw lastError;
+}
 /** Maps isolation level names to SQL */
 const ISOLATION_LEVELS = {
     ReadUncommitted: 'READ UNCOMMITTED',
@@ -73,7 +97,8 @@ export class TransactionClient {
             // Create a QueryInterface that uses the transaction client as its "pool"
             // We use a proxy pool that routes queries through the transaction client
             const txPool = this.createTxPool();
-            qi = new QueryInterface(txPool, name, this.schema, this.middlewares, this.queryOptions);
+            const txOpts = { ...this.queryOptions, _txScoped: true };
+            qi = new QueryInterface(txPool, name, this.schema, this.middlewares, txOpts);
             this.tableCache.set(name, qi);
         }
         return qi;
@@ -535,6 +560,27 @@ export class TurbineClient {
         }
     }
     // -------------------------------------------------------------------------
+    // Retry — automatic retry for retryable errors (deadlock, serialization)
+    // -------------------------------------------------------------------------
+    /**
+     * Execute an async function with automatic retry on retryable errors.
+     *
+     * Only errors with `isRetryable === true` (DeadlockError, SerializationFailureError)
+     * are retried. Uses exponential backoff with jitter.
+     *
+     * @example
+     * ```ts
+     * const result = await db.$retry(() =>
+     *   db.$transaction(async (tx) => {
+     *     // ... serializable transaction logic
+     *   }, { isolationLevel: 'Serializable' })
+     * );
+     * ```
+     */
+    async $retry(fn, options) {
+        return withRetry(fn, options);
+    }
+    // -------------------------------------------------------------------------
     // Connection lifecycle
     // -------------------------------------------------------------------------
     /**

package/dist/errors.d.ts

@@ -20,6 +20,8 @@ export declare const TurbineErrorCode: {
     readonly DEADLOCK_DETECTED: "TURBINE_E012";
     readonly SERIALIZATION_FAILURE: "TURBINE_E013";
     readonly PIPELINE: "TURBINE_E014";
+    readonly OPTIMISTIC_LOCK: "TURBINE_E015";
+    readonly EXCLUSION_VIOLATION: "TURBINE_E016";
 };
 export type TurbineErrorCode = (typeof TurbineErrorCode)[keyof typeof TurbineErrorCode];
 /** Base error class for all Turbine errors */
@@ -208,6 +210,16 @@ export declare class CheckConstraintError extends TurbineError {
         cause?: unknown;
     });
 }
+export declare class ExclusionConstraintError extends TurbineError {
+    readonly constraint?: string;
+    readonly table?: string;
+    constructor(opts?: {
+        constraint?: string;
+        table?: string;
+        message?: string;
+        cause?: unknown;
+    });
+}
 /** Result slot for a single query in a non-transactional pipeline */
 export type PipelineResultSlot = {
     status: 'ok';
@@ -251,6 +263,16 @@ export declare class PipelineError extends TurbineError {
         cause?: unknown;
     });
 }
+export declare class OptimisticLockError extends TurbineError {
+    readonly table: string;
+    readonly versionField: string;
+    readonly expectedVersion: unknown;
+    constructor(opts: {
+        table: string;
+        versionField: string;
+        expectedVersion: unknown;
+    });
+}
 /**
  * Translate a pg driver error into a typed Turbine error.
  * If the error doesn't match a known constraint code, returns it unchanged.
@@ -260,6 +282,7 @@ export declare class PipelineError extends TurbineError {
  *   23503 (foreign_key_violation) -> ForeignKeyError
  *   23502 (not_null_violation)    -> NotNullViolationError
  *   23514 (check_violation)       -> CheckConstraintError
+ *   23P01 (exclusion_violation)   -> ExclusionConstraintError
  *   40P01 (deadlock_detected)     -> DeadlockError       (retryable)
  *   40001 (serialization_failure) -> SerializationFailureError (retryable)
  *