@relq/orm 0.1.0

package/dist/cjs/core/shared/validation.cjs

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateData = validateData;
+exports.validateComposite = validateComposite;
+const relq_errors_1 = require("../../../shared/errors/relq-errors.cjs");
+const methods_1 = require("../helpers/methods.cjs");
+function validateData(tableName, data, operation, mappings, config) {
+    const validation = config?.validation;
+    if (validation?.enabled === false)
+        return;
+    const mapping = mappings.get(tableName);
+    if (!mapping) {
+        (0, methods_1.debugLog)(config, `No mapping found for table: ${tableName}. Available:`, Array.from(mappings.keys()));
+        return;
+    }
+    const errors = [];
+    const validateLength = validation?.validateLength !== false;
+    const validateTypes = validation?.validateTypes !== false;
+    const onError = validation?.onError ?? 'throw';
+    (0, methods_1.debugLog)(config, `Validating ${operation} on ${tableName}. Fields:`, Object.keys(data));
+    for (const [propName, value] of Object.entries(data)) {
+        if (value === null || value === undefined)
+            continue;
+        const colType = mapping.propToType.get(propName);
+        const colTypeStr = typeof colType === 'string' ? colType : null;
+        if (validateTypes && colTypeStr) {
+            const jsType = typeof value;
+            const upperType = colTypeStr.toUpperCase();
+            if (['INTEGER', 'INT', 'SMALLINT', 'BIGINT', 'INT2', 'INT4', 'INT8', 'SERIAL'].some(t => upperType.includes(t))) {
+                if (jsType !== 'number' && jsType !== 'bigint' && jsType !== 'string') {
+                    errors.push(`${propName}: expected number for ${colType}, got ${jsType}`);
+                }
+            }
+            else if (['REAL', 'DOUBLE', 'FLOAT', 'NUMERIC', 'DECIMAL'].some(t => upperType.includes(t))) {
+                if (jsType !== 'number' && jsType !== 'string') {
+                    errors.push(`${propName}: expected number for ${colType}, got ${jsType}`);
+                }
+            }
+            else if (upperType.includes('BOOL')) {
+                if (jsType !== 'boolean') {
+                    errors.push(`${propName}: expected boolean for ${colType}, got ${jsType}`);
+                }
+            }
+            else if (['VARCHAR', 'CHAR', 'TEXT', 'UUID'].some(t => upperType.includes(t))) {
+                if (jsType !== 'string') {
+                    errors.push(`${propName}: expected string for ${colType}, got ${jsType}`);
+                }
+            }
+        }
+        if (validateLength && typeof value === 'string' && colTypeStr) {
+            const lengthMatch = colTypeStr.match(/(?:var)?char\((\d+)\)/i);
+            if (lengthMatch) {
+                const maxLength = parseInt(lengthMatch[1], 10);
+                if (value.length > maxLength) {
+                    errors.push(`${propName}: string length ${value.length} exceeds ${colTypeStr} limit of ${maxLength}`);
+                }
+            }
+        }
+        const validateFn = mapping.propToValidate.get(propName);
+        if (validateFn) {
+            const isValid = validateFn(value);
+            (0, methods_1.debugLog)(config, `Domain validation for '${propName}' with value '${value}': isValid=${isValid}`);
+            if (!isValid) {
+                errors.push(`${propName}: value '${value}' failed domain validation`);
+            }
+        }
+        const compositeFields = mapping.propToFields.get(propName);
+        if (compositeFields && value && typeof value === 'object') {
+            validateComposite(propName, value, compositeFields, errors, config);
+        }
+        const checkValues = mapping.propToCheckValues.get(propName);
+        if (checkValues && checkValues.length > 0 && typeof value === 'string') {
+            if (!checkValues.includes(value)) {
+                errors.push(`${propName}: value '${value}' not in allowed values [${checkValues.join(', ')}]`);
+            }
+        }
+    }
+    if (errors.length > 0) {
+        const message = `Validation failed for ${operation} on ${tableName}:\n  - ${errors.join('\n  - ')}`;
+        (0, methods_1.debugLog)(config, message);
+        if (onError === 'throw') {
+            throw new relq_errors_1.RelqQueryError(message);
+        }
+        else if (onError === 'warn') {
+            console.warn('[Relq]', message);
+        }
+        else if (onError === 'log') {
+            console.log('[Relq]', message);
+        }
+    }
+}
+function validateComposite(propName, value, fields, errors, config) {
+    const validation = config?.validation;
+    const validateLength = validation?.validateLength !== false;
+    const validateTypes = validation?.validateTypes !== false;
+    for (const [fieldName, colDef] of Object.entries(fields)) {
+        const colConfig = colDef;
+        const fieldValue = value[fieldName];
+        const colType = colConfig.$sqlType ?? colConfig.$config?.$type ?? (typeof colConfig.$type === 'string' ? colConfig.$type : 'TEXT');
+        const upperType = colType.toUpperCase();
+        const isNullable = colConfig.$config?.$nullable ?? colConfig.$nullable;
+        (0, methods_1.debugLog)(config, `Composite field '${propName}.${fieldName}': value=${JSON.stringify(fieldValue)}, colType=${colType}, nullable=${isNullable}`);
+        if (fieldValue === null || fieldValue === undefined) {
+            if (isNullable === false) {
+                errors.push(`${propName}.${fieldName}: cannot be null`);
+            }
+            continue;
+        }
+        if (validateTypes && upperType) {
+            const jsType = typeof fieldValue;
+            if (['INTEGER', 'INT', 'SMALLINT', 'BIGINT', 'SERIAL'].some(t => upperType.includes(t))) {
+                if (jsType !== 'number' && jsType !== 'bigint' && jsType !== 'string') {
+                    errors.push(`${propName}.${fieldName}: expected number, got ${jsType}`);
+                }
+            }
+            else if (['VARCHAR', 'CHAR', 'TEXT'].some(t => upperType.includes(t))) {
+                if (jsType !== 'string') {
+                    errors.push(`${propName}.${fieldName}: expected string, got ${jsType}`);
+                }
+            }
+        }
+        if (validateLength && typeof fieldValue === 'string' && typeof colType === 'string') {
+            const lengthMatch = colType.match(/(?:var)?char\((\d+)\)/i);
+            if (lengthMatch) {
+                const maxLength = parseInt(lengthMatch[1], 10);
+                if (fieldValue.length > maxLength) {
+                    errors.push(`${propName}.${fieldName}: length ${fieldValue.length} exceeds ${maxLength}`);
+                }
+            }
+        }
+        if (colConfig.$validate && typeof colConfig.$validate === 'function') {
+            if (!colConfig.$validate(fieldValue)) {
+                errors.push(`${propName}.${fieldName}: failed domain validation`);
+            }
+        }
+        if (colConfig.$fields && fieldValue && typeof fieldValue === 'object') {
+            validateComposite(`${propName}.${fieldName}`, fieldValue, colConfig.$fields, errors, config);
+        }
+    }
+}

package/dist/cjs/core/types/core.types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/count/count-builder.cjs

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CountBuilder = void 0;
+const pg_format_1 = __importDefault(require("../shared/pg-format.cjs"));
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+class CountBuilder {
+    tableName;
+    countGroups = [];
+    whereConditions = [];
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    group(name, callback, options) {
+        const conditionBuilder = new condition_collector_1.ConditionCollector();
+        callback(conditionBuilder);
+        let aggregateFunction = 'COUNT';
+        let column;
+        if (options) {
+            if (options.distinct) {
+                aggregateFunction = 'COUNT_DISTINCT';
+                column = options.distinct;
+            }
+            else if (options.sum) {
+                aggregateFunction = 'SUM';
+                column = options.sum;
+            }
+            else if (options.avg) {
+                aggregateFunction = 'AVG';
+                column = options.avg;
+            }
+            else if (options.min) {
+                aggregateFunction = 'MIN';
+                column = options.min;
+            }
+            else if (options.max) {
+                aggregateFunction = 'MAX';
+                column = options.max;
+            }
+        }
+        this.countGroups.push({
+            name,
+            conditions: conditionBuilder.getConditions(),
+            aggregateFunction,
+            column
+        });
+        return this;
+    }
+    where(callback) {
+        const conditionBuilder = new condition_collector_1.ConditionCollector();
+        callback(conditionBuilder);
+        this.whereConditions.push(...conditionBuilder.getConditions());
+        return this;
+    }
+    toString() {
+        let selectColumns = [];
+        if (this.countGroups.length > 0) {
+            selectColumns = this.countGroups.map(group => this.buildGroupSQL(group));
+        }
+        else {
+            selectColumns.push('COUNT(*) AS count');
+        }
+        let query = (0, pg_format_1.default)('SELECT %s FROM %I', selectColumns.join(', '), this.tableName);
+        if (this.whereConditions.length > 0) {
+            query += ' WHERE ' + (0, condition_collector_1.buildConditionsSQL)(this.whereConditions);
+        }
+        return query;
+    }
+    buildGroupSQL(group) {
+        const conditionsSQL = group.conditions.map(condition => (0, condition_collector_1.buildConditionSQL)(condition)).join(' AND ');
+        let aggregateColumn = '*';
+        if (group.column) {
+            aggregateColumn = group.aggregateFunction === 'COUNT_DISTINCT'
+                ? (0, pg_format_1.default)('DISTINCT %I', group.column)
+                : pg_format_1.default.ident(group.column);
+        }
+        const funcName = group.aggregateFunction === 'COUNT_DISTINCT' ? 'COUNT' : group.aggregateFunction;
+        if (group.conditions.length > 0) {
+            return (0, pg_format_1.default)('%s(%s) FILTER (WHERE %s) AS %I', funcName, aggregateColumn, conditionsSQL, group.name);
+        }
+        else {
+            return (0, pg_format_1.default)('%s(%s) AS %I', funcName, aggregateColumn, group.name);
+        }
+    }
+}
+exports.CountBuilder = CountBuilder;

package/dist/cjs/count/index.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CountBuilder = void 0;
+var count_builder_1 = require("./count-builder.cjs");
+Object.defineProperty(exports, "CountBuilder", { enumerable: true, get: function () { return count_builder_1.CountBuilder; } });

package/dist/cjs/delete/delete-builder.cjs

@@ -0,0 +1,176 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteBuilder = void 0;
+const pg_format_1 = __importDefault(require("../shared/pg-format.cjs"));
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const select_builder_1 = require("../select/select-builder.cjs");
+const count_builder_1 = require("../count/count-builder.cjs");
+class DeleteBuilder {
+    tableName;
+    whereConditions = [];
+    returningClause;
+    columnResolver;
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return 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)
+            };
+        });
+    }
+    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;
+    }
+    toString() {
+        let query = (0, pg_format_1.default)('DELETE FROM %I', this.tableName);
+        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.DeleteBuilder = DeleteBuilder;

package/dist/cjs/delete/index.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteBuilder = void 0;
+var delete_builder_1 = require("./delete-builder.cjs");
+Object.defineProperty(exports, "DeleteBuilder", { enumerable: true, get: function () { return delete_builder_1.DeleteBuilder; } });

package/dist/cjs/explain/explain-builder.cjs

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExplainBuilder = void 0;
+class ExplainBuilder {
+    query;
+    options;
+    constructor(query, options = {}) {
+        this.query = query;
+        this.options = options;
+    }
+    analyze(enable = true) {
+        this.options.analyze = enable;
+        return this;
+    }
+    verbose(enable = true) {
+        this.options.verbose = enable;
+        return this;
+    }
+    costs(enable = true) {
+        this.options.costs = enable;
+        return this;
+    }
+    settings(enable = true) {
+        this.options.settings = enable;
+        return this;
+    }
+    buffers(enable = true) {
+        this.options.buffers = enable;
+        if (enable) {
+            this.options.analyze = true;
+        }
+        return this;
+    }
+    timing(enable = true) {
+        this.options.timing = enable;
+        if (enable) {
+            this.options.analyze = true;
+        }
+        return this;
+    }
+    summary(enable = true) {
+        this.options.summary = enable;
+        return this;
+    }
+    wal(enable = true) {
+        this.options.wal = enable;
+        if (enable) {
+            this.options.analyze = true;
+        }
+        return this;
+    }
+    format(format) {
+        this.options.format = format;
+        return this;
+    }
+    toString() {
+        const options = [];
+        if (this.options.analyze) {
+            options.push('ANALYZE');
+        }
+        if (this.options.verbose) {
+            options.push('VERBOSE');
+        }
+        if (this.options.costs === false) {
+            options.push('COSTS FALSE');
+        }
+        else if (this.options.costs === true) {
+            options.push('COSTS TRUE');
+        }
+        if (this.options.settings) {
+            options.push('SETTINGS');
+        }
+        if (this.options.buffers) {
+            options.push('BUFFERS');
+        }
+        if (this.options.timing === false) {
+            options.push('TIMING FALSE');
+        }
+        else if (this.options.timing === true) {
+            options.push('TIMING TRUE');
+        }
+        if (this.options.summary) {
+            options.push('SUMMARY');
+        }
+        if (this.options.wal) {
+            options.push('WAL');
+        }
+        if (this.options.format) {
+            options.push(`FORMAT ${this.options.format}`);
+        }
+        let sql = 'EXPLAIN';
+        if (options.length > 0) {
+            sql += ` (${options.join(', ')})`;
+        }
+        sql += ' ' + this.query;
+        return sql;
+    }
+}
+exports.ExplainBuilder = ExplainBuilder;

package/dist/cjs/explain/index.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExplainBuilder = void 0;
+var explain_builder_1 = require("./explain-builder.cjs");
+Object.defineProperty(exports, "ExplainBuilder", { enumerable: true, get: function () { return explain_builder_1.ExplainBuilder; } });

package/dist/cjs/index.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pg_format = exports.isRelqQueryError = exports.isRelqConnectionError = exports.isRelqError = exports.RelqPoolError = exports.RelqTimeoutError = exports.RelqConfigError = exports.RelqTransactionError = exports.RelqQueryError = exports.RelqConnectionError = exports.RelqError = exports.RelqCockroachDB = exports.RelqDsql = exports.RelqNile = exports.RelqPostgres = exports.Relq = void 0;
+var relq_client_1 = require("./core/relq-client.cjs");
+Object.defineProperty(exports, "Relq", { enumerable: true, get: function () { return relq_client_1.Relq; } });
+var pg_client_1 = require("./core/pg-family/pg-client/index.cjs");
+Object.defineProperty(exports, "RelqPostgres", { enumerable: true, get: function () { return pg_client_1.RelqPostgres; } });
+var nile_client_1 = require("./core/pg-family/nile-client/index.cjs");
+Object.defineProperty(exports, "RelqNile", { enumerable: true, get: function () { return nile_client_1.RelqNile; } });
+var dsql_client_1 = require("./core/pg-family/dsql-client/index.cjs");
+Object.defineProperty(exports, "RelqDsql", { enumerable: true, get: function () { return dsql_client_1.RelqDsql; } });
+var cockroachdb_client_1 = require("./core/pg-family/cockroachdb-client/index.cjs");
+Object.defineProperty(exports, "RelqCockroachDB", { enumerable: true, get: function () { return cockroachdb_client_1.RelqCockroachDB; } });
+var relq_errors_1 = require("../shared/errors/relq-errors.cjs");
+Object.defineProperty(exports, "RelqError", { enumerable: true, get: function () { return relq_errors_1.RelqError; } });
+Object.defineProperty(exports, "RelqConnectionError", { enumerable: true, get: function () { return relq_errors_1.RelqConnectionError; } });
+Object.defineProperty(exports, "RelqQueryError", { enumerable: true, get: function () { return relq_errors_1.RelqQueryError; } });
+Object.defineProperty(exports, "RelqTransactionError", { enumerable: true, get: function () { return relq_errors_1.RelqTransactionError; } });
+Object.defineProperty(exports, "RelqConfigError", { enumerable: true, get: function () { return relq_errors_1.RelqConfigError; } });
+Object.defineProperty(exports, "RelqTimeoutError", { enumerable: true, get: function () { return relq_errors_1.RelqTimeoutError; } });
+Object.defineProperty(exports, "RelqPoolError", { enumerable: true, get: function () { return relq_errors_1.RelqPoolError; } });
+Object.defineProperty(exports, "isRelqError", { enumerable: true, get: function () { return relq_errors_1.isRelqError; } });
+Object.defineProperty(exports, "isRelqConnectionError", { enumerable: true, get: function () { return relq_errors_1.isRelqConnectionError; } });
+Object.defineProperty(exports, "isRelqQueryError", { enumerable: true, get: function () { return relq_errors_1.isRelqQueryError; } });
+var utils_1 = require("./utils/index.cjs");
+Object.defineProperty(exports, "pg_format", { enumerable: true, get: function () { return utils_1.format; } });