@relq/orm 0.1.3 → 0.1.5

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

@@ -0,0 +1,56 @@
+import { MysqlRawQueryBuilder } from "../raw/index.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
+export class MysqlConnectedRawQueryBuilder {
+    relq;
+    builder;
+    constructor(query, params, relq) {
+        this.relq = relq;
+        this.builder = new MysqlRawQueryBuilder(query, params);
+    }
+    async all() {
+        const sql = this.builder.toString();
+        const { result, duration } = await this.relq[INTERNAL].executeRawQuery(sql);
+        return {
+            data: result.rows,
+            metadata: { rowCount: result.rowCount, command: result.command, duration, fields: result.fields },
+        };
+    }
+    async get() {
+        const sql = this.builder.toString();
+        const { result, duration } = await this.relq[INTERNAL].executeRawQuery(sql);
+        return {
+            data: (result.rows[0] || null),
+            metadata: { rowCount: result.rowCount, command: result.command, duration, fields: result.fields },
+        };
+    }
+    async getMany(count) {
+        const sql = this.builder.toString();
+        const limitedSql = sql.toUpperCase().includes('LIMIT') ? sql : `${sql} LIMIT ${count}`;
+        const { result, duration } = await this.relq[INTERNAL].executeRawQuery(limitedSql);
+        return {
+            data: result.rows,
+            metadata: { rowCount: result.rowCount, command: result.command, duration, fields: result.fields },
+        };
+    }
+    async run() {
+        const sql = this.builder.toString();
+        const { result, duration } = await this.relq[INTERNAL].executeRawQuery(sql);
+        return {
+            success: true,
+            metadata: { rowCount: result.rowCount, command: result.command, duration, fields: result.fields },
+        };
+    }
+    async count() {
+        const sql = this.builder.toString();
+        const { result, duration } = await this.relq[INTERNAL].executeRawQuery(sql);
+        const row = result.rows[0];
+        const count = row ? Number(Object.values(row)[0]) || 0 : 0;
+        return {
+            count,
+            metadata: { rowCount: result.rowCount, command: result.command, duration, fields: result.fields },
+        };
+    }
+    toString() {
+        return this.builder.toString();
+    }
+}

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

@@ -0,0 +1,391 @@
+import { MysqlConditionCollector } from "../condition/condition-collector.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
+import { executeMysqlTypeSafeJoin, executeMysqlCorrelatedSubqueryJoin, executeMysqlJoinManyThrough, executeMysqlLateralJoin, executeMysqlLateralJoinThrough, } from "./select-joins.js";
+import { executeMysqlCursorEach, executeMysqlPagination } from "./select-pagination.js";
+import { requireCapability } from "../../core/helpers/capability-guard.js";
+import { createTableAccessor } from "../../core/shared/table-accessor.js";
+import { MysqlAggregateFunctions } from "../select/sql-expression.js";
+import { createMysqlTableProxy } from "../select/table-proxy.js";
+import { resolveMysqlForeignKey } from "../utils/fk-resolver.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
+import mysqlFormat from "../clients/shared/mysql-format.js";
+export class MysqlConnectedSelectBuilder {
+    builder;
+    relq;
+    tableName;
+    schemaKey;
+    constructor(builder, relq, tableName, _columns, schemaKey) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    get joinCtx() {
+        return { relq: this.relq, builder: this.builder, tableName: this.tableName, schemaKey: this.schemaKey };
+    }
+    get paginationCtx() {
+        return { relq: this.relq, builder: this.builder, tableName: this.tableName };
+    }
+    setupColumnResolver() {
+        const internal = this.relq[INTERNAL];
+        const tableKey = this.schemaKey || this.tableName;
+        const tableDef = internal.getTableDef(tableKey);
+        if (!tableDef) {
+            return;
+        }
+        const tableColumns = tableDef.$columns || tableDef;
+        this.builder.setColumnResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (columnDef) {
+                return columnDef.$columnName || column;
+            }
+            return column;
+        });
+    }
+    transformJoinResults(rows) {
+        const joins = this.builder.getStructuredJoins();
+        if (joins.length === 0) {
+            return rows;
+        }
+        const internal = this.relq[INTERNAL];
+        return rows.map(row => {
+            if (!row || typeof row !== 'object')
+                return row;
+            const transformed = { ...row };
+            for (const join of joins) {
+                const alias = join.alias;
+                const nestedData = transformed[alias];
+                if (nestedData === null || nestedData === undefined) {
+                    continue;
+                }
+                const joinedTableDef = internal.getTableDef(join.schemaKey || alias) || internal.getTableDef(join.table);
+                if (!joinedTableDef) {
+                    continue;
+                }
+                const tableColumns = joinedTableDef.$columns || joinedTableDef;
+                const dbToProp = new Map();
+                const propTypes = new Map();
+                for (const [propName, colDef] of Object.entries(tableColumns)) {
+                    const dbColName = colDef?.$columnName ?? propName;
+                    dbToProp.set(dbColName, propName);
+                    const snakeCase = propName.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+                    if (snakeCase !== propName && !dbToProp.has(snakeCase)) {
+                        dbToProp.set(snakeCase, propName);
+                    }
+                    const sqlType = colDef?.$sqlType || (typeof colDef?.$type === 'string' ? colDef.$type : undefined);
+                    if (sqlType) {
+                        propTypes.set(propName, sqlType.toLowerCase());
+                    }
+                }
+                if (Array.isArray(nestedData)) {
+                    transformed[alias] = nestedData.map((item) => this.transformNestedObject(item, dbToProp, propTypes));
+                }
+                else {
+                    transformed[alias] = this.transformNestedObject(nestedData, dbToProp, propTypes);
+                }
+            }
+            return transformed;
+        });
+    }
+    transformNestedObject(obj, dbToProp, propTypes) {
+        if (!obj || typeof obj !== 'object')
+            return obj;
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            const propName = dbToProp.get(key) ?? key;
+            result[propName] = propTypes ? this.coerceValue(value, propTypes.get(propName)) : value;
+        }
+        return result;
+    }
+    coerceValue(value, sqlType) {
+        if (value === null || value === undefined || !sqlType)
+            return value;
+        switch (sqlType) {
+            case 'timestamp':
+            case 'datetime':
+            case 'date':
+                return typeof value === 'string' ? new Date(value) : value;
+            case 'bigint':
+                return typeof value === 'number' ? BigInt(value) : typeof value === 'string' ? BigInt(value) : value;
+            default:
+                return value;
+        }
+    }
+    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) => {
+            q._tables = createTableAccessor(this.relq, this.relq.schema);
+            return callback(q);
+        });
+        return this;
+    }
+    orderBy(column, direction) {
+        const dbColumn = this.relq[INTERNAL].hasColumnMapping()
+            ? Object.keys(this.relq[INTERNAL].transformToDbColumns(this.tableName, { [column]: true }))[0]
+            : column;
+        this.builder.orderBy(dbColumn, direction);
+        return this;
+    }
+    limit(count) {
+        this.builder.limit(count);
+        return this;
+    }
+    offset(count) {
+        this.builder.offset(count);
+        return this;
+    }
+    groupBy(...columns) {
+        const dbColumns = this.relq[INTERNAL].hasColumnMapping()
+            ? columns.map(col => Object.keys(this.relq[INTERNAL].transformToDbColumns(this.tableName, { [col]: true }))[0])
+            : columns;
+        this.builder.groupBy(...dbColumns);
+        return this;
+    }
+    having(callback) {
+        this.builder.having(callback);
+        return this;
+    }
+    include(callback) {
+        const agg = new MysqlAggregateFunctions();
+        const internal = this.relq[INTERNAL];
+        const schema = internal.getSchema() || {};
+        const sourceSchemaKey = this.schemaKey || this.tableName;
+        const sourceAlias = this.builder.getTableIdentifier();
+        const accessedTables = new Set();
+        const tableProxies = new Proxy({}, {
+            get(_, tableKey) {
+                if (typeof tableKey === 'symbol')
+                    return undefined;
+                const key = tableKey;
+                const tableDef = schema[key];
+                const tableSqlName = tableDef?.$name || key;
+                if (key === sourceSchemaKey) {
+                    return createMysqlTableProxy(tableSqlName, sourceAlias, tableDef);
+                }
+                accessedTables.add(key);
+                return createMysqlTableProxy(tableSqlName, key, tableDef);
+            }
+        });
+        const expressions = callback(agg, tableProxies);
+        const sourceExprs = [];
+        const externalExprs = new Map();
+        for (const [alias, expr] of Object.entries(expressions)) {
+            let targetTable = null;
+            for (const tableKey of accessedTables) {
+                if (expr.sql.includes(`\`${tableKey}\`.`)) {
+                    targetTable = tableKey;
+                    break;
+                }
+            }
+            if (targetTable) {
+                if (!externalExprs.has(targetTable))
+                    externalExprs.set(targetTable, []);
+                externalExprs.get(targetTable).push({ alias, sql: expr.sql });
+            }
+            else {
+                sourceExprs.push({ alias, sql: expr.sql });
+            }
+        }
+        for (const e of sourceExprs) {
+            this.builder.addIncludeExpression(e.alias, e.sql);
+        }
+        for (const [tableKey, exprs] of externalExprs) {
+            const tableDef = schema[tableKey];
+            const sqlTableName = tableDef?.$name || tableKey;
+            const existingJoins = this.builder.getStructuredJoins();
+            const alreadyJoined = existingJoins.some(j => j.table === sqlTableName || j.schemaKey === tableKey || j.alias === tableKey);
+            if (alreadyJoined) {
+                for (const e of exprs) {
+                    this.builder.addIncludeExpression(e.alias, e.sql);
+                }
+                continue;
+            }
+            const fk = resolveMysqlForeignKey(schema, sourceSchemaKey, tableKey);
+            if (!fk) {
+                throw new RelqBuilderError(`include() references table "${tableKey}" but no foreign key relationship exists between "${sourceSchemaKey}" and "${tableKey}". Define the relationship in your schema.`, { builder: 'include', hint: `Add a foreign key from "${tableKey}" to "${sourceSchemaKey}" in your table definition.` });
+            }
+            for (const e of exprs) {
+                const unqualifiedSql = e.sql.replace(new RegExp(`\`${tableKey}\`\\.`, 'g'), '');
+                const subquery = `(SELECT ${unqualifiedSql} FROM ${mysqlFormat.ident(sqlTableName)} WHERE ${mysqlFormat.ident(fk.toColumn)} = ${mysqlFormat.ident(sourceAlias)}.${mysqlFormat.ident(fk.fromColumn)})`;
+                this.builder.addIncludeExpression(e.alias, subquery);
+            }
+        }
+        return this;
+    }
+    join(tableOrAlias, callback) {
+        executeMysqlTypeSafeJoin(this.joinCtx, 'JOIN', tableOrAlias, callback);
+        return this;
+    }
+    leftJoin(tableOrAlias, callback) {
+        executeMysqlTypeSafeJoin(this.joinCtx, 'LEFT JOIN', tableOrAlias, callback);
+        return this;
+    }
+    rightJoin(tableOrAlias, callback) {
+        executeMysqlTypeSafeJoin(this.joinCtx, 'RIGHT JOIN', tableOrAlias, callback);
+        return this;
+    }
+    innerJoin(tableOrAlias, callback) {
+        executeMysqlTypeSafeJoin(this.joinCtx, 'INNER JOIN', tableOrAlias, callback);
+        return this;
+    }
+    crossJoin(tableOrAlias) {
+        const [tableKey, alias] = Array.isArray(tableOrAlias) ? tableOrAlias : [tableOrAlias, tableOrAlias];
+        const internal = this.relq[INTERNAL];
+        const tableDef = internal.getTableDef(tableKey);
+        const tableSqlName = tableDef?.$name || tableKey;
+        this.builder.crossJoin(tableSqlName);
+        this.builder.addStructuredJoin({ table: tableSqlName, alias, type: 'CROSS JOIN', schemaKey: tableKey });
+        return this;
+    }
+    joinSubquery(alias, subquery, onClause) {
+        const subquerySQL = typeof subquery === 'string' ? subquery : subquery.toString();
+        this.builder.addRawJoin(`JOIN (${subquerySQL}) AS ${mysqlFormat.ident(alias)} ON ${onClause}`);
+        return this;
+    }
+    leftJoinSubquery(alias, subquery, onClause) {
+        const subquerySQL = typeof subquery === 'string' ? subquery : subquery.toString();
+        this.builder.addRawJoin(`LEFT JOIN (${subquerySQL}) AS ${mysqlFormat.ident(alias)} ON ${onClause}`);
+        return this;
+    }
+    joinMany(tableOrAlias, callbackOrOptions, throughCallback) {
+        if (callbackOrOptions && typeof callbackOrOptions === 'object' && 'through' in callbackOrOptions) {
+            executeMysqlJoinManyThrough(this.joinCtx, tableOrAlias, callbackOrOptions.through, throughCallback);
+        }
+        else {
+            executeMysqlCorrelatedSubqueryJoin(this.joinCtx, tableOrAlias, callbackOrOptions);
+        }
+        return this;
+    }
+    leftJoinMany(tableOrAlias, callbackOrOptions, throughCallback) {
+        if (callbackOrOptions && typeof callbackOrOptions === 'object' && 'through' in callbackOrOptions) {
+            executeMysqlJoinManyThrough(this.joinCtx, tableOrAlias, callbackOrOptions.through, throughCallback);
+        }
+        else {
+            executeMysqlCorrelatedSubqueryJoin(this.joinCtx, tableOrAlias, callbackOrOptions);
+        }
+        return this;
+    }
+    joinManyLateral(tableOrAlias, callbackOrOptions, throughCallback) {
+        if (callbackOrOptions && typeof callbackOrOptions === 'object' && 'through' in callbackOrOptions) {
+            executeMysqlLateralJoinThrough(this.joinCtx, 'JOIN', tableOrAlias, callbackOrOptions.through, throughCallback);
+        }
+        else {
+            executeMysqlLateralJoin(this.joinCtx, 'JOIN', tableOrAlias, callbackOrOptions);
+        }
+        return this;
+    }
+    leftJoinManyLateral(tableOrAlias, callbackOrOptions, throughCallback) {
+        if (callbackOrOptions && typeof callbackOrOptions === 'object' && 'through' in callbackOrOptions) {
+            executeMysqlLateralJoinThrough(this.joinCtx, 'LEFT JOIN', tableOrAlias, callbackOrOptions.through, throughCallback);
+        }
+        else {
+            executeMysqlLateralJoin(this.joinCtx, 'LEFT JOIN', tableOrAlias, callbackOrOptions);
+        }
+        return this;
+    }
+    with(table) {
+        executeMysqlTypeSafeJoin(this.joinCtx, 'LEFT JOIN', table);
+        return this;
+    }
+    withMany(table, options) {
+        if (options && 'through' in options) {
+            executeMysqlJoinManyThrough(this.joinCtx, table, options.through);
+            return this;
+        }
+        const internal = this.relq[INTERNAL];
+        const schema = internal.getSchema();
+        if (!schema) {
+            throw new RelqBuilderError(`Cannot use .withMany('${table}') without schema. Pass your schema when creating Relq.`, { builder: 'withMany', hint: `Use .leftJoinMany() with an explicit callback instead.` });
+        }
+        const sourceKey = this.schemaKey || this.tableName;
+        const fk = resolveMysqlForeignKey(schema, sourceKey, table);
+        if (!fk) {
+            throw new RelqBuilderError(`No foreign key relationship found between "${sourceKey}" and "${table}". Define $foreignKeys on your table definitions.`, { builder: 'withMany', hint: `Use .leftJoinMany() with explicit join conditions instead.` });
+        }
+        executeMysqlCorrelatedSubqueryJoin(this.joinCtx, table, (on, right, left) => {
+            const rightCol = right[fk.toColumn];
+            const leftCol = left[fk.fromColumn];
+            return on.equal(rightCol, leftCol);
+        });
+        return this;
+    }
+    distinct() {
+        this.builder.distinct();
+        return this;
+    }
+    union(query) {
+        this.builder.union(typeof query === 'string' ? query : query.toString());
+        return this;
+    }
+    unionAll(query) {
+        this.builder.unionAll(typeof query === 'string' ? query : query.toString());
+        return this;
+    }
+    intersect(query) {
+        this.builder.intersect(typeof query === 'string' ? query : query.toString());
+        return this;
+    }
+    except(query) {
+        this.builder.except(typeof query === 'string' ? query : query.toString());
+        return this;
+    }
+    forUpdate() {
+        this.builder.forUpdate();
+        return this;
+    }
+    forUpdateSkipLocked() {
+        requireCapability(this.relq, 'forUpdateSkipLocked', 'FOR UPDATE SKIP LOCKED', 'Use FOR UPDATE without SKIP LOCKED');
+        this.builder.forUpdateSkipLocked();
+        return this;
+    }
+    forUpdateNoWait() {
+        this.builder.forUpdateNoWait();
+        return this;
+    }
+    forShare() {
+        this.builder.forShare();
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async all(withMetadata, _asRequired) {
+        const sql = this.builder.toString();
+        const result = await this.relq[INTERNAL].executeSelect(sql, this.tableName);
+        const transformedData = this.transformJoinResults(result.data);
+        if (withMetadata) {
+            return { data: transformedData, metadata: result.metadata };
+        }
+        return transformedData;
+    }
+    async get(withMetadata, _asRequired) {
+        this.builder.limit(1);
+        const sql = this.builder.toString();
+        const result = await this.relq[INTERNAL].executeSelectOne(sql, this.tableName);
+        const transformedData = result.data ? this.transformJoinResults([result.data])[0] : null;
+        if (withMetadata) {
+            return { data: transformedData, metadata: result.metadata };
+        }
+        return transformedData;
+    }
+    async each(callback, options = {}) {
+        return executeMysqlCursorEach(this.paginationCtx, callback, options);
+    }
+    async pagination(options) {
+        return executeMysqlPagination(this.paginationCtx, options, (opts) => this.pagination(opts));
+    }
+}

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

@@ -0,0 +1,123 @@
+import { MysqlConnectedRawQueryBuilder } from "./MysqlConnectedRawQueryBuilder.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
+export class MysqlTransactionClient {
+    client;
+    relq;
+    schema;
+    constructor(client, relq) {
+        this.client = client;
+        this.relq = relq;
+        const internal = this.relq[INTERNAL];
+        this.schema = internal.getSchema?.() ?? this.relq.schema;
+    }
+    get dialect() { return this.relq.dialect; }
+    get capabilities() { return this.relq.capabilities; }
+    get table() {
+        const { createMysqlTableAccessor } = require('../shared/mysql-table-accessor');
+        return createMysqlTableAccessor(this, this.schema);
+    }
+    raw(query, ...params) {
+        return new MysqlConnectedRawQueryBuilder(query, params, this);
+    }
+    async savepoint(name) {
+        await this.executeOnClient(`SAVEPOINT \`${name}\``);
+    }
+    async rollbackTo(name) {
+        await this.executeOnClient(`ROLLBACK TO SAVEPOINT \`${name}\``);
+    }
+    async releaseSavepoint(name) {
+        await this.executeOnClient(`RELEASE SAVEPOINT \`${name}\``);
+    }
+    async executeOnClient(sql) {
+        const [rows, fields] = await this.client.query(sql);
+        return {
+            rows: Array.isArray(rows) ? rows : [],
+            rowCount: rows?.affectedRows ?? 0,
+            command: sql.split(' ')[0] || 'QUERY',
+            fields: (fields ?? []).map((f) => ({ name: f.name, dataTypeID: f.columnType ?? 0 })),
+        };
+    }
+    get [INTERNAL]() {
+        const parentInternal = this.relq[INTERNAL];
+        const queryViaClient = async (sql) => {
+            const start = performance.now();
+            const result = await this.executeOnClient(sql);
+            return { result, duration: performance.now() - start };
+        };
+        const buildMetadata = (result, duration) => ({
+            rowCount: result.rowCount,
+            command: result.command,
+            duration,
+            fields: result.fields,
+        });
+        return {
+            executeQuery: queryViaClient,
+            async executeSelect(sql, tableName) {
+                const { result, duration } = await queryViaClient(sql);
+                const rows = tableName
+                    ? parentInternal.transformResultsFromDb(tableName, result.rows)
+                    : result.rows;
+                return { data: rows, metadata: buildMetadata(result, duration) };
+            },
+            async executeSelectOne(sql, tableName) {
+                const { result, duration } = await queryViaClient(sql);
+                const row = result.rows[0]
+                    ? (tableName ? parentInternal.transformFromDbColumns(tableName, result.rows[0]) : result.rows[0])
+                    : null;
+                return { data: row, metadata: buildMetadata(result, duration) };
+            },
+            async executeCount(sql) {
+                const { result, duration } = await queryViaClient(sql);
+                const count = result.rows[0]?.count
+                    ? parseInt(result.rows[0].count, 10)
+                    : 0;
+                return { count, metadata: buildMetadata(result, duration) };
+            },
+            async executeRun(sql) {
+                const { result, duration } = await queryViaClient(sql);
+                return { success: true, metadata: buildMetadata(result, duration) };
+            },
+            executeRawQuery: queryViaClient,
+            transformToDbColumns: parentInternal.transformToDbColumns,
+            transformFromDbColumns: parentInternal.transformFromDbColumns,
+            transformResultsFromDb: parentInternal.transformResultsFromDb,
+            hasColumnMapping: parentInternal.hasColumnMapping,
+            validateData: parentInternal.validateData,
+            getSchema: parentInternal.getSchema,
+            getRelations: parentInternal.getRelations,
+            getTableDef: parentInternal.getTableDef,
+            getClientForCursor: async () => ({ client: this.client, release: () => { } }),
+        };
+    }
+}
+export async function executeMysqlTransaction(relq, callback, options) {
+    await relq.ensureInitialized();
+    const { client, release } = await relq[INTERNAL].getClientForCursor();
+    try {
+        if (options?.isolation) {
+            await client.query(`SET TRANSACTION ISOLATION LEVEL ${options.isolation}`);
+        }
+        let startSql = 'START TRANSACTION';
+        if (options?.readOnly === true) {
+            startSql += ' READ ONLY';
+        }
+        else if (options?.readOnly === false) {
+            startSql += ' READ WRITE';
+        }
+        await client.query(startSql);
+        const tx = new MysqlTransactionClient(client, relq);
+        const result = await callback(tx);
+        await client.query('COMMIT');
+        return result;
+    }
+    catch (error) {
+        try {
+            await client.query('ROLLBACK');
+        }
+        catch { }
+        throw error;
+    }
+    finally {
+        release();
+    }
+}

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

@@ -0,0 +1,88 @@
+import { MysqlConditionCollector } from "../condition/condition-collector.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
+export class MysqlConnectedUpdateBuilder {
+    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;
+        });
+    }
+    set(data) {
+        this.builder.set(data);
+        return this;
+    }
+    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;
+    }
+    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) {
+        this.relq[INTERNAL].validateData(this.builder.tableName, this.builder.updateData, 'update');
+        const sql = this.builder.toString();
+        const result = await this.relq[INTERNAL].executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return result.metadata.rowCount ?? 0;
+    }
+}