@relq/orm 0.1.0

package/dist/cjs/update/update-builder.cjs

@@ -0,0 +1,274 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateBuilder = void 0;
+const pg_format_1 = __importDefault(require("../shared/pg-format.cjs"));
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const case_converter_1 = require("../utils/case-converter.cjs");
+const array_update_builder_1 = require("./array-update-builder.cjs");
+const jsonb_update_builder_1 = require("./jsonb-update-builder.cjs");
+const select_builder_1 = require("../select/select-builder.cjs");
+const count_builder_1 = require("../count/count-builder.cjs");
+class UpdateBuilder {
+    tableName;
+    updateData;
+    whereConditions = [];
+    returningClause;
+    _case = 'keep-case';
+    _convertCase = '2snake';
+    columnResolver;
+    columnTypeResolver;
+    constructor(tableName, data) {
+        this.tableName = tableName;
+        this.updateData = this.normalizeData(data);
+    }
+    normalizeData(data) {
+        const normalized = {};
+        for (const [key, value] of Object.entries(data)) {
+            normalized[key] = value === undefined ? null : value;
+        }
+        return normalized;
+    }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    setColumnTypeResolver(resolver) {
+        this.columnTypeResolver = resolver;
+        return this;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return this.convertColumnName(name);
+    }
+    transformConditionColumns(conditions) {
+        if (!this.columnResolver) {
+            return conditions;
+        }
+        return conditions.map(cond => {
+            if (cond.method === 'or' || cond.method === 'and') {
+                return {
+                    ...cond,
+                    values: this.transformConditionColumns(cond.values)
+                };
+            }
+            if (!cond.column || cond.method === 'raw') {
+                return cond;
+            }
+            if (cond.column.includes('.')) {
+                const [tableRef, colName] = cond.column.split('.');
+                return {
+                    ...cond,
+                    column: `${tableRef}.${this.columnResolver(colName)}`
+                };
+            }
+            return {
+                ...cond,
+                column: this.columnResolver(cond.column)
+            };
+        });
+    }
+    convertCase(type, conversionCase = '2snake') {
+        this._case = type;
+        this._convertCase = conversionCase;
+        return this;
+    }
+    where(callback) {
+        const conditionBuilder = new condition_collector_1.ConditionCollector();
+        callback(conditionBuilder);
+        this.whereConditions.push(...conditionBuilder.getConditions());
+        return this;
+    }
+    returning(columns) {
+        if (columns === null) {
+            this.returningClause = undefined;
+        }
+        else {
+            this.returningClause = {
+                type: 'columns',
+                columns: Array.isArray(columns) ? columns : [columns]
+            };
+        }
+        return this;
+    }
+    returningSelect(callback) {
+        const builder = new select_builder_1.SelectBuilder(this.tableName);
+        const result = callback(builder);
+        if (result === null) {
+            this.returningClause = undefined;
+        }
+        else {
+            this.returningClause = {
+                type: 'select',
+                builder: result
+            };
+        }
+        return this;
+    }
+    returningCount(callback) {
+        const builder = new count_builder_1.CountBuilder(this.tableName);
+        const result = callback(builder);
+        if (result === null) {
+            this.returningClause = undefined;
+        }
+        else {
+            this.returningClause = {
+                type: 'count',
+                builder: result
+            };
+        }
+        return this;
+    }
+    convertColumnName(name) {
+        if (this._case === 'to-lower')
+            return name.toLowerCase();
+        if (this._case === 'to-upper')
+            return name.toUpperCase();
+        if (this._case === 'convert-case')
+            return (0, case_converter_1.convertCase)(name, this._convertCase);
+        return name;
+    }
+    formatPostgresArray(value) {
+        if (value.length === 0)
+            return 'ARRAY[]';
+        const firstElement = value[0];
+        const firstType = typeof firstElement;
+        const isHomogeneous = value.every(v => typeof v === firstType);
+        if (!isHomogeneous) {
+            const jsonValues = value.map(v => (0, pg_format_1.default)('%L::jsonb', JSON.stringify(v))).join(',');
+            return `ARRAY[${jsonValues}]`;
+        }
+        if (firstType === 'string') {
+            const stringValues = value.map(v => (0, pg_format_1.default)('%L', v)).join(',');
+            return `ARRAY[${stringValues}]`;
+        }
+        if (firstType === 'number') {
+            return `ARRAY[${value.join(',')}]`;
+        }
+        if (firstType === 'boolean') {
+            return `ARRAY[${value.map(v => v.toString()).join(',')}]`;
+        }
+        if (firstType === 'object' && firstElement !== null) {
+            const jsonValues = value.map(v => (0, pg_format_1.default)('%L::jsonb', JSON.stringify(v))).join(',');
+            return `ARRAY[${jsonValues}]`;
+        }
+        const stringValues = value.map(v => (0, pg_format_1.default)('%L', v)).join(',');
+        return `ARRAY[${stringValues}]`;
+    }
+    formatJsonbValue(value) {
+        const json = JSON.stringify(value).replace(/'/g, "''");
+        return `'${json}'::jsonb`;
+    }
+    formatArrayValueWithType(colName, value) {
+        const typeInfo = this.columnTypeResolver?.(colName);
+        if (typeInfo) {
+            if (typeInfo.isArray) {
+                return this.formatPostgresArray(value);
+            }
+            else if (typeInfo.type === 'jsonb' || typeInfo.type === 'json') {
+                return this.formatJsonbValue(value);
+            }
+            else {
+                return this.formatJsonbValue(value);
+            }
+        }
+        return this.formatJsonbValue(value);
+    }
+    toString() {
+        const processedPairs = Object.entries(this.updateData).map(([col, val]) => {
+            const convertedCol = this.resolveColumnName(col);
+            if (typeof val === 'function') {
+                const operationsBuilder = {
+                    array: new array_update_builder_1.ArrayUpdateBuilder(col),
+                    jsonb: new jsonb_update_builder_1.JsonbUpdateBuilder()
+                };
+                const result = val(operationsBuilder);
+                const finalResult = result.replace(/__COLUMN__/g, pg_format_1.default.ident(convertedCol));
+                return (0, pg_format_1.default)('%I = %s', convertedCol, finalResult);
+            }
+            if (Array.isArray(val)) {
+                return (0, pg_format_1.default)('%I = %s', convertedCol, this.formatArrayValueWithType(col, val));
+            }
+            if (val !== null && typeof val === 'object' && !(val instanceof Date)) {
+                return (0, pg_format_1.default)('%I = %s', convertedCol, this.formatJsonbValue(val));
+            }
+            return (0, pg_format_1.default)('%I = %L', convertedCol, val);
+        });
+        let query = (0, pg_format_1.default)('UPDATE %I SET %s', this.tableName, processedPairs.join(', '));
+        if (this.whereConditions.length > 0) {
+            const transformedConditions = this.transformConditionColumns(this.whereConditions);
+            query += ' WHERE ' + (0, condition_collector_1.buildConditionsSQL)(transformedConditions);
+        }
+        if (this.returningClause) {
+            query += this.buildReturningClause();
+        }
+        return query;
+    }
+    parseCountColumns(columnsStr) {
+        const columns = [];
+        let depth = 0;
+        let currentExpr = '';
+        let i = 0;
+        while (i < columnsStr.length) {
+            const char = columnsStr[i];
+            if (char === '(')
+                depth++;
+            else if (char === ')')
+                depth--;
+            else if (char === ',' && depth === 0) {
+                if (currentExpr.trim()) {
+                    columns.push(this.parseColumnExpr(currentExpr.trim()));
+                }
+                currentExpr = '';
+                i++;
+                continue;
+            }
+            currentExpr += char;
+            i++;
+        }
+        if (currentExpr.trim()) {
+            columns.push(this.parseColumnExpr(currentExpr.trim()));
+        }
+        return columns;
+    }
+    parseColumnExpr(expr) {
+        const asMatch = expr.match(/^(.+?)\s+AS\s+(.+)$/i);
+        if (!asMatch) {
+            return { name: 'count', expr };
+        }
+        const [, expression, alias] = asMatch;
+        const name = alias.replace(/^["']|["']$/g, '');
+        return { name, expr: expression.trim() };
+    }
+    buildReturningClause() {
+        if (!this.returningClause)
+            return '';
+        switch (this.returningClause.type) {
+            case 'columns': {
+                const resolvedColumns = this.returningClause.columns.map(col => col === '*' ? '*' : this.resolveColumnName(col));
+                return (0, pg_format_1.default)(' RETURNING %I', resolvedColumns);
+            }
+            case 'select': {
+                const selectSQL = this.returningClause.builder.toString();
+                return ` RETURNING (${selectSQL})`;
+            }
+            case 'count': {
+                const countSQL = this.returningClause.builder.toString();
+                const selectMatch = countSQL.match(/^SELECT\s+(.+?)\s+FROM\s+(.+)$/is);
+                if (!selectMatch)
+                    return ` RETURNING (${countSQL})`;
+                const [, columnsStr, fromClause] = selectMatch;
+                const columns = this.parseCountColumns(columnsStr);
+                const jsonArgs = columns.map(({ name, expr }) => `${(0, pg_format_1.default)('%L', name)}, ${expr}`).join(', ');
+                return ` RETURNING (SELECT json_build_object(${jsonArgs}) FROM ${fromClause})`;
+            }
+            default:
+                return '';
+        }
+    }
+}
+exports.UpdateBuilder = UpdateBuilder;

package/dist/cjs/utils/addon/pg/cursor.cjs

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var pg_cursor_1 = require("../../../addon/cursor.cjs");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(pg_cursor_1).default; } });

package/dist/cjs/utils/addon/pg/pg.cjs

@@ -0,0 +1,23 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+__exportStar(require("../../../addon/pg.cjs"), exports);
+var pg_1 = require("../../../addon/pg.cjs");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(pg_1).default; } });

package/dist/cjs/utils/case-converter.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertCase = convertCase;
+function convertCase(str, type) {
+    if (!str || typeof str !== 'string')
+        return str;
+    function toCamel(s) {
+        return s.split(/[_\s-]+/).filter(segment => segment.length > 0).map((segment, index) => {
+            if (index === 0)
+                return segment.charAt(0).toLowerCase() + segment.slice(1).toLowerCase();
+            return segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase();
+        }).join('').replace(/'/g, '');
+    }
+    function toPascal(s) {
+        return s.split(/[_\s-]+/).filter(segment => segment.length > 0).map(segment => {
+            return segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase();
+        }).join('').replace(/'/g, '');
+    }
+    function toSnake(s) {
+        return s.split(/[_\s-]+/).filter(segment => segment.length > 0).map(segment => {
+            return segment.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
+        }).join('_').replace(/'/g, '');
+    }
+    switch (type) {
+        case 'snake2camel':
+            return /^[a-z0-9]+(_[a-z0-9]+)*$/.test(str)
+                ? str.split('_').map((word, index) => index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)).join('')
+                : str;
+        case 'snake2pascal':
+            return /^[a-z0-9]+(_[a-z0-9]+)*$/.test(str)
+                ? str.split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join('')
+                : str;
+        case 'camel2snake':
+            return /^[a-z][a-z0-9]*([A-Z][a-z0-9]*)*$/.test(str)
+                ? str.replace(/([A-Z])/g, '_$1').toLowerCase()
+                : str;
+        case 'camel2pascal':
+            return /^[a-z][a-z0-9]*([A-Z][a-z0-9]*)*$/.test(str)
+                ? str.charAt(0).toUpperCase() + str.slice(1)
+                : str;
+        case 'pascal2snake':
+            return /^[A-Z][a-z0-9]*([A-Z][a-z0-9]*)*$/.test(str)
+                ? str.replace(/([A-Z])/g, (match, offset) => offset > 0 ? '_' + match : match).toLowerCase()
+                : str;
+        case 'pascal2camel':
+            return /^[A-Z][a-z0-9]*([A-Z][a-z0-9]*)*$/.test(str)
+                ? str.charAt(0).toLowerCase() + str.slice(1)
+                : str;
+        case '2camel':
+            return toCamel(str);
+        case '2pascal':
+            return toPascal(str);
+        case '2snake':
+            return toSnake(str);
+        default:
+            return str;
+    }
+}

package/dist/cjs/utils/env-resolver.cjs

@@ -0,0 +1,226 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEnvFile = loadEnvFile;
+exports.resolvePgEnv = resolvePgEnv;
+exports.resolveAwsEnv = resolveAwsEnv;
+exports.hasPgEnvConfig = hasPgEnvConfig;
+exports.hasAwsEnvConfig = hasAwsEnvConfig;
+exports.validateEnvConfig = validateEnvConfig;
+exports.mergeWithPgEnv = mergeWithPgEnv;
+exports.mergeWithAwsEnv = mergeWithAwsEnv;
+const node_process_1 = __importDefault(require("node:process"));
+const relq_errors_1 = require("../shared/errors/relq-errors.cjs");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+let envLoaded = false;
+function parseEnvFile(content) {
+    const result = {};
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex === -1)
+            continue;
+        const key = trimmed.slice(0, eqIndex).trim();
+        let value = trimmed.slice(eqIndex + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        value = value.replace(/\\n/g, '\n').replace(/\\r/g, '\r');
+        result[key] = value;
+    }
+    return result;
+}
+function findEnvFile(startDir) {
+    let currentDir = (0, node_path_1.resolve)(startDir);
+    let prevDir = '';
+    while (currentDir !== prevDir) {
+        const envPath = (0, node_path_1.join)(currentDir, '.env');
+        if ((0, node_fs_1.existsSync)(envPath)) {
+            return envPath;
+        }
+        const pkgPath = (0, node_path_1.join)(currentDir, 'package.json');
+        if ((0, node_fs_1.existsSync)(pkgPath)) {
+            return null;
+        }
+        prevDir = currentDir;
+        currentDir = (0, node_path_1.dirname)(currentDir);
+    }
+    return null;
+}
+function loadEnvFile(path) {
+    if (typeof node_process_1.default === 'undefined' || !node_process_1.default.env) {
+        return {};
+    }
+    try {
+        const envPath = path ?? findEnvFile(node_process_1.default.cwd());
+        if (!envPath)
+            return {};
+        const content = (0, node_fs_1.readFileSync)(envPath, 'utf-8');
+        const vars = parseEnvFile(content);
+        for (const [key, value] of Object.entries(vars)) {
+            if (node_process_1.default.env[key] === undefined) {
+                node_process_1.default.env[key] = value;
+            }
+        }
+        return vars;
+    }
+    catch {
+        return {};
+    }
+}
+function ensureEnvLoaded() {
+    if (envLoaded)
+        return;
+    envLoaded = true;
+    loadEnvFile();
+}
+ensureEnvLoaded();
+function getEnv(key) {
+    if (typeof node_process_1.default === 'undefined' || !node_process_1.default.env) {
+        return undefined;
+    }
+    ensureEnvLoaded();
+    return node_process_1.default.env[key];
+}
+function getEnvNumber(key) {
+    const val = getEnv(key);
+    if (val === undefined)
+        return undefined;
+    const num = parseInt(val, 10);
+    return isNaN(num) ? undefined : num;
+}
+function getEnvBoolean(key) {
+    const val = getEnv(key);
+    if (val === undefined)
+        return undefined;
+    return val === 'true' || val === '1';
+}
+function resolvePgEnv() {
+    const result = {};
+    const databaseUrl = getEnv('DATABASE_URL');
+    if (databaseUrl) {
+        result.connectionString = databaseUrl;
+    }
+    result.host = getEnv('DATABASE_HOST') ?? getEnv('PGHOST');
+    result.port = getEnvNumber('DATABASE_PORT') ?? getEnvNumber('PGPORT');
+    result.user = getEnv('DATABASE_USER') ?? getEnv('PGUSER');
+    result.password = getEnv('DATABASE_PASSWORD') ?? getEnv('PGPASSWORD');
+    result.database = getEnv('DATABASE_NAME') ?? getEnv('PGDATABASE');
+    const sslMode = getEnv('DATABASE_SSL') ?? getEnv('PGSSLMODE');
+    if (sslMode) {
+        result.ssl = sslMode !== 'disable' && sslMode !== 'false' && sslMode !== '0';
+    }
+    return result;
+}
+function resolveAwsEnv() {
+    return {
+        accessKeyId: getEnv('AWS_ACCESS_KEY_ID'),
+        secretAccessKey: getEnv('AWS_SECRET_ACCESS_KEY'),
+        hostname: getEnv('AWS_DATABASE_HOST'),
+        region: getEnv('AWS_REGION') ?? getEnv('AWS_DEFAULT_REGION'),
+        database: getEnv('AWS_DATABASE_NAME') ?? 'postgres'
+    };
+}
+function hasPgEnvConfig(env) {
+    if (env.connectionString)
+        return true;
+    return !!(env.host || env.database);
+}
+function hasAwsEnvConfig(env) {
+    return !!(env.hostname && env.region);
+}
+function hasUserPgConfig(config) {
+    if (config.connectionString)
+        return true;
+    if (config.host || config.database)
+        return true;
+    return false;
+}
+function hasUserAwsConfig(config) {
+    const aws = config.aws;
+    if (!aws)
+        return false;
+    return !!(aws.hostname && aws.region);
+}
+function validateEnvConfig(dialect, config = {}) {
+    switch (dialect) {
+        case 'postgres':
+        case 'nile':
+        case 'cockroachdb': {
+            if (hasUserPgConfig(config))
+                return;
+            const env = resolvePgEnv();
+            if (hasPgEnvConfig(env))
+                return;
+            throw new relq_errors_1.RelqConfigError(`Missing database configuration for "${dialect}".\n\n` +
+                `Provide connection options or set environment variables:\n` +
+                `  DATABASE_URL=postgresql://user:pass@host:5432/dbname\n` +
+                `  or: DATABASE_HOST, DATABASE_USER, DATABASE_PASSWORD, DATABASE_NAME\n` +
+                `  or: PGHOST, PGUSER, PGPASSWORD, PGDATABASE`, { field: 'config' });
+        }
+        case 'awsdsql': {
+            if (hasUserAwsConfig(config))
+                return;
+            const env = resolveAwsEnv();
+            if (hasAwsEnvConfig(env))
+                return;
+            const missing = [];
+            if (!env.hostname)
+                missing.push('AWS_DATABASE_HOST');
+            if (!env.region)
+                missing.push('AWS_REGION');
+            throw new relq_errors_1.RelqConfigError(`Missing AWS DSQL configuration.\n\n` +
+                `Provide aws config or set environment variables:\n` +
+                `  AWS_DATABASE_HOST=cluster.dsql.us-east-1.on.aws\n` +
+                `  AWS_REGION=us-east-1\n` +
+                `  AWS_ACCESS_KEY_ID=AKIA...\n` +
+                `  AWS_SECRET_ACCESS_KEY=...\n\n` +
+                `Missing: ${missing.join(', ')}`, { field: 'config' });
+        }
+        default:
+            break;
+    }
+}
+function mergeWithPgEnv(config) {
+    const env = resolvePgEnv();
+    return {
+        ...env,
+        ...config,
+        connectionString: config.connectionString ?? env.connectionString
+    };
+}
+function mergeWithAwsEnv(config) {
+    const env = resolveAwsEnv();
+    const awsConfig = config.aws;
+    if (awsConfig) {
+        return {
+            ...config,
+            aws: {
+                hostname: env.hostname,
+                region: env.region,
+                accessKeyId: env.accessKeyId,
+                secretAccessKey: env.secretAccessKey,
+                ...awsConfig
+            }
+        };
+    }
+    if (hasAwsEnvConfig(env)) {
+        return {
+            ...config,
+            database: config.database ?? env.database,
+            aws: {
+                hostname: env.hostname,
+                region: env.region,
+                accessKeyId: env.accessKeyId,
+                secretAccessKey: env.secretAccessKey
+            }
+        };
+    }
+    return config;
+}