turbine-orm 0.13.3 → 0.15.0

package/dist/adapters/cockroachdb.js

@@ -166,7 +166,7 @@ export const cockroachdb = {
     },
     statementTimeout(seconds) {
         // CockroachDB v23.1+ supports transaction_timeout
-        return `SET transaction_timeout = '${seconds}s'`;
+        return { sql: `SET transaction_timeout = $1`, params: [`${seconds}s`] };
     },
 };
 //# sourceMappingURL=cockroachdb.js.map

package/dist/adapters/index.d.ts

@@ -55,13 +55,16 @@ export interface DatabaseAdapter {
     introspectionOverrides?: Partial<IntrospectionOverrides>;
     /**
      * Generate the SQL to set a statement timeout within a transaction.
-     * PostgreSQL uses `SET LOCAL statement_timeout = '<n>s'`.
-     * CockroachDB uses `SET transaction_timeout = '<n>s'` (v23.1+).
+     * PostgreSQL uses `SET LOCAL statement_timeout = $1`.
+     * CockroachDB uses `SET transaction_timeout = $1` (v23.1+).
      *
      * @param seconds — timeout in seconds
-     * @returns the SQL string to execute
+     * @returns an object with the parameterized SQL and its bound values
      */
-    statementTimeout?(seconds: number): string;
+    statementTimeout?(seconds: number): {
+        sql: string;
+        params: unknown[];
+    };
     /**
      * SQL to create the lock table used by table-based locking adapters.
      * Called during `ensureTrackingTable` when the adapter uses table locks.

package/dist/adapters/index.js

@@ -31,7 +31,7 @@ export const postgresql = {
         await client.query(`SELECT pg_advisory_unlock($1)`, [lockId]);
     },
     statementTimeout(seconds) {
-        return `SET LOCAL statement_timeout = '${seconds}s'`;
+        return { sql: `SET LOCAL statement_timeout = $1`, params: [`${seconds}s`] };
     },
 };
 // ---------------------------------------------------------------------------

package/dist/adapters/yugabytedb.js

@@ -150,7 +150,7 @@ export const yugabytedb = {
     },
     statementTimeout(seconds) {
         // YugabyteDB supports standard PostgreSQL statement_timeout
-        return `SET LOCAL statement_timeout = '${seconds}s'`;
+        return { sql: `SET LOCAL statement_timeout = $1`, params: [`${seconds}s`] };
     },
 };
 //# sourceMappingURL=yugabytedb.js.map

package/dist/cjs/adapters/cockroachdb.js

@@ -169,6 +169,6 @@ exports.cockroachdb = {
     },
     statementTimeout(seconds) {
         // CockroachDB v23.1+ supports transaction_timeout
-        return `SET transaction_timeout = '${seconds}s'`;
+        return { sql: `SET transaction_timeout = $1`, params: [`${seconds}s`] };
     },
 };

package/dist/cjs/adapters/index.js

@@ -34,7 +34,7 @@ exports.postgresql = {
         await client.query(`SELECT pg_advisory_unlock($1)`, [lockId]);
     },
     statementTimeout(seconds) {
-        return `SET LOCAL statement_timeout = '${seconds}s'`;
+        return { sql: `SET LOCAL statement_timeout = $1`, params: [`${seconds}s`] };
     },
 };
 // ---------------------------------------------------------------------------

package/dist/cjs/adapters/yugabytedb.js

@@ -153,6 +153,6 @@ exports.yugabytedb = {
     },
     statementTimeout(seconds) {
         // YugabyteDB supports standard PostgreSQL statement_timeout
-        return `SET LOCAL statement_timeout = '${seconds}s'`;
+        return { sql: `SET LOCAL statement_timeout = $1`, params: [`${seconds}s`] };
     },
 };

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,35 @@ 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 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 +104,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;
@@ -542,6 +568,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/dialect.js

@@ -9,6 +9,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.postgresDialect = void 0;
 const errors_js_1 = require("./errors.js");
+const schema_js_1 = require("./schema.js");
 /** PostgreSQL implementation of the dialect contract. */
 exports.postgresDialect = {
     name: 'postgresql',
@@ -72,10 +73,11 @@ exports.postgresDialect = {
             .map((col, i) => `${leftRef}.${this.quoteIdentifier(col)} = ${rightRef}.${this.quoteIdentifier(rightCols[i])}`)
             .join(' AND ');
     },
-    typeToTypeScript(_dialectType, _nullable) {
-        // Existing PostgreSQL type mapping remains in schema.ts/generate.ts for now.
-        // This hook is the package boundary MySQL/SQLite implementations will fill.
-        return 'unknown';
+    typeToTypeScript(dialectType, nullable) {
+        return (0, schema_js_1.pgTypeToTs)(dialectType, nullable);
+    },
+    arrayType(baseType) {
+        return (0, schema_js_1.pgArrayType)(baseType);
     },
     buildColumnType(input) {
         if (input.type === 'VARCHAR' && input.maxLength != null) {

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');
 }
 // ---------------------------------------------------------------------------
@@ -218,7 +304,13 @@ function generateMetadata(schema) {
         // dateColumns
         const dateCols = [...table.dateColumns];
         lines.push(`      dateColumns: new Set([${dateCols.map((c) => `'${escSQ(c)}'`).join(', ')}]),`);
-        // pgTypes
+        // dialectTypes + pgTypes (pgTypes is kept for backwards compatibility)
+        const dialectTypes = table.dialectTypes ?? table.pgTypes;
+        lines.push('      dialectTypes: {');
+        for (const [col, dialectType] of Object.entries(dialectTypes)) {
+            lines.push(`        ${quoteIfNeeded(col)}: '${escSQ(dialectType)}',`);
+        }
+        lines.push('      },');
         lines.push('      pgTypes: {');
         for (const [col, pgType] of Object.entries(table.pgTypes)) {
             lines.push(`        ${quoteIfNeeded(col)}: '${escSQ(pgType)}',`);
@@ -392,11 +484,13 @@ function serializeColumn(col) {
     const parts = [
         `name: '${escSQ(col.name)}'`,
         `field: '${escSQ(col.field)}'`,
+        `dialectType: '${escSQ(col.dialectType ?? col.pgType)}'`,
         `pgType: '${escSQ(col.pgType)}'`,
         `tsType: '${escSQ(col.tsType)}'`,
         `nullable: ${col.nullable}`,
         `hasDefault: ${col.hasDefault}`,
         `isArray: ${col.isArray}`,
+        `arrayType: '${escSQ(col.arrayType ?? col.pgArrayType)}'`,
         `pgArrayType: '${escSQ(col.pgArrayType)}'`,
     ];
     if (col.maxLength !== undefined)

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; } });

package/dist/cjs/introspect.js

@@ -14,6 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.introspect = introspect;
 const pg_1 = __importDefault(require("pg"));
+const dialect_js_1 = require("./dialect.js");
 const schema_js_1 = require("./schema.js");
 // ---------------------------------------------------------------------------
 // SQL queries (all parameterized, no interpolation)
@@ -101,6 +102,7 @@ const SQL_ENUMS = `
 // ---------------------------------------------------------------------------
 async function introspect(options) {
     const schema = options.schema ?? 'public';
+    const dialect = dialect_js_1.postgresDialect;
     const pool = new pg_1.default.Pool({
         connectionString: options.connectionString,
         max: 1,
@@ -137,15 +139,20 @@ async function introspect(options) {
             const isNullable = row.is_nullable === 'YES';
             const isArray = row.data_type === 'ARRAY';
             const baseType = isArray ? row.udt_name.slice(1) : row.udt_name;
+            const dialectType = row.udt_name;
+            const arrayType = dialect.arrayType?.(baseType) ?? 'text[]';
             const col = {
                 name: row.column_name,
                 field: (0, schema_js_1.snakeToCamel)(row.column_name),
-                pgType: row.udt_name,
-                tsType: (0, schema_js_1.pgTypeToTs)(isArray ? row.udt_name : baseType, isNullable),
+                dialectType,
+                pgType: dialectType,
+                tsType: dialect.typeToTypeScript?.(isArray ? dialectType : baseType, isNullable) ??
+                    (0, schema_js_1.pgTypeToTs)(isArray ? dialectType : baseType, isNullable),
                 nullable: isNullable,
                 hasDefault: row.column_default !== null,
                 isArray,
-                pgArrayType: (0, schema_js_1.pgArrayType)(baseType),
+                arrayType,
+                pgArrayType: arrayType,
                 maxLength: row.character_maximum_length ?? undefined,
             };
             if (!columnsByTable.has(tableName))
@@ -281,14 +288,16 @@ async function introspect(options) {
             const columnMap = {};
             const reverseColumnMap = {};
             const dateColumns = new Set();
+            const dialectTypes = {};
             const pgTypes = {};
             const allColumns = [];
             for (const col of columns) {
                 columnMap[col.field] = col.name;
                 reverseColumnMap[col.name] = col.field;
                 allColumns.push(col.name);
+                dialectTypes[col.name] = col.dialectType ?? col.pgType;
                 pgTypes[col.name] = col.pgType;
-                const baseType = col.isArray ? col.pgType.slice(1) : col.pgType;
+                const baseType = col.isArray ? (col.dialectType ?? col.pgType).slice(1) : (col.dialectType ?? col.pgType);
                 if ((0, schema_js_1.isDateType)(baseType)) {
                     dateColumns.add(col.name);
                 }
@@ -299,6 +308,7 @@ async function introspect(options) {
                 columnMap,
                 reverseColumnMap,
                 dateColumns,
+                dialectTypes,
                 pgTypes,
                 allColumns,
                 primaryKey: pkByTable.get(tableName) ?? [],