turbine-orm 0.14.0 → 0.16.0

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

@@ -24,9 +24,17 @@
 import pg from 'pg';
 import type { Dialect } from './dialect.js';
 import { type ErrorMessageMode } from './errors.js';
+import { type ObserveConfig, type ObserveHandle } from './observe.js';
 import { type PipelineOptions, type PipelineResults } from './pipeline.js';
-import { type DeferredQuery, QueryInterface, type QueryInterfaceOptions } from './query/index.js';
+import { type DeferredQuery, type QueryEventListener, 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
@@ -212,7 +220,9 @@ export declare class TurbineClient {
     private readonly logging;
     private readonly tableCache;
     private readonly middlewares;
-    private readonly queryOptions;
+    private readonly queryListeners;
+    private queryOptions;
+    private readonly errorMessagesSafe;
     /** True when Turbine created the pool and is responsible for tearing it down */
     private readonly ownsPool;
     constructor(config: TurbineConfig | undefined, schema: SchemaMetadata);
@@ -248,6 +258,10 @@ export declare class TurbineClient {
      * ```
      */
     $use(middleware: Middleware): void;
+    $on(_event: 'query', listener: QueryEventListener): void;
+    $off(_event: 'query', listener: QueryEventListener): void;
+    private observeEngine?;
+    $observe(config: ObserveConfig): Promise<ObserveHandle>;
     /**
      * Get a QueryInterface for a table.
      * Results are cached — calling `table('users')` twice returns the same instance.
@@ -316,6 +330,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

@@ -23,8 +23,33 @@
  */
 import pg from 'pg';
 import { setErrorMessageMode, TimeoutError, wrapPgError } from './errors.js';
+import { ObserveEngine } from './observe.js';
 import { executePipeline, pipelineSupported } from './pipeline.js';
-import { QueryInterface } from './query/index.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 +98,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;
@@ -158,7 +184,9 @@ export 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) {
@@ -192,12 +220,27 @@ export 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).
@@ -250,6 +293,11 @@ export 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
@@ -291,6 +339,37 @@ export 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 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
     // -------------------------------------------------------------------------
     /**
@@ -535,6 +614,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)
  *

package/dist/errors.js

@@ -20,6 +20,8 @@ export const 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 */
 export class TurbineError extends Error {
@@ -331,6 +333,25 @@ export class CheckConstraintError extends TurbineError {
         this.table = table;
     }
 }
+export 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(TurbineErrorCode.EXCLUSION_VIOLATION, message, { cause });
+        this.name = 'ExclusionConstraintError';
+        this.constraint = constraint;
+        this.table = table;
+    }
+}
 /**
  * Thrown when a non-transactional pipeline has partial failures.
  *
@@ -371,6 +392,19 @@ export class PipelineError extends TurbineError {
         this.failedTag = failedTag;
     }
 }
+export class OptimisticLockError extends TurbineError {
+    table;
+    versionField;
+    expectedVersion;
+    constructor(opts) {
+        super(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;
+    }
+}
 /**
  * Parse column names out of a pg `detail` string like:
  *   "Key (email)=(foo@bar) already exists."
@@ -391,6 +425,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)
  *
@@ -430,6 +465,12 @@ export 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/generate.js

@@ -177,6 +177,92 @@ export 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/index.d.ts

@@ -34,14 +34,16 @@
  */
 export type { DatabaseAdapter, IntrospectionOverrides } from './adapters/index.js';
 export { alloydb, cockroachdb, postgresql, timescale, yugabytedb } from './adapters/index.js';
-export { type Middleware, type MiddlewareNext, type MiddlewareParams, type PgCompatPool, type PgCompatPoolClient, type PgCompatQueryResult, TransactionClient, type TransactionOptions, TurbineClient, type TurbineConfig, } from './client.js';
+export { type Middleware, type MiddlewareNext, type MiddlewareParams, type PgCompatPool, type PgCompatPoolClient, type PgCompatQueryResult, type RetryOptions, TransactionClient, type TransactionOptions, TurbineClient, type TurbineConfig, withRetry, } from './client.js';
 export type { BuiltStatement, BulkInsertStatementInput, ColumnDefinitionInput, ColumnTypeInput, CreateIndexStatementInput, CreateTableStatementInput, Dialect, DialectIntrospector, DialectMigrator, DialectName, InsertStatementInput, IntrospectOptions as DialectIntrospectOptions, UpsertStatementInput, } from './dialect.js';
 export { postgresDialect } from './dialect.js';
-export { CheckConstraintError, CircularRelationError, ConnectionError, DeadlockError, type ErrorMessageMode, ForeignKeyError, getErrorMessageMode, MigrationError, NotFoundError, NotNullViolationError, PipelineError, type PipelineResultSlot, RelationError, SerializationFailureError, setErrorMessageMode, TimeoutError, TurbineError, TurbineErrorCode, UniqueConstraintError, ValidationError, wrapPgError, } from './errors.js';
+export { CheckConstraintError, CircularRelationError, ConnectionError, DeadlockError, type ErrorMessageMode, ExclusionConstraintError, ForeignKeyError, getErrorMessageMode, MigrationError, NotFoundError, NotNullViolationError, OptimisticLockError, PipelineError, type PipelineResultSlot, RelationError, SerializationFailureError, setErrorMessageMode, TimeoutError, TurbineError, TurbineErrorCode, UniqueConstraintError, ValidationError, wrapPgError, } from './errors.js';
 export { type GenerateOptions, generate } from './generate.js';
 export { type IntrospectOptions, introspect } from './introspect.js';
+export { executeNestedCreate, executeNestedUpdate, hasRelationFields, type NestedWriteContext, } from './nested-write.js';
+export type { ObserveConfig, ObserveHandle } from './observe.js';
 export { executePipeline, type PipelineOptions, type PipelineResults, pipelineSupported } from './pipeline.js';
-export { type AggregateArgs, type AggregateResult, type ArrayFilter, type CountArgs, type CreateArgs, type CreateManyArgs, type DeferredQuery, type DeleteArgs, type DeleteManyArgs, type FindManyArgs, type FindManyStreamArgs, type FindUniqueArgs, type GroupByArgs, type JsonFilter, type OrderDirection, QueryInterface, type RelationDescriptor, type RelationFilter, type TypedWithClause, type UpdateArgs, type UpdateInput, type UpdateManyArgs, type UpdateOperatorInput, type UpsertArgs, type WithClause, type WithOptions, type WithResult, } from './query/index.js';
+export { type AggregateArgs, type AggregateResult, type ArrayFilter, type ConnectOrCreateOp, type CountArgs, type CreateArgs, type CreateManyArgs, type DeferredQuery, type DeleteArgs, type DeleteManyArgs, type FieldResult, type FindManyArgs, type FindManyStreamArgs, type FindUniqueArgs, type GroupByArgs, type JsonFilter, type NestedCreateOp, type NestedUpdateOp, type OmitResult, type OrderDirection, type QueryEvent, type QueryEventListener, QueryInterface, type QueryResult, type RelationDescriptor, type RelationFilter, type SelectResult, type TextSearchFilter, type TypedWithClause, type UpdateArgs, type UpdateInput, type UpdateManyArgs, type UpdateOperatorInput, type UpsertArgs, type WithClause, type WithOptions, type WithResult, } from './query/index.js';
 export type { ColumnMetadata, IndexMetadata, RelationDef, SchemaMetadata, TableMetadata, } from './schema.js';
 export { camelToSnake, isDateType, normalizeKeyColumns, pgArrayType, pgTypeToTs, singularize, snakeToCamel, snakeToPascal, } from './schema.js';
 export { ColumnBuilder, type ColumnConfig, type ColumnDef, type ColumnType, type ColumnTypeName, column, defineSchema, type SchemaDef, type TableDef, table, } from './schema-builder.js';

package/dist/index.js

@@ -34,14 +34,16 @@
  */
 export { alloydb, cockroachdb, postgresql, timescale, yugabytedb } from './adapters/index.js';
 // Client
-export { TransactionClient, TurbineClient, } from './client.js';
+export { TransactionClient, TurbineClient, withRetry, } from './client.js';
 export { postgresDialect } from './dialect.js';
 // Error types
-export { CheckConstraintError, CircularRelationError, ConnectionError, DeadlockError, ForeignKeyError, getErrorMessageMode, MigrationError, NotFoundError, NotNullViolationError, PipelineError, RelationError, SerializationFailureError, setErrorMessageMode, TimeoutError, TurbineError, TurbineErrorCode, UniqueConstraintError, ValidationError, wrapPgError, } from './errors.js';
+export { CheckConstraintError, CircularRelationError, ConnectionError, DeadlockError, ExclusionConstraintError, ForeignKeyError, getErrorMessageMode, MigrationError, NotFoundError, NotNullViolationError, OptimisticLockError, PipelineError, RelationError, SerializationFailureError, setErrorMessageMode, TimeoutError, TurbineError, TurbineErrorCode, UniqueConstraintError, ValidationError, wrapPgError, } from './errors.js';
 // Code generation
 export { generate } from './generate.js';
 // Introspection
 export { introspect } from './introspect.js';
+// Nested writes
+export { executeNestedCreate, executeNestedUpdate, hasRelationFields, } from './nested-write.js';
 // Pipeline
 export { executePipeline, pipelineSupported } from './pipeline.js';
 // Query builder