joist-core 2.3.0-next.96 → 2.3.0-next.97

package/build/EntityFilter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"EntityFilter.js","names":[],"sources":["../src/EntityFilter.ts"],"sourcesContent":["import { type Alias } from \"./Aliases.ts\";\nimport { type AndCondition, type DomainPredicate, type OrCondition, type UnbrandedPredicate } from \"./conditions.ts\";\nimport { type Entity } from \"./Entity.ts\";\nimport { type FindFilterOptions, type IdOf } from \"./EntityManager.ts\";\nimport { type Scope, isScope, resolveScope } from \"./scopes.ts\";\nimport { type FieldsOf, type FilterOf, type OrderOf } from \"./typeMap.ts\";\n\n/** Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings. */\nexport type FilterAndSettings<T extends Entity> = {\n  // Either a `{ ... }` EntityFilter or a Scope like `Adult.parent`\n  where: FindFilter<T>;\n  conditions?: ExpressionFilter;\n  orderBy?: OrderOf<T> | OrderOf<T>[];\n  limit?: number | undefined;\n  offset?: number | undefined;\n  softDeletes?: \"exclude\" | \"include\";\n  allowMultipleLeftJoins?: boolean;\n  optimizeJoinsToExists?: boolean;\n};\n\nexport type OrderBy = \"ASC\" | \"DESC\";\n\n/**\n * A filter for an entity of type `T` for `em.find` inline conditions.\n *\n * An entity filter can either filter by \"an exact entity\" (i.e. the book with id 2)\n * or its own set of filters (i.e. all books with a title that starts with \"The\").\n *\n * @typeparam T The entity type, i.e. `Author`\n * @typeparam I The ID type of the entity, i.e. `AuthorId`\n * @typeparam F The filter type for the entity, i.e. `AuthorFilter`\n * @typeparam N Either `null | undefined` if the entity can be null, or `never` if it cannot.\n */\nexport type EntityFilter<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> =\n  | T\n  | readonly T[]\n  | I\n  | readonly I[]\n  | Scope<T>\n  // Note that this is a weak type (all optional keys) but TS still enforces at least one overlap\n  | EntityFilterObject<T, I, F, N>\n  // Always allow `undefined` for condition pruning\n  | undefined\n  // But only allow `null` for `nullable` relations\n  | N\n  | { ne: T | I | N | undefined }\n  // Allow setting `true` for `is not null` or `false` for `is null`\n  | boolean\n  | Alias<T>;\n\n/** A nested object filter, including logical composition at the current entity alias. */\nexport type EntityFilterObject<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> = {\n  as?: Alias<T>;\n  and?: EntityFilter<T, I, F, N> | readonly EntityFilter<T, I, F, N>[];\n  or?: EntityFilter<T, I, F, N> | readonly EntityFilter<T, I, F, N>[];\n} & F;\n\nexport type BooleanFilter<N> = true | false | N;\n\n/**\n * The root `em.find` `where` shape: an `EntityFilterObject` with `I`/`F`/`N` defaulted.\n *\n * Intentionally a thin alias rather than the source of truth: `as`/`and`/`or` are defined once on\n * `EntityFilterObject<T, I, F, N>` so the parameterized nested-relation arm of `EntityFilter` and this\n * root can't drift. That arm needs the `F`/`N` params — GraphQL filter shapes (`F`) and relation\n * nullability (`N`) flow through `and`/`or` recursion — which a `FilterOf<T>`-hardcoded root can't\n * supply, so the shape lives on `EntityFilterObject` and this just specializes it.\n */\nexport type FilterWithAlias<T extends Entity> = EntityFilterObject<T>;\n\n/** Allows `em.find` to accept either a `{ ... }` EntityFilter or a Scope like `Adult.parent` */\nexport type FindFilter<T extends Entity> = FilterWithAlias<T> | Scope<T>;\n\nexport type UniqueFilter<T extends Entity> = {\n  [K in keyof FieldsOf<T> & keyof FilterOf<T> as FieldsOf<T>[K] extends { unique: true } ? K : never]?: FilterOf<T>[K];\n};\n\n/**\n * Filters against a specific field's values within `em.find` inline conditions.\n *\n * We always allow `undefined` to support condition pruning, but only conditionally\n * allow `null` if the column is actually nullable.\n */\nexport type ValueFilter<V, N> =\n  | V\n  | readonly V[]\n  | N\n  | undefined\n  // Both eq and in are redundant with `V` and `V[]` above but are convenient for matching GQL filter APIs\n  | { eq: V | N | undefined }\n  | { ne: V | N | undefined }\n  | { in: readonly (V | N | null)[] | undefined }\n  | { nin: readonly (V | N)[] | undefined }\n  | { gt: V | undefined }\n  | { gte: V | undefined }\n  | { lt: V | undefined }\n  | { lte: V | undefined }\n  | { like: V | undefined }\n  | { nlike: V | undefined }\n  | { ilike: V | undefined }\n  | { nilike: V | undefined }\n  | { regex?: V | undefined }\n  | { iregex?: V | undefined }\n  | { nregex?: V | undefined }\n  | { niregex?: V | undefined }\n  | { search: V | undefined }\n  // should put these in a dedicated ArrayFilter\n  | { contains: V | undefined }\n  | { overlaps: V | undefined }\n  | { containedBy: V | undefined }\n  // should put these in a dedicated JsonbFilter\n  | { pathExists: string | undefined }\n  | { pathIsTrue: string | undefined }\n  // this is between\n  | { gte: V | undefined; lte: V | undefined }\n  | { between: [V, V] | undefined };\n\n/**\n * Filters against complex expressions of filters.\n *\n * This is the user-facing DSL that internally will be converted to `ParsedExpressionFilter.\n */\nexport type ExpressionFilter = AndCondition<ExpressionCondition> | OrCondition<ExpressionCondition>;\n\n/** A domain-alias predicate or nested group for em.find and scopes, not SQL table expressions. */\nexport type ExpressionCondition = ExpressionFilter | DomainPredicate | UnbrandedPredicate;\n\n/** Merges root-scope find settings with caller options, letting caller options win. */\nexport function mergeFindOptions<T extends Entity>(\n  where: FindFilter<T>,\n  options: FindFilterOptions<T>,\n): { where: FindFilter<T>; options: FindFilterOptions<T> } {\n  if (!isScope<T>(where)) return { where, options };\n\n  const resolved = resolveScope(where);\n  const scopeOptions: FindFilterOptions<T> = {};\n  if (resolved.orderBys.length > 0) scopeOptions.orderBy = resolved.orderBys;\n  if (resolved.limit !== undefined) scopeOptions.limit = resolved.limit;\n  if (resolved.offset !== undefined) scopeOptions.offset = resolved.offset;\n  if (resolved.softDeletes !== undefined) scopeOptions.softDeletes = resolved.softDeletes;\n  return { where, options: { ...scopeOptions, ...options } };\n}\n"],"mappings":";;;;;;;;AAgIA,SAAgB,iBACd,OACA,SACyD;CACzD,IAAI,CAAC,QAAW,KAAK,GAAG,OAAO;EAAE;EAAO;CAAQ;CAEhD,MAAM,WAAW,aAAa,KAAK;CACnC,MAAM,eAAqC,CAAC;CAC5C,IAAI,SAAS,SAAS,SAAS,GAAG,aAAa,UAAU,SAAS;CAClE,IAAI,SAAS,UAAU,KAAA,GAAW,aAAa,QAAQ,SAAS;CAChE,IAAI,SAAS,WAAW,KAAA,GAAW,aAAa,SAAS,SAAS;CAClE,IAAI,SAAS,gBAAgB,KAAA,GAAW,aAAa,cAAc,SAAS;CAC5E,OAAO;EAAE;EAAO,SAAS;GAAE,GAAG;GAAc,GAAG;EAAQ;CAAE;AAC3D"}

package/build/EntityGraphQLFilter.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"EntityGraphQLFilter.cjs","names":[],"sources":["../src/EntityGraphQLFilter.ts"],"sourcesContent":["import { type Alias } from \"./Aliases.ts\";\nimport { type Entity } from \"./Entity.ts\";\nimport { type EntityFilter, type ExpressionFilter } from \"./EntityFilter.ts\";\nimport { type GraphQLFilterOf, type OrderOf } from \"./typeMap.ts\";\n\nexport type GraphQLFilterWithAlias<T extends Entity> = { as?: Alias<T> } & GraphQLFilterOf<T>;\n\n/** Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings. */\nexport type GraphQLFilterAndSettings<T extends Entity> = {\n  where: GraphQLFilterWithAlias<T>;\n  conditions?: ExpressionFilter;\n  orderBy?: OrderOf<T>;\n  limit?: number | null;\n  offset?: number | null;\n  softDeletes?: \"exclude\" | \"include\";\n  allowMultipleLeftJoins?: boolean;\n  optimizeJoinsToExists?: boolean;\n};\n\n/**\n * This essentially matches the ValueFilter but with looser types to placate GraphQL.\n */\nexport type ValueGraphQLFilter<V> =\n  | {\n      eq?: V | null;\n      in?: readonly V[] | null;\n      nin?: readonly V[] | null;\n      gt?: V | null;\n      gte?: V | null;\n      ne?: V | null;\n      lt?: V | null;\n      lte?: V | null;\n      like?: V | null;\n      nlike?: V | null;\n      ilike?: V | null;\n      nilike?: V | null;\n      regex?: V | null;\n      iregex?: V | null;\n      nregex?: V | null;\n      niregex?: V | null;\n      search?: V | null;\n      between?: readonly V[] | null;\n      contains?: V | null;\n      overlaps?: V | null;\n      containedBy?: V | null;\n      pathExists?: string | null;\n      pathIsTrue?: string | null;\n    }\n  | { op: Operator; value: V | readonly V[] | undefined | null }\n  | V\n  | readonly V[]\n  | null;\n\nexport type BooleanGraphQLFilter = true | false | null;\n\nexport const operators = [\n  \"eq\",\n  \"gt\",\n  \"gte\",\n  \"ne\",\n  \"lt\",\n  \"lte\",\n  \"like\",\n  \"nlike\",\n  \"ilike\",\n  \"nilike\",\n  // Regular expression operators\n  \"regex\",\n  \"iregex\",\n  \"nregex\",\n  \"niregex\",\n  \"in\",\n  \"nin\",\n  \"between\",\n  \"contains\",\n  \"overlaps\",\n  \"containedBy\",\n  \"jsonPathExists\",\n  \"jsonPathPredicate\",\n] as const;\n\nexport type Operator = (typeof operators)[number];\n\nexport const opToFn: Record<Exclude<Operator, \"in\" | \"nin\" | \"between\">, string> = {\n  eq: \"=\",\n  gt: \">\",\n  gte: \">=\",\n  ne: \"!=\",\n  lt: \"<\",\n  lte: \"<=\",\n  like: \"LIKE\",\n  nlike: \"NOT LIKE\",\n  ilike: \"ILIKE\",\n  nilike: \"NOT ILIKE\",\n  // Regular expression operators\n  regex: \"~\",\n  iregex: \"~*\",\n  nregex: \"!~\",\n  niregex: \"!~*\",\n  // containsAll / hasAll\n  contains: \"@>\",\n  containedBy: \"<@\",\n  // containsSome / hasSome\n  overlaps: \"&&\",\n  jsonPathExists: \"@?\",\n  jsonPathPredicate: \"@@\",\n};\n\n/** A GraphQL version of EntityFilter. */\nexport type EntityGraphQLFilter<T extends Entity, I, F, N> = EntityFilter<T, I, F, N> | null;\n"],"mappings":";;;;;;AAuDA,MAAa,YAAY;CACvB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAIA,MAAa,SAAsE;CACjF,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,MAAM;CACN,OAAO;CACP,OAAO;CACP,QAAQ;CAER,OAAO;CACP,QAAQ;CACR,QAAQ;CACR,SAAS;CAET,UAAU;CACV,aAAa;CAEb,UAAU;CACV,gBAAgB;CAChB,mBAAmB;AACrB"}

package/build/EntityGraphQLFilter.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"EntityGraphQLFilter.d.cts","names":[],"sources":["../src/EntityGraphQLFilter.ts"],"mappings":";;;;;KAKY,uBAAuB,UAAU;EAAY,KAAK,MAAM;IAAO,gBAAgB;;KAG/E,yBAAyB,UAAU;EAC7C,OAAO,uBAAuB;EAC9B,aAAa;EACb,UAAU,QAAQ;EAClB;EACA;EACA;EACA;EACA;;;;;KAMU,mBAAmB;EAEzB,KAAK;EACL,cAAc;EACd,eAAe;EACf,KAAK;EACL,MAAM;EACN,KAAK;EACL,KAAK;EACL,MAAM;EACN,OAAO;EACP,QAAQ;EACR,QAAQ;EACR,SAAS;EACT,QAAQ;EACR,SAAS;EACT,SAAS;EACT,UAAU;EACV,SAAS;EACT,mBAAmB;EACnB,WAAW;EACX,WAAW;EACX,cAAc;EACd;EACA;;EAEA,IAAI;EAAU,OAAO,aAAa;IACpC,aACS;KAGD;cAEC;KA0BD,mBAAmB;cAElB,QAAQ,OAAO,QAAQ;;KA0BxB,oBAAoB,UAAU,QAAQ,GAAG,GAAG,KAAK,aAAa,GAAG,GAAG,GAAG"}

package/build/EntityGraphQLFilter.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"EntityGraphQLFilter.d.mts","names":[],"sources":["../src/EntityGraphQLFilter.ts"],"mappings":";;;;;KAKY,uBAAuB,UAAU;EAAY,KAAK,MAAM;IAAO,gBAAgB;;KAG/E,yBAAyB,UAAU;EAC7C,OAAO,uBAAuB;EAC9B,aAAa;EACb,UAAU,QAAQ;EAClB;EACA;EACA;EACA;EACA;;;;;KAMU,mBAAmB;EAEzB,KAAK;EACL,cAAc;EACd,eAAe;EACf,KAAK;EACL,MAAM;EACN,KAAK;EACL,KAAK;EACL,MAAM;EACN,OAAO;EACP,QAAQ;EACR,QAAQ;EACR,SAAS;EACT,QAAQ;EACR,SAAS;EACT,SAAS;EACT,UAAU;EACV,SAAS;EACT,mBAAmB;EACnB,WAAW;EACX,WAAW;EACX,cAAc;EACd;EACA;;EAEA,IAAI;EAAU,OAAO,aAAa;IACpC,aACS;KAGD;cAEC;KA0BD,mBAAmB;cAElB,QAAQ,OAAO,QAAQ;;KA0BxB,oBAAoB,UAAU,QAAQ,GAAG,GAAG,KAAK,aAAa,GAAG,GAAG,GAAG"}

package/build/EntityGraphQLFilter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"EntityGraphQLFilter.js","names":[],"sources":["../src/EntityGraphQLFilter.ts"],"sourcesContent":["import { type Alias } from \"./Aliases.ts\";\nimport { type Entity } from \"./Entity.ts\";\nimport { type EntityFilter, type ExpressionFilter } from \"./EntityFilter.ts\";\nimport { type GraphQLFilterOf, type OrderOf } from \"./typeMap.ts\";\n\nexport type GraphQLFilterWithAlias<T extends Entity> = { as?: Alias<T> } & GraphQLFilterOf<T>;\n\n/** Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings. */\nexport type GraphQLFilterAndSettings<T extends Entity> = {\n  where: GraphQLFilterWithAlias<T>;\n  conditions?: ExpressionFilter;\n  orderBy?: OrderOf<T>;\n  limit?: number | null;\n  offset?: number | null;\n  softDeletes?: \"exclude\" | \"include\";\n  allowMultipleLeftJoins?: boolean;\n  optimizeJoinsToExists?: boolean;\n};\n\n/**\n * This essentially matches the ValueFilter but with looser types to placate GraphQL.\n */\nexport type ValueGraphQLFilter<V> =\n  | {\n      eq?: V | null;\n      in?: readonly V[] | null;\n      nin?: readonly V[] | null;\n      gt?: V | null;\n      gte?: V | null;\n      ne?: V | null;\n      lt?: V | null;\n      lte?: V | null;\n      like?: V | null;\n      nlike?: V | null;\n      ilike?: V | null;\n      nilike?: V | null;\n      regex?: V | null;\n      iregex?: V | null;\n      nregex?: V | null;\n      niregex?: V | null;\n      search?: V | null;\n      between?: readonly V[] | null;\n      contains?: V | null;\n      overlaps?: V | null;\n      containedBy?: V | null;\n      pathExists?: string | null;\n      pathIsTrue?: string | null;\n    }\n  | { op: Operator; value: V | readonly V[] | undefined | null }\n  | V\n  | readonly V[]\n  | null;\n\nexport type BooleanGraphQLFilter = true | false | null;\n\nexport const operators = [\n  \"eq\",\n  \"gt\",\n  \"gte\",\n  \"ne\",\n  \"lt\",\n  \"lte\",\n  \"like\",\n  \"nlike\",\n  \"ilike\",\n  \"nilike\",\n  // Regular expression operators\n  \"regex\",\n  \"iregex\",\n  \"nregex\",\n  \"niregex\",\n  \"in\",\n  \"nin\",\n  \"between\",\n  \"contains\",\n  \"overlaps\",\n  \"containedBy\",\n  \"jsonPathExists\",\n  \"jsonPathPredicate\",\n] as const;\n\nexport type Operator = (typeof operators)[number];\n\nexport const opToFn: Record<Exclude<Operator, \"in\" | \"nin\" | \"between\">, string> = {\n  eq: \"=\",\n  gt: \">\",\n  gte: \">=\",\n  ne: \"!=\",\n  lt: \"<\",\n  lte: \"<=\",\n  like: \"LIKE\",\n  nlike: \"NOT LIKE\",\n  ilike: \"ILIKE\",\n  nilike: \"NOT ILIKE\",\n  // Regular expression operators\n  regex: \"~\",\n  iregex: \"~*\",\n  nregex: \"!~\",\n  niregex: \"!~*\",\n  // containsAll / hasAll\n  contains: \"@>\",\n  containedBy: \"<@\",\n  // containsSome / hasSome\n  overlaps: \"&&\",\n  jsonPathExists: \"@?\",\n  jsonPathPredicate: \"@@\",\n};\n\n/** A GraphQL version of EntityFilter. */\nexport type EntityGraphQLFilter<T extends Entity, I, F, N> = EntityFilter<T, I, F, N> | null;\n"],"mappings":";;;;;AAuDA,MAAa,YAAY;CACvB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAIA,MAAa,SAAsE;CACjF,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,MAAM;CACN,OAAO;CACP,OAAO;CACP,QAAQ;CAER,OAAO;CACP,QAAQ;CACR,QAAQ;CACR,SAAS;CAET,UAAU;CACV,aAAa;CAEb,UAAU;CACV,gBAAgB;CAChB,mBAAmB;AACrB"}

package/build/Expr.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Expr.cjs","names":["brandPredicate","arrayOutputType","skipCondition","safeKq"],"sources":["../src/Expr.ts"],"sourcesContent":["import { type ConditionInput, type PredicateBrand, type SqlCondition, brandPredicate } from \"./conditions.ts\";\nimport type { EntityMetadata } from \"./EntityMetadata.ts\";\nimport { safeKq } from \"./keywords.ts\";\nimport type { ExpressionOrderBy, QueryCondition } from \"./query.ts\";\nimport type { RawCondition } from \"./QueryParser.ts\";\nimport { skipCondition } from \"./skipCondition.ts\";\nimport { type TypeInfo, arrayOutputType } from \"./TypeInfo.ts\";\n\n/**\n * The shared expression protocol for `em.query`.\n *\n * Table columns (`a.first_name`), aggregates (`b.id.count()`), `sql` templates, subquery columns\n * (`bookStats.bookCount`), and scalar subqueries all implement it, so any of them can appear in\n * `select`, `where`, `groupBy`, `having`, `orderBy`, and inside other expressions.\n *\n * This module is a leaf on purpose: `Tables.ts` extends `BaseExpr` at load time, so nothing here may\n * import (at runtime) a module that leads back to `Tables.ts`. Anything that needs metadata, alias\n * binding, or SQL generation for conditions is reached through the `ExprContext` the query parser passes in.\n */\n\nexport const exprBrand: unique symbol = Symbol(\"joist.expr\");\n\n/**\n * Phantom type information carried by every `Expr`.\n *\n * `R` is the decoded result type.\n *\n * `Src` is the expression's *source key*: the type-level identity of the table it reads from. An entity\n * table's key is its type name (`table(Author)` gives `\"Author\"`) or the explicit name in\n * `table(Author, \"m\")`; a subquery's key is its `as: \"book_stats\"`, or the shared sentinel `\"?\"` when it\n * has no `as`. Exactly two questions are asked of a source key, and nothing else:\n *\n * - `MaybeNull` asks \"is my source key among the LEFT-joined sources in this query's join list?\" If yes,\n *   the value can be `null`.\n * - `CheckScope` asks \"is my source key among `from` + `join` at all?\" If no, the query reads from a\n *   table it never joined.\n *\n * Two special keys opt out of both questions:\n *\n * - `Expr<number, never>` reads from nothing that can be left-joined away, i.e. `b.id.count()`\n * - `Expr<number, string>` (the default) is untracked, i.e. `sql.ref` on an unknown table\n */\nexport interface ExprBrand<R, Src extends string> {\n  readonly __result: R;\n  readonly __source: Src;\n}\n\n/**\n * \"Any expression whose result is `R`\", checked by brand alone.\n *\n * Method parameters use this instead of `Expr<R>` so that `Expr` stays covariant in `R`: checking\n * `Expr<AuthorId>` against `Expr<AuthorId | null>` then only compares the phantom `__result`, not every\n * method's parameter list (which would make `Expr` invariant, and break `select: b.author_id` dispatch and\n * polymorphic joins).\n */\nexport type ExprLike<R> = { readonly [exprBrand]: ExprBrand<R, any> };\n\n/** Controls which values enter an array aggregate and their order within the array. */\nexport interface ArrayAggOptions {\n  distinct?: boolean;\n  /** With DISTINCT, PostgreSQL requires ordering expressions to match the aggregate argument. */\n  orderBy?: readonly (ExpressionOrderBy | undefined)[];\n  /** Undefined conditions are pruned, as in a query's where clause. */\n  filter?: QueryCondition;\n}\n\n/**\n * A typed SQL expression: a table column, an aggregate, a `sql` template, or a scalar subquery.\n *\n * Conditions and SQL functions are methods, so they need no import. Aggregates keep `Src` so scope\n * checking still sees through `bs.x.max()`; `count` is source-less because `count(x)` is 0, not null,\n * when `x`'s table is left-joined away; `coalesce` drops `Src` on purpose, since its whole job is to\n * remove the nullability a left join adds.\n */\nexport interface Expr<R, Src extends string = string> {\n  readonly [exprBrand]: ExprBrand<R, Src>;\n  eq(value: R | ExprLike<R> | undefined): SqlCondition;\n  ne(value: R | ExprLike<R> | undefined): SqlCondition;\n  gt(value: R | ExprLike<R> | undefined): SqlCondition;\n  gte(value: R | ExprLike<R> | undefined): SqlCondition;\n  lt(value: R | ExprLike<R> | undefined): SqlCondition;\n  lte(value: R | ExprLike<R> | undefined): SqlCondition;\n  // A list subquery may select a nullable column; NULLs in the set never match, so that is fine.\n  in(values: readonly R[] | ExprLike<R | null> | undefined): SqlCondition;\n  nin(values: readonly R[] | ExprLike<R | null> | undefined): SqlCondition;\n\n  /** Prefixes this expression and a space to a raw predicate; write .is`IS NULL`, not .is`NULL`. */\n  is(strings: TemplateStringsArray, ...values: unknown[]): SqlCondition;\n\n  /** `count(x)::int`; `count(a.id)` is `count(*)` for the FROM table, and the matched-row count for a left-joined one. */\n  count(): Expr<number, never>;\n  countDistinct(): Expr<number, never>;\n  sum(this: Expr<number | null, Src>): Expr<number | null, Src>;\n  avg(this: Expr<number | null, Src>): Expr<number | null, Src>;\n  min(): Expr<R | null, Src>;\n  max(): Expr<R | null, Src>;\n  /** PG keeps element NULLs (a left-joined empty group aggregates as `[null]`), and zero rows aggregate as NULL. */\n  arrayAgg(options?: ArrayAggOptions): Expr<R[] | null, Src>;\n  stringAgg(this: Expr<string | null, Src>, delimiter: string): Expr<string | null, Src>;\n  coalesce(fallback: NonNullable<R>): Expr<NonNullable<R>, never>;\n}\n\n/**\n * A join entry: the join kind is the key, the joined source is the value, plus `on`. `inner?: never` /\n * `left?: never` keep an entry to one kind (the `SqlCondition` `and`/`or` trick).\n *\n * `on` is required. A join is pruned when nothing references it anymore, not by an `undefined` ON;\n * `keep: true` pins a join that would otherwise prune, i.e. an inner join used as an existence filter,\n * the way em.find's `keepAliases` does. It is a boolean so callers can pass a flag.\n *\n * Declared here (not `query.ts`) so the relation join factories in `Tables.ts` (i.e. `a.books.as(b)`) can\n * return them without importing `query.ts`; `query.ts` re-constrains `A` to its `QuerySource`.\n */\nexport interface InnerJoin<A, C = SqlCondition> {\n  readonly inner: A;\n  readonly left?: never;\n  readonly on: C;\n  readonly keep?: boolean;\n}\n\nexport interface LeftJoin<A, C = SqlCondition> {\n  readonly left: A;\n  readonly inner?: never;\n  readonly on: C;\n  readonly keep?: boolean;\n}\n\n/** SQL plus its `?` bindings plus the SQL aliases it references, i.e. for join pruning. */\nexport interface SqlFragment {\n  sql: string;\n  bindings: any[];\n  refs: string[];\n}\n\n/**\n * What an expression needs from the query it is generating SQL for: the SQL alias assigned to each\n * source, and a way to turn nested conditions into SQL (which needs `ConditionBuilder`, so it lives in `query.ts`).\n */\nexport interface ExprContext {\n  /** Returns the SQL alias for a table's `TableMgmt` or a subquery handle, searching enclosing queries. */\n  aliasFor(handle: object): string;\n  /** Turns a user-facing condition into SQL; `undefined` if it pruned away entirely. */\n  conditionToSql(cond: QueryCondition): SqlFragment | undefined;\n}\n\nexport function isExpr(value: unknown): value is ExprLike<any> {\n  return typeof value === \"object\" && value !== null && exprBrand in value;\n}\n\n/** Every `Expr` is a `BaseExpr` at runtime; this cast keeps `isExpr` a plain type guard so unions narrow. */\nexport function asNode(expr: ExprLike<any>): BaseExpr {\n  return expr as any as BaseExpr;\n}\n\nexport const deferredSym: unique symbol = Symbol(\"joist.deferredCondition\");\n\n/**\n * A condition whose SQL depends on aliases that are only known once the query is parsed, i.e.\n * `bookStats.bookCount.gt(1)` or `bs.authorId.eq(a.id)`.\n *\n * It is shaped like a `RawCondition` with a SQL brand so it can sit in any `SqlCondition`; `resolveDeferredConditions`\n * snapshots `condition`, `bindings`, and `aliases` before the filter is parsed. Domain alias conditions\n * use a separate protocol in the `em.find` parser.\n */\nexport interface DeferredCondition extends RawCondition, PredicateBrand<\"sql\"> {\n  [deferredSym]: (ctx: ExprContext) => RawCondition;\n}\n\nexport function isDeferredCondition(cond: unknown): cond is DeferredCondition {\n  return typeof cond === \"object\" && cond !== null && deferredSym in cond;\n}\n\n/** Creates a `DeferredCondition` that generates its SQL with `fn` once the query's aliases are known. */\nexport function deferredCondition(fn: (ctx: ExprContext) => SqlFragment): DeferredCondition {\n  const cond: DeferredCondition = brandPredicate(\n    {\n      kind: \"raw\",\n      aliases: [],\n      condition: \"<unresolved>\",\n      bindings: [],\n      pruneable: false,\n      [deferredSym]: (ctx: ExprContext): RawCondition => {\n        const { sql, bindings, refs } = fn(ctx);\n        return { ...cond, condition: sql, bindings, aliases: refs };\n      },\n    },\n    \"sql\",\n  );\n  return cond;\n}\n\n/**\n * Resolve each condition occurrence and snapshot it before resolving the next one. A nested subquery\n * may reuse the same condition under another alias; it must not overwrite this occurrence's SQL.\n */\nexport function resolveDeferredConditions(\n  cond: ConditionInput | undefined,\n  ctx: ExprContext,\n): ConditionInput | undefined {\n  if (cond === undefined || cond === null) return cond;\n  if (isDeferredCondition(cond)) {\n    return cond[deferredSym](ctx);\n  } else if (\"and\" in cond && cond.and) {\n    return { ...cond, and: cond.and.map((c) => resolveDeferredConditions(c, ctx)) };\n  } else if (\"or\" in cond && cond.or) {\n    return { ...cond, or: cond.or.map((c) => resolveDeferredConditions(c, ctx)) };\n  }\n  return cond;\n}\n\n/** Concatenates SQL fragments with `sep`, keeping bindings and refs in order. */\nexport function joinFragments(parts: SqlFragment[], sep: string): SqlFragment {\n  return {\n    sql: parts.map((p) => p.sql).join(sep),\n    bindings: parts.flatMap((p) => p.bindings),\n    refs: parts.flatMap((p) => p.refs),\n  };\n}\n\n/**\n * The methods every expression shares. Subclasses provide `toSql`, and usually `decode`/`encode`.\n *\n * Table columns can override comparisons to apply column-specific conversions. Domain aliases do not\n * implement this protocol.\n */\nexport abstract class BaseExpr {\n  readonly [exprBrand]: any = this;\n\n  /** Produces this expression's SQL so it can be embedded in a larger expression, i.e. a subquery gets parens. */\n  abstract toSql(ctx: ExprContext): SqlFragment;\n\n  /** Only an actual scalar/IN subquery exposes its selected expression, not an ordinary ID expression. */\n  get subquerySelect(): BaseExpr | undefined {\n    return undefined;\n  }\n\n  /** Known SQL representation and logical domain; raw SQL and unmodeled refs remain unknown. */\n  get outputType(): TypeInfo | undefined {\n    return undefined;\n  }\n\n  /** Physical SQL nullability; undefined means unknown, not a NOT NULL guarantee. */\n  get sqlNullable(): boolean | undefined {\n    return undefined;\n  }\n\n  /** The source of a direct column reference, whose value becomes NULL under an unmatched LEFT join. */\n  get sqlSource(): object | undefined {\n    return undefined;\n  }\n\n  /** Produces the SQL without the outer parens a subquery normally gets; only differs for subqueries. */\n  toSqlBare(ctx: ExprContext): SqlFragment {\n    return this.toSql(ctx);\n  }\n\n  /** Converts a result-set value into the domain value, i.e. an int into a tagged id. */\n  decode(value: unknown): unknown {\n    return value;\n  }\n\n  /** Converts a domain value into the database value, i.e. a tagged id into an int, for bindings. */\n  encode(value: unknown): unknown {\n    return value;\n  }\n\n  eq(value: unknown): SqlCondition {\n    return this.compare(\"=\", value);\n  }\n\n  ne(value: unknown): SqlCondition {\n    return this.compare(\"!=\", value);\n  }\n\n  gt(value: unknown): SqlCondition {\n    return this.compare(\">\", value);\n  }\n\n  gte(value: unknown): SqlCondition {\n    return this.compare(\">=\", value);\n  }\n\n  lt(value: unknown): SqlCondition {\n    return this.compare(\"<\", value);\n  }\n\n  lte(value: unknown): SqlCondition {\n    return this.compare(\"<=\", value);\n  }\n\n  in(values: unknown): SqlCondition {\n    return this.inList(\"IN\", values);\n  }\n\n  nin(values: unknown): SqlCondition {\n    return this.inList(\"NOT IN\", values);\n  }\n\n  /** Prefixes this expression to a SQL template, retaining bindings and referenced aliases. */\n  is(strings: TemplateStringsArray, ...values: unknown[]): SqlCondition {\n    const suffix = new TemplateExpr(strings, values);\n    return deferredCondition((ctx) => joinFragments([this.toSql(ctx), suffix.toSql(ctx)], \" \"));\n  }\n\n  count(): Expr<number, never> {\n    return new FnExpr(\"count\", [this], {\n      suffix: \"::int\",\n      decode: decodeNumber,\n      encode: identity,\n      outputType: { dbType: \"int4\", domain: Number, arrayElementSafe: true },\n    }) as any;\n  }\n\n  countDistinct(): Expr<number, never> {\n    return new FnExpr(\"count\", [this], {\n      prefix: \"DISTINCT \",\n      suffix: \"::int\",\n      decode: decodeNumber,\n      encode: identity,\n      outputType: { dbType: \"int4\", domain: Number, arrayElementSafe: true },\n    }) as any;\n  }\n\n  sum(): Expr<number | null, any> {\n    return new FnExpr(\"sum\", [this], {\n      decode: decodeNumber,\n      encode: identity,\n      outputType: numericAggregateOutputType(\"sum\", this.outputType),\n    }) as any;\n  }\n\n  avg(): Expr<number | null, any> {\n    return new FnExpr(\"avg\", [this], {\n      decode: decodeNumber,\n      encode: identity,\n      outputType: numericAggregateOutputType(\"avg\", this.outputType),\n    }) as any;\n  }\n\n  min(): Expr<any, any> {\n    return new FnExpr(\"min\", [this], {\n      decode: (v) => this.decode(v),\n      outputType: minMaxOutputType(this.outputType),\n    }) as any;\n  }\n\n  max(): Expr<any, any> {\n    return new FnExpr(\"max\", [this], {\n      decode: (v) => this.decode(v),\n      outputType: minMaxOutputType(this.outputType),\n    }) as any;\n  }\n\n  arrayAgg(options?: ArrayAggOptions): Expr<any, any> {\n    // Values are arrays while the argument encodes/decodes *elements*, i.e. a `.coalesce([\"b:1\"])`\n    // fallback must encode each tagged id, not hand the whole array to the id column's encoder\n    return new FnExpr(\"array_agg\", [this], {\n      prefix: options?.distinct ? \"DISTINCT \" : undefined,\n      aggregate: options,\n      decode: (v) => (Array.isArray(v) ? v.map((e) => this.decode(e)) : v),\n      encode: (v) => (Array.isArray(v) ? v.map((e) => this.encode(e)) : v),\n      outputType: arrayOutputType(this.outputType),\n    }) as any;\n  }\n\n  stringAgg(delimiter: string): Expr<string | null, any> {\n    return new FnExpr(\"string_agg\", [this, new BindingExpr(delimiter)], {\n      outputType:\n        this.outputType?.domain === String ? { dbType: \"text\", domain: String, arrayElementSafe: true } : undefined,\n    }) as any;\n  }\n\n  coalesce(fallback: unknown): Expr<any, never> {\n    return new FnExpr(\"coalesce\", [this, new BindingExpr(this.encode(fallback))], {\n      decode: (v) => this.decode(v),\n      outputType: this.outputType,\n    }) as any;\n  }\n\n  /** `this op value`, where `value` may be `undefined` (pruned), `null`, another expression, or a literal. */\n  protected compare(op: string, value: unknown): SqlCondition {\n    if (value === undefined) return skipCondition;\n    if (value === null) {\n      const not = op === \"=\" ? \"\" : op === \"!=\" ? \"NOT \" : fail(`Cannot compare ${op} to null`);\n      return deferredCondition((ctx) => {\n        const left = this.toSql(ctx);\n        return { ...left, sql: `${left.sql} IS ${not}NULL` };\n      });\n    }\n    if (isExpr(value)) {\n      return deferredCondition((ctx) => joinFragments([this.toSql(ctx), asNode(value).toSql(ctx)], ` ${op} `));\n    }\n    return deferredCondition((ctx) => {\n      const left = this.toSql(ctx);\n      return { sql: `${left.sql} ${op} ?`, bindings: [...left.bindings, this.encode(value)], refs: left.refs };\n    });\n  }\n\n  /** `this IN (subquery)` or `this = ANY(?)` for a list; `NOT IN` / `!= ALL(?)` for `nin`. */\n  protected inList(op: \"IN\" | \"NOT IN\", values: unknown): SqlCondition {\n    if (values === undefined) return skipCondition;\n    if (isExpr(values)) {\n      return deferredCondition((ctx) => {\n        const left = this.toSql(ctx);\n        const right = asNode(values).toSqlBare(ctx);\n        return joinFragments([left, { ...right, sql: `(${right.sql})` }], ` ${op} `);\n      });\n    }\n    if (!Array.isArray(values)) fail(`Expected an array or subquery for ${op}, got ${values}`);\n    const fn = op === \"IN\" ? \"= ANY(?)\" : \"!= ALL(?)\";\n    return deferredCondition((ctx) => {\n      const left = this.toSql(ctx);\n      return {\n        sql: `${left.sql} ${fn}`,\n        bindings: [...left.bindings, values.map((v) => this.encode(v))],\n        refs: left.refs,\n      };\n    });\n  }\n}\n\n/**\n * A SQL function applied to expressions, i.e. `count(a.\"id\")::int` or `coalesce(bs.\"n\", ?)`.\n *\n * By default decoding is identity and encoding follows the first argument. Callers explicitly supply\n * a decoder and output type when needed (`max(a.id)` is still an id); numeric aggregates supply their\n * own decoder/encoder, since `count(a.id)` is a number, not an id. Unknown functions have no output type.\n */\nexport class FnExpr extends BaseExpr {\n  constructor(\n    private name: string,\n    private args: BaseExpr[],\n    private opts: {\n      prefix?: string;\n      suffix?: string;\n      decode?: (value: unknown) => unknown;\n      encode?: (value: unknown) => unknown;\n      outputType?: TypeInfo;\n      aggregate?: ArrayAggOptions;\n    },\n  ) {\n    super();\n  }\n\n  get outputType(): TypeInfo | undefined {\n    return this.opts.outputType;\n  }\n\n  get sqlNullable(): boolean | undefined {\n    switch (this.name) {\n      case \"count\":\n        return false;\n      case \"sum\":\n      case \"avg\":\n      case \"min\":\n      case \"max\":\n      case \"array_agg\":\n      case \"string_agg\":\n        return true;\n      case \"coalesce\":\n        // Only the fallback is independent of an outer query's LEFT joins.\n        return this.args[1]?.sqlNullable === false ? false : undefined;\n      default:\n        return undefined;\n    }\n  }\n\n  /**\n   * Renders function arguments, aggregate ordering, and the filter in SQL binding order.\n   * Keep references from all three so aggregate-only joins are retained.\n   */\n  toSql(ctx: ExprContext): SqlFragment {\n    const args = joinFragments(\n      this.args.map((a) => a.toSql(ctx)),\n      \", \",\n    );\n    const ordering = joinFragments(\n      (this.opts.aggregate?.orderBy ?? []).flatMap((entry) => {\n        if (entry === undefined) return [];\n        const fragment = orderByToSql(entry, ctx);\n        return fragment ? [fragment] : [];\n      }),\n      \", \",\n    );\n    const filter = this.opts.aggregate?.filter;\n    const condition = filter === undefined ? undefined : ctx.conditionToSql(filter);\n    return {\n      sql: `${this.name}(${this.opts.prefix ?? \"\"}${args.sql}${ordering.sql ? ` ORDER BY ${ordering.sql}` : \"\"})${condition ? ` FILTER (WHERE ${condition.sql})` : \"\"}${this.opts.suffix ?? \"\"}`,\n      bindings: [...args.bindings, ...ordering.bindings, ...(condition?.bindings ?? [])],\n      refs: [...args.refs, ...ordering.refs, ...(condition?.refs ?? [])],\n    };\n  }\n\n  decode(value: unknown): unknown {\n    if (value === null || value === undefined) return value;\n    return this.opts.decode ? this.opts.decode(value) : value;\n  }\n\n  encode(value: unknown): unknown {\n    return this.opts.encode ? this.opts.encode(value) : this.args[0].encode(value);\n  }\n}\n\n/** A bound literal, i.e. the `?` in `coalesce(x, ?)`. */\nexport class BindingExpr extends BaseExpr {\n  constructor(private value: unknown) {\n    super();\n  }\n\n  get sqlNullable(): boolean {\n    return this.value === null || this.value === undefined;\n  }\n\n  toSql(): SqlFragment {\n    return { sql: \"?\", bindings: [this.value], refs: [] };\n  }\n}\n\n/** An unmodeled column on a known source, i.e. `sql.ref(a, \"ts_search\")`; untracked at the type level. */\nexport class RefExpr extends BaseExpr {\n  constructor(\n    private handle: object,\n    private column: string,\n  ) {\n    super();\n  }\n\n  get sqlSource(): object {\n    return this.handle;\n  }\n\n  toSql(ctx: ExprContext): SqlFragment {\n    const alias = ctx.aliasFor(this.handle);\n    // safeKq for both halves: sql.ref takes user strings, and a subquery alias is its `as` name\n    return { sql: `${safeKq(alias)}.${safeKq(this.column)}`, bindings: [], refs: [alias] };\n  }\n}\n\n/**\n * A `sql` tagged template.\n *\n * For an Author table `a` assigned the SQL alias `a1`:\n *\n * ```ts\n * sql`${a.age} * 2`     // Expression: a1.age * 2\n * sql`${a.age.gte(18)}` // Condition: (a1.age >= ?), bindings [18]\n * sql`${\"Alice\"}`      // Value: ?, bindings [\"Alice\"]\n * ```\n */\nexport class TemplateExpr extends BaseExpr {\n  constructor(\n    private strings: TemplateStringsArray,\n    private values: unknown[],\n  ) {\n    super();\n  }\n\n  toSql(ctx: ExprContext): SqlFragment {\n    const parts: SqlFragment[] = [];\n    this.strings.forEach((s, i) => {\n      parts.push({ sql: s, bindings: [], refs: [] });\n      if (i < this.values.length) parts.push(interpolationToSql(this.values[i], ctx));\n    });\n    return joinFragments(parts, \"\");\n  }\n}\n\n/** Turns one `${...}` of a `sql` template into SQL: an expression, a condition, or a bound value. */\nexport function interpolationToSql(value: unknown, ctx: ExprContext): SqlFragment {\n  if (isExpr(value)) {\n    return asNode(value).toSql(ctx);\n  } else if (isConditionLike(value)) {\n    return ctx.conditionToSql(value as SqlCondition) ?? { sql: \"true\", bindings: [], refs: [] };\n  } else {\n    return { sql: \"?\", bindings: [value], refs: [] };\n  }\n}\n\n/** True for the user-facing condition shapes: `{ and }`, `{ or }`, `ColumnCondition`, `RawCondition`. */\nexport function isConditionLike(value: unknown): boolean {\n  if (typeof value !== \"object\" || value === null) return false;\n  const v = value as any;\n  return \"and\" in v || \"or\" in v || v.kind === \"column\" || v.kind === \"raw\" || v.kind === \"exists\";\n}\n\n/**\n * Resolves the SQL result type of supported numeric aggregates; other overloads remain unknown.\n *\n * I.e. `a.age.sum()` has `dbType: \"int8\"` and Number conversion, while `a.age` has `dbType: \"int4\"`\n * and identity conversion. Their number domains agree, but SQL types reject a union in either order.\n */\nfunction numericAggregateOutputType(name: \"sum\" | \"avg\", outputType: TypeInfo | undefined): TypeInfo | undefined {\n  switch (outputType?.dbType) {\n    case \"int2\":\n    case \"int4\":\n      return { dbType: name === \"sum\" ? \"int8\" : \"numeric\", domain: Number, arrayElementSafe: true };\n    case \"int8\":\n    case \"numeric\":\n      return { dbType: \"numeric\", domain: Number, arrayElementSafe: true };\n    case \"float4\":\n      return { dbType: name === \"sum\" ? \"float4\" : \"float8\", domain: Number, arrayElementSafe: true };\n    case \"float8\":\n      return { dbType: \"float8\", domain: Number, arrayElementSafe: true };\n    default:\n      return undefined;\n  }\n}\n\n/** Only known MIN/MAX overloads have predictable output types; varchar/name use the text overload. */\nfunction minMaxOutputType(outputType: TypeInfo | undefined): TypeInfo | undefined {\n  switch (outputType?.dbType) {\n    case \"varchar\":\n    case \"name\":\n      return { ...outputType, dbType: \"text\" };\n    case \"int2\":\n    case \"int4\":\n    case \"int8\":\n    case \"numeric\":\n    case \"float4\":\n    case \"float8\":\n    case \"text\":\n    case \"bpchar\":\n    case \"date\":\n    case \"time\":\n    case \"timetz\":\n    case \"timestamp\":\n    case \"timestamptz\":\n    case \"interval\":\n    case \"money\":\n    case \"inet\":\n      return outputType;\n    default:\n      return undefined;\n  }\n}\n\n/** Decodes `count`/`sum`/`avg` results, which Postgres returns as strings for bigint/numeric. */\nfunction decodeNumber(value: unknown): unknown {\n  return typeof value === \"string\" ? Number(value) : value;\n}\n\n/** Renders an expression order for either a query or an aggregate, or prunes an undefined order. */\nexport function orderByToSql(o: ExpressionOrderBy, ctx: ExprContext): SqlFragment | undefined {\n  if (!(o.sort instanceof BaseExpr)) {\n    return fail(\"orderBy must be an expression, i.e. a table column, aggregate, sql`...`, or scalar query(...)\");\n  }\n  if (Object.keys(o).some((key) => key !== \"sort\" && key !== \"order\" && key !== \"nulls\")) {\n    return fail(\"Expression orderBy entries only accept sort, order, and nulls\");\n  }\n  if (o.order === undefined) return undefined;\n  if (o.order !== \"ASC\" && o.order !== \"DESC\") {\n    return fail(`Invalid orderBy direction '${o.order}'`);\n  }\n  // `nulls` is interpolated into the SQL, so never trust it, i.e. it might cross an `any` boundary\n  if (o.nulls !== undefined && o.nulls !== \"first\" && o.nulls !== \"last\") {\n    return fail(`Invalid orderBy nulls '${o.nulls}'`);\n  }\n  const fragment = o.sort.toSql(ctx);\n  const nulls = o.nulls ? ` NULLS ${o.nulls.toUpperCase()}` : \"\";\n  return { ...fragment, sql: `${fragment.sql} ${o.order}${nulls}` };\n}\n\nfunction identity(value: unknown): unknown {\n  return value;\n}\n\nfunction fail(message: string): never {\n  throw new Error(message);\n}\n"],"mappings":"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"}

package/build/Expr.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Expr.d.cts","names":[],"sources":["../src/Expr.ts"],"mappings":"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"}

package/build/Expr.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Expr.d.mts","names":[],"sources":["../src/Expr.ts"],"mappings":";;;;;;;;;;;;;;;;cAoBa;;;;;;;;;;;;;;;;;;;;;UAsBI,UAAU,GAAG;WACnB,UAAU;WACV,UAAU;;;;;;;;;;KAWT,SAAS;YAAiB,YAAY,UAAU;;;UAG3C;EACf;;EAEA,oBAAoB;;EAEpB,SAAS;;;;;;;;;;UAWM,KAAK,GAAG;YACb,YAAY,UAAU,GAAG;EACnC,GAAG,OAAO,IAAI,SAAS,iBAAiB;EACxC,GAAG,OAAO,IAAI,SAAS,iBAAiB;EACxC,GAAG,OAAO,IAAI,SAAS,iBAAiB;EACxC,IAAI,OAAO,IAAI,SAAS,iBAAiB;EACzC,GAAG,OAAO,IAAI,SAAS,iBAAiB;EACxC,IAAI,OAAO,IAAI,SAAS,iBAAiB;EAEzC,GAAG,iBAAiB,MAAM,SAAS,wBAAwB;EAC3D,IAAI,iBAAiB,MAAM,SAAS,wBAAwB;;EAG5D,GAAG,SAAS,yBAAyB,oBAAoB;;EAGzD,SAAS;EACT,iBAAiB;EACjB,IAAI,MAAM,oBAAoB,OAAO,oBAAoB;EACzD,IAAI,MAAM,oBAAoB,OAAO,oBAAoB;EACzD,OAAO,KAAK,UAAU;EACtB,OAAO,KAAK,UAAU;;EAEtB,SAAS,UAAU,kBAAkB,KAAK,YAAY;EACtD,UAAU,MAAM,oBAAoB,MAAM,oBAAoB,oBAAoB;EAClF,SAAS,UAAU,YAAY,KAAK,KAAK,YAAY;;;;;;;;;;;;;UActC,UAAU,GAAG,IAAI;WACvB,OAAO;WACP;WACA,IAAI;WACJ;;UAGM,SAAS,GAAG,IAAI;WACtB,MAAM;WACN;WACA,IAAI;WACJ;;;UAIM;EACf;EACA;EACA;;;;;;UAOe;;EAEf,SAAS;;EAET,eAAe,MAAM,iBAAiB;;iBAGxB,OAAO,iBAAiB,SAAS;;iBAKjC,OAAO,MAAM,gBAAgB;cAIhC;;;;;;;;;UAUI,0BAA0B,cAAc;GACtD,eAAe,KAAK,gBAAgB;;iBAGvB,oBAAoB,gBAAgB,QAAQ;;iBAK5C,kBAAkB,KAAK,KAAK,gBAAgB,cAAc;;;;;iBAsB1D,0BACd,MAAM,4BACN,KAAK,cACJ;;iBAaa,cAAc,OAAO,eAAe,cAAc;;;;;;;uBAc5C;YACV;;WAGD,MAAM,KAAK,cAAc;;MAG9B,kBAAkB;;MAKlB,cAAc;;MAKd;;MAKA;;EAKJ,UAAU,KAAK,cAAc;;EAK7B,OAAO;;EAKP,OAAO;EAIP,GAAG,iBAAiB;EAIpB,GAAG,iBAAiB;EAIpB,GAAG,iBAAiB;EAIpB,IAAI,iBAAiB;EAIrB,GAAG,iBAAiB;EAIpB,IAAI,iBAAiB;EAIrB,GAAG,kBAAkB;EAIrB,IAAI,kBAAkB;;EAKtB,GAAG,SAAS,yBAAyB,oBAAoB;EAKzD,SAAS;EAST,iBAAiB;EAUjB,OAAO;EAQP,OAAO;EAQP,OAAO;EAOP,OAAO;EAOP,SAAS,UAAU,kBAAkB;EAYrC,UAAU,oBAAoB;EAO9B,SAAS,oBAAoB;;YAQnB,QAAQ,YAAY,iBAAiB;;YAmBrC,OAAO,qBAAqB,kBAAkB;;;;;;;;;cA6B7C,eAAe;UAEhB;UACA;UACA;EAHV,YACU,cACA,MAAM,YACN;IACN;IACA;IACA,UAAU;IACV,UAAU;IACV,aAAa;IACb,YAAY;;MAMZ,cAAc;MAId;;;;;EAuBJ,MAAM,KAAK,cAAc;EAsBzB,OAAO;EAKP,OAAO;;;cAMI,oBAAoB;UACX;EAApB,YAAoB;MAIhB;EAIJ,SAAS;;;cAME,gBAAgB;UAEjB;UACA;EAFV,YACU,gBACA;MAKN;EAIJ,MAAM,KAAK,cAAc;;;;;;;;;;;;;cAkBd,qBAAqB;UAEtB;UACA;EAFV,YACU,SAAS,sBACT;EAKV,MAAM,KAAK,cAAc;;;iBAWX,mBAAmB,gBAAgB,KAAK,cAAc;;iBAWtD,gBAAgB;;iBA+DhB,aAAa,GAAG,mBAAmB,KAAK,cAAc"}

package/build/Expr.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Expr.js","names":[],"sources":["../src/Expr.ts"],"sourcesContent":["import { type ConditionInput, type PredicateBrand, type SqlCondition, brandPredicate } from \"./conditions.ts\";\nimport type { EntityMetadata } from \"./EntityMetadata.ts\";\nimport { safeKq } from \"./keywords.ts\";\nimport type { ExpressionOrderBy, QueryCondition } from \"./query.ts\";\nimport type { RawCondition } from \"./QueryParser.ts\";\nimport { skipCondition } from \"./skipCondition.ts\";\nimport { type TypeInfo, arrayOutputType } from \"./TypeInfo.ts\";\n\n/**\n * The shared expression protocol for `em.query`.\n *\n * Table columns (`a.first_name`), aggregates (`b.id.count()`), `sql` templates, subquery columns\n * (`bookStats.bookCount`), and scalar subqueries all implement it, so any of them can appear in\n * `select`, `where`, `groupBy`, `having`, `orderBy`, and inside other expressions.\n *\n * This module is a leaf on purpose: `Tables.ts` extends `BaseExpr` at load time, so nothing here may\n * import (at runtime) a module that leads back to `Tables.ts`. Anything that needs metadata, alias\n * binding, or SQL generation for conditions is reached through the `ExprContext` the query parser passes in.\n */\n\nexport const exprBrand: unique symbol = Symbol(\"joist.expr\");\n\n/**\n * Phantom type information carried by every `Expr`.\n *\n * `R` is the decoded result type.\n *\n * `Src` is the expression's *source key*: the type-level identity of the table it reads from. An entity\n * table's key is its type name (`table(Author)` gives `\"Author\"`) or the explicit name in\n * `table(Author, \"m\")`; a subquery's key is its `as: \"book_stats\"`, or the shared sentinel `\"?\"` when it\n * has no `as`. Exactly two questions are asked of a source key, and nothing else:\n *\n * - `MaybeNull` asks \"is my source key among the LEFT-joined sources in this query's join list?\" If yes,\n *   the value can be `null`.\n * - `CheckScope` asks \"is my source key among `from` + `join` at all?\" If no, the query reads from a\n *   table it never joined.\n *\n * Two special keys opt out of both questions:\n *\n * - `Expr<number, never>` reads from nothing that can be left-joined away, i.e. `b.id.count()`\n * - `Expr<number, string>` (the default) is untracked, i.e. `sql.ref` on an unknown table\n */\nexport interface ExprBrand<R, Src extends string> {\n  readonly __result: R;\n  readonly __source: Src;\n}\n\n/**\n * \"Any expression whose result is `R`\", checked by brand alone.\n *\n * Method parameters use this instead of `Expr<R>` so that `Expr` stays covariant in `R`: checking\n * `Expr<AuthorId>` against `Expr<AuthorId | null>` then only compares the phantom `__result`, not every\n * method's parameter list (which would make `Expr` invariant, and break `select: b.author_id` dispatch and\n * polymorphic joins).\n */\nexport type ExprLike<R> = { readonly [exprBrand]: ExprBrand<R, any> };\n\n/** Controls which values enter an array aggregate and their order within the array. */\nexport interface ArrayAggOptions {\n  distinct?: boolean;\n  /** With DISTINCT, PostgreSQL requires ordering expressions to match the aggregate argument. */\n  orderBy?: readonly (ExpressionOrderBy | undefined)[];\n  /** Undefined conditions are pruned, as in a query's where clause. */\n  filter?: QueryCondition;\n}\n\n/**\n * A typed SQL expression: a table column, an aggregate, a `sql` template, or a scalar subquery.\n *\n * Conditions and SQL functions are methods, so they need no import. Aggregates keep `Src` so scope\n * checking still sees through `bs.x.max()`; `count` is source-less because `count(x)` is 0, not null,\n * when `x`'s table is left-joined away; `coalesce` drops `Src` on purpose, since its whole job is to\n * remove the nullability a left join adds.\n */\nexport interface Expr<R, Src extends string = string> {\n  readonly [exprBrand]: ExprBrand<R, Src>;\n  eq(value: R | ExprLike<R> | undefined): SqlCondition;\n  ne(value: R | ExprLike<R> | undefined): SqlCondition;\n  gt(value: R | ExprLike<R> | undefined): SqlCondition;\n  gte(value: R | ExprLike<R> | undefined): SqlCondition;\n  lt(value: R | ExprLike<R> | undefined): SqlCondition;\n  lte(value: R | ExprLike<R> | undefined): SqlCondition;\n  // A list subquery may select a nullable column; NULLs in the set never match, so that is fine.\n  in(values: readonly R[] | ExprLike<R | null> | undefined): SqlCondition;\n  nin(values: readonly R[] | ExprLike<R | null> | undefined): SqlCondition;\n\n  /** Prefixes this expression and a space to a raw predicate; write .is`IS NULL`, not .is`NULL`. */\n  is(strings: TemplateStringsArray, ...values: unknown[]): SqlCondition;\n\n  /** `count(x)::int`; `count(a.id)` is `count(*)` for the FROM table, and the matched-row count for a left-joined one. */\n  count(): Expr<number, never>;\n  countDistinct(): Expr<number, never>;\n  sum(this: Expr<number | null, Src>): Expr<number | null, Src>;\n  avg(this: Expr<number | null, Src>): Expr<number | null, Src>;\n  min(): Expr<R | null, Src>;\n  max(): Expr<R | null, Src>;\n  /** PG keeps element NULLs (a left-joined empty group aggregates as `[null]`), and zero rows aggregate as NULL. */\n  arrayAgg(options?: ArrayAggOptions): Expr<R[] | null, Src>;\n  stringAgg(this: Expr<string | null, Src>, delimiter: string): Expr<string | null, Src>;\n  coalesce(fallback: NonNullable<R>): Expr<NonNullable<R>, never>;\n}\n\n/**\n * A join entry: the join kind is the key, the joined source is the value, plus `on`. `inner?: never` /\n * `left?: never` keep an entry to one kind (the `SqlCondition` `and`/`or` trick).\n *\n * `on` is required. A join is pruned when nothing references it anymore, not by an `undefined` ON;\n * `keep: true` pins a join that would otherwise prune, i.e. an inner join used as an existence filter,\n * the way em.find's `keepAliases` does. It is a boolean so callers can pass a flag.\n *\n * Declared here (not `query.ts`) so the relation join factories in `Tables.ts` (i.e. `a.books.as(b)`) can\n * return them without importing `query.ts`; `query.ts` re-constrains `A` to its `QuerySource`.\n */\nexport interface InnerJoin<A, C = SqlCondition> {\n  readonly inner: A;\n  readonly left?: never;\n  readonly on: C;\n  readonly keep?: boolean;\n}\n\nexport interface LeftJoin<A, C = SqlCondition> {\n  readonly left: A;\n  readonly inner?: never;\n  readonly on: C;\n  readonly keep?: boolean;\n}\n\n/** SQL plus its `?` bindings plus the SQL aliases it references, i.e. for join pruning. */\nexport interface SqlFragment {\n  sql: string;\n  bindings: any[];\n  refs: string[];\n}\n\n/**\n * What an expression needs from the query it is generating SQL for: the SQL alias assigned to each\n * source, and a way to turn nested conditions into SQL (which needs `ConditionBuilder`, so it lives in `query.ts`).\n */\nexport interface ExprContext {\n  /** Returns the SQL alias for a table's `TableMgmt` or a subquery handle, searching enclosing queries. */\n  aliasFor(handle: object): string;\n  /** Turns a user-facing condition into SQL; `undefined` if it pruned away entirely. */\n  conditionToSql(cond: QueryCondition): SqlFragment | undefined;\n}\n\nexport function isExpr(value: unknown): value is ExprLike<any> {\n  return typeof value === \"object\" && value !== null && exprBrand in value;\n}\n\n/** Every `Expr` is a `BaseExpr` at runtime; this cast keeps `isExpr` a plain type guard so unions narrow. */\nexport function asNode(expr: ExprLike<any>): BaseExpr {\n  return expr as any as BaseExpr;\n}\n\nexport const deferredSym: unique symbol = Symbol(\"joist.deferredCondition\");\n\n/**\n * A condition whose SQL depends on aliases that are only known once the query is parsed, i.e.\n * `bookStats.bookCount.gt(1)` or `bs.authorId.eq(a.id)`.\n *\n * It is shaped like a `RawCondition` with a SQL brand so it can sit in any `SqlCondition`; `resolveDeferredConditions`\n * snapshots `condition`, `bindings`, and `aliases` before the filter is parsed. Domain alias conditions\n * use a separate protocol in the `em.find` parser.\n */\nexport interface DeferredCondition extends RawCondition, PredicateBrand<\"sql\"> {\n  [deferredSym]: (ctx: ExprContext) => RawCondition;\n}\n\nexport function isDeferredCondition(cond: unknown): cond is DeferredCondition {\n  return typeof cond === \"object\" && cond !== null && deferredSym in cond;\n}\n\n/** Creates a `DeferredCondition` that generates its SQL with `fn` once the query's aliases are known. */\nexport function deferredCondition(fn: (ctx: ExprContext) => SqlFragment): DeferredCondition {\n  const cond: DeferredCondition = brandPredicate(\n    {\n      kind: \"raw\",\n      aliases: [],\n      condition: \"<unresolved>\",\n      bindings: [],\n      pruneable: false,\n      [deferredSym]: (ctx: ExprContext): RawCondition => {\n        const { sql, bindings, refs } = fn(ctx);\n        return { ...cond, condition: sql, bindings, aliases: refs };\n      },\n    },\n    \"sql\",\n  );\n  return cond;\n}\n\n/**\n * Resolve each condition occurrence and snapshot it before resolving the next one. A nested subquery\n * may reuse the same condition under another alias; it must not overwrite this occurrence's SQL.\n */\nexport function resolveDeferredConditions(\n  cond: ConditionInput | undefined,\n  ctx: ExprContext,\n): ConditionInput | undefined {\n  if (cond === undefined || cond === null) return cond;\n  if (isDeferredCondition(cond)) {\n    return cond[deferredSym](ctx);\n  } else if (\"and\" in cond && cond.and) {\n    return { ...cond, and: cond.and.map((c) => resolveDeferredConditions(c, ctx)) };\n  } else if (\"or\" in cond && cond.or) {\n    return { ...cond, or: cond.or.map((c) => resolveDeferredConditions(c, ctx)) };\n  }\n  return cond;\n}\n\n/** Concatenates SQL fragments with `sep`, keeping bindings and refs in order. */\nexport function joinFragments(parts: SqlFragment[], sep: string): SqlFragment {\n  return {\n    sql: parts.map((p) => p.sql).join(sep),\n    bindings: parts.flatMap((p) => p.bindings),\n    refs: parts.flatMap((p) => p.refs),\n  };\n}\n\n/**\n * The methods every expression shares. Subclasses provide `toSql`, and usually `decode`/`encode`.\n *\n * Table columns can override comparisons to apply column-specific conversions. Domain aliases do not\n * implement this protocol.\n */\nexport abstract class BaseExpr {\n  readonly [exprBrand]: any = this;\n\n  /** Produces this expression's SQL so it can be embedded in a larger expression, i.e. a subquery gets parens. */\n  abstract toSql(ctx: ExprContext): SqlFragment;\n\n  /** Only an actual scalar/IN subquery exposes its selected expression, not an ordinary ID expression. */\n  get subquerySelect(): BaseExpr | undefined {\n    return undefined;\n  }\n\n  /** Known SQL representation and logical domain; raw SQL and unmodeled refs remain unknown. */\n  get outputType(): TypeInfo | undefined {\n    return undefined;\n  }\n\n  /** Physical SQL nullability; undefined means unknown, not a NOT NULL guarantee. */\n  get sqlNullable(): boolean | undefined {\n    return undefined;\n  }\n\n  /** The source of a direct column reference, whose value becomes NULL under an unmatched LEFT join. */\n  get sqlSource(): object | undefined {\n    return undefined;\n  }\n\n  /** Produces the SQL without the outer parens a subquery normally gets; only differs for subqueries. */\n  toSqlBare(ctx: ExprContext): SqlFragment {\n    return this.toSql(ctx);\n  }\n\n  /** Converts a result-set value into the domain value, i.e. an int into a tagged id. */\n  decode(value: unknown): unknown {\n    return value;\n  }\n\n  /** Converts a domain value into the database value, i.e. a tagged id into an int, for bindings. */\n  encode(value: unknown): unknown {\n    return value;\n  }\n\n  eq(value: unknown): SqlCondition {\n    return this.compare(\"=\", value);\n  }\n\n  ne(value: unknown): SqlCondition {\n    return this.compare(\"!=\", value);\n  }\n\n  gt(value: unknown): SqlCondition {\n    return this.compare(\">\", value);\n  }\n\n  gte(value: unknown): SqlCondition {\n    return this.compare(\">=\", value);\n  }\n\n  lt(value: unknown): SqlCondition {\n    return this.compare(\"<\", value);\n  }\n\n  lte(value: unknown): SqlCondition {\n    return this.compare(\"<=\", value);\n  }\n\n  in(values: unknown): SqlCondition {\n    return this.inList(\"IN\", values);\n  }\n\n  nin(values: unknown): SqlCondition {\n    return this.inList(\"NOT IN\", values);\n  }\n\n  /** Prefixes this expression to a SQL template, retaining bindings and referenced aliases. */\n  is(strings: TemplateStringsArray, ...values: unknown[]): SqlCondition {\n    const suffix = new TemplateExpr(strings, values);\n    return deferredCondition((ctx) => joinFragments([this.toSql(ctx), suffix.toSql(ctx)], \" \"));\n  }\n\n  count(): Expr<number, never> {\n    return new FnExpr(\"count\", [this], {\n      suffix: \"::int\",\n      decode: decodeNumber,\n      encode: identity,\n      outputType: { dbType: \"int4\", domain: Number, arrayElementSafe: true },\n    }) as any;\n  }\n\n  countDistinct(): Expr<number, never> {\n    return new FnExpr(\"count\", [this], {\n      prefix: \"DISTINCT \",\n      suffix: \"::int\",\n      decode: decodeNumber,\n      encode: identity,\n      outputType: { dbType: \"int4\", domain: Number, arrayElementSafe: true },\n    }) as any;\n  }\n\n  sum(): Expr<number | null, any> {\n    return new FnExpr(\"sum\", [this], {\n      decode: decodeNumber,\n      encode: identity,\n      outputType: numericAggregateOutputType(\"sum\", this.outputType),\n    }) as any;\n  }\n\n  avg(): Expr<number | null, any> {\n    return new FnExpr(\"avg\", [this], {\n      decode: decodeNumber,\n      encode: identity,\n      outputType: numericAggregateOutputType(\"avg\", this.outputType),\n    }) as any;\n  }\n\n  min(): Expr<any, any> {\n    return new FnExpr(\"min\", [this], {\n      decode: (v) => this.decode(v),\n      outputType: minMaxOutputType(this.outputType),\n    }) as any;\n  }\n\n  max(): Expr<any, any> {\n    return new FnExpr(\"max\", [this], {\n      decode: (v) => this.decode(v),\n      outputType: minMaxOutputType(this.outputType),\n    }) as any;\n  }\n\n  arrayAgg(options?: ArrayAggOptions): Expr<any, any> {\n    // Values are arrays while the argument encodes/decodes *elements*, i.e. a `.coalesce([\"b:1\"])`\n    // fallback must encode each tagged id, not hand the whole array to the id column's encoder\n    return new FnExpr(\"array_agg\", [this], {\n      prefix: options?.distinct ? \"DISTINCT \" : undefined,\n      aggregate: options,\n      decode: (v) => (Array.isArray(v) ? v.map((e) => this.decode(e)) : v),\n      encode: (v) => (Array.isArray(v) ? v.map((e) => this.encode(e)) : v),\n      outputType: arrayOutputType(this.outputType),\n    }) as any;\n  }\n\n  stringAgg(delimiter: string): Expr<string | null, any> {\n    return new FnExpr(\"string_agg\", [this, new BindingExpr(delimiter)], {\n      outputType:\n        this.outputType?.domain === String ? { dbType: \"text\", domain: String, arrayElementSafe: true } : undefined,\n    }) as any;\n  }\n\n  coalesce(fallback: unknown): Expr<any, never> {\n    return new FnExpr(\"coalesce\", [this, new BindingExpr(this.encode(fallback))], {\n      decode: (v) => this.decode(v),\n      outputType: this.outputType,\n    }) as any;\n  }\n\n  /** `this op value`, where `value` may be `undefined` (pruned), `null`, another expression, or a literal. */\n  protected compare(op: string, value: unknown): SqlCondition {\n    if (value === undefined) return skipCondition;\n    if (value === null) {\n      const not = op === \"=\" ? \"\" : op === \"!=\" ? \"NOT \" : fail(`Cannot compare ${op} to null`);\n      return deferredCondition((ctx) => {\n        const left = this.toSql(ctx);\n        return { ...left, sql: `${left.sql} IS ${not}NULL` };\n      });\n    }\n    if (isExpr(value)) {\n      return deferredCondition((ctx) => joinFragments([this.toSql(ctx), asNode(value).toSql(ctx)], ` ${op} `));\n    }\n    return deferredCondition((ctx) => {\n      const left = this.toSql(ctx);\n      return { sql: `${left.sql} ${op} ?`, bindings: [...left.bindings, this.encode(value)], refs: left.refs };\n    });\n  }\n\n  /** `this IN (subquery)` or `this = ANY(?)` for a list; `NOT IN` / `!= ALL(?)` for `nin`. */\n  protected inList(op: \"IN\" | \"NOT IN\", values: unknown): SqlCondition {\n    if (values === undefined) return skipCondition;\n    if (isExpr(values)) {\n      return deferredCondition((ctx) => {\n        const left = this.toSql(ctx);\n        const right = asNode(values).toSqlBare(ctx);\n        return joinFragments([left, { ...right, sql: `(${right.sql})` }], ` ${op} `);\n      });\n    }\n    if (!Array.isArray(values)) fail(`Expected an array or subquery for ${op}, got ${values}`);\n    const fn = op === \"IN\" ? \"= ANY(?)\" : \"!= ALL(?)\";\n    return deferredCondition((ctx) => {\n      const left = this.toSql(ctx);\n      return {\n        sql: `${left.sql} ${fn}`,\n        bindings: [...left.bindings, values.map((v) => this.encode(v))],\n        refs: left.refs,\n      };\n    });\n  }\n}\n\n/**\n * A SQL function applied to expressions, i.e. `count(a.\"id\")::int` or `coalesce(bs.\"n\", ?)`.\n *\n * By default decoding is identity and encoding follows the first argument. Callers explicitly supply\n * a decoder and output type when needed (`max(a.id)` is still an id); numeric aggregates supply their\n * own decoder/encoder, since `count(a.id)` is a number, not an id. Unknown functions have no output type.\n */\nexport class FnExpr extends BaseExpr {\n  constructor(\n    private name: string,\n    private args: BaseExpr[],\n    private opts: {\n      prefix?: string;\n      suffix?: string;\n      decode?: (value: unknown) => unknown;\n      encode?: (value: unknown) => unknown;\n      outputType?: TypeInfo;\n      aggregate?: ArrayAggOptions;\n    },\n  ) {\n    super();\n  }\n\n  get outputType(): TypeInfo | undefined {\n    return this.opts.outputType;\n  }\n\n  get sqlNullable(): boolean | undefined {\n    switch (this.name) {\n      case \"count\":\n        return false;\n      case \"sum\":\n      case \"avg\":\n      case \"min\":\n      case \"max\":\n      case \"array_agg\":\n      case \"string_agg\":\n        return true;\n      case \"coalesce\":\n        // Only the fallback is independent of an outer query's LEFT joins.\n        return this.args[1]?.sqlNullable === false ? false : undefined;\n      default:\n        return undefined;\n    }\n  }\n\n  /**\n   * Renders function arguments, aggregate ordering, and the filter in SQL binding order.\n   * Keep references from all three so aggregate-only joins are retained.\n   */\n  toSql(ctx: ExprContext): SqlFragment {\n    const args = joinFragments(\n      this.args.map((a) => a.toSql(ctx)),\n      \", \",\n    );\n    const ordering = joinFragments(\n      (this.opts.aggregate?.orderBy ?? []).flatMap((entry) => {\n        if (entry === undefined) return [];\n        const fragment = orderByToSql(entry, ctx);\n        return fragment ? [fragment] : [];\n      }),\n      \", \",\n    );\n    const filter = this.opts.aggregate?.filter;\n    const condition = filter === undefined ? undefined : ctx.conditionToSql(filter);\n    return {\n      sql: `${this.name}(${this.opts.prefix ?? \"\"}${args.sql}${ordering.sql ? ` ORDER BY ${ordering.sql}` : \"\"})${condition ? ` FILTER (WHERE ${condition.sql})` : \"\"}${this.opts.suffix ?? \"\"}`,\n      bindings: [...args.bindings, ...ordering.bindings, ...(condition?.bindings ?? [])],\n      refs: [...args.refs, ...ordering.refs, ...(condition?.refs ?? [])],\n    };\n  }\n\n  decode(value: unknown): unknown {\n    if (value === null || value === undefined) return value;\n    return this.opts.decode ? this.opts.decode(value) : value;\n  }\n\n  encode(value: unknown): unknown {\n    return this.opts.encode ? this.opts.encode(value) : this.args[0].encode(value);\n  }\n}\n\n/** A bound literal, i.e. the `?` in `coalesce(x, ?)`. */\nexport class BindingExpr extends BaseExpr {\n  constructor(private value: unknown) {\n    super();\n  }\n\n  get sqlNullable(): boolean {\n    return this.value === null || this.value === undefined;\n  }\n\n  toSql(): SqlFragment {\n    return { sql: \"?\", bindings: [this.value], refs: [] };\n  }\n}\n\n/** An unmodeled column on a known source, i.e. `sql.ref(a, \"ts_search\")`; untracked at the type level. */\nexport class RefExpr extends BaseExpr {\n  constructor(\n    private handle: object,\n    private column: string,\n  ) {\n    super();\n  }\n\n  get sqlSource(): object {\n    return this.handle;\n  }\n\n  toSql(ctx: ExprContext): SqlFragment {\n    const alias = ctx.aliasFor(this.handle);\n    // safeKq for both halves: sql.ref takes user strings, and a subquery alias is its `as` name\n    return { sql: `${safeKq(alias)}.${safeKq(this.column)}`, bindings: [], refs: [alias] };\n  }\n}\n\n/**\n * A `sql` tagged template.\n *\n * For an Author table `a` assigned the SQL alias `a1`:\n *\n * ```ts\n * sql`${a.age} * 2`     // Expression: a1.age * 2\n * sql`${a.age.gte(18)}` // Condition: (a1.age >= ?), bindings [18]\n * sql`${\"Alice\"}`      // Value: ?, bindings [\"Alice\"]\n * ```\n */\nexport class TemplateExpr extends BaseExpr {\n  constructor(\n    private strings: TemplateStringsArray,\n    private values: unknown[],\n  ) {\n    super();\n  }\n\n  toSql(ctx: ExprContext): SqlFragment {\n    const parts: SqlFragment[] = [];\n    this.strings.forEach((s, i) => {\n      parts.push({ sql: s, bindings: [], refs: [] });\n      if (i < this.values.length) parts.push(interpolationToSql(this.values[i], ctx));\n    });\n    return joinFragments(parts, \"\");\n  }\n}\n\n/** Turns one `${...}` of a `sql` template into SQL: an expression, a condition, or a bound value. */\nexport function interpolationToSql(value: unknown, ctx: ExprContext): SqlFragment {\n  if (isExpr(value)) {\n    return asNode(value).toSql(ctx);\n  } else if (isConditionLike(value)) {\n    return ctx.conditionToSql(value as SqlCondition) ?? { sql: \"true\", bindings: [], refs: [] };\n  } else {\n    return { sql: \"?\", bindings: [value], refs: [] };\n  }\n}\n\n/** True for the user-facing condition shapes: `{ and }`, `{ or }`, `ColumnCondition`, `RawCondition`. */\nexport function isConditionLike(value: unknown): boolean {\n  if (typeof value !== \"object\" || value === null) return false;\n  const v = value as any;\n  return \"and\" in v || \"or\" in v || v.kind === \"column\" || v.kind === \"raw\" || v.kind === \"exists\";\n}\n\n/**\n * Resolves the SQL result type of supported numeric aggregates; other overloads remain unknown.\n *\n * I.e. `a.age.sum()` has `dbType: \"int8\"` and Number conversion, while `a.age` has `dbType: \"int4\"`\n * and identity conversion. Their number domains agree, but SQL types reject a union in either order.\n */\nfunction numericAggregateOutputType(name: \"sum\" | \"avg\", outputType: TypeInfo | undefined): TypeInfo | undefined {\n  switch (outputType?.dbType) {\n    case \"int2\":\n    case \"int4\":\n      return { dbType: name === \"sum\" ? \"int8\" : \"numeric\", domain: Number, arrayElementSafe: true };\n    case \"int8\":\n    case \"numeric\":\n      return { dbType: \"numeric\", domain: Number, arrayElementSafe: true };\n    case \"float4\":\n      return { dbType: name === \"sum\" ? \"float4\" : \"float8\", domain: Number, arrayElementSafe: true };\n    case \"float8\":\n      return { dbType: \"float8\", domain: Number, arrayElementSafe: true };\n    default:\n      return undefined;\n  }\n}\n\n/** Only known MIN/MAX overloads have predictable output types; varchar/name use the text overload. */\nfunction minMaxOutputType(outputType: TypeInfo | undefined): TypeInfo | undefined {\n  switch (outputType?.dbType) {\n    case \"varchar\":\n    case \"name\":\n      return { ...outputType, dbType: \"text\" };\n    case \"int2\":\n    case \"int4\":\n    case \"int8\":\n    case \"numeric\":\n    case \"float4\":\n    case \"float8\":\n    case \"text\":\n    case \"bpchar\":\n    case \"date\":\n    case \"time\":\n    case \"timetz\":\n    case \"timestamp\":\n    case \"timestamptz\":\n    case \"interval\":\n    case \"money\":\n    case \"inet\":\n      return outputType;\n    default:\n      return undefined;\n  }\n}\n\n/** Decodes `count`/`sum`/`avg` results, which Postgres returns as strings for bigint/numeric. */\nfunction decodeNumber(value: unknown): unknown {\n  return typeof value === \"string\" ? Number(value) : value;\n}\n\n/** Renders an expression order for either a query or an aggregate, or prunes an undefined order. */\nexport function orderByToSql(o: ExpressionOrderBy, ctx: ExprContext): SqlFragment | undefined {\n  if (!(o.sort instanceof BaseExpr)) {\n    return fail(\"orderBy must be an expression, i.e. a table column, aggregate, sql`...`, or scalar query(...)\");\n  }\n  if (Object.keys(o).some((key) => key !== \"sort\" && key !== \"order\" && key !== \"nulls\")) {\n    return fail(\"Expression orderBy entries only accept sort, order, and nulls\");\n  }\n  if (o.order === undefined) return undefined;\n  if (o.order !== \"ASC\" && o.order !== \"DESC\") {\n    return fail(`Invalid orderBy direction '${o.order}'`);\n  }\n  // `nulls` is interpolated into the SQL, so never trust it, i.e. it might cross an `any` boundary\n  if (o.nulls !== undefined && o.nulls !== \"first\" && o.nulls !== \"last\") {\n    return fail(`Invalid orderBy nulls '${o.nulls}'`);\n  }\n  const fragment = o.sort.toSql(ctx);\n  const nulls = o.nulls ? ` NULLS ${o.nulls.toUpperCase()}` : \"\";\n  return { ...fragment, sql: `${fragment.sql} ${o.order}${nulls}` };\n}\n\nfunction identity(value: unknown): unknown {\n  return value;\n}\n\nfunction fail(message: string): never {\n  throw new Error(message);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAoBA,MAAa,YAA2B,OAAO,YAAY;AA6H3D,SAAgB,OAAO,OAAwC;CAC7D,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,aAAa;AACrE;;AAGA,SAAgB,OAAO,MAA+B;CACpD,OAAO;AACT;AAEA,MAAa,cAA6B,OAAO,yBAAyB;AAc1E,SAAgB,oBAAoB,MAA0C;CAC5E,OAAO,OAAO,SAAS,YAAY,SAAS,QAAQ,eAAe;AACrE;;AAGA,SAAgB,kBAAkB,IAA0D;CAC1F,MAAM,OAA0B,eAC9B;EACE,MAAM;EACN,SAAS,CAAC;EACV,WAAW;EACX,UAAU,CAAC;EACX,WAAW;GACV,eAAe,QAAmC;GACjD,MAAM,EAAE,KAAK,UAAU,SAAS,GAAG,GAAG;GACtC,OAAO;IAAE,GAAG;IAAM,WAAW;IAAK;IAAU,SAAS;GAAK;EAC5D;CACF,GACA,KACF;CACA,OAAO;AACT;;;;;AAMA,SAAgB,0BACd,MACA,KAC4B;CAC5B,IAAI,SAAS,KAAA,KAAa,SAAS,MAAM,OAAO;CAChD,IAAI,oBAAoB,IAAI,GAC1B,OAAO,KAAK,YAAY,CAAC,GAAG;MACvB,IAAI,SAAS,QAAQ,KAAK,KAC/B,OAAO;EAAE,GAAG;EAAM,KAAK,KAAK,IAAI,KAAK,MAAM,0BAA0B,GAAG,GAAG,CAAC;CAAE;MACzE,IAAI,QAAQ,QAAQ,KAAK,IAC9B,OAAO;EAAE,GAAG;EAAM,IAAI,KAAK,GAAG,KAAK,MAAM,0BAA0B,GAAG,GAAG,CAAC;CAAE;CAE9E,OAAO;AACT;;AAGA,SAAgB,cAAc,OAAsB,KAA0B;CAC5E,OAAO;EACL,KAAK,MAAM,KAAK,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,GAAG;EACrC,UAAU,MAAM,SAAS,MAAM,EAAE,QAAQ;EACzC,MAAM,MAAM,SAAS,MAAM,EAAE,IAAI;CACnC;AACF;;;;;;;AAQA,IAAsB,WAAtB,MAA+B;CAC7B,CAAU,aAAkB;;CAM5B,IAAI,iBAAuC,CAE3C;;CAGA,IAAI,aAAmC,CAEvC;;CAGA,IAAI,cAAmC,CAEvC;;CAGA,IAAI,YAAgC,CAEpC;;CAGA,UAAU,KAA+B;EACvC,OAAO,KAAK,MAAM,GAAG;CACvB;;CAGA,OAAO,OAAyB;EAC9B,OAAO;CACT;;CAGA,OAAO,OAAyB;EAC9B,OAAO;CACT;CAEA,GAAG,OAA8B;EAC/B,OAAO,KAAK,QAAQ,KAAK,KAAK;CAChC;CAEA,GAAG,OAA8B;EAC/B,OAAO,KAAK,QAAQ,MAAM,KAAK;CACjC;CAEA,GAAG,OAA8B;EAC/B,OAAO,KAAK,QAAQ,KAAK,KAAK;CAChC;CAEA,IAAI,OAA8B;EAChC,OAAO,KAAK,QAAQ,MAAM,KAAK;CACjC;CAEA,GAAG,OAA8B;EAC/B,OAAO,KAAK,QAAQ,KAAK,KAAK;CAChC;CAEA,IAAI,OAA8B;EAChC,OAAO,KAAK,QAAQ,MAAM,KAAK;CACjC;CAEA,GAAG,QAA+B;EAChC,OAAO,KAAK,OAAO,MAAM,MAAM;CACjC;CAEA,IAAI,QAA+B;EACjC,OAAO,KAAK,OAAO,UAAU,MAAM;CACrC;;CAGA,GAAG,SAA+B,GAAG,QAAiC;EACpE,MAAM,SAAS,IAAI,aAAa,SAAS,MAAM;EAC/C,OAAO,mBAAmB,QAAQ,cAAc,CAAC,KAAK,MAAM,GAAG,GAAG,OAAO,MAAM,GAAG,CAAC,GAAG,GAAG,CAAC;CAC5F;CAEA,QAA6B;EAC3B,OAAO,IAAI,OAAO,SAAS,CAAC,IAAI,GAAG;GACjC,QAAQ;GACR,QAAQ;GACR,QAAQ;GACR,YAAY;IAAE,QAAQ;IAAQ,QAAQ;IAAQ,kBAAkB;GAAK;EACvE,CAAC;CACH;CAEA,gBAAqC;EACnC,OAAO,IAAI,OAAO,SAAS,CAAC,IAAI,GAAG;GACjC,QAAQ;GACR,QAAQ;GACR,QAAQ;GACR,QAAQ;GACR,YAAY;IAAE,QAAQ;IAAQ,QAAQ;IAAQ,kBAAkB;GAAK;EACvE,CAAC;CACH;CAEA,MAAgC;EAC9B,OAAO,IAAI,OAAO,OAAO,CAAC,IAAI,GAAG;GAC/B,QAAQ;GACR,QAAQ;GACR,YAAY,2BAA2B,OAAO,KAAK,UAAU;EAC/D,CAAC;CACH;CAEA,MAAgC;EAC9B,OAAO,IAAI,OAAO,OAAO,CAAC,IAAI,GAAG;GAC/B,QAAQ;GACR,QAAQ;GACR,YAAY,2BAA2B,OAAO,KAAK,UAAU;EAC/D,CAAC;CACH;CAEA,MAAsB;EACpB,OAAO,IAAI,OAAO,OAAO,CAAC,IAAI,GAAG;GAC/B,SAAS,MAAM,KAAK,OAAO,CAAC;GAC5B,YAAY,iBAAiB,KAAK,UAAU;EAC9C,CAAC;CACH;CAEA,MAAsB;EACpB,OAAO,IAAI,OAAO,OAAO,CAAC,IAAI,GAAG;GAC/B,SAAS,MAAM,KAAK,OAAO,CAAC;GAC5B,YAAY,iBAAiB,KAAK,UAAU;EAC9C,CAAC;CACH;CAEA,SAAS,SAA2C;EAGlD,OAAO,IAAI,OAAO,aAAa,CAAC,IAAI,GAAG;GACrC,QAAQ,SAAS,WAAW,cAAc,KAAA;GAC1C,WAAW;GACX,SAAS,MAAO,MAAM,QAAQ,CAAC,IAAI,EAAE,KAAK,MAAM,KAAK,OAAO,CAAC,CAAC,IAAI;GAClE,SAAS,MAAO,MAAM,QAAQ,CAAC,IAAI,EAAE,KAAK,MAAM,KAAK,OAAO,CAAC,CAAC,IAAI;GAClE,YAAY,gBAAgB,KAAK,UAAU;EAC7C,CAAC;CACH;CAEA,UAAU,WAA6C;EACrD,OAAO,IAAI,OAAO,cAAc,CAAC,MAAM,IAAI,YAAY,SAAS,CAAC,GAAG,EAClE,YACE,KAAK,YAAY,WAAW,SAAS;GAAE,QAAQ;GAAQ,QAAQ;GAAQ,kBAAkB;EAAK,IAAI,KAAA,EACtG,CAAC;CACH;CAEA,SAAS,UAAqC;EAC5C,OAAO,IAAI,OAAO,YAAY,CAAC,MAAM,IAAI,YAAY,KAAK,OAAO,QAAQ,CAAC,CAAC,GAAG;GAC5E,SAAS,MAAM,KAAK,OAAO,CAAC;GAC5B,YAAY,KAAK;EACnB,CAAC;CACH;;CAGA,QAAkB,IAAY,OAA8B;EAC1D,IAAI,UAAU,KAAA,GAAW,OAAO;EAChC,IAAI,UAAU,MAAM;GAClB,MAAM,MAAM,OAAO,MAAM,KAAK,OAAO,OAAO,SAAS,KAAK,kBAAkB,GAAG,SAAS;GACxF,OAAO,mBAAmB,QAAQ;IAChC,MAAM,OAAO,KAAK,MAAM,GAAG;IAC3B,OAAO;KAAE,GAAG;KAAM,KAAK,GAAG,KAAK,IAAI,MAAM,IAAI;IAAM;GACrD,CAAC;EACH;EACA,IAAI,OAAO,KAAK,GACd,OAAO,mBAAmB,QAAQ,cAAc,CAAC,KAAK,MAAM,GAAG,GAAG,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC,GAAG,IAAI,GAAG,EAAE,CAAC;EAEzG,OAAO,mBAAmB,QAAQ;GAChC,MAAM,OAAO,KAAK,MAAM,GAAG;GAC3B,OAAO;IAAE,KAAK,GAAG,KAAK,IAAI,GAAG,GAAG;IAAK,UAAU,CAAC,GAAG,KAAK,UAAU,KAAK,OAAO,KAAK,CAAC;IAAG,MAAM,KAAK;GAAK;EACzG,CAAC;CACH;;CAGA,OAAiB,IAAqB,QAA+B;EACnE,IAAI,WAAW,KAAA,GAAW,OAAO;EACjC,IAAI,OAAO,MAAM,GACf,OAAO,mBAAmB,QAAQ;GAChC,MAAM,OAAO,KAAK,MAAM,GAAG;GAC3B,MAAM,QAAQ,OAAO,MAAM,CAAC,CAAC,UAAU,GAAG;GAC1C,OAAO,cAAc,CAAC,MAAM;IAAE,GAAG;IAAO,KAAK,IAAI,MAAM,IAAI;GAAG,CAAC,GAAG,IAAI,GAAG,EAAE;EAC7E,CAAC;EAEH,IAAI,CAAC,MAAM,QAAQ,MAAM,GAAG,KAAK,qCAAqC,GAAG,QAAQ,QAAQ;EACzF,MAAM,KAAK,OAAO,OAAO,aAAa;EACtC,OAAO,mBAAmB,QAAQ;GAChC,MAAM,OAAO,KAAK,MAAM,GAAG;GAC3B,OAAO;IACL,KAAK,GAAG,KAAK,IAAI,GAAG;IACpB,UAAU,CAAC,GAAG,KAAK,UAAU,OAAO,KAAK,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC;IAC9D,MAAM,KAAK;GACb;EACF,CAAC;CACH;AACF;;;;;;;;AASA,IAAa,SAAb,cAA4B,SAAS;CAEzB;CACA;CACA;CAHV,YACE,MACA,MACA,MAQA;EACA,MAAM;EAXE,KAAA,OAAA;EACA,KAAA,OAAA;EACA,KAAA,OAAA;CAUV;CAEA,IAAI,aAAmC;EACrC,OAAO,KAAK,KAAK;CACnB;CAEA,IAAI,cAAmC;EACrC,QAAQ,KAAK,MAAb;GACE,KAAK,SACH,OAAO;GACT,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK,cACH,OAAO;GACT,KAAK,YAEH,OAAO,KAAK,KAAK,EAAE,EAAE,gBAAgB,QAAQ,QAAQ,KAAA;GACvD,SACE;EACJ;CACF;;;;;CAMA,MAAM,KAA+B;EACnC,MAAM,OAAO,cACX,KAAK,KAAK,KAAK,MAAM,EAAE,MAAM,GAAG,CAAC,GACjC,IACF;EACA,MAAM,WAAW,eACd,KAAK,KAAK,WAAW,WAAW,CAAC,EAAA,CAAG,SAAS,UAAU;GACtD,IAAI,UAAU,KAAA,GAAW,OAAO,CAAC;GACjC,MAAM,WAAW,aAAa,OAAO,GAAG;GACxC,OAAO,WAAW,CAAC,QAAQ,IAAI,CAAC;EAClC,CAAC,GACD,IACF;EACA,MAAM,SAAS,KAAK,KAAK,WAAW;EACpC,MAAM,YAAY,WAAW,KAAA,IAAY,KAAA,IAAY,IAAI,eAAe,MAAM;EAC9E,OAAO;GACL,KAAK,GAAG,KAAK,KAAK,GAAG,KAAK,KAAK,UAAU,KAAK,KAAK,MAAM,SAAS,MAAM,aAAa,SAAS,QAAQ,GAAG,GAAG,YAAY,kBAAkB,UAAU,IAAI,KAAK,KAAK,KAAK,KAAK,UAAU;GACtL,UAAU;IAAC,GAAG,KAAK;IAAU,GAAG,SAAS;IAAU,GAAI,WAAW,YAAY,CAAC;GAAE;GACjF,MAAM;IAAC,GAAG,KAAK;IAAM,GAAG,SAAS;IAAM,GAAI,WAAW,QAAQ,CAAC;GAAE;EACnE;CACF;CAEA,OAAO,OAAyB;EAC9B,IAAI,UAAU,QAAQ,UAAU,KAAA,GAAW,OAAO;EAClD,OAAO,KAAK,KAAK,SAAS,KAAK,KAAK,OAAO,KAAK,IAAI;CACtD;CAEA,OAAO,OAAyB;EAC9B,OAAO,KAAK,KAAK,SAAS,KAAK,KAAK,OAAO,KAAK,IAAI,KAAK,KAAK,EAAE,CAAC,OAAO,KAAK;CAC/E;AACF;;AAGA,IAAa,cAAb,cAAiC,SAAS;CACpB;CAApB,YAAY,OAAwB;EAClC,MAAM;EADY,KAAA,QAAA;CAEpB;CAEA,IAAI,cAAuB;EACzB,OAAO,KAAK,UAAU,QAAQ,KAAK,UAAU,KAAA;CAC/C;CAEA,QAAqB;EACnB,OAAO;GAAE,KAAK;GAAK,UAAU,CAAC,KAAK,KAAK;GAAG,MAAM,CAAC;EAAE;CACtD;AACF;;AAGA,IAAa,UAAb,cAA6B,SAAS;CAE1B;CACA;CAFV,YACE,QACA,QACA;EACA,MAAM;EAHE,KAAA,SAAA;EACA,KAAA,SAAA;CAGV;CAEA,IAAI,YAAoB;EACtB,OAAO,KAAK;CACd;CAEA,MAAM,KAA+B;EACnC,MAAM,QAAQ,IAAI,SAAS,KAAK,MAAM;EAEtC,OAAO;GAAE,KAAK,GAAG,OAAO,KAAK,EAAE,GAAG,OAAO,KAAK,MAAM;GAAK,UAAU,CAAC;GAAG,MAAM,CAAC,KAAK;EAAE;CACvF;AACF;;;;;;;;;;;;AAaA,IAAa,eAAb,cAAkC,SAAS;CAE/B;CACA;CAFV,YACE,SACA,QACA;EACA,MAAM;EAHE,KAAA,UAAA;EACA,KAAA,SAAA;CAGV;CAEA,MAAM,KAA+B;EACnC,MAAM,QAAuB,CAAC;EAC9B,KAAK,QAAQ,SAAS,GAAG,MAAM;GAC7B,MAAM,KAAK;IAAE,KAAK;IAAG,UAAU,CAAC;IAAG,MAAM,CAAC;GAAE,CAAC;GAC7C,IAAI,IAAI,KAAK,OAAO,QAAQ,MAAM,KAAK,mBAAmB,KAAK,OAAO,IAAI,GAAG,CAAC;EAChF,CAAC;EACD,OAAO,cAAc,OAAO,EAAE;CAChC;AACF;;AAGA,SAAgB,mBAAmB,OAAgB,KAA+B;CAChF,IAAI,OAAO,KAAK,GACd,OAAO,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG;MACzB,IAAI,gBAAgB,KAAK,GAC9B,OAAO,IAAI,eAAe,KAAqB,KAAK;EAAE,KAAK;EAAQ,UAAU,CAAC;EAAG,MAAM,CAAC;CAAE;MAE1F,OAAO;EAAE,KAAK;EAAK,UAAU,CAAC,KAAK;EAAG,MAAM,CAAC;CAAE;AAEnD;;AAGA,SAAgB,gBAAgB,OAAyB;CACvD,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,MAAM,IAAI;CACV,OAAO,SAAS,KAAK,QAAQ,KAAK,EAAE,SAAS,YAAY,EAAE,SAAS,SAAS,EAAE,SAAS;AAC1F;;;;;;;AAQA,SAAS,2BAA2B,MAAqB,YAAwD;CAC/G,QAAQ,YAAY,QAApB;EACE,KAAK;EACL,KAAK,QACH,OAAO;GAAE,QAAQ,SAAS,QAAQ,SAAS;GAAW,QAAQ;GAAQ,kBAAkB;EAAK;EAC/F,KAAK;EACL,KAAK,WACH,OAAO;GAAE,QAAQ;GAAW,QAAQ;GAAQ,kBAAkB;EAAK;EACrE,KAAK,UACH,OAAO;GAAE,QAAQ,SAAS,QAAQ,WAAW;GAAU,QAAQ;GAAQ,kBAAkB;EAAK;EAChG,KAAK,UACH,OAAO;GAAE,QAAQ;GAAU,QAAQ;GAAQ,kBAAkB;EAAK;EACpE,SACE;CACJ;AACF;;AAGA,SAAS,iBAAiB,YAAwD;CAChF,QAAQ,YAAY,QAApB;EACE,KAAK;EACL,KAAK,QACH,OAAO;GAAE,GAAG;GAAY,QAAQ;EAAO;EACzC,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,QACH,OAAO;EACT,SACE;CACJ;AACF;;AAGA,SAAS,aAAa,OAAyB;CAC7C,OAAO,OAAO,UAAU,WAAW,OAAO,KAAK,IAAI;AACrD;;AAGA,SAAgB,aAAa,GAAsB,KAA2C;CAC5F,IAAI,EAAE,EAAE,gBAAgB,WACtB,OAAO,KAAK,+FAA+F;CAE7G,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,MAAM,QAAQ,QAAQ,UAAU,QAAQ,WAAW,QAAQ,OAAO,GACnF,OAAO,KAAK,+DAA+D;CAE7E,IAAI,EAAE,UAAU,KAAA,GAAW,OAAO,KAAA;CAClC,IAAI,EAAE,UAAU,SAAS,EAAE,UAAU,QACnC,OAAO,KAAK,8BAA8B,EAAE,MAAM,EAAE;CAGtD,IAAI,EAAE,UAAU,KAAA,KAAa,EAAE,UAAU,WAAW,EAAE,UAAU,QAC9D,OAAO,KAAK,0BAA0B,EAAE,MAAM,EAAE;CAElD,MAAM,WAAW,EAAE,KAAK,MAAM,GAAG;CACjC,MAAM,QAAQ,EAAE,QAAQ,UAAU,EAAE,MAAM,YAAY,MAAM;CAC5D,OAAO;EAAE,GAAG;EAAU,KAAK,GAAG,SAAS,IAAI,GAAG,EAAE,QAAQ;CAAQ;AAClE;AAEA,SAAS,SAAS,OAAyB;CACzC,OAAO;AACT;AAEA,SAAS,KAAK,SAAwB;CACpC,MAAM,IAAI,MAAM,OAAO;AACzB"}

package/build/QueryParser.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryParser.cjs","names":["ConditionBuilder","abbreviation","getBaseMeta","isScope","isAlias","kq","kqDot","getAliasMgmt","resolveScope","newAlias","isScopeJoinFilter","fail","getConstructorFromTaggedId","groupBy","keyToNumber","maybeResolveReferenceToId","getMaybeCtiAlias","alias","getMetadataForTable","isEntity","isPlainObject","assertNever","isDefined","isDeferredCondition","predicateBrand","isDeferredAliasCondition","deferredAliasSym"],"sources":["../src/QueryParser.ts"],"sourcesContent":["import { groupBy, isPlainObject } from \"joist-utils\";\n\nimport { type AliasMgmt, getAliasMgmt, getMaybeCtiAlias, isAlias, alias as newAlias } from \"./Aliases.ts\";\nimport { type ConditionInput, predicateBrand } from \"./conditions.ts\";\nimport { getMetadataForTable } from \"./configure.ts\";\nimport { deferredAliasSym, isDeferredAliasCondition } from \"./DeferredAlias.ts\";\nimport { type Entity, isEntity } from \"./Entity.ts\";\nimport { type ExpressionFilter, type OrderBy, type ValueFilter } from \"./EntityFilter.ts\";\nimport { type EntityMetadata, type Field, getBaseMeta } from \"./EntityMetadata.ts\";\nimport { isDeferredCondition } from \"./Expr.ts\";\nimport {\n  type Column,\n  ConditionBuilder,\n  getConstructorFromTaggedId,\n  isDefined,\n  keyToNumber,\n  maybeResolveReferenceToId,\n} from \"./index.ts\";\nimport { kq, kqDot } from \"./keywords.ts\";\nimport { pruneUnusedJoins } from \"./QueryParser.pruning.ts\";\nimport { visitConditions } from \"./QueryVisitor.ts\";\nimport { type Scope, isScope, isScopeJoinFilter, resolveScope } from \"./scopes.ts\";\nimport { abbreviation, assertNever, fail } from \"./utils.ts\";\n\n/** A tree of ANDs/ORs with conditions or nested conditions. */\nexport interface ParsedExpressionFilter {\n  kind: \"exp\";\n  op: \"and\" | \"or\";\n  conditions: ParsedExpressionCondition[];\n}\n\n/** A condition or nested condition in a `ParsedExpressionFilter`. */\nexport type ParsedExpressionCondition = ParsedExpressionFilter | ColumnCondition | RawCondition | ExistsCondition;\n\nexport interface ColumnCondition {\n  kind: \"column\";\n  alias: string;\n  column: string;\n  dbType: string;\n  cond: ParsedValueFilter<any>;\n  /**\n   * A pruneable condition is one that was auto-added by something like soft-delete, and shouldn't\n   * be something that marks a join as actually used by the user's query.\n   */\n  pruneable?: boolean;\n}\n\n/** A user-provided condition like `SUM(${alias}.amount) > 1000` or `a1.last_name = b1.title`. */\nexport interface RawCondition {\n  kind: \"raw\";\n  /** The aliases, i.e. `[a, b]`, used within the condition, to ensure we don't prune them. */\n  aliases: string[];\n  /** The condition itself, i.e. `SUM(a.age) DESC`. */\n  condition: string;\n  /** The bindings within `condition`, i.e. `SUM(${alias}.amount) > ?`. */\n  bindings: readonly any[];\n  /** Used to mark system-added conditions (like `LATERAL JOIN` conditions), which can be ignored when pruning unused joins. */\n  pruneable: boolean;\n}\n\n/** An EXISTS or NOT EXISTS subquery condition. */\nexport interface ExistsCondition {\n  kind: \"exists\";\n  /** When true, renders as NOT EXISTS. */\n  negate: boolean;\n  /** The subquery: SELECT 1 FROM child WHERE correlation AND filter. */\n  subquery: ParsedFindQuery;\n  /** Outer aliases referenced by the correlation predicate, for join pruning. */\n  outerAliases: string[];\n}\n\n// `skipCondition` lives in its own leaf module, shared by domain aliases and SQL expressions\n// without a load-order cycle; `index.ts` re-exports it directly.\n\nexport interface PrimaryTable {\n  join: \"primary\";\n  alias: string;\n  table: string;\n}\n\nexport interface JoinTable {\n  join: \"inner\" | \"outer\";\n  alias: string;\n  table: string;\n  col1: string;\n  col2: string;\n  distinct?: boolean;\n  /**\n   * Metadata used by `optimizeCollectionJoins` to rewrite collection joins into EXISTS.\n   *\n   * I.e. for `Author.books.reviews`:\n   * ```sql\n   * authors a\n   * LEFT JOIN books b ON a.id = b.author_id\n   * LEFT JOIN book_reviews br ON b.id = br.book_id\n   * ```\n   * `books b` has `parentAlias: \"a\"` and `rootAlias: \"b\"`, while `book_reviews br` has\n   * `parentAlias: \"b\"` and `rootAlias: \"br\"`.\n   *\n   * I.e. for `Author.tags`, the m2m join table is the collection root:\n   * ```sql\n   * authors a\n   * LEFT JOIN authors_to_tags att ON a.id = att.author_id\n   * LEFT JOIN tags t ON att.tag_id = t.id\n   * ```\n   * `authors_to_tags att` has `alias: \"att\"` and `rootAlias: \"att\"`, while `tags t` has `alias: \"t\"`\n   * but still has `rootAlias: \"att\"` because it belongs to the m2m subtree rooted at the join table.\n   */\n  collection?: {\n    /** The collection relation type, i.e. `o2m` for `Author.books`, or `m2m` for `Author.tags`. */\n    kind: \"o2m\" | \"m2m\";\n    /** The alias that owns this collection path, i.e. `a` for `Author.books`, or `att` for `Author.tags -> tags`. */\n    parentAlias: string;\n    /** The top-level alias in this collection subtree, i.e. `b` for `Author.books.reviews`, or `att` for `Author.tags`. */\n    rootAlias: string;\n  };\n}\n\n/**\n * Creates a `CROSS JOIN`, currently used for our `em.find` batching.\n *\n * I.e. queries like:\n *\n * ```sql\n * WITH _find (tag, arg1, arg2) AS (VALUES\n *   (0::int, 'a'::varchar, 'a'::varchar),\n *   (1, 'b', 'b'),\n *   (2, 'c', 'c')\n * )\n * SELECT a.*, array_agg(_find.tag) AS _tags\n * FROM authors a\n * CROSS JOIN _find AS _find\n * WHERE a.first_name = _find.arg0 OR a.last_name = _find.arg1\n * GROUP BY a.id\n * ```\n */\nexport interface CrossJoinTable {\n  join: \"cross\";\n  /** The new alias for the joined table. */\n  alias: string;\n  /** The table name to join into the query. */\n  table: string;\n}\n\n/**\n * Adds `WITH` CTE clauses to the query.\n *\n * I.e. queries like:\n *\n * ```sql\n * WITH _find (tag, arg0, arg1) AS (\n *   VALUES ($1::int, $2::character varying, $3::character varying), ($4, $5, $6)\n * )\n * ```\n */\nexport interface ParsedCteClause {\n  /** The new alias for the CTE, i.e. `_find` in the above query. */\n  alias: string;\n  /** The columns, i.e. `tag, arg0, arg1` in the above query. */\n  columns?: { columnName: string; dbType: string }[];\n  /** The subquery for the AS of the CTE clause. */\n  query: { kind: \"raw\"; sql: string; bindings: readonly any[] } | { kind: \"ast\"; query: ParsedFindQuery };\n  /** Whether to include a `RECURSIVE` keyword after the `WITH`. */\n  recursive?: boolean;\n}\n\n/**\n * Creates `LATERAL JOIN`s, currently used by `findCount` and JSON preloading.\n */\nexport interface LateralJoinTable {\n  join: \"lateral\";\n  alias: string;\n  /** Used for join dependency tracking. */\n  fromAlias: string;\n  /** Used more for bookkeeping/consistency with other join tables than the query itself. */\n  table: string;\n  /** The subquery that will look for/roll-up N children. */\n  query: ParsedFindQuery;\n  /** Optional settings for the subquery, i.e. per-parent pagination. */\n  settings?: { limit?: number; offset?: number };\n}\n\nexport type ParsedTable = PrimaryTable | JoinTable | CrossJoinTable | LateralJoinTable;\n\nexport interface ParsedOrderBy {\n  alias: string;\n  column: string;\n  order: OrderBy;\n}\n\nexport type ParsedGroupBy = { alias: string; column: string } | { expression: string };\n\nexport type ParsedSelect = string | ParsedSelectWithBindings;\ntype ParsedSelectWithBindings = { sql: string; bindings: any[]; aliases: string[] };\n\n/** The result of parsing an `em.find` filter. */\nexport interface ParsedFindQuery {\n  selects: ParsedSelect[];\n  /** The primary table plus any joins. */\n  tables: ParsedTable[];\n  /** The query's conditions. */\n  condition?: ParsedExpressionFilter;\n  /** Extremely optional group bys; we generally don't support adhoc/aggregate queries, but the auto-batching infra uses these. */\n  groupBys?: ParsedGroupBy[];\n  /** Any optional orders to add before the default 'order by id'. */\n  orderBys: ParsedOrderBy[];\n  /** Optional CTE to prefix to the query, i.e. for recursive relations. */\n  ctes?: ParsedCteClause[];\n}\n\n/**\n * Parses an `em.find` filter into a logical `ParsedFindQuery` AST, leaving optimization/pruning to callers.\n *\n * The main execution flow is:\n * parseFindQuery -> beforeFind plugins -> optimizeCollectionJoins -> pruneUnusedJoins -> execute SQL.\n */\nexport function parseFindQuery(\n  meta: EntityMetadata,\n  filter: any,\n  opts: {\n    conditions?: ExpressionFilter;\n    orderBy?: any;\n    pruneJoins?: boolean;\n    keepAliases?: string[];\n    softDeletes?: \"include\" | \"exclude\";\n    allowMultipleLeftJoins?: boolean;\n    optimizeJoinsToExists?: boolean;\n  } = {},\n): ParsedFindQuery {\n  const selects: string[] = [];\n  const tables: ParsedTable[] = [];\n  const orderBys: ParsedOrderBy[] = [];\n  const query: ParsedFindQuery = { selects, tables, orderBys };\n  const { orderBy, conditions: optsExpression, softDeletes = \"exclude\", pruneJoins = false, keepAliases = [] } = opts;\n  const cb = new ConditionBuilder();\n  // Where each user-created `alias(...)` is bound in this parse's join literal; alias-built conditions\n  // (`a.firstName.eq(...)`) are resolved against it once the whole tree is walked\n  const aliasBindings = new Map<AliasMgmt, { meta: EntityMetadata; alias: string }>();\n\n  const aliases: Record<string, number> = {};\n  function getAlias(tableName: string): string {\n    const abbrev = abbreviation(tableName);\n    const i = aliases[abbrev] || 0;\n    aliases[abbrev] = i + 1;\n    return i === 0 ? abbrev : `${abbrev}${i}`;\n  }\n\n  /** Adds a `deleted_at IS NULL` condition for `alias`, i.e. for the primary table or a collection join. */\n  function addSoftDeleteCondition(meta: EntityMetadata, alias: string, targetCb: ConditionBuilder): void {\n    if (filterSoftDeletes(meta, softDeletes)) {\n      const column = meta.allFields[getBaseMeta(meta).timestampFields!.deletedAt!].serde?.columns[0]!;\n      targetCb.addSimpleCondition({\n        kind: \"column\",\n        alias,\n        column: column.columnName,\n        dbType: column.dbType,\n        cond: { kind: \"is-null\" },\n        pruneable: true,\n      });\n    }\n  }\n\n  function addTable(\n    meta: EntityMetadata,\n    alias: string,\n    join: ParsedTable[\"join\"],\n    col1: string,\n    col2: string,\n    filter: any,\n    fieldName?: string,\n    targetCb: ConditionBuilder = cb,\n    /** Whether this table is the \"other side\" of a collection, i.e. `books` in `em.find(Author, { books: ... })`. */\n    isCollection: boolean = false,\n  ): void {\n    // look at filter, is it `{ book: \"b2\" }` or `{ book: { ... } }`\n    const scopeFilter = isScope(filter);\n    const ef = scopeFilter ? undefined : parseEntityFilter(meta, filter);\n    if (!scopeFilter && !ef && join !== \"primary\" && !isAlias(filter)) {\n      return;\n    }\n\n    if (join === \"primary\") {\n      tables.push({ alias, table: meta.tableName, join });\n      addTablePerClassJoinsAndClassTag({ selects, tables, orderBys }, meta, alias, true);\n    } else if (meta.inheritanceType === \"cti\" && fieldName && !(fieldName in meta.fields)) {\n      // For cti, our meta might be a subtype while the FK is actually on the base table.  This should only be the case\n      // 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\n      // its directly in our meta, if not we should assume it's in the base type and join that in first.\n      meta.baseTypes.forEach((bt, i) => {\n        tables.push({\n          alias: `${alias}_b${i}`,\n          table: bt.tableName,\n          join: \"outer\",\n          col1,\n          col2: `${kq(`${alias}_b${i}`)}.${col2.split(\".\")[1]}`,\n          distinct: false,\n        });\n        // and we still need to join in our subtype as well in case its own fields are queried against\n        tables.push({\n          alias: `${alias}`,\n          table: meta.tableName,\n          join: \"outer\",\n          col1: kqDot(alias, \"id\"),\n          col2: kqDot(`${alias}_b${i}`, \"id\"),\n          distinct: false,\n        });\n      });\n    } else if (join === \"lateral\" || join === \"cross\") {\n      fail(\"Unexpected lateral join\");\n    } else {\n      tables.push({ alias, table: meta.tableName, join, col1, col2 });\n      // Maybe only do this if we're the primary, or have a field that needs it?\n      addTablePerClassJoinsAndClassTag({ selects, tables, orderBys }, meta, alias, false);\n    }\n\n    if (needsStiDiscriminator(meta)) {\n      addStiSubtypeFilter(targetCb, meta, alias);\n    }\n\n    // Only the primary table & collection joins filter soft-deletes, to match the in-memory relation\n    // semantics of \"o2m/m2m collections filter out soft-deletes, but m2o/o2o references still return\n    // them\". I.e. `book.author.get` returns a soft-deleted author, so `em.find(Book, { author: ... })`\n    // should still match the book, as long as the book itself is not soft-deleted.\n    if (join === \"primary\" || isCollection) {\n      addSoftDeleteCondition(meta, alias, targetCb);\n    }\n\n    // The user's locally declared aliases, i.e. `const [a, b] = aliases(Author, Book)`,\n    // aren't guaranteed to line up with the aliases we've assigned internally, like `a`\n    // might actually be `a1` if there are two `authors` tables in the query, so push the\n    // canonical alias value for the current clause into the Alias.\n    if (filter && typeof filter === \"object\" && \"as\" in filter && isAlias(filter.as)) {\n      aliasBindings.set(getAliasMgmt(filter.as), { meta, alias });\n    } else if (isAlias(filter)) {\n      aliasBindings.set(getAliasMgmt(filter), { meta, alias });\n    }\n\n    addFilterAt(meta, alias, filter, targetCb, ef, join);\n  }\n\n  function addFilterAt(\n    meta: EntityMetadata,\n    tableAlias: string,\n    filter: any,\n    targetCb: ConditionBuilder,\n    parsed: ParsedEntityFilter | undefined = parseEntityFilter(meta, filter),\n    parentJoin: ParsedTable[\"join\"] = \"primary\",\n  ): void {\n    if (isScope(filter)) {\n      addScopeFilterAt(meta, tableAlias, filter, targetCb, parentJoin);\n    } else if (parsed && parsed.kind === \"join\") {\n      addSubFilter(meta, tableAlias, parsed.subFilter, targetCb, parentJoin);\n    } else if (parsed) {\n      const column = meta.fields[\"id\"].serde!.columns[0];\n      targetCb.addValueFilter(tableAlias, column, parsed);\n    }\n  }\n\n  function addScopeFilterAt<T extends Entity>(\n    meta: EntityMetadata<T>,\n    tableAlias: string,\n    scope: Scope<T>,\n    targetCb: ConditionBuilder,\n    parentJoin: ParsedTable[\"join\"],\n  ): void {\n    for (const fragment of resolveScope(scope).fragments) {\n      if (fragment.kind === \"filter\") {\n        addFilterAt(meta, tableAlias, fragment.filter, targetCb, undefined, parentJoin);\n      } else {\n        const a = newAlias(meta.cstr);\n        const result = fragment.fn(a);\n        aliasBindings.set(getAliasMgmt(a), { meta, alias: tableAlias });\n        if (isScopeJoinFilter(result)) {\n          // Parse the join tree first so its `as:` bindings re-root the aliases that\n          // `conditions` reference, then add the conditions against the now-bound aliases.\n          addFilterAt(meta, tableAlias, result.where, targetCb, undefined, parentJoin);\n          checkDomainCondition(result.conditions);\n          targetCb.maybeAddExpression(result.conditions);\n        } else {\n          const conditions = Array.isArray(result) ? result : [result];\n          for (const condition of conditions) checkDomainCondition(condition);\n          if (conditions.length > 0) targetCb.maybeAddExpression({ and: conditions });\n        }\n      }\n    }\n  }\n\n  function addSubFilter(\n    meta: EntityMetadata,\n    tableAlias: string,\n    subFilter: object,\n    targetCb: ConditionBuilder,\n    parentJoin: ParsedTable[\"join\"],\n  ): void {\n    // subFilter really means we're matching against the entity columns/further joins\n    Object.keys(subFilter).forEach((key) => {\n      // Skip the `{ as: ... }` alias binding\n      if (key === \"as\") return;\n      if (key === \"and\" || key === \"or\") {\n        addLogicalFilter(meta, tableAlias, key, (subFilter as any)[key], targetCb, parentJoin);\n        return;\n      }\n      const field = findFilterField(meta, key) ?? fail(`Field '${key}' not found on ${meta.tableName}`);\n      const fa = `${tableAlias}${field.aliasSuffix}`;\n      if (field.kind === \"primitive\" || field.kind === \"primaryKey\" || field.kind === \"enum\") {\n        const column = field.serde.columns[0];\n        parseValueFilter((subFilter as any)[key]).forEach((filter) => {\n          targetCb.addValueFilter(fa, column, filter);\n        });\n      } else if (field.kind === \"m2o\") {\n        const column = field.serde.columns[0];\n        const sub = (subFilter as any)[key];\n        const joinKind = field.required && parentJoin !== \"outer\" ? \"inner\" : \"outer\";\n        if (isAlias(sub)) {\n          const a = getAlias(field.otherMetadata().tableName);\n          addTable(\n            field.otherMetadata(),\n            a,\n            joinKind,\n            kqDot(fa, column.columnName),\n            kqDot(a, \"id\"),\n            sub,\n            undefined,\n            targetCb,\n          );\n        }\n        const f = parseEntityFilter(field.otherMetadata(), sub);\n        // Probe the filter and see if it's just an id, if so we can avoid the join; m2os don't need\n        // a join for soft-delete filtering because references don't filter out soft-deletes.\n        if (!f) {\n          // skip\n        } else if (f.kind === \"join\") {\n          const a = getAlias(field.otherMetadata().tableName);\n          addTable(\n            field.otherMetadata(),\n            a,\n            joinKind,\n            kqDot(fa, column.columnName),\n            kqDot(a, \"id\"),\n            sub,\n            undefined,\n            targetCb,\n          );\n        } else {\n          targetCb.addValueFilter(fa, column, f);\n        }\n      } else if (field.kind === \"poly\") {\n        const f = parseEntityFilter(meta, (subFilter as any)[key]);\n        if (!f) {\n          // skip\n        } else if (f.kind === \"join\") {\n          throw new Error(\"Joins through polys are not supported\");\n        } else {\n          // We're left with basically a ValueFilter against the ids\n          // For now only support eq/ne/in/is-null\n          if (f.kind === \"eq\" || f.kind === \"ne\") {\n            if (isNilIdValue(f.value)) return;\n            const comp = field.components.find((p) => {\n              const otherMeta = p.otherMetadata();\n              const cstr = getConstructorFromTaggedId(f.value as string);\n              // tagged ids from subclasses always map to the base class, so we should compare to the base class if we don't directly match\n              return otherMeta.cstr === cstr || otherMeta.baseType === cstr.name;\n            });\n            if (!comp) fail(`Invalid tagged id passed to ${meta.type}.${key}: ${f.value}`);\n            const column = field.serde.columns.find((c) => c.columnName === comp.columnName)!;\n            targetCb.addValueFilter(fa, column, f);\n          } else if (f.kind === \"is-null\") {\n            // Add a condition for every component--these can be AND-d with the rest of the simple/inline conditions\n            field.components.forEach((comp) => {\n              const column = field.serde.columns.find((c) => c.columnName === comp.columnName)!;\n              targetCb.addSimpleCondition({\n                kind: \"column\",\n                alias: fa,\n                column: comp.columnName,\n                dbType: column.dbType,\n                cond: f,\n              });\n            });\n          } else if (f.kind === \"not-null\") {\n            const conditions = field.components.map((comp) => {\n              const column = field.serde.columns.find((c) => c.columnName === comp.columnName)!;\n              return {\n                kind: \"column\",\n                alias: fa,\n                column: comp.columnName,\n                dbType: column.dbType,\n                cond: { kind: \"not-null\" },\n              };\n            }) satisfies ColumnCondition[];\n            targetCb.addParsedExpression({ kind: \"exp\", op: \"or\", conditions });\n          } else if (f.kind === \"in\") {\n            // An empty `in` matches nothing, so emit a single always-false condition (consistent\n            // with a non-poly m2o `{ relation: [] }`); otherwise grouping by constructor would yield\n            // zero conditions and prune the filter entirely, incorrectly matching every row.\n            if (f.value.length === 0) {\n              targetCb.addValueFilter(fa, field.serde.columns[0], { kind: \"in\", value: [] });\n              return;\n            }\n            // Split up the ids by constructor\n            const idsByConstructor = groupBy(f.value, (id) => getConstructorFromTaggedId(id as string).name);\n            // Or together `parent_book_id in (1,2,3) OR parent_author_id IN (4,5,6)`\n            // ...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)`...\n            const conditions = Object.entries(idsByConstructor).map(([cstrName, ids]) => {\n              const column =\n                field.serde.columns.find(\n                  // tagged ids from subclasses always map to the base class, so we should compare to the base class if we don't directly match\n                  (c) => c.otherMetadata().cstr.name === cstrName || c.otherMetadata().baseType === cstrName,\n                ) ?? fail(`Invalid tagged ids passed to ${meta.type}.${key}: ${ids}`);\n              return {\n                kind: \"column\",\n                alias: fa,\n                column: column.columnName,\n                dbType: column.dbType,\n                cond: mapToDb(column, { kind: \"in\", value: ids }),\n              } satisfies ColumnCondition;\n            });\n            targetCb.addParsedExpression({ kind: \"exp\", op: \"or\", conditions });\n          } else {\n            throw new Error(`Filters on polys for ${f.kind} are not supported`);\n          }\n        }\n      } else if (field.kind === \"o2o\") {\n        // We have to always join into o2os, i.e. we can't probe the filter like we do for m2os\n        const otherMeta = field.otherMetadata();\n        const a = getAlias(otherMeta.tableName);\n        const otherField = otherMeta.allFields[field.otherFieldName];\n        const otherColumn =\n          // if our other is a poly, we need to find a matching column rather than just picking the first\n          otherField.kind === \"poly\"\n            ? otherField.components.find((c) => c.otherMetadata() === meta || c.otherMetadata() === getBaseMeta(meta))!\n                .columnName\n            : otherField.serde!.columns[0].columnName;\n        addTable(\n          field.otherMetadata(),\n          a,\n          \"outer\",\n          kqDot(tableAlias, \"id\"),\n          kqDot(a, otherColumn),\n          (subFilter as any)[key],\n          field.otherFieldName,\n          targetCb,\n        );\n      } else if (field.kind === \"o2m\") {\n        const otherMeta = field.otherMetadata();\n        const otherField = otherMeta.allFields[field.otherFieldName];\n        let otherColumn = otherField.serde!.columns[0].columnName;\n        if (otherField.kind === \"poly\") {\n          const otherComponent =\n            otherField.components.find((c) => c.otherMetadata() === meta) ??\n            fail(`No poly component found for ${otherField.fieldName}`);\n          otherColumn = otherComponent.columnName;\n        }\n        const isCtiBaseFk =\n          otherMeta.inheritanceType === \"cti\" && field.otherFieldName && !(field.otherFieldName in otherMeta.fields);\n        const a = getAlias(otherMeta.tableName);\n        addTable(\n          otherMeta,\n          a,\n          \"outer\",\n          kqDot(tableAlias, \"id\"),\n          kqDot(a, otherColumn),\n          (subFilter as any)[key],\n          field.otherFieldName,\n          targetCb,\n          true,\n        );\n        if (!isCtiBaseFk) {\n          const table = tables.find((t) => t.alias === a);\n          if (table && (table.join === \"inner\" || table.join === \"outer\")) {\n            table.collection = { parentAlias: tableAlias, rootAlias: a, kind: \"o2m\" };\n          }\n        }\n      } else if (field.kind === \"m2m\") {\n        const sub = (subFilter as any)[key];\n        const f = parseEntityFilter(field.otherMetadata(), sub);\n        if (!f && !isAlias(sub)) return;\n\n        const ja = getAlias(field.joinTableName);\n        tables.push({\n          join: \"outer\",\n          alias: ja,\n          table: field.joinTableName,\n          col1: kqDot(tableAlias, \"id\"),\n          col2: kqDot(ja, field.columnNames[0]),\n          collection: { parentAlias: tableAlias, rootAlias: ja, kind: \"m2m\" },\n        });\n\n        if (isAlias(sub) || f?.kind === \"join\" || filterSoftDeletes(field.otherMetadata(), softDeletes)) {\n          const a = getAlias(field.otherMetadata().tableName);\n          addTable(\n            field.otherMetadata(),\n            a,\n            \"outer\",\n            kqDot(ja, field.columnNames[1]),\n            kqDot(a, \"id\"),\n            sub,\n            undefined,\n            targetCb,\n            true,\n          );\n          const table = tables.find((t) => t.alias === a);\n          if (table && (table.join === \"inner\" || table.join === \"outer\")) {\n            table.collection = { parentAlias: ja, rootAlias: ja, kind: \"m2m\" };\n          }\n        } else if (f) {\n          const otherMeta = field.otherMetadata();\n          const column: any = {\n            columnName: field.columnNames[1],\n            dbType: otherMeta.idDbType,\n            mapToDb(value: any) {\n              return value === null || isNilIdValue(value)\n                ? value\n                : keyToNumber(otherMeta, maybeResolveReferenceToId(value));\n            },\n          };\n          targetCb.addSimpleCondition({\n            kind: \"column\",\n            alias: ja,\n            column: field.columnNames[1],\n            dbType: otherMeta.idDbType,\n            cond: mapToDb(column, f),\n          });\n        }\n      } else if (field.kind === \"m2mEnum\") {\n        // Membership filter, e.g. `{ logoColors: Color.Red }` / `{ logoColors: [Red, Green] }`: join the\n        // join table and filter its enum-id column, mapping enum codes -> their numeric ids.\n        const ja = getAlias(field.joinTableName);\n        tables.push({\n          join: \"outer\",\n          alias: ja,\n          table: field.joinTableName,\n          col1: kqDot(tableAlias, \"id\"),\n          col2: kqDot(ja, field.columnNames[0]),\n          collection: { parentAlias: tableAlias, rootAlias: ja, kind: \"m2m\" },\n        });\n        const column: any = {\n          columnName: field.columnNames[1],\n          dbType: \"int\",\n          mapToDb(value: any) {\n            return value === null || value === undefined ? value : field.enumDetailType.getByCode(value).id;\n          },\n        };\n        parseValueFilter((subFilter as any)[key]).forEach((filter) => {\n          targetCb.addValueFilter(ja, column, filter);\n        });\n      } else {\n        throw new Error(`Unsupported field ${key}`);\n      }\n    });\n  }\n\n  function addLogicalFilter(\n    meta: EntityMetadata,\n    tableAlias: string,\n    op: \"and\" | \"or\",\n    value: unknown,\n    targetCb: ConditionBuilder,\n    parentJoin: ParsedTable[\"join\"],\n  ): void {\n    const filters = Array.isArray(value) ? value : [value];\n    const conditions = filters.flatMap((filter) => {\n      const branchCb = new ConditionBuilder();\n      addFilterAt(meta, tableAlias, filter, branchCb, undefined, parentJoin);\n      const condition = branchCb.toExpressionFilter();\n      return condition ? [condition] : [];\n    });\n    if (conditions.length > 0) targetCb.addParsedExpression({ kind: \"exp\", op, conditions });\n  }\n\n  function addOrderBy(meta: EntityMetadata, alias: string, orderBy: Record<string, any>): void {\n    const entries = Object.entries(orderBy);\n    if (entries.length === 0) return;\n    for (const [key, value] of entries) {\n      if (!value) continue; // prune undefined\n      const field = meta.allFields[key] ?? fail(`${key} not found on ${meta.tableName}`);\n      if (field.kind === \"primitive\" || field.kind === \"primaryKey\" || field.kind === \"enum\") {\n        const column = field.serde.columns[0];\n        orderBys.push({\n          alias: `${alias}${field.aliasSuffix ?? \"\"}`,\n          column: column.columnName,\n          order: value as OrderBy,\n        });\n      } else if (field.kind === \"m2o\") {\n        // Do we already this table joined in?\n        let table = tables.find((t) => t.table === field.otherMetadata().tableName);\n        if (table) {\n          addTablePerClassJoinsAndClassTag(query, field.otherMetadata(), table.alias, false);\n          addOrderBy(field.otherMetadata(), table.alias, value);\n        } else {\n          const table = field.otherMetadata().tableName;\n          const a = getAlias(table);\n          const column = field.serde.columns[0].columnName;\n          const fa = getMaybeCtiAlias(meta, field, meta, alias);\n          // If we don't have a join, don't force this to be an inner join\n          tables.push({\n            alias: a,\n            table,\n            join: \"outer\",\n            col1: kqDot(fa, column),\n            col2: kqDot(a, \"id\"),\n            distinct: false,\n          });\n          addTablePerClassJoinsAndClassTag(query, field.otherMetadata(), a, false);\n          addOrderBy(field.otherMetadata(), a, value);\n        }\n      } else {\n        throw new Error(`Unsupported field ${key}`);\n      }\n    }\n  }\n\n  // always add the main table\n  const alias = getAlias(meta.tableName);\n  if (meta.hasLazyColumns) {\n    selects.push(...lazyExcludedSelects(meta, alias));\n  } else {\n    selects.push(`${kq(alias)}.*`);\n  }\n  addTable(meta, alias, \"primary\", \"n/a\", \"n/a\", filter);\n\n  // If they passed extra `conditions: ...`, parse that\n  if (optsExpression) {\n    checkDomainCondition(optsExpression);\n    cb.maybeAddExpression(optsExpression);\n  }\n\n  Object.assign(query, {\n    condition: cb.toExpressionFilter(),\n  });\n\n  // Resolve alias-built conditions against this parse's bindings, before anything reads their\n  // aliases (the id-not-null injection just below, and join pruning)\n  resolveAliasConditions(query, aliasBindings);\n\n  if (query.tables.some((t) => t.join === \"outer\")) {\n    maybeAddIdNotNulls(query);\n  }\n\n  if (orderBy) {\n    if (Array.isArray(orderBy)) {\n      for (const ob of orderBy) addOrderBy(meta, alias, ob);\n    } else {\n      addOrderBy(meta, alias, orderBy);\n    }\n  }\n  maybeAddOrderBy(query, meta, alias);\n\n  if (pruneJoins) {\n    pruneUnusedJoins(query, keepAliases);\n  }\n  return query;\n}\n\n/**\n * Look for conditions doing `some_column IS NULL` in an outer join that\n * need an `id IS NOT NULL` to make sure they don't match inadvertently on\n * the child row simply not existing.\n *\n * Note: Instead of injecting an extra `id IS NOT NULL` condition, I had tried\n * using all INNER JOINs and flipping joins to OUTER only if the user explicit\n * had `id IS NULL` in their filter, but that didn't work for queries that wanted\n * to do an `OR` across two different children (which queries both children being\n * OUTER JOINs, and detecting that case seemed complicated).\n */\nexport function maybeAddIdNotNulls(query: ParsedFindQuery): void {\n  visitConditions(query, {\n    visitCond(c: ColumnCondition) {\n      // Check `c.prunable` to make sure we don't catch our injected `deleted_at is null` conditions\n      if (c.cond.kind !== \"is-null\" || c.column === \"id\" || c.pruneable) {\n        return c;\n      }\n      // This is an `some_column IS NULL`, is it in an outer join?\n      const table = query.tables.find((t) => t.alias === c.alias);\n      if (table && table.join === \"outer\") {\n        const meta = getMetadataForTable(table.table);\n        return {\n          kind: \"exp\",\n          op: \"and\",\n          conditions: [\n            c,\n            {\n              kind: \"column\",\n              alias: c.alias,\n              column: \"id\",\n              dbType: meta.idDbType,\n              cond: { kind: \"not-null\" },\n            },\n          ],\n        } satisfies ParsedExpressionFilter;\n      }\n      return c;\n    },\n  });\n}\n\n/** Returns the `a` from `\"a\".*`. */\nexport function parseAlias(alias: string): string {\n  return alias.split(\".\")[0].replaceAll(`\"`, \"\");\n}\n\n/** An ADT version of `EntityFilter`. */\nexport type ParsedEntityFilter =\n  // ParsedValueFilter is any simple match on `id`\n  | ParsedValueFilter<string | number>\n  // Otherwise we return the join/complex\n  | { kind: \"join\"; subFilter: object };\n\n/** Parses an entity filter, which could be \"just an id\", an array of ids, or a nested filter. */\nexport function parseEntityFilter(meta: EntityMetadata, filter: any): ParsedEntityFilter | undefined {\n  if (filter === undefined) {\n    // This matches legacy `em.find(Book, { author: undefined })` behavior\n    return undefined;\n  } else if (isAlias(filter)) {\n    // We're just binding an alias to this position in the join tree\n    return undefined;\n  } else if (isScope(filter)) {\n    // A scope on a relation (e.g. `{ author: Author.adult }`) always implies conditions on the\n    // related entity, so signal \"needs a join\" via the existing `join` discriminant rather than\n    // adding a dedicated `kind: \"scope\"` that every relation branch would have to learn. The empty\n    // `subFilter` is intentionally never read: the m2o/m2m branches only check `kind === \"join\"` to\n    // decide whether to join, then re-dispatch the original scope value back through `addTable`,\n    // where `isScope(...)` routes it to `addScopeFilterAt` to apply the scope's actual fragments.\n    return { kind: \"join\", subFilter: {} };\n  } else if (filter === null) {\n    return { kind: \"is-null\" };\n  } else if (typeof filter === \"string\" || typeof filter === \"number\") {\n    return { kind: \"eq\", value: filter };\n  } else if (typeof filter === \"boolean\") {\n    return filter ? { kind: \"not-null\" } : { kind: \"is-null\" };\n  } else if (Array.isArray(filter)) {\n    return {\n      kind: \"in\",\n      value: filter.map((v: string | number | Entity) => {\n        return isEntity(v) ? (v.idTaggedMaybe ?? nilIdValue(meta)) : v;\n      }),\n    };\n  } else if (isEntity(filter)) {\n    return { kind: \"eq\", value: filter.idTaggedMaybe || nilIdValue(meta) };\n  } else if (typeof filter === \"object\") {\n    // Looking for `{ firstName: \"f1\" }` or `{ ne: \"f1\" }`\n    const keys = Object.keys(filter);\n    // Special case only looking at `ne`\n    if (keys.length === 1 && keys[0] === \"ne\") {\n      const value = filter[\"ne\"];\n      if (value === undefined) {\n        return undefined;\n      } else if (value === null) {\n        return { kind: \"not-null\" };\n      } else if (typeof value === \"string\" || typeof value === \"number\") {\n        return { kind: \"ne\", value };\n      } else if (isEntity(value)) {\n        return { kind: \"ne\", value: value.idTaggedMaybe || nilIdValue(meta) };\n      } else {\n        throw new Error(`Unsupported \"ne\" value ${value}`);\n      }\n    }\n    // Special case only looking at `id`\n    if (keys.length === 1 && keys[0] === \"id\") {\n      const value = filter[\"id\"];\n      if (value === undefined) {\n        return undefined;\n      } else if (value === null) {\n        return { kind: \"is-null\" };\n      } else if (typeof value === \"string\" || typeof value === \"number\") {\n        return { kind: \"eq\", value };\n      } else if (isEntity(value)) {\n        return { kind: \"eq\", value: value.idTaggedMaybe || nilIdValue(meta) };\n      } else {\n        return parseValueFilter(value)[0] as any;\n      }\n    }\n    // Look for subFilter values being EntityFilter-ish instances like ManyToOneReference\n    // that have an id, and so structurally match the entity filter without really being filters,\n    // and convert them over here before getting into parseValueFilter.\n    const subFilter = {} as any;\n    for (const [key, value] of Object.entries(filter)) {\n      if (value && typeof value === \"object\" && !isPlainObject(value) && \"idTaggedMaybe\" in value) {\n        subFilter[key] = value.idTaggedMaybe || nilIdValue(meta);\n      } else {\n        subFilter[key] = value;\n      }\n    }\n    return { kind: \"join\", subFilter };\n  } else {\n    throw new Error(`Unrecognized filter ${filter}`);\n  }\n}\n\n/**\n * We use this value if users include new (id-less) entities as em.find conditions.\n *\n * The idea is that this condition would never be met, but we still want to do the em.find\n * query in case it's in an `OR` clause that would match false, but some other part of the\n * clause would match. I.e. instead of just skipping the DB query all together, which is\n * also something we could consider doing.\n *\n * For int IDs we use -1, and for uuid IDs, we use the nil UUID value:\n *\n * https://en.wikipedia.org/wiki/Universally_unique_identifier#Nil_UUID\n */\nfunction nilIdValue(meta: EntityMetadata): any {\n  switch (meta.idDbType) {\n    case \"int\":\n    case \"bigint\":\n      return -1;\n    case \"uuid\":\n      return \"00000000-0000-0000-0000-000000000000\";\n    case \"text\":\n      return \"0\";\n    default:\n      return assertNever(meta.idDbType);\n  }\n}\n\nfunction isNilIdValue(value: any): boolean {\n  return value === -1 || value === \"00000000-0000-0000-0000-000000000000\";\n}\n\n/** Finds a filter field by fieldName or generated fieldIdName. */\nexport function findFilterField(meta: EntityMetadata, key: string): (Field & { aliasSuffix: string }) | undefined {\n  return (\n    meta.allFields[key] ??\n    meta.polyComponentFields?.[key] ??\n    Object.values(meta.allFields).find((field) => field.fieldIdName === key) ??\n    Object.values(meta.polyComponentFields ?? {}).find((field) => field.fieldIdName === key)\n  );\n}\n\n/**\n * An ADT version of `ValueFilter`.\n *\n * The ValueFilter is a\n */\nexport type ParsedValueFilter<V> =\n  | { kind: \"eq\"; value: V }\n  | { kind: \"in\"; value: readonly V[] }\n  | { kind: \"nin\"; value: readonly V[] }\n  | { kind: \"gt\"; value: V }\n  | { kind: \"gte\"; value: V }\n  | { kind: \"ne\"; value: V }\n  | { kind: \"is-null\" }\n  | { kind: \"not-null\" }\n  | { kind: \"lt\"; value: V }\n  | { kind: \"lte\"; value: V }\n  | { kind: \"like\"; value: V }\n  | { kind: \"nlike\"; value: V }\n  | { kind: \"ilike\"; value: V }\n  | { kind: \"nilike\"; value: V }\n  | { kind: \"regex\"; value: V }\n  | { kind: \"nregex\"; value: V }\n  | { kind: \"iregex\"; value: V }\n  | { kind: \"niregex\"; value: V }\n  | { kind: \"contains\"; value: readonly V[] }\n  | { kind: \"ncontains\"; value: readonly V[] }\n  | { kind: \"overlaps\"; value: readonly V[] }\n  | { kind: \"noverlaps\"; value: readonly V[] }\n  | { kind: \"containedBy\"; value: readonly V[] }\n  | { kind: \"between\"; value: [V, V] }\n  | { kind: \"jsonPathExists\"; value: string }\n  | { kind: \"jsonPathPredicate\"; value: string };\n\n/**\n * Parses the many/hodgepodge (ergonomic!) patterns of value filters into a `ParsedValueFilter[]`.\n *\n * Note we return an array because filter might be a `ValueGraphQLFilter` that is allowed to have\n * multiple conditions, i.e. `{ lt: 10, gt: 5 }`.\n */\nexport function parseValueFilter<V>(filter: ValueFilter<V, any>): ParsedValueFilter<V>[] {\n  if (filter === null) {\n    return [{ kind: \"is-null\" }];\n  } else if (filter === undefined) {\n    // This is legacy behavior where `em.find(Book, { author: undefined })` would match all books\n    return [];\n  } else if (Array.isArray(filter)) {\n    return [{ kind: \"in\", value: filter }];\n  } else if (isPlainObject(filter)) {\n    const keys = Object.keys(filter);\n    if (keys.length === 0) {\n      // Should this be an error?\n      return [];\n    } else if (keys.length === 2 && \"op\" in filter && \"value\" in filter) {\n      // Probe for `findGql` op & value\n      const { op, value } = filter;\n      if (shouldPruneValueFilter(op, value)) {\n        return [];\n      } else if (value === null) {\n        return [{ kind: \"is-null\" }];\n      } else {\n        return [{ kind: op, value: value ?? null }];\n      }\n    } else if (keys.length === 2 && \"gte\" in filter && \"lte\" in filter) {\n      const { gte, lte } = filter;\n      return [{ kind: \"between\", value: [gte, lte] }];\n    } else {\n      return Object.entries(filter)\n        .map(([key, value]) => {\n          // Always do condition pruning on the value\n          if (shouldPruneValueFilter(key, value)) {\n            return undefined;\n          }\n          switch (key) {\n            case \"eq\":\n              if (value === null) {\n                return { kind: \"is-null\" as const };\n              } else {\n                return { kind: \"eq\" as const, value: filter[key] };\n              }\n            case \"ne\":\n              if (value === null) {\n                return { kind: \"not-null\" as const };\n              } else {\n                return { kind: \"ne\" as const, value: filter[key] ?? null };\n              }\n            case \"in\":\n            case \"nin\":\n            case \"gt\":\n            case \"gte\":\n            case \"lt\":\n            case \"lte\":\n            case \"like\":\n            case \"nlike\":\n            case \"ilike\":\n            case \"nilike\":\n            case \"regex\":\n            case \"nregex\":\n            case \"iregex\":\n            case \"niregex\":\n            case \"contains\":\n            case \"overlaps\":\n            case \"containedBy\":\n              return { kind: key, value: filter[key] };\n            case \"pathExists\":\n              return { kind: \"jsonPathExists\" as const, value: filter[key] };\n            case \"pathIsTrue\":\n              return { kind: \"jsonPathPredicate\" as const, value: filter[key] };\n            case \"search\":\n              return { kind: \"ilike\" as const, value: makeLike(filter[key]) };\n            case \"between\":\n              return { kind: key, value: filter[key] };\n            default:\n              throw new Error(`Unsupported value filter key ${key}`);\n          }\n        })\n        .filter(isDefined);\n    }\n  } else {\n    // This is a primitive like a string, number\n    return [{ kind: \"eq\", value: filter }];\n  }\n}\n\n/** Converts domain-level values like string ids/enums into their db equivalent. */\nexport function mapToDb(column: Column, filter: ParsedValueFilter<any>): ParsedValueFilter<any> {\n  // ...to teach this `mapToDb` function to handle/rewrite `in: [1, null]` handling, we'd need to:\n  // 1. return a maybe-simple/maybe-nested condition, so basically a `ParsedExpressionCondition`, because\n  // this would let `in` return an `{ or: ... }` to all the callers.\n  // 2. also return `{ parsed: ParsedExpressionCondition, simples: SimpleCondition[] }` tuple, for the\n  // alias `addCondition` processing to track the `simples` and rewrite their alias when later bound.\n  switch (filter.kind) {\n    case \"eq\":\n    case \"gt\":\n    case \"gte\":\n    case \"ne\":\n    case \"lt\":\n    case \"lte\":\n    case \"like\":\n    case \"nlike\":\n    case \"ilike\":\n    case \"nilike\":\n    case \"regex\":\n    case \"nregex\":\n    case \"iregex\":\n    case \"niregex\":\n      filter.value = column.mapToDb(filter.value);\n      return filter;\n    case \"in\":\n      if (column.isArray) {\n        // Arrays need a special operator\n        return { kind: \"contains\", value: column.mapToDb(filter.value) };\n      } else {\n        filter.value = filter.value.map((v) => column.mapToDb(v));\n      }\n      return filter;\n    case \"nin\":\n      if (column.isArray) {\n        // Arrays need a special operator\n        throw new Error(\"The nin operator is not supported on array columns yet\");\n      } else {\n        filter.value = filter.value.map((v) => column.mapToDb(v));\n      }\n      return filter;\n    case \"contains\":\n    case \"ncontains\":\n    case \"overlaps\":\n    case \"noverlaps\":\n    case \"containedBy\":\n      const supportsContains = column.isArray || column.dbType === \"jsonb\";\n      if (!supportsContains) {\n        throw new Error(`${filter.kind} is only unsupported on array or jsonb columns`);\n      }\n      if (column.isArray) {\n        filter.value = column.mapToDb(filter.value);\n      } else {\n        // leave jsonb values alone\n      }\n      return filter;\n    case \"between\":\n      filter.value = [column.mapToDb(filter.value[0]), column.mapToDb(filter.value[1])];\n      return filter;\n    case \"is-null\":\n    case \"not-null\":\n    case \"jsonPathExists\":\n    case \"jsonPathPredicate\":\n      return filter;\n    default:\n      throw assertNever(filter);\n  }\n}\n\n/** Adds any user-configured default order, plus an \"always order by id\" for determinism. */\nexport function maybeAddOrderBy(query: ParsedFindQuery, meta: EntityMetadata, alias: string): void {\n  const { orderBys } = query;\n  if (meta.orderBy) {\n    const field = meta.allFields[meta.orderBy] ?? fail(`${meta.orderBy} not found on ${meta.tableName}`);\n    const column = field.serde!.columns[0].columnName;\n    const hasAlready = orderBys.find((o) => o.alias === alias && o.column === column);\n    if (!hasAlready) {\n      orderBys.push({ alias, column, order: \"ASC\" });\n    }\n  }\n  // Even if they already added orders, add id as the last one to get deterministic output\n  const hasIdOrder = orderBys.find((o) => o.alias === alias && o.column === \"id\");\n  if (!hasIdOrder) {\n    orderBys.push({ alias, column: \"id\", order: \"ASC\" });\n  }\n}\n\nexport function addTablePerClassJoinsAndClassTag(\n  query: ParsedFindQuery,\n  meta: EntityMetadata,\n  alias: string,\n  isPrimary: boolean,\n): void {\n  if (!needsClassPerTableJoins(meta)) return;\n  const { selects, tables } = query;\n  // When `.load(SmallPublisher)` is called, join in base tables like `Publisher`\n  meta.baseTypes.forEach((bt, i) => {\n    if (isPrimary) {\n      selects.push(`${alias}_b${i}.*`);\n    }\n    tables.push({\n      alias: `${alias}_b${i}`,\n      table: bt.tableName,\n      join: \"outer\",\n      col1: kqDot(alias, \"id\"),\n      col2: `${alias}_b${i}.id`,\n      distinct: false,\n    });\n  });\n\n  // We always join in the base table in case a query happens to use\n  // it as a filter, but we only need to do the subtype joins + selects\n  // if this is the primary table\n  if (isPrimary) {\n    // Watch for subTypes that share column names. It'd be great to do\n    // this statically at codegen time, like a meta.sharedSubtypeColumns.\n    const stColumns: { stAlias: string; columnName: string }[] = [];\n\n    // When `.load(Publisher)` is called, join in sub tables like `SmallPublisher` and `LargePublisher`\n    meta.subTypes.forEach((st, i) => {\n      const stAlias = `${alias}_s${i}`;\n      selects.push(`${stAlias}.*`);\n      tables.push({\n        alias: stAlias,\n        table: st.tableName,\n        join: \"outer\",\n        col1: kqDot(alias, \"id\"),\n        col2: `${alias}_s${i}.id`,\n        distinct: false,\n      });\n      for (const field of Object.values(st.fields)) {\n        if (field.fieldName !== \"id\" && field.serde) {\n          for (const c of field.serde?.columns) {\n            stColumns.push({ stAlias, columnName: c.columnName });\n          }\n        }\n      }\n    });\n\n    // Nominate a specific `id` column to avoid ambiguity\n    selects.push(`${kq(alias)}.id as id`);\n\n    // Add an explicit coalesce for shared columns\n    Object.values(groupBy(stColumns, (c) => c.columnName))\n      .filter((columns) => columns.length > 1)\n      .forEach((columns) => {\n        const { columnName } = columns[0];\n        selects.push(`COALESCE(${columns.map((c) => `${c.stAlias}.${columnName}`).join(\", \")}) as ${columnName}`);\n      });\n\n    // If our meta has no subtypes, we're a left type and don't need a __class\n    const cases = meta.subTypes.map((st, i) => `WHEN ${alias}_s${i}.id IS NOT NULL THEN '${st.type}'`);\n    if (cases.length > 0) {\n      selects.push(`CASE ${cases.join(\" \")} ELSE '_' END as __class`);\n    }\n  }\n}\n\n/**\n * Builds the primary table's SELECT columns explicitly, i.e. excluding any `lazy` columns.\n *\n * Only used when `meta.hasLazyColumns` is true; otherwise callers keep their plain `alias.*`, so\n * that entities without lazy columns emit byte-identical SQL to before this feature existed.\n */\nexport function lazyExcludedSelects(meta: EntityMetadata, alias: string): string[] {\n  const selects: string[] = [];\n  for (const field of Object.values(meta.fields)) {\n    if (!field.serde) continue;\n    if (field.kind === \"primitive\" && field.lazy) continue;\n    for (const column of field.serde.columns) selects.push(kqDot(alias, column.columnName));\n  }\n  return selects;\n}\n\n/** Rejects SQL predicates throughout a domain condition tree before optional-filter pruning. */\nfunction checkDomainCondition(condition: ConditionInput | undefined): void {\n  if (!condition) return;\n  if (isDeferredCondition(condition) || (predicateBrand in condition && condition[predicateBrand] === \"sql\")) {\n    fail(\"SQL predicates are only supported by em.query/em.execute; use alias(...) predicates in em.find and scopes.\");\n  }\n  if (\"and\" in condition && condition.and) {\n    for (const child of condition.and) checkDomainCondition(child);\n  } else if (\"or\" in condition && condition.or) {\n    for (const child of condition.or) checkDomainCondition(child);\n  }\n}\n\n/** Resolves every `DeferredAliasCondition` in `query` against the parse's alias bindings. */\nfunction resolveAliasConditions(\n  query: ParsedFindQuery,\n  bindings: Map<AliasMgmt, { meta: EntityMetadata; alias: string }>,\n): void {\n  function resolve(handle: AliasMgmt): { meta: EntityMetadata; alias: string } {\n    return bindings.get(handle) ?? fail(`Alias for ${handle.tableName} is not bound to this query's join literal`);\n  }\n  function maybeResolve<C extends ColumnCondition | RawCondition>(c: C): C | undefined {\n    return isDeferredAliasCondition(c) ? c[deferredAliasSym](resolve) : undefined;\n  }\n  visitConditions(query, { visitCond: maybeResolve, visitRaw: maybeResolve });\n}\n\nexport function maybeAddNotSoftDeleted(\n  conditions: ColumnCondition[],\n  meta: EntityMetadata,\n  alias: string,\n  softDeletes: \"include\" | \"exclude\",\n): void {\n  if (filterSoftDeletes(meta, softDeletes)) {\n    const column = meta.allFields[getBaseMeta(meta).timestampFields!.deletedAt!].serde?.columns[0]!;\n    conditions.push({\n      kind: \"column\",\n      alias,\n      column: column.columnName,\n      dbType: column.dbType,\n      cond: { kind: \"is-null\" },\n    });\n  }\n}\n\nexport function filterSoftDeletes(meta: EntityMetadata, softDeletes: \"include\" | \"exclude\"): boolean {\n  return (\n    softDeletes === \"exclude\" &&\n    !!getBaseMeta(meta).timestampFields?.deletedAt &&\n    // We don't support CTI subtype soft-delete filtering yet\n    (meta.inheritanceType !== \"cti\" || meta.baseTypes.length === 0)\n  );\n}\n\nexport function getTables(query: ParsedFindQuery): [PrimaryTable, JoinTable[], LateralJoinTable[], CrossJoinTable[]] {\n  let primary: PrimaryTable;\n  const joins: JoinTable[] = [];\n  const laterals: LateralJoinTable[] = [];\n  const crosses: CrossJoinTable[] = [];\n  for (const table of query.tables) {\n    if (table.join === \"primary\") {\n      primary = table;\n    } else if (table.join === \"lateral\") {\n      laterals.push(table);\n    } else if (table.join === \"cross\") {\n      crosses.push(table);\n    } else {\n      joins.push(table);\n    }\n  }\n  return [primary!, joins, laterals, crosses];\n}\n\nfunction needsClassPerTableJoins(meta: EntityMetadata): boolean {\n  return meta.inheritanceType === \"cti\" && (meta.subTypes.length > 0 || meta.baseTypes.length > 0);\n}\n\nfunction needsStiDiscriminator(meta: EntityMetadata): boolean {\n  return meta.inheritanceType === \"sti\" && !meta.stiDiscriminatorField;\n}\n\nfunction addStiSubtypeFilter(cb: ConditionBuilder, subtypeMeta: EntityMetadata, alias: string): void {\n  const cond = stiSubtypeFilter(subtypeMeta, alias);\n  if (cond) cb.addSimpleCondition(cond);\n}\n\n/** The `type_id = X` discriminator condition for an STI subtype, shared by em.find and em.query. */\nexport function stiSubtypeFilter(meta: EntityMetadata, alias: string): ColumnCondition | undefined {\n  if (meta.inheritanceType !== \"sti\" || meta.stiDiscriminatorValue === undefined) return undefined;\n  const baseMeta = getBaseMeta(meta);\n  const column = baseMeta.fields[baseMeta.stiDiscriminatorField!].serde?.columns[0]!;\n  return {\n    kind: \"column\",\n    alias,\n    column: column.columnName,\n    dbType: column.dbType,\n    cond: { kind: \"eq\", value: meta.stiDiscriminatorValue },\n    pruneable: true,\n  };\n}\n\n/** Converts a search term like `foo bar` into a SQL `like` pattern like `%foo%bar%`. */\nexport function makeLike(search: any | undefined): any {\n  return search ? `%${search.replace(/\\s+/g, \"%\")}%` : undefined;\n}\n\n/** Returns true for values that should be treated like an omitted filter. */\nfunction shouldPruneValueFilter(key: unknown, value: unknown): boolean {\n  if (value === undefined) return true;\n  return value === false && key !== \"eq\" && key !== \"ne\";\n}\n"],"mappings":"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"}

package/build/QueryParser.collectionJoins.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryParser.collectionJoins.cjs","names":["selectReferencesAlias","parseAlias"],"sources":["../src/QueryParser.collectionJoins.ts"],"sourcesContent":["import { pruneUnusedJoins, selectReferencesAlias } from \"./QueryParser.pruning.ts\";\nimport {\n  type ExistsCondition,\n  type JoinTable,\n  type ParsedExpressionCondition,\n  type ParsedExpressionFilter,\n  type ParsedFindQuery,\n  type PrimaryTable,\n  type RawCondition,\n  maybeAddIdNotNulls,\n  parseAlias,\n} from \"./QueryParser.ts\";\nimport { assertNever } from \"./utils.ts\";\n\n/** A collection root plus every join nested under it, i.e. `books b` with `book_reviews br`. */\ninterface CollectionRoot {\n  /** The top-level collection join that becomes the EXISTS FROM table, i.e. `books b`. */\n  table: JoinTable;\n  /** Every alias in this collection subtree, i.e. `b` and `br` for `authors -> books -> reviews`. */\n  aliases: Set<string>;\n  /** Every join table in this collection subtree, i.e. `att` and `t` for an m2m tag filter. */\n  joinTables: JoinTable[];\n}\n\n/**\n * Rewrites eligible logical collection LEFT JOINs into EXISTS after plugins have mutated the AST.\n *\n * QueryParser intentionally leaves collection filters as ordinary joins so `beforeFind` plugins see\n * stabler/simpler input than \"sometimes JOINs / sometimes EXISTS\".\n *\n * This pass runs after plugins and before SQL rendering:\n *\n * 1. `rewriteCollectionJoins` finds top-level collection joins and moves conditions that reference only\n *    that subtree into a correlated EXISTS subquery. I.e. `{ books: { title: \"b1\" } }` becomes\n *    `EXISTS (SELECT 1 FROM books b WHERE a.id = b.author_id AND b.title = 'b1')`.\n * 2. The same helper recurses into the generated subquery, so nested collections become nested EXISTS clauses.\n *    I.e. `{ books: { reviews: { rating: 5 } } }` becomes EXISTS(books WHERE EXISTS(reviews)).\n * 3. Conditions that cannot be safely moved stay as LEFT JOINs. I.e. `OR(b.title = 'x', a.first_name = 'x')`\n *    needs both aliases in one SQL scope, so `b` remains a join instead of becoming an EXISTS.\n * 4. Remaining fanout LEFT JOIN roots are rejected unless `allowMultipleLeftJoins` is set,\n *    because they can produce cross-product row explosions.\n * 5. Finally, `maybeAddIdNotNulls` and `pruneUnusedJoins` clean up the joins that remain.\n */\nexport function optimizeCollectionJoins(\n  query: ParsedFindQuery,\n  opts: {\n    allowMultipleLeftJoins?: boolean;\n    optimizeJoinsToExists?: boolean;\n    pruneJoins?: boolean;\n    keepAliases?: string[];\n  } = {},\n): void {\n  const { allowMultipleLeftJoins = false, optimizeJoinsToExists = true, pruneJoins = true, keepAliases = [] } = opts;\n  for (const table of query.tables) {\n    // I.e. batched find/count queries wrap the real query in a LATERAL subquery; optimize that inner query too,\n    // but let the outer query decide final pruning so it can keep the lateral alias itself.\n    if (table.join === \"lateral\") optimizeCollectionJoins(table.query, { ...opts, pruneJoins: false });\n  }\n  if (optimizeJoinsToExists) rewriteCollectionJoins(query, keepAliases);\n\n  // I.e. collection LEFT JOINs now fall into three buckets:\n  // 1. local real filters, like `{ books: { title: \"b1\" } }`, were rewritten to EXISTS above;\n  // 2. no local real filters, like `{ books: {}, comments: {} }`, are safe because pruning will remove them;\n  // 3. blocked real filters, like cross-scope ORs, must stay as LEFT JOINs and can multiply rows.\n  // Only the third bucket should trip the fanout guard.\n  const fanoutLeftJoinAliases = getCollectionRoots(query)\n    .filter((root) => conditionBlocksExistsRewrite(query.condition, root.aliases))\n    .map((root) => root.table.alias);\n  if (optimizeJoinsToExists && !allowMultipleLeftJoins && fanoutLeftJoinAliases.length > 1) {\n    throw new Error(\n      `em.find would issue multiple LEFT JOINs across collection relations (${fanoutLeftJoinAliases.join(\n        \", \",\n      )}); pass allowMultipleLeftJoins: true if this fanout is intentional`,\n    );\n  }\n\n  if (query.tables.some((t) => t.join === \"outer\")) {\n    // I.e. preserve legacy LEFT JOIN null semantics for any joins that could not become EXISTS.\n    maybeAddIdNotNulls(query);\n  }\n  if (pruneJoins) {\n    // I.e. remove logical collection joins that were replaced by EXISTS and any joins only needed before plugin edits.\n    pruneUnusedJoins(query, keepAliases);\n  }\n}\n\n/**\n * Rewrites root-level collection join subtrees into EXISTS when their conditions are locally scoped.\n *\n * I.e. for `authors a -> books b -> book_reviews br`, `b` is the collection root and `br` is part of its subtree.\n */\nfunction rewriteCollectionJoins(query: ParsedFindQuery, keepAliases: string[] = []): void {\n  const roots = getCollectionRoots(query);\n  if (query.condition) rewriteSiblingOrExpression(query, query.condition, roots, keepAliases);\n  for (const root of roots) {\n    if (queryReferencesAliasesOutsideConditions(query, root.aliases, keepAliases)) continue;\n    if (conditionHasCrossScopeReference(query.condition, root.aliases)) continue;\n    // I.e. move `b.title = 'x'` and `(br.rating = 5 OR br.rating = 4)`, but not `b.title = 'x' OR a.first_name = 'x'`.\n    const moved = query.condition ? removeLocallyScopedConditions(query.condition, root.aliases) : [];\n    if (moved.length === 0) continue;\n    const exists = createExistsCondition(query, root, moved);\n    if (!exists) {\n      addConditions(query, moved);\n      continue;\n    }\n    addConditions(query, [exists]);\n    // I.e. after adding EXISTS, remove `books b` and its children from the outer FROM list.\n    query.tables = query.tables.filter((t) => !root.aliases.has(t.alias));\n  }\n  removeEmptyExpressions(query.condition);\n}\n\n/** Rewrites eligible sibling collection ORs while preserving outer/mixed-scope ORs as joins. */\nfunction rewriteSiblingOrExpression(\n  query: ParsedFindQuery,\n  condition: ParsedExpressionCondition,\n  roots: CollectionRoot[],\n  keepAliases: string[],\n): void {\n  if (condition.kind !== \"exp\") return;\n  if (condition.op === \"or\" && rewriteSiblingOrExpressionChildren(query, condition, roots, keepAliases)) return;\n  if (condition.op === \"and\") {\n    for (const child of condition.conditions) rewriteSiblingOrExpression(query, child, roots, keepAliases);\n  }\n}\n\n/** Returns true when OR branches that are scoped to collection subtrees became EXISTS conditions. */\nfunction rewriteSiblingOrExpressionChildren(\n  query: ParsedFindQuery,\n  exp: ParsedExpressionFilter,\n  roots: CollectionRoot[],\n  keepAliases: string[],\n): boolean {\n  const matches: { collectionRoot: CollectionRoot; condition: ParsedExpressionCondition }[] = [];\n  const usedAliases = new Set<string>();\n  const usedRoots = new Set<string>();\n  let hasAntiJoinBranch = false;\n  for (const condition of exp.conditions) {\n    if (!isRealCondition(condition)) return false;\n    const match = roots.find((root) => conditionReferencesOnlyAliases(condition, root.aliases));\n    if (!match) {\n      const found = conditionAliases(condition);\n      // I.e. `a.first_name = 'x'` can stay in the OR while `b.title = 'x'` becomes EXISTS, but\n      // `a.first_name = 'x' AND b.title = 'x'` must stay joined because one branch spans both scopes.\n      if (roots.some((root) => hasAnyAlias(found, root.aliases))) return false;\n      continue;\n    }\n    matches.push({ collectionRoot: match, condition });\n    usedRoots.add(match.table.alias);\n    hasAntiJoinBranch ||= isCollectionAntiJoin(condition, match);\n    for (const alias of match.aliases) usedAliases.add(alias);\n  }\n  if (matches.length === 0) return false;\n  // I.e. rewrite true sibling collection ORs like `b.id IS NOT NULL OR c.id IS NOT NULL`, and same-root\n  // anti-join ORs like `b.id IS NULL OR br.rating = 5` that need `b.id IS NULL` to become `NOT EXISTS`.\n  // skip positive-only single-root ORs, i.e. ORs with no `b.id IS NULL` anti-join branch like\n  // `b.title = 'x' OR br.rating = 5`; mixed ordinary/collection ORs like `a.first_name = 'x' OR b.title = 'x'`\n  // are safe because only the collection branch is replaced. Aliases are also filtered elsewhere like\n  // `b.order = 1 AND (b.title = 'x' OR c.text = 'x')`, and aliases that must stay projected/sorted like\n  // `SELECT b.title` or `ORDER BY b.title`.\n  if (\n    (matches.length === exp.conditions.length && usedRoots.size < 2 && !hasAntiJoinBranch) ||\n    conditionReferencesAliasesOutside(query.condition, exp, usedAliases) ||\n    queryReferencesAliasesOutsideConditions(query, usedAliases, keepAliases)\n  ) {\n    return false;\n  }\n\n  const existsConditions = new Map<ParsedExpressionCondition, ExistsCondition>();\n  for (const match of matches) {\n    const exists = createExistsCondition(query, match.collectionRoot, [match.condition]);\n    if (!exists) return false;\n    existsConditions.set(match.condition, exists);\n  }\n  exp.conditions = exp.conditions.map((condition) => existsConditions.get(condition) ?? condition);\n  // I.e. leave the collection joins in place for now; pruning removes them after all rewrites.\n  return true;\n}\n\n/** Creates an EXISTS/NOT EXISTS condition for moved collection filters, or undefined when a LEFT JOIN must stay. */\nfunction createExistsCondition(\n  query: ParsedFindQuery,\n  collectionRoot: CollectionRoot,\n  moved: ParsedExpressionCondition[],\n): ExistsCondition | undefined {\n  const root = collectionRoot.table;\n  const hasOnlyAntiJoin = moved.length === 1 && isCollectionAntiJoin(moved[0], collectionRoot);\n  if (!hasOnlyAntiJoin && !moved.some(isRealCondition)) {\n    // I.e. only soft-delete/STI conditions moved; don't create an EXISTS that changes nothing.\n    return undefined;\n  }\n  if (!hasOnlyAntiJoin && moved.some((c) => conditionContainsCollectionAntiJoin(c, collectionRoot))) {\n    // I.e. `b.id IS NULL OR br.rating = 5` is not a pure anti-join; leave it as a LEFT JOIN for SQL semantics.\n    return undefined;\n  }\n\n  // I.e. `rpm` may correlate through `_pp_version.id = rpm.ready_plan_version_id`, so pruning must keep\n  // `_pp_version` even when the collection metadata's parent alias is only `pp`.\n  const correlationAliases = joinDependencies(root);\n  const correlation: RawCondition = {\n    kind: \"raw\",\n    aliases: [root.alias, ...correlationAliases],\n    condition: `${root.col1} = ${root.col2}`,\n    bindings: [],\n    pruneable: false,\n  };\n  // I.e. a pure `b.id IS NULL` anti-join becomes `NOT EXISTS (SELECT 1 FROM books b WHERE a.id = b.author_id)`.\n  const conditions = hasOnlyAntiJoin ? [correlation] : [correlation, ...moved];\n  const subquery: ParsedFindQuery = {\n    selects: [\"1\"],\n    tables: query.tables\n      .filter((t) => (hasOnlyAntiJoin ? t.alias === root.alias : collectionRoot.aliases.has(t.alias)))\n      .map((t) => {\n        // I.e. the collection root becomes the subquery's FROM table; children remain joins off that root.\n        if (t.alias === root.alias) return { join: \"primary\", alias: t.alias, table: t.table } satisfies PrimaryTable;\n        // I.e. preserve nullable paths like `LEFT JOIN p ... LEFT JOIN sp ... WHERE p.id = 1 OR sp.id = 1`; forcing\n        // children to INNER JOIN would require every optional branch to exist before the OR can match any branch.\n        if (t.join === \"outer\") return { ...t, distinct: false };\n        return t;\n      }),\n    condition: { kind: \"exp\", op: \"and\", conditions },\n    orderBys: [],\n  };\n  // I.e. nested `books.reviews` first creates an EXISTS for books, then this recursive call creates EXISTS for reviews.\n  rewriteCollectionJoins(subquery);\n  return {\n    kind: \"exists\",\n    negate: hasOnlyAntiJoin,\n    subquery,\n    outerAliases: correlationAliases,\n  };\n}\n\n/** Appends conditions to the top-level expression, creating an AND wrapper when needed. */\nfunction addConditions(query: ParsedFindQuery, conditions: ParsedExpressionCondition[]): void {\n  query.condition ??= { kind: \"exp\", op: \"and\", conditions: [] };\n  query.condition.conditions.push(...conditions);\n}\n\n/** Returns top-level collection roots with their full join subtrees. */\nfunction getCollectionRoots(query: ParsedFindQuery): CollectionRoot[] {\n  return getTopLevelCollectionRoots(query).map((table) => {\n    const aliases = collectJoinSubtreeAliases(query, table.alias);\n    return {\n      table,\n      aliases,\n      joinTables: query.tables.filter((t): t is JoinTable => isJoinTable(t) && aliases.has(t.alias)),\n    };\n  });\n}\n\n/** Returns top-level collection roots, i.e. `books b` but not nested `book_reviews br`. */\nfunction getTopLevelCollectionRoots(query: ParsedFindQuery): JoinTable[] {\n  // I.e. if `books b` is nested under another collection root, the parent pass should absorb it; don't rewrite it here.\n  const joinTables = query.tables.filter(isJoinTable);\n  const collectionAliases = new Set(joinTables.flatMap((t) => (t.collection ? [t.alias] : [])));\n  return joinTables.filter(\n    (t) => t.collection?.rootAlias === t.alias && !collectionAliases.has(t.collection.parentAlias),\n  );\n}\n\n/** Returns true if a remaining real condition prevents this subtree from becoming EXISTS, i.e. a cross-scope OR. */\nfunction conditionBlocksExistsRewrite(condition: ParsedExpressionCondition | undefined, aliases: Set<string>): boolean {\n  if (!condition || !isRealCondition(condition)) return false;\n  if (condition.kind === \"exp\" && condition.op === \"and\") {\n    return condition.conditions.some((c) => conditionBlocksExistsRewrite(c, aliases));\n  }\n  return conditionReferencesAnyAlias(condition, aliases);\n}\n\n/** Collects a collection root and all joins that depend on it, i.e. `b -> br -> c`. */\nfunction collectJoinSubtreeAliases(query: ParsedFindQuery, rootAlias: string): Set<string> {\n  const aliases = new Set([rootAlias]);\n  let changed = true;\n  while (changed) {\n    changed = false;\n    for (const table of query.tables) {\n      if (!isJoinTable(table)) continue;\n      // I.e. `book_reviews br ON b.id = br.book_id` depends on `b`, so `br` belongs in the `b` subtree.\n      if (!aliases.has(table.alias) && joinReferencesAnyAlias(table, aliases)) {\n        aliases.add(table.alias);\n        changed = true;\n      }\n    }\n  }\n  return aliases;\n}\n\n/**\n * Removes AND-safe conditions whose aliases all live inside one collection subtree.\n *\n * I.e. in `a.age = 1 AND b.title = 'x'`, only `b.title = 'x'` moves. In `b.title = 'x' OR br.rating = 5`,\n * the whole OR moves only if every alias is inside the same subtree.\n */\nfunction removeLocallyScopedConditions(exp: ParsedExpressionFilter, aliases: Set<string>): ParsedExpressionCondition[] {\n  if (exp.op === \"or\") {\n    // I.e. OR cannot be split across scopes; either move the whole OR into the EXISTS, or leave it outside.\n    if (!conditionReferencesOnlyAliases(exp, aliases)) return [];\n    const moved = { ...exp, conditions: [...exp.conditions] } satisfies ParsedExpressionFilter;\n    exp.conditions = [];\n    return [moved];\n  }\n  const moved: ParsedExpressionCondition[] = [];\n  for (let i = exp.conditions.length - 1; i >= 0; i--) {\n    const condition = exp.conditions[i];\n    if (condition.kind === \"exp\" && condition.op === \"and\") {\n      // I.e. flatten nested AND movement so `a AND (b AND br)` can still move `b` and `br` into the EXISTS.\n      moved.push(...removeLocallyScopedConditions(condition, aliases));\n      if (condition.conditions.length === 0) exp.conditions.splice(i, 1);\n    } else if (conditionReferencesOnlyAliases(condition, aliases)) {\n      // I.e. move `b.title = 'x'` out of the parent AND and into the collection EXISTS.\n      moved.unshift(condition);\n      exp.conditions.splice(i, 1);\n    }\n  }\n  return moved;\n}\n\n/** Returns true when a condition references at least one alias and all aliases are in `aliases`, i.e. only `b`/`br`. */\nfunction conditionReferencesOnlyAliases(condition: ParsedExpressionCondition, aliases: Set<string>): boolean {\n  const found = conditionAliases(condition);\n  return found.size > 0 && [...found].every((alias) => aliases.has(alias));\n}\n\n/** Returns true when `aliases` are referenced by a real condition other than the targeted OR expression. */\nfunction conditionReferencesAliasesOutside(\n  condition: ParsedExpressionCondition | undefined,\n  target: ParsedExpressionCondition,\n  aliases: Set<string>,\n): boolean {\n  if (!condition || condition === target || !isRealCondition(condition)) return false;\n  if (condition.kind === \"exp\") {\n    return condition.conditions.some((child) => conditionReferencesAliasesOutside(child, target, aliases));\n  }\n  return conditionReferencesAnyAlias(condition, aliases);\n}\n\n/** Returns true when selected/ordered aliases would force these joins to remain in the outer query. */\nfunction queryReferencesAliasesOutsideConditions(\n  query: ParsedFindQuery,\n  aliases: Set<string>,\n  keepAliases: string[],\n): boolean {\n  const requiredAliases = queryRequiredAliasesOutsideConditions(query, keepAliases);\n  // I.e. if `array_agg(br.rating)` requires `br`, then `b` is required too because `br` joins through `b`; don't\n  // move `b` under EXISTS just because the select references only its child alias directly.\n  return hasAnyAlias(requiredAliases, aliases);\n}\n\n/**\n * Returns aliases needed by SELECT/GROUP/ORDER plus their join dependencies.\n *\n * I.e. `array_agg(br.rating)` requires `br`, and then `br` requires `b` because it joins through `b`.\n */\nfunction queryRequiredAliasesOutsideConditions(query: ParsedFindQuery, keepAliases: string[]): Set<string> {\n  const required = new Set<string>();\n  for (const alias of keepAliases) required.add(alias);\n  for (const orderBy of query.orderBys) required.add(orderBy.alias);\n  for (const groupBy of query.groupBys ?? []) {\n    if (\"expression\" in groupBy) {\n      addSelectAliases(query, required, groupBy.expression);\n    } else {\n      required.add(groupBy.alias);\n    }\n  }\n  for (const select of query.selects) {\n    if (typeof select === \"string\") {\n      addSelectAliases(query, required, select);\n    } else if (\"aliases\" in select) {\n      for (const alias of select.aliases) required.add(alias);\n      addSelectAliases(query, required, select.sql);\n    }\n  }\n\n  const todo = [...required];\n  while (todo.length > 0) {\n    const alias = todo.pop()!;\n    const table = query.tables.find((t) => t.alias === alias);\n    if (!table || !isJoinTable(table)) continue;\n    for (const dependency of joinDependencies(table)) {\n      if (!required.has(dependency)) {\n        required.add(dependency);\n        todo.push(dependency);\n      }\n    }\n  }\n  return required;\n}\n\n/** Adds aliases referenced by raw select SQL, i.e. `array_agg(br.rating)` requires `br`. */\nfunction addSelectAliases(query: ParsedFindQuery, required: Set<string>, select: string): void {\n  for (const table of query.tables) {\n    if (selectReferencesAlias(select, table.alias)) required.add(table.alias);\n  }\n}\n\n/** Returns the aliases needed to evaluate a join's ON clause, excluding the joined alias itself. */\nfunction joinDependencies(table: JoinTable): string[] {\n  return [parseAlias(table.col1), parseAlias(table.col2)].filter((alias) => alias !== table.alias);\n}\n\n/** Returns true when a condition references this subtree and another scope, i.e. `b.title = 'x' OR c.text = 'x'`. */\nfunction conditionHasCrossScopeReference(\n  condition: ParsedExpressionCondition | undefined,\n  aliases: Set<string>,\n): boolean {\n  if (!condition || !isRealCondition(condition)) return false;\n  if (condition.kind === \"exp\" && condition.op === \"and\") {\n    return condition.conditions.some((child) => conditionHasCrossScopeReference(child, aliases));\n  }\n  const found = conditionAliases(condition);\n  return hasAnyAlias(found, aliases) && ![...found].every((alias) => aliases.has(alias));\n}\n\n/** Returns true when a condition references any alias in `aliases`, i.e. `b` in `b.title = c.text`. */\nfunction conditionReferencesAnyAlias(condition: ParsedExpressionCondition, aliases: Set<string>): boolean {\n  return hasAnyAlias(conditionAliases(condition), aliases);\n}\n\n/** Returns true when `table` is an ordinary SQL join. */\nfunction isJoinTable(table: ParsedFindQuery[\"tables\"][number]): table is JoinTable {\n  return table.join === \"inner\" || table.join === \"outer\";\n}\n\n/** Returns true when a join's ON clause references any alias in `aliases`. */\nfunction joinReferencesAnyAlias(table: JoinTable, aliases: Set<string>): boolean {\n  return joinDependencies(table).some((alias) => aliases.has(alias));\n}\n\n/** Returns true when two alias sets overlap. */\nfunction hasAnyAlias(found: Set<string>, aliases: Set<string>): boolean {\n  return [...found].some((alias) => aliases.has(alias));\n}\n\n/** Returns true for collection anti-joins, i.e. `b.id IS NULL` or m2m target `t.id IS NULL` for root `att`. */\nfunction isCollectionAntiJoin(condition: ParsedExpressionCondition, root: CollectionRoot): boolean {\n  return collectionAntiJoinAliases(root).some((alias) => isAliasIdNull(condition, alias));\n}\n\n/** Returns aliases whose `id IS NULL` means the collection root has no matching row. */\nfunction collectionAntiJoinAliases(root: CollectionRoot): string[] {\n  return [...root.aliases].filter((alias) => {\n    if (alias === root.table.alias) return true;\n    const table = rootTable(root, alias);\n    // I.e. for m2m `authors -> authors_to_tags att -> tags t`, `t.id IS NULL` means no tag membership.\n    return table?.collection?.rootAlias === root.table.alias;\n  });\n}\n\n/** Returns a join table from a collection subtree by alias. */\nfunction rootTable(root: CollectionRoot, alias: string): JoinTable | undefined {\n  return root.joinTables.find((table) => table.alias === alias);\n}\n\n/** Returns true for `alias.id IS NULL`, i.e. the parse shape for `{ books: { id: null } }`. */\nfunction isAliasIdNull(condition: ParsedExpressionCondition, alias: string): boolean {\n  return (\n    condition.kind === \"column\" &&\n    condition.alias === alias &&\n    condition.column === \"id\" &&\n    condition.cond.kind === \"is-null\"\n  );\n}\n\n/** Returns true when a condition tree contains a collection anti-join branch inside an OR. */\nfunction conditionContainsCollectionAntiJoin(condition: ParsedExpressionCondition, root: CollectionRoot): boolean {\n  if (isCollectionAntiJoin(condition, root)) return true;\n  if (condition.kind === \"exp\") return condition.conditions.some((c) => conditionContainsCollectionAntiJoin(c, root));\n  return false;\n}\n\n/** Removes empty expression wrappers left behind by condition movement, i.e. `AND []` after all children moved. */\nfunction removeEmptyExpressions(exp: ParsedExpressionFilter | undefined): void {\n  if (!exp) return;\n  for (let i = exp.conditions.length - 1; i >= 0; i--) {\n    const condition = exp.conditions[i];\n    if (condition.kind === \"exp\") {\n      removeEmptyExpressions(condition);\n      if (condition.conditions.length === 0) exp.conditions.splice(i, 1);\n    }\n  }\n}\n\n/** Returns true if a condition must be preserved to maintain query semantics, i.e. user filters vs soft-delete filters. */\nfunction isRealCondition(condition: ParsedExpressionCondition): boolean {\n  if (condition.kind === \"column\" || condition.kind === \"raw\") {\n    return !condition.pruneable;\n  } else if (condition.kind === \"exists\") {\n    return true;\n  } else if (condition.kind === \"exp\") {\n    return condition.conditions.some(isRealCondition);\n  } else {\n    assertNever(condition);\n  }\n}\n\n/** Returns all aliases referenced by a condition, i.e. `b` and `a` in an OR. */\nfunction conditionAliases(condition: ParsedExpressionCondition): Set<string> {\n  const aliases = new Set<string>();\n  collectAllAliases(condition, aliases);\n  return aliases;\n}\n\n/** Collects all aliases referenced by a condition, including inside nested expressions, i.e. `b` and `a` in an OR. */\nfunction collectAllAliases(cond: ParsedExpressionCondition, out: Set<string>): void {\n  if (cond.kind === \"column\") {\n    out.add(cond.alias);\n  } else if (cond.kind === \"raw\") {\n    for (const a of cond.aliases) out.add(a);\n  } else if (cond.kind === \"exp\") {\n    for (const c of cond.conditions) collectAllAliases(c, out);\n  } else if (cond.kind === \"exists\") {\n    // I.e. an EXISTS subquery is already a scoped unit; outer movement decisions should not inspect its internals.\n  } else {\n    assertNever(cond);\n  }\n}\n"],"mappings":"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"}

package/build/QueryParser.collectionJoins.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryParser.collectionJoins.d.cts","names":[],"sources":["../src/QueryParser.collectionJoins.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;iBA2CgB,wBACd,OAAO,iBACP;EACE;EACA;EACA;EACA"}

package/build/QueryParser.collectionJoins.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryParser.collectionJoins.d.mts","names":[],"sources":["../src/QueryParser.collectionJoins.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;iBA2CgB,wBACd,OAAO,iBACP;EACE;EACA;EACA;EACA"}