relq 1.0.0

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

@@ -0,0 +1,195 @@
+"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("../../addons/pg-format.js"));
+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 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';
+    constructor(tableName, data) {
+        this.tableName = tableName;
+        this.updateData = data;
+    }
+    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;
+    }
+    formatArrayValue(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}]`;
+    }
+    toString() {
+        const processedPairs = Object.entries(this.updateData).map(([col, val]) => {
+            const convertedCol = this.convertColumnName(col);
+            if (typeof val === 'function') {
+                const arrayBuilder = new array_update_builder_1.ArrayUpdateBuilder(col);
+                const result = val(arrayBuilder);
+                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.formatArrayValue(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) {
+            query += ' WHERE ' + (0, condition_collector_1.buildConditionsSQL)(this.whereConditions);
+        }
+        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':
+                return (0, pg_format_1.default)(' RETURNING %I', this.returningClause.columns);
+            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/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/environment-detection.cjs

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectEnvironment = detectEnvironment;
+exports.isServerless = isServerless;
+exports.isTraditional = isTraditional;
+exports.isEdge = isEdge;
+exports.getEnvironmentDescription = getEnvironmentDescription;
+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
+    };
+}
+function isServerless() {
+    return detectEnvironment().type === 'serverless';
+}
+function isTraditional() {
+    return detectEnvironment().type === 'traditional';
+}
+function isEdge() {
+    return detectEnvironment().type === 'edge';
+}
+function getEnvironmentDescription(env) {
+    if (env.type === 'serverless') {
+        return `${env.provider} (serverless)`;
+    }
+    if (env.type === 'edge') {
+        return `${env.provider || 'edge'} runtime`;
+    }
+    return 'Traditional server';
+}

package/dist/cjs/utils/index.cjs

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = exports.convertCase = void 0;
+var case_converter_1 = require("./case-converter.cjs");
+Object.defineProperty(exports, "convertCase", { enumerable: true, get: function () { return case_converter_1.convertCase; } });
+var pg_format_1 = require("../../addons/pg-format.js");
+Object.defineProperty(exports, "format", { enumerable: true, get: function () { return __importDefault(pg_format_1).default; } });

package/dist/cjs/utils/pool-defaults.cjs

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSmartPoolDefaults = getSmartPoolDefaults;
+exports.validatePoolConfig = validatePoolConfig;
+exports.mergeWithDefaults = mergeWithDefaults;
+exports.formatPoolConfig = formatPoolConfig;
+const environment_detection_1 = require("./environment-detection.cjs");
+function getSmartPoolDefaults() {
+    const env = (0, environment_detection_1.detectEnvironment)();
+    const baseConfig = {
+        min: 0,
+        idleTimeoutMillis: 10000,
+        connectionTimeoutMillis: 10000,
+        pool: false
+    };
+    if (env.type === 'serverless') {
+        return {
+            ...baseConfig,
+            max: 1,
+            idleTimeoutMillis: 1000,
+            recommendation: `Serverless environment detected (${env.provider}).\n` +
+                '   Using single connection mode (recommended).\n' +
+                '   If pooling enabled: min: 0, max: 1'
+        };
+    }
+    if (env.type === 'edge') {
+        return {
+            ...baseConfig,
+            max: 0,
+            recommendation: 'Edge runtime detected. PostgreSQL connections not supported.\n' +
+                '   Use query builder only: relq("table").select().toString()'
+        };
+    }
+    return {
+        ...baseConfig,
+        max: 10,
+        idleTimeoutMillis: 30000,
+        recommendation: 'Traditional server environment.\n' +
+            '   Pooling disabled by default (single client).\n' +
+            '   To enable pooling: new Relq(schema, { pool: true, ... })'
+    };
+}
+function validatePoolConfig(config, env) {
+    const warnings = [];
+    const errors = [];
+    const min = config.min ?? 0;
+    const max = config.max ?? 10;
+    if (env.type === 'edge') {
+        errors.push('❌ Edge runtime detected (Cloudflare Workers/Deno Deploy).\n' +
+            '   PostgreSQL connections are not supported in edge runtimes.\n' +
+            '   \n' +
+            '   Options:\n' +
+            '   1. Use query builder only: relq("table").select().toString()\n' +
+            '   2. Use HTTP-based database (Supabase, Neon, Xata)\n' +
+            '   3. Deploy to traditional Node.js runtime');
+        return { valid: false, warnings, errors };
+    }
+    if (min > max) {
+        warnings.push(`⚠️  Pool min (${min}) is greater than max (${max}).\n` +
+            `   This is invalid. Min will be clamped to max (${max}).`);
+    }
+    if (env.type === 'serverless' && max > 1) {
+        warnings.push(`⚠️  Running in ${env.provider} with pool max: ${max}.\n` +
+            '   Each serverless function will create up to ' + max + ' connections.\n' +
+            '   With many concurrent functions, this can exhaust PostgreSQL connections.\n' +
+            '   \n' +
+            '   Recommended: pool: { min: 0, max: 1 }\n' +
+            '   \n' +
+            '   If you need connection pooling in serverless:\n' +
+            '   - Use PgBouncer or connection pooler\n' +
+            '   - Use Supabase (built-in pooling)\n' +
+            '   - Use Neon serverless driver');
+    }
+    if (env.type === 'traditional' && min > 5) {
+        warnings.push(`⚠️  Pool min set to ${min}. This keeps ${min} connections always open.\n` +
+            '   High min values waste resources when traffic is low.\n' +
+            '   \n' +
+            '   Recommended: min: 0 (connections created on demand)\n' +
+            '   Pool will scale up to max: ' + max + ' under load automatically.');
+    }
+    if (max > 20) {
+        warnings.push(`⚠️  Pool max set to ${max}. This is very high.\n` +
+            '   PostgreSQL connection limit is typically 100-200.\n' +
+            '   Multiple app instances × max connections can exhaust the database.\n' +
+            '   \n' +
+            '   Recommended: max: 10-20 per app instance');
+    }
+    return {
+        valid: errors.length === 0,
+        warnings,
+        errors
+    };
+}
+function mergeWithDefaults(userConfig) {
+    const defaults = getSmartPoolDefaults();
+    return {
+        min: userConfig?.min ?? defaults.min,
+        max: userConfig?.max ?? defaults.max,
+        idleTimeoutMillis: userConfig?.idleTimeoutMillis ?? defaults.idleTimeoutMillis,
+        connectionTimeoutMillis: userConfig?.connectionTimeoutMillis ?? defaults.connectionTimeoutMillis,
+        recommendation: defaults.recommendation
+    };
+}
+function formatPoolConfig(config) {
+    return `{ min: ${config.min}, max: ${config.max}, idleTimeout: ${config.idleTimeoutMillis}ms }`;
+}

package/dist/cjs/utils/type-coercion.cjs

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeValue = deserializeValue;
+exports.deserializeRow = deserializeRow;
+exports.deserializeRows = deserializeRows;
+exports.serializeValue = serializeValue;
+exports.serializeRow = serializeRow;
+exports.extractSchemaColumns = extractSchemaColumns;
+const BIGINT_TYPES = new Set(['BIGINT', 'INT8', 'BIGSERIAL', 'SERIAL8']);
+const DATE_TYPES = new Set(['TIMESTAMP', 'TIMESTAMPTZ', 'DATE', 'TIME', 'TIMETZ']);
+const JSON_TYPES = new Set(['JSON', 'JSONB']);
+function deserializeValue(value, pgType) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    const upperType = pgType.toUpperCase();
+    if (BIGINT_TYPES.has(upperType)) {
+        if (typeof value === 'string') {
+            return BigInt(value);
+        }
+        if (typeof value === 'number') {
+            return BigInt(value);
+        }
+        return value;
+    }
+    if (DATE_TYPES.has(upperType) || upperType.startsWith('TIMESTAMP')) {
+        if (value instanceof Date) {
+            return value;
+        }
+        if (typeof value === 'string' || typeof value === 'number') {
+            return new Date(value);
+        }
+        return value;
+    }
+    if (JSON_TYPES.has(upperType)) {
+        if (typeof value === 'string') {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return value;
+            }
+        }
+        return value;
+    }
+    if (upperType === 'BOOLEAN' || upperType === 'BOOL') {
+        if (typeof value === 'string') {
+            return value.toLowerCase() === 'true' || value === 't' || value === '1';
+        }
+        return Boolean(value);
+    }
+    return value;
+}
+function deserializeRow(row, schema) {
+    const result = {};
+    const columnMap = new Map();
+    for (const [key, config] of Object.entries(schema)) {
+        const dbColumnName = config.$columnName || key;
+        columnMap.set(dbColumnName, { key, type: config.$type });
+    }
+    for (const [dbColumn, value] of Object.entries(row)) {
+        const mapping = columnMap.get(dbColumn);
+        if (mapping) {
+            result[mapping.key] = deserializeValue(value, mapping.type);
+        }
+        else {
+            result[dbColumn] = value;
+        }
+    }
+    return result;
+}
+function deserializeRows(rows, schema) {
+    return rows.map(row => deserializeRow(row, schema));
+}
+function serializeValue(value, pgType) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    const upperType = pgType.toUpperCase();
+    if (BIGINT_TYPES.has(upperType)) {
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        return value;
+    }
+    if (DATE_TYPES.has(upperType) || upperType.startsWith('TIMESTAMP')) {
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        return value;
+    }
+    if (JSON_TYPES.has(upperType)) {
+        if (typeof value === 'object' && value !== null) {
+            return JSON.stringify(value);
+        }
+        return value;
+    }
+    return value;
+}
+function serializeRow(row, schema) {
+    const result = {};
+    for (const [key, value] of Object.entries(row)) {
+        const config = schema[key];
+        if (config) {
+            result[key] = serializeValue(value, config.$type);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function extractSchemaColumns(tableDefinition) {
+    if (tableDefinition && tableDefinition.$columns) {
+        return tableDefinition.$columns;
+    }
+    return null;
+}