@relq/orm 0.1.0

package/dist/cjs/shared/aws-dsql.cjs

@@ -0,0 +1,181 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAwsDsqlToken = getAwsDsqlToken;
+exports.clearAwsDsqlToken = clearAwsDsqlToken;
+exports.isAwsDsql = isAwsDsql;
+const node_process_1 = __importDefault(require("node:process"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const node_crypto_1 = require("node:crypto");
+const node_constants_1 = require("node:constants");
+const relq_errors_1 = require("./errors/relq-errors.cjs");
+const tokenCache = new Map();
+function getCacheKey(config) {
+    const hash = (0, node_crypto_1.createHash)('md5')
+        .update(`${config.secretAccessKey ?? ''}-${config.accessKeyId ?? ''}-${config.region}-${config.hostname}`)
+        .digest('hex');
+    return hash;
+}
+function getTempFolder() {
+    return (0, node_path_1.join)((0, node_os_1.tmpdir)(), '.dsql_');
+}
+function isTempFolderAvailable() {
+    const tempFolder = getTempFolder();
+    try {
+        (0, node_fs_1.mkdirSync)(tempFolder, { recursive: true });
+        (0, node_fs_1.accessSync)(tempFolder, node_constants_1.F_OK | node_constants_1.R_OK | node_constants_1.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getFromCache(cacheKey) {
+    const memoryToken = tokenCache.get(cacheKey);
+    if (memoryToken && memoryToken.expiresAt > Date.now()) {
+        return memoryToken;
+    }
+    const envName = `DSQL_TOKEN_${cacheKey}`;
+    const envToken = node_process_1.default.env[envName];
+    if (envToken) {
+        try {
+            const parsed = JSON.parse(envToken);
+            if (parsed.expiresAt > Date.now()) {
+                tokenCache.set(cacheKey, parsed);
+                return parsed;
+            }
+        }
+        catch { }
+    }
+    if (isTempFolderAvailable()) {
+        const tokenFile = (0, node_path_1.join)(getTempFolder(), `${cacheKey}.json`);
+        if ((0, node_fs_1.existsSync)(tokenFile)) {
+            try {
+                const parsed = JSON.parse((0, node_fs_1.readFileSync)(tokenFile, 'utf8'));
+                if (parsed.expiresAt > Date.now()) {
+                    tokenCache.set(cacheKey, parsed);
+                    node_process_1.default.env[envName] = JSON.stringify(parsed);
+                    return parsed;
+                }
+            }
+            catch { }
+        }
+    }
+    return null;
+}
+function saveToCache(cacheKey, token) {
+    tokenCache.set(cacheKey, token);
+    const envName = `DSQL_TOKEN_${cacheKey}`;
+    node_process_1.default.env[envName] = JSON.stringify(token);
+    if (isTempFolderAvailable()) {
+        const tokenFile = (0, node_path_1.join)(getTempFolder(), `${cacheKey}.json`);
+        try {
+            (0, node_fs_1.writeFileSync)(tokenFile, JSON.stringify(token));
+        }
+        catch { }
+    }
+}
+let DsqlSigner = null;
+async function loadAwsSdk() {
+    if (!DsqlSigner) {
+        try {
+            const sdk = await Promise.resolve().then(() => __importStar(require('@aws-sdk/dsql-signer')));
+            DsqlSigner = sdk.DsqlSigner;
+        }
+        catch (error) {
+            throw new relq_errors_1.RelqConfigError('AWS DSQL requires @aws-sdk/dsql-signer package.\n\n' +
+                'Install it with:\n' +
+                '  npm install @aws-sdk/dsql-signer\n' +
+                '  # or\n' +
+                '  bun add @aws-sdk/dsql-signer', { field: '@aws-sdk/dsql-signer', value: 'not installed' });
+        }
+    }
+    return DsqlSigner;
+}
+async function getAwsDsqlToken(config) {
+    const cacheKey = getCacheKey(config);
+    const cached = getFromCache(cacheKey);
+    if (cached) {
+        return cached.token;
+    }
+    if (!config.useDefaultCredentials && (!config.accessKeyId || !config.secretAccessKey)) {
+        throw new relq_errors_1.RelqConfigError('AWS DSQL requires credentials. Either provide accessKeyId + secretAccessKey, ' +
+            'or set useDefaultCredentials: true to use AWS credential chain.', { field: 'aws.credentials', value: 'missing' });
+    }
+    const SignerClass = await loadAwsSdk();
+    const expiresIn = config.tokenExpiresIn ?? 604800;
+    const signerConfig = {
+        hostname: config.hostname,
+        region: config.region,
+        expiresIn,
+    };
+    if (!config.useDefaultCredentials) {
+        signerConfig.credentials = {
+            accessKeyId: config.accessKeyId,
+            secretAccessKey: config.secretAccessKey,
+        };
+    }
+    const signer = new SignerClass(signerConfig);
+    const token = await signer.getDbConnectAdminAuthToken();
+    const cachedToken = {
+        token,
+        expiresAt: Date.now() + ((expiresIn - 30) * 1000)
+    };
+    saveToCache(cacheKey, cachedToken);
+    return token;
+}
+function clearAwsDsqlToken(config) {
+    const cacheKey = getCacheKey(config);
+    tokenCache.delete(cacheKey);
+    const envName = `DSQL_TOKEN_${cacheKey}`;
+    delete node_process_1.default.env[envName];
+    if (isTempFolderAvailable()) {
+        const tokenFile = (0, node_path_1.join)(getTempFolder(), `${cacheKey}.json`);
+        try {
+            if ((0, node_fs_1.existsSync)(tokenFile)) {
+                (0, node_fs_1.writeFileSync)(tokenFile, '');
+            }
+        }
+        catch { }
+    }
+}
+function isAwsDsql(config) {
+    return !!config.aws?.hostname && !!config.aws?.region;
+}

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

@@ -0,0 +1,361 @@
+"use strict";
+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.setupErrorHandler = setupErrorHandler;
+exports.isRelqError = isRelqError;
+exports.isRelqConnectionError = isRelqConnectionError;
+exports.isRelqQueryError = isRelqQueryError;
+exports.isRelqBuilderError = isRelqBuilderError;
+exports.wrapError = wrapError;
+exports.parsePostgresError = parsePostgresError;
+const node_process_1 = __importDefault(require("node:process"));
+function setupErrorHandler() {
+    if (typeof node_process_1.default === 'undefined' || !node_process_1.default.on)
+        return;
+    node_process_1.default.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'));
+            }
+        }
+        node_process_1.default.exit();
+    });
+    node_process_1.default.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);
+        }
+        node_process_1.default.exit();
+    });
+}
+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
+        };
+    }
+}
+exports.RelqError = RelqError;
+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
+        };
+    }
+}
+exports.RelqConnectionError = RelqConnectionError;
+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
+        };
+    }
+}
+exports.RelqQueryError = RelqQueryError;
+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
+        };
+    }
+}
+exports.RelqTransactionError = RelqTransactionError;
+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
+        };
+    }
+}
+exports.RelqConfigError = RelqConfigError;
+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
+        };
+    }
+}
+exports.RelqTimeoutError = RelqTimeoutError;
+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
+        };
+    }
+}
+exports.RelqPoolError = RelqPoolError;
+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
+        };
+    }
+}
+exports.RelqEnvironmentError = RelqEnvironmentError;
+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
+        };
+    }
+}
+exports.RelqBuilderError = RelqBuilderError;
+function isRelqError(error) {
+    return error instanceof RelqError;
+}
+function isRelqConnectionError(error) {
+    return error instanceof RelqConnectionError;
+}
+function isRelqQueryError(error) {
+    return error instanceof RelqQueryError;
+}
+function isRelqBuilderError(error) {
+    return error instanceof RelqBuilderError;
+}
+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);
+}
+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);
+}