@relq/orm 0.1.3 → 0.1.4

package/dist/esm/mysql/delete/delete-builder.js

@@ -0,0 +1,98 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+import { MysqlConditionCollector, buildMysqlConditionsSQL } from "../condition/condition-collector.js";
+export 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 MysqlConditionCollector) {
+            this.whereConditions.push(...callbackOrCondition.getConditions());
+        }
+        else {
+            const conditionBuilder = new MysqlConditionCollector();
+            callbackOrCondition(conditionBuilder);
+            this.whereConditions.push(...conditionBuilder.getConditions());
+        }
+        return this;
+    }
+    join(table, condition) {
+        this.joinClauses.push(`JOIN ${mysqlFormat.ident(table)} ON ${condition}`);
+        return this;
+    }
+    leftJoin(table, condition) {
+        this.joinClauses.push(`LEFT JOIN ${mysqlFormat.ident(table)} ON ${condition}`);
+        return this;
+    }
+    innerJoin(table, condition) {
+        this.joinClauses.push(`INNER JOIN ${mysqlFormat.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 => mysqlFormat.ident(t)).join(', ')
+                : mysqlFormat.ident(this.tableName);
+            let query = `DELETE ${deleteTargets} FROM ${mysqlFormat.ident(this.tableName)}`;
+            query += ' ' + this.joinClauses.join(' ');
+            if (this.whereConditions.length > 0) {
+                const transformedConditions = this.transformConditionColumns(this.whereConditions);
+                query += ' WHERE ' + buildMysqlConditionsSQL(transformedConditions);
+            }
+            return query;
+        }
+        let query = `DELETE FROM ${mysqlFormat.ident(this.tableName)}`;
+        if (this.whereConditions.length > 0) {
+            const transformedConditions = this.transformConditionColumns(this.whereConditions);
+            query += ' WHERE ' + buildMysqlConditionsSQL(transformedConditions);
+        }
+        if (this.orderByColumns.length > 0) {
+            query += ' ORDER BY ' + this.orderByColumns
+                .map(order => `${mysqlFormat.ident(order.column)} ${order.direction}`)
+                .join(', ');
+        }
+        if (this.limitValue !== undefined) {
+            query += ` LIMIT ${this.limitValue}`;
+        }
+        return query;
+    }
+}

package/dist/esm/mysql/delete/index.js

@@ -0,0 +1 @@
+export { MysqlDeleteBuilder } from "./delete-builder.js";

package/dist/esm/mysql/explain/explain-builder.js

@@ -0,0 +1,39 @@
+export 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;
+    }
+}

package/dist/esm/mysql/explain/index.js

@@ -0,0 +1 @@
+export { MysqlExplainBuilder } from "./explain-builder.js";

package/dist/esm/mysql/helpers/MysqlConnectedAggregateBuilder.js

@@ -0,0 +1,128 @@
+import { MysqlConditionCollector } from "../condition/condition-collector.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
+export class MysqlConnectedAggregateBuilder {
+    builder;
+    relq;
+    tableName;
+    constructor(builder, relq, tableName) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+    }
+    mapColumn(column) {
+        const transformed = this.relq[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 MysqlConditionCollector) {
+            const conditionTable = callbackOrCondition._tableName;
+            if (conditionTable && conditionTable !== this.tableName) {
+                throw new 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[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[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;
+    }
+}

package/dist/esm/{core/helpers/ConnectedCountBuilder.js → mysql/helpers/MysqlConnectedCountBuilder.js}

@@ -1,6 +1,7 @@
-import { INTERNAL } from "./methods.js";
-import { createTableAccessor } from "../shared/table-accessor.js";
-export class ConnectedCountBuilder {
+import { MysqlConditionCollector } from "../condition/condition-collector.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
+export class MysqlConnectedCountBuilder {
     builder;
     relq;
     tableName;
@@ -18,9 +19,18 @@ export class ConnectedCountBuilder {
         }, options);
         return this;
     }
-    where(callback) {
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof MysqlConditionCollector) {
+            const conditionTable = callbackOrCondition._tableName;
+            if (conditionTable && conditionTable !== this.tableName) {
+                throw new 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) => {
-            q._tables = createTableAccessor(this.relq, this.relq.schema);
             const wrapped = this.wrapConditionBuilder(q);
             return callback(wrapped);
         });

package/dist/esm/mysql/helpers/MysqlConnectedDeleteBuilder.js

@@ -0,0 +1,87 @@
+import { MysqlConditionCollector } from "../condition/condition-collector.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
+export 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[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 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 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[INTERNAL].executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return result.metadata.rowCount ?? 0;
+    }
+}

package/dist/esm/mysql/helpers/MysqlConnectedInsertBuilder.js

@@ -0,0 +1,71 @@
+import { INTERNAL } from "../../core/helpers/methods.js";
+export 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[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[INTERNAL].executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return {
+            affectedRows: result.metadata.rowCount ?? 0,
+            insertId: result.metadata.insertId ?? 0,
+        };
+    }
+}

package/dist/esm/mysql/helpers/MysqlConnectedInsertFromSelectBuilder.js

@@ -0,0 +1,53 @@
+import { INTERNAL } from "../../core/helpers/methods.js";
+export 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[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[INTERNAL].executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return result.metadata.rowCount ?? 0;
+    }
+}

package/dist/esm/mysql/helpers/MysqlConnectedQueryBuilder.js

@@ -0,0 +1,137 @@
+import { MysqlCountBuilder } from "../count/count-builder.js";
+import { MysqlDeleteBuilder } from "../delete/delete-builder.js";
+import { MysqlInsertBuilder } from "../insert/insert-builder.js";
+import { MysqlInsertFromSelectBuilder } from "../insert/insert-from-select-builder.js";
+import { MysqlAggregateQueryBuilder } from "../select/aggregate-builder.js";
+import { MysqlSelectBuilder } from "../select/select-builder.js";
+import { MysqlUpdateBuilder } from "../update/update-builder.js";
+import { MysqlConnectedAggregateBuilder } from "./MysqlConnectedAggregateBuilder.js";
+import { MysqlConnectedCountBuilder } from "./MysqlConnectedCountBuilder.js";
+import { MysqlConnectedDeleteBuilder } from "./MysqlConnectedDeleteBuilder.js";
+import { MysqlConnectedInsertBuilder } from "./MysqlConnectedInsertBuilder.js";
+import { MysqlConnectedInsertFromSelectBuilder } from "./MysqlConnectedInsertFromSelectBuilder.js";
+import { MysqlConnectedSelectBuilder } from "./MysqlConnectedSelectBuilder.js";
+import { MysqlConnectedUpdateBuilder } from "./MysqlConnectedUpdateBuilder.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
+import { MysqlPaginateBuilder } from "./MysqlPaginateBuilder.js";
+import { executeMysqlFindById, executeMysqlFindOne, executeMysqlFindMany, executeMysqlExists, executeMysqlUpsert, executeMysqlCreateWith, getMysqlPrimaryKeyColumn } from "./query-convenience.js";
+export class MysqlConnectedQueryBuilder {
+    tableName;
+    relq;
+    schemaKey;
+    constructor(tableName, relq, schemaKey) {
+        this.tableName = tableName;
+        this.relq = relq;
+        this.schemaKey = schemaKey;
+    }
+    get ctx() {
+        return { relq: this.relq, tableName: this.tableName };
+    }
+    select(...args) {
+        let columns;
+        if (args.length === 0) {
+            columns = undefined;
+        }
+        else if (args.length === 1) {
+            columns = args[0];
+        }
+        else {
+            columns = args;
+        }
+        if (columns !== undefined) {
+            if (Array.isArray(columns)) {
+                if (columns.length === 0) {
+                    throw new RelqBuilderError('select() requires at least one column', { builder: 'select', hint: 'Use .select() without arguments for SELECT *' });
+                }
+            }
+            else if (typeof columns === 'string') {
+                if (columns === '' || columns === '*') {
+                    throw new RelqBuilderError(`Invalid column name: "${columns}"`, { builder: 'select', hint: 'Use .select() without arguments for SELECT *, or pass valid column names' });
+                }
+            }
+        }
+        let dbColumns = columns;
+        if (columns && this.relq[INTERNAL].hasColumnMapping()) {
+            if (Array.isArray(columns)) {
+                dbColumns = columns.map(col => {
+                    if (Array.isArray(col)) {
+                        const transformed = this.relq[INTERNAL].transformToDbColumns(this.tableName, { [col[0]]: true });
+                        return [Object.keys(transformed)[0], col[1]];
+                    }
+                    else {
+                        const transformed = this.relq[INTERNAL].transformToDbColumns(this.tableName, { [col]: true });
+                        return Object.keys(transformed)[0];
+                    }
+                });
+            }
+            else {
+                const transformed = this.relq[INTERNAL].transformToDbColumns(this.tableName, { [columns]: true });
+                dbColumns = Object.keys(transformed)[0];
+            }
+        }
+        const builder = new MysqlSelectBuilder(this.tableName, dbColumns);
+        return new MysqlConnectedSelectBuilder(builder, this.relq, this.tableName, columns, this.schemaKey);
+    }
+    insert(data) {
+        const rows = Array.isArray(data) ? data : [data];
+        if (rows.length === 0) {
+            const builder = new MysqlInsertBuilder(this.tableName, {});
+            builder.clear();
+            return new MysqlConnectedInsertBuilder(builder, this.relq, this.tableName, this.schemaKey);
+        }
+        const builder = new MysqlInsertBuilder(this.tableName, rows[0]);
+        if (rows.length > 1) {
+            builder.addRows(rows.slice(1));
+        }
+        return new MysqlConnectedInsertBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    update(data) {
+        const builder = new MysqlUpdateBuilder(this.tableName, data);
+        return new MysqlConnectedUpdateBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    delete() {
+        const builder = new MysqlDeleteBuilder(this.tableName);
+        return new MysqlConnectedDeleteBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    count() {
+        const builder = new MysqlCountBuilder(this.tableName);
+        return new MysqlConnectedCountBuilder(builder, this.relq, this.tableName);
+    }
+    aggregate() {
+        const builder = new MysqlAggregateQueryBuilder(this.tableName);
+        return new MysqlConnectedAggregateBuilder(builder, this.relq, this.tableName);
+    }
+    async findById(id) {
+        return executeMysqlFindById(this.ctx, id, () => getMysqlPrimaryKeyColumn(this.relq, this.tableName));
+    }
+    async findOne(filter) {
+        return executeMysqlFindOne(this.ctx, filter);
+    }
+    async findMany(filter) {
+        return executeMysqlFindMany(this.ctx, filter);
+    }
+    async exists(filter) {
+        return executeMysqlExists(this.ctx, filter);
+    }
+    async upsert(options) {
+        return executeMysqlUpsert(this.ctx, {
+            where: options.where,
+            create: options.create,
+            update: options.update,
+        });
+    }
+    insertFrom(columns, selectCallback) {
+        const { createTableAccessor } = require('../../core/shared/table-accessor');
+        const tables = createTableAccessor(this.relq, this.relq.schema);
+        const selectQuery = selectCallback(tables);
+        const builder = new MysqlInsertFromSelectBuilder(this.tableName, columns, selectQuery.toString());
+        return new MysqlConnectedInsertFromSelectBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    paginate(options = {}) {
+        return new MysqlPaginateBuilder(this.relq, this.tableName, options.columns, options.where, options.orderBy);
+    }
+    async createWith(options) {
+        return executeMysqlCreateWith(this.ctx, options.data, options.with);
+    }
+}