@relq/orm 0.1.2 → 0.1.4

package/dist/cjs/shared/errors/relq-errors.cjs

@@ -3,9 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RelqBuilderError = exports.RelqEnvironmentError = exports.RelqPoolError = exports.RelqTimeoutError = exports.RelqConfigError = exports.RelqTransactionError = exports.RelqQueryError = exports.RelqConnectionError = exports.RelqError = void 0;
+exports.RelqLockError = exports.RelqDataError = exports.RelqSchemaError = exports.RelqConstraintError = exports.RelqBuilderError = exports.RelqEnvironmentError = exports.RelqPoolError = exports.RelqTimeoutError = exports.RelqConfigError = exports.RelqTransactionError = exports.RelqQueryError = exports.RelqConnectionError = exports.RelqError = void 0;
 exports.setupErrorHandler = setupErrorHandler;
+exports.getOriginalError = getOriginalError;
 exports.isRelqError = isRelqError;
+exports.isRelqConstraintError = isRelqConstraintError;
+exports.isRelqSchemaError = isRelqSchemaError;
+exports.isRelqDataError = isRelqDataError;
+exports.isRelqLockError = isRelqLockError;
 exports.isRelqConnectionError = isRelqConnectionError;
 exports.isRelqQueryError = isRelqQueryError;
 exports.isRelqBuilderError = isRelqBuilderError;
@@ -57,34 +62,93 @@ function setupErrorHandler() {
         node_process_1.default.exit();
     });
 }
+const ORIGINAL_ERROR = Symbol('relq-original-error');
+let _errorHandlerInstalled = false;
+function _autoInstallErrorHandler() {
+    if (_errorHandlerInstalled)
+        return;
+    _errorHandlerInstalled = true;
+    if (typeof node_process_1.default === 'undefined' || !node_process_1.default.on)
+        return;
+    const formatRelqError = (error) => {
+        const lines = [
+            '',
+            `  \x1b[1m\x1b[31m${error.name}\x1b[0m: ${error.message}`,
+        ];
+        const props = error._getInspectProps?.() || {};
+        for (const [key, value] of Object.entries(props)) {
+            if (value === undefined)
+                continue;
+            const strVal = typeof value === 'string' ? value : JSON.stringify(value);
+            lines.push(`  \x1b[2m${key.padStart(16)}:\x1b[0m ${strVal}`);
+        }
+        lines.push(`  \x1b[2m       timestamp:\x1b[0m ${error.timestamp.toISOString()}`);
+        lines.push('');
+        return lines.join('\n');
+    };
+    node_process_1.default.on('uncaughtException', (error) => {
+        if (error instanceof RelqError) {
+            console.error(formatRelqError(error));
+        }
+        else {
+            console.error(`${error.name || 'Error'}: ${error.message}`);
+            if (error.stack) {
+                const stackLines = error.stack.split('\n').filter((line) => line.trim().startsWith('at '));
+                console.error(stackLines.slice(0, 5).join('\n'));
+            }
+        }
+        node_process_1.default.exit(1);
+    });
+    node_process_1.default.on('unhandledRejection', (reason) => {
+        if (reason instanceof RelqError) {
+            console.error(formatRelqError(reason));
+        }
+        else if (reason instanceof Error) {
+            console.error(`${reason.name || 'Error'}: ${reason.message}`);
+        }
+        else {
+            console.error('Unhandled rejection:', reason);
+        }
+        node_process_1.default.exit(1);
+    });
+}
 class RelqError extends Error {
     name;
-    cause;
     timestamp;
     constructor(message, cause) {
         super(message);
         this.name = 'RelqError';
-        this.cause = cause;
+        Object.defineProperty(this, ORIGINAL_ERROR, {
+            value: cause,
+            enumerable: false,
+            writable: false,
+        });
         this.timestamp = new Date();
+        _autoInstallErrorHandler();
         if (Error.captureStackTrace) {
             Error.captureStackTrace(this, this.constructor);
         }
+        if (this.stack) {
+            const lines = this.stack.split('\n');
+            this.stack = lines.filter(line => line.includes(this.name) ||
+                line.trim().startsWith('at ') ||
+                line.trim() === '').slice(0, 8).join('\n');
+        }
     }
     [Symbol.for('nodejs.util.inspect.custom')](_depth, _options) {
         const lines = [
-            `${this.name}: ${this.message}`,
-            ` timestamp: ${this.timestamp.toISOString()}`
+            '',
+            `  \x1b[1m\x1b[31m${this.name}\x1b[0m: ${this.message}`,
         ];
         const props = this._getInspectProps();
         for (const [key, value] of Object.entries(props)) {
-            const strVal = value === undefined ? 'undefined' : JSON.stringify(value);
-            lines.push(`${key.padStart(10)}: ${strVal}`);
-        }
-        if (this.stack) {
-            const stackLines = this.stack.split('\n').filter(line => line.trim().startsWith('at ') || line.includes(this.name));
-            lines.push('');
-            lines.push(...stackLines.slice(1, 6));
+            if (value === undefined)
+                continue;
+            const strVal = typeof value === 'string' ? value : JSON.stringify(value);
+            lines.push(`  \x1b[2m${key.padStart(16)}:\x1b[0m ${strVal}`);
         }
+        lines.push(`  \x1b[2m       timestamp:\x1b[0m ${this.timestamp.toISOString()}`);
+        lines.push('');
         return lines.join('\n');
     }
     _getInspectProps() {
@@ -94,13 +158,15 @@ class RelqError extends Error {
         return {
             name: this.name,
             message: this.message,
-            cause: this.cause?.message,
             timestamp: this.timestamp.toISOString(),
-            stack: this.stack
+            ...this._getInspectProps(),
         };
     }
 }
 exports.RelqError = RelqError;
+function getOriginalError(error) {
+    return error[ORIGINAL_ERROR];
+}
 class RelqConnectionError extends RelqError {
     name = 'RelqConnectionError';
     code;
@@ -284,9 +350,143 @@ class RelqBuilderError extends RelqError {
     }
 }
 exports.RelqBuilderError = RelqBuilderError;
+class RelqConstraintError extends RelqError {
+    name = 'RelqConstraintError';
+    constraintType;
+    table;
+    column;
+    constraint;
+    value;
+    sql;
+    code;
+    detail;
+    retryable = false;
+    constructor(message, constraintType, options) {
+        super(message, options?.cause);
+        this.constraintType = constraintType;
+        this.table = options?.table;
+        this.column = options?.column;
+        this.constraint = options?.constraint;
+        this.value = options?.value;
+        this.sql = options?.sql;
+        this.code = options?.code;
+        this.detail = options?.detail;
+    }
+    _getInspectProps() {
+        return {
+            constraintType: this.constraintType,
+            table: this.table,
+            column: this.column,
+            constraint: this.constraint,
+            value: this.value,
+            code: this.code,
+            detail: this.detail,
+        };
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            constraintType: this.constraintType,
+            table: this.table,
+            column: this.column,
+            constraint: this.constraint,
+            value: this.value,
+            sql: this.sql,
+            code: this.code,
+            detail: this.detail,
+            retryable: this.retryable,
+        };
+    }
+}
+exports.RelqConstraintError = RelqConstraintError;
+class RelqSchemaError extends RelqError {
+    name = 'RelqSchemaError';
+    schemaObject;
+    objectName;
+    table;
+    sql;
+    code;
+    hint;
+    constructor(message, schemaObject, options) {
+        super(message, options?.cause);
+        this.schemaObject = schemaObject;
+        this.objectName = options?.objectName;
+        this.table = options?.table;
+        this.sql = options?.sql;
+        this.code = options?.code;
+        this.hint = options?.hint;
+    }
+    _getInspectProps() {
+        return { schemaObject: this.schemaObject, objectName: this.objectName, table: this.table, code: this.code, hint: this.hint };
+    }
+    toJSON() {
+        return { ...super.toJSON(), schemaObject: this.schemaObject, objectName: this.objectName, table: this.table, sql: this.sql, code: this.code, hint: this.hint };
+    }
+}
+exports.RelqSchemaError = RelqSchemaError;
+class RelqDataError extends RelqError {
+    name = 'RelqDataError';
+    dataIssue;
+    column;
+    table;
+    value;
+    dataType;
+    sql;
+    code;
+    constructor(message, dataIssue, options) {
+        super(message, options?.cause);
+        this.dataIssue = dataIssue;
+        this.column = options?.column;
+        this.table = options?.table;
+        this.value = options?.value;
+        this.dataType = options?.dataType;
+        this.sql = options?.sql;
+        this.code = options?.code;
+    }
+    _getInspectProps() {
+        return { dataIssue: this.dataIssue, column: this.column, table: this.table, dataType: this.dataType, code: this.code };
+    }
+    toJSON() {
+        return { ...super.toJSON(), dataIssue: this.dataIssue, column: this.column, table: this.table, value: this.value, dataType: this.dataType, sql: this.sql, code: this.code };
+    }
+}
+exports.RelqDataError = RelqDataError;
+class RelqLockError extends RelqError {
+    name = 'RelqLockError';
+    lockIssue;
+    sql;
+    code;
+    retryable;
+    constructor(message, lockIssue, options) {
+        super(message, options?.cause);
+        this.lockIssue = lockIssue;
+        this.sql = options?.sql;
+        this.code = options?.code;
+        this.retryable = lockIssue === 'deadlock' || lockIssue === 'serialization_failure';
+    }
+    _getInspectProps() {
+        return { lockIssue: this.lockIssue, retryable: this.retryable, code: this.code };
+    }
+    toJSON() {
+        return { ...super.toJSON(), lockIssue: this.lockIssue, sql: this.sql, code: this.code, retryable: this.retryable };
+    }
+}
+exports.RelqLockError = RelqLockError;
 function isRelqError(error) {
     return error instanceof RelqError;
 }
+function isRelqConstraintError(error) {
+    return error instanceof RelqConstraintError;
+}
+function isRelqSchemaError(error) {
+    return error instanceof RelqSchemaError;
+}
+function isRelqDataError(error) {
+    return error instanceof RelqDataError;
+}
+function isRelqLockError(error) {
+    return error instanceof RelqLockError;
+}
 function isRelqConnectionError(error) {
     return error instanceof RelqConnectionError;
 }
@@ -309,48 +509,309 @@ function wrapError(error, context) {
         : String(error);
     return new RelqError(message);
 }
-function parsePostgresError(error, sql) {
+function parsePostgresError(error, sql, isBuilder = true) {
     const message = error.message || 'Database error';
     const code = error.code;
     if (isNetworkErrorCode(code)) {
         return new RelqConnectionError(message, {
-            cause: error,
-            code,
-            host: error.hostname || error.address,
-            port: error.port
+            cause: error, code, host: error.hostname || error.address, port: error.port
         });
     }
-    if (code === '57P01' || code === '57P03' || code === '08006' || code === '08001' || code === '08004') {
-        return new RelqConnectionError(message, {
-            cause: error,
-            code,
-            host: error.hostname,
-            port: error.port
+    if (code === '57P01' || code === '57P03' || code === '08006' || code === '08001' || code === '08004' || code === '08000' || code === '08003') {
+        const friendlyMessages = {
+            '57P01': 'Database server is shutting down.',
+            '57P03': 'Database server is starting up — try again in a moment.',
+            '08006': 'Connection to database was lost during the query.',
+            '08001': 'Cannot connect to database server. Check your host, port, and credentials.',
+            '08004': 'Database server rejected the connection. You may have reached the connection limit.',
+            '08000': 'Database connection failed.',
+            '08003': 'Database connection does not exist. The connection may have been dropped.',
+        };
+        return new RelqConnectionError(friendlyMessages[code] || message, {
+            cause: error, code, host: error.hostname, port: error.port
         });
     }
+    if (code === '53300') {
+        return new RelqConnectionError('Too many database connections. The server has reached its connection limit. Try again later or increase max_connections.', { cause: error, code });
+    }
     if (code === '57014') {
-        return new RelqTimeoutError('Query execution timed out', error.timeout || 0, 'query', error);
+        return new RelqTimeoutError('Query execution timed out.', error.timeout || 0, 'query', error);
     }
     if (message.includes('timeout exceeded when trying to connect')) {
-        return new RelqTimeoutError('Connection timed out', error.timeout || 0, 'connection', error);
+        return new RelqTimeoutError('Connection timed out.', error.timeout || 0, 'connection', error);
     }
     if (!code && (message.includes('Connection terminated') ||
         message.includes('connection is closed') ||
         message.includes('Client has encountered a connection error'))) {
         return new RelqConnectionError(message, {
-            cause: error,
-            host: error.hostname || error.address,
-            port: error.port
+            cause: error, host: error.hostname || error.address, port: error.port
+        });
+    }
+    if (!isBuilder) {
+        return new RelqQueryError(message, { cause: error, sql, code, detail: error.detail, hint: error.hint });
+    }
+    if (code === '23505') {
+        const valueMatch = error.detail?.match(/Key \((.+?)\)=\((.+?)\) already exists/);
+        const col = valueMatch?.[1] || error.column;
+        const val = valueMatch?.[2];
+        return new RelqConstraintError(`Duplicate value: A record with this ${col || 'value'} already exists.${val ? ` Value: "${val}".` : ''}${error.constraint ? ` Constraint: "${error.constraint}".` : ''}`, 'unique', { cause: error, table: error.table, column: col, constraint: error.constraint, value: val, sql, code, detail: error.detail });
+    }
+    if (code === '23503') {
+        const isDelete = error.detail?.includes('is still referenced from table');
+        const refMatch = error.detail?.match(/(?:table|from table) "(\w+)"/);
+        const refTable = refMatch?.[1];
+        const msg = isDelete
+            ? `Cannot delete: This record is still referenced by "${refTable || 'another table'}".${error.constraint ? ` Constraint: "${error.constraint}".` : ''}`
+            : `Referenced record not found: The value you're inserting references a record in "${refTable || 'another table'}" that doesn't exist.${error.constraint ? ` Constraint: "${error.constraint}".` : ''}`;
+        return new RelqConstraintError(msg, 'foreign_key', {
+            cause: error, table: error.table, constraint: error.constraint, sql, code, detail: error.detail
         });
     }
+    if (code === '23502') {
+        return new RelqConstraintError(`Required field missing: Column "${error.column || 'unknown'}" on table "${error.table || 'unknown'}" cannot be NULL. Provide a value or set a default in your schema.`, 'not_null', { cause: error, table: error.table, column: error.column, sql, code, detail: error.detail });
+    }
+    if (code === '23514') {
+        return new RelqConstraintError(`Check constraint failed: "${error.constraint || 'unknown'}" on table "${error.table || 'unknown'}". The value doesn't satisfy the validation rule.`, 'check', { cause: error, table: error.table, constraint: error.constraint, sql, code, detail: error.detail });
+    }
+    if (code === '23P01') {
+        return new RelqConstraintError(`Exclusion constraint failed: "${error.constraint || 'unknown'}" on table "${error.table || 'unknown'}". A conflicting record exists.`, 'exclusion', { cause: error, table: error.table, constraint: error.constraint, sql, code, detail: error.detail });
+    }
+    if (code === '23001') {
+        return new RelqConstraintError(`Restrict violation: Cannot delete or update — a RESTRICT constraint prevents this operation.`, 'restrict', { cause: error, table: error.table, constraint: error.constraint, sql, code, detail: error.detail });
+    }
+    if (code === '23000') {
+        return new RelqConstraintError(`Integrity constraint violation: ${error.detail || message}.${error.constraint ? ` Constraint: "${error.constraint}".` : ''}`, 'unique', { cause: error, table: error.table, constraint: error.constraint, sql, code, detail: error.detail });
+    }
+    if (code === '40003') {
+        return new RelqLockError('Ambiguous result: The transaction outcome is unknown (network issue during COMMIT). Check if the transaction was applied and retry if needed.', 'serialization_failure', { cause: error, sql, code });
+    }
+    if (code === '40P01') {
+        return new RelqLockError('Deadlock detected: Two transactions are waiting for each other. Retry the transaction.', 'deadlock', { cause: error, sql, code });
+    }
+    if (code === '40001') {
+        return new RelqLockError('Serialization conflict: Another transaction modified the same data. Retry the transaction.', 'serialization_failure', { cause: error, sql, code });
+    }
+    if (code === '55P03') {
+        return new RelqLockError('Lock not available: Another transaction holds the lock and NOWAIT was specified. Retry or remove NOWAIT.', 'lock_not_available', { cause: error, sql, code });
+    }
+    if (code === '42P01') {
+        return new RelqSchemaError(`Table "${error.table || extractFromMessage(message, /relation "(.+?)"/)}" does not exist. Check your schema definition or run migrations.`, 'table', { cause: error, objectName: error.table, sql, code });
+    }
+    if (code === '42703') {
+        const col = error.column || extractFromMessage(message, /column "(.+?)"/);
+        return new RelqSchemaError(`Column "${col}" does not exist. Check column name spelling in your schema and query.`, 'column', { cause: error, objectName: col, table: error.table, sql, code });
+    }
+    if (code === '42803') {
+        const col = extractFromMessage(message, /column "(.+?)"/);
+        return new RelqSchemaError(`Grouping error: Column "${col || 'unknown'}" must be in GROUP BY or used in an aggregate function. Add it to .groupBy() or wrap it in .include() with an aggregate.`, 'column', { cause: error, objectName: col, sql, code, hint: 'Add the column to .groupBy() or use it inside .include() with a.count(), a.sum(), etc.' });
+    }
+    if (code === '42883') {
+        const fnMatch = message.match(/function (\w+)\((\w+)\)/);
+        const fnName = fnMatch?.[1];
+        const argType = fnMatch?.[2];
+        if (fnName === 'bool_and' || fnName === 'bool_or') {
+            const relqMethod = fnName === 'bool_and' ? 'boolAnd' : 'boolOr';
+            return new RelqSchemaError(`${relqMethod}() only accepts boolean columns, but received a ${argType || 'non-boolean'} column. Pass a boolean column like t.table.isActive or t.table.delivered.`, 'function', { cause: error, sql, code, hint: `Change a.${relqMethod}(t.table.numericColumn) to a.${relqMethod}(t.table.booleanColumn)` });
+        }
+        if (fnName === 'string_agg') {
+            return new RelqSchemaError(`stringAgg() received an incompatible column type (${argType || 'unknown'}). The column should be a text/string type.`, 'function', { cause: error, sql, code, hint: 'stringAgg auto-casts to text — if you see this error, the column type may not support text conversion.' });
+        }
+        return new RelqSchemaError(`Function not found: ${message}. Check function name and argument types.`, 'function', { cause: error, sql, code });
+    }
+    if (code === '42804' || code === '42846') {
+        return new RelqSchemaError(`Type mismatch: ${message}. Check that the value type matches the column type.`, 'type', { cause: error, sql, code });
+    }
+    if (code === '42601') {
+        return new RelqSchemaError(`SQL syntax error: ${message}. This may indicate a bug in the query builder — please report it.`, 'column', { cause: error, sql, code, hint: 'If you are using db.raw(), check your SQL syntax.' });
+    }
+    if (code === '428C9') {
+        return new RelqSchemaError(`Cannot write to generated column. Remove it from your insert or update data — generated columns are computed by the database.`, 'column', { cause: error, objectName: error.column, table: error.table, sql, code });
+    }
+    if (code === '42P07') {
+        return new RelqSchemaError(`Table "${error.table || extractFromMessage(message, /relation "(.+?)"/)}" already exists.`, 'table', { cause: error, objectName: error.table, sql, code });
+    }
+    if (code === '42501') {
+        return new RelqSchemaError(`Permission denied: ${message}. Check that your database user has the required privileges.`, 'table', { cause: error, table: error.table, sql, code });
+    }
+    if (code === '42702') {
+        const col = extractFromMessage(message, /column "(.+?)"/);
+        return new RelqSchemaError(`Ambiguous column "${col || 'unknown'}": The column exists in multiple tables. Qualify it with a table name or alias.`, 'column', { cause: error, objectName: col, sql, code, hint: 'When joining tables, use the table alias to qualify ambiguous columns.' });
+    }
+    if (code === '42830') {
+        return new RelqSchemaError(`Invalid foreign key definition: ${message}.`, 'constraint', { cause: error, sql, code });
+    }
+    if (code === '42701') {
+        const col = extractFromMessage(message, /column "(.+?)"/);
+        return new RelqSchemaError(`Duplicate column "${col || 'unknown'}": A column with this name already exists.`, 'column', { cause: error, objectName: col, table: error.table, sql, code });
+    }
+    if (code === '42P02') {
+        return new RelqSchemaError(`Undefined parameter: ${message}. Check that the number of parameters matches the placeholders in your query.`, 'column', { cause: error, sql, code });
+    }
+    if (code === '42704') {
+        const obj = extractFromMessage(message, /type "(.+?)"/) || extractFromMessage(message, /"(.+?)"/);
+        return new RelqSchemaError(`Object "${obj || 'unknown'}" does not exist: ${message}`, 'type', { cause: error, objectName: obj, sql, code });
+    }
+    if (code === '42P04') {
+        const db = extractFromMessage(message, /database "(.+?)"/);
+        return new RelqSchemaError(`Database "${db || 'unknown'}" already exists.`, 'schema', { cause: error, objectName: db, sql, code });
+    }
+    if (code === '42P06') {
+        const schema = extractFromMessage(message, /schema "(.+?)"/);
+        return new RelqSchemaError(`Schema "${schema || 'unknown'}" already exists.`, 'schema', { cause: error, objectName: schema, sql, code });
+    }
+    if (code === '42710') {
+        const obj = extractFromMessage(message, /"(.+?)"/);
+        return new RelqSchemaError(`Object "${obj || 'unknown'}" already exists: ${message}`, 'type', { cause: error, objectName: obj, sql, code });
+    }
+    if (code === '42809') {
+        return new RelqSchemaError(`Wrong object type: ${message}. The object exists but is not the expected type (e.g., using a view as a table).`, 'type', { cause: error, sql, code });
+    }
+    if (code === '42P18') {
+        return new RelqSchemaError(`Cannot determine data type: ${message}. Add an explicit type cast.`, 'type', { cause: error, sql, code, hint: 'TypeScript types are correct but the database needs a type hint. This usually happens with NULL or ambiguous literals.' });
+    }
+    if (code === '42P20') {
+        return new RelqSchemaError(`Window function error: ${message}.`, 'function', { cause: error, sql, code });
+    }
+    if (code === '42P19') {
+        return new RelqSchemaError(`Invalid recursion: ${message}. Check your CTE recursive query.`, 'function', { cause: error, sql, code });
+    }
+    if (code === '42622') {
+        return new RelqSchemaError(`Name too long: ${message}. PostgreSQL identifiers are limited to 63 characters.`, 'column', { cause: error, sql, code });
+    }
+    if (code === '42939') {
+        return new RelqSchemaError(`Reserved name: ${message}. The name conflicts with a PostgreSQL reserved word.`, 'column', { cause: error, sql, code, hint: 'Rename the column/table or quote the identifier.' });
+    }
+    if (code === '42602') {
+        return new RelqSchemaError(`Invalid name: ${message}. The identifier contains invalid characters.`, 'column', { cause: error, sql, code });
+    }
+    if (code === '42P10') {
+        return new RelqSchemaError(`Invalid column reference: ${message}. The column cannot be used in this context.`, 'column', { cause: error, sql, code });
+    }
+    if (code === '42611') {
+        return new RelqSchemaError(`Invalid column definition: ${message}.`, 'column', { cause: error, sql, code });
+    }
+    if (code === '42P16') {
+        return new RelqSchemaError(`Invalid table definition: ${message}.`, 'table', { cause: error, sql, code });
+    }
+    if (code === '42P17') {
+        return new RelqSchemaError(`Invalid object definition: ${message}.`, 'type', { cause: error, sql, code });
+    }
+    if (code === '42725') {
+        return new RelqSchemaError(`Ambiguous function: ${message}. Multiple functions match the given name and argument types.`, 'function', { cause: error, sql, code, hint: 'Add explicit type casts to the arguments to resolve ambiguity.' });
+    }
+    if (code === '42P21' || code === '42P22') {
+        return new RelqSchemaError(`Collation mismatch: ${message}. The columns use different collations.`, 'column', { cause: error, sql, code });
+    }
+    if (code?.startsWith('42')) {
+        return new RelqSchemaError(`Schema/syntax error: ${message}`, 'type', { cause: error, sql, code });
+    }
+    if (code === '28000' || code === '28P01') {
+        return new RelqConnectionError(`Authentication failed: ${code === '28P01' ? 'Invalid password.' : 'Invalid authorization.'} Check your database credentials.`, { cause: error, code });
+    }
+    if (code === '3D000') {
+        const db = extractFromMessage(message, /database "(.+?)"/);
+        return new RelqSchemaError(`Database "${db || 'unknown'}" does not exist. Check your database name in the connection config.`, 'schema', { cause: error, objectName: db, sql, code });
+    }
+    if (code === '3F000') {
+        const schema = extractFromMessage(message, /schema "(.+?)"/);
+        return new RelqSchemaError(`Schema "${schema || 'unknown'}" does not exist. Check the schema name in your config.`, 'schema', { cause: error, objectName: schema, sql, code });
+    }
+    if (code === '25001') {
+        return new RelqTransactionError('A transaction is already active. Nested transactions are not supported — use savepoints instead.', 'BEGIN', { cause: error, transactionState: 'active' });
+    }
+    if (code === '25P01') {
+        return new RelqTransactionError('No active transaction. You tried to COMMIT or ROLLBACK but there is no transaction in progress.', 'COMMIT', { cause: error, transactionState: 'none' });
+    }
+    if (code === '25P03') {
+        return new RelqTimeoutError('Idle transaction timeout: The transaction was idle for too long and was terminated by the server.', 0, 'query', error);
+    }
+    if (code === 'OC000') {
+        return new RelqLockError('Transaction conflict (DSQL): Another transaction modified the same data. Retry the transaction.', 'serialization_failure', { cause: error, sql, code });
+    }
+    if (code === 'OC001') {
+        return new RelqSchemaError('Schema conflict (DSQL): The schema was updated by another transaction. Retry the operation.', 'schema', { cause: error, sql, code });
+    }
+    if (code === '53100') {
+        return new RelqQueryError('Disk full: The server has run out of disk space.', { cause: error, sql, code });
+    }
+    if (code === '54001') {
+        return new RelqQueryError('Statement too complex: Simplify the query or break it into smaller parts.', { cause: error, sql, code });
+    }
+    if (code === '0A000') {
+        return new RelqSchemaError(`Feature not supported: ${message}. This feature may not be available on your database dialect.`, 'type', { cause: error, sql, code, hint: 'Check your dialect\'s supported features.' });
+    }
+    if (code === '22001') {
+        return new RelqDataError(`Value too long for column "${error.column || 'unknown'}". Shorten the value or increase the column length in your schema.`, 'too_long', { cause: error, column: error.column, table: error.table, sql, code });
+    }
+    if (code === '22003') {
+        return new RelqDataError(`Numeric value out of range for column "${error.column || 'unknown'}". The number is too large or too small for the column type.`, 'out_of_range', { cause: error, column: error.column, table: error.table, sql, code });
+    }
+    if (code === '22P02') {
+        return new RelqDataError(`Invalid value: Cannot convert the given value to the expected type. ${error.detail || message}`, 'invalid_type', { cause: error, dataType: error.dataType, sql, code });
+    }
+    if (code === '22007' || code === '22008') {
+        return new RelqDataError(`Invalid date/time value: ${error.detail || message}. Check date format and range.`, 'invalid_format', { cause: error, sql, code });
+    }
+    if (code === '22012') {
+        return new RelqDataError('Division by zero in query.', 'division_by_zero', { cause: error, sql, code });
+    }
+    if (code === '22004') {
+        return new RelqDataError(`Null value not allowed in this context. ${error.detail || message}`, 'null_not_allowed', { cause: error, column: error.column, table: error.table, sql, code });
+    }
+    if (code === '22023') {
+        return new RelqDataError(`Invalid parameter value: ${error.detail || message}`, 'invalid_type', { cause: error, sql, code });
+    }
+    if (code === '22018') {
+        return new RelqDataError(`Invalid value for type cast: ${error.detail || message}. Cannot convert the value to the target type.`, 'invalid_type', { cause: error, dataType: error.dataType, sql, code });
+    }
+    if (code === '2200H') {
+        return new RelqDataError(`Sequence limit exceeded. The sequence has reached its maximum value.`, 'out_of_range', { cause: error, sql, code });
+    }
+    if (code === '25P02') {
+        return new RelqTransactionError('Transaction is in a failed state. A previous error in this transaction makes it unusable. The transaction will be rolled back.', 'ROLLBACK', { cause: error, transactionState: 'failed' });
+    }
+    if (code === '25006') {
+        return new RelqTransactionError('Cannot write data in a read-only transaction. Remove the readOnly option or use a separate transaction for writes.', 'COMMIT', { cause: error, transactionState: 'read_only' });
+    }
+    if (code === '53200') {
+        return new RelqQueryError('Out of memory: The query requires too much memory. Try reducing result size with LIMIT or simplifying the query.', {
+            cause: error, sql, code
+        });
+    }
+    if (code?.startsWith('22')) {
+        return new RelqDataError(`Data error: ${message}`, 'invalid_type', { cause: error, sql, code });
+    }
+    if (code?.startsWith('23')) {
+        return new RelqConstraintError(`Constraint violation: ${message}`, 'unique', { cause: error, table: error.table, constraint: error.constraint, sql, code, detail: error.detail });
+    }
+    if (code?.startsWith('25')) {
+        return new RelqTransactionError(`Transaction error: ${message}`, 'ROLLBACK', { cause: error });
+    }
+    if (code?.startsWith('40')) {
+        return new RelqLockError(`Transaction rollback: ${message}. Retry the transaction.`, 'serialization_failure', { cause: error, sql, code });
+    }
+    if (code?.startsWith('53')) {
+        return new RelqQueryError(`Resource limit: ${message}`, { cause: error, sql, code });
+    }
+    if (code?.startsWith('54')) {
+        return new RelqQueryError(`Limit exceeded: ${message}`, { cause: error, sql, code });
+    }
+    if (code?.startsWith('55')) {
+        return new RelqQueryError(`Object state error: ${message}`, { cause: error, sql, code });
+    }
+    if (code?.startsWith('57')) {
+        return new RelqConnectionError(`Server intervention: ${message}`, { cause: error, code });
+    }
+    if (code?.startsWith('08')) {
+        return new RelqConnectionError(`Connection error: ${message}`, { cause: error, code });
+    }
     return new RelqQueryError(message, {
-        cause: error,
-        sql,
-        code,
-        detail: error.detail,
-        hint: error.hint
+        cause: error, sql, code, detail: error.detail, hint: error.hint
     });
 }
+function extractFromMessage(message, pattern) {
+    return message.match(pattern)?.[1];
+}
 const NETWORK_ERROR_CODES = new Set([
     'ECONNREFUSED', 'ECONNRESET', 'ENOTFOUND', 'ESERVFAIL',
     'ETIMEDOUT', 'EPIPE', 'EAI_AGAIN', 'EHOSTUNREACH',

package/dist/cjs/shared/types/config-types.cjs

@@ -3,14 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isPoolingEnabled = isPoolingEnabled;
 exports.toPoolConfig = toPoolConfig;
 exports.isAwsDsqlConfig = isAwsDsqlConfig;
-const pool_defaults_1 = require("../../orm/utils/pool-defaults.cjs");
+function mergeWithDefaults(userConfig) {
+    return {
+        min: userConfig?.min ?? 0,
+        max: userConfig?.max ?? 10,
+        idleTimeoutMillis: userConfig?.idleTimeoutMillis ?? 30000,
+        connectionTimeoutMillis: userConfig?.connectionTimeoutMillis ?? 10000,
+    };
+}
 function isPoolingEnabled(config) {
     return config.pooling !== false;
 }
 function toPoolConfig(config) {
     const smartDefaults = config.disableSmartDefaults
         ? { min: 0, max: 10, idleTimeoutMillis: 30000, connectionTimeoutMillis: 0 }
-        : (0, pool_defaults_1.mergeWithDefaults)(config.pool);
+        : mergeWithDefaults(config.pool);
     const isAws = !!config.aws;
     const host = isAws ? config.aws.hostname : (config.host || 'localhost');
     const port = config.aws?.port ?? config.port ?? 5432;
@@ -32,9 +39,9 @@ function toPoolConfig(config) {
         ssl: config.pool?.ssl ?? ssl,
         allowExitOnIdle
     };
-    if (config.connectionString) {
+    if (config.url) {
         return {
-            connectionString: config.connectionString,
+            connectionString: config.url,
             min: poolConfig.min,
             max: poolConfig.max,
             idleTimeoutMillis: poolConfig.idleTimeoutMillis,