turbine-orm 0.4.0 → 0.7.0

package/dist/client.js

@@ -22,21 +22,9 @@
  * ```
  */
 import pg from 'pg';
-import { QueryInterface } from './query.js';
+import { TimeoutError, wrapPgError } from './errors.js';
 import { executePipeline } from './pipeline.js';
-// Parse int8 (bigint, OID 20) as JavaScript number instead of string.
-// Safe for values up to Number.MAX_SAFE_INTEGER (9,007,199,254,740,991).
-pg.types.setTypeParser(20, (val) => {
-    const n = Number(val);
-    return Number.isSafeInteger(n) ? n : val; // fall back to string for huge values
-});
-// Parse numeric (OID 1700) as number when safe, string otherwise
-pg.types.setTypeParser(1700, (val) => {
-    const n = Number(val);
-    if (val.includes('.') && Number.isFinite(n))
-        return n;
-    return Number.isSafeInteger(n) ? n : val;
-});
+import { QueryInterface } from './query.js';
 /** Maps isolation level names to SQL */
 const ISOLATION_LEVELS = {
     ReadUncommitted: 'READ UNCOMMITTED',
@@ -56,12 +44,14 @@ export class TransactionClient {
     client;
     schema;
     middlewares;
+    queryOptions;
     tableCache = new Map();
     savepointCounter = 0;
-    constructor(client, schema, middlewares) {
+    constructor(client, schema, middlewares, queryOptions) {
         this.client = client;
         this.schema = schema;
         this.middlewares = middlewares;
+        this.queryOptions = queryOptions;
         // Auto-create typed table accessors for all tables in the schema
         for (const tableName of Object.keys(schema.tables)) {
             const camelName = tableName.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
@@ -83,7 +73,7 @@ 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);
+            qi = new QueryInterface(txPool, name, this.schema, this.middlewares, this.queryOptions);
             this.tableCache.set(name, qi);
         }
         return qi;
@@ -116,20 +106,36 @@ export class TransactionClient {
                 sql += `$${i + 1}`;
             }
         });
-        const result = await this.client.query(sql, values);
-        return result.rows;
+        try {
+            const result = await this.client.query(sql, values);
+            return result.rows;
+        }
+        catch (err) {
+            throw wrapPgError(err);
+        }
     }
     /**
      * Create a pool-like wrapper around the transaction client.
      * This allows QueryInterface to work with the transaction connection
      * without knowing it's in a transaction.
+     *
+     * pg driver errors thrown by queries are translated into typed Turbine
+     * errors via wrapPgError so transaction-scoped queries surface the same
+     * typed errors as pool-scoped queries.
      */
     createTxPool() {
         const client = this.client;
         // Return a minimal pool-compatible object that routes queries
         // through the transaction client
         return {
-            query: (text, values) => client.query(text, values),
+            query: async (text, values) => {
+                try {
+                    return await client.query(text, values);
+                }
+                catch (err) {
+                    throw wrapPgError(err);
+                }
+            },
             connect: () => Promise.resolve(client),
         };
     }
@@ -142,33 +148,81 @@ export class TurbineClient {
     pool;
     /** The schema metadata this client was built from */
     schema;
+    static int8ParserRegistered = false;
     logging;
     tableCache = new Map();
     middlewares = [];
+    queryOptions;
+    /** True when Turbine created the pool and is responsible for tearing it down */
+    ownsPool = true;
     constructor(config = {}, schema) {
+        /**
+         * Parse int8 (bigint, OID 20) as JavaScript number instead of string.
+         * Safe for values up to Number.MAX_SAFE_INTEGER (9,007,199,254,740,991).
+         *
+         * NOTE: For values exceeding Number.MAX_SAFE_INTEGER, the parser falls back
+         * to returning the raw string to avoid precision loss. The generated TypeScript
+         * type maps int8/bigint to `number`, which is correct for the vast majority of
+         * use cases (IDs, counts, timestamps). If you store values > 2^53 - 1 in a
+         * bigint column, the runtime return type will be `string` for those rows.
+         *
+         * NOTE: We intentionally do NOT register a parser for numeric (OID 1700).
+         * Postgres numeric is arbitrary-precision, so the default pg driver behavior
+         * of returning a string is correct and matches the generated TypeScript type
+         * (numeric → string). Users who want number can cast explicitly in SQL.
+         */
+        // Only register the int8 parser when we own the pg driver. External
+        // pools (Neon HTTP, Vercel Postgres) may ship their own pg-types fork
+        // and rely on their own parser configuration — don't mutate global state
+        // we don't own.
+        if (!config.pool && !TurbineClient.int8ParserRegistered) {
+            pg.types.setTypeParser(20, (val) => {
+                const n = Number(val);
+                return Number.isSafeInteger(n) ? n : val;
+            });
+            TurbineClient.int8ParserRegistered = true;
+        }
         this.logging = config.logging ?? false;
         this.schema = schema;
-        const poolConfig = {
-            max: config.poolSize ?? 10,
-            idleTimeoutMillis: config.idleTimeoutMs ?? 30_000,
-            connectionTimeoutMillis: config.connectionTimeoutMs ?? 5_000,
+        this.queryOptions = {
+            defaultLimit: config.defaultLimit,
+            warnOnUnlimited: config.warnOnUnlimited,
         };
-        if (config.connectionString) {
-            poolConfig.connectionString = config.connectionString;
+        if (config.pool) {
+            // External pool — use directly. Turbine doesn't manage its lifecycle.
+            this.pool = config.pool;
+            this.ownsPool = false;
+            if (this.logging) {
+                console.log(`[turbine] Using external pool — ${Object.keys(schema.tables).length} tables`);
+            }
         }
         else {
-            poolConfig.host = config.host ?? 'localhost';
-            poolConfig.port = config.port ?? 5432;
-            poolConfig.database = config.database ?? 'postgres';
-            poolConfig.user = config.user ?? 'postgres';
-            poolConfig.password = config.password;
-        }
-        this.pool = new pg.Pool(poolConfig);
-        this.pool.on('error', (err) => {
-            console.error('[turbine] Unexpected pool error:', err.message);
-        });
-        if (this.logging) {
-            console.log(`[turbine] Pool created — max ${poolConfig.max} connections, ${Object.keys(schema.tables).length} tables`);
+            const poolConfig = {
+                max: config.poolSize ?? 10,
+                idleTimeoutMillis: config.idleTimeoutMs ?? 30_000,
+                connectionTimeoutMillis: config.connectionTimeoutMs ?? 5_000,
+            };
+            if (config.connectionString) {
+                poolConfig.connectionString = config.connectionString;
+            }
+            else {
+                poolConfig.host = config.host ?? 'localhost';
+                poolConfig.port = config.port ?? 5432;
+                poolConfig.database = config.database ?? 'postgres';
+                poolConfig.user = config.user ?? 'postgres';
+                poolConfig.password = config.password;
+            }
+            if (config.ssl !== undefined) {
+                poolConfig.ssl = config.ssl;
+            }
+            this.pool = new pg.Pool(poolConfig);
+            this.ownsPool = true;
+            this.pool.on('error', (err) => {
+                console.error('[turbine] Unexpected pool error:', err.message);
+            });
+            if (this.logging) {
+                console.log(`[turbine] Pool created — max ${poolConfig.max} connections, ${Object.keys(schema.tables).length} tables`);
+            }
         }
         // Auto-create typed table accessors for all tables in the schema
         for (const tableName of Object.keys(schema.tables)) {
@@ -187,6 +241,11 @@ export class TurbineClient {
     /**
      * Register a middleware function that runs before/after every query.
      *
+     * Middleware can inspect and log query parameters, modify results after execution,
+     * and measure timing. Note: query SQL is generated before middleware runs, so
+     * modifying params.args in middleware will NOT affect the executed SQL.
+     * To intercept queries before SQL generation, use the raw() method instead.
+     *
      * @example
      * ```ts
      * // Query timing middleware
@@ -225,7 +284,7 @@ export class TurbineClient {
     table(name) {
         let qi = this.tableCache.get(name);
         if (!qi) {
-            qi = new QueryInterface(this.pool, name, this.schema, this.middlewares);
+            qi = new QueryInterface(this.pool, name, this.schema, this.middlewares, this.queryOptions);
             this.tableCache.set(name, qi);
         }
         return qi;
@@ -270,8 +329,13 @@ export class TurbineClient {
         if (this.logging) {
             console.log(`[turbine] Raw SQL: ${sql.trim().substring(0, 120)}...`);
         }
-        const result = await this.pool.query(sql, values);
-        return result.rows;
+        try {
+            const result = await this.pool.query(sql, values);
+            return result.rows;
+        }
+        catch (err) {
+            throw wrapPgError(err);
+        }
     }
     // -------------------------------------------------------------------------
     // Transaction support (raw — legacy)
@@ -338,7 +402,7 @@ export class TurbineClient {
             }
             await client.query(beginSQL);
             // Create the transaction client with typed table accessors
-            const tx = new TransactionClient(client, this.schema, this.middlewares);
+            const tx = new TransactionClient(client, this.schema, this.middlewares, this.queryOptions);
             // Dynamically attach table accessors to tx
             for (const tableName of Object.keys(this.schema.tables)) {
                 const camelName = tableName.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
@@ -355,7 +419,7 @@ export class TurbineClient {
                 let timer;
                 const timeoutPromise = new Promise((_, reject) => {
                     timer = setTimeout(() => {
-                        reject(new Error(`[turbine] Transaction timed out after ${timeout}ms`));
+                        reject(new TimeoutError(timeout, 'Transaction'));
                     }, timeout);
                 });
                 try {
@@ -406,8 +470,17 @@ export class TurbineClient {
     }
     /**
      * Gracefully shut down the connection pool.
+     *
+     * If Turbine was given an external pool via `TurbineConfig.pool`, this
+     * method is a no-op — the caller is responsible for the pool's lifecycle.
      */
     async disconnect() {
+        if (!this.ownsPool) {
+            if (this.logging) {
+                console.log('[turbine] disconnect() skipped — external pool is not owned by Turbine');
+            }
+            return;
+        }
         await this.pool.end();
         if (this.logging) {
             console.log('[turbine] Pool disconnected');
@@ -417,12 +490,15 @@ export class TurbineClient {
     async end() {
         return this.disconnect();
     }
-    /** Pool statistics for monitoring. */
+    /**
+     * Pool statistics for monitoring. Returns zeros for pools that don't
+     * expose connection counts (e.g., stateless HTTP drivers like Neon).
+     */
     get stats() {
         return {
-            totalCount: this.pool.totalCount,
-            idleCount: this.pool.idleCount,
-            waitingCount: this.pool.waitingCount,
+            totalCount: this.pool.totalCount ?? 0,
+            idleCount: this.pool.idleCount ?? 0,
+            waitingCount: this.pool.waitingCount ?? 0,
         };
     }
 }

package/dist/errors.d.ts

@@ -0,0 +1,138 @@
+/**
+ * turbine-orm — Error types
+ *
+ * Typed errors with error codes for programmatic handling.
+ * All Turbine errors extend TurbineError which includes a `code` property.
+ */
+/** Error codes for all Turbine errors */
+export declare const TurbineErrorCode: {
+    readonly NOT_FOUND: "TURBINE_E001";
+    readonly TIMEOUT: "TURBINE_E002";
+    readonly VALIDATION: "TURBINE_E003";
+    readonly CONNECTION: "TURBINE_E004";
+    readonly RELATION: "TURBINE_E005";
+    readonly MIGRATION: "TURBINE_E006";
+    readonly CIRCULAR_RELATION: "TURBINE_E007";
+    readonly UNIQUE_VIOLATION: "TURBINE_E008";
+    readonly FOREIGN_KEY_VIOLATION: "TURBINE_E009";
+    readonly NOT_NULL_VIOLATION: "TURBINE_E010";
+    readonly CHECK_VIOLATION: "TURBINE_E011";
+};
+export type TurbineErrorCode = (typeof TurbineErrorCode)[keyof typeof TurbineErrorCode];
+/** Base error class for all Turbine errors */
+export declare class TurbineError extends Error {
+    readonly code: TurbineErrorCode;
+    constructor(code: TurbineErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when a record is not found (findUniqueOrThrow, findFirstOrThrow,
+ * update/delete against a non-matching row, etc.)
+ *
+ * Supports two call styles for back-compat:
+ *   - `new NotFoundError()` / `new NotFoundError('custom message')`
+ *   - `new NotFoundError({ table, where, operation, cause, message })`
+ *
+ * When called with an options object and no explicit `message`, a Prisma-style
+ * message is built automatically, e.g.:
+ *   `[turbine] findUniqueOrThrow on "users" found no record matching where: {"id":1}`
+ */
+export declare class NotFoundError extends TurbineError {
+    readonly table?: string;
+    readonly where?: unknown;
+    readonly operation?: string;
+    constructor(input?: string | {
+        table?: string;
+        where?: unknown;
+        operation?: string;
+        cause?: unknown;
+        message?: string;
+    });
+}
+/** Thrown when a query or transaction exceeds the configured timeout */
+export declare class TimeoutError extends TurbineError {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number, context?: string);
+}
+/** Thrown when query arguments fail validation (unknown column, invalid operator, etc.) */
+export declare class ValidationError extends TurbineError {
+    constructor(message: string);
+}
+/** Thrown when a database connection fails */
+export declare class ConnectionError extends TurbineError {
+    constructor(message: string);
+}
+/** Thrown when a relation reference is invalid */
+export declare class RelationError extends TurbineError {
+    constructor(message: string);
+}
+/** Thrown when a migration operation fails */
+export declare class MigrationError extends TurbineError {
+    constructor(message: string);
+}
+/** Thrown when circular relation nesting is detected */
+export declare class CircularRelationError extends TurbineError {
+    readonly path: string[];
+    constructor(path: string[]);
+}
+/** Thrown when a UNIQUE constraint is violated (pg code 23505) */
+export declare class UniqueConstraintError extends TurbineError {
+    readonly constraint?: string;
+    readonly columns?: string[];
+    readonly table?: string;
+    constructor(opts?: {
+        constraint?: string;
+        columns?: string[];
+        table?: string;
+        message?: string;
+        cause?: unknown;
+    });
+}
+/** Thrown when a FOREIGN KEY constraint is violated (pg code 23503) */
+export declare class ForeignKeyError extends TurbineError {
+    readonly constraint?: string;
+    readonly table?: string;
+    constructor(opts?: {
+        constraint?: string;
+        table?: string;
+        message?: string;
+        cause?: unknown;
+    });
+}
+/** Thrown when a NOT NULL constraint is violated (pg code 23502) */
+export declare class NotNullViolationError extends TurbineError {
+    readonly column?: string;
+    readonly table?: string;
+    constructor(opts?: {
+        column?: string;
+        table?: string;
+        message?: string;
+        cause?: unknown;
+    });
+}
+/** Thrown when a CHECK constraint is violated (pg code 23514) */
+export declare class CheckConstraintError extends TurbineError {
+    readonly constraint?: string;
+    readonly table?: string;
+    constructor(opts?: {
+        constraint?: string;
+        table?: string;
+        message?: string;
+        cause?: unknown;
+    });
+}
+/**
+ * Translate a pg driver error into a typed Turbine error.
+ * If the error doesn't match a known constraint code, returns it unchanged.
+ *
+ * Maps:
+ *   23505 (unique_violation)      -> UniqueConstraintError
+ *   23503 (foreign_key_violation) -> ForeignKeyError
+ *   23502 (not_null_violation)    -> NotNullViolationError
+ *   23514 (check_violation)       -> CheckConstraintError
+ *
+ * The original pg error is preserved as `.cause` on the wrapped error.
+ */
+export declare function wrapPgError(err: unknown): unknown;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

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