@relq/orm 0.1.0

package/dist/esm/core/helpers/ReturningExecutor.js

@@ -0,0 +1,66 @@
+import { InsertBuilder } from "../../insert/insert-builder.js";
+import { UpdateBuilder } from "../../update/update-builder.js";
+import { INTERNAL } from "./methods.js";
+export 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[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 InsertBuilder) {
+            for (const row of this.builder.insertData) {
+                this.relq[INTERNAL].validateData(this.builder.tableName, row, 'insert');
+            }
+        }
+        else if (this.builder instanceof UpdateBuilder) {
+            this.relq[INTERNAL].validateData(this.builder.tableName, this.builder.updateData, 'update');
+        }
+        const sql = this.builder.toString();
+        const result = await this.relq[INTERNAL].executeSelect(sql);
+        const transformedData = result.data.map(row => this.transformRow(row));
+        if (withMetadata) {
+            return { ...result, data: transformedData };
+        }
+        return transformedData;
+    }
+}

package/dist/esm/core/helpers/capability-guard.js

@@ -0,0 +1,7 @@
+import { RelqDialectError } from "../shared/errors.js";
+export function requireCapability(relq, capability, featureName, suggestion) {
+    const value = relq.capabilities[capability];
+    if (value === false) {
+        throw new RelqDialectError(`${featureName} is not supported`, relq.dialect, suggestion);
+    }
+}

package/dist/esm/core/helpers/index.js

@@ -0,0 +1,13 @@
+export { ConnectedAggregateBuilder } from "./ConnectedAggregateBuilder.js";
+export { ConnectedCTEBuilder } from "./ConnectedCTEBuilder.js";
+export { ConnectedSelectBuilder } from "./ConnectedSelectBuilder.js";
+export { ConnectedUpdateBuilder } from "./ConnectedUpdateBuilder.js";
+export { ConnectedDeleteBuilder } from "./ConnectedDeleteBuilder.js";
+export { ConnectedInsertBuilder } from "./ConnectedInsertBuilder.js";
+export { ConnectedCountBuilder } from "./ConnectedCountBuilder.js";
+export { TransactionClient, executeTransaction } from "./ConnectedTransactionBuilder.js";
+export { ConnectedQueryBuilder } from "./ConnectedQueryBuilder.js";
+export { ConnectedRawQueryBuilder } from "./ConnectedRawQueryBuilder.js";
+export { PaginateBuilder } from "./PaginateBuilder.js";
+export { ReturningExecutor } from "./ReturningExecutor.js";
+export { INTERNAL, debugLog } from "./methods.js";

package/dist/esm/core/helpers/methods.js

@@ -0,0 +1,6 @@
+export const INTERNAL = Symbol('relq-internal');
+export function debugLog(config, ...args) {
+    if (config?.logLevel === 'debug') {
+        console.log('[Relq DEBUG]', ...args);
+    }
+}

package/dist/esm/core/helpers/query-convenience.js

@@ -0,0 +1,194 @@
+import { CountBuilder } from "../../count/count-builder.js";
+import { InsertBuilder } from "../../insert/insert-builder.js";
+import { SelectBuilder } from "../../select/select-builder.js";
+import { UpdateBuilder } from "../../update/update-builder.js";
+import { INTERNAL } from "./methods.js";
+export async function executeFindById(ctx, id, getPrimaryKeyColumn) {
+    const pkColumn = getPrimaryKeyColumn();
+    const dbColumn = ctx.relq[INTERNAL].transformToDbColumns(ctx.tableName, { [pkColumn]: id });
+    const dbColName = Object.keys(dbColumn)[0];
+    const builder = new SelectBuilder(ctx.tableName, ['*']);
+    builder.where(q => q.equal(dbColName, id));
+    builder.limit(1);
+    const sql = builder.toString();
+    const result = await ctx.relq[INTERNAL].executeSelectOne(sql, ctx.tableName);
+    return result.data;
+}
+export async function executeFindOne(ctx, filter) {
+    const builder = new SelectBuilder(ctx.tableName, ['*']);
+    const dbFilter = ctx.relq[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[INTERNAL].executeSelectOne(sql, ctx.tableName);
+    return result.data;
+}
+export async function executeFindMany(ctx, filter) {
+    const builder = new SelectBuilder(ctx.tableName, ['*']);
+    const dbFilter = ctx.relq[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[INTERNAL].executeSelect(sql, ctx.tableName);
+    return result.data;
+}
+export async function executeExists(ctx, filter) {
+    const builder = new CountBuilder(ctx.tableName);
+    const dbFilter = ctx.relq[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[INTERNAL].executeCount(sql);
+    return result.count > 0;
+}
+export async function executeUpsert(ctx, options) {
+    const dbCreate = ctx.relq[INTERNAL].transformToDbColumns(ctx.tableName, options.create);
+    const dbUpdate = ctx.relq[INTERNAL].transformToDbColumns(ctx.tableName, options.update);
+    const dbWhere = ctx.relq[INTERNAL].transformToDbColumns(ctx.tableName, options.where);
+    const conflictColumn = Object.keys(dbWhere)[0];
+    const builder = new InsertBuilder(ctx.tableName, dbCreate);
+    builder._onConflict(conflictColumn, cb => cb.doUpdate(dbUpdate));
+    builder.returning(['*']);
+    const sql = builder.toString();
+    const result = await ctx.relq[INTERNAL].executeQuery(sql);
+    const transformed = ctx.relq[INTERNAL].transformResultsFromDb(ctx.tableName, result.result.rows);
+    return transformed[0];
+}
+export async function executeSoftDelete(ctx, filter) {
+    const dbFilter = ctx.relq[INTERNAL].transformToDbColumns(ctx.tableName, filter);
+    const builder = new 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[INTERNAL].executeQuery(sql);
+    if (result.result.rows.length === 0)
+        return null;
+    const transformed = ctx.relq[INTERNAL].transformResultsFromDb(ctx.tableName, result.result.rows);
+    return transformed[0];
+}
+export async function executeRestore(ctx, filter) {
+    const dbFilter = ctx.relq[INTERNAL].transformToDbColumns(ctx.tableName, filter);
+    const builder = new 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[INTERNAL].executeQuery(sql);
+    if (result.result.rows.length === 0)
+        return null;
+    const transformed = ctx.relq[INTERNAL].transformResultsFromDb(ctx.tableName, result.result.rows);
+    return transformed[0];
+}
+export async function executeCreateWith(ctx, parentData, related) {
+    const internal = ctx.relq[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 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 import("../../utils/fk-resolver.js");
+            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 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;
+}
+export 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/esm/core/helpers/select-joins.js

@@ -0,0 +1,246 @@
+import { createTableProxy } from "../../select/table-proxy.js";
+import { JoinConditionBuilder } from "../../select/join-condition-builder.js";
+import { JOIN_INTERNAL, JOIN_SETUP } from "../../select/join-internals.js";
+import { JoinManyConditionBuilder } from "../../select/join-many-condition-builder.js";
+import { RelqQueryError } from "../../../shared/errors/relq-errors.js";
+import { resolveForeignKey } from "../../utils/fk-resolver.js";
+import { INTERNAL } from "./methods.js";
+export function executeTypeSafeJoin(ctx, joinType, tableOrAlias, callback) {
+    const [rightTableKey, rightAlias] = Array.isArray(tableOrAlias)
+        ? tableOrAlias
+        : [tableOrAlias, tableOrAlias];
+    const internal = ctx.relq[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 = createTableProxy(leftTableName, leftAlias, leftTableDef);
+    const rightProxy = createTableProxy(rightTableName, rightAlias, rightTableDef);
+    const conditionBuilder = new JoinConditionBuilder();
+    if (callback) {
+        if (joinType === 'RIGHT JOIN') {
+            callback(conditionBuilder, leftProxy, rightProxy);
+        }
+        else {
+            callback(conditionBuilder, rightProxy, leftProxy);
+        }
+    }
+    const conditionInternals = conditionBuilder[JOIN_INTERNAL];
+    if (!conditionInternals.hasConditions() && schema && relations) {
+        const fkResolution = 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 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);
+}
+export function executeTypeSafeJoinMany(ctx, joinType, tableOrAlias, callback) {
+    const [rightTableKey, rightAlias] = Array.isArray(tableOrAlias)
+        ? tableOrAlias
+        : [tableOrAlias, tableOrAlias];
+    const internal = ctx.relq[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 = createTableProxy(leftTableName, leftAlias, leftTableDef);
+    const rightProxy = createTableProxy(rightTableName, rightAlias, rightTableDef);
+    const conditionBuilder = new JoinManyConditionBuilder();
+    const proxyCreator = (tableKey, alias) => {
+        const tableDef = internal.getTableDef(tableKey);
+        const sqlTableName = tableDef?.$name || tableKey;
+        return {
+            proxy: createTableProxy(sqlTableName, alias, tableDef),
+            tableName: sqlTableName
+        };
+    };
+    conditionBuilder[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_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(' ');
+}
+export function executeTypeSafeJoinManyThrough(ctx, joinType, targetTableOrAlias, junctionTableKey, callback) {
+    const [targetKey, targetAlias] = Array.isArray(targetTableOrAlias)
+        ? targetTableOrAlias
+        : [targetTableOrAlias, targetTableOrAlias];
+    const internal = ctx.relq[INTERNAL];
+    const schema = internal.getSchema();
+    const relations = internal.getRelations();
+    if (!schema || !relations) {
+        throw new 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 = resolveForeignKey(relations, schema, ctx.schemaKey || ctx.tableName, junctionTableKey);
+    if (!leftToJunction) {
+        throw new 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 = resolveForeignKey(relations, schema, junctionTableKey, targetKey);
+    if (!junctionToTarget) {
+        throw new 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 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_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(' ');
+}