{"version":3,"sources":["../src/query/order.ts","../src/query/expressions.ts"],"names":["sql","ConfigurationError","UnsupportedPredicateError","assertPortableScalarValueType","assertPortableCountDistinctValueType"],"mappings":"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","file":"chunk-AHUN2DLL.cjs","sourcesContent":["import { ConfigurationError } from \"../errors\";\nimport type { SortDirection } from \"./ast\";\nimport { sql, type SqlFragment } from \"./sql-fragment\";\n\n/** Compiles one portable scalar ORDER BY term with explicit null placement. */\nexport function compileOrderTerm(\n  expression: SqlFragment,\n  direction: \"asc\" | \"desc\",\n  nulls: \"first\" | \"last\",\n): SqlFragment {\n  validateOrderTokens(direction, nulls);\n  const directionSql = direction === \"asc\" ? sql.raw(\"ASC\") : sql.raw(\"DESC\");\n  const nullsSql =\n    nulls === \"first\" ? sql.raw(\"NULLS FIRST\") : sql.raw(\"NULLS LAST\");\n  return sql`${expression} ${directionSql} ${nullsSql}`;\n}\n\n/** Runtime AST input can bypass the TypeScript enum contract. */\nfunction validateOrderTokens(direction: string, nulls: string): void {\n  if (direction !== \"asc\" && direction !== \"desc\") {\n    throw new ConfigurationError(`Invalid ORDER BY direction: ${direction}`);\n  }\n  if (nulls !== \"first\" && nulls !== \"last\") {\n    throw new ConfigurationError(`Invalid ORDER BY null placement: ${nulls}`);\n  }\n}\n\n/** Resolves the portable null placement for an ordering specification. */\nexport function resolveNullOrdering(\n  order: Readonly<{\n    direction: SortDirection;\n    nulls?: \"first\" | \"last\" | undefined;\n  }>,\n): \"first\" | \"last\" {\n  return order.nulls ?? (order.direction === \"asc\" ? \"last\" : \"first\");\n}\n","import { UnsupportedPredicateError } from \"../errors\";\nimport {\n  assertPortableCountDistinctValueType,\n  assertPortableScalarValueType,\n} from \"./aggregate-value-types\";\nimport type { FieldRef, QueryAst, ValueType } from \"./ast\";\nimport { resolveNullOrdering } from \"./order\";\n\ntype DatabaseJsonValue =\n  | boolean\n  | number\n  | string\n  | null\n  | readonly DatabaseJsonValue[]\n  | Readonly<{ [key: string]: DatabaseJsonValue }>;\n\nexport type DatabaseLiteral = DatabaseJsonValue | Date | undefined;\n\nexport type ArithmeticOperator = \"add\" | \"divide\" | \"multiply\" | \"subtract\";\nexport type ExpressionComparisonOperator =\n  \"eq\" | \"gt\" | \"gte\" | \"lt\" | \"lte\" | \"neq\";\nexport type AggregateOperator =\n  \"avg\" | \"count\" | \"countDistinct\" | \"max\" | \"min\" | \"sum\";\n\nexport type CollectOrder<Scope extends string = string> = Readonly<{\n  expression: DatabaseExpression<\n    boolean | Date | number | string | undefined,\n    Scope\n  >;\n  direction?: \"asc\" | \"desc\";\n  nulls?: \"first\" | \"last\";\n}>;\n\n/** Options for ordered collection aggregation. */\nexport type CollectOptions<Scope extends string = string> = Readonly<{\n  filter?: DatabaseExpression<boolean | undefined, Scope>;\n  orderBy: readonly [CollectOrder<Scope>, ...CollectOrder<Scope>[]];\n}>;\n\nexport type CollectExpressionNode = Readonly<{\n  kind: \"collect\";\n  operand: DatabaseExpression | CollectRecordOperand;\n  filter?: DatabaseExpression<boolean | undefined>;\n  orderBy: readonly CollectOrder[];\n}>;\n\n/** Flat named scalar expressions collected as one JSON object per admitted row. */\nexport type CollectRecordOperand = Readonly<{\n  kind: \"record\";\n  fields: Readonly<Record<string, DatabaseExpression>>;\n}>;\n\n/** @internal */\nexport function isCollectRecordOperand(\n  operand: CollectExpressionNode[\"operand\"],\n): operand is CollectRecordOperand {\n  const kind: unknown = \"kind\" in operand ? operand.kind : undefined;\n  return kind === \"record\";\n}\n\n/** @internal Enumerates every value expression in a COLLECT operand. */\nexport function collectOperandExpressions(\n  operand: CollectExpressionNode[\"operand\"],\n): readonly DatabaseExpression[] {\n  return isCollectRecordOperand(operand) ?\n      resolveCollectRecordFields(operand.fields).map(\n        ({ expression }) => expression,\n      )\n    : [operand];\n}\n\n/** @internal */\nexport function isCollectScalarOperand(\n  operand: DatabaseExpression | Readonly<Record<string, unknown>>,\n): operand is DatabaseExpression {\n  return \"__type\" in operand && operand.__type === \"database_expression\";\n}\n\n/** @internal Validates and orders flat scalar record fields. */\nexport function resolveCollectRecordFields(\n  fields: unknown,\n): readonly Readonly<{ name: string; expression: DatabaseExpression }>[] {\n  if (typeof fields !== \"object\" || fields === null || Array.isArray(fields))\n    throw new UnsupportedPredicateError(\"COLLECT record requires a field map\");\n  const entries: readonly [string, unknown][] = Object.entries(fields);\n  if (entries.length === 0)\n    throw new UnsupportedPredicateError(\n      \"COLLECT record requires at least one field\",\n    );\n  return entries\n    .toSorted(([left], [right]) =>\n      left < right ? -1\n      : left > right ? 1\n      : 0,\n    )\n    .map(([name, expression]) => {\n      assertExpression(expression);\n      assertPortableScalarValueType(\n        expression.valueType,\n        \"COLLECT record field\",\n      );\n      return { name, expression };\n    });\n}\n\ntype FieldExpressionNode = Readonly<{\n  kind: \"field\";\n  field: FieldRef;\n}>;\ntype LiteralExpressionNode = Readonly<{\n  kind: \"literal\";\n  value: DatabaseLiteral;\n}>;\ntype ParameterExpressionNode = Readonly<{\n  kind: \"parameter\";\n  name: string;\n}>;\ntype ArithmeticExpressionNode = Readonly<{\n  kind: \"arithmetic\";\n  operator: ArithmeticOperator;\n  left: DatabaseExpression;\n  right: DatabaseExpression;\n}>;\ntype ComparisonExpressionNode = Readonly<{\n  kind: \"comparison\";\n  operator: ExpressionComparisonOperator;\n  left: DatabaseExpression;\n  right: DatabaseExpression;\n}>;\ntype ArrayContainsExpressionNode = Readonly<{\n  kind: \"array_contains\";\n  array: DatabaseExpression;\n  element: DatabaseExpression;\n}>;\ntype BooleanExpressionNode = Readonly<{\n  kind: \"boolean\";\n  operator: \"and\" | \"or\";\n  operands: readonly DatabaseExpression<boolean | undefined>[];\n}>;\ntype NotExpressionNode = Readonly<{\n  kind: \"not\";\n  operand: DatabaseExpression<boolean | undefined>;\n}>;\ntype NullCheckExpressionNode = Readonly<{\n  kind: \"null_check\";\n  operator: \"isNull\" | \"isNotNull\";\n  operand: DatabaseExpression;\n}>;\ntype AggregateExpressionNode = Readonly<{\n  kind: \"aggregate\";\n  operator: AggregateOperator;\n  operand?: DatabaseExpression | undefined;\n}>;\ntype CoalesceExpressionNode = Readonly<{\n  kind: \"coalesce\";\n  operands: readonly DatabaseExpression[];\n}>;\ntype ConditionalExpressionNode = Readonly<{\n  kind: \"conditional\";\n  condition: DatabaseExpression<boolean | undefined>;\n  then: DatabaseExpression;\n  otherwise: DatabaseExpression;\n}>;\ntype NumericConversionExpressionNode = Readonly<{\n  kind: \"numeric_conversion\";\n  operand: DatabaseExpression;\n}>;\ntype OuterReferenceExpressionNode = Readonly<{\n  kind: \"outer_reference\";\n  expression: DatabaseExpression;\n  outerScopeIdentity: symbol;\n}>;\ntype ExistsSubqueryExpressionNode = Readonly<{\n  kind: \"exists_subquery\";\n  subquery: QueryAst;\n}>;\ntype ScalarSubqueryExpressionNode = Readonly<{\n  kind: \"scalar_subquery\";\n  subquery: QueryAst;\n}>;\n\nexport type DatabaseExpressionNode =\n  | AggregateExpressionNode\n  | ArithmeticExpressionNode\n  | ArrayContainsExpressionNode\n  | BooleanExpressionNode\n  | CoalesceExpressionNode\n  | CollectExpressionNode\n  | ComparisonExpressionNode\n  | ConditionalExpressionNode\n  | ExistsSubqueryExpressionNode\n  | FieldExpressionNode\n  | LiteralExpressionNode\n  | NotExpressionNode\n  | NullCheckExpressionNode\n  | NumericConversionExpressionNode\n  | OuterReferenceExpressionNode\n  | ParameterExpressionNode\n  | ScalarSubqueryExpressionNode;\n\n/** A portable database expression carrying its decoded type and query scope. */\nexport type DatabaseExpression<\n  out T = unknown,\n  out Scope extends string = string,\n> = Readonly<{\n  __type: \"database_expression\";\n  node: DatabaseExpressionNode;\n  valueType: ValueType;\n  /** @internal Element typing for array operands; separate from result decoding. */\n  arrayElementType?: ValueType;\n  /** Element type carried by collection-valued expressions; records also carry field codecs. */\n  elementValueType?: ValueType;\n  /** Scalar codecs for fields of each collected record. */\n  elementFields?: Readonly<Record<string, ValueType>>;\n  nullable: boolean;\n  scopeIdentity: symbol;\n  /** @internal Carries the public result type without runtime data. */\n  __value?: T;\n  /** @internal Carries the public query scope without exposing SQL aliases. */\n  __scope?: Scope;\n}>;\n\ntype NonNull<T> = Exclude<T, undefined>;\ntype LiteralResult<T> = T extends null ? undefined : T;\ntype ParameterValue<Value extends ValueType> =\n  Value extends \"boolean\" ? boolean\n  : Value extends \"date\" ? Date\n  : Value extends \"number\" ? number\n  : Value extends \"string\" ? string\n  : Value extends \"array\" ? readonly DatabaseJsonValue[]\n  : Value extends \"object\" ? Readonly<Record<string, DatabaseJsonValue>>\n  : unknown;\ntype Comparable = boolean | Date | number | string;\ntype OrderedComparable = Date | number | string;\ntype NullIfEitherUndefined<Left, Right, Value> =\n  undefined extends Left | Right ? Value | undefined : Value;\ntype NumericExpression<Scope extends string> = DatabaseExpression<\n  number | undefined,\n  Scope\n>;\ntype ComparableExpression<\n  T extends Comparable,\n  Scope extends string,\n> = DatabaseExpression<T | undefined, Scope>;\n\nconst UNSCOPED_EXPRESSION = Symbol(\"unscoped database expression\");\n\nfunction createExpression<T, Scope extends string>(\n  node: DatabaseExpressionNode,\n  valueType: ValueType,\n  nullable: boolean,\n  scopeIdentity: symbol,\n  elementValueType?: ValueType,\n  elementFields?: Readonly<Record<string, ValueType>>,\n  arrayElementType?: ValueType,\n): DatabaseExpression<T, Scope> {\n  return {\n    __type: \"database_expression\",\n    node,\n    nullable,\n    scopeIdentity,\n    valueType,\n    ...(arrayElementType === undefined ? {} : { arrayElementType }),\n    ...(elementValueType === undefined ? {} : { elementValueType }),\n    ...(elementFields === undefined ? {} : { elementFields }),\n  };\n}\n\nfunction assertExpression(value: unknown): asserts value is DatabaseExpression {\n  if (\n    typeof value !== \"object\" ||\n    value === null ||\n    !(\"__type\" in value) ||\n    value.__type !== \"database_expression\"\n  ) {\n    throw new TypeError(\"Expected a database expression operand\");\n  }\n}\n\nfunction resolveScope(expressions: readonly DatabaseExpression[]): symbol {\n  for (const expression of expressions) assertExpression(expression);\n  const scoped = expressions.filter(\n    (expression) => expression.scopeIdentity !== UNSCOPED_EXPRESSION,\n  );\n  const firstScope = scoped[0]?.scopeIdentity;\n  if (\n    firstScope !== undefined &&\n    scoped.some((expression) => expression.scopeIdentity !== firstScope)\n  ) {\n    throw new TypeError(\n      \"Database expression operands belong to different query scopes\",\n    );\n  }\n  return firstScope ?? UNSCOPED_EXPRESSION;\n}\n\n/** @internal Compares scalar or record collection codecs across expression composition. */\nexport function haveCompatibleCollectionElements(\n  left: Pick<DatabaseExpression, \"elementValueType\" | \"elementFields\">,\n  right: Pick<DatabaseExpression, \"elementValueType\" | \"elementFields\">,\n): boolean {\n  if (left.elementValueType !== right.elementValueType) return false;\n  const leftFields = left.elementFields;\n  const rightFields = right.elementFields;\n  if (leftFields === undefined || rightFields === undefined)\n    return leftFields === rightFields;\n  const keys = Object.keys(leftFields);\n  return (\n    keys.length === Object.keys(rightFields).length &&\n    keys.every((key) => leftFields[key] === rightFields[key])\n  );\n}\n\nfunction assertSameValueType(\n  expressions: readonly DatabaseExpression[],\n): ValueType {\n  const firstExpression = expressions[0];\n  if (firstExpression === undefined)\n    throw new TypeError(\"At least one database expression is required\");\n  const valueType = firstExpression.valueType;\n  if (valueType === \"unknown\")\n    throw new TypeError(\"Unknown expression value types cannot be combined\");\n  if (expressions.some((expression) => expression.valueType !== valueType)) {\n    throw new TypeError(\n      \"Database expression operands have incompatible value types\",\n    );\n  }\n  if (\n    valueType === \"array\" &&\n    expressions.some(\n      (expression) =>\n        !haveCompatibleCollectionElements(expression, firstExpression),\n    )\n  )\n    throw new TypeError(\n      \"Database array expression operands have incompatible element value types\",\n    );\n  if (\n    valueType === \"array\" &&\n    expressions.some(\n      (expression) =>\n        expression.arrayElementType !== firstExpression.arrayElementType,\n    )\n  )\n    throw new TypeError(\n      \"Database array expression operands have incompatible array element types\",\n    );\n  return valueType;\n}\n\nfunction inferLiteralType(value: DatabaseLiteral): ValueType {\n  if (value === undefined || value === null) return \"unknown\";\n  if (value instanceof Date) return \"date\";\n  if (Array.isArray(value)) return \"array\";\n  if (typeof value === \"object\") return \"object\";\n  if (typeof value === \"boolean\") return \"boolean\";\n  if (typeof value === \"number\") return \"number\";\n  return \"string\";\n}\n\nfunction validateJsonLiteral(\n  value: unknown,\n  path: string,\n  ancestors: WeakSet<object>,\n): asserts value is DatabaseJsonValue {\n  if (value === undefined)\n    throw new TypeError(`JSON literal value at ${path} cannot be undefined`);\n  if (typeof value === \"number\" && !Number.isFinite(value))\n    throw new TypeError(`JSON literal number at ${path} must be finite`);\n  if (Array.isArray(value)) {\n    if (ancestors.has(value))\n      throw new TypeError(`JSON literal at ${path} cannot contain a cycle`);\n    ancestors.add(value);\n    for (const [index, element] of value.entries())\n      validateJsonLiteral(element, `${path}[${index}]`, ancestors);\n    ancestors.delete(value);\n    return;\n  }\n  if (typeof value === \"object\" && value !== null) {\n    const prototype = Object.getPrototypeOf(value) as unknown;\n    if (prototype !== Object.prototype && prototype !== null)\n      throw new TypeError(`Value at ${path} must be a plain JSON object`);\n    if (ancestors.has(value))\n      throw new TypeError(`JSON literal at ${path} cannot contain a cycle`);\n    ancestors.add(value);\n    for (const [key, element] of Object.entries(value))\n      validateJsonLiteral(element, `${path}.${key}`, ancestors);\n    ancestors.delete(value);\n    return;\n  }\n  if (\n    value !== null &&\n    typeof value !== \"boolean\" &&\n    typeof value !== \"number\" &&\n    typeof value !== \"string\"\n  )\n    throw new TypeError(`Value at ${path} is not a JSON literal`);\n}\n\n/** Validates and snapshots a value accepted by expression literals and bindings. */\nexport function normalizeDatabaseLiteral(\n  value: unknown,\n  contextName = \"$literal\",\n): DatabaseLiteral {\n  if (value instanceof Date) {\n    if (!Number.isFinite(value.getTime()))\n      throw new TypeError(`${contextName} must be a valid Date`);\n    return new Date(value);\n  }\n  if (value === undefined) return undefined;\n  validateJsonLiteral(value, contextName, new WeakSet());\n  return typeof value === \"object\" && value !== null ?\n      structuredClone(value)\n    : value;\n}\n\nexport function createFieldExpression<T, Scope extends string>(\n  field: FieldRef<T>,\n  scopeIdentity: symbol,\n  nullable: false,\n): DatabaseExpression<Exclude<T, undefined>, Scope>;\nexport function createFieldExpression<T, Scope extends string>(\n  field: FieldRef<T>,\n  scopeIdentity: symbol,\n  nullable: true,\n): DatabaseExpression<Exclude<T, undefined> | undefined, Scope>;\nexport function createFieldExpression<T, Scope extends string>(\n  field: FieldRef<T>,\n  scopeIdentity: symbol,\n  nullable: boolean,\n): DatabaseExpression<T | undefined, Scope>;\nexport function createFieldExpression<T, Scope extends string>(\n  field: FieldRef<T>,\n  scopeIdentity: symbol,\n  nullable: boolean,\n): DatabaseExpression<T | undefined, Scope> {\n  return createExpression(\n    { field, kind: \"field\" },\n    field.valueType ?? \"unknown\",\n    nullable,\n    scopeIdentity,\n    undefined,\n    undefined,\n    field.elementType,\n  );\n}\n\n/** @internal Reads array operand typing without turning it into result-decoding metadata. */\nexport function arrayExpressionElementType(\n  expression: DatabaseExpression,\n): ValueType | undefined {\n  if (expression.arrayElementType !== undefined)\n    return expression.arrayElementType;\n  if (expression.node.kind === \"field\")\n    return expression.node.field.elementType;\n  if (expression.node.kind === \"outer_reference\")\n    return arrayExpressionElementType(expression.node.expression);\n  if (expression.node.kind === \"coalesce\") {\n    const [first] = expression.node.operands;\n    return first === undefined ? undefined : arrayExpressionElementType(first);\n  }\n  if (expression.node.kind === \"conditional\")\n    return arrayExpressionElementType(expression.node.then);\n  return undefined;\n}\n\n/** @internal Refuses array membership types without portable scalar equality. */\nexport function assertPortableArrayMembershipElementType(\n  elementType: ValueType,\n): void {\n  if (\n    elementType === \"array\" ||\n    elementType === \"embedding\" ||\n    elementType === \"object\"\n  ) {\n    throw new UnsupportedPredicateError(\n      `Array membership does not support structured ${elementType} elements`,\n    );\n  }\n}\n\n/** @internal Rebinds an outer field into a child expression scope. */\nexport function createOuterReferenceExpression<T, Scope extends string>(\n  expression: DatabaseExpression<T>,\n  childScopeIdentity: symbol,\n): DatabaseExpression<T, Scope> {\n  if (expression.node.kind !== \"field\") {\n    throw new TypeError(\"Outer query references must be field expressions\");\n  }\n  return createExpression(\n    {\n      expression,\n      kind: \"outer_reference\",\n      outerScopeIdentity: expression.scopeIdentity,\n    },\n    expression.valueType,\n    expression.nullable,\n    childScopeIdentity,\n    expression.elementValueType,\n    expression.elementFields,\n    expression.arrayElementType,\n  );\n}\n\n/** @internal Creates a correlated EXISTS expression in its parent scope. */\nexport function createExistsSubqueryExpression<Scope extends string>(\n  subquery: QueryAst,\n  parentScopeIdentity: symbol,\n): DatabaseExpression<boolean, Scope> {\n  return createExpression(\n    { kind: \"exists_subquery\", subquery },\n    \"boolean\",\n    false,\n    parentScopeIdentity,\n  );\n}\n\n/** @internal Creates a nullable scalar subquery expression in its parent scope. */\nexport function createScalarSubqueryExpression<T, Scope extends string>(\n  subquery: QueryAst,\n  projected: DatabaseExpression<T>,\n  parentScopeIdentity: symbol,\n): DatabaseExpression<T | undefined, Scope> {\n  return createExpression(\n    { kind: \"scalar_subquery\", subquery },\n    projected.valueType,\n    true,\n    parentScopeIdentity,\n    projected.elementValueType,\n    projected.elementFields,\n    projected.arrayElementType,\n  );\n}\n\nfunction literal<T extends DatabaseLiteral>(\n  value: T,\n): DatabaseExpression<LiteralResult<T>, never> {\n  const storedValue = normalizeDatabaseLiteral(value) as T;\n  return createExpression(\n    { kind: \"literal\", value: storedValue },\n    inferLiteralType(value),\n    inferLiteralType(value) === \"unknown\",\n    UNSCOPED_EXPRESSION,\n  );\n}\n\nfunction parameter<Value extends ValueType>(\n  name: string,\n  valueType: Value,\n): DatabaseExpression<ParameterValue<Value>, never> {\n  if (name.length === 0) throw new TypeError(\"Parameter names cannot be empty\");\n  if (valueType === \"unknown\")\n    throw new TypeError(\"Parameters require a concrete value type\");\n  return createExpression(\n    { kind: \"parameter\", name },\n    valueType,\n    false,\n    UNSCOPED_EXPRESSION,\n  );\n}\n\nfunction arithmetic<\n  Operator extends ArithmeticOperator,\n  Left extends number | undefined,\n  Right extends number | undefined,\n  Scope extends string,\n>(\n  operator: Operator,\n  left: DatabaseExpression<Left, Scope>,\n  right: DatabaseExpression<Right, Scope>,\n): DatabaseExpression<\n  Operator extends \"divide\" ? number | undefined\n  : NullIfEitherUndefined<Left, Right, number>,\n  Scope\n> {\n  const scopeIdentity = resolveScope([left, right]);\n  if (left.valueType !== \"number\" || right.valueType !== \"number\")\n    throw new TypeError(\"Arithmetic operands must be numeric expressions\");\n  return createExpression(\n    { kind: \"arithmetic\", left, operator, right },\n    \"number\",\n    left.nullable || right.nullable || operator === \"divide\",\n    scopeIdentity,\n  );\n}\n\nfunction comparison<\n  Left extends Comparable | undefined,\n  Right extends NonNull<Left> | undefined,\n  Scope extends string,\n>(\n  operator: ExpressionComparisonOperator,\n  left: DatabaseExpression<Left, Scope>,\n  right: DatabaseExpression<Right, Scope>,\n): DatabaseExpression<NullIfEitherUndefined<Left, Right, boolean>, Scope> {\n  const scopeIdentity = resolveScope([left, right]);\n  assertSameValueType([left, right]);\n  return createExpression(\n    { kind: \"comparison\", left, operator, right },\n    \"boolean\",\n    left.nullable || right.nullable,\n    scopeIdentity,\n  );\n}\n\ntype ArrayExpressionElement<ArrayValue> =\n  ArrayValue extends readonly (infer Element)[] ? Element : never;\n\nfunction arrayContains<\n  ArrayValue extends readonly unknown[] | undefined,\n  Scope extends string,\n>(\n  array: DatabaseExpression<ArrayValue, Scope>,\n  element: DatabaseExpression<\n    ArrayExpressionElement<ArrayValue> | undefined,\n    Scope\n  >,\n): DatabaseExpression<boolean, Scope> {\n  const scopeIdentity = resolveScope([array, element]);\n  if (array.valueType !== \"array\")\n    throw new TypeError(\"arrayContains requires an array expression\");\n  const elementType = arrayExpressionElementType(array);\n  if (elementType === undefined || elementType === \"unknown\")\n    throw new TypeError(\"arrayContains requires a known array element type\");\n  assertPortableArrayMembershipElementType(elementType);\n  if (elementType !== element.valueType)\n    throw new TypeError(\n      \"arrayContains operands have incompatible element types\",\n    );\n  return createExpression<boolean, Scope>(\n    { array, element, kind: \"array_contains\" },\n    \"boolean\",\n    false,\n    scopeIdentity,\n  );\n}\n\nfunction booleanComposition<Scope extends string>(\n  operator: \"and\" | \"or\",\n  operands: readonly DatabaseExpression<boolean | undefined, Scope>[],\n): DatabaseExpression<boolean | undefined, Scope> {\n  if (operands.length === 0)\n    throw new TypeError(`Boolean ${operator} requires at least one operand`);\n  const scopeIdentity = resolveScope(operands);\n  if (operands.some((operand) => operand.valueType !== \"boolean\"))\n    throw new TypeError(\"Boolean operands must be Boolean expressions\");\n  return createExpression(\n    { kind: \"boolean\", operands, operator },\n    \"boolean\",\n    operands.some((operand) => operand.nullable),\n    scopeIdentity,\n  );\n}\n\nfunction not<Scope extends string>(\n  operand: DatabaseExpression<boolean | undefined, Scope>,\n): DatabaseExpression<boolean | undefined, Scope> {\n  const scopeIdentity = resolveScope([operand]);\n  if (operand.valueType !== \"boolean\")\n    throw new TypeError(\"NOT requires a Boolean expression\");\n  return createExpression(\n    { kind: \"not\", operand },\n    \"boolean\",\n    operand.nullable,\n    scopeIdentity,\n  );\n}\n\nfunction nullCheck<T, Scope extends string>(\n  operator: \"isNull\" | \"isNotNull\",\n  operand: DatabaseExpression<T, Scope>,\n): DatabaseExpression<boolean, Scope> {\n  return createExpression(\n    { kind: \"null_check\", operand, operator },\n    \"boolean\",\n    false,\n    resolveScope([operand]),\n  );\n}\n\nfunction isNull<T, Scope extends string>(\n  operand: DatabaseExpression<T, Scope>,\n): DatabaseExpression<boolean, Scope> {\n  return nullCheck(\"isNull\", operand);\n}\n\nfunction isNotNull<T, Scope extends string>(\n  operand: DatabaseExpression<T, Scope>,\n): DatabaseExpression<boolean, Scope> {\n  return nullCheck(\"isNotNull\", operand);\n}\n\nfunction aggregate<T, Scope extends string>(\n  operator: AggregateOperator,\n  operand: DatabaseExpression<T, Scope> | undefined,\n  valueType: ValueType,\n): DatabaseExpression<number | undefined, Scope> {\n  const scopeIdentity =\n    operand === undefined ? UNSCOPED_EXPRESSION : resolveScope([operand]);\n  return createExpression(\n    { kind: \"aggregate\", operand, operator },\n    valueType,\n    operator !== \"count\" && operator !== \"countDistinct\",\n    scopeIdentity,\n  );\n}\n\nfunction count<Scope extends string = never>(\n  operand?: DatabaseExpression<unknown, Scope>,\n): DatabaseExpression<number, Scope> {\n  return aggregate(\"count\", operand, \"number\") as DatabaseExpression<\n    number,\n    Scope\n  >;\n}\n\nfunction countDistinct<Scope extends string>(\n  operand: DatabaseExpression<\n    boolean | Date | number | string | undefined,\n    Scope\n  >,\n): DatabaseExpression<number, Scope> {\n  assertPortableCountDistinctValueType(operand.valueType);\n  return aggregate(\"countDistinct\", operand, \"number\") as DatabaseExpression<\n    number,\n    Scope\n  >;\n}\n\n/** Validates and resolves collection ordering for builders and raw expression compilation. */\nexport function resolveCollectOrder<Scope extends string>(\n  orderBy: readonly CollectOrder<Scope>[] | undefined,\n): readonly Readonly<{\n  expression: CollectOrder<Scope>[\"expression\"];\n  direction: \"asc\" | \"desc\";\n  nulls: \"first\" | \"last\";\n}>[] {\n  if (!Array.isArray(orderBy) || orderBy.length === 0)\n    throw new UnsupportedPredicateError(\n      \"COLLECT requires at least one ordering expression\",\n    );\n  return orderBy.map((order: CollectOrder<Scope>) => {\n    assertPortableScalarValueType(\n      order.expression.valueType,\n      \"COLLECT ordering\",\n    );\n    const direction = order.direction ?? \"asc\";\n    if (![\"asc\", \"desc\"].includes(direction))\n      throw new UnsupportedPredicateError(\n        \"COLLECT ordering direction must be asc or desc\",\n      );\n    const nulls = resolveNullOrdering({ ...order, direction });\n    if (![\"first\", \"last\"].includes(nulls))\n      throw new UnsupportedPredicateError(\n        \"COLLECT null ordering must be first or last\",\n      );\n    return { expression: order.expression, direction, nulls };\n  });\n}\n\n/** Validates the optional row filter shared by builders and raw compilation. */\nexport function resolveCollectFilter<Scope extends string>(\n  filter: DatabaseExpression<boolean | undefined, Scope> | undefined,\n): DatabaseExpression<boolean | undefined, Scope> | undefined {\n  if (filter !== undefined && filter.valueType !== \"boolean\")\n    throw new UnsupportedPredicateError(\n      \"COLLECT filter requires a Boolean expression\",\n    );\n  return filter;\n}\n\n/** Explicitly named scalar expressions accepted by record collection aggregation. */\nexport type CollectRecordFields<Scope extends string = string> = Readonly<\n  Record<string, DatabaseExpression<Comparable | undefined, Scope>>\n>;\n/** Readonly decoded record inferred from a collection field map. */\nexport type CollectedRecord<Fields extends CollectRecordFields<string>> =\n  Readonly<{\n    [Name in keyof Fields]: Fields[Name] extends (\n      DatabaseExpression<infer Value>\n    ) ?\n      Value\n    : never;\n  }>;\n\n/** Collects scalar values in explicit order, optionally filtering admitted rows. */\nfunction collect<T extends Comparable | undefined, Scope extends string>(\n  operand: DatabaseExpression<T, Scope>,\n  options: CollectOptions<Scope>,\n): DatabaseExpression<readonly T[], Scope>;\n/** Collects explicitly projected scalar fields into ordered readonly records. */\nfunction collect<\n  Scope extends string,\n  Fields extends CollectRecordFields<Scope>,\n>(\n  operand: Fields & CollectRecordFields<Scope>,\n  options: CollectOptions<Scope>,\n): DatabaseExpression<readonly CollectedRecord<Fields>[], Scope>;\nfunction collect<Scope extends string>(\n  operand:\n    | DatabaseExpression<Comparable | undefined, Scope>\n    | CollectRecordFields<Scope>,\n  options: CollectOptions<Scope>,\n): DatabaseExpression<readonly unknown[], Scope> {\n  const scalar = isCollectScalarOperand(operand);\n  const recordEntries = scalar ? [] : resolveCollectRecordFields(operand);\n  if (scalar) assertPortableScalarValueType(operand.valueType, \"COLLECT\");\n  const values =\n    scalar ? [operand] : recordEntries.map(({ expression }) => expression);\n  const recordFields =\n    scalar ? undefined : (\n      Object.fromEntries(\n        recordEntries.map(({ name, expression }) => [\n          name,\n          expression.valueType,\n        ]),\n      )\n    );\n  const orderBy = resolveCollectOrder(options.orderBy);\n  const filter = resolveCollectFilter(options.filter);\n  const scopeIdentity = resolveScope([\n    ...values,\n    ...orderBy.map((order) => order.expression),\n    ...(filter === undefined ? [] : [filter]),\n  ]);\n  return createExpression(\n    {\n      ...(filter === undefined ? {} : { filter }),\n      kind: \"collect\",\n      operand:\n        scalar ? operand : (\n          {\n            kind: \"record\",\n            fields: Object.fromEntries(\n              recordEntries.map(({ name, expression }) => [name, expression]),\n            ),\n          }\n        ),\n      orderBy,\n    },\n    \"array\",\n    false,\n    scopeIdentity,\n    scalar ? operand.valueType : \"object\",\n    recordFields,\n  );\n}\n\nfunction numericAggregate<Scope extends string>(\n  operator: \"avg\" | \"sum\",\n  operand: NumericExpression<Scope>,\n): NumericExpression<Scope> {\n  if (operand.valueType !== \"number\")\n    throw new TypeError(`${operator} requires a numeric expression`);\n  return aggregate(operator, operand, \"number\");\n}\n\nfunction extrema<T extends OrderedComparable, Scope extends string>(\n  operator: \"max\" | \"min\",\n  operand: ComparableExpression<T, Scope>,\n): DatabaseExpression<T | undefined, Scope> {\n  if (\n    operand.valueType !== \"number\" &&\n    operand.valueType !== \"string\" &&\n    operand.valueType !== \"date\"\n  )\n    throw new TypeError(`${operator} requires a comparable expression`);\n  return createExpression(\n    { kind: \"aggregate\", operand, operator },\n    operand.valueType,\n    true,\n    resolveScope([operand]),\n  );\n}\n\nfunction coalesce<T, Scope extends string>(\n  first: DatabaseExpression<T | undefined, Scope>,\n  fallback: DatabaseExpression<NoInfer<T>, Scope>,\n  ...rest: readonly DatabaseExpression<NoInfer<T> | undefined, Scope>[]\n): DatabaseExpression<T, Scope>;\nfunction coalesce<T, Scope extends string>(\n  first: DatabaseExpression<T | undefined, Scope>,\n  ...rest: readonly DatabaseExpression<NoInfer<T> | undefined, Scope>[]\n): DatabaseExpression<T | undefined, Scope> {\n  const operands = [first, ...rest];\n  const scopeIdentity = resolveScope(operands);\n  const valueType = assertSameValueType(operands);\n  return createExpression(\n    { kind: \"coalesce\", operands },\n    valueType,\n    operands.every((operand) => operand.nullable),\n    scopeIdentity,\n    first.elementValueType,\n    first.elementFields,\n    first.arrayElementType,\n  );\n}\n\nfunction when<\n  Then,\n  Otherwise extends NonNull<Then> | undefined,\n  Scope extends string,\n>(\n  condition: DatabaseExpression<boolean | undefined, Scope>,\n  then: DatabaseExpression<Then, Scope>,\n  otherwise: DatabaseExpression<Otherwise, Scope>,\n): DatabaseExpression<\n  NullIfEitherUndefined<Then, Otherwise, NonNull<Then>>,\n  Scope\n> {\n  const scopeIdentity = resolveScope([condition, then, otherwise]);\n  if (condition.valueType !== \"boolean\")\n    throw new TypeError(\"Conditional expressions require a Boolean condition\");\n  const valueType = assertSameValueType([then, otherwise]);\n  return createExpression(\n    // eslint-disable-next-line unicorn/no-thenable -- `then` is the SQL conditional branch.\n    { condition, kind: \"conditional\", otherwise, then },\n    valueType,\n    then.nullable || otherwise.nullable,\n    scopeIdentity,\n    then.elementValueType,\n    then.elementFields,\n    then.arrayElementType,\n  );\n}\n\nfunction toNumber<Scope extends string>(\n  operand: DatabaseExpression<number | string | undefined, Scope>,\n): NumericExpression<Scope> {\n  const allowed =\n    operand.valueType === \"number\" || operand.valueType === \"string\";\n  if (!allowed)\n    throw new TypeError(\n      \"Numeric conversion requires a string or number expression\",\n    );\n  return createExpression(\n    { kind: \"numeric_conversion\", operand },\n    \"number\",\n    true,\n    resolveScope([operand]),\n  );\n}\n\nexport const expr = {\n  add: <\n    Left extends number | undefined,\n    Right extends number | undefined,\n    Scope extends string,\n  >(\n    left: DatabaseExpression<Left, Scope>,\n    right: DatabaseExpression<Right, Scope>,\n  ) => arithmetic(\"add\", left, right),\n  and: <Scope extends string>(\n    ...operands: readonly DatabaseExpression<boolean | undefined, Scope>[]\n  ) => booleanComposition(\"and\", operands),\n  arrayContains,\n  avg: <Scope extends string>(operand: NumericExpression<Scope>) =>\n    numericAggregate(\"avg\", operand),\n  coalesce,\n  collect,\n  count,\n  countDistinct,\n  divide: <\n    Left extends number | undefined,\n    Right extends number | undefined,\n    Scope extends string,\n  >(\n    left: DatabaseExpression<Left, Scope>,\n    right: DatabaseExpression<Right, Scope>,\n  ) => arithmetic(\"divide\", left, right),\n  eq: <\n    Left extends Comparable | undefined,\n    Right extends NonNull<Left> | undefined,\n    Scope extends string,\n  >(\n    left: DatabaseExpression<Left, Scope>,\n    right: DatabaseExpression<Right, Scope>,\n  ) => comparison(\"eq\", left, right),\n  gt: <\n    Left extends Comparable | undefined,\n    Right extends NonNull<Left> | undefined,\n    Scope extends string,\n  >(\n    left: DatabaseExpression<Left, Scope>,\n    right: DatabaseExpression<Right, Scope>,\n  ) => comparison(\"gt\", left, right),\n  gte: <\n    Left extends Comparable | undefined,\n    Right extends NonNull<Left> | undefined,\n    Scope extends string,\n  >(\n    left: DatabaseExpression<Left, Scope>,\n    right: DatabaseExpression<Right, Scope>,\n  ) => comparison(\"gte\", left, right),\n  isNotNull,\n  isNull,\n  literal,\n  lt: <\n    Left extends Comparable | undefined,\n    Right extends NonNull<Left> | undefined,\n    Scope extends string,\n  >(\n    left: DatabaseExpression<Left, Scope>,\n    right: DatabaseExpression<Right, Scope>,\n  ) => comparison(\"lt\", left, right),\n  lte: <\n    Left extends Comparable | undefined,\n    Right extends NonNull<Left> | undefined,\n    Scope extends string,\n  >(\n    left: DatabaseExpression<Left, Scope>,\n    right: DatabaseExpression<Right, Scope>,\n  ) => comparison(\"lte\", left, right),\n  max: <T extends OrderedComparable, Scope extends string>(\n    operand: ComparableExpression<T, Scope>,\n  ) => extrema(\"max\", operand),\n  min: <T extends OrderedComparable, Scope extends string>(\n    operand: ComparableExpression<T, Scope>,\n  ) => extrema(\"min\", operand),\n  multiply: <\n    Left extends number | undefined,\n    Right extends number | undefined,\n    Scope extends string,\n  >(\n    left: DatabaseExpression<Left, Scope>,\n    right: DatabaseExpression<Right, Scope>,\n  ) => arithmetic(\"multiply\", left, right),\n  neq: <\n    Left extends Comparable | undefined,\n    Right extends NonNull<Left> | undefined,\n    Scope extends string,\n  >(\n    left: DatabaseExpression<Left, Scope>,\n    right: DatabaseExpression<Right, Scope>,\n  ) => comparison(\"neq\", left, right),\n  not,\n  or: <Scope extends string>(\n    ...operands: readonly DatabaseExpression<boolean | undefined, Scope>[]\n  ) => booleanComposition(\"or\", operands),\n  param: parameter,\n  subtract: <\n    Left extends number | undefined,\n    Right extends number | undefined,\n    Scope extends string,\n  >(\n    left: DatabaseExpression<Left, Scope>,\n    right: DatabaseExpression<Right, Scope>,\n  ) => arithmetic(\"subtract\", left, right),\n  sum: <Scope extends string>(operand: NumericExpression<Scope>) =>\n    numericAggregate(\"sum\", operand),\n  toNumber,\n  when,\n} as const;\n"]}