@relq/orm 0.1.0

package/dist/esm/update/update-builder.js

@@ -0,0 +1,267 @@
+import format from "../shared/pg-format.js";
+import { ConditionCollector, buildConditionsSQL } from "../condition/condition-collector.js";
+import { convertCase } from "../utils/case-converter.js";
+import { ArrayUpdateBuilder } from "./array-update-builder.js";
+import { JsonbUpdateBuilder } from "./jsonb-update-builder.js";
+import { SelectBuilder } from "../select/select-builder.js";
+import { CountBuilder } from "../count/count-builder.js";
+export 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 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 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 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 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 => format('%L::jsonb', JSON.stringify(v))).join(',');
+            return `ARRAY[${jsonValues}]`;
+        }
+        if (firstType === 'string') {
+            const stringValues = value.map(v => format('%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 => format('%L::jsonb', JSON.stringify(v))).join(',');
+            return `ARRAY[${jsonValues}]`;
+        }
+        const stringValues = value.map(v => format('%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 ArrayUpdateBuilder(col),
+                    jsonb: new JsonbUpdateBuilder()
+                };
+                const result = val(operationsBuilder);
+                const finalResult = result.replace(/__COLUMN__/g, format.ident(convertedCol));
+                return format('%I = %s', convertedCol, finalResult);
+            }
+            if (Array.isArray(val)) {
+                return format('%I = %s', convertedCol, this.formatArrayValueWithType(col, val));
+            }
+            if (val !== null && typeof val === 'object' && !(val instanceof Date)) {
+                return format('%I = %s', convertedCol, this.formatJsonbValue(val));
+            }
+            return format('%I = %L', convertedCol, val);
+        });
+        let query = format('UPDATE %I SET %s', this.tableName, processedPairs.join(', '));
+        if (this.whereConditions.length > 0) {
+            const transformedConditions = this.transformConditionColumns(this.whereConditions);
+            query += ' WHERE ' + 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 format(' 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 }) => `${format('%L', name)}, ${expr}`).join(', ');
+                return ` RETURNING (SELECT json_build_object(${jsonArgs}) FROM ${fromClause})`;
+            }
+            default:
+                return '';
+        }
+    }
+}

package/dist/esm/utils/addon/pg/cursor.js

@@ -0,0 +1 @@
+export { default } from "../../../addon/cursor.js";

package/dist/esm/utils/addon/pg/pg.js

@@ -0,0 +1,2 @@
+export * from "../../../addon/pg.js";
+export { default } from "../../../addon/pg.js";

package/dist/esm/utils/case-converter.js

@@ -0,0 +1,55 @@
+export 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/esm/utils/env-resolver.js

@@ -0,0 +1,213 @@
+import process from 'node:process';
+import { RelqConfigError } from "../shared/errors/relq-errors.js";
+import { existsSync, readFileSync } from 'node:fs';
+import { join, dirname, resolve } from '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 = resolve(startDir);
+    let prevDir = '';
+    while (currentDir !== prevDir) {
+        const envPath = join(currentDir, '.env');
+        if (existsSync(envPath)) {
+            return envPath;
+        }
+        const pkgPath = join(currentDir, 'package.json');
+        if (existsSync(pkgPath)) {
+            return null;
+        }
+        prevDir = currentDir;
+        currentDir = dirname(currentDir);
+    }
+    return null;
+}
+export function loadEnvFile(path) {
+    if (typeof process === 'undefined' || !process.env) {
+        return {};
+    }
+    try {
+        const envPath = path ?? findEnvFile(process.cwd());
+        if (!envPath)
+            return {};
+        const content = readFileSync(envPath, 'utf-8');
+        const vars = parseEnvFile(content);
+        for (const [key, value] of Object.entries(vars)) {
+            if (process.env[key] === undefined) {
+                process.env[key] = value;
+            }
+        }
+        return vars;
+    }
+    catch {
+        return {};
+    }
+}
+function ensureEnvLoaded() {
+    if (envLoaded)
+        return;
+    envLoaded = true;
+    loadEnvFile();
+}
+ensureEnvLoaded();
+function getEnv(key) {
+    if (typeof process === 'undefined' || !process.env) {
+        return undefined;
+    }
+    ensureEnvLoaded();
+    return process.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';
+}
+export 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;
+}
+export 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'
+    };
+}
+export function hasPgEnvConfig(env) {
+    if (env.connectionString)
+        return true;
+    return !!(env.host || env.database);
+}
+export 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);
+}
+export 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 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 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;
+    }
+}
+export function mergeWithPgEnv(config) {
+    const env = resolvePgEnv();
+    return {
+        ...env,
+        ...config,
+        connectionString: config.connectionString ?? env.connectionString
+    };
+}
+export 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;
+}

package/dist/esm/utils/environment-detection.js

@@ -0,0 +1,114 @@
+import process from 'node:process';
+export function detectEnvironment() {
+    const detected = [];
+    const hasProcess = typeof process !== 'undefined' && process.env !== undefined;
+    if (!hasProcess) {
+        return {
+            type: 'edge',
+            provider: 'cloudflare',
+            detected: ['NO_PROCESS_OBJECT'],
+            hasProcess: false
+        };
+    }
+    if (process.env.VERCEL || process.env.VERCEL_ENV) {
+        if (process.env.VERCEL)
+            detected.push('VERCEL');
+        if (process.env.VERCEL_ENV)
+            detected.push('VERCEL_ENV');
+        return {
+            type: 'serverless',
+            provider: 'vercel',
+            detected,
+            hasProcess: true
+        };
+    }
+    if (process.env.AWS_LAMBDA_FUNCTION_NAME ||
+        process.env.AWS_EXECUTION_ENV ||
+        process.env.LAMBDA_TASK_ROOT) {
+        if (process.env.AWS_LAMBDA_FUNCTION_NAME)
+            detected.push('AWS_LAMBDA_FUNCTION_NAME');
+        if (process.env.AWS_EXECUTION_ENV)
+            detected.push('AWS_EXECUTION_ENV');
+        if (process.env.LAMBDA_TASK_ROOT)
+            detected.push('LAMBDA_TASK_ROOT');
+        return {
+            type: 'serverless',
+            provider: 'aws-lambda',
+            detected,
+            hasProcess: true
+        };
+    }
+    if (process.env.NETLIFY || process.env.NETLIFY_DEV) {
+        if (process.env.NETLIFY)
+            detected.push('NETLIFY');
+        if (process.env.NETLIFY_DEV)
+            detected.push('NETLIFY_DEV');
+        return {
+            type: 'serverless',
+            provider: 'netlify',
+            detected,
+            hasProcess: true
+        };
+    }
+    if (process.env.FUNCTION_NAME || process.env.FUNCTION_TARGET || process.env.GCP_PROJECT) {
+        if (process.env.FUNCTION_NAME)
+            detected.push('FUNCTION_NAME');
+        if (process.env.FUNCTION_TARGET)
+            detected.push('FUNCTION_TARGET');
+        if (process.env.GCP_PROJECT)
+            detected.push('GCP_PROJECT');
+        return {
+            type: 'serverless',
+            provider: 'google-cloud',
+            detected,
+            hasProcess: true
+        };
+    }
+    if (process.env.AZURE_FUNCTIONS_ENVIRONMENT || process.env.WEBSITE_INSTANCE_ID) {
+        if (process.env.AZURE_FUNCTIONS_ENVIRONMENT)
+            detected.push('AZURE_FUNCTIONS_ENVIRONMENT');
+        if (process.env.WEBSITE_INSTANCE_ID)
+            detected.push('WEBSITE_INSTANCE_ID');
+        return {
+            type: 'serverless',
+            provider: 'azure',
+            detected,
+            hasProcess: true
+        };
+    }
+    if (process.env.CLOUDFLARE_WORKERS || process.env.CF_PAGES) {
+        if (process.env.CLOUDFLARE_WORKERS)
+            detected.push('CLOUDFLARE_WORKERS');
+        if (process.env.CF_PAGES)
+            detected.push('CF_PAGES');
+        return {
+            type: 'edge',
+            provider: 'cloudflare',
+            detected,
+            hasProcess: true
+        };
+    }
+    return {
+        type: 'traditional',
+        detected: [],
+        hasProcess: true
+    };
+}
+export function isServerless() {
+    return detectEnvironment().type === 'serverless';
+}
+export function isTraditional() {
+    return detectEnvironment().type === 'traditional';
+}
+export function isEdge() {
+    return detectEnvironment().type === 'edge';
+}
+export function getEnvironmentDescription(env) {
+    if (env.type === 'serverless') {
+        return `${env.provider} (serverless)`;
+    }
+    if (env.type === 'edge') {
+        return `${env.provider || 'edge'} runtime`;
+    }
+    return 'Traditional server';
+}