joist-orm 1.218.2 → 1.220.0

package/build/QueryParser.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConditionBuilder = exports.skipCondition = void 0;
 exports.parseFindQuery = parseFindQuery;
+exports.parseAlias = parseAlias;
 exports.parseEntityFilter = parseEntityFilter;
 exports.parseValueFilter = parseValueFilter;
 exports.mapToDb = mapToDb;
@@ -9,9 +10,6 @@ exports.maybeAddOrderBy = maybeAddOrderBy;
 exports.addTablePerClassJoinsAndClassTag = addTablePerClassJoinsAndClassTag;
 exports.maybeAddNotSoftDeleted = maybeAddNotSoftDeleted;
 exports.getTables = getTables;
-exports.joinKeywords = joinKeywords;
-exports.joinClause = joinClause;
-exports.joinClauses = joinClauses;
 exports.makeLike = makeLike;
 const joist_utils_1 = require("joist-utils");
 const Aliases_1 = require("./Aliases");
@@ -20,6 +18,7 @@ const EntityMetadata_1 = require("./EntityMetadata");
 const QueryBuilder_1 = require("./QueryBuilder");
 const QueryVisitor_1 = require("./QueryVisitor");
 const configure_1 = require("./configure");
+const buildUtils_1 = require("./drivers/buildUtils");
 const index_1 = require("./index");
 const keywords_1 = require("./keywords");
 const utils_1 = require("./utils");
@@ -37,61 +36,200 @@ function parseFindQuery(meta, filter, opts = {}) {
     const tables = [];
     const orderBys = [];
     const query = { selects, tables, orderBys };
-    const { orderBy = undefined, conditions: optsExpression = undefined, softDeletes = "exclude", pruneJoins = true, keepAliases = [], } = opts;
+    const { orderBy = undefined, softDeletes = "exclude", pruneJoins = true, keepAliases = [] } = opts;
     const cb = new ConditionBuilder();
-    const aliases = {};
+    const aliases = opts.aliases ?? {};
     function getAlias(tableName) {
         const abbrev = (0, QueryBuilder_1.abbreviation)(tableName);
         const i = aliases[abbrev] || 0;
         aliases[abbrev] = i + 1;
         return i === 0 ? abbrev : `${abbrev}${i}`;
     }
-    function maybeAddNotSoftDeleted(meta, alias) {
-        if (filterSoftDeletes(meta, softDeletes)) {
-            const column = meta.allFields[(0, EntityMetadata_1.getBaseMeta)(meta).timestampFields.deletedAt].serde?.columns[0];
+    // If they passed extra `conditions: ...`, parse that.
+    // We can do this up-front b/c it doesn't require any join-tree metadata to perform,
+    // and then it's available for our `addLateralJoin`s to rewrite.
+    if (opts.conditions)
+        cb.maybeAddExpression(opts.conditions);
+    // Also see if outer `addLateralJoin` is passing us its join conditions
+    if (opts.rawConditions) {
+        for (const rc of opts.rawConditions)
+            cb.addRawCondition(rc);
+    }
+    function addLateralJoin(meta, fromAlias, alias, filter, 
+    // The join condition for the subquery from the outer table
+    condition, 
+    // If we're a m2m, the join table to inject (which will use the outer table)
+    joinTable, 
+    // Allow addOrderBy to do its own post-addTable lateral join building
+    orderByTables = undefined) {
+        const ef = parseEntityFilter(meta, filter);
+        // Maybe skip
+        if (!ef && !(0, Aliases_1.isAlias)(filter) && !orderByTables)
+            return;
+        bindAlias(filter, meta, alias);
+        // Create an alias to use for our subquery's `where parent_id = id` condition
+        const a = (0, Aliases_1.newAliasProxy)(meta.cstr);
+        // This is kinda janky, but take the `ef: ParsedEntityFilter` and re-work it back into a
+        // `subFilter/count` pair that we can use for our recursive `parseFindQuery` call.
+        function convertFilter() {
+            if (ef) {
+                if (ef.kind === "join") {
+                    // subFilter will be unprocessed, so we can pass it recursively into `parseFindQuery`
+                    return { subFilter: ef.subFilter, count: undefined };
+                }
+                else if (ef.kind === "not-null") {
+                    return { subFilter: {}, count: { kind: "gt", value: 0 } };
+                }
+                else if (ef.kind === "is-null") {
+                    return { subFilter: {}, count: { kind: "eq", value: 0 } };
+                }
+                else if (ef.kind === "eq") {
+                    return { subFilter: { id: ef.value }, count: undefined };
+                }
+                else if (ef.kind === "in") {
+                    return { subFilter: { id: { in: ef.value } }, count: undefined };
+                }
+                else {
+                    // If `ef` is set, it's already parsed, which `parseFindQuery` won't expect, so pass the original `filter`
+                    return { subFilter: { id: filter }, count: undefined };
+                }
+            }
+            else {
+                return { subFilter: {}, count: undefined };
+            }
+        }
+        const { subFilter, 
+        // If `ef` was is-null/not-null, use that as the count, otherwise probe for subFilter[$count]
+        count = subFilter && "$count" in subFilter ? { kind: "eq", value: subFilter["$count"] } : undefined, } = convertFilter();
+        const subQuery = parseFindQuery(meta, { as: a, ...subFilter }, {
+            // Only pass through a subset of the opts...
+            softDeletes: opts.softDeletes,
+            pruneJoins: opts.pruneJoins,
+            keepAliases: opts.keepAliases,
+            aliases,
+            alias,
+            // And set our own complex condition as the join condition (for o2m, two for m2m)
+            rawConditions: [condition],
+            // Let the subquery's pruneUnusedJoins know about the top-level WHERE clauses
+            topLevelCondition: opts.topLevelCondition ?? cb,
+            outerLateralJoins: [{ alias, select: selects, outerCb: cb }, ...(opts.outerLateralJoins ?? [])],
+        });
+        subQuery.orderBys = [];
+        if (joinTable)
+            subQuery.tables.unshift(joinTable);
+        const join = { join: "lateral", table: meta.tableName, query: subQuery, alias, fromAlias };
+        (orderByTables ?? tables).push(join);
+        // Look for complex conditions...
+        const topLevelAlias = opts.outerLateralJoins?.[opts.outerLateralJoins?.length - 1]?.alias;
+        const complexConditions = (opts.topLevelCondition ?? cb).findAndRewrite(topLevelAlias ?? alias, alias);
+        for (const cc of complexConditions) {
+            if (cc.cond.kind === "column" && cc.cond.column === "$count") {
+                subQuery.selects.push(buildCountStar(cc));
+            }
+            else {
+                const [sql, bindings] = (0, buildUtils_1.buildCondition)(cc.cond);
+                subQuery.selects.push({
+                    sql: `BOOL_OR(${sql}) as ${cc.as}`,
+                    aliases: [cc.cond.alias],
+                    bindings,
+                });
+            }
+        }
+        // If there are complex conditions looking at our data, we don't want a "make sure at least one matched"
+        const usedByComplexCondition = selects.some((s) => typeof s === "object" && "aliases" in s && s.aliases.includes(alias)) ||
+            // If we're the very 1st addLateralJoin, we don't push our selects into the next-up
+            // lateral join, so instead look through the top-level condition
+            (!opts.topLevelCondition &&
+                deepFindConditions(cb.expressions[0], true).some((c) => {
+                    return c.kind === "raw" && c.aliases.includes(alias);
+                }));
+        // If there are literally no conditions on this child relation, don't add the "make sure at least one matched"
+        const hasAnyFilter = deepFindConditions(subQuery.condition, true).length > 0 || count !== undefined;
+        if (!usedByComplexCondition && hasAnyFilter) {
             cb.addSimpleCondition({
                 kind: "column",
                 alias,
-                column: column.columnName,
-                dbType: column.dbType,
-                cond: { kind: "is-null" },
-                pruneable: true,
+                column: "_",
+                dbType: "int",
+                cond: count ?? { kind: "gt", value: 0 },
+                // Don't let this condition pin the join, unless the user asked for a specific count
+                // (or deepFindConditions finds a real condition from the above filter).
+                pruneable: count === undefined,
+            });
+            // Go up the tree and make sure any parent lateral joins have a "at least 1 match"
+            opts.outerLateralJoins?.forEach(({ alias, outerCb }) => {
+                outerCb.addSimpleCondition({
+                    kind: "column",
+                    alias,
+                    column: "_",
+                    dbType: "int",
+                    cond: { kind: "gt", value: 0 },
+                    pruneable: true,
+                });
             });
         }
+        return join;
     }
+    /** Adds `meta` to the query, i.e. for m2o/o2o joins into parents. */
     function addTable(meta, alias, join, col1, col2, filter) {
         // look at filter, is it `{ book: "b2" }` or `{ book: { ... } }`
         const ef = parseEntityFilter(meta, filter);
-        if (!ef && join !== "primary" && !(0, Aliases_1.isAlias)(filter)) {
+        // Maybe skip
+        if (!ef && join !== "primary" && !(0, Aliases_1.isAlias)(filter))
             return;
-        }
         if (join === "primary") {
             tables.push({ alias, table: meta.tableName, join });
         }
+        else if (join === "lateral") {
+            (0, utils_1.fail)("Unexpected lateral join");
+        }
         else {
             tables.push({ alias, table: meta.tableName, join, col1, col2 });
         }
         // Maybe only do this if we're the primary, or have a field that needs it?
-        addTablePerClassJoinsAndClassTag(query, meta, alias, join === "primary");
+        addTablePerClassJoinsAndClassTag(query, meta, alias, 
+        // Use opts.topLevelCondition to tell we're in a `addLateralJoin` and don't want the `CASE ... END as __class`
+        // select clause, which won't work because it's not an aggregate
+        join === "primary" && !opts.topLevelCondition);
         if (needsStiDiscriminator(meta)) {
             addStiSubtypeFilter(cb, meta, alias);
         }
-        maybeAddNotSoftDeleted(meta, alias);
-        // The user's locally declared aliases, i.e. `const [a, b] = aliases(Author, Book)`,
-        // aren't guaranteed to line up with the aliases we've assigned internally, like `a`
-        // might actually be `a1` if there are two `authors` tables in the query, so push the
-        // canonical alias value for the current clause into the Alias.
-        if (filter && typeof filter === "object" && "as" in filter && (0, Aliases_1.isAlias)(filter.as)) {
-            filter.as[Aliases_1.aliasMgmt].setAlias(meta, alias);
-        }
-        else if ((0, Aliases_1.isAlias)(filter)) {
-            filter[Aliases_1.aliasMgmt].setAlias(meta, alias);
+        maybeAddNotSoftDeleted(cb, softDeletes, meta, alias);
+        bindAlias(filter, meta, alias);
+        // If we're inside a lateral join, look for top-level conditions that need to be rewritten as `BOOL_OR(...)`
+        // I.e. we might be a regular m2o join, but we just came from a lateral join, so any complex conditions
+        // like `ourTable.column.eq(...)` need to be:
+        // a) injected as a `BOOL_OR(ourTable.column.eq(...)) as _b_column_0` select to surface outside the lateral join, and
+        // b) rewritten in the top-level query to be just `_b_column_0`
+        if (opts.topLevelCondition) {
+            const topLevelAlias = opts.outerLateralJoins?.[opts.outerLateralJoins?.length - 1]?.alias;
+            const complexConditions = opts.topLevelCondition.findAndRewrite(topLevelAlias ?? alias, alias);
+            for (const cc of complexConditions) {
+                if (cc.cond.kind === "column" && cc.cond.column === "$count") {
+                    selects.push(buildCountStar(cc));
+                }
+                else {
+                    const [sql, bindings] = (0, buildUtils_1.buildCondition)(cc.cond);
+                    selects.push({ sql: `BOOL_OR(${sql}) as ${cc.as}`, aliases: [cc.cond.alias], bindings });
+                }
+                // Expose the `_b_column_0` through `SELECT`s all the up the tree
+                // (...until the top-level query, which doesn't need to SELECT it, only WHERE against it)
+                opts.outerLateralJoins?.forEach(({ alias, select }, i) => {
+                    const isTopLevel = i === opts.outerLateralJoins.length - 1;
+                    if (!isTopLevel) {
+                        select.push({ sql: `BOOL_OR(${alias}.${cc.as}) as ${cc.as}`, bindings: [], aliases: [alias] });
+                    }
+                });
+            }
+            // prune needs to see the immediate, not necessarily the whole conditions...
+            // only rewriting needs to see the whole thing
         }
+        // See if the clause says we must do a join into the relation
         if (ef && ef.kind === "join") {
             // subFilter really means we're matching against the entity columns/further joins
             Object.keys(ef.subFilter).forEach((key) => {
                 // Skip the `{ as: ... }` alias binding
-                if (key === "as")
+                if (key === "as" || key === "$count")
                     return;
                 const field = meta.allFields[key] ??
                     meta.polyComponentFields?.[key] ??
@@ -209,55 +347,22 @@ function parseFindQuery(meta, filter, opts = {}) {
                             (0, utils_1.fail)(`No poly component found for ${otherField.fieldName}`);
                         otherColumn = otherComponent.columnName;
                     }
-                    addTable(field.otherMetadata(), a, "outer", (0, keywords_1.kqDot)(alias, "id"), (0, keywords_1.kqDot)(a, otherColumn), ef.subFilter[key]);
+                    const condition = `${(0, keywords_1.kqDot)(alias, "id")} = ${(0, keywords_1.kqDot)(a + otherField.aliasSuffix, otherColumn)}`;
+                    addLateralJoin(field.otherMetadata(), alias, a, ef.subFilter[key], { kind: "raw", aliases: [a, alias], condition, pruneable: true, bindings: [] }, undefined);
                 }
                 else if (field.kind === "m2m") {
                     // Always join into the m2m table
                     const ja = getAlias(field.joinTableName);
-                    tables.push({
+                    const jt = {
                         alias: ja,
-                        join: "outer",
+                        join: "inner",
                         table: field.joinTableName,
                         col1: (0, keywords_1.kqDot)(alias, "id"),
                         col2: (0, keywords_1.kqDot)(ja, field.columnNames[0]),
-                    });
-                    // But conditionally join into the alias table
-                    const sub = ef.subFilter[key];
-                    if ((0, Aliases_1.isAlias)(sub)) {
-                        const a = getAlias(field.otherMetadata().tableName);
-                        addTable(field.otherMetadata(), a, "outer", (0, keywords_1.kqDot)(ja, field.columnNames[1]), (0, keywords_1.kqDot)(a, "id"), sub);
-                    }
-                    const f = parseEntityFilter(field.otherMetadata(), sub);
-                    // Probe the filter and see if it's just an id, if so we can avoid the join
-                    if (!f) {
-                        // skip
-                    }
-                    else if (f.kind === "join" || filterSoftDeletes(field.otherMetadata(), softDeletes)) {
-                        const a = getAlias(field.otherMetadata().tableName);
-                        addTable(field.otherMetadata(), a, "outer", (0, keywords_1.kqDot)(ja, field.columnNames[1]), (0, keywords_1.kqDot)(a, "id"), ef.subFilter[key]);
-                    }
-                    else {
-                        const meta = field.otherMetadata();
-                        // We normally don't have `columns` for m2m fields, b/c they don't go through normal serde
-                        // codepaths, so make one up to leverage the existing `mapToDb` function.
-                        const column = {
-                            columnName: field.columnNames[1],
-                            dbType: meta.idDbType,
-                            mapToDb(value) {
-                                // Check for `typeof value === number` in case this is a new entity, and we've been given the nilIdValue
-                                return value === null || isNilIdValue(value)
-                                    ? value
-                                    : (0, index_1.keyToNumber)(meta, (0, index_1.maybeResolveReferenceToId)(value));
-                            },
-                        };
-                        cb.addSimpleCondition({
-                            kind: "column",
-                            alias: ja,
-                            column: field.columnNames[1],
-                            dbType: meta.idDbType,
-                            cond: mapToDb(column, f),
-                        });
-                    }
+                    };
+                    const a = getAlias(field.otherMetadata().tableName);
+                    const condition = `${(0, keywords_1.kqDot)(ja, field.columnNames[1])} = ${(0, keywords_1.kqDot)(a, "id")}`;
+                    addLateralJoin(field.otherMetadata(), alias, a, ef.subFilter[key], { kind: "raw", aliases: [ja, a], condition, bindings: [], pruneable: true }, jt);
                 }
                 else {
                     throw new Error(`Unsupported field ${key}`);
@@ -269,8 +374,10 @@ function parseFindQuery(meta, filter, opts = {}) {
             cb.addValueFilter(alias, column, ef);
         }
     }
-    function addOrderBy(meta, alias, orderBy) {
+    function addOrderBy(meta, alias, orderBy, lateralJoins) {
         const entries = Object.entries(orderBy);
+        // If we're recursing for lateral joins, look in the local query's tables,
+        const tables = (lateralJoins[lateralJoins.length - 1]?.query ?? query).tables;
         if (entries.length === 0)
             return;
         for (const [key, value] of entries) {
@@ -279,33 +386,73 @@ function parseFindQuery(meta, filter, opts = {}) {
             const field = meta.allFields[key] ?? (0, utils_1.fail)(`${key} not found on ${meta.tableName}`);
             if (field.kind === "primitive" || field.kind === "primaryKey" || field.kind === "enum") {
                 const column = field.serde.columns[0];
-                orderBys.push({
-                    alias: `${alias}${field.aliasSuffix ?? ""}`,
-                    column: column.columnName,
-                    order: value,
-                });
+                if (lateralJoins.length === 0) {
+                    // We can add the orderBy directly against the column
+                    orderBys.push({
+                        alias: `${alias}${field.aliasSuffix}`,
+                        column: column.columnName,
+                        order: value,
+                    });
+                }
+                else {
+                    // We need to orderBy the summed column
+                    const [topJoin, ...rest] = lateralJoins;
+                    const lastJoin = rest[rest.length - 1] ?? topJoin;
+                    const as = `_${alias}_${column.columnName}_sum`;
+                    lastJoin.query.selects.push({
+                        sql: `SUM(${alias}${field.aliasSuffix}.${column.columnName}) AS ${as}`,
+                        aliases: [alias],
+                        bindings: [],
+                    });
+                    for (const join of lateralJoins) {
+                        if (join !== lastJoin) {
+                            join.query.selects.push({
+                                sql: `SUM(${alias}.${as}) AS ${as}`,
+                                aliases: [join.alias],
+                                bindings: [],
+                            });
+                        }
+                    }
+                    orderBys.push({ alias: `${topJoin.alias}`, column: as, order: value });
+                }
             }
             else if (field.kind === "m2o") {
                 // Do we already this table joined in?
                 let table = tables.find((t) => t.table === field.otherMetadata().tableName);
-                if (table) {
-                    addOrderBy(field.otherMetadata(), table.alias, value);
-                }
-                else {
-                    const table = field.otherMetadata().tableName;
-                    const a = getAlias(table);
+                if (!table) {
+                    const { tableName } = field.otherMetadata();
+                    const a = getAlias(tableName);
                     const column = field.serde.columns[0].columnName;
-                    // If we don't have a join, don't force this to be an inner join
-                    tables.push({
+                    table = {
                         alias: a,
-                        table,
-                        join: "outer",
+                        table: tableName,
+                        // If we don't have a join, don't force this to be an inner join
+                        join: "outer", // don't drop the entity just b/c of a missing order by
                         col1: (0, keywords_1.kqDot)(alias, column),
                         col2: (0, keywords_1.kqDot)(a, "id"),
-                        distinct: false,
-                    });
-                    addOrderBy(field.otherMetadata(), a, value);
+                    };
+                    tables.push(table);
+                }
+                addOrderBy(field.otherMetadata(), table.alias, value, lateralJoins);
+            }
+            else if (field.kind === "o2m") {
+                let table = tables.filter((t) => t.join === "lateral").find((t) => t.table === field.otherMetadata().tableName);
+                if (!table) {
+                    // ...big copy/paste from up above...
+                    const a = getAlias(field.otherMetadata().tableName);
+                    const otherField = field.otherMetadata().allFields[field.otherFieldName];
+                    let otherColumn = otherField.serde.columns[0].columnName;
+                    // If the other field is a poly, we need to find the right column
+                    if (otherField.kind === "poly") {
+                        // For a subcomponent that matches field's metadata
+                        const otherComponent = otherField.components.find((c) => c.otherMetadata() === meta) ??
+                            (0, utils_1.fail)(`No poly component found for ${otherField.fieldName}`);
+                        otherColumn = otherComponent.columnName;
+                    }
+                    const condition = `${(0, keywords_1.kqDot)(alias, "id")} = ${(0, keywords_1.kqDot)(a + otherField.aliasSuffix, otherColumn)}`;
+                    table = addLateralJoin(field.otherMetadata(), alias, a, undefined, { kind: "raw", aliases: [a, alias], condition, pruneable: true, bindings: [] }, undefined, tables);
                 }
+                addOrderBy(field.otherMetadata(), table.alias, value, [...lateralJoins, table]);
             }
             else {
                 throw new Error(`Unsupported field ${key}`);
@@ -313,13 +460,14 @@ function parseFindQuery(meta, filter, opts = {}) {
         }
     }
     // always add the main table
-    const alias = getAlias(meta.tableName);
-    selects.push(`${(0, keywords_1.kq)(alias)}.*`);
-    addTable(meta, alias, "primary", "n/a", "n/a", filter);
-    // If they passed extra `conditions: ...`, parse that
-    if (optsExpression) {
-        cb.maybeAddExpression(optsExpression);
+    const alias = opts.alias ?? getAlias(meta.tableName);
+    if (opts.topLevelCondition === undefined) {
+        selects.push(`${(0, keywords_1.kq)(alias)}.*`);
+    }
+    else {
+        selects.push("count(*) as _");
     }
+    addTable(meta, alias, "primary", "n/a", "n/a", filter);
     Object.assign(query, {
         condition: cb.toExpressionFilter(),
     });
@@ -329,10 +477,10 @@ function parseFindQuery(meta, filter, opts = {}) {
     if (orderBy) {
         if (Array.isArray(orderBy)) {
             for (const ob of orderBy)
-                addOrderBy(meta, alias, ob);
+                addOrderBy(meta, alias, ob, []);
         }
         else {
-            addOrderBy(meta, alias, orderBy);
+            addOrderBy(meta, alias, orderBy, []);
         }
     }
     maybeAddOrderBy(query, meta, alias);
@@ -384,48 +532,62 @@ function maybeAddIdNotNulls(query) {
 }
 // Remove any joins that are not used in the select or conditions
 function pruneUnusedJoins(parsed, keepAliases) {
+    const dt = new DependencyTracker();
+    // First setup the alias -> alias dependencies...
+    const todo = [...parsed.tables];
+    while (todo.length > 0) {
+        const t = todo.pop();
+        if (t.join === "lateral") {
+            dt.addAlias(t.alias, [t.fromAlias]);
+            // Recurse into lateral joins...
+            todo.push(...t.query.tables);
+        }
+        else if (t.join === "cross") {
+            // Doesn't have any conditions
+        }
+        else if (t.join !== "primary") {
+            dt.addAlias(t.alias, [parseAlias(t.col1)]);
+        }
+    }
     // Mark all terminal usages
-    const used = new Set();
-    parsed.selects.forEach((s) => used.add(parseAlias(s)));
-    parsed.orderBys.forEach((o) => used.add(o.alias));
-    keepAliases.forEach((a) => used.add(a));
-    deepFindConditions(parsed.condition)
-        .filter((c) => !c.pruneable)
-        .forEach((c) => {
-        switch (c.kind) {
-            case "column":
-                used.add(c.alias);
-                break;
-            case "raw":
-                for (const alias of c.aliases) {
-                    used.add(alias);
-                }
-                break;
-            default:
-                (0, utils_1.assertNever)(c);
+    parsed.selects.forEach((s) => {
+        if (typeof s === "string") {
+            if (!s.includes("count("))
+                dt.markRequired(parseAlias(s));
+        }
+        else {
+            for (const a of s.aliases)
+                dt.markRequired(a);
         }
     });
-    // Mark all usages via joins
-    for (let i = 0; i < parsed.tables.length; i++) {
-        const t = parsed.tables[i];
-        if (t.join !== "primary") {
-            // If alias (col2) is required, ensure the col1 alias is also required
-            const a2 = t.alias;
-            const a1 = parseAlias(t.col1);
-            if (used.has(a2) && !used.has(a1)) {
-                used.add(a1);
-                // Restart at zero to find dependencies before us
-                i = 0;
+    parsed.orderBys.forEach((o) => dt.markRequired(o.alias));
+    keepAliases.forEach((a) => dt.markRequired(a));
+    // Look recursively into lateral join conditions
+    const todo2 = [parsed];
+    while (todo2.length > 0) {
+        const query = todo2.pop();
+        deepFindConditions(query.condition, true).forEach((c) => {
+            if (c.kind === "column") {
+                dt.markRequired(c.alias);
             }
-        }
+            else if (c.kind === "raw") {
+                for (const alias of c.aliases)
+                    dt.markRequired(alias);
+            }
+            else {
+                (0, utils_1.assertNever)(c);
+            }
+        });
+        todo2.push(...query.tables.filter((t) => t.join === "lateral").map((t) => t.query));
     }
     // Now remove any unused joins
-    parsed.tables = parsed.tables.filter((t) => used.has(t.alias));
+    parsed.tables = parsed.tables.filter((t) => dt.required.has(t.alias));
     // And then remove any inline soft-delete conditions we don't need anymore
     if (parsed.condition && parsed.condition.op === "and") {
         parsed.condition.conditions = parsed.condition.conditions.filter((c) => {
             if (c.kind === "column") {
-                const prune = c.pruneable && !parsed.tables.some((t) => t.alias === c.alias);
+                const prune = c.pruneable && !dt.required.has(c.alias);
+                // if (prune) console.log(`DROPPING`, c);
                 return !prune;
             }
             else {
@@ -433,9 +595,13 @@ function pruneUnusedJoins(parsed, keepAliases) {
             }
         });
     }
+    // Remove any `{ and: [...] }`s that are empty; we should probably do this deeply?
+    if (parsed.condition && parsed.condition.conditions.length === 0) {
+        parsed.condition = undefined;
+    }
 }
 /** Pulls out a flat list of all `ColumnCondition`s from a `ParsedExpressionFilter` tree. */
-function deepFindConditions(condition) {
+function deepFindConditions(condition, filterPruneable) {
     const todo = condition ? [condition] : [];
     const result = [];
     while (todo.length !== 0) {
@@ -444,8 +610,12 @@ function deepFindConditions(condition) {
             if (c.kind === "exp") {
                 todo.push(c);
             }
+            else if (c.kind === "column" || c.kind === "raw") {
+                if (!filterPruneable || !c.pruneable)
+                    result.push(c);
+            }
             else {
-                result.push(c);
+                (0, utils_1.assertNever)(c);
             }
         }
     }
@@ -681,6 +851,14 @@ class ConditionBuilder {
     addSimpleCondition(condition) {
         this.conditions.push(condition);
     }
+    /** Adds an already-db-level condition to the simple conditions list. */
+    addRawCondition(condition) {
+        this.conditions.push({
+            kind: "raw",
+            bindings: [],
+            ...condition,
+        });
+    }
     /** Adds an already-db-level expression to the expressions list. */
     addParsedExpression(parsed) {
         this.expressions.push(parsed);
@@ -733,12 +911,83 @@ class ConditionBuilder {
             // If no inline conditions, and just 1 opt expression, just use that
             return expressions[0];
         }
+        else if (expressions.length === 1 && expressions[0].op === "and") {
+            // Merge the 1 `AND` expression with the other simple conditions
+            return { kind: "exp", op: "and", conditions: [...conditions, ...expressions[0].conditions] };
+        }
         else if (conditions.length > 0 || expressions.length > 0) {
             // Combine the conditions within the `em.find` join literal & the `conditions` as ANDs
             return { kind: "exp", op: "and", conditions: [...conditions, ...expressions] };
         }
         return undefined;
     }
+    /**
+     * Finds `child.column.eq(...)` complex conditions that need pushed down into each lateral join.
+     *
+     * Once we find something like `{ column: "first_name", cond: { eq: "a1" } }`, we return it to the
+     * caller (for injection into the lateral join's `SELECT` clause), and replace it with a boolean
+     * expression that is basically "did any of my children match this condition?".
+     *
+     * We also assume that `findAndRewrite` is only called on the top-level/user-facing `ParsedFindQuery`,
+     * and not any intermediate `LateralJoinTable` queries (which are allowed to have their own
+     * `ConditionBuilder`s for building their internal query, but it's not exposed to the user,
+     * so won't have any truly-complex conditions that should need rewritten).
+     *
+     * @param topLevelLateralJoin the outermost lateral join alias, as that will be the only alias
+     *   that is visible to the rewritten condition, i.e. `_alias._whatever_condition_`.
+     * @param alias the alias being "hidden" in a lateral join, and so its columns/data won't be
+     *   available for the top-level condition to directly AND/OR against.
+     */
+    findAndRewrite(topLevelLateralJoin, alias) {
+        let j = 0;
+        const found = [];
+        const todo = [this.conditions];
+        for (const exp of this.expressions)
+            todo.push(exp.conditions);
+        while (todo.length > 0) {
+            const array = todo.pop();
+            array.forEach((cond, i) => {
+                if (cond.kind === "column") {
+                    // Use startsWith to look for `_b0` / `_s0` base/subtype conditions
+                    if (cond.alias === alias || cond.alias.startsWith(`${alias}_`)) {
+                        if (cond.column === "_")
+                            return; // Hack to skip rewriting `alias._ > 0`
+                        const as = `_${alias}_${cond.column}_${j++}`;
+                        array[i] = {
+                            kind: "raw",
+                            aliases: [topLevelLateralJoin],
+                            condition: `${topLevelLateralJoin}.${as}`,
+                            bindings: [],
+                            pruneable: false,
+                            ...{ rewritten: true },
+                        };
+                        found.push({ cond, as });
+                    }
+                }
+                else if (cond.kind === "exp") {
+                    todo.push(cond.conditions);
+                }
+                else if (cond.kind === "raw") {
+                    // what would we do here?
+                    if (cond.aliases.includes(alias)) {
+                        // Look for a hacky hint that this is our own already-rewritten query; this is likely
+                        // because `findAndRewrite` is mutating condition expressions that get passed into
+                        // `parseFindQuery` multiple times, i.e. while batching/dataloading.
+                        //
+                        // ...although in theory parseExpression should already be making a copy of any user-facing
+                        // `em.find` conditions. :thinking:
+                        if ("rewritten" in cond)
+                            return;
+                        throw new Error("Joist doesn't support raw conditions in lateral joins yet");
+                    }
+                }
+                else {
+                    (0, utils_1.assertNever)(cond);
+                }
+            });
+        }
+        return found;
+    }
 }
 exports.ConditionBuilder = ConditionBuilder;
 /** Converts domain-level values like string ids/enums into their db equivalent. */
@@ -835,7 +1084,6 @@ function addTablePerClassJoinsAndClassTag(query, meta, alias, isPrimary) {
             join: "outer",
             col1: (0, keywords_1.kqDot)(alias, "id"),
             col2: `${alias}_b${i}.id`,
-            distinct: false,
         });
     });
     // We always join in the base table in case a query happens to use
@@ -855,7 +1103,6 @@ function addTablePerClassJoinsAndClassTag(query, meta, alias, isPrimary) {
                 join: "outer",
                 col1: (0, keywords_1.kqDot)(alias, "id"),
                 col2: `${alias}_s${i}.id`,
-                distinct: false,
             });
             for (const field of Object.values(st.fields)) {
                 if (field.fieldName !== "id" && field.serde) {
@@ -881,16 +1128,25 @@ function addTablePerClassJoinsAndClassTag(query, meta, alias, isPrimary) {
         }
     }
 }
-function maybeAddNotSoftDeleted(conditions, meta, alias, softDeletes) {
+function maybeAddNotSoftDeleted(
+// Within this file we pass ConditionBuilder, but findByUniqueDataLoader passes ColumnCondition[]
+cb, softDeletes, meta, alias) {
     if (filterSoftDeletes(meta, softDeletes)) {
         const column = meta.allFields[(0, EntityMetadata_1.getBaseMeta)(meta).timestampFields.deletedAt].serde?.columns[0];
-        conditions.push({
+        const condition = {
             kind: "column",
             alias,
             column: column.columnName,
             dbType: column.dbType,
             cond: { kind: "is-null" },
-        });
+            pruneable: true,
+        };
+        if (cb instanceof ConditionBuilder) {
+            cb.addSimpleCondition(condition);
+        }
+        else {
+            cb.push(condition);
+        }
     }
 }
 function filterSoftDeletes(meta, softDeletes) {
@@ -899,12 +1155,15 @@ function filterSoftDeletes(meta, softDeletes) {
         // We don't support CTI subtype soft-delete filtering yet
         (meta.inheritanceType !== "cti" || meta.baseTypes.length === 0));
 }
+/** Parses user-facing `{ and: ... }` or `{ or: ... }` into a `ParsedExpressionFilter`. */
 function parseExpression(expression) {
+    // Look for `{ and: [...] }` or `{ or: [...] }`
     const [op, expressions] = "and" in expression && expression.and
         ? ["and", expression.and]
         : "or" in expression && expression.or
             ? ["or", expression.or]
             : (0, utils_1.fail)(`Invalid expression ${expression}`);
+    // Potentially recurse into nested expressions
     const conditions = expressions.map((exp) => (exp && ("and" in exp || "or" in exp) ? parseExpression(exp) : exp));
     const [skip, valid] = (0, utils_1.partition)(conditions, (cond) => cond === undefined || cond === exports.skipCondition);
     if ((skip.length > 0 && expression.pruneIfUndefined === "any") || valid.length === 0) {
@@ -915,24 +1174,23 @@ function parseExpression(expression) {
 function getTables(query) {
     let primary;
     const joins = [];
+    const laterals = [];
+    const crosses = [];
     for (const table of query.tables) {
         if (table.join === "primary") {
             primary = table;
         }
+        else if (table.join === "lateral") {
+            laterals.push(table);
+        }
+        else if (table.join === "cross") {
+            crosses.push(table);
+        }
         else {
             joins.push(table);
         }
     }
-    return [primary, joins];
-}
-function joinKeywords(join) {
-    return join.join === "inner" ? "JOIN" : "LEFT OUTER JOIN";
-}
-function joinClause(join) {
-    return `${joinKeywords(join)} ${(0, keywords_1.kq)(join.table)} ${(0, keywords_1.kq)(join.alias)} ON ${join.col1} = ${join.col2}`;
-}
-function joinClauses(joins) {
-    return joins.map((t) => (t.join !== "primary" ? joinClause(t) : ""));
+    return [primary, joins, laterals, crosses];
 }
 function needsClassPerTableJoins(meta) {
     return meta.inheritanceType === "cti" && (meta.subTypes.length > 0 || meta.baseTypes.length > 0);
@@ -951,8 +1209,60 @@ function addStiSubtypeFilter(cb, subtypeMeta, alias) {
         cond: { kind: "eq", value: subtypeMeta.stiDiscriminatorValue },
     });
 }
+/**
+ * Given a filter that might be an `alias(Author)` placeholder, or have an `as: author`
+ * binding, tells the `Alias` its canonical meta/alias.
+ *
+ * That way, when we later walk `conditions` and build the `AND/OR` tree, each condition
+ * will know the canonical alias to output into the SQL clause.
+ */
+function bindAlias(filter, meta, alias) {
+    // The user's locally declared aliases, i.e. `const [a, b] = aliases(Author, Book)`,
+    // aren't guaranteed to line up with the aliases we've assigned internally, like `a`
+    // might actually be `a1` if there are two `authors` tables in the query, so push the
+    // canonical alias value for the current clause into the Alias.
+    if (filter && typeof filter === "object" && "as" in filter && (0, Aliases_1.isAlias)(filter.as)) {
+        filter.as[Aliases_1.aliasMgmt].setAlias(meta, alias);
+    }
+    else if ((0, Aliases_1.isAlias)(filter)) {
+        filter[Aliases_1.aliasMgmt].setAlias(meta, alias);
+    }
+}
 /** Converts a search term like `foo bar` into a SQL `like` pattern like `%foo%bar%`. */
 function makeLike(search) {
     return search ? `%${search.replace(/\s+/g, "%")}%` : undefined;
 }
+/** Track join dependencies for `pruneUnusedJoins`. */
+class DependencyTracker {
+    nodes = new Map();
+    required = new Set();
+    addAlias(alias, dependencies = []) {
+        this.nodes.set(alias, dependencies);
+    }
+    markRequired(alias) {
+        const marked = new Set();
+        const todo = [alias];
+        while (todo.length > 0) {
+            const alias = todo.pop();
+            if (!marked.has(alias)) {
+                marked.add(alias);
+                todo.push(...(this.nodes.get(alias) || []));
+            }
+        }
+        this.required = new Set([...this.required, ...marked]);
+    }
+}
+/** Takes a `{ column: "$count", kind: eq/gt/etc }` and turns it into a ParsedSelect. */
+function buildCountStar(cc) {
+    // Reuse buildCondition to get the et/gt/etc --> operator
+    const [op, bindings] = (0, buildUtils_1.buildCondition)(cc.cond);
+    // But swap the dummy column name with `count(*)`
+    const parts = op.split(" ");
+    parts[0] = "count(*)";
+    return {
+        sql: `${parts.join(" ")} as ${cc.as}`,
+        aliases: [cc.cond.alias],
+        bindings,
+    };
+}
 //# sourceMappingURL=QueryParser.js.map