@relq/orm 0.1.2 → 0.1.4

package/dist/cjs/mysql/helpers/MysqlConnectedQueryBuilder.cjs

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlConnectedQueryBuilder = void 0;
+const count_builder_1 = require("../count/count-builder.cjs");
+const delete_builder_1 = require("../delete/delete-builder.cjs");
+const insert_builder_1 = require("../insert/insert-builder.cjs");
+const insert_from_select_builder_1 = require("../insert/insert-from-select-builder.cjs");
+const aggregate_builder_1 = require("../select/aggregate-builder.cjs");
+const select_builder_1 = require("../select/select-builder.cjs");
+const update_builder_1 = require("../update/update-builder.cjs");
+const MysqlConnectedAggregateBuilder_1 = require("./MysqlConnectedAggregateBuilder.cjs");
+const MysqlConnectedCountBuilder_1 = require("./MysqlConnectedCountBuilder.cjs");
+const MysqlConnectedDeleteBuilder_1 = require("./MysqlConnectedDeleteBuilder.cjs");
+const MysqlConnectedInsertBuilder_1 = require("./MysqlConnectedInsertBuilder.cjs");
+const MysqlConnectedInsertFromSelectBuilder_1 = require("./MysqlConnectedInsertFromSelectBuilder.cjs");
+const MysqlConnectedSelectBuilder_1 = require("./MysqlConnectedSelectBuilder.cjs");
+const MysqlConnectedUpdateBuilder_1 = require("./MysqlConnectedUpdateBuilder.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
+const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
+const MysqlPaginateBuilder_1 = require("./MysqlPaginateBuilder.cjs");
+const query_convenience_1 = require("./query-convenience.cjs");
+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 relq_errors_1.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 relq_errors_1.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[methods_1.INTERNAL].hasColumnMapping()) {
+            if (Array.isArray(columns)) {
+                dbColumns = columns.map(col => {
+                    if (Array.isArray(col)) {
+                        const transformed = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [col[0]]: true });
+                        return [Object.keys(transformed)[0], col[1]];
+                    }
+                    else {
+                        const transformed = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [col]: true });
+                        return Object.keys(transformed)[0];
+                    }
+                });
+            }
+            else {
+                const transformed = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [columns]: true });
+                dbColumns = Object.keys(transformed)[0];
+            }
+        }
+        const builder = new select_builder_1.MysqlSelectBuilder(this.tableName, dbColumns);
+        return new MysqlConnectedSelectBuilder_1.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 insert_builder_1.MysqlInsertBuilder(this.tableName, {});
+            builder.clear();
+            return new MysqlConnectedInsertBuilder_1.MysqlConnectedInsertBuilder(builder, this.relq, this.tableName, this.schemaKey);
+        }
+        const builder = new insert_builder_1.MysqlInsertBuilder(this.tableName, rows[0]);
+        if (rows.length > 1) {
+            builder.addRows(rows.slice(1));
+        }
+        return new MysqlConnectedInsertBuilder_1.MysqlConnectedInsertBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    update(data) {
+        const builder = new update_builder_1.MysqlUpdateBuilder(this.tableName, data);
+        return new MysqlConnectedUpdateBuilder_1.MysqlConnectedUpdateBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    delete() {
+        const builder = new delete_builder_1.MysqlDeleteBuilder(this.tableName);
+        return new MysqlConnectedDeleteBuilder_1.MysqlConnectedDeleteBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    count() {
+        const builder = new count_builder_1.MysqlCountBuilder(this.tableName);
+        return new MysqlConnectedCountBuilder_1.MysqlConnectedCountBuilder(builder, this.relq, this.tableName);
+    }
+    aggregate() {
+        const builder = new aggregate_builder_1.MysqlAggregateQueryBuilder(this.tableName);
+        return new MysqlConnectedAggregateBuilder_1.MysqlConnectedAggregateBuilder(builder, this.relq, this.tableName);
+    }
+    async findById(id) {
+        return (0, query_convenience_1.executeMysqlFindById)(this.ctx, id, () => (0, query_convenience_1.getMysqlPrimaryKeyColumn)(this.relq, this.tableName));
+    }
+    async findOne(filter) {
+        return (0, query_convenience_1.executeMysqlFindOne)(this.ctx, filter);
+    }
+    async findMany(filter) {
+        return (0, query_convenience_1.executeMysqlFindMany)(this.ctx, filter);
+    }
+    async exists(filter) {
+        return (0, query_convenience_1.executeMysqlExists)(this.ctx, filter);
+    }
+    async upsert(options) {
+        return (0, query_convenience_1.executeMysqlUpsert)(this.ctx, {
+            where: options.where,
+            create: options.create,
+            update: options.update,
+        });
+    }
+    insertFrom(columns, selectCallback) {
+        const { createTableAccessor } = require("../../core/shared/table-accessor.cjs");
+        const tables = createTableAccessor(this.relq, this.relq.schema);
+        const selectQuery = selectCallback(tables);
+        const builder = new insert_from_select_builder_1.MysqlInsertFromSelectBuilder(this.tableName, columns, selectQuery.toString());
+        return new MysqlConnectedInsertFromSelectBuilder_1.MysqlConnectedInsertFromSelectBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    paginate(options = {}) {
+        return new MysqlPaginateBuilder_1.MysqlPaginateBuilder(this.relq, this.tableName, options.columns, options.where, options.orderBy);
+    }
+    async createWith(options) {
+        return (0, query_convenience_1.executeMysqlCreateWith)(this.ctx, options.data, options.with);
+    }
+}
+exports.MysqlConnectedQueryBuilder = MysqlConnectedQueryBuilder;

package/dist/cjs/mysql/helpers/MysqlConnectedRawQueryBuilder.cjs

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlConnectedRawQueryBuilder = void 0;
+const raw_1 = require("../raw/index.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
+class MysqlConnectedRawQueryBuilder {
+    relq;
+    builder;
+    constructor(query, params, relq) {
+        this.relq = relq;
+        this.builder = new raw_1.MysqlRawQueryBuilder(query, params);
+    }
+    async all() {
+        const sql = this.builder.toString();
+        const { result, duration } = await this.relq[methods_1.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[methods_1.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[methods_1.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[methods_1.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[methods_1.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();
+    }
+}
+exports.MysqlConnectedRawQueryBuilder = MysqlConnectedRawQueryBuilder;

package/dist/cjs/mysql/helpers/MysqlConnectedSelectBuilder.cjs

@@ -0,0 +1,398 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlConnectedSelectBuilder = void 0;
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
+const select_joins_1 = require("./select-joins.cjs");
+const select_pagination_1 = require("./select-pagination.cjs");
+const capability_guard_1 = require("../../core/helpers/capability-guard.cjs");
+const table_accessor_1 = require("../../core/shared/table-accessor.cjs");
+const sql_expression_1 = require("../select/sql-expression.cjs");
+const table_proxy_1 = require("../select/table-proxy.cjs");
+const fk_resolver_1 = require("../utils/fk-resolver.cjs");
+const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+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[methods_1.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[methods_1.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 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) => {
+            q._tables = (0, table_accessor_1.createTableAccessor)(this.relq, this.relq.schema);
+            return callback(q);
+        });
+        return this;
+    }
+    orderBy(column, direction) {
+        const dbColumn = this.relq[methods_1.INTERNAL].hasColumnMapping()
+            ? Object.keys(this.relq[methods_1.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[methods_1.INTERNAL].hasColumnMapping()
+            ? columns.map(col => Object.keys(this.relq[methods_1.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 sql_expression_1.MysqlAggregateFunctions();
+        const internal = this.relq[methods_1.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 (0, table_proxy_1.createMysqlTableProxy)(tableSqlName, sourceAlias, tableDef);
+                }
+                accessedTables.add(key);
+                return (0, table_proxy_1.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 = (0, fk_resolver_1.resolveMysqlForeignKey)(schema, sourceSchemaKey, tableKey);
+            if (!fk) {
+                throw new relq_errors_1.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 ${mysql_format_1.default.ident(sqlTableName)} WHERE ${mysql_format_1.default.ident(fk.toColumn)} = ${mysql_format_1.default.ident(sourceAlias)}.${mysql_format_1.default.ident(fk.fromColumn)})`;
+                this.builder.addIncludeExpression(e.alias, subquery);
+            }
+        }
+        return this;
+    }
+    join(tableOrAlias, callback) {
+        (0, select_joins_1.executeMysqlTypeSafeJoin)(this.joinCtx, 'JOIN', tableOrAlias, callback);
+        return this;
+    }
+    leftJoin(tableOrAlias, callback) {
+        (0, select_joins_1.executeMysqlTypeSafeJoin)(this.joinCtx, 'LEFT JOIN', tableOrAlias, callback);
+        return this;
+    }
+    rightJoin(tableOrAlias, callback) {
+        (0, select_joins_1.executeMysqlTypeSafeJoin)(this.joinCtx, 'RIGHT JOIN', tableOrAlias, callback);
+        return this;
+    }
+    innerJoin(tableOrAlias, callback) {
+        (0, select_joins_1.executeMysqlTypeSafeJoin)(this.joinCtx, 'INNER JOIN', tableOrAlias, callback);
+        return this;
+    }
+    crossJoin(tableOrAlias) {
+        const [tableKey, alias] = Array.isArray(tableOrAlias) ? tableOrAlias : [tableOrAlias, tableOrAlias];
+        const internal = this.relq[methods_1.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 ${mysql_format_1.default.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 ${mysql_format_1.default.ident(alias)} ON ${onClause}`);
+        return this;
+    }
+    joinMany(tableOrAlias, callbackOrOptions, throughCallback) {
+        if (callbackOrOptions && typeof callbackOrOptions === 'object' && 'through' in callbackOrOptions) {
+            (0, select_joins_1.executeMysqlJoinManyThrough)(this.joinCtx, tableOrAlias, callbackOrOptions.through, throughCallback);
+        }
+        else {
+            (0, select_joins_1.executeMysqlCorrelatedSubqueryJoin)(this.joinCtx, tableOrAlias, callbackOrOptions);
+        }
+        return this;
+    }
+    leftJoinMany(tableOrAlias, callbackOrOptions, throughCallback) {
+        if (callbackOrOptions && typeof callbackOrOptions === 'object' && 'through' in callbackOrOptions) {
+            (0, select_joins_1.executeMysqlJoinManyThrough)(this.joinCtx, tableOrAlias, callbackOrOptions.through, throughCallback);
+        }
+        else {
+            (0, select_joins_1.executeMysqlCorrelatedSubqueryJoin)(this.joinCtx, tableOrAlias, callbackOrOptions);
+        }
+        return this;
+    }
+    joinManyLateral(tableOrAlias, callbackOrOptions, throughCallback) {
+        if (callbackOrOptions && typeof callbackOrOptions === 'object' && 'through' in callbackOrOptions) {
+            (0, select_joins_1.executeMysqlLateralJoinThrough)(this.joinCtx, 'JOIN', tableOrAlias, callbackOrOptions.through, throughCallback);
+        }
+        else {
+            (0, select_joins_1.executeMysqlLateralJoin)(this.joinCtx, 'JOIN', tableOrAlias, callbackOrOptions);
+        }
+        return this;
+    }
+    leftJoinManyLateral(tableOrAlias, callbackOrOptions, throughCallback) {
+        if (callbackOrOptions && typeof callbackOrOptions === 'object' && 'through' in callbackOrOptions) {
+            (0, select_joins_1.executeMysqlLateralJoinThrough)(this.joinCtx, 'LEFT JOIN', tableOrAlias, callbackOrOptions.through, throughCallback);
+        }
+        else {
+            (0, select_joins_1.executeMysqlLateralJoin)(this.joinCtx, 'LEFT JOIN', tableOrAlias, callbackOrOptions);
+        }
+        return this;
+    }
+    with(table) {
+        (0, select_joins_1.executeMysqlTypeSafeJoin)(this.joinCtx, 'LEFT JOIN', table);
+        return this;
+    }
+    withMany(table, options) {
+        if (options && 'through' in options) {
+            (0, select_joins_1.executeMysqlJoinManyThrough)(this.joinCtx, table, options.through);
+            return this;
+        }
+        const internal = this.relq[methods_1.INTERNAL];
+        const schema = internal.getSchema();
+        if (!schema) {
+            throw new relq_errors_1.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 = (0, fk_resolver_1.resolveMysqlForeignKey)(schema, sourceKey, table);
+        if (!fk) {
+            throw new relq_errors_1.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.` });
+        }
+        (0, select_joins_1.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() {
+        (0, capability_guard_1.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[methods_1.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[methods_1.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 (0, select_pagination_1.executeMysqlCursorEach)(this.paginationCtx, callback, options);
+    }
+    async pagination(options) {
+        return (0, select_pagination_1.executeMysqlPagination)(this.paginationCtx, options, (opts) => this.pagination(opts));
+    }
+}
+exports.MysqlConnectedSelectBuilder = MysqlConnectedSelectBuilder;