@relq/orm 0.1.0

package/dist/esm/shared/errors/relq-errors.js

@@ -0,0 +1,339 @@
+import process from 'node:process';
+export function setupErrorHandler() {
+    if (typeof process === 'undefined' || !process.on)
+        return;
+    process.on('uncaughtException', (error) => {
+        if (error instanceof RelqError) {
+            const inspect = error[Symbol.for('nodejs.util.inspect.custom')];
+            if (typeof inspect === 'function') {
+                console.error(inspect.call(error, 0, {}));
+            }
+            else {
+                console.error(`${error.name}: ${error.message}`);
+            }
+        }
+        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'));
+            }
+        }
+        process.exit();
+    });
+    process.on('unhandledRejection', (reason) => {
+        if (reason instanceof RelqError) {
+            const inspect = reason[Symbol.for('nodejs.util.inspect.custom')];
+            if (typeof inspect === 'function') {
+                console.error(inspect.call(reason, 0, {}));
+            }
+            else {
+                console.error(`${reason.name}: ${reason.message}`);
+            }
+        }
+        else if (reason instanceof Error) {
+            console.error(`${reason.name || 'Error'}: ${reason.message}`);
+            if (reason.stack) {
+                const stackLines = reason.stack.split('\n').filter(line => line.trim().startsWith('at '));
+                console.error(stackLines.slice(0, 5).join('\n'));
+            }
+        }
+        else {
+            console.error('Unhandled rejection:', reason);
+        }
+        process.exit();
+    });
+}
+export class RelqError extends Error {
+    name;
+    cause;
+    timestamp;
+    constructor(message, cause) {
+        super(message);
+        this.name = 'RelqError';
+        this.cause = cause;
+        this.timestamp = new Date();
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    [Symbol.for('nodejs.util.inspect.custom')](_depth, _options) {
+        const lines = [
+            `${this.name}: ${this.message}`,
+            ` timestamp: ${this.timestamp.toISOString()}`
+        ];
+        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));
+        }
+        return lines.join('\n');
+    }
+    _getInspectProps() {
+        return {};
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            cause: this.cause?.message,
+            timestamp: this.timestamp.toISOString(),
+            stack: this.stack
+        };
+    }
+}
+export class RelqConnectionError extends RelqError {
+    name = 'RelqConnectionError';
+    code;
+    host;
+    port;
+    constructor(message, options) {
+        super(message, options?.cause);
+        this.code = options?.code;
+        this.host = options?.host;
+        this.port = options?.port;
+    }
+    _getInspectProps() {
+        return { code: this.code, host: this.host, port: this.port };
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            code: this.code,
+            host: this.host,
+            port: this.port
+        };
+    }
+}
+export class RelqQueryError extends RelqError {
+    name = 'RelqQueryError';
+    sql;
+    code;
+    detail;
+    hint;
+    constructor(message, options) {
+        super(message, options?.cause);
+        this.sql = options?.sql;
+        this.code = options?.code;
+        this.detail = options?.detail;
+        this.hint = options?.hint;
+    }
+    _getInspectProps() {
+        return { sql: this.sql, detail: this.detail, hint: this.hint, code: this.code };
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            sql: this.sql,
+            code: this.code,
+            detail: this.detail,
+            hint: this.hint
+        };
+    }
+}
+export class RelqTransactionError extends RelqError {
+    name = 'RelqTransactionError';
+    operation;
+    transactionState;
+    constructor(message, operation, options) {
+        super(message, options?.cause);
+        this.operation = operation;
+        this.transactionState = options?.transactionState;
+    }
+    _getInspectProps() {
+        return { operation: this.operation, transactionState: this.transactionState };
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            operation: this.operation,
+            transactionState: this.transactionState
+        };
+    }
+}
+export class RelqConfigError extends RelqError {
+    name = 'RelqConfigError';
+    field;
+    value;
+    constructor(message, options) {
+        super(message);
+        this.field = options?.field;
+        this.value = options?.value;
+    }
+    _getInspectProps() {
+        return { field: this.field, value: this.value };
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            field: this.field,
+            value: this.value
+        };
+    }
+}
+export class RelqTimeoutError extends RelqError {
+    name = 'RelqTimeoutError';
+    timeout;
+    operation;
+    constructor(message, timeout, operation, cause) {
+        super(message, cause);
+        this.timeout = timeout;
+        this.operation = operation;
+    }
+    _getInspectProps() {
+        return { timeout: this.timeout, operation: this.operation };
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            timeout: this.timeout,
+            operation: this.operation
+        };
+    }
+}
+export class RelqPoolError extends RelqError {
+    name = 'RelqPoolError';
+    poolSize;
+    activeConnections;
+    waitingClients;
+    constructor(message, options) {
+        super(message, options?.cause);
+        this.poolSize = options?.poolSize;
+        this.activeConnections = options?.activeConnections;
+        this.waitingClients = options?.waitingClients;
+    }
+    _getInspectProps() {
+        return { poolSize: this.poolSize, activeConnections: this.activeConnections, waitingClients: this.waitingClients };
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            poolSize: this.poolSize,
+            activeConnections: this.activeConnections,
+            waitingClients: this.waitingClients
+        };
+    }
+}
+export class RelqEnvironmentError extends RelqError {
+    name = 'RelqEnvironmentError';
+    environment;
+    reason;
+    constructor(message, environment, reason) {
+        super(message);
+        this.environment = environment;
+        this.reason = reason;
+    }
+    _getInspectProps() {
+        return { environment: this.environment, reason: this.reason };
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            environment: this.environment,
+            reason: this.reason
+        };
+    }
+}
+export class RelqBuilderError extends RelqError {
+    name = 'RelqBuilderError';
+    builder;
+    missing;
+    hint;
+    constructor(message, options) {
+        super(message);
+        this.builder = options?.builder;
+        this.missing = options?.missing;
+        this.hint = options?.hint;
+    }
+    _getInspectProps() {
+        return { builder: this.builder, missing: this.missing, hint: this.hint };
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            builder: this.builder,
+            missing: this.missing,
+            hint: this.hint
+        };
+    }
+}
+export function isRelqError(error) {
+    return error instanceof RelqError;
+}
+export function isRelqConnectionError(error) {
+    return error instanceof RelqConnectionError;
+}
+export function isRelqQueryError(error) {
+    return error instanceof RelqQueryError;
+}
+export function isRelqBuilderError(error) {
+    return error instanceof RelqBuilderError;
+}
+export function wrapError(error, context) {
+    if (isRelqError(error)) {
+        return error;
+    }
+    if (error instanceof Error) {
+        const message = context ? `${context}: ${error.message}` : error.message;
+        return new RelqError(message, error);
+    }
+    const message = context
+        ? `${context}: ${String(error)}`
+        : String(error);
+    return new RelqError(message);
+}
+export function parsePostgresError(error, sql) {
+    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
+        });
+    }
+    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 === '57014') {
+        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);
+    }
+    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
+        });
+    }
+    return new RelqQueryError(message, {
+        cause: error,
+        sql,
+        code,
+        detail: error.detail,
+        hint: error.hint
+    });
+}
+const NETWORK_ERROR_CODES = new Set([
+    'ECONNREFUSED', 'ECONNRESET', 'ENOTFOUND', 'ESERVFAIL',
+    'ETIMEDOUT', 'EPIPE', 'EAI_AGAIN', 'EHOSTUNREACH',
+    'CONNECTION_LOST', 'PROTOCOL_CONNECTION_LOST',
+]);
+function isNetworkErrorCode(code) {
+    return !!code && NETWORK_ERROR_CODES.has(code);
+}

package/dist/esm/shared/pg-format.js

@@ -0,0 +1,375 @@
+const reservedMap = {
+    "AES128": true,
+    "AES256": true,
+    "ALL": true,
+    "ALLOWOVERWRITE": true,
+    "ANALYSE": true,
+    "ANALYZE": true,
+    "AND": true,
+    "ANY": true,
+    "ARRAY": true,
+    "AS": true,
+    "ASC": true,
+    "AUTHORIZATION": true,
+    "BACKUP": true,
+    "BETWEEN": true,
+    "BINARY": true,
+    "BLANKSASNULL": true,
+    "BOTH": true,
+    "BYTEDICT": true,
+    "CASE": true,
+    "CAST": true,
+    "CHECK": true,
+    "COLLATE": true,
+    "COLUMN": true,
+    "CONSTRAINT": true,
+    "CREATE": true,
+    "CREDENTIALS": true,
+    "CROSS": true,
+    "CURRENT_DATE": true,
+    "CURRENT_TIME": true,
+    "CURRENT_TIMESTAMP": true,
+    "CURRENT_USER": true,
+    "CURRENT_USER_ID": true,
+    "DEFAULT": true,
+    "DEFERRABLE": true,
+    "DEFLATE": true,
+    "DEFRAG": true,
+    "DELTA": true,
+    "DELTA32K": true,
+    "DESC": true,
+    "DISABLE": true,
+    "DISTINCT": true,
+    "DO": true,
+    "ELSE": true,
+    "EMPTYASNULL": true,
+    "ENABLE": true,
+    "ENCODE": true,
+    "ENCRYPT": true,
+    "ENCRYPTION": true,
+    "END": true,
+    "EXCEPT": true,
+    "EXPLICIT": true,
+    "FALSE": true,
+    "FOR": true,
+    "FOREIGN": true,
+    "FREEZE": true,
+    "FROM": true,
+    "FULL": true,
+    "GLOBALDICT256": true,
+    "GLOBALDICT64K": true,
+    "GRANT": true,
+    "GROUP": true,
+    "GZIP": true,
+    "HAVING": true,
+    "IDENTITY": true,
+    "IGNORE": true,
+    "ILIKE": true,
+    "IN": true,
+    "INITIALLY": true,
+    "INNER": true,
+    "INTERSECT": true,
+    "INTO": true,
+    "IS": true,
+    "ISNULL": true,
+    "JOIN": true,
+    "LEADING": true,
+    "LEFT": true,
+    "LIKE": true,
+    "LIMIT": true,
+    "LOCALTIME": true,
+    "LOCALTIMESTAMP": true,
+    "LUN": true,
+    "LUNS": true,
+    "LZO": true,
+    "LZOP": true,
+    "MINUS": true,
+    "MOSTLY13": true,
+    "MOSTLY32": true,
+    "MOSTLY8": true,
+    "NATURAL": true,
+    "NEW": true,
+    "NOT": true,
+    "NOTNULL": true,
+    "NULL": true,
+    "NULLS": true,
+    "OFF": true,
+    "OFFLINE": true,
+    "OFFSET": true,
+    "OLD": true,
+    "ON": true,
+    "ONLY": true,
+    "OPEN": true,
+    "OR": true,
+    "ORDER": true,
+    "OUTER": true,
+    "OVERLAPS": true,
+    "PARALLEL": true,
+    "PARTITION": true,
+    "PERCENT": true,
+    "PLACING": true,
+    "PRIMARY": true,
+    "RAW": true,
+    "READRATIO": true,
+    "RECOVER": true,
+    "REFERENCES": true,
+    "REJECTLOG": true,
+    "RESORT": true,
+    "RESTORE": true,
+    "RIGHT": true,
+    "SELECT": true,
+    "SESSION_USER": true,
+    "SIMILAR": true,
+    "SOME": true,
+    "SYSDATE": true,
+    "SYSTEM": true,
+    "TABLE": true,
+    "TAG": true,
+    "TDES": true,
+    "TEXT255": true,
+    "TEXT32K": true,
+    "THEN": true,
+    "TO": true,
+    "TOP": true,
+    "TRAILING": true,
+    "TRUE": true,
+    "TRUNCATECOLUMNS": true,
+    "UNION": true,
+    "UNIQUE": true,
+    "USER": true,
+    "USING": true,
+    "VERBOSE": true,
+    "WALLET": true,
+    "WHEN": true,
+    "WHERE": true,
+    "WITH": true,
+    "WITHOUT": true,
+};
+const fmtPattern = {
+    ident: 'I',
+    literal: 'L',
+    string: 's',
+};
+function formatDate(date) {
+    date = date.replace('T', ' ');
+    date = date.replace('Z', '+00');
+    return date;
+}
+function isReserved(value) {
+    return !!reservedMap[value.toUpperCase()];
+}
+function arrayToList(useSpace, array, formatter) {
+    let sql = useSpace ? ' (' : '(';
+    for (let i = 0; i < array.length; i++) {
+        sql += (i === 0 ? '' : ', ') + formatter(array[i]);
+    }
+    sql += ')';
+    return sql;
+}
+export function quoteIdent(value) {
+    if (value === undefined || value === null) {
+        throw new Error('SQL identifier cannot be null or undefined');
+    }
+    else if (value === false) {
+        return '"f"';
+    }
+    else if (value === true) {
+        return '"t"';
+    }
+    else if (value instanceof Date) {
+        return '"' + formatDate(value.toISOString()) + '"';
+    }
+    else if (typeof Buffer !== 'undefined' && value instanceof Buffer) {
+        throw new Error('SQL identifier cannot be a buffer');
+    }
+    else if (Array.isArray(value)) {
+        const temp = [];
+        for (let i = 0; i < value.length; i++) {
+            if (Array.isArray(value[i])) {
+                throw new Error('Nested array to grouped list conversion is not supported for SQL identifier');
+            }
+            else {
+                temp.push(quoteIdent(value[i]));
+            }
+        }
+        return temp.toString();
+    }
+    else if (value === Object(value)) {
+        throw new Error('SQL identifier cannot be an object');
+    }
+    const ident = value.toString().slice(0);
+    if (/^[a-z_][a-z0-9_$]*$/.test(ident) && !isReserved(ident)) {
+        return ident;
+    }
+    let quoted = '"';
+    for (let i = 0; i < ident.length; i++) {
+        const c = ident[i];
+        if (c === '"') {
+            quoted += c + c;
+        }
+        else {
+            quoted += c;
+        }
+    }
+    quoted += '"';
+    return quoted;
+}
+export function quoteLiteral(value) {
+    let literal = '';
+    let explicitCast = null;
+    if (value === undefined || value === null) {
+        return 'NULL';
+    }
+    else if (value === false) {
+        return "'f'";
+    }
+    else if (value === true) {
+        return "'t'";
+    }
+    else if (value instanceof Date) {
+        return "'" + formatDate(value.toISOString()) + "'";
+    }
+    else if (typeof Buffer !== 'undefined' && value instanceof Buffer) {
+        return "E'\\\\x" + value.toString('hex') + "'";
+    }
+    else if (Array.isArray(value)) {
+        const temp = [];
+        for (let i = 0; i < value.length; i++) {
+            if (Array.isArray(value[i])) {
+                temp.push(arrayToList(i !== 0, value[i], quoteLiteral));
+            }
+            else {
+                temp.push(quoteLiteral(value[i]));
+            }
+        }
+        return temp.toString();
+    }
+    else if (value === Object(value)) {
+        explicitCast = 'jsonb';
+        literal = JSON.stringify(value);
+    }
+    else {
+        literal = value.toString().slice(0);
+    }
+    let hasBackslash = false;
+    let quoted = "'";
+    for (let i = 0; i < literal.length; i++) {
+        const c = literal[i];
+        if (c === "'") {
+            quoted += c + c;
+        }
+        else if (c === '\\') {
+            quoted += c + c;
+            hasBackslash = true;
+        }
+        else {
+            quoted += c;
+        }
+    }
+    quoted += "'";
+    if (hasBackslash) {
+        quoted = 'E' + quoted;
+    }
+    if (explicitCast) {
+        quoted += '::' + explicitCast;
+    }
+    return quoted;
+}
+export function quoteString(value) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    else if (value === false) {
+        return 'f';
+    }
+    else if (value === true) {
+        return 't';
+    }
+    else if (value instanceof Date) {
+        return formatDate(value.toISOString());
+    }
+    else if (typeof Buffer !== 'undefined' && value instanceof Buffer) {
+        return '\\x' + value.toString('hex');
+    }
+    else if (Array.isArray(value)) {
+        const temp = [];
+        for (let i = 0; i < value.length; i++) {
+            if (value[i] !== null && value[i] !== undefined) {
+                if (Array.isArray(value[i])) {
+                    temp.push(arrayToList(i !== 0, value[i], quoteString));
+                }
+                else {
+                    temp.push(quoteString(value[i]));
+                }
+            }
+        }
+        return temp.toString();
+    }
+    else if (value === Object(value)) {
+        return JSON.stringify(value);
+    }
+    return value.toString().slice(0);
+}
+export function config(cfg) {
+    fmtPattern.ident = 'I';
+    fmtPattern.literal = 'L';
+    fmtPattern.string = 's';
+    if (cfg && cfg.pattern) {
+        if (cfg.pattern.ident) {
+            fmtPattern.ident = cfg.pattern.ident;
+        }
+        if (cfg.pattern.literal) {
+            fmtPattern.literal = cfg.pattern.literal;
+        }
+        if (cfg.pattern.string) {
+            fmtPattern.string = cfg.pattern.string;
+        }
+    }
+}
+export function formatWithArray(fmt, parameters) {
+    const params = parameters;
+    let re = '%(%|(\\d+\\$)?[';
+    re += fmtPattern.ident;
+    re += fmtPattern.literal;
+    re += fmtPattern.string;
+    re += '])';
+    const regex = new RegExp(re, 'g');
+    let index = 0;
+    return fmt.replace(regex, function (_, type) {
+        if (type === '%') {
+            return '%';
+        }
+        let position = index;
+        const tokens = type.split('$');
+        if (tokens.length > 1) {
+            position = parseInt(tokens[0]) - 1;
+            type = tokens[1];
+        }
+        if (position < 0) {
+            throw new Error('specified argument 0 but arguments start at 1');
+        }
+        else if (position > params.length - 1) {
+            throw new Error('too few arguments');
+        }
+        index = position + 1;
+        if (type === fmtPattern.ident) {
+            return quoteIdent(params[position]);
+        }
+        else if (type === fmtPattern.literal) {
+            return quoteLiteral(params[position]);
+        }
+        else if (type === fmtPattern.string) {
+            return quoteString(params[position]);
+        }
+        return _;
+    });
+}
+export function format(fmt, ...args) {
+    return formatWithArray(fmt, args);
+}
+export default format;
+format.ident = quoteIdent;
+format.literal = quoteLiteral;
+format.string = quoteString;
+format.withArray = formatWithArray;
+format.config = config;