turbine-orm 0.14.0 → 0.16.0

package/dist/cjs/cli/studio.js

@@ -74,8 +74,12 @@ async function startStudio(options) {
     });
     const authToken = (0, node_crypto_1.randomBytes)(24).toString('hex');
     const stateDir = (0, node_path_1.resolve)(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 = (0, node_http_1.createServer)((req, res) => {
         handleRequest(req, res, ctx).catch((err) => {
             sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
@@ -152,6 +156,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);
     }
@@ -192,6 +204,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;
@@ -277,7 +309,7 @@ async function apiTableRows(res, ctx, rawTableName, params) {
     let mainWhere = '';
     if (hasSearch && pattern !== null) {
         mainValues.push(pattern);
-        const conds = textColumns.map((c) => `${(0, index_js_1.quoteIdent)(c)} ILIKE $3`);
+        const conds = textColumns.map((c) => `${(0, index_js_1.quoteIdent)(c)} ILIKE $3 ESCAPE '\\'`);
         mainWhere = `WHERE (${conds.join(' OR ')})`;
     }
     // Count query: $1 = pattern (if search)
@@ -285,7 +317,7 @@ async function apiTableRows(res, ctx, rawTableName, params) {
     let countWhere = '';
     if (hasSearch && pattern !== null) {
         countValues.push(pattern);
-        const conds = textColumns.map((c) => `${(0, index_js_1.quoteIdent)(c)} ILIKE $1`);
+        const conds = textColumns.map((c) => `${(0, index_js_1.quoteIdent)(c)} ILIKE $1 ESCAPE '\\'`);
         countWhere = `WHERE (${conds.join(' OR ')})`;
     }
     const qualifiedTable = `${(0, index_js_1.quoteIdent)(ctx.options.schema)}.${(0, index_js_1.quoteIdent)(table.name)}`;
@@ -294,7 +326,7 @@ 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');
@@ -351,6 +383,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',
@@ -360,7 +396,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;
@@ -412,7 +448,7 @@ 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;
@@ -608,6 +644,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);
 }
@@ -626,6 +663,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/cjs/client.js

@@ -27,10 +27,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurbineClient = exports.TransactionClient = void 0;
+exports.withRetry = withRetry;
 const pg_1 = __importDefault(require("pg"));
 const errors_js_1 = require("./errors.js");
+const observe_js_1 = require("./observe.js");
 const pipeline_js_1 = require("./pipeline.js");
 const index_js_1 = require("./query/index.js");
+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',
@@ -79,7 +105,8 @@ 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 index_js_1.QueryInterface(txPool, name, this.schema, this.middlewares, this.queryOptions);
+            const txOpts = { ...this.queryOptions, _txScoped: true };
+            qi = new index_js_1.QueryInterface(txPool, name, this.schema, this.middlewares, txOpts);
             this.tableCache.set(name, qi);
         }
         return qi;
@@ -165,7 +192,9 @@ class TurbineClient {
     logging;
     tableCache = new Map();
     middlewares = [];
+    queryListeners = new Set();
     queryOptions;
+    errorMessagesSafe;
     /** True when Turbine created the pool and is responsible for tearing it down */
     ownsPool = true;
     constructor(config = {}, schema) {
@@ -199,12 +228,27 @@ class TurbineClient {
         this.schema = schema;
         // Respect env var kill switch
         const envDisablePrepared = typeof process !== 'undefined' && process.env?.TURBINE_DISABLE_PREPARED === '1';
+        this.errorMessagesSafe = (config.errorMessages ?? 'safe') === 'safe';
         this.queryOptions = {
             defaultLimit: config.defaultLimit,
             warnOnUnlimited: config.warnOnUnlimited,
             preparedStatements: envDisablePrepared ? false : (config.preparedStatements ?? !config.pool),
             sqlCache: config.sqlCache ?? true,
             dialect: config.dialect,
+            _onQuery: (event) => {
+                if (this.queryListeners.size === 0)
+                    return;
+                const emitted = this.errorMessagesSafe ? { ...event, params: event.params.map(() => '[REDACTED]') } : event;
+                for (const listener of this.queryListeners) {
+                    try {
+                        listener(emitted);
+                    }
+                    catch (e) {
+                        if (this.logging)
+                            console.error('[turbine] Query listener error:', e);
+                    }
+                }
+            },
         };
         // Apply NotFoundError message redaction mode (default: safe — values are
         // stripped from messages to avoid leaking PII into error logs).
@@ -257,6 +301,11 @@ class TurbineClient {
                 });
             }
         }
+        // Auto-start observability from env var
+        const observeUrl = typeof process !== 'undefined' ? process.env?.TURBINE_OBSERVE_URL : undefined;
+        if (observeUrl) {
+            this.$observe({ connectionString: observeUrl }).catch(() => { });
+        }
     }
     // -------------------------------------------------------------------------
     // Middleware — intercept all queries
@@ -298,6 +347,37 @@ class TurbineClient {
         this.tableCache.clear();
     }
     // -------------------------------------------------------------------------
+    // Event emitter — subscribe to query lifecycle events
+    // -------------------------------------------------------------------------
+    $on(_event, listener) {
+        this.queryListeners.add(listener);
+    }
+    $off(_event, listener) {
+        this.queryListeners.delete(listener);
+    }
+    // -------------------------------------------------------------------------
+    // Observability — automatic metrics collection
+    // -------------------------------------------------------------------------
+    observeEngine;
+    async $observe(config) {
+        if (this.observeEngine) {
+            await this.observeEngine.stop();
+            this.$off('query', this.observeEngine.getListener());
+        }
+        const engine = new observe_js_1.ObserveEngine(config);
+        this.observeEngine = engine;
+        await engine.init();
+        this.$on('query', engine.getListener());
+        return {
+            stop: async () => {
+                this.$off('query', engine.getListener());
+                await engine.stop();
+                if (this.observeEngine === engine)
+                    this.observeEngine = undefined;
+            },
+        };
+    }
+    // -------------------------------------------------------------------------
     // Table accessor — creates QueryInterface for any table
     // -------------------------------------------------------------------------
     /**
@@ -542,6 +622,27 @@ 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/cjs/errors.js

@@ -6,7 +6,7 @@
  * All Turbine errors extend TurbineError which includes a `code` property.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-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.OptimisticLockError = exports.PipelineError = exports.ExclusionConstraintError = 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;
@@ -26,6 +26,8 @@ exports.TurbineErrorCode = {
     DEADLOCK_DETECTED: 'TURBINE_E012',
     SERIALIZATION_FAILURE: 'TURBINE_E013',
     PIPELINE: 'TURBINE_E014',
+    OPTIMISTIC_LOCK: 'TURBINE_E015',
+    EXCLUSION_VIOLATION: 'TURBINE_E016',
 };
 /** Base error class for all Turbine errors */
 class TurbineError extends Error {
@@ -351,6 +353,26 @@ class CheckConstraintError extends TurbineError {
     }
 }
 exports.CheckConstraintError = CheckConstraintError;
+class ExclusionConstraintError extends TurbineError {
+    constraint;
+    table;
+    constructor(opts = {}) {
+        const { constraint, table, cause } = opts;
+        let message = opts.message;
+        if (!message) {
+            const constraintPart = constraint ? ` on ${constraint}` : '';
+            message = `[turbine] Exclusion constraint violation${constraintPart}`;
+            const detail = detailFromCause(cause);
+            if (detail)
+                message += `: ${detail}`;
+        }
+        super(exports.TurbineErrorCode.EXCLUSION_VIOLATION, message, { cause });
+        this.name = 'ExclusionConstraintError';
+        this.constraint = constraint;
+        this.table = table;
+    }
+}
+exports.ExclusionConstraintError = ExclusionConstraintError;
 /**
  * Thrown when a non-transactional pipeline has partial failures.
  *
@@ -392,6 +414,20 @@ class PipelineError extends TurbineError {
     }
 }
 exports.PipelineError = PipelineError;
+class OptimisticLockError extends TurbineError {
+    table;
+    versionField;
+    expectedVersion;
+    constructor(opts) {
+        super(exports.TurbineErrorCode.OPTIMISTIC_LOCK, `[turbine] Optimistic lock failed on "${opts.table}" — ` +
+            `expected ${opts.versionField} = ${opts.expectedVersion} but row was modified by another transaction`);
+        this.name = 'OptimisticLockError';
+        this.table = opts.table;
+        this.versionField = opts.versionField;
+        this.expectedVersion = opts.expectedVersion;
+    }
+}
+exports.OptimisticLockError = OptimisticLockError;
 /**
  * Parse column names out of a pg `detail` string like:
  *   "Key (email)=(foo@bar) already exists."
@@ -412,6 +448,7 @@ function parseColumnsFromDetail(detail) {
  *   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)
  *
@@ -451,6 +488,12 @@ function wrapPgError(err) {
                 table: e.table,
                 cause: err,
             });
+        case '23P01':
+            return new ExclusionConstraintError({
+                constraint: e.constraint,
+                table: e.table,
+                cause: err,
+            });
         case '40P01':
             return new DeadlockError({
                 constraint: e.constraint,

package/dist/cjs/generate.js

@@ -181,6 +181,92 @@ function generateTypes(schema) {
             }
         }
     }
+    // ---------------------------------------------------------------------------
+    // Nested write types (WhereUnique, NestedCreateInput, NestedUpdateInput,
+    // ConnectOrCreate, CreateInput, UpdateInput)
+    // ---------------------------------------------------------------------------
+    for (const table of Object.values(schema.tables)) {
+        const typeName = entityName(table.name);
+        const hasRels = Object.keys(table.relations).length > 0;
+        // WhereUnique — union of unique constraint shapes, deduplicating PK
+        const seen = new Set();
+        const uniqueSets = [];
+        // Always include the primary key first
+        const pkKey = table.primaryKey.join(',');
+        seen.add(pkKey);
+        uniqueSets.push(table.primaryKey);
+        // Add unique indexes that aren't duplicates of the PK
+        for (const uc of table.uniqueColumns) {
+            const ucKey = uc.join(',');
+            if (!seen.has(ucKey)) {
+                seen.add(ucKey);
+                uniqueSets.push(uc);
+            }
+        }
+        if (uniqueSets.length > 0) {
+            const branches = uniqueSets.map((cols) => {
+                const fields = cols.map((colName) => {
+                    const col = table.columns.find((c) => c.name === colName);
+                    const field = col?.field ?? colName;
+                    const tsType = col?.tsType ?? 'unknown';
+                    return `${field}: ${tsType}`;
+                });
+                return `{ ${fields.join('; ')} }`;
+            });
+            lines.push(`export type ${typeName}WhereUnique = ${branches.join(' | ')};`);
+            lines.push('');
+        }
+        // CreateInput / UpdateInput — extends base type with optional relation fields
+        if (hasRels) {
+            lines.push(`export type ${typeName}CreateInput = ${typeName}Create & {`);
+            for (const [relName, rel] of Object.entries(table.relations)) {
+                const targetType = entityName(rel.to);
+                lines.push(`  ${relName}?: ${targetType}NestedCreateInput;`);
+            }
+            lines.push('};');
+            lines.push('');
+            lines.push(`export type ${typeName}UpdateInput = ${typeName}Update & {`);
+            for (const [relName, rel] of Object.entries(table.relations)) {
+                const targetType = entityName(rel.to);
+                if (rel.type === 'hasMany') {
+                    lines.push(`  ${relName}?: ${targetType}NestedUpdateInput;`);
+                }
+                else {
+                    lines.push(`  ${relName}?: ${targetType}NestedCreateInput;`);
+                }
+            }
+            lines.push('};');
+            lines.push('');
+        }
+    }
+    // Emit NestedCreateInput, NestedUpdateInput, ConnectOrCreate for every table
+    for (const table of Object.values(schema.tables)) {
+        const typeName = entityName(table.name);
+        const hasRels = Object.keys(table.relations).length > 0;
+        // NestedCreateInput uses *CreateInput (which includes relation fields) when
+        // the table has relations, otherwise falls back to the plain *Create type.
+        const createRefType = hasRels ? `${typeName}CreateInput` : `${typeName}Create`;
+        lines.push(`export interface ${typeName}NestedCreateInput {`);
+        lines.push(`  create?: ${createRefType} | ${createRefType}[];`);
+        lines.push(`  connect?: ${typeName}WhereUnique | ${typeName}WhereUnique[];`);
+        lines.push(`  connectOrCreate?: ${typeName}ConnectOrCreate | ${typeName}ConnectOrCreate[];`);
+        lines.push('}');
+        lines.push('');
+        lines.push(`export interface ${typeName}NestedUpdateInput {`);
+        lines.push(`  create?: ${createRefType} | ${createRefType}[];`);
+        lines.push(`  connect?: ${typeName}WhereUnique | ${typeName}WhereUnique[];`);
+        lines.push(`  connectOrCreate?: ${typeName}ConnectOrCreate | ${typeName}ConnectOrCreate[];`);
+        lines.push(`  disconnect?: ${typeName}WhereUnique | ${typeName}WhereUnique[];`);
+        lines.push(`  set?: ${typeName}WhereUnique[];`);
+        lines.push(`  delete?: ${typeName}WhereUnique | ${typeName}WhereUnique[];`);
+        lines.push('}');
+        lines.push('');
+        lines.push(`export interface ${typeName}ConnectOrCreate {`);
+        lines.push(`  where: ${typeName}WhereUnique;`);
+        lines.push(`  create: ${createRefType};`);
+        lines.push('}');
+        lines.push('');
+    }
     return lines.join('\n');
 }
 // ---------------------------------------------------------------------------

package/dist/cjs/index.js

@@ -34,7 +34,8 @@
  * ```
  */
 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.normalizeKeyColumns = 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.postgresDialect = exports.TurbineClient = exports.TransactionClient = exports.yugabytedb = exports.timescale = exports.postgresql = exports.cockroachdb = exports.alloydb = void 0;
+exports.table = exports.defineSchema = exports.column = exports.ColumnBuilder = exports.snakeToPascal = exports.snakeToCamel = exports.singularize = exports.pgTypeToTs = exports.pgArrayType = exports.normalizeKeyColumns = exports.isDateType = exports.camelToSnake = exports.QueryInterface = exports.pipelineSupported = exports.executePipeline = exports.hasRelationFields = exports.executeNestedUpdate = exports.executeNestedCreate = 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.OptimisticLockError = exports.NotNullViolationError = exports.NotFoundError = exports.MigrationError = exports.getErrorMessageMode = exports.ForeignKeyError = exports.ExclusionConstraintError = exports.DeadlockError = exports.ConnectionError = exports.CircularRelationError = exports.CheckConstraintError = exports.postgresDialect = exports.withRetry = exports.TurbineClient = exports.TransactionClient = exports.yugabytedb = exports.timescale = exports.postgresql = exports.cockroachdb = exports.alloydb = void 0;
+exports.turbineHttp = exports.schemaToSQLString = exports.schemaToSQL = exports.schemaPush = exports.schemaDiff = void 0;
 var index_js_1 = require("./adapters/index.js");
 Object.defineProperty(exports, "alloydb", { enumerable: true, get: function () { return index_js_1.alloydb; } });
 Object.defineProperty(exports, "cockroachdb", { enumerable: true, get: function () { return index_js_1.cockroachdb; } });
@@ -45,6 +46,7 @@ Object.defineProperty(exports, "yugabytedb", { enumerable: true, get: function (
 var client_js_1 = require("./client.js");
 Object.defineProperty(exports, "TransactionClient", { enumerable: true, get: function () { return client_js_1.TransactionClient; } });
 Object.defineProperty(exports, "TurbineClient", { enumerable: true, get: function () { return client_js_1.TurbineClient; } });
+Object.defineProperty(exports, "withRetry", { enumerable: true, get: function () { return client_js_1.withRetry; } });
 var dialect_js_1 = require("./dialect.js");
 Object.defineProperty(exports, "postgresDialect", { enumerable: true, get: function () { return dialect_js_1.postgresDialect; } });
 // Error types
@@ -53,11 +55,13 @@ Object.defineProperty(exports, "CheckConstraintError", { enumerable: true, get:
 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, "ExclusionConstraintError", { enumerable: true, get: function () { return errors_js_1.ExclusionConstraintError; } });
 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, "OptimisticLockError", { enumerable: true, get: function () { return errors_js_1.OptimisticLockError; } });
 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; } });
@@ -74,6 +78,11 @@ Object.defineProperty(exports, "generate", { enumerable: true, get: function ()
 // Introspection
 var introspect_js_1 = require("./introspect.js");
 Object.defineProperty(exports, "introspect", { enumerable: true, get: function () { return introspect_js_1.introspect; } });
+// Nested writes
+var nested_write_js_1 = require("./nested-write.js");
+Object.defineProperty(exports, "executeNestedCreate", { enumerable: true, get: function () { return nested_write_js_1.executeNestedCreate; } });
+Object.defineProperty(exports, "executeNestedUpdate", { enumerable: true, get: function () { return nested_write_js_1.executeNestedUpdate; } });
+Object.defineProperty(exports, "hasRelationFields", { enumerable: true, get: function () { return nested_write_js_1.hasRelationFields; } });
 // Pipeline
 var pipeline_js_1 = require("./pipeline.js");
 Object.defineProperty(exports, "executePipeline", { enumerable: true, get: function () { return pipeline_js_1.executePipeline; } });