joist-core 2.2.0-next.38 → 2.2.0-next.39

package/build/QueryParser.js

@@ -5,11 +5,13 @@ exports.parseFindQuery = parseFindQuery;
 exports.maybeAddIdNotNulls = maybeAddIdNotNulls;
 exports.parseAlias = parseAlias;
 exports.parseEntityFilter = parseEntityFilter;
+exports.findFilterField = findFilterField;
 exports.parseValueFilter = parseValueFilter;
 exports.mapToDb = mapToDb;
 exports.maybeAddOrderBy = maybeAddOrderBy;
 exports.addTablePerClassJoinsAndClassTag = addTablePerClassJoinsAndClassTag;
 exports.maybeAddNotSoftDeleted = maybeAddNotSoftDeleted;
+exports.filterSoftDeletes = filterSoftDeletes;
 exports.getTables = getTables;
 exports.makeLike = makeLike;
 const joist_utils_1 = require("joist-utils");
@@ -21,6 +23,7 @@ const QueryVisitor_1 = require("./QueryVisitor");
 const configure_1 = require("./configure");
 const index_1 = require("./index");
 const keywords_1 = require("./keywords");
+const scopes_1 = require("./scopes");
 const utils_1 = require("./utils");
 /** A marker condition for alias methods to indicate they should be skipped/pruned. */
 exports.skipCondition = {
@@ -50,10 +53,10 @@ function parseFindQuery(meta, filter, opts = {}) {
         aliases[abbrev] = i + 1;
         return i === 0 ? abbrev : `${abbrev}${i}`;
     }
-    function addSoftDeleteCondition(meta, alias) {
+    function addSoftDeleteCondition(meta, alias, targetCb) {
         if (filterSoftDeletes(meta, softDeletes)) {
             const column = meta.allFields[(0, EntityMetadata_1.getBaseMeta)(meta).timestampFields.deletedAt].serde?.columns[0];
-            cb.addSimpleCondition({
+            targetCb.addSimpleCondition({
                 kind: "column",
                 alias,
                 column: column.columnName,
@@ -63,10 +66,11 @@ function parseFindQuery(meta, filter, opts = {}) {
             });
         }
     }
-    function addTable(meta, alias, join, col1, col2, filter, fieldName) {
+    function addTable(meta, alias, join, col1, col2, filter, fieldName, targetCb = cb) {
         // look at filter, is it `{ book: "b2" }` or `{ book: { ... } }`
-        const ef = parseEntityFilter(meta, filter);
-        if (!ef && join !== "primary" && !(0, Aliases_1.isAlias)(filter)) {
+        const scopeFilter = (0, scopes_1.isScope)(filter);
+        const ef = scopeFilter ? undefined : parseEntityFilter(meta, filter);
+        if (!scopeFilter && !ef && join !== "primary" && !(0, Aliases_1.isAlias)(filter)) {
             return;
         }
         if (join === "primary") {
@@ -106,9 +110,9 @@ function parseFindQuery(meta, filter, opts = {}) {
             addTablePerClassJoinsAndClassTag({ selects, tables, orderBys }, meta, alias, false);
         }
         if (needsStiDiscriminator(meta)) {
-            addStiSubtypeFilter(cb, meta, alias);
+            addStiSubtypeFilter(targetCb, meta, alias);
         }
-        addSoftDeleteCondition(meta, alias);
+        addSoftDeleteCondition(meta, alias, targetCb);
         // 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
@@ -119,200 +123,248 @@ function parseFindQuery(meta, filter, opts = {}) {
         else if ((0, Aliases_1.isAlias)(filter)) {
             (0, Aliases_1.getAliasMgmt)(filter).setAlias(meta, alias);
         }
-        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")
-                    return;
-                const field = findFilterField(meta, key) ?? (0, utils_1.fail)(`Field '${key}' not found on ${meta.tableName}`);
-                const fa = `${alias}${field.aliasSuffix}`;
-                if (field.kind === "primitive" || field.kind === "primaryKey" || field.kind === "enum") {
-                    const column = field.serde.columns[0];
-                    parseValueFilter(ef.subFilter[key]).forEach((filter) => {
-                        cb.addValueFilter(fa, column, filter);
-                    });
+        addFilterAt(meta, alias, filter, targetCb, ef, join);
+    }
+    function addFilterAt(meta, tableAlias, filter, targetCb, parsed = parseEntityFilter(meta, filter), parentJoin = "primary") {
+        if ((0, scopes_1.isScope)(filter)) {
+            addScopeFilterAt(meta, tableAlias, filter, targetCb, parentJoin);
+        }
+        else if (parsed && parsed.kind === "join") {
+            addSubFilter(meta, tableAlias, parsed.subFilter, targetCb, parentJoin);
+        }
+        else if (parsed) {
+            const column = meta.fields["id"].serde.columns[0];
+            targetCb.addValueFilter(tableAlias, column, parsed);
+        }
+    }
+    function addScopeFilterAt(meta, tableAlias, scope, targetCb, parentJoin) {
+        for (const fragment of (0, scopes_1.resolveScope)(scope).fragments) {
+            if (fragment.kind === "filter") {
+                addFilterAt(meta, tableAlias, fragment.filter, targetCb, undefined, parentJoin);
+            }
+            else {
+                const a = (0, Aliases_1.alias)(meta.cstr);
+                const result = fragment.fn(a);
+                (0, Aliases_1.getAliasMgmt)(a).setAlias(meta, tableAlias);
+                if ((0, scopes_1.isScopeJoinFilter)(result)) {
+                    // Parse the join tree first so its `as:` bindings re-root the aliases that
+                    // `conditions` reference, then add the conditions against the now-bound aliases.
+                    addFilterAt(meta, tableAlias, result.where, targetCb, undefined, parentJoin);
+                    targetCb.maybeAddExpression(result.conditions);
                 }
-                else if (field.kind === "m2o") {
-                    const column = field.serde.columns[0];
-                    const sub = ef.subFilter[key];
-                    const joinKind = field.required && join !== "outer" ? "inner" : "outer";
-                    if ((0, Aliases_1.isAlias)(sub)) {
-                        const a = getAlias(field.otherMetadata().tableName);
-                        addTable(field.otherMetadata(), a, joinKind, (0, keywords_1.kqDot)(fa, column.columnName), (0, keywords_1.kqDot)(a, "id"), sub);
-                    }
-                    const f = parseEntityFilter(field.otherMetadata(), sub);
-                    // Probe the filter and see if it's just an id (...and not soft deleted), 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, joinKind, (0, keywords_1.kqDot)(fa, column.columnName), (0, keywords_1.kqDot)(a, "id"), sub);
-                    }
-                    else {
-                        cb.addValueFilter(fa, column, f);
-                    }
+                else {
+                    const conditions = Array.isArray(result) ? result : [result];
+                    if (conditions.length > 0)
+                        targetCb.maybeAddExpression({ and: conditions });
                 }
-                else if (field.kind === "poly") {
-                    const f = parseEntityFilter(meta, ef.subFilter[key]);
-                    if (!f) {
-                        // skip
-                    }
-                    else if (f.kind === "join") {
-                        throw new Error("Joins through polys are not supported");
+            }
+        }
+    }
+    function addSubFilter(meta, tableAlias, subFilter, targetCb, parentJoin) {
+        // subFilter really means we're matching against the entity columns/further joins
+        Object.keys(subFilter).forEach((key) => {
+            // Skip the `{ as: ... }` alias binding
+            if (key === "as")
+                return;
+            if (key === "and" || key === "or") {
+                addLogicalFilter(meta, tableAlias, key, subFilter[key], targetCb, parentJoin);
+                return;
+            }
+            const field = findFilterField(meta, key) ?? (0, utils_1.fail)(`Field '${key}' not found on ${meta.tableName}`);
+            const fa = `${tableAlias}${field.aliasSuffix}`;
+            if (field.kind === "primitive" || field.kind === "primaryKey" || field.kind === "enum") {
+                const column = field.serde.columns[0];
+                parseValueFilter(subFilter[key]).forEach((filter) => {
+                    targetCb.addValueFilter(fa, column, filter);
+                });
+            }
+            else if (field.kind === "m2o") {
+                const column = field.serde.columns[0];
+                const sub = subFilter[key];
+                const joinKind = field.required && parentJoin !== "outer" ? "inner" : "outer";
+                if ((0, Aliases_1.isAlias)(sub)) {
+                    const a = getAlias(field.otherMetadata().tableName);
+                    addTable(field.otherMetadata(), a, joinKind, (0, keywords_1.kqDot)(fa, column.columnName), (0, keywords_1.kqDot)(a, "id"), sub, undefined, targetCb);
+                }
+                const f = parseEntityFilter(field.otherMetadata(), sub);
+                // Probe the filter and see if it's just an id (...and not soft deleted), 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, joinKind, (0, keywords_1.kqDot)(fa, column.columnName), (0, keywords_1.kqDot)(a, "id"), sub, undefined, targetCb);
+                }
+                else {
+                    targetCb.addValueFilter(fa, column, f);
+                }
+            }
+            else if (field.kind === "poly") {
+                const f = parseEntityFilter(meta, subFilter[key]);
+                if (!f) {
+                    // skip
+                }
+                else if (f.kind === "join") {
+                    throw new Error("Joins through polys are not supported");
+                }
+                else {
+                    // We're left with basically a ValueFilter against the ids
+                    // For now only support eq/ne/in/is-null
+                    if (f.kind === "eq" || f.kind === "ne") {
+                        if (isNilIdValue(f.value))
+                            return;
+                        const comp = field.components.find((p) => {
+                            const otherMeta = p.otherMetadata();
+                            const cstr = (0, index_1.getConstructorFromTaggedId)(f.value);
+                            // tagged ids from subclasses always map to the base class, so we should compare to the base class if we don't directly match
+                            return otherMeta.cstr === cstr || otherMeta.baseType === cstr.name;
+                        });
+                        if (!comp)
+                            (0, utils_1.fail)(`Invalid tagged id passed to ${meta.type}.${key}: ${f.value}`);
+                        const column = field.serde.columns.find((c) => c.columnName === comp.columnName);
+                        targetCb.addValueFilter(fa, column, f);
                     }
-                    else {
-                        // We're left with basically a ValueFilter against the ids
-                        // For now only support eq/ne/in/is-null
-                        if (f.kind === "eq" || f.kind === "ne") {
-                            if (isNilIdValue(f.value))
-                                return;
-                            const comp = field.components.find((p) => {
-                                const otherMeta = p.otherMetadata();
-                                const cstr = (0, index_1.getConstructorFromTaggedId)(f.value);
-                                // tagged ids from subclasses always map to the base class, so we should compare to the base class if we don't directly match
-                                return otherMeta.cstr === cstr || otherMeta.baseType === cstr.name;
-                            });
-                            if (!comp)
-                                (0, utils_1.fail)(`Invalid tagged id passed to ${meta.type}.${key}: ${f.value}`);
+                    else if (f.kind === "is-null") {
+                        // Add a condition for every component--these can be AND-d with the rest of the simple/inline conditions
+                        field.components.forEach((comp) => {
                             const column = field.serde.columns.find((c) => c.columnName === comp.columnName);
-                            cb.addValueFilter(fa, column, f);
-                        }
-                        else if (f.kind === "is-null") {
-                            // Add a condition for every component--these can be AND-d with the rest of the simple/inline conditions
-                            field.components.forEach((comp) => {
-                                const column = field.serde.columns.find((c) => c.columnName === comp.columnName);
-                                cb.addSimpleCondition({
-                                    kind: "column",
-                                    alias: fa,
-                                    column: comp.columnName,
-                                    dbType: column.dbType,
-                                    cond: f,
-                                });
-                            });
-                        }
-                        else if (f.kind === "not-null") {
-                            const conditions = field.components.map((comp) => {
-                                const column = field.serde.columns.find((c) => c.columnName === comp.columnName);
-                                return {
-                                    kind: "column",
-                                    alias: fa,
-                                    column: comp.columnName,
-                                    dbType: column.dbType,
-                                    cond: { kind: "not-null" },
-                                };
-                            });
-                            cb.addParsedExpression({ kind: "exp", op: "or", conditions });
-                        }
-                        else if (f.kind === "in") {
-                            // Split up the ids by constructor
-                            const idsByConstructor = (0, joist_utils_1.groupBy)(f.value, (id) => (0, index_1.getConstructorFromTaggedId)(id).name);
-                            // Or together `parent_book_id in (1,2,3) OR parent_author_id IN (4,5,6)`
-                            // ...if there is a `parent IN [b:1, b:2, a:1, null]` we'd need to pull the `null` out and do an `OR (all columns are null)`...
-                            const conditions = Object.entries(idsByConstructor).map(([cstrName, ids]) => {
-                                const column = field.serde.columns.find(
-                                // tagged ids from subclasses always map to the base class, so we should compare to the base class if we don't directly match
-                                (c) => c.otherMetadata().cstr.name === cstrName || c.otherMetadata().baseType === cstrName) ?? (0, utils_1.fail)(`Invalid tagged ids passed to ${meta.type}.${key}: ${ids}`);
-                                return {
-                                    kind: "column",
-                                    alias: fa,
-                                    column: column.columnName,
-                                    dbType: column.dbType,
-                                    cond: mapToDb(column, { kind: "in", value: ids }),
-                                };
+                            targetCb.addSimpleCondition({
+                                kind: "column",
+                                alias: fa,
+                                column: comp.columnName,
+                                dbType: column.dbType,
+                                cond: f,
                             });
-                            if (conditions.length > 0) {
-                                cb.addParsedExpression({ kind: "exp", op: "or", conditions });
-                            }
-                        }
-                        else {
-                            throw new Error(`Filters on polys for ${f.kind} are not supported`);
+                        });
+                    }
+                    else if (f.kind === "not-null") {
+                        const conditions = field.components.map((comp) => {
+                            const column = field.serde.columns.find((c) => c.columnName === comp.columnName);
+                            return {
+                                kind: "column",
+                                alias: fa,
+                                column: comp.columnName,
+                                dbType: column.dbType,
+                                cond: { kind: "not-null" },
+                            };
+                        });
+                        targetCb.addParsedExpression({ kind: "exp", op: "or", conditions });
+                    }
+                    else if (f.kind === "in") {
+                        // Split up the ids by constructor
+                        const idsByConstructor = (0, joist_utils_1.groupBy)(f.value, (id) => (0, index_1.getConstructorFromTaggedId)(id).name);
+                        // Or together `parent_book_id in (1,2,3) OR parent_author_id IN (4,5,6)`
+                        // ...if there is a `parent IN [b:1, b:2, a:1, null]` we'd need to pull the `null` out and do an `OR (all columns are null)`...
+                        const conditions = Object.entries(idsByConstructor).map(([cstrName, ids]) => {
+                            const column = field.serde.columns.find(
+                            // tagged ids from subclasses always map to the base class, so we should compare to the base class if we don't directly match
+                            (c) => c.otherMetadata().cstr.name === cstrName || c.otherMetadata().baseType === cstrName) ?? (0, utils_1.fail)(`Invalid tagged ids passed to ${meta.type}.${key}: ${ids}`);
+                            return {
+                                kind: "column",
+                                alias: fa,
+                                column: column.columnName,
+                                dbType: column.dbType,
+                                cond: mapToDb(column, { kind: "in", value: ids }),
+                            };
+                        });
+                        if (conditions.length > 0) {
+                            targetCb.addParsedExpression({ kind: "exp", op: "or", conditions });
                         }
                     }
+                    else {
+                        throw new Error(`Filters on polys for ${f.kind} are not supported`);
+                    }
                 }
-                else if (field.kind === "o2o") {
-                    // We have to always join into o2os, i.e. we can't probe the filter like we do for m2os
-                    const otherMeta = field.otherMetadata();
-                    const a = getAlias(otherMeta.tableName);
-                    const otherField = otherMeta.allFields[field.otherFieldName];
-                    const otherColumn = 
-                    // if our other is a poly, we need to find a matching column rather than just picking the first
-                    otherField.kind === "poly"
-                        ? otherField.components.find((c) => c.otherMetadata() === meta || c.otherMetadata() === (0, EntityMetadata_1.getBaseMeta)(meta)).columnName
-                        : otherField.serde.columns[0].columnName;
-                    addTable(field.otherMetadata(), a, "outer", (0, keywords_1.kqDot)(alias, "id"), (0, keywords_1.kqDot)(a, otherColumn), ef.subFilter[key], field.otherFieldName);
+            }
+            else if (field.kind === "o2o") {
+                // We have to always join into o2os, i.e. we can't probe the filter like we do for m2os
+                const otherMeta = field.otherMetadata();
+                const a = getAlias(otherMeta.tableName);
+                const otherField = otherMeta.allFields[field.otherFieldName];
+                const otherColumn = 
+                // if our other is a poly, we need to find a matching column rather than just picking the first
+                otherField.kind === "poly"
+                    ? otherField.components.find((c) => c.otherMetadata() === meta || c.otherMetadata() === (0, EntityMetadata_1.getBaseMeta)(meta))
+                        .columnName
+                    : otherField.serde.columns[0].columnName;
+                addTable(field.otherMetadata(), a, "outer", (0, keywords_1.kqDot)(tableAlias, "id"), (0, keywords_1.kqDot)(a, otherColumn), subFilter[key], field.otherFieldName, targetCb);
+            }
+            else if (field.kind === "o2m") {
+                const otherMeta = field.otherMetadata();
+                const otherField = otherMeta.allFields[field.otherFieldName];
+                let otherColumn = otherField.serde.columns[0].columnName;
+                if (otherField.kind === "poly") {
+                    const otherComponent = otherField.components.find((c) => c.otherMetadata() === meta) ??
+                        (0, utils_1.fail)(`No poly component found for ${otherField.fieldName}`);
+                    otherColumn = otherComponent.columnName;
                 }
-                else if (field.kind === "o2m") {
-                    const otherMeta = field.otherMetadata();
-                    const otherField = otherMeta.allFields[field.otherFieldName];
-                    let otherColumn = otherField.serde.columns[0].columnName;
-                    if (otherField.kind === "poly") {
-                        const otherComponent = otherField.components.find((c) => c.otherMetadata() === meta) ??
-                            (0, utils_1.fail)(`No poly component found for ${otherField.fieldName}`);
-                        otherColumn = otherComponent.columnName;
+                const isCtiBaseFk = otherMeta.inheritanceType === "cti" && field.otherFieldName && !(field.otherFieldName in otherMeta.fields);
+                const a = getAlias(otherMeta.tableName);
+                addTable(otherMeta, a, "outer", (0, keywords_1.kqDot)(tableAlias, "id"), (0, keywords_1.kqDot)(a, otherColumn), subFilter[key], field.otherFieldName, targetCb);
+                if (!isCtiBaseFk) {
+                    const table = tables.find((t) => t.alias === a);
+                    if (table && (table.join === "inner" || table.join === "outer")) {
+                        table.collection = { parentAlias: tableAlias, rootAlias: a, kind: "o2m" };
                     }
-                    const isCtiBaseFk = otherMeta.inheritanceType === "cti" && field.otherFieldName && !(field.otherFieldName in otherMeta.fields);
-                    const a = getAlias(otherMeta.tableName);
-                    addTable(otherMeta, a, "outer", (0, keywords_1.kqDot)(alias, "id"), (0, keywords_1.kqDot)(a, otherColumn), ef.subFilter[key], field.otherFieldName);
-                    if (!isCtiBaseFk) {
-                        const table = tables.find((t) => t.alias === a);
-                        if (table && (table.join === "inner" || table.join === "outer")) {
-                            table.collection = { parentAlias: alias, rootAlias: a, kind: "o2m" };
-                        }
+                }
+            }
+            else if (field.kind === "m2m") {
+                const sub = subFilter[key];
+                const f = parseEntityFilter(field.otherMetadata(), sub);
+                if (!f && !(0, Aliases_1.isAlias)(sub))
+                    return;
+                const ja = getAlias(field.joinTableName);
+                tables.push({
+                    join: "outer",
+                    alias: ja,
+                    table: field.joinTableName,
+                    col1: (0, keywords_1.kqDot)(tableAlias, "id"),
+                    col2: (0, keywords_1.kqDot)(ja, field.columnNames[0]),
+                    collection: { parentAlias: tableAlias, rootAlias: ja, kind: "m2m" },
+                });
+                if ((0, Aliases_1.isAlias)(sub) || 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"), sub, undefined, targetCb);
+                    const table = tables.find((t) => t.alias === a);
+                    if (table && (table.join === "inner" || table.join === "outer")) {
+                        table.collection = { parentAlias: ja, rootAlias: ja, kind: "m2m" };
                     }
                 }
-                else if (field.kind === "m2m") {
-                    const sub = ef.subFilter[key];
-                    const f = parseEntityFilter(field.otherMetadata(), sub);
-                    if (!f && !(0, Aliases_1.isAlias)(sub))
-                        return;
-                    const ja = getAlias(field.joinTableName);
-                    tables.push({
-                        join: "outer",
+                else if (f) {
+                    const otherMeta = field.otherMetadata();
+                    const column = {
+                        columnName: field.columnNames[1],
+                        dbType: otherMeta.idDbType,
+                        mapToDb(value) {
+                            return value === null || isNilIdValue(value)
+                                ? value
+                                : (0, index_1.keyToNumber)(otherMeta, (0, index_1.maybeResolveReferenceToId)(value));
+                        },
+                    };
+                    targetCb.addSimpleCondition({
+                        kind: "column",
                         alias: ja,
-                        table: field.joinTableName,
-                        col1: (0, keywords_1.kqDot)(alias, "id"),
-                        col2: (0, keywords_1.kqDot)(ja, field.columnNames[0]),
-                        collection: { parentAlias: alias, rootAlias: ja, kind: "m2m" },
+                        column: field.columnNames[1],
+                        dbType: otherMeta.idDbType,
+                        cond: mapToDb(column, f),
                     });
-                    if ((0, Aliases_1.isAlias)(sub) || 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"), sub);
-                        const table = tables.find((t) => t.alias === a);
-                        if (table && (table.join === "inner" || table.join === "outer")) {
-                            table.collection = { parentAlias: ja, rootAlias: ja, kind: "m2m" };
-                        }
-                    }
-                    else if (f) {
-                        const otherMeta = field.otherMetadata();
-                        const column = {
-                            columnName: field.columnNames[1],
-                            dbType: otherMeta.idDbType,
-                            mapToDb(value) {
-                                return value === null || isNilIdValue(value)
-                                    ? value
-                                    : (0, index_1.keyToNumber)(otherMeta, (0, index_1.maybeResolveReferenceToId)(value));
-                            },
-                        };
-                        cb.addSimpleCondition({
-                            kind: "column",
-                            alias: ja,
-                            column: field.columnNames[1],
-                            dbType: otherMeta.idDbType,
-                            cond: mapToDb(column, f),
-                        });
-                    }
                 }
-                else {
-                    throw new Error(`Unsupported field ${key}`);
-                }
-            });
-        }
-        else if (ef) {
-            const column = meta.fields["id"].serde.columns[0];
-            cb.addValueFilter(alias, column, ef);
-        }
+            }
+            else {
+                throw new Error(`Unsupported field ${key}`);
+            }
+        });
+    }
+    function addLogicalFilter(meta, tableAlias, op, value, targetCb, parentJoin) {
+        const filters = Array.isArray(value) ? value : [value];
+        const conditions = filters.flatMap((filter) => {
+            const branchCb = new index_1.ConditionBuilder();
+            addFilterAt(meta, tableAlias, filter, branchCb, undefined, parentJoin);
+            const condition = branchCb.toExpressionFilter();
+            return condition ? [condition] : [];
+        });
+        if (conditions.length > 0)
+            targetCb.addParsedExpression({ kind: "exp", op, conditions });
     }
     function addOrderBy(meta, alias, orderBy) {
         const entries = Object.entries(orderBy);
@@ -444,6 +496,15 @@ function parseEntityFilter(meta, filter) {
         // We're just binding an alias to this position in the join tree
         return undefined;
     }
+    else if ((0, scopes_1.isScope)(filter)) {
+        // A scope on a relation (e.g. `{ author: Author.adult }`) always implies conditions on the
+        // related entity, so signal "needs a join" via the existing `join` discriminant rather than
+        // adding a dedicated `kind: "scope"` that every relation branch would have to learn. The empty
+        // `subFilter` is intentionally never read: the m2o/m2m branches only check `kind === "join"` to
+        // decide whether to join, then re-dispatch the original scope value back through `addTable`,
+        // where `isScope(...)` routes it to `addScopeFilterAt` to apply the scope's actual fragments.
+        return { kind: "join", subFilter: {} };
+    }
     else if (filter === null) {
         return { kind: "is-null" };
     }