@relq/orm 0.1.0

package/dist/cjs/core/helpers/ReturningExecutor.cjs

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturningExecutor = void 0;
+const insert_builder_1 = require("../../insert/insert-builder.cjs");
+const update_builder_1 = require("../../update/update-builder.cjs");
+const methods_1 = require("./methods.cjs");
+class ReturningExecutor {
+    builder;
+    relq;
+    tableName;
+    schemaKey;
+    columnMapping;
+    constructor(builder, relq, tableName, schemaKey) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnMapping();
+    }
+    setupColumnMapping() {
+        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.columnMapping = new Map();
+        for (const [propName, columnDef] of Object.entries(tableColumns)) {
+            if (columnDef && typeof columnDef === 'object') {
+                const sqlName = columnDef.$columnName || propName;
+                this.columnMapping.set(sqlName, propName);
+            }
+        }
+    }
+    transformRow(row) {
+        if (!this.columnMapping) {
+            return row;
+        }
+        const transformed = {};
+        for (const [sqlKey, value] of Object.entries(row)) {
+            const propName = this.columnMapping.get(sqlKey) || sqlKey;
+            transformed[propName] = value;
+        }
+        return transformed;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async run(withMetadata) {
+        if (this.builder instanceof insert_builder_1.InsertBuilder) {
+            for (const row of this.builder.insertData) {
+                this.relq[methods_1.INTERNAL].validateData(this.builder.tableName, row, 'insert');
+            }
+        }
+        else if (this.builder instanceof update_builder_1.UpdateBuilder) {
+            this.relq[methods_1.INTERNAL].validateData(this.builder.tableName, this.builder.updateData, 'update');
+        }
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeSelect(sql);
+        const transformedData = result.data.map(row => this.transformRow(row));
+        if (withMetadata) {
+            return { ...result, data: transformedData };
+        }
+        return transformedData;
+    }
+}
+exports.ReturningExecutor = ReturningExecutor;

package/dist/cjs/core/helpers/capability-guard.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireCapability = requireCapability;
+const errors_1 = require("../shared/errors.cjs");
+function requireCapability(relq, capability, featureName, suggestion) {
+    const value = relq.capabilities[capability];
+    if (value === false) {
+        throw new errors_1.RelqDialectError(`${featureName} is not supported`, relq.dialect, suggestion);
+    }
+}

package/dist/cjs/core/helpers/index.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugLog = exports.INTERNAL = exports.ReturningExecutor = exports.PaginateBuilder = exports.ConnectedRawQueryBuilder = exports.ConnectedQueryBuilder = exports.executeTransaction = exports.TransactionClient = exports.ConnectedCountBuilder = exports.ConnectedInsertBuilder = exports.ConnectedDeleteBuilder = exports.ConnectedUpdateBuilder = exports.ConnectedSelectBuilder = exports.ConnectedCTEBuilder = exports.ConnectedAggregateBuilder = void 0;
+var ConnectedAggregateBuilder_1 = require("./ConnectedAggregateBuilder.cjs");
+Object.defineProperty(exports, "ConnectedAggregateBuilder", { enumerable: true, get: function () { return ConnectedAggregateBuilder_1.ConnectedAggregateBuilder; } });
+var ConnectedCTEBuilder_1 = require("./ConnectedCTEBuilder.cjs");
+Object.defineProperty(exports, "ConnectedCTEBuilder", { enumerable: true, get: function () { return ConnectedCTEBuilder_1.ConnectedCTEBuilder; } });
+var ConnectedSelectBuilder_1 = require("./ConnectedSelectBuilder.cjs");
+Object.defineProperty(exports, "ConnectedSelectBuilder", { enumerable: true, get: function () { return ConnectedSelectBuilder_1.ConnectedSelectBuilder; } });
+var ConnectedUpdateBuilder_1 = require("./ConnectedUpdateBuilder.cjs");
+Object.defineProperty(exports, "ConnectedUpdateBuilder", { enumerable: true, get: function () { return ConnectedUpdateBuilder_1.ConnectedUpdateBuilder; } });
+var ConnectedDeleteBuilder_1 = require("./ConnectedDeleteBuilder.cjs");
+Object.defineProperty(exports, "ConnectedDeleteBuilder", { enumerable: true, get: function () { return ConnectedDeleteBuilder_1.ConnectedDeleteBuilder; } });
+var ConnectedInsertBuilder_1 = require("./ConnectedInsertBuilder.cjs");
+Object.defineProperty(exports, "ConnectedInsertBuilder", { enumerable: true, get: function () { return ConnectedInsertBuilder_1.ConnectedInsertBuilder; } });
+var ConnectedCountBuilder_1 = require("./ConnectedCountBuilder.cjs");
+Object.defineProperty(exports, "ConnectedCountBuilder", { enumerable: true, get: function () { return ConnectedCountBuilder_1.ConnectedCountBuilder; } });
+var ConnectedTransactionBuilder_1 = require("./ConnectedTransactionBuilder.cjs");
+Object.defineProperty(exports, "TransactionClient", { enumerable: true, get: function () { return ConnectedTransactionBuilder_1.TransactionClient; } });
+Object.defineProperty(exports, "executeTransaction", { enumerable: true, get: function () { return ConnectedTransactionBuilder_1.executeTransaction; } });
+var ConnectedQueryBuilder_1 = require("./ConnectedQueryBuilder.cjs");
+Object.defineProperty(exports, "ConnectedQueryBuilder", { enumerable: true, get: function () { return ConnectedQueryBuilder_1.ConnectedQueryBuilder; } });
+var ConnectedRawQueryBuilder_1 = require("./ConnectedRawQueryBuilder.cjs");
+Object.defineProperty(exports, "ConnectedRawQueryBuilder", { enumerable: true, get: function () { return ConnectedRawQueryBuilder_1.ConnectedRawQueryBuilder; } });
+var PaginateBuilder_1 = require("./PaginateBuilder.cjs");
+Object.defineProperty(exports, "PaginateBuilder", { enumerable: true, get: function () { return PaginateBuilder_1.PaginateBuilder; } });
+var ReturningExecutor_1 = require("./ReturningExecutor.cjs");
+Object.defineProperty(exports, "ReturningExecutor", { enumerable: true, get: function () { return ReturningExecutor_1.ReturningExecutor; } });
+var methods_1 = require("./methods.cjs");
+Object.defineProperty(exports, "INTERNAL", { enumerable: true, get: function () { return methods_1.INTERNAL; } });
+Object.defineProperty(exports, "debugLog", { enumerable: true, get: function () { return methods_1.debugLog; } });

package/dist/cjs/core/helpers/methods.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTERNAL = void 0;
+exports.debugLog = debugLog;
+exports.INTERNAL = Symbol('relq-internal');
+function debugLog(config, ...args) {
+    if (config?.logLevel === 'debug') {
+        console.log('[Relq DEBUG]', ...args);
+    }
+}

package/dist/cjs/core/helpers/query-convenience.cjs

@@ -0,0 +1,238 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeFindById = executeFindById;
+exports.executeFindOne = executeFindOne;
+exports.executeFindMany = executeFindMany;
+exports.executeExists = executeExists;
+exports.executeUpsert = executeUpsert;
+exports.executeSoftDelete = executeSoftDelete;
+exports.executeRestore = executeRestore;
+exports.executeCreateWith = executeCreateWith;
+exports.getPrimaryKeyColumn = getPrimaryKeyColumn;
+const count_builder_1 = require("../../count/count-builder.cjs");
+const insert_builder_1 = require("../../insert/insert-builder.cjs");
+const select_builder_1 = require("../../select/select-builder.cjs");
+const update_builder_1 = require("../../update/update-builder.cjs");
+const methods_1 = require("./methods.cjs");
+async function executeFindById(ctx, id, getPrimaryKeyColumn) {
+    const pkColumn = getPrimaryKeyColumn();
+    const dbColumn = ctx.relq[methods_1.INTERNAL].transformToDbColumns(ctx.tableName, { [pkColumn]: id });
+    const dbColName = Object.keys(dbColumn)[0];
+    const builder = new select_builder_1.SelectBuilder(ctx.tableName, ['*']);
+    builder.where(q => q.equal(dbColName, id));
+    builder.limit(1);
+    const sql = builder.toString();
+    const result = await ctx.relq[methods_1.INTERNAL].executeSelectOne(sql, ctx.tableName);
+    return result.data;
+}
+async function executeFindOne(ctx, filter) {
+    const builder = new select_builder_1.SelectBuilder(ctx.tableName, ['*']);
+    const dbFilter = ctx.relq[methods_1.INTERNAL].transformToDbColumns(ctx.tableName, filter);
+    builder.where(q => {
+        for (const [col, val] of Object.entries(dbFilter)) {
+            q.equal(col, val);
+        }
+        return q;
+    });
+    builder.limit(1);
+    const sql = builder.toString();
+    const result = await ctx.relq[methods_1.INTERNAL].executeSelectOne(sql, ctx.tableName);
+    return result.data;
+}
+async function executeFindMany(ctx, filter) {
+    const builder = new select_builder_1.SelectBuilder(ctx.tableName, ['*']);
+    const dbFilter = ctx.relq[methods_1.INTERNAL].transformToDbColumns(ctx.tableName, filter);
+    builder.where(q => {
+        for (const [col, val] of Object.entries(dbFilter)) {
+            q.equal(col, val);
+        }
+        return q;
+    });
+    const sql = builder.toString();
+    const result = await ctx.relq[methods_1.INTERNAL].executeSelect(sql, ctx.tableName);
+    return result.data;
+}
+async function executeExists(ctx, filter) {
+    const builder = new count_builder_1.CountBuilder(ctx.tableName);
+    const dbFilter = ctx.relq[methods_1.INTERNAL].transformToDbColumns(ctx.tableName, filter);
+    builder.where(q => {
+        for (const [col, val] of Object.entries(dbFilter)) {
+            q.equal(col, val);
+        }
+        return q;
+    });
+    const sql = builder.toString();
+    const result = await ctx.relq[methods_1.INTERNAL].executeCount(sql);
+    return result.count > 0;
+}
+async function executeUpsert(ctx, options) {
+    const dbCreate = ctx.relq[methods_1.INTERNAL].transformToDbColumns(ctx.tableName, options.create);
+    const dbUpdate = ctx.relq[methods_1.INTERNAL].transformToDbColumns(ctx.tableName, options.update);
+    const dbWhere = ctx.relq[methods_1.INTERNAL].transformToDbColumns(ctx.tableName, options.where);
+    const conflictColumn = Object.keys(dbWhere)[0];
+    const builder = new insert_builder_1.InsertBuilder(ctx.tableName, dbCreate);
+    builder._onConflict(conflictColumn, cb => cb.doUpdate(dbUpdate));
+    builder.returning(['*']);
+    const sql = builder.toString();
+    const result = await ctx.relq[methods_1.INTERNAL].executeQuery(sql);
+    const transformed = ctx.relq[methods_1.INTERNAL].transformResultsFromDb(ctx.tableName, result.result.rows);
+    return transformed[0];
+}
+async function executeSoftDelete(ctx, filter) {
+    const dbFilter = ctx.relq[methods_1.INTERNAL].transformToDbColumns(ctx.tableName, filter);
+    const builder = new update_builder_1.UpdateBuilder(ctx.tableName, { deleted_at: new Date() });
+    builder.where(q => {
+        for (const [col, val] of Object.entries(dbFilter)) {
+            q.equal(col, val);
+        }
+        return q;
+    });
+    builder.returning(['*']);
+    const sql = builder.toString();
+    const result = await ctx.relq[methods_1.INTERNAL].executeQuery(sql);
+    if (result.result.rows.length === 0)
+        return null;
+    const transformed = ctx.relq[methods_1.INTERNAL].transformResultsFromDb(ctx.tableName, result.result.rows);
+    return transformed[0];
+}
+async function executeRestore(ctx, filter) {
+    const dbFilter = ctx.relq[methods_1.INTERNAL].transformToDbColumns(ctx.tableName, filter);
+    const builder = new update_builder_1.UpdateBuilder(ctx.tableName, { deleted_at: null });
+    builder.where(q => {
+        for (const [col, val] of Object.entries(dbFilter)) {
+            q.equal(col, val);
+        }
+        return q;
+    });
+    builder.returning(['*']);
+    const sql = builder.toString();
+    const result = await ctx.relq[methods_1.INTERNAL].executeQuery(sql);
+    if (result.result.rows.length === 0)
+        return null;
+    const transformed = ctx.relq[methods_1.INTERNAL].transformResultsFromDb(ctx.tableName, result.result.rows);
+    return transformed[0];
+}
+async function executeCreateWith(ctx, parentData, related) {
+    const internal = ctx.relq[methods_1.INTERNAL];
+    const schema = internal.getSchema();
+    const relations = internal.getRelations();
+    if (!schema || !relations) {
+        throw new Error('Cannot use createWith() without schema and relations config. ' +
+            'Use separate insert calls with a transaction instead.');
+    }
+    const parentSchemaKey = findSchemaKeyByTableName(schema, ctx.tableName) || ctx.tableName;
+    try {
+        await internal.executeRun('BEGIN');
+        const dbParent = internal.transformToDbColumns(ctx.tableName, parentData);
+        const parentBuilder = new insert_builder_1.InsertBuilder(ctx.tableName, dbParent);
+        parentBuilder.returning(['*']);
+        const parentSQL = parentBuilder.toString();
+        const parentResult = await internal.executeQuery(parentSQL);
+        if (!parentResult.result.rows || parentResult.result.rows.length === 0) {
+            throw new Error('Parent insert returned no rows');
+        }
+        const parentRow = parentResult.result.rows[0];
+        for (const [relationKey, childData] of Object.entries(related)) {
+            const childTableDef = schema[relationKey];
+            if (!childTableDef) {
+                throw new Error(`Unknown table "${relationKey}" in createWith(). Check your schema.`);
+            }
+            const childTableName = childTableDef.$name || relationKey;
+            const { resolveForeignKey } = await Promise.resolve().then(() => __importStar(require("../../utils/fk-resolver.cjs")));
+            const fk = resolveForeignKey(relations, schema, parentSchemaKey, relationKey);
+            if (!fk) {
+                throw new Error(`No FK relationship between "${parentSchemaKey}" and "${relationKey}". ` +
+                    'Define the relationship in your relations config.');
+            }
+            let fkColumn;
+            let fkValue;
+            if (fk.direction === 'reverse') {
+                fkColumn = fk.toColumn;
+                fkValue = parentRow[fk.fromColumn];
+            }
+            else {
+                fkColumn = fk.fromColumn;
+                fkValue = parentRow[fk.toColumn];
+            }
+            const rows = Array.isArray(childData) ? childData : [childData];
+            if (rows.length === 0)
+                continue;
+            const firstRow = { ...rows[0], [fkColumn]: fkValue };
+            const dbFirst = internal.transformToDbColumns(childTableName, firstRow);
+            const childBuilder = new insert_builder_1.InsertBuilder(childTableName, dbFirst);
+            for (let i = 1; i < rows.length; i++) {
+                const row = { ...rows[i], [fkColumn]: fkValue };
+                const dbRow = internal.transformToDbColumns(childTableName, row);
+                childBuilder.addRow(dbRow);
+            }
+            const childSQL = childBuilder.toString();
+            await internal.executeQuery(childSQL);
+        }
+        await internal.executeRun('COMMIT');
+        const transformed = internal.transformResultsFromDb(ctx.tableName, [parentRow]);
+        return transformed[0];
+    }
+    catch (error) {
+        try {
+            await internal.executeRun('ROLLBACK');
+        }
+        catch {
+        }
+        throw error;
+    }
+}
+function findSchemaKeyByTableName(schema, tableName) {
+    for (const [key, def] of Object.entries(schema)) {
+        if (def?.$name === tableName || key === tableName) {
+            return key;
+        }
+    }
+    return null;
+}
+function getPrimaryKeyColumn(relq, tableName) {
+    const schema = relq.schema;
+    if (schema && schema[tableName]) {
+        const tableSchema = schema[tableName];
+        for (const [colName, colDef] of Object.entries(tableSchema)) {
+            if (colDef && typeof colDef === 'object' &&
+                ('$primaryKey' in colDef ||
+                    colDef.config?.$primaryKey === true)) {
+                return colName;
+            }
+        }
+    }
+    return 'id';
+}

package/dist/cjs/core/helpers/select-joins.cjs

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTypeSafeJoin = executeTypeSafeJoin;
+exports.executeTypeSafeJoinMany = executeTypeSafeJoinMany;
+exports.executeTypeSafeJoinManyThrough = executeTypeSafeJoinManyThrough;
+const table_proxy_1 = require("../../select/table-proxy.cjs");
+const join_condition_builder_1 = require("../../select/join-condition-builder.cjs");
+const join_internals_1 = require("../../select/join-internals.cjs");
+const join_many_condition_builder_1 = require("../../select/join-many-condition-builder.cjs");
+const relq_errors_1 = require("../../../shared/errors/relq-errors.cjs");
+const fk_resolver_1 = require("../../utils/fk-resolver.cjs");
+const methods_1 = require("./methods.cjs");
+function executeTypeSafeJoin(ctx, joinType, tableOrAlias, callback) {
+    const [rightTableKey, rightAlias] = Array.isArray(tableOrAlias)
+        ? tableOrAlias
+        : [tableOrAlias, tableOrAlias];
+    const internal = ctx.relq[methods_1.INTERNAL];
+    const schema = internal.getSchema();
+    const relations = internal.getRelations();
+    const leftTableDef = internal.getTableDef(ctx.schemaKey || ctx.tableName);
+    const rightTableDef = internal.getTableDef(rightTableKey);
+    const leftTableName = leftTableDef?.$name || ctx.tableName;
+    const rightTableName = rightTableDef?.$name || rightTableKey;
+    const leftAlias = ctx.builder.getTableIdentifier();
+    const leftProxy = (0, table_proxy_1.createTableProxy)(leftTableName, leftAlias, leftTableDef);
+    const rightProxy = (0, table_proxy_1.createTableProxy)(rightTableName, rightAlias, rightTableDef);
+    const conditionBuilder = new join_condition_builder_1.JoinConditionBuilder();
+    if (callback) {
+        if (joinType === 'RIGHT JOIN') {
+            callback(conditionBuilder, leftProxy, rightProxy);
+        }
+        else {
+            callback(conditionBuilder, rightProxy, leftProxy);
+        }
+    }
+    const conditionInternals = conditionBuilder[join_internals_1.JOIN_INTERNAL];
+    if (!conditionInternals.hasConditions() && schema && relations) {
+        const fkResolution = (0, fk_resolver_1.resolveForeignKey)(relations, schema, ctx.schemaKey || ctx.tableName, rightTableKey);
+        if (fkResolution) {
+            const leftCol = leftProxy[fkResolution.fromColumn];
+            const rightCol = rightProxy[fkResolution.toColumn];
+            conditionBuilder.equal(leftCol, rightCol);
+        }
+        else {
+            throw new relq_errors_1.RelqQueryError(`Cannot auto-resolve FK relationship between "${ctx.schemaKey || ctx.tableName}" and "${rightTableKey}". ` +
+                `Either provide a callback with explicit join conditions, or define the relationship in your relations config.`, { hint: `Use .join('${rightTableKey}', (on, ${rightTableKey}, source) => on.equal(${rightTableKey}.id, source.columnName))` });
+        }
+    }
+    const selectedProps = conditionInternals.getSelectedColumns();
+    let selectColumns;
+    const toSnake = (s) => s.replace(/[A-Z]/g, l => `_${l.toLowerCase()}`);
+    if (selectedProps && selectedProps.length > 0) {
+        const rightColumns = rightTableDef?.$columns || rightTableDef;
+        selectColumns = selectedProps.map(prop => {
+            const columnDef = rightColumns?.[prop];
+            const sqlName = columnDef?.$columnName || toSnake(prop);
+            return { property: prop, sqlName };
+        });
+    }
+    else if (rightTableDef) {
+        const rightColumns = rightTableDef.$columns || rightTableDef;
+        selectColumns = Object.entries(rightColumns)
+            .filter(([_, colDef]) => colDef && typeof colDef === 'object' && '$type' in colDef)
+            .map(([propName, colDef]) => ({
+            property: propName,
+            sqlName: colDef.$columnName || toSnake(propName),
+        }));
+    }
+    const joinClause = {
+        type: joinType,
+        table: rightTableName,
+        alias: rightAlias,
+        schemaKey: rightTableKey,
+        onClause: conditionInternals.toSQL() || undefined,
+        usingColumns: conditionInternals.getUsingColumns() || undefined,
+        selectColumns
+    };
+    ctx.builder.addStructuredJoin(joinClause);
+}
+function executeTypeSafeJoinMany(ctx, joinType, tableOrAlias, callback) {
+    const [rightTableKey, rightAlias] = Array.isArray(tableOrAlias)
+        ? tableOrAlias
+        : [tableOrAlias, tableOrAlias];
+    const internal = ctx.relq[methods_1.INTERNAL];
+    const leftTableDef = internal.getTableDef(ctx.schemaKey || ctx.tableName);
+    const rightTableDef = internal.getTableDef(rightTableKey);
+    const leftTableName = leftTableDef?.$name || ctx.tableName;
+    const rightTableName = rightTableDef?.$name || rightTableKey;
+    const leftAlias = ctx.builder.getTableIdentifier();
+    const leftProxy = (0, table_proxy_1.createTableProxy)(leftTableName, leftAlias, leftTableDef);
+    const rightProxy = (0, table_proxy_1.createTableProxy)(rightTableName, rightAlias, rightTableDef);
+    const conditionBuilder = new join_many_condition_builder_1.JoinManyConditionBuilder();
+    const proxyCreator = (tableKey, alias) => {
+        const tableDef = internal.getTableDef(tableKey);
+        const sqlTableName = tableDef?.$name || tableKey;
+        return {
+            proxy: (0, table_proxy_1.createTableProxy)(sqlTableName, alias, tableDef),
+            tableName: sqlTableName
+        };
+    };
+    conditionBuilder[join_internals_1.JOIN_SETUP](proxyCreator, rightProxy);
+    callback(conditionBuilder, rightProxy, leftProxy);
+    const lateralSQL = buildLateralSubquery(rightTableName, rightAlias, conditionBuilder, rightTableDef);
+    const lateralJoinType = joinType === 'LEFT JOIN' ? 'LEFT JOIN LATERAL' : 'JOIN LATERAL';
+    const joinClause = {
+        type: lateralJoinType,
+        table: rightTableName,
+        alias: rightAlias,
+        schemaKey: rightTableKey,
+        lateralSubquery: lateralSQL
+    };
+    ctx.builder.addStructuredJoin(joinClause);
+}
+function buildLateralSubquery(tableName, alias, builder, tableDef) {
+    const parts = [];
+    parts.push('(SELECT');
+    parts.push(`COALESCE(jsonb_agg(row_to_json(sub.*)), '[]'::jsonb) AS ${alias}`);
+    parts.push('FROM (');
+    const internals = builder[join_internals_1.JOIN_INTERNAL];
+    parts.push('SELECT');
+    const selectedProps = internals.getSelectedColumns();
+    const innerJoins = internals.getInnerJoins();
+    const hasInnerJoins = innerJoins.length > 0;
+    const toSnake = (s) => s.replace(/[A-Z]/g, l => `_${l.toLowerCase()}`);
+    if (selectedProps && selectedProps.length > 0) {
+        const tableColumns = tableDef?.$columns || tableDef;
+        const selectCols = selectedProps.map(prop => {
+            const columnDef = tableColumns?.[prop];
+            if (columnDef || !hasInnerJoins) {
+                const sqlName = columnDef?.$columnName || toSnake(prop);
+                return `"${alias}"."${sqlName}" AS "${prop}"`;
+            }
+            else {
+                const sqlName = toSnake(prop);
+                return `"${sqlName}" AS "${prop}"`;
+            }
+        }).join(', ');
+        parts.push(selectCols);
+    }
+    else {
+        parts.push(`"${alias}".*`);
+    }
+    parts.push(`FROM "${tableName}" AS "${alias}"`);
+    for (const join of innerJoins) {
+        parts.push(`${join.type} "${join.table}" AS "${join.alias}" ON ${join.onClause}`);
+    }
+    const whereSQL = internals.toWhereSQL();
+    if (whereSQL) {
+        parts.push(`WHERE ${whereSQL}`);
+    }
+    const orderBySQL = internals.toOrderBySQL();
+    if (orderBySQL) {
+        parts.push(`ORDER BY ${orderBySQL}`);
+    }
+    const limitSQL = internals.toLimitSQL();
+    if (limitSQL) {
+        parts.push(limitSQL);
+    }
+    const offsetSQL = internals.toOffsetSQL();
+    if (offsetSQL) {
+        parts.push(offsetSQL);
+    }
+    parts.push(') sub');
+    parts.push(`) AS "${alias}_lateral"`);
+    return parts.join(' ');
+}
+function executeTypeSafeJoinManyThrough(ctx, joinType, targetTableOrAlias, junctionTableKey, callback) {
+    const [targetKey, targetAlias] = Array.isArray(targetTableOrAlias)
+        ? targetTableOrAlias
+        : [targetTableOrAlias, targetTableOrAlias];
+    const internal = ctx.relq[methods_1.INTERNAL];
+    const schema = internal.getSchema();
+    const relations = internal.getRelations();
+    if (!schema || !relations) {
+        throw new relq_errors_1.RelqQueryError(`Cannot use { through } without schema and relations config.`, { hint: `Define relations in your schema to use the { through } pattern, or use the callback form of joinMany instead.` });
+    }
+    const leftTableDef = internal.getTableDef(ctx.schemaKey || ctx.tableName);
+    const junctionTableDef = internal.getTableDef(junctionTableKey);
+    const targetTableDef = internal.getTableDef(targetKey);
+    const leftTableName = leftTableDef?.$name || ctx.tableName;
+    const junctionTableName = junctionTableDef?.$name || junctionTableKey;
+    const targetTableName = targetTableDef?.$name || targetKey;
+    const leftAlias = ctx.builder.getTableIdentifier();
+    const leftToJunction = (0, fk_resolver_1.resolveForeignKey)(relations, schema, ctx.schemaKey || ctx.tableName, junctionTableKey);
+    if (!leftToJunction) {
+        throw new relq_errors_1.RelqQueryError(`Cannot resolve FK between "${ctx.schemaKey || ctx.tableName}" and junction table "${junctionTableKey}".`, { hint: `Define a foreign key relationship between these tables in your relations config, or use the callback form of joinMany instead.` });
+    }
+    const junctionToTarget = (0, fk_resolver_1.resolveForeignKey)(relations, schema, junctionTableKey, targetKey);
+    if (!junctionToTarget) {
+        throw new relq_errors_1.RelqQueryError(`Cannot resolve FK between junction table "${junctionTableKey}" and target table "${targetKey}".`, { hint: `Define a foreign key relationship between these tables in your relations config, or use the callback form of joinMany instead.` });
+    }
+    const conditionBuilder = new join_many_condition_builder_1.JoinManyConditionBuilder();
+    if (callback) {
+        callback(conditionBuilder);
+    }
+    const lateralSQL = buildThroughLateralSubquery(junctionTableName, junctionTableKey, targetTableName, targetAlias, leftAlias, leftToJunction, junctionToTarget, conditionBuilder, targetTableDef);
+    const lateralJoinType = joinType === 'LEFT JOIN' ? 'LEFT JOIN LATERAL' : 'JOIN LATERAL';
+    const joinClause = {
+        type: lateralJoinType,
+        table: targetTableName,
+        alias: targetAlias,
+        schemaKey: targetKey,
+        lateralSubquery: lateralSQL
+    };
+    ctx.builder.addStructuredJoin(joinClause);
+}
+function buildThroughLateralSubquery(junctionTableName, junctionAlias, targetTableName, targetAlias, leftAlias, leftToJunction, junctionToTarget, builder, targetTableDef) {
+    const parts = [];
+    const internals = builder[join_internals_1.JOIN_INTERNAL];
+    const toSnake = (s) => s.replace(/[A-Z]/g, l => `_${l.toLowerCase()}`);
+    parts.push('(SELECT');
+    parts.push(`COALESCE(jsonb_agg(row_to_json(sub.*)), '[]'::jsonb) AS ${targetAlias}`);
+    parts.push('FROM (');
+    parts.push('SELECT');
+    const selectedProps = internals.getSelectedColumns();
+    if (selectedProps && selectedProps.length > 0) {
+        const tableColumns = targetTableDef?.$columns || targetTableDef;
+        const selectCols = selectedProps.map(prop => {
+            const columnDef = tableColumns?.[prop];
+            const sqlName = columnDef?.$columnName || toSnake(prop);
+            return `"${targetAlias}"."${sqlName}" AS "${prop}"`;
+        }).join(', ');
+        parts.push(selectCols);
+    }
+    else {
+        parts.push(`"${targetAlias}".*`);
+    }
+    parts.push(`FROM "${junctionTableName}" AS "${junctionAlias}"`);
+    parts.push(`JOIN "${targetTableName}" AS "${targetAlias}" ON "${junctionAlias}"."${junctionToTarget.fromColumn}" = "${targetAlias}"."${junctionToTarget.toColumn}"`);
+    let whereSQL = `"${junctionAlias}"."${leftToJunction.toColumn}" = "${leftAlias}"."${leftToJunction.fromColumn}"`;
+    const userWhereSQL = internals.toWhereSQL();
+    if (userWhereSQL) {
+        whereSQL += ` AND ${userWhereSQL}`;
+    }
+    parts.push(`WHERE ${whereSQL}`);
+    const orderBySQL = internals.toOrderBySQL();
+    if (orderBySQL) {
+        parts.push(`ORDER BY ${orderBySQL}`);
+    }
+    const limitSQL = internals.toLimitSQL();
+    if (limitSQL) {
+        parts.push(limitSQL);
+    }
+    const offsetSQL = internals.toOffsetSQL();
+    if (offsetSQL) {
+        parts.push(offsetSQL);
+    }
+    parts.push(') sub');
+    parts.push(`) AS "${targetAlias}_lateral"`);
+    return parts.join(' ');
+}