joist-core 2.3.0 → 2.4.0-next.2

package/build/QueryParser.js

@@ -1,965 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.skipCondition = void 0;
-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");
-const Aliases_1 = require("./Aliases");
-const Entity_1 = require("./Entity");
-const EntityMetadata_1 = require("./EntityMetadata");
-const QueryParser_pruning_1 = require("./QueryParser.pruning");
-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 = {
-    kind: "column",
-    alias: "skip",
-    column: "skip",
-    dbType: "skip",
-    cond: undefined,
-};
-/**
- * Parses an `em.find` filter into a logical `ParsedFindQuery` AST, leaving optimization/pruning to callers.
- *
- * The main execution flow is:
- * parseFindQuery -> beforeFind plugins -> optimizeCollectionJoins -> pruneUnusedJoins -> execute SQL.
- */
-function parseFindQuery(meta, filter, opts = {}) {
-    const selects = [];
-    const tables = [];
-    const orderBys = [];
-    const query = { selects, tables, orderBys };
-    const { orderBy = undefined, conditions: optsExpression = undefined, softDeletes = "exclude", pruneJoins = false, keepAliases = [], } = opts;
-    const cb = new index_1.ConditionBuilder();
-    const aliases = {};
-    function getAlias(tableName) {
-        const abbrev = (0, utils_1.abbreviation)(tableName);
-        const i = aliases[abbrev] || 0;
-        aliases[abbrev] = i + 1;
-        return i === 0 ? abbrev : `${abbrev}${i}`;
-    }
-    function addSoftDeleteCondition(meta, alias, targetCb) {
-        if (filterSoftDeletes(meta, softDeletes)) {
-            const column = meta.allFields[(0, EntityMetadata_1.getBaseMeta)(meta).timestampFields.deletedAt].serde?.columns[0];
-            targetCb.addSimpleCondition({
-                kind: "column",
-                alias,
-                column: column.columnName,
-                dbType: column.dbType,
-                cond: { kind: "is-null" },
-                pruneable: true,
-            });
-        }
-    }
-    function addTable(meta, alias, join, col1, col2, filter, fieldName, targetCb = cb) {
-        // look at filter, is it `{ book: "b2" }` or `{ book: { ... } }`
-        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") {
-            tables.push({ alias, table: meta.tableName, join });
-            addTablePerClassJoinsAndClassTag({ selects, tables, orderBys }, meta, alias, true);
-        }
-        else if (meta.inheritanceType === "cti" && fieldName && !(fieldName in meta.fields)) {
-            // For cti, our meta might be a subtype while the FK is actually on the base table.  This should only be the case
-            // when the fk is on another table (e.g. o2o/o2m).  In these cases, we'll be passed a field name and can verify if
-            // its directly in our meta, if not we should assume it's in the base type and join that in first.
-            meta.baseTypes.forEach((bt, i) => {
-                tables.push({
-                    alias: `${alias}_b${i}`,
-                    table: bt.tableName,
-                    join: "outer",
-                    col1,
-                    col2: `${(0, keywords_1.kq)(`${alias}_b${i}`)}.${col2.split(".")[1]}`,
-                    distinct: false,
-                });
-                // and we still need to join in our subtype as well in case its own fields are queried against
-                tables.push({
-                    alias: `${alias}`,
-                    table: meta.tableName,
-                    join: "outer",
-                    col1: (0, keywords_1.kqDot)(alias, "id"),
-                    col2: (0, keywords_1.kqDot)(`${alias}_b${i}`, "id"),
-                    distinct: false,
-                });
-            });
-        }
-        else if (join === "lateral" || join === "cross") {
-            (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({ selects, tables, orderBys }, meta, alias, false);
-        }
-        if (needsStiDiscriminator(meta)) {
-            addStiSubtypeFilter(targetCb, 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
-        // canonical alias value for the current clause into the Alias.
-        if (filter && typeof filter === "object" && "as" in filter && (0, Aliases_1.isAlias)(filter.as)) {
-            (0, Aliases_1.getAliasMgmt)(filter.as).setAlias(meta, alias);
-        }
-        else if ((0, Aliases_1.isAlias)(filter)) {
-            (0, Aliases_1.getAliasMgmt)(filter).setAlias(meta, alias);
-        }
-        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 {
-                    const conditions = Array.isArray(result) ? result : [result];
-                    if (conditions.length > 0)
-                        targetCb.maybeAddExpression({ and: conditions });
-                }
-            }
-        }
-    }
-    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 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);
-                            targetCb.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" },
-                            };
-                        });
-                        targetCb.addParsedExpression({ kind: "exp", op: "or", conditions });
-                    }
-                    else if (f.kind === "in") {
-                        // An empty `in` matches nothing, so emit a single always-false condition (consistent
-                        // with a non-poly m2o `{ relation: [] }`); otherwise grouping by constructor would yield
-                        // zero conditions and prune the filter entirely, incorrectly matching every row.
-                        if (f.value.length === 0) {
-                            targetCb.addValueFilter(fa, field.serde.columns[0], { kind: "in", value: [] });
-                            return;
-                        }
-                        // 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.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)(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;
-                }
-                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" };
-                    }
-                }
-            }
-            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 (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,
-                        column: field.columnNames[1],
-                        dbType: otherMeta.idDbType,
-                        cond: mapToDb(column, f),
-                    });
-                }
-            }
-            else if (field.kind === "m2mEnum") {
-                // Membership filter, e.g. `{ logoColors: Color.Red }` / `{ logoColors: [Red, Green] }`: join the
-                // join table and filter its enum-id column, mapping enum codes -> their numeric ids.
-                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" },
-                });
-                const column = {
-                    columnName: field.columnNames[1],
-                    dbType: "int",
-                    mapToDb(value) {
-                        return value === null || value === undefined ? value : field.enumDetailType.getByCode(value).id;
-                    },
-                };
-                parseValueFilter(subFilter[key]).forEach((filter) => {
-                    targetCb.addValueFilter(ja, column, filter);
-                });
-            }
-            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);
-        if (entries.length === 0)
-            return;
-        for (const [key, value] of entries) {
-            if (!value)
-                continue; // prune undefined
-            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,
-                });
-            }
-            else if (field.kind === "m2o") {
-                // Do we already this table joined in?
-                let table = tables.find((t) => t.table === field.otherMetadata().tableName);
-                if (table) {
-                    addTablePerClassJoinsAndClassTag(query, field.otherMetadata(), table.alias, false);
-                    addOrderBy(field.otherMetadata(), table.alias, value);
-                }
-                else {
-                    const table = field.otherMetadata().tableName;
-                    const a = getAlias(table);
-                    const column = field.serde.columns[0].columnName;
-                    const fa = (0, Aliases_1.getMaybeCtiAlias)(meta, field, meta, alias);
-                    // If we don't have a join, don't force this to be an inner join
-                    tables.push({
-                        alias: a,
-                        table,
-                        join: "outer",
-                        col1: (0, keywords_1.kqDot)(fa, column),
-                        col2: (0, keywords_1.kqDot)(a, "id"),
-                        distinct: false,
-                    });
-                    addTablePerClassJoinsAndClassTag(query, field.otherMetadata(), a, false);
-                    addOrderBy(field.otherMetadata(), a, value);
-                }
-            }
-            else {
-                throw new Error(`Unsupported field ${key}`);
-            }
-        }
-    }
-    // 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);
-    }
-    Object.assign(query, {
-        condition: cb.toExpressionFilter(),
-    });
-    if (query.tables.some((t) => t.join === "outer")) {
-        maybeAddIdNotNulls(query);
-    }
-    if (orderBy) {
-        if (Array.isArray(orderBy)) {
-            for (const ob of orderBy)
-                addOrderBy(meta, alias, ob);
-        }
-        else {
-            addOrderBy(meta, alias, orderBy);
-        }
-    }
-    maybeAddOrderBy(query, meta, alias);
-    if (pruneJoins) {
-        (0, QueryParser_pruning_1.pruneUnusedJoins)(query, keepAliases);
-    }
-    return query;
-}
-/**
- * Look for conditions doing `some_column IS NULL` in an outer join that
- * need an `id IS NOT NULL` to make sure they don't match inadvertently on
- * the child row simply not existing.
- *
- * Note: Instead of injecting an extra `id IS NOT NULL` condition, I had tried
- * using all INNER JOINs and flipping joins to OUTER only if the user explicit
- * had `id IS NULL` in their filter, but that didn't work for queries that wanted
- * to do an `OR` across two different children (which queries both children being
- * OUTER JOINs, and detecting that case seemed complicated).
- */
-function maybeAddIdNotNulls(query) {
-    (0, QueryVisitor_1.visitConditions)(query, {
-        visitCond(c) {
-            // Check `c.prunable` to make sure we don't catch our injected `deleted_at is null` conditions
-            if (c.cond.kind !== "is-null" || c.column === "id" || c.pruneable) {
-                return c;
-            }
-            // This is an `some_column IS NULL`, is it in an outer join?
-            const table = query.tables.find((t) => t.alias === c.alias);
-            if (table && table.join === "outer") {
-                const meta = (0, configure_1.getMetadataForTable)(table.table);
-                return {
-                    kind: "exp",
-                    op: "and",
-                    conditions: [
-                        c,
-                        {
-                            kind: "column",
-                            alias: c.alias,
-                            column: "id",
-                            dbType: meta.idDbType,
-                            cond: { kind: "not-null" },
-                        },
-                    ],
-                };
-            }
-            return c;
-        },
-    });
-}
-/** Returns the `a` from `"a".*`. */
-function parseAlias(alias) {
-    return alias.split(".")[0].replaceAll(`"`, "");
-}
-/** Parses an entity filter, which could be "just an id", an array of ids, or a nested filter. */
-function parseEntityFilter(meta, filter) {
-    if (filter === undefined) {
-        // This matches legacy `em.find(Book, { author: undefined })` behavior
-        return undefined;
-    }
-    else if ((0, Aliases_1.isAlias)(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" };
-    }
-    else if (typeof filter === "string" || typeof filter === "number") {
-        return { kind: "eq", value: filter };
-    }
-    else if (typeof filter === "boolean") {
-        return filter ? { kind: "not-null" } : { kind: "is-null" };
-    }
-    else if (Array.isArray(filter)) {
-        return {
-            kind: "in",
-            value: filter.map((v) => {
-                return (0, Entity_1.isEntity)(v) ? (v.idTaggedMaybe ?? nilIdValue(meta)) : v;
-            }),
-        };
-    }
-    else if ((0, Entity_1.isEntity)(filter)) {
-        return { kind: "eq", value: filter.idTaggedMaybe || nilIdValue(meta) };
-    }
-    else if (typeof filter === "object") {
-        // Looking for `{ firstName: "f1" }` or `{ ne: "f1" }`
-        const keys = Object.keys(filter);
-        // Special case only looking at `ne`
-        if (keys.length === 1 && keys[0] === "ne") {
-            const value = filter["ne"];
-            if (value === undefined) {
-                return undefined;
-            }
-            else if (value === null) {
-                return { kind: "not-null" };
-            }
-            else if (typeof value === "string" || typeof value === "number") {
-                return { kind: "ne", value };
-            }
-            else if ((0, Entity_1.isEntity)(value)) {
-                return { kind: "ne", value: value.idTaggedMaybe || nilIdValue(meta) };
-            }
-            else {
-                throw new Error(`Unsupported "ne" value ${value}`);
-            }
-        }
-        // Special case only looking at `id`
-        if (keys.length === 1 && keys[0] === "id") {
-            const value = filter["id"];
-            if (value === undefined) {
-                return undefined;
-            }
-            else if (value === null) {
-                return { kind: "is-null" };
-            }
-            else if (typeof value === "string" || typeof value === "number") {
-                return { kind: "eq", value };
-            }
-            else if ((0, Entity_1.isEntity)(value)) {
-                return { kind: "eq", value: value.idTaggedMaybe || nilIdValue(meta) };
-            }
-            else {
-                return parseValueFilter(value)[0];
-            }
-        }
-        // Look for subFilter values being EntityFilter-ish instances like ManyToOneReference
-        // that have an id, and so structurally match the entity filter without really being filters,
-        // and convert them over here before getting into parseValueFilter.
-        const subFilter = {};
-        for (const [key, value] of Object.entries(filter)) {
-            if (value && typeof value === "object" && !(0, joist_utils_1.isPlainObject)(value) && "idTaggedMaybe" in value) {
-                subFilter[key] = value.idTaggedMaybe || nilIdValue(meta);
-            }
-            else {
-                subFilter[key] = value;
-            }
-        }
-        return { kind: "join", subFilter };
-    }
-    else {
-        throw new Error(`Unrecognized filter ${filter}`);
-    }
-}
-/**
- * We use this value if users include new (id-less) entities as em.find conditions.
- *
- * The idea is that this condition would never be met, but we still want to do the em.find
- * query in case it's in an `OR` clause that would match false, but some other part of the
- * clause would match. I.e. instead of just skipping the DB query all together, which is
- * also something we could consider doing.
- *
- * For int IDs we use -1, and for uuid IDs, we use the nil UUID value:
- *
- * https://en.wikipedia.org/wiki/Universally_unique_identifier#Nil_UUID
- */
-function nilIdValue(meta) {
-    switch (meta.idDbType) {
-        case "int":
-        case "bigint":
-            return -1;
-        case "uuid":
-            return "00000000-0000-0000-0000-000000000000";
-        case "text":
-            return "0";
-        default:
-            return (0, utils_1.assertNever)(meta.idDbType);
-    }
-}
-function isNilIdValue(value) {
-    return value === -1 || value === "00000000-0000-0000-0000-000000000000";
-}
-/** Finds a filter field by fieldName or generated fieldIdName. */
-function findFilterField(meta, key) {
-    return (meta.allFields[key] ??
-        meta.polyComponentFields?.[key] ??
-        Object.values(meta.allFields).find((field) => field.fieldIdName === key) ??
-        Object.values(meta.polyComponentFields ?? {}).find((field) => field.fieldIdName === key));
-}
-/**
- * Parses the many/hodgepodge (ergonomic!) patterns of value filters into a `ParsedValueFilter[]`.
- *
- * Note we return an array because filter might be a `ValueGraphQLFilter` that is allowed to have
- * multiple conditions, i.e. `{ lt: 10, gt: 5 }`.
- */
-function parseValueFilter(filter) {
-    if (filter === null) {
-        return [{ kind: "is-null" }];
-    }
-    else if (filter === undefined) {
-        // This is legacy behavior where `em.find(Book, { author: undefined })` would match all books
-        return [];
-    }
-    else if (Array.isArray(filter)) {
-        return [{ kind: "in", value: filter }];
-    }
-    else if ((0, joist_utils_1.isPlainObject)(filter)) {
-        const keys = Object.keys(filter);
-        if (keys.length === 0) {
-            // Should this be an error?
-            return [];
-        }
-        else if (keys.length === 2 && "op" in filter && "value" in filter) {
-            // Probe for `findGql` op & value
-            const { op, value } = filter;
-            if (shouldPruneValueFilter(op, value)) {
-                return [];
-            }
-            else if (value === null) {
-                return [{ kind: "is-null" }];
-            }
-            else {
-                return [{ kind: op, value: value ?? null }];
-            }
-        }
-        else if (keys.length === 2 && "gte" in filter && "lte" in filter) {
-            const { gte, lte } = filter;
-            return [{ kind: "between", value: [gte, lte] }];
-        }
-        else {
-            return Object.entries(filter)
-                .map(([key, value]) => {
-                // Always do condition pruning on the value
-                if (shouldPruneValueFilter(key, value)) {
-                    return undefined;
-                }
-                switch (key) {
-                    case "eq":
-                        if (value === null) {
-                            return { kind: "is-null" };
-                        }
-                        else {
-                            return { kind: "eq", value: filter[key] };
-                        }
-                    case "ne":
-                        if (value === null) {
-                            return { kind: "not-null" };
-                        }
-                        else {
-                            return { kind: "ne", value: filter[key] ?? null };
-                        }
-                    case "in":
-                    case "nin":
-                    case "gt":
-                    case "gte":
-                    case "lt":
-                    case "lte":
-                    case "like":
-                    case "nlike":
-                    case "ilike":
-                    case "nilike":
-                    case "regex":
-                    case "nregex":
-                    case "iregex":
-                    case "niregex":
-                    case "contains":
-                    case "overlaps":
-                    case "containedBy":
-                        return { kind: key, value: filter[key] };
-                    case "pathExists":
-                        return { kind: "jsonPathExists", value: filter[key] };
-                    case "pathIsTrue":
-                        return { kind: "jsonPathPredicate", value: filter[key] };
-                    case "search":
-                        return { kind: "ilike", value: makeLike(filter[key]) };
-                    case "between":
-                        return { kind: key, value: filter[key] };
-                    default:
-                        throw new Error(`Unsupported value filter key ${key}`);
-                }
-            })
-                .filter(index_1.isDefined);
-        }
-    }
-    else {
-        // This is a primitive like a string, number
-        return [{ kind: "eq", value: filter }];
-    }
-}
-/** Converts domain-level values like string ids/enums into their db equivalent. */
-function mapToDb(column, filter) {
-    // ...to teach this `mapToDb` function to handle/rewrite `in: [1, null]` handling, we'd need to:
-    // 1. return a maybe-simple/maybe-nested condition, so basically a `ParsedExpressionCondition`, because
-    // this would let `in` return an `{ or: ... }` to all the callers.
-    // 2. also return `{ parsed: ParsedExpressionCondition, simples: SimpleCondition[] }` tuple, for the
-    // alias `addCondition` processing to track the `simples` and rewrite their alias when later bound.
-    switch (filter.kind) {
-        case "eq":
-        case "gt":
-        case "gte":
-        case "ne":
-        case "lt":
-        case "lte":
-        case "like":
-        case "nlike":
-        case "ilike":
-        case "nilike":
-        case "regex":
-        case "nregex":
-        case "iregex":
-        case "niregex":
-            filter.value = column.mapToDb(filter.value);
-            return filter;
-        case "in":
-            if (column.isArray) {
-                // Arrays need a special operator
-                return { kind: "contains", value: column.mapToDb(filter.value) };
-            }
-            else {
-                filter.value = filter.value.map((v) => column.mapToDb(v));
-            }
-            return filter;
-        case "nin":
-            if (column.isArray) {
-                // Arrays need a special operator
-                throw new Error("The nin operator is not supported on array columns yet");
-            }
-            else {
-                filter.value = filter.value.map((v) => column.mapToDb(v));
-            }
-            return filter;
-        case "contains":
-        case "ncontains":
-        case "overlaps":
-        case "noverlaps":
-        case "containedBy":
-            const supportsContains = column.isArray || column.dbType === "jsonb";
-            if (!supportsContains) {
-                throw new Error(`${filter.kind} is only unsupported on array or jsonb columns`);
-            }
-            if (column.isArray) {
-                filter.value = column.mapToDb(filter.value);
-            }
-            else {
-                // leave jsonb values alone
-            }
-            return filter;
-        case "between":
-            filter.value = [column.mapToDb(filter.value[0]), column.mapToDb(filter.value[1])];
-            return filter;
-        case "is-null":
-        case "not-null":
-        case "jsonPathExists":
-        case "jsonPathPredicate":
-            return filter;
-        default:
-            throw (0, utils_1.assertNever)(filter);
-    }
-}
-/** Adds any user-configured default order, plus an "always order by id" for determinism. */
-function maybeAddOrderBy(query, meta, alias) {
-    const { orderBys } = query;
-    if (meta.orderBy) {
-        const field = meta.allFields[meta.orderBy] ?? (0, utils_1.fail)(`${meta.orderBy} not found on ${meta.tableName}`);
-        const column = field.serde.columns[0].columnName;
-        const hasAlready = orderBys.find((o) => o.alias === alias && o.column === column);
-        if (!hasAlready) {
-            orderBys.push({ alias, column, order: "ASC" });
-        }
-    }
-    // Even if they already added orders, add id as the last one to get deterministic output
-    const hasIdOrder = orderBys.find((o) => o.alias === alias && o.column === "id");
-    if (!hasIdOrder) {
-        orderBys.push({ alias, column: "id", order: "ASC" });
-    }
-}
-function addTablePerClassJoinsAndClassTag(query, meta, alias, isPrimary) {
-    if (!needsClassPerTableJoins(meta))
-        return;
-    const { selects, tables } = query;
-    // When `.load(SmallPublisher)` is called, join in base tables like `Publisher`
-    meta.baseTypes.forEach((bt, i) => {
-        if (isPrimary) {
-            selects.push(`${alias}_b${i}.*`);
-        }
-        tables.push({
-            alias: `${alias}_b${i}`,
-            table: bt.tableName,
-            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
-    // it as a filter, but we only need to do the subtype joins + selects
-    // if this is the primary table
-    if (isPrimary) {
-        // Watch for subTypes that share column names. It'd be great to do
-        // this statically at codegen time, like a meta.sharedSubtypeColumns.
-        const stColumns = [];
-        // When `.load(Publisher)` is called, join in sub tables like `SmallPublisher` and `LargePublisher`
-        meta.subTypes.forEach((st, i) => {
-            const stAlias = `${alias}_s${i}`;
-            selects.push(`${stAlias}.*`);
-            tables.push({
-                alias: stAlias,
-                table: st.tableName,
-                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) {
-                    for (const c of field.serde?.columns) {
-                        stColumns.push({ stAlias, columnName: c.columnName });
-                    }
-                }
-            }
-        });
-        // Nominate a specific `id` column to avoid ambiguity
-        selects.push(`${(0, keywords_1.kq)(alias)}.id as id`);
-        // Add an explicit coalesce for shared columns
-        Object.values((0, joist_utils_1.groupBy)(stColumns, (c) => c.columnName))
-            .filter((columns) => columns.length > 1)
-            .forEach((columns) => {
-            const { columnName } = columns[0];
-            selects.push(`COALESCE(${columns.map((c) => `${c.stAlias}.${columnName}`).join(", ")}) as ${columnName}`);
-        });
-        // If our meta has no subtypes, we're a left type and don't need a __class
-        const cases = meta.subTypes.map((st, i) => `WHEN ${alias}_s${i}.id IS NOT NULL THEN '${st.type}'`);
-        if (cases.length > 0) {
-            selects.push(`CASE ${cases.join(" ")} ELSE '_' END as __class`);
-        }
-    }
-}
-function maybeAddNotSoftDeleted(conditions, meta, alias, softDeletes) {
-    if (filterSoftDeletes(meta, softDeletes)) {
-        const column = meta.allFields[(0, EntityMetadata_1.getBaseMeta)(meta).timestampFields.deletedAt].serde?.columns[0];
-        conditions.push({
-            kind: "column",
-            alias,
-            column: column.columnName,
-            dbType: column.dbType,
-            cond: { kind: "is-null" },
-        });
-    }
-}
-function filterSoftDeletes(meta, softDeletes) {
-    return (softDeletes === "exclude" &&
-        !!(0, EntityMetadata_1.getBaseMeta)(meta).timestampFields?.deletedAt &&
-        // We don't support CTI subtype soft-delete filtering yet
-        (meta.inheritanceType !== "cti" || meta.baseTypes.length === 0));
-}
-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, laterals, crosses];
-}
-function needsClassPerTableJoins(meta) {
-    return meta.inheritanceType === "cti" && (meta.subTypes.length > 0 || meta.baseTypes.length > 0);
-}
-function needsStiDiscriminator(meta) {
-    return meta.inheritanceType === "sti" && !meta.stiDiscriminatorField;
-}
-function addStiSubtypeFilter(cb, subtypeMeta, alias) {
-    const baseMeta = (0, EntityMetadata_1.getBaseMeta)(subtypeMeta);
-    const column = baseMeta.fields[baseMeta.stiDiscriminatorField].serde?.columns[0];
-    cb.addSimpleCondition({
-        kind: "column",
-        alias,
-        column: column.columnName,
-        dbType: column.dbType,
-        cond: { kind: "eq", value: subtypeMeta.stiDiscriminatorValue },
-        pruneable: true,
-    });
-}
-/** 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;
-}
-/** Returns true for values that should be treated like an omitted filter. */
-function shouldPruneValueFilter(key, value) {
-    if (value === undefined)
-        return true;
-    return value === false && key !== "eq" && key !== "ne";
-}
-//# sourceMappingURL=QueryParser.js.map