@relq/orm 0.1.3 → 0.1.4

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

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlDeleteBuilder = void 0;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+class MysqlDeleteBuilder {
+    tableName;
+    whereConditions = [];
+    joinClauses = [];
+    deleteFromTables = [];
+    orderByColumns = [];
+    limitValue;
+    columnResolver;
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    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(callbackOrCondition) {
+        if (callbackOrCondition instanceof condition_collector_1.MysqlConditionCollector) {
+            this.whereConditions.push(...callbackOrCondition.getConditions());
+        }
+        else {
+            const conditionBuilder = new condition_collector_1.MysqlConditionCollector();
+            callbackOrCondition(conditionBuilder);
+            this.whereConditions.push(...conditionBuilder.getConditions());
+        }
+        return this;
+    }
+    join(table, condition) {
+        this.joinClauses.push(`JOIN ${mysql_format_1.default.ident(table)} ON ${condition}`);
+        return this;
+    }
+    leftJoin(table, condition) {
+        this.joinClauses.push(`LEFT JOIN ${mysql_format_1.default.ident(table)} ON ${condition}`);
+        return this;
+    }
+    innerJoin(table, condition) {
+        this.joinClauses.push(`INNER JOIN ${mysql_format_1.default.ident(table)} ON ${condition}`);
+        return this;
+    }
+    using(...tables) {
+        this.deleteFromTables.push(...tables);
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderByColumns.push({ column, direction });
+        return this;
+    }
+    limit(count) {
+        this.limitValue = count;
+        return this;
+    }
+    toString() {
+        const hasJoins = this.joinClauses.length > 0;
+        if (hasJoins) {
+            const deleteTargets = this.deleteFromTables.length > 0
+                ? this.deleteFromTables.map(t => mysql_format_1.default.ident(t)).join(', ')
+                : mysql_format_1.default.ident(this.tableName);
+            let query = `DELETE ${deleteTargets} FROM ${mysql_format_1.default.ident(this.tableName)}`;
+            query += ' ' + this.joinClauses.join(' ');
+            if (this.whereConditions.length > 0) {
+                const transformedConditions = this.transformConditionColumns(this.whereConditions);
+                query += ' WHERE ' + (0, condition_collector_1.buildMysqlConditionsSQL)(transformedConditions);
+            }
+            return query;
+        }
+        let query = `DELETE FROM ${mysql_format_1.default.ident(this.tableName)}`;
+        if (this.whereConditions.length > 0) {
+            const transformedConditions = this.transformConditionColumns(this.whereConditions);
+            query += ' WHERE ' + (0, condition_collector_1.buildMysqlConditionsSQL)(transformedConditions);
+        }
+        if (this.orderByColumns.length > 0) {
+            query += ' ORDER BY ' + this.orderByColumns
+                .map(order => `${mysql_format_1.default.ident(order.column)} ${order.direction}`)
+                .join(', ');
+        }
+        if (this.limitValue !== undefined) {
+            query += ` LIMIT ${this.limitValue}`;
+        }
+        return query;
+    }
+}
+exports.MysqlDeleteBuilder = MysqlDeleteBuilder;

package/dist/cjs/mysql/delete/index.cjs

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

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlExplainBuilder = void 0;
+class MysqlExplainBuilder {
+    query;
+    options;
+    constructor(query, options = {}) {
+        this.query = query;
+        this.options = options;
+    }
+    analyze(enable = true) {
+        this.options.analyze = enable;
+        return this;
+    }
+    format(format) {
+        this.options.format = format;
+        return this;
+    }
+    forConnection(connectionId) {
+        this.options.forConnection = connectionId;
+        return this;
+    }
+    toString() {
+        if (this.options.forConnection !== undefined) {
+            let sql = 'EXPLAIN';
+            if (this.options.format && this.options.format !== 'TRADITIONAL') {
+                sql += ` FORMAT = ${this.options.format}`;
+            }
+            sql += ` FOR CONNECTION ${this.options.forConnection}`;
+            return sql;
+        }
+        let sql = 'EXPLAIN';
+        if (this.options.analyze) {
+            sql += ' ANALYZE';
+        }
+        else if (this.options.format && this.options.format !== 'TRADITIONAL') {
+            sql += ` FORMAT = ${this.options.format}`;
+        }
+        sql += ' ' + this.query;
+        return sql;
+    }
+}
+exports.MysqlExplainBuilder = MysqlExplainBuilder;

package/dist/cjs/mysql/explain/index.cjs

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

package/dist/cjs/mysql/helpers/MysqlConnectedAggregateBuilder.cjs

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlConnectedAggregateBuilder = void 0;
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
+const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
+class MysqlConnectedAggregateBuilder {
+    builder;
+    relq;
+    tableName;
+    constructor(builder, relq, tableName) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+    }
+    mapColumn(column) {
+        const transformed = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [column]: true });
+        return Object.keys(transformed)[0] || column;
+    }
+    groupBy(...columns) {
+        const dbColumns = columns.map(col => this.mapColumn(col));
+        this.builder.groupBy(...dbColumns);
+        return this;
+    }
+    count(alias) {
+        this.builder.count(alias);
+        return this;
+    }
+    countColumn(column, alias) {
+        this.builder.countColumn(this.mapColumn(column), alias);
+        return this;
+    }
+    countDistinct(column, alias) {
+        this.builder.countDistinct(this.mapColumn(column), alias);
+        return this;
+    }
+    sum(column, alias, filter) {
+        this.builder.sum(this.mapColumn(column), alias, filter);
+        return this;
+    }
+    avg(column, alias, filter) {
+        this.builder.avg(this.mapColumn(column), alias, filter);
+        return this;
+    }
+    min(column, alias) {
+        this.builder.min(this.mapColumn(column), alias);
+        return this;
+    }
+    max(column, alias) {
+        this.builder.max(this.mapColumn(column), alias);
+        return this;
+    }
+    groupConcat(column, separator, alias, orderBy, orderDir) {
+        this.builder.groupConcat(this.mapColumn(column), separator, alias, orderBy ? this.mapColumn(orderBy) : undefined, orderDir);
+        return this;
+    }
+    jsonArrayAgg(column, alias) {
+        this.builder.jsonArrayAgg(this.mapColumn(column), alias);
+        return this;
+    }
+    bitAnd(column, alias) {
+        this.builder.bitAnd(this.mapColumn(column), alias);
+        return this;
+    }
+    bitOr(column, alias) {
+        this.builder.bitOr(this.mapColumn(column), alias);
+        return this;
+    }
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof condition_collector_1.MysqlConditionCollector) {
+            const conditionTable = callbackOrCondition._tableName;
+            if (conditionTable && conditionTable !== this.tableName) {
+                throw new relq_errors_1.RelqBuilderError(`Condition was created for table '${conditionTable}' but is being used on '${this.tableName}'. ` +
+                    `Create the condition with db.where('${this.tableName}') instead.`);
+            }
+            this.builder.where(callbackOrCondition);
+            return this;
+        }
+        const callback = callbackOrCondition;
+        this.builder.where(callback);
+        return this;
+    }
+    having(callback) {
+        this.builder.having(callback);
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.builder.orderBy(this.mapColumn(column), direction);
+        return this;
+    }
+    limit(count) {
+        this.builder.limit(count);
+        return this;
+    }
+    offset(count) {
+        this.builder.offset(count);
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async all() {
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeSelect(sql, this.tableName);
+        const numericAliases = this.builder.getNumericAliases();
+        if (numericAliases.length > 0) {
+            for (const row of result.data) {
+                for (const alias of numericAliases) {
+                    if (alias in row && typeof row[alias] === 'string') {
+                        row[alias] = Number(row[alias]);
+                    }
+                }
+            }
+        }
+        return result.data;
+    }
+    async get() {
+        this.builder.limit(1);
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeSelectOne(sql, this.tableName);
+        const numericAliases = this.builder.getNumericAliases();
+        if (numericAliases.length > 0 && result.data) {
+            for (const alias of numericAliases) {
+                if (alias in result.data && typeof result.data[alias] === 'string') {
+                    result.data[alias] = Number(result.data[alias]);
+                }
+            }
+        }
+        return result.data;
+    }
+}
+exports.MysqlConnectedAggregateBuilder = MysqlConnectedAggregateBuilder;

package/dist/cjs/mysql/helpers/MysqlConnectedCountBuilder.cjs

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlConnectedCountBuilder = void 0;
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
+const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
+class MysqlConnectedCountBuilder {
+    builder;
+    relq;
+    tableName;
+    groupNames = [];
+    constructor(builder, relq, tableName) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+    }
+    group(name, callback, options) {
+        this.groupNames.push(name);
+        this.builder.group(name, (q) => {
+            const wrapped = this.wrapConditionBuilder(q);
+            return callback(wrapped);
+        }, options);
+        return this;
+    }
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof condition_collector_1.MysqlConditionCollector) {
+            const conditionTable = callbackOrCondition._tableName;
+            if (conditionTable && conditionTable !== this.tableName) {
+                throw new relq_errors_1.RelqBuilderError(`Condition was created for table '${conditionTable}' but is being used on '${this.tableName}'. ` +
+                    `Create the condition with db.where('${this.tableName}') instead.`);
+            }
+            this.builder.where(callbackOrCondition);
+            return this;
+        }
+        const callback = callbackOrCondition;
+        this.builder.where((q) => {
+            const wrapped = this.wrapConditionBuilder(q);
+            return callback(wrapped);
+        });
+        return this;
+    }
+    wrapConditionBuilder(originalBuilder) {
+        const relq = this.relq;
+        const tableName = this.tableName;
+        const createProxy = (target) => {
+            return new Proxy(target, {
+                get(target, prop) {
+                    const original = target[prop];
+                    if (typeof original === 'function') {
+                        return function (column, ...args) {
+                            const transformed = relq[methods_1.INTERNAL].transformToDbColumns(tableName, { [column]: true });
+                            const dbColumn = Object.keys(transformed)[0] || column;
+                            const result = original.call(target, dbColumn, ...args);
+                            if (result === target || (result && typeof result === 'object')) {
+                                return createProxy(result);
+                            }
+                            return result;
+                        };
+                    }
+                    return original;
+                }
+            });
+        };
+        return createProxy(originalBuilder);
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async get() {
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeQuery(sql);
+        const row = result.result.rows[0];
+        if (this.groupNames.length === 0) {
+            return (Number(row?.count) ?? 0);
+        }
+        const counts = {};
+        for (const name of this.groupNames) {
+            counts[name] = Number(row?.[name] ?? 0);
+        }
+        return counts;
+    }
+}
+exports.MysqlConnectedCountBuilder = MysqlConnectedCountBuilder;

package/dist/cjs/mysql/helpers/MysqlConnectedDeleteBuilder.cjs

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlConnectedDeleteBuilder = void 0;
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
+const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
+class MysqlConnectedDeleteBuilder {
+    builder;
+    relq;
+    tableName;
+    schemaKey;
+    constructor(builder, relq, tableName, schemaKey) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    setupColumnResolver() {
+        if (!this.tableName && !this.schemaKey)
+            return;
+        const internal = this.relq[methods_1.INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef)
+            return;
+        const tableColumns = tableDef.$columns || tableDef;
+        this.builder.setColumnResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (columnDef) {
+                return columnDef.$columnName || column;
+            }
+            return column;
+        });
+    }
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof condition_collector_1.MysqlConditionCollector) {
+            const conditionTable = callbackOrCondition._tableName;
+            if (conditionTable) {
+                const matches = conditionTable === this.schemaKey || conditionTable === this.tableName;
+                if (!matches) {
+                    const queryTable = this.schemaKey || this.tableName;
+                    throw new relq_errors_1.RelqBuilderError(`Condition was created for table '${conditionTable}' but is being used on '${queryTable}'. ` +
+                        `Create the condition with db.where('${queryTable}') instead.`);
+                }
+            }
+            this.builder.where(callbackOrCondition);
+            return this;
+        }
+        const callback = callbackOrCondition;
+        this.builder.where((q) => {
+            return callback(q);
+        });
+        return this;
+    }
+    join(table, condition) {
+        this.builder.join(table, condition);
+        return this;
+    }
+    leftJoin(table, condition) {
+        this.builder.leftJoin(table, condition);
+        return this;
+    }
+    innerJoin(table, condition) {
+        this.builder.innerJoin(table, condition);
+        return this;
+    }
+    using(...tables) {
+        this.builder.using(...tables);
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.builder.orderBy(column, direction);
+        return this;
+    }
+    limit(count) {
+        this.builder.limit(count);
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async run(withMetadata) {
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return result.metadata.rowCount ?? 0;
+    }
+}
+exports.MysqlConnectedDeleteBuilder = MysqlConnectedDeleteBuilder;

package/dist/cjs/mysql/helpers/MysqlConnectedInsertBuilder.cjs

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlConnectedInsertBuilder = void 0;
+const methods_1 = require("../../core/helpers/methods.cjs");
+class MysqlConnectedInsertBuilder {
+    builder;
+    relq;
+    tableName;
+    schemaKey;
+    constructor(builder, relq, tableName, schemaKey) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    setupColumnResolver() {
+        if (!this.tableName && !this.schemaKey)
+            return;
+        const internal = this.relq[methods_1.INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef)
+            return;
+        const tableColumns = tableDef.$columns || tableDef;
+        this.builder.setColumnResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (columnDef) {
+                return columnDef.$columnName || column;
+            }
+            return column;
+        });
+    }
+    addRow(row) {
+        this.builder.addRow(row);
+        return this;
+    }
+    addRows(rows) {
+        this.builder.addRows(rows);
+        return this;
+    }
+    ignore() {
+        this.builder.ignore();
+        return this;
+    }
+    replace() {
+        this.builder.replace();
+        return this;
+    }
+    onDuplicateKeyUpdate(callback) {
+        this.builder.onDuplicateKeyUpdate(callback);
+        return this;
+    }
+    clear() {
+        this.builder.clear();
+        return this;
+    }
+    get total() {
+        return this.builder.total;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async run(withMetadata) {
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return {
+            affectedRows: result.metadata.rowCount ?? 0,
+            insertId: result.metadata.insertId ?? 0,
+        };
+    }
+}
+exports.MysqlConnectedInsertBuilder = MysqlConnectedInsertBuilder;

package/dist/cjs/mysql/helpers/MysqlConnectedInsertFromSelectBuilder.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlConnectedInsertFromSelectBuilder = void 0;
+const methods_1 = require("../../core/helpers/methods.cjs");
+class MysqlConnectedInsertFromSelectBuilder {
+    builder;
+    relq;
+    tableName;
+    schemaKey;
+    constructor(builder, relq, tableName, schemaKey) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    setupColumnResolver() {
+        if (!this.tableName && !this.schemaKey)
+            return;
+        const internal = this.relq[methods_1.INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef)
+            return;
+        const tableColumns = tableDef.$columns || tableDef;
+        this.builder.setColumnResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (columnDef) {
+                return columnDef.$columnName || column;
+            }
+            return column;
+        });
+    }
+    ignore() {
+        this.builder.ignore();
+        return this;
+    }
+    replace() {
+        this.builder.replace();
+        return this;
+    }
+    onDuplicateKeyUpdate(callback) {
+        this.builder.onDuplicateKeyUpdate(callback);
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async run(withMetadata) {
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return result.metadata.rowCount ?? 0;
+    }
+}
+exports.MysqlConnectedInsertFromSelectBuilder = MysqlConnectedInsertFromSelectBuilder;