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

package/build/queries/sql/execute.js.map

@@ -1 +1 @@
-{"version":3,"file":"execute.js","names":[],"sources":["../../../src/queries/sql/execute.ts"],"sourcesContent":["import type { Column } from \"../../columns.ts\";\nimport type { DriverQueryResult } from \"../../drivers/Driver.ts\";\nimport { type Entity, isEntity } from \"../../Entity.ts\";\nimport type { IdOf } from \"../../EntityManager.ts\";\nimport type { EntityMetadata } from \"../../EntityMetadata.ts\";\nimport { keyToTaggedId, toTaggedId } from \"../../keys.ts\";\nimport type { ColumnsOf, TypeMapEntry } from \"../../typeMap.ts\";\nimport { fail } from \"../../utils.ts\";\nimport type { SqlCondition } from \"../conditions.ts\";\nimport { AliasAssigner } from \"./AliasAssigner.ts\";\nimport { type ExprBrand, type ExprLike, type SqlFragment, asNode, exprBrand, isExpr } from \"./Expr.ts\";\nimport { kq, safeKq } from \"./keywords.ts\";\nimport {\n  type CheckReadQuery,\n  type CheckScope,\n  type CheckSetQuery,\n  Ctx,\n  type EntityHydrator,\n  type NameOf,\n  type Plan,\n  type Query,\n  type QueryJoins,\n  type QueryRow,\n  type ReadQueryRow,\n  type SetOperand,\n  type SetOperation,\n  type SetQuery,\n  type Subquery,\n  type WithInput,\n  conditionToSql,\n  entityQueryBrand,\n  injectedConditions,\n  isReadQueryValue,\n  parseNestedQuery,\n  parseUserQuery,\n  projectionToSql,\n  pruneCtes,\n  registerCtes,\n  subqueryBrand,\n  withFragment,\n} from \"./query.ts\";\nimport { type TableFor, getTableMgmt, isTable, tableMgmt } from \"./Tables.ts\";\n\n/** The native command count and decoded rows from one immediate SQL statement. */\nexport interface ExecuteResult<R> {\n  rowCount: number;\n  rows: R[];\n}\n\n/** A mutation's RETURNING projection: one SQL expression or a named object of expressions. */\nexport type MutationReturning = (ExprLike<unknown> | Readonly<Record<string, ExprLike<unknown>>>) & {\n  readonly [tableMgmt]?: never;\n  readonly [subqueryBrand]?: never;\n  readonly [entityQueryBrand]?: never;\n};\n\n/** SQL INSERT inputs, based on physical storage rather than entity creation options. */\nexport type InsertValues<T extends Entity> = {\n  [K in RequiredInsertKey<T>]: Assignment<T, K>;\n} & {\n  [K in Exclude<InsertKey<T>, RequiredInsertKey<T>>]?: Assignment<T, K> | undefined;\n};\n\n/** SQL UPDATE inputs include persisted derived columns, but never primary keys. */\nexport type UpdateValues<T extends Entity> = {\n  [K in UpdateKey<T>]?: Assignment<T, K> | undefined;\n};\n\n/** A reusable INSERT POJO; use a concrete Q for annotated INSERT SELECT source checking. */\nexport type InsertStatement<\n  T extends Entity,\n  R extends MutationReturning | undefined = MutationReturning | undefined,\n  Q extends SetOperand = Query<InsertProjection<T>, []> | Subquery<InsertSourceRow<T>, string>,\n> = {\n  readonly insert: MutationTarget<T>;\n  readonly returning?: R;\n  readonly update?: never;\n  readonly delete?: never;\n  readonly set?: never;\n  readonly where?: never;\n  readonly allowAll?: never;\n  readonly softDeletes?: never;\n  /** CTEs to add to a `WITH` before the INSERT; see `Clauses.with`. */\n  readonly with?: WithInput;\n} & NoMutationReadClauses &\n  (\n    | { readonly values: InsertValues<T> | readonly InsertValues<T>[]; readonly from?: never }\n    | { readonly from: Q & CheckInsertSource<T, Q>; readonly values?: never }\n  );\n\n/** A reusable guarded UPDATE POJO. Undefined assignments leave existing columns unchanged. */\nexport type UpdateStatement<\n  T extends Entity,\n  R extends MutationReturning | undefined = MutationReturning | undefined,\n> = {\n  readonly update: MutationTarget<T>;\n  readonly set: UpdateValues<T>;\n  readonly returning?: R;\n  readonly insert?: never;\n  readonly delete?: never;\n  readonly values?: never;\n  readonly from?: never;\n  /** CTEs to add to a `WITH` before the UPDATE; see `Clauses.with`. */\n  readonly with?: WithInput;\n} & MutationFilter &\n  NoMutationReadClauses;\n\n/** A reusable guarded physical DELETE POJO, not an ORM soft delete. */\nexport type DeleteStatement<\n  T extends Entity,\n  R extends MutationReturning | undefined = MutationReturning | undefined,\n> = {\n  readonly delete: MutationTarget<T>;\n  readonly returning?: R;\n  readonly insert?: never;\n  readonly update?: never;\n  readonly values?: never;\n  readonly from?: never;\n  readonly set?: never;\n  /** CTEs to add to a `WITH` before the DELETE; see `Clauses.with`. */\n  readonly with?: WithInput;\n} & MutationFilter &\n  NoMutationReadClauses;\n\n/** Public statement annotations retain the target's physical field policy. */\nexport type MutationStatement<\n  T extends Entity,\n  R extends MutationReturning | undefined = MutationReturning | undefined,\n> = InsertStatement<T, R> | UpdateStatement<T, R> | DeleteStatement<T, R>;\n\n/** Inference starts with the literal POJO; CheckMutation checks its target and every supplied key. */\nexport type MutationInput = (\n  | { readonly insert: TableFor<Entity>; readonly values: object | readonly object[]; readonly from?: never }\n  | { readonly insert: TableFor<Entity>; readonly from: SetOperand; readonly values?: never }\n  | { readonly update: TableFor<Entity>; readonly set: object }\n  | { readonly delete: TableFor<Entity> }\n) & { readonly returning?: MutationReturning; readonly with?: WithInput } & MutationFilter;\n\n/** Without RETURNING the row type is never; scalar expressions produce scalar rows. */\nexport type MutationRow<M> = M extends { readonly returning?: infer R }\n  ? R extends MutationReturning\n    ? R extends ExprLike<unknown>\n      ? QueryRow<R>\n      : { -readonly [K in keyof QueryRow<R>]: QueryRow<R>[K] }\n    : never\n  : never;\n\n/** Checks nonliteral statements as well as fresh literals without widening their inferred result. */\nexport type CheckMutation<M> = M extends unknown\n  ? TargetEntity<M> extends infer T extends Entity\n    ? TypeMapEntry<T, \"supportsEmExecute\"> extends true\n      ? { readonly [K in keyof M]: K extends MutationClause<M> ? unknown : never } & {\n          readonly returning?: M extends { readonly returning?: infer R }\n            ? CheckReturning<R, NameOf<TargetTable<M>>>\n            : never;\n        } & (\n            | (M extends { readonly values: infer V } ? { readonly values: CheckValues<T, V> } : never)\n            | (M extends { readonly from: infer Q extends SetOperand }\n                ? { readonly from: CheckInsertSource<T, Q> }\n                : never)\n            | (M extends { readonly set: infer V }\n                ? { readonly set: CheckAssignments<V, UpdateValues<T>, NameOf<TargetTable<M>>> }\n                : never)\n            | (M extends { readonly delete: unknown } ? unknown : never)\n          )\n      : \"SQL mutations require a supported non-inherited target and regenerated metadata\"\n    : never\n  : never;\n\n/** Classifies mutation roots before EntityManager applies write permissions, including malformed roots. */\nexport function isMutation(arg: unknown): boolean {\n  return (\n    typeof arg === \"object\" &&\n    arg !== null &&\n    !isReadQueryValue(arg) &&\n    [\"insert\", \"update\", \"delete\"].some((key) => key in arg)\n  );\n}\n\n/**\n * Compiles one immediate statement using the read compiler's scopes, projections, and codecs.\n * INSERT SELECT keeps source rows in PostgreSQL; only RETURNING rows pass through JS decoders.\n * An undefined plan represents a validated standalone empty VALUES array, not DEFAULT VALUES.\n */\nexport function parseStatement(arg: unknown): Plan | undefined {\n  if (!isMutation(arg)) return parseUserQuery(arg);\n  const statement = arg as Record<string, unknown>;\n  const roots = [\"insert\", \"update\", \"delete\"].filter((key) => key in statement);\n  if (roots.length !== 1) fail(\"A mutation requires exactly one insert, update, or delete root\");\n  const operation = roots[0];\n  const allowed =\n    operation === \"insert\"\n      ? [\"insert\", \"values\", \"from\", \"returning\", \"with\"]\n      : [\n          operation,\n          \"where\",\n          \"allowAll\",\n          \"softDeletes\",\n          \"returning\",\n          \"with\",\n          ...(operation === \"update\" ? [\"set\"] : []),\n        ];\n  checkPojo(statement, allowed, `SQL ${operation}`);\n  const target = statement[operation];\n  if (!isTable(target)) fail(\"A mutation target must be an entity table\");\n  const mgmt = getTableMgmt(target);\n  const meta = mgmt.meta;\n  if (meta.inheritanceType || meta.baseType || meta.baseTypes.length || meta.subTypes.length) {\n    fail(\"SQL mutations do not support CTI/STI targets or inherited table families\");\n  }\n  if (meta.supportsEmExecute !== true)\n    fail(`SQL mutations require supported physical metadata for ${meta.type}; run codegen`);\n  const fields = Object.entries(meta.columns);\n  for (const [, field] of fields) {\n    requireColumnMetadata(meta, field);\n  }\n  const assigner = new AliasAssigner();\n  // A CTE is in scope for the whole statement, so its scope is the parent of every other one here. It\n  // deliberately holds no target alias, which is what lets INSERT VALUES cells and the INSERT SELECT\n  // source read the CTEs without also seeing the row being written.\n  const withCtx = new Ctx(assigner, undefined);\n  const ctes = registerCtes(statement, withCtx, assigner);\n  // Aliases the rest of the statement reads, so an unread CTE prunes like it does on a read query.\n  const refs: string[] = [];\n  const ctx = new Ctx(assigner, withCtx);\n  const alias = assigner.getAlias(meta.tableName);\n  ctx.register(mgmt, alias);\n  const returning = statement.returning === undefined ? undefined : projectionToSql(statement.returning, ctx);\n  if (returning) for (const select of returning.selects) refs.push(...select.refs);\n  let sql = `${operation === \"delete\" ? \"DELETE FROM\" : operation.toUpperCase() + (operation === \"insert\" ? \" INTO\" : \"\")} ${kq(meta.tableName)} AS ${kq(alias)}`;\n  const bindings: unknown[] = [];\n  if (operation === \"insert\") {\n    if (\"values\" in statement === \"from\" in statement) fail(\"INSERT requires exactly one of values or from\");\n    const required = fields.filter(([, column]) => column.insert === \"required\");\n    if (\"values\" in statement) {\n      const rows = Array.isArray(statement.values) ? statement.values : [statement.values];\n      // A VALUES cell *is* the new row, so there is no existing row for it to read: this scope skips\n      // the `ctx.register(mgmt, alias)` above, so a cell naming the target fails instead of emitting a\n      // `b` with no FROM clause. I.e. an UPDATE can say `set: { title: b.title }`; an INSERT cannot.\n      // A value subquery still works, because it brings its own sources, and the parent here is the CTE\n      // scope rather than `ctx`, so a cell can read a `with` entry but not the row being written.\n      const valuesCtx = new Ctx(assigner, withCtx);\n      const entries = rows.map((row) => assignments(meta, row, \"insert\"));\n      for (const row of entries) {\n        for (const [key] of required) {\n          if (!row.some((entry) => entry[0] === key)) fail(`INSERT requires ${meta.type}.${key}`);\n        }\n      }\n      if (rows.length === 0) return undefined;\n      const keys = fields.filter(([key]) => entries.some((row) => row.some((entry) => entry[0] === key)));\n      sql += ` (${keys.map(([, field]) => kq(field.columnName)).join(\", \")}) VALUES `;\n      sql += entries\n        .map((row) => {\n          const cells = keys.map(([key, field]) => {\n            const entry = row.find((entry) => entry[0] === key);\n            if (!entry) return \"DEFAULT\";\n            const cell = assignmentToSql(meta, field, entry[1], valuesCtx);\n            bindings.push(...cell.bindings);\n            refs.push(...cell.refs);\n            return cell.sql;\n          });\n          return `(${cells.join(\", \")})`;\n        })\n        .join(\", \");\n    } else {\n      const source = parseNestedQuery(statement.from, withCtx, assigner);\n      if (source.output.kind !== \"pojo\") fail(\"INSERT SELECT requires named POJO output columns\");\n      const columns = source.output.columns;\n      for (const [key] of required) {\n        if (!columns.some((column) => column[0] === key)) fail(`INSERT requires ${meta.type}.${key}`);\n      }\n      for (const [key, expr] of columns) {\n        const field = writableField(meta, key, \"insert\");\n        const left = field.outputType;\n        const right = expr.outputType;\n        if (\n          !left ||\n          !right ||\n          left.dbType !== right.dbType ||\n          left.domain !== right.domain ||\n          left.idMeta !== right.idMeta\n        ) {\n          fail(`INSERT SELECT ${meta.type}.${key} has incompatible or unknown storage codecs`);\n        }\n        if (!field.sqlNullable && expr.sqlNullable === true)\n          fail(`INSERT SELECT ${meta.type}.${key} cannot accept a nullable output`);\n      }\n      const keys = fields.filter(([key]) => columns.some((column) => column[0] === key));\n      const sourceAlias = safeKq(assigner.getLiteralAlias(\"sq\"));\n      sql += ` (${keys.map(([, field]) => kq(field.columnName)).join(\", \")}) SELECT ${keys.map(([key]) => `${sourceAlias}.${safeKq(key)}`).join(\", \")} FROM (${source.sql}) AS ${sourceAlias}`;\n      bindings.push(...source.bindings);\n      refs.push(...source.outerRefs);\n    }\n  } else {\n    if (statement.allowAll !== undefined && typeof statement.allowAll !== \"boolean\") fail(\"allowAll must be a boolean\");\n    if (\n      statement.softDeletes !== undefined &&\n      statement.softDeletes !== \"include\" &&\n      statement.softDeletes !== \"exclude\"\n    )\n      fail(\"softDeletes must be 'include' or 'exclude'\");\n    const user = mutationCondition(statement.where, ctx);\n    if (!user && statement.allowAll !== true) fail(\"UPDATE and DELETE require a nonempty user where or allowAll: true\");\n    if (operation === \"update\") {\n      const entries = assignments(meta, statement.set, \"update\");\n      sql +=\n        \" SET \" +\n        entries\n          .map((entry) => {\n            const [key, value] = entry;\n            const field = writableField(meta, key, \"update\");\n            const cell = assignmentToSql(meta, field, value, ctx);\n            bindings.push(...cell.bindings);\n            refs.push(...cell.refs);\n            return `${kq(field.columnName)} = ${cell.sql}`;\n          })\n          .join(\", \");\n    }\n    const injected = conditionToSql(\n      { and: injectedConditions({ meta, alias }, statement.softDeletes ?? \"exclude\") },\n      ctx,\n      true,\n    );\n    const conditions = [user, injected].filter((condition) => condition !== undefined);\n    if (conditions.length) {\n      sql += ` WHERE ${conditions.map((condition) => `(${condition.sql})`).join(\" AND \")}`;\n      for (const condition of conditions) {\n        bindings.push(...condition.bindings);\n        refs.push(...condition.refs);\n      }\n    }\n  }\n  if (returning) {\n    sql += ` RETURNING ${returning.selects.map((select) => select.sql).join(\", \")}`;\n    for (const select of returning.selects) bindings.push(...select.bindings);\n  }\n  const keptCtes = pruneCtes(ctes, new Set(refs));\n  if (keptCtes.length > 0) {\n    const clause = withFragment(keptCtes);\n    sql = clause.sql + sql;\n    bindings.unshift(...clause.bindings);\n  }\n  return {\n    sql,\n    bindings,\n    outerRefs: [],\n    output: returning?.output ?? { kind: \"pojo\", columns: [] },\n    decodeRows: returning?.decodeRows ?? (() => []),\n  };\n}\n\n/** Retains native counts even when no rows return, and propagates decoding failures after execution. */\nexport function decodeStatementResult(\n  em: EntityHydrator,\n  plan: Plan,\n  result: DriverQueryResult,\n): ExecuteResult<unknown> {\n  if (typeof result.rowCount !== \"number\" || !Number.isInteger(result.rowCount) || result.rowCount < 0)\n    fail(\"The driver did not return a numeric command rowCount\");\n  return { rowCount: result.rowCount, rows: plan.decodeRows(em, result.rows) };\n}\n\ntype MutationTarget<T extends Entity> = TableFor<T> &\n  (TypeMapEntry<T, \"supportsEmExecute\"> extends true ? unknown : never);\ntype MutationFilter = {\n  readonly where?: SqlCondition | ExprLike<boolean>;\n  readonly allowAll?: boolean;\n  readonly softDeletes?: \"include\" | \"exclude\";\n};\ntype NoMutationReadClauses = Partial<\n  Record<\n    | \"select\"\n    | \"join\"\n    | \"groupBy\"\n    | \"having\"\n    | \"orderBy\"\n    | \"limit\"\n    | \"offset\"\n    | \"distinct\"\n    | \"pruneJoins\"\n    | \"as\"\n    | \"union\"\n    | \"unionAll\"\n    | \"intersect\"\n    | \"intersectAll\"\n    | \"except\"\n    | \"exceptAll\"\n    | \"ctes\"\n    | \"using\"\n    | \"onConflict\",\n    never\n  >\n>;\n/** Column keys allowed in INSERT, i.e. Book's optional `id` and required `authorId`. */\ntype InsertKey<T> = {\n  [K in keyof ColumnsOf<T>]: ColumnsOf<T>[K] extends { insert: \"required\" | \"optional\" } ? K : never;\n}[keyof ColumnsOf<T>];\n/** Column keys that each INSERT row must supply, i.e. Book's `authorId` despite its ORM default. */\ntype RequiredInsertKey<T> = {\n  [K in keyof ColumnsOf<T>]: ColumnsOf<T>[K] extends { insert: \"required\" } ? K : never;\n}[keyof ColumnsOf<T>];\n/** Column keys allowed in UPDATE SET, i.e. Book's `title` and `authorId`, but not `id`. */\ntype UpdateKey<T> = {\n  [K in keyof ColumnsOf<T>]: ColumnsOf<T>[K] extends { update: true } ? K : never;\n}[keyof ColumnsOf<T>];\n/** A column's domain value before SQL nullability is added, i.e. Book's `id` is BookId and `authorId` is AuthorId. */\ntype DomainValue<T, K extends keyof ColumnsOf<T>> = K extends \"id\"\n  ? IdOf<T>\n  : ColumnsOf<T>[K] extends { entity: infer U }\n    ? IdOf<U>\n    : ColumnsOf<T>[K] extends { type: infer V }\n      ? V\n      : never;\ntype SqlValue<T, K extends keyof ColumnsOf<T>> =\n  | DomainValue<T, K>\n  | (ColumnsOf<T>[K] extends { nullable: true } ? null : never);\ntype Assignment<T, K extends keyof ColumnsOf<T>> =\n  | SqlValue<T, K>\n  | ExprLike<SqlValue<T, K>>\n  | (K extends \"id\" ? never : ColumnsOf<T>[K] extends { entity: infer U } ? U : never);\ntype InsertSourceRow<T> = { [K in RequiredInsertKey<T>]: SqlValue<T, K> } & {\n  [K in Exclude<InsertKey<T>, RequiredInsertKey<T>>]?: SqlValue<T, K>;\n};\ntype InsertProjection<T> = { [K in RequiredInsertKey<T>]: ExprLike<SqlValue<T, K>> } & {\n  [K in Exclude<InsertKey<T>, RequiredInsertKey<T>>]?: ExprLike<SqlValue<T, K>>;\n};\ntype UnionKeys<V> = V extends unknown ? keyof V : never;\n/** Collects every alternative before scope checking; a valid branch cannot hide an unrelated alias. */\ntype UnionValue<V, K extends PropertyKey> = V extends unknown ? (K extends keyof V ? V[K] : never) : never;\ntype ExprSource<V> = V extends { readonly [exprBrand]: ExprBrand<unknown, infer Src> } ? Src : never;\ntype CheckExprScope<V, Scope> =\n  string extends ExprSource<V>\n    ? unknown\n    : [Exclude<ExprSource<V>, Scope>] extends [never]\n      ? unknown\n      : \"Expression source is not in the statement scope\";\ntype ReturningExpr<R> = R extends ExprLike<unknown> ? R : R extends undefined ? never : R[keyof R];\ntype EmptyReturning<R> = R extends object ? (keyof R extends never ? true : false) : false;\ntype CheckReturning<R, Scope> = true extends EmptyReturning<R> ? never : CheckExprScope<ReturningExpr<R>, Scope>;\ntype CheckAssignments<V, Allowed, Scope> = [Exclude<UnionKeys<V>, keyof Allowed>] extends [never]\n  ? Allowed & {\n      [K in UnionKeys<V>]?: CheckExprScope<UnionValue<V, K>, Scope>;\n    }\n  : \"SQL assignments have unknown target fields\";\ntype CheckValues<T extends Entity, V> =\n  | ([Extract<V, readonly unknown[]>] extends [never]\n      ? never\n      : readonly CheckAssignments<Extract<V, readonly unknown[]>[number], InsertValues<T>, never>[])\n  | ([Exclude<V, readonly unknown[]>] extends [never]\n      ? never\n      : CheckAssignments<Exclude<V, readonly unknown[]>, InsertValues<T>, never>);\ntype CheckSourceScope<Q> = Q extends { readonly select: infer S; readonly from: infer F }\n  ? CheckScope<S, F, \"join\" extends keyof Q ? Extract<Q[keyof Q & \"join\"], QueryJoins> : []>\n  : {\n      [K in keyof Q]: K extends SetOperation\n        ? Q[K] extends readonly unknown[]\n          ? { [I in keyof Q[K]]: CheckSourceScope<Q[K][I]> }\n          : unknown\n        : unknown;\n    };\ntype CheckInsertSource<T, Q extends SetOperand> = SetOperand extends Q\n  ? \"INSERT source was typed too generically; retain its named output fields\"\n  : ReadQueryRow<Q> extends InsertSourceRow<T>\n    ? Exclude<UnionKeys<ReadQueryRow<Q>>, InsertKey<T>> extends never\n      ? CheckReadQuery<Q> &\n          CheckSourceScope<Q> &\n          (Q extends SetQuery<readonly SetOperand[]> ? CheckSetQuery<Q> : unknown)\n      : \"INSERT SELECT has unknown target fields\"\n    : \"INSERT SELECT requires compatible values for all SQL-required fields\";\ntype TargetEntity<M> = M extends\n  | { readonly insert: TableFor<infer T> }\n  | { readonly update: TableFor<infer T> }\n  | { readonly delete: TableFor<infer T> }\n  ? T\n  : never;\ntype TargetTable<M> = M extends\n  | { readonly insert: infer A }\n  | { readonly update: infer A }\n  | { readonly delete: infer A }\n  ? A\n  : never;\ntype MutationClause<M> =\n  | \"returning\"\n  | \"with\"\n  | (M extends { readonly insert: unknown }\n      ? \"insert\" | (M extends { readonly values: unknown } ? \"values\" : \"from\")\n      : \"where\" | \"allowAll\" | \"softDeletes\" | (M extends { readonly update: unknown } ? \"update\" | \"set\" : \"delete\"));\n/** SQL mutations require complete physical metadata. */\nfunction requireColumnMetadata(meta: EntityMetadata, column: Column): void {\n  if (\n    typeof column.sqlNullable !== \"boolean\" ||\n    typeof column.hasDefault !== \"boolean\" ||\n    typeof column.isGenerated !== \"boolean\"\n  )\n    fail(`Missing physical metadata for ${meta.type}.${column.columnName}; run codegen`);\n}\n\n/** Validates every supplied key, including undefined fields, before pruning omitted values. */\nfunction assignments(meta: EntityMetadata, value: unknown, operation: \"insert\" | \"update\"): [string, unknown][] {\n  if (!value || typeof value !== \"object\" || Array.isArray(value) || isExpr(value) || isEntity(value))\n    fail(`${operation} assignments must be a field POJO`);\n  const entries = Object.entries(value);\n  for (const [key] of entries) writableField(meta, key, operation);\n  checkPojo(value, Object.keys(meta.columns), `${operation} assignments`);\n  const defined = entries.filter((entry) => entry[1] !== undefined);\n  if (!defined.length) fail(`${operation} requires at least one defined field; empty rows/sets are not DEFAULT VALUES`);\n  return defined;\n}\n\n/** Applies physical write restrictions, not ORM-derived, protected, or business-immutable flags. */\nfunction writableField(meta: EntityMetadata, key: string, operation: \"insert\" | \"update\"): Column {\n  const column = Object.hasOwn(meta.columns, key) ? meta.columns[key] : undefined;\n  if (!column) fail(`Unsupported SQL mutation field ${meta.type}.${key}`);\n  requireColumnMetadata(meta, column);\n  if (operation === \"update\" && key === \"id\") fail(\"UPDATE primary-key assignments are not supported\");\n  if (column.isGenerated) fail(`Generated field ${meta.type}.${key} is omit-only`);\n  if (operation === \"update\" ? !column.update : column.insert === \"never\")\n    fail(`Unsupported SQL mutation field ${meta.type}.${key}`);\n  return column;\n}\n\n/**\n * Classifies SQL expressions and SQL NULL before invoking the column's entity-independent write codec.\n * Normalizes public PK/FK ids to internal tagged ids using the target entity's idType.\n */\nfunction assignmentToSql(meta: EntityMetadata, column: Column, value: unknown, ctx: Ctx): SqlFragment {\n  if (isExpr(value)) return asNode(value).toSql(ctx);\n  if (value === null) {\n    if (!column.sqlNullable) fail(`${meta.type}.${column.columnName} is physically NOT NULL`);\n    return { sql: \"NULL\", bindings: [], refs: [] };\n  }\n  if (column.idMetadata) {\n    const other = column.idMetadata();\n    if (isEntity(value)) {\n      if (column.columnName === \"id\" || !(value instanceof other.cstr)) fail(`Expected a ${other.type} reference`);\n      if (value.isNewEntity || value.idTaggedMaybe === undefined)\n        fail(`Cannot reference an unflushed ${other.type}, even with an assigned ID`);\n      value = value.idTaggedMaybe;\n    } else if (typeof value !== (other.idType === \"number\" ? \"number\" : \"string\")) {\n      fail(`Expected a persisted ${other.type} or its ID; nested creation is not supported`);\n    } else {\n      // Public untagged TEXT ids may contain delimiters or start with the entity tag.\n      value =\n        other.idType === \"untagged-string\"\n          ? keyToTaggedId(other, value as string)\n          : toTaggedId(other, value as string | number);\n    }\n  }\n  if (!column.codec.mapToDbValue)\n    fail(`The codec for ${meta.type}.${column.columnName} does not support SQL value writes`);\n  return { sql: \"?\", bindings: [column.mapToDbValue(value)], refs: [] };\n}\n\n/** Checks the user predicate independently so metadata filters cannot turn a pruned guard into consent. */\nfunction mutationCondition(value: unknown, ctx: Ctx): SqlFragment | undefined {\n  if (isExpr(value)) return asNode(value).toSql(ctx);\n  return conditionToSql(value as SqlCondition | undefined, ctx, true);\n}\n\n/** Only own enumerable POJO clauses count as input or explicit full-table consent. */\nfunction checkPojo(value: object, allowed: readonly PropertyKey[], description: string): void {\n  if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)\n    fail(`${description} must be a plain POJO`);\n  for (const key of Reflect.ownKeys(value)) {\n    if (!allowed.includes(key)) fail(`${description} does not support '${String(key)}'`);\n    if (typeof key === \"string\" && !Object.prototype.propertyIsEnumerable.call(value, key))\n      fail(`${description} requires enumerable fields`);\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"execute.js","names":[],"sources":["../../../src/queries/sql/execute.ts"],"sourcesContent":["import type { DriverQueryResult } from \"src/drivers/Driver.ts\";\nimport { type Entity, isEntity } from \"src/Entity.ts\";\nimport type { IdOf } from \"src/EntityManager.ts\";\nimport type { EntityMetadata } from \"src/EntityMetadata.ts\";\nimport { keyToTaggedId, toTaggedId } from \"src/keys.ts\";\nimport type { SqlCondition } from \"src/queries/conditions.ts\";\nimport { AliasAssigner } from \"src/queries/sql/AliasAssigner.ts\";\nimport { type ExprBrand, type ExprLike, type SqlFragment, asNode, exprBrand, isExpr } from \"src/queries/sql/Expr.ts\";\nimport { kq, safeKq } from \"src/queries/sql/keywords.ts\";\nimport {\n  type CheckReadQuery,\n  type CheckScope,\n  type CheckSetQuery,\n  Ctx,\n  type EntityHydrator,\n  type NameOf,\n  type Plan,\n  type Query,\n  type QueryJoins,\n  type QueryRow,\n  type ReadQueryRow,\n  type SetOperand,\n  type SetOperation,\n  type SetQuery,\n  type Subquery,\n  type WithInput,\n  conditionToSql,\n  entityQueryBrand,\n  injectedConditions,\n  isReadQueryValue,\n  parseNestedQuery,\n  parseUserQuery,\n  projectionToSql,\n  pruneCtes,\n  registerCtes,\n  subqueryBrand,\n  withFragment,\n} from \"src/queries/sql/query.ts\";\nimport { type TableFor, getTableMgmt, isTable, tableMgmt } from \"src/queries/sql/Tables.ts\";\nimport type { Column } from \"src/serde/columns.ts\";\nimport type { ColumnsOf, TypeMapEntry } from \"src/typeMap.ts\";\nimport { fail } from \"src/utils.ts\";\n\n/** The native command count and decoded rows from one immediate SQL statement. */\nexport interface ExecuteResult<R> {\n  rowCount: number;\n  rows: R[];\n}\n\n/** A mutation's RETURNING projection: one SQL expression or a named object of expressions. */\nexport type MutationReturning = (ExprLike<unknown> | Readonly<Record<string, ExprLike<unknown>>>) & {\n  readonly [tableMgmt]?: never;\n  readonly [subqueryBrand]?: never;\n  readonly [entityQueryBrand]?: never;\n};\n\n/** SQL INSERT inputs, based on physical storage rather than entity creation options. */\nexport type InsertValues<T extends Entity> = {\n  [K in RequiredInsertKey<T>]: Assignment<T, K>;\n} & {\n  [K in Exclude<InsertKey<T>, RequiredInsertKey<T>>]?: Assignment<T, K> | undefined;\n};\n\n/** SQL UPDATE inputs include persisted derived columns, but never primary keys. */\nexport type UpdateValues<T extends Entity> = {\n  [K in UpdateKey<T>]?: Assignment<T, K> | undefined;\n};\n\n/** A reusable INSERT POJO; use a concrete Q for annotated INSERT SELECT source checking. */\nexport type InsertStatement<\n  T extends Entity,\n  R extends MutationReturning | undefined = MutationReturning | undefined,\n  Q extends SetOperand = Query<InsertProjection<T>, []> | Subquery<InsertSourceRow<T>, string>,\n> = {\n  readonly insert: MutationTarget<T>;\n  readonly returning?: R;\n  readonly update?: never;\n  readonly delete?: never;\n  readonly set?: never;\n  readonly where?: never;\n  readonly allowAll?: never;\n  readonly softDeletes?: never;\n  /** CTEs to add to a `WITH` before the INSERT; see `Clauses.with`. */\n  readonly with?: WithInput;\n} & NoMutationReadClauses &\n  (\n    | { readonly values: InsertValues<T> | readonly InsertValues<T>[]; readonly from?: never }\n    | { readonly from: Q & CheckInsertSource<T, Q>; readonly values?: never }\n  );\n\n/** A reusable guarded UPDATE POJO. Undefined assignments leave existing columns unchanged. */\nexport type UpdateStatement<\n  T extends Entity,\n  R extends MutationReturning | undefined = MutationReturning | undefined,\n> = {\n  readonly update: MutationTarget<T>;\n  readonly set: UpdateValues<T>;\n  readonly returning?: R;\n  readonly insert?: never;\n  readonly delete?: never;\n  readonly values?: never;\n  readonly from?: never;\n  /** CTEs to add to a `WITH` before the UPDATE; see `Clauses.with`. */\n  readonly with?: WithInput;\n} & MutationFilter &\n  NoMutationReadClauses;\n\n/** A reusable guarded physical DELETE POJO, not an ORM soft delete. */\nexport type DeleteStatement<\n  T extends Entity,\n  R extends MutationReturning | undefined = MutationReturning | undefined,\n> = {\n  readonly delete: MutationTarget<T>;\n  readonly returning?: R;\n  readonly insert?: never;\n  readonly update?: never;\n  readonly values?: never;\n  readonly from?: never;\n  readonly set?: never;\n  /** CTEs to add to a `WITH` before the DELETE; see `Clauses.with`. */\n  readonly with?: WithInput;\n} & MutationFilter &\n  NoMutationReadClauses;\n\n/** Public statement annotations retain the target's physical field policy. */\nexport type MutationStatement<\n  T extends Entity,\n  R extends MutationReturning | undefined = MutationReturning | undefined,\n> = InsertStatement<T, R> | UpdateStatement<T, R> | DeleteStatement<T, R>;\n\n/** Inference starts with the literal POJO; CheckMutation checks its target and every supplied key. */\nexport type MutationInput = (\n  | { readonly insert: TableFor<Entity>; readonly values: object | readonly object[]; readonly from?: never }\n  | { readonly insert: TableFor<Entity>; readonly from: SetOperand; readonly values?: never }\n  | { readonly update: TableFor<Entity>; readonly set: object }\n  | { readonly delete: TableFor<Entity> }\n) & { readonly returning?: MutationReturning; readonly with?: WithInput } & MutationFilter;\n\n/** Without RETURNING the row type is never; scalar expressions produce scalar rows. */\nexport type MutationRow<M> = M extends { readonly returning?: infer R }\n  ? R extends MutationReturning\n    ? R extends ExprLike<unknown>\n      ? QueryRow<R>\n      : { -readonly [K in keyof QueryRow<R>]: QueryRow<R>[K] }\n    : never\n  : never;\n\n/** Checks nonliteral statements as well as fresh literals without widening their inferred result. */\nexport type CheckMutation<M> = M extends unknown\n  ? TargetEntity<M> extends infer T extends Entity\n    ? TypeMapEntry<T, \"supportsEmExecute\"> extends true\n      ? { readonly [K in keyof M]: K extends MutationClause<M> ? unknown : never } & {\n          readonly returning?: M extends { readonly returning?: infer R }\n            ? CheckReturning<R, NameOf<TargetTable<M>>>\n            : never;\n        } & (\n            | (M extends { readonly values: infer V } ? { readonly values: CheckValues<T, V> } : never)\n            | (M extends { readonly from: infer Q extends SetOperand }\n                ? { readonly from: CheckInsertSource<T, Q> }\n                : never)\n            | (M extends { readonly set: infer V }\n                ? { readonly set: CheckAssignments<V, UpdateValues<T>, NameOf<TargetTable<M>>> }\n                : never)\n            | (M extends { readonly delete: unknown } ? unknown : never)\n          )\n      : \"SQL mutations require a supported non-inherited target and regenerated metadata\"\n    : never\n  : never;\n\n/** Classifies mutation roots before EntityManager applies write permissions, including malformed roots. */\nexport function isMutation(arg: unknown): boolean {\n  return (\n    typeof arg === \"object\" &&\n    arg !== null &&\n    !isReadQueryValue(arg) &&\n    [\"insert\", \"update\", \"delete\"].some((key) => key in arg)\n  );\n}\n\n/**\n * Compiles one immediate statement using the read compiler's scopes, projections, and codecs.\n * INSERT SELECT keeps source rows in PostgreSQL; only RETURNING rows pass through JS decoders.\n * An undefined plan represents a validated standalone empty VALUES array, not DEFAULT VALUES.\n */\nexport function parseStatement(arg: unknown): Plan | undefined {\n  if (!isMutation(arg)) return parseUserQuery(arg);\n  const statement = arg as Record<string, unknown>;\n  const roots = [\"insert\", \"update\", \"delete\"].filter((key) => key in statement);\n  if (roots.length !== 1) fail(\"A mutation requires exactly one insert, update, or delete root\");\n  const operation = roots[0];\n  const allowed =\n    operation === \"insert\"\n      ? [\"insert\", \"values\", \"from\", \"returning\", \"with\"]\n      : [\n          operation,\n          \"where\",\n          \"allowAll\",\n          \"softDeletes\",\n          \"returning\",\n          \"with\",\n          ...(operation === \"update\" ? [\"set\"] : []),\n        ];\n  checkPojo(statement, allowed, `SQL ${operation}`);\n  const target = statement[operation];\n  if (!isTable(target)) fail(\"A mutation target must be an entity table\");\n  const mgmt = getTableMgmt(target);\n  const meta = mgmt.meta;\n  if (meta.inheritanceType || meta.baseType || meta.baseTypes.length || meta.subTypes.length) {\n    fail(\"SQL mutations do not support CTI/STI targets or inherited table families\");\n  }\n  if (meta.supportsEmExecute !== true)\n    fail(`SQL mutations require supported physical metadata for ${meta.type}; run codegen`);\n  const fields = Object.entries(meta.columns);\n  for (const [, field] of fields) {\n    requireColumnMetadata(meta, field);\n  }\n  const assigner = new AliasAssigner();\n  // A CTE is in scope for the whole statement, so its scope is the parent of every other one here. It\n  // deliberately holds no target alias, which is what lets INSERT VALUES cells and the INSERT SELECT\n  // source read the CTEs without also seeing the row being written.\n  const withCtx = new Ctx(assigner, undefined);\n  const ctes = registerCtes(statement, withCtx, assigner);\n  // Aliases the rest of the statement reads, so an unread CTE prunes like it does on a read query.\n  const refs: string[] = [];\n  const ctx = new Ctx(assigner, withCtx);\n  const alias = assigner.getAlias(meta.tableName);\n  ctx.register(mgmt, alias);\n  const returning = statement.returning === undefined ? undefined : projectionToSql(statement.returning, ctx);\n  if (returning) for (const select of returning.selects) refs.push(...select.refs);\n  let sql = `${operation === \"delete\" ? \"DELETE FROM\" : operation.toUpperCase() + (operation === \"insert\" ? \" INTO\" : \"\")} ${kq(meta.tableName)} AS ${kq(alias)}`;\n  const bindings: unknown[] = [];\n  if (operation === \"insert\") {\n    if (\"values\" in statement === \"from\" in statement) fail(\"INSERT requires exactly one of values or from\");\n    const required = fields.filter(([, column]) => column.insert === \"required\");\n    if (\"values\" in statement) {\n      const rows = Array.isArray(statement.values) ? statement.values : [statement.values];\n      // A VALUES cell *is* the new row, so there is no existing row for it to read: this scope skips\n      // the `ctx.register(mgmt, alias)` above, so a cell naming the target fails instead of emitting a\n      // `b` with no FROM clause. I.e. an UPDATE can say `set: { title: b.title }`; an INSERT cannot.\n      // A value subquery still works, because it brings its own sources, and the parent here is the CTE\n      // scope rather than `ctx`, so a cell can read a `with` entry but not the row being written.\n      const valuesCtx = new Ctx(assigner, withCtx);\n      const entries = rows.map((row) => assignments(meta, row, \"insert\"));\n      for (const row of entries) {\n        for (const [key] of required) {\n          if (!row.some((entry) => entry[0] === key)) fail(`INSERT requires ${meta.type}.${key}`);\n        }\n      }\n      if (rows.length === 0) return undefined;\n      const keys = fields.filter(([key]) => entries.some((row) => row.some((entry) => entry[0] === key)));\n      sql += ` (${keys.map(([, field]) => kq(field.columnName)).join(\", \")}) VALUES `;\n      sql += entries\n        .map((row) => {\n          const cells = keys.map(([key, field]) => {\n            const entry = row.find((entry) => entry[0] === key);\n            if (!entry) return \"DEFAULT\";\n            const cell = assignmentToSql(meta, field, entry[1], valuesCtx);\n            bindings.push(...cell.bindings);\n            refs.push(...cell.refs);\n            return cell.sql;\n          });\n          return `(${cells.join(\", \")})`;\n        })\n        .join(\", \");\n    } else {\n      const source = parseNestedQuery(statement.from, withCtx, assigner);\n      if (source.output.kind !== \"pojo\") fail(\"INSERT SELECT requires named POJO output columns\");\n      const columns = source.output.columns;\n      for (const [key] of required) {\n        if (!columns.some((column) => column[0] === key)) fail(`INSERT requires ${meta.type}.${key}`);\n      }\n      for (const [key, expr] of columns) {\n        const field = writableField(meta, key, \"insert\");\n        const left = field.outputType;\n        const right = expr.outputType;\n        if (\n          !left ||\n          !right ||\n          left.dbType !== right.dbType ||\n          left.domain !== right.domain ||\n          left.idMeta !== right.idMeta\n        ) {\n          fail(`INSERT SELECT ${meta.type}.${key} has incompatible or unknown storage codecs`);\n        }\n        if (!field.sqlNullable && expr.sqlNullable === true)\n          fail(`INSERT SELECT ${meta.type}.${key} cannot accept a nullable output`);\n      }\n      const keys = fields.filter(([key]) => columns.some((column) => column[0] === key));\n      const sourceAlias = safeKq(assigner.getLiteralAlias(\"sq\"));\n      sql += ` (${keys.map(([, field]) => kq(field.columnName)).join(\", \")}) SELECT ${keys.map(([key]) => `${sourceAlias}.${safeKq(key)}`).join(\", \")} FROM (${source.sql}) AS ${sourceAlias}`;\n      bindings.push(...source.bindings);\n      refs.push(...source.outerRefs);\n    }\n  } else {\n    if (statement.allowAll !== undefined && typeof statement.allowAll !== \"boolean\") fail(\"allowAll must be a boolean\");\n    if (\n      statement.softDeletes !== undefined &&\n      statement.softDeletes !== \"include\" &&\n      statement.softDeletes !== \"exclude\"\n    )\n      fail(\"softDeletes must be 'include' or 'exclude'\");\n    const user = mutationCondition(statement.where, ctx);\n    if (!user && statement.allowAll !== true) fail(\"UPDATE and DELETE require a nonempty user where or allowAll: true\");\n    if (operation === \"update\") {\n      const entries = assignments(meta, statement.set, \"update\");\n      sql +=\n        \" SET \" +\n        entries\n          .map((entry) => {\n            const [key, value] = entry;\n            const field = writableField(meta, key, \"update\");\n            const cell = assignmentToSql(meta, field, value, ctx);\n            bindings.push(...cell.bindings);\n            refs.push(...cell.refs);\n            return `${kq(field.columnName)} = ${cell.sql}`;\n          })\n          .join(\", \");\n    }\n    const injected = conditionToSql(\n      { and: injectedConditions({ meta, alias }, statement.softDeletes ?? \"exclude\") },\n      ctx,\n      true,\n    );\n    const conditions = [user, injected].filter((condition) => condition !== undefined);\n    if (conditions.length) {\n      sql += ` WHERE ${conditions.map((condition) => `(${condition.sql})`).join(\" AND \")}`;\n      for (const condition of conditions) {\n        bindings.push(...condition.bindings);\n        refs.push(...condition.refs);\n      }\n    }\n  }\n  if (returning) {\n    sql += ` RETURNING ${returning.selects.map((select) => select.sql).join(\", \")}`;\n    for (const select of returning.selects) bindings.push(...select.bindings);\n  }\n  const keptCtes = pruneCtes(ctes, new Set(refs));\n  if (keptCtes.length > 0) {\n    const clause = withFragment(keptCtes);\n    sql = clause.sql + sql;\n    bindings.unshift(...clause.bindings);\n  }\n  return {\n    sql,\n    bindings,\n    outerRefs: [],\n    output: returning?.output ?? { kind: \"pojo\", columns: [] },\n    decodeRows: returning?.decodeRows ?? (() => []),\n  };\n}\n\n/** Retains native counts even when no rows return, and propagates decoding failures after execution. */\nexport function decodeStatementResult(\n  em: EntityHydrator,\n  plan: Plan,\n  result: DriverQueryResult,\n): ExecuteResult<unknown> {\n  if (typeof result.rowCount !== \"number\" || !Number.isInteger(result.rowCount) || result.rowCount < 0)\n    fail(\"The driver did not return a numeric command rowCount\");\n  return { rowCount: result.rowCount, rows: plan.decodeRows(em, result.rows) };\n}\n\ntype MutationTarget<T extends Entity> = TableFor<T> &\n  (TypeMapEntry<T, \"supportsEmExecute\"> extends true ? unknown : never);\ntype MutationFilter = {\n  readonly where?: SqlCondition | ExprLike<boolean>;\n  readonly allowAll?: boolean;\n  readonly softDeletes?: \"include\" | \"exclude\";\n};\ntype NoMutationReadClauses = Partial<\n  Record<\n    | \"select\"\n    | \"join\"\n    | \"groupBy\"\n    | \"having\"\n    | \"orderBy\"\n    | \"limit\"\n    | \"offset\"\n    | \"distinct\"\n    | \"pruneJoins\"\n    | \"as\"\n    | \"union\"\n    | \"unionAll\"\n    | \"intersect\"\n    | \"intersectAll\"\n    | \"except\"\n    | \"exceptAll\"\n    | \"ctes\"\n    | \"using\"\n    | \"onConflict\",\n    never\n  >\n>;\n/** Column keys allowed in INSERT, i.e. Book's optional `id` and required `authorId`. */\ntype InsertKey<T> = {\n  [K in keyof ColumnsOf<T>]: ColumnsOf<T>[K] extends { insert: \"required\" | \"optional\" } ? K : never;\n}[keyof ColumnsOf<T>];\n/** Column keys that each INSERT row must supply, i.e. Book's `authorId` despite its ORM default. */\ntype RequiredInsertKey<T> = {\n  [K in keyof ColumnsOf<T>]: ColumnsOf<T>[K] extends { insert: \"required\" } ? K : never;\n}[keyof ColumnsOf<T>];\n/** Column keys allowed in UPDATE SET, i.e. Book's `title` and `authorId`, but not `id`. */\ntype UpdateKey<T> = {\n  [K in keyof ColumnsOf<T>]: ColumnsOf<T>[K] extends { update: true } ? K : never;\n}[keyof ColumnsOf<T>];\n/** A column's domain value before SQL nullability is added, i.e. Book's `id` is BookId and `authorId` is AuthorId. */\ntype DomainValue<T, K extends keyof ColumnsOf<T>> = K extends \"id\"\n  ? IdOf<T>\n  : ColumnsOf<T>[K] extends { entity: infer U }\n    ? IdOf<U>\n    : ColumnsOf<T>[K] extends { type: infer V }\n      ? V\n      : never;\ntype SqlValue<T, K extends keyof ColumnsOf<T>> =\n  | DomainValue<T, K>\n  | (ColumnsOf<T>[K] extends { nullable: true } ? null : never);\ntype Assignment<T, K extends keyof ColumnsOf<T>> =\n  | SqlValue<T, K>\n  | ExprLike<SqlValue<T, K>>\n  | (K extends \"id\" ? never : ColumnsOf<T>[K] extends { entity: infer U } ? U : never);\ntype InsertSourceRow<T> = { [K in RequiredInsertKey<T>]: SqlValue<T, K> } & {\n  [K in Exclude<InsertKey<T>, RequiredInsertKey<T>>]?: SqlValue<T, K>;\n};\ntype InsertProjection<T> = { [K in RequiredInsertKey<T>]: ExprLike<SqlValue<T, K>> } & {\n  [K in Exclude<InsertKey<T>, RequiredInsertKey<T>>]?: ExprLike<SqlValue<T, K>>;\n};\ntype UnionKeys<V> = V extends unknown ? keyof V : never;\n/** Collects every alternative before scope checking; a valid branch cannot hide an unrelated alias. */\ntype UnionValue<V, K extends PropertyKey> = V extends unknown ? (K extends keyof V ? V[K] : never) : never;\ntype ExprSource<V> = V extends { readonly [exprBrand]: ExprBrand<unknown, infer Src> } ? Src : never;\ntype CheckExprScope<V, Scope> =\n  string extends ExprSource<V>\n    ? unknown\n    : [Exclude<ExprSource<V>, Scope>] extends [never]\n      ? unknown\n      : \"Expression source is not in the statement scope\";\ntype ReturningExpr<R> = R extends ExprLike<unknown> ? R : R extends undefined ? never : R[keyof R];\ntype EmptyReturning<R> = R extends object ? (keyof R extends never ? true : false) : false;\ntype CheckReturning<R, Scope> = true extends EmptyReturning<R> ? never : CheckExprScope<ReturningExpr<R>, Scope>;\ntype CheckAssignments<V, Allowed, Scope> = [Exclude<UnionKeys<V>, keyof Allowed>] extends [never]\n  ? Allowed & {\n      [K in UnionKeys<V>]?: CheckExprScope<UnionValue<V, K>, Scope>;\n    }\n  : \"SQL assignments have unknown target fields\";\ntype CheckValues<T extends Entity, V> =\n  | ([Extract<V, readonly unknown[]>] extends [never]\n      ? never\n      : readonly CheckAssignments<Extract<V, readonly unknown[]>[number], InsertValues<T>, never>[])\n  | ([Exclude<V, readonly unknown[]>] extends [never]\n      ? never\n      : CheckAssignments<Exclude<V, readonly unknown[]>, InsertValues<T>, never>);\ntype CheckSourceScope<Q> = Q extends { readonly select: infer S; readonly from: infer F }\n  ? CheckScope<S, F, \"join\" extends keyof Q ? Extract<Q[keyof Q & \"join\"], QueryJoins> : []>\n  : {\n      [K in keyof Q]: K extends SetOperation\n        ? Q[K] extends readonly unknown[]\n          ? { [I in keyof Q[K]]: CheckSourceScope<Q[K][I]> }\n          : unknown\n        : unknown;\n    };\ntype CheckInsertSource<T, Q extends SetOperand> = SetOperand extends Q\n  ? \"INSERT source was typed too generically; retain its named output fields\"\n  : ReadQueryRow<Q> extends InsertSourceRow<T>\n    ? Exclude<UnionKeys<ReadQueryRow<Q>>, InsertKey<T>> extends never\n      ? CheckReadQuery<Q> &\n          CheckSourceScope<Q> &\n          (Q extends SetQuery<readonly SetOperand[]> ? CheckSetQuery<Q> : unknown)\n      : \"INSERT SELECT has unknown target fields\"\n    : \"INSERT SELECT requires compatible values for all SQL-required fields\";\ntype TargetEntity<M> = M extends\n  | { readonly insert: TableFor<infer T> }\n  | { readonly update: TableFor<infer T> }\n  | { readonly delete: TableFor<infer T> }\n  ? T\n  : never;\ntype TargetTable<M> = M extends\n  | { readonly insert: infer A }\n  | { readonly update: infer A }\n  | { readonly delete: infer A }\n  ? A\n  : never;\ntype MutationClause<M> =\n  | \"returning\"\n  | \"with\"\n  | (M extends { readonly insert: unknown }\n      ? \"insert\" | (M extends { readonly values: unknown } ? \"values\" : \"from\")\n      : \"where\" | \"allowAll\" | \"softDeletes\" | (M extends { readonly update: unknown } ? \"update\" | \"set\" : \"delete\"));\n/** SQL mutations require complete physical metadata. */\nfunction requireColumnMetadata(meta: EntityMetadata, column: Column): void {\n  if (\n    typeof column.sqlNullable !== \"boolean\" ||\n    typeof column.hasDefault !== \"boolean\" ||\n    typeof column.isGenerated !== \"boolean\"\n  )\n    fail(`Missing physical metadata for ${meta.type}.${column.columnName}; run codegen`);\n}\n\n/** Validates every supplied key, including undefined fields, before pruning omitted values. */\nfunction assignments(meta: EntityMetadata, value: unknown, operation: \"insert\" | \"update\"): [string, unknown][] {\n  if (!value || typeof value !== \"object\" || Array.isArray(value) || isExpr(value) || isEntity(value))\n    fail(`${operation} assignments must be a field POJO`);\n  const entries = Object.entries(value);\n  for (const [key] of entries) writableField(meta, key, operation);\n  checkPojo(value, Object.keys(meta.columns), `${operation} assignments`);\n  const defined = entries.filter((entry) => entry[1] !== undefined);\n  if (!defined.length) fail(`${operation} requires at least one defined field; empty rows/sets are not DEFAULT VALUES`);\n  return defined;\n}\n\n/** Applies physical write restrictions, not ORM-derived, protected, or business-immutable flags. */\nfunction writableField(meta: EntityMetadata, key: string, operation: \"insert\" | \"update\"): Column {\n  const column = Object.hasOwn(meta.columns, key) ? meta.columns[key] : undefined;\n  if (!column) fail(`Unsupported SQL mutation field ${meta.type}.${key}`);\n  requireColumnMetadata(meta, column);\n  if (operation === \"update\" && key === \"id\") fail(\"UPDATE primary-key assignments are not supported\");\n  if (column.isGenerated) fail(`Generated field ${meta.type}.${key} is omit-only`);\n  if (operation === \"update\" ? !column.update : column.insert === \"never\")\n    fail(`Unsupported SQL mutation field ${meta.type}.${key}`);\n  return column;\n}\n\n/**\n * Classifies SQL expressions and SQL NULL before invoking the column's entity-independent write codec.\n * Normalizes public PK/FK ids to internal tagged ids using the target entity's idType.\n */\nfunction assignmentToSql(meta: EntityMetadata, column: Column, value: unknown, ctx: Ctx): SqlFragment {\n  if (isExpr(value)) return asNode(value).toSql(ctx);\n  if (value === null) {\n    if (!column.sqlNullable) fail(`${meta.type}.${column.columnName} is physically NOT NULL`);\n    return { sql: \"NULL\", bindings: [], refs: [] };\n  }\n  if (column.idMetadata) {\n    const other = column.idMetadata();\n    if (isEntity(value)) {\n      if (column.columnName === \"id\" || !(value instanceof other.cstr)) fail(`Expected a ${other.type} reference`);\n      if (value.isNewEntity || value.idTaggedMaybe === undefined)\n        fail(`Cannot reference an unflushed ${other.type}, even with an assigned ID`);\n      value = value.idTaggedMaybe;\n    } else if (typeof value !== (other.idType === \"number\" ? \"number\" : \"string\")) {\n      fail(`Expected a persisted ${other.type} or its ID; nested creation is not supported`);\n    } else {\n      // Public untagged TEXT ids may contain delimiters or start with the entity tag.\n      value =\n        other.idType === \"untagged-string\"\n          ? keyToTaggedId(other, value as string)\n          : toTaggedId(other, value as string | number);\n    }\n  }\n  if (!column.codec.mapToDbValue)\n    fail(`The codec for ${meta.type}.${column.columnName} does not support SQL value writes`);\n  return { sql: \"?\", bindings: [column.mapToDbValue(value)], refs: [] };\n}\n\n/** Checks the user predicate independently so metadata filters cannot turn a pruned guard into consent. */\nfunction mutationCondition(value: unknown, ctx: Ctx): SqlFragment | undefined {\n  if (isExpr(value)) return asNode(value).toSql(ctx);\n  return conditionToSql(value as SqlCondition | undefined, ctx, true);\n}\n\n/** Only own enumerable POJO clauses count as input or explicit full-table consent. */\nfunction checkPojo(value: object, allowed: readonly PropertyKey[], description: string): void {\n  if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)\n    fail(`${description} must be a plain POJO`);\n  for (const key of Reflect.ownKeys(value)) {\n    if (!allowed.includes(key)) fail(`${description} does not support '${String(key)}'`);\n    if (typeof key === \"string\" && !Object.prototype.propertyIsEnumerable.call(value, key))\n      fail(`${description} requires enumerable fields`);\n  }\n}\n"],"mappings":"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"}

package/build/queries/sql/expressions/arrayAgg.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"arrayAgg.cjs","names":["BaseExpr","parseExpression","expressionToSql","joinFragments","orderByToSql","isObject"],"sources":["../../../../src/queries/sql/expressions/arrayAgg.ts"],"sourcesContent":["import {\n  type ArrayAggOptions,\n  BaseExpr,\n  type ExprContext,\n  type ExprLike,\n  type SqlFragment,\n  joinFragments,\n  orderByToSql,\n} from \"../Expr.ts\";\nimport { expressionToSql } from \"./expression.ts\";\nimport { checkKeys, isObject, parseExpression } from \"./parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"./types.ts\";\n\n/** The aggregate value alone, or the value together with PostgreSQL aggregate options. */\nexport interface ArrayAggInput {\n  readonly arrayAgg: ExprLike<unknown> | ArrayAggExpressionOptions;\n}\n\n/** Options for an inline ARRAY_AGG expression. */\nexport interface ArrayAggExpressionOptions extends ArrayAggOptions {\n  readonly value: unknown;\n}\n\n/** An ARRAY_AGG value and its aggregate options. */\nexport interface ParsedArrayAggExpression {\n  kind: \"arrayAgg\";\n  value: ParsedExpression;\n  options?: ArrayAggOptions;\n}\n\n/** Parses compact and expanded ARRAY_AGG inputs. */\nexport function parseArrayAggExpression(input: unknown): ParsedArrayAggExpression {\n  if (input instanceof BaseExpr || !isArrayAggOptions(input)) {\n    return { kind: \"arrayAgg\", value: parseExpression(input) };\n  }\n  checkKeys(input, [\"value\", \"distinct\", \"orderBy\", \"filter\"]);\n  if (!(\"value\" in input)) throw new Error(\"ARRAY_AGG options need a value\");\n  if (input.distinct !== undefined && typeof input.distinct !== \"boolean\") {\n    throw new Error(\"ARRAY_AGG distinct must be a boolean\");\n  }\n  if (input.orderBy !== undefined && !Array.isArray(input.orderBy)) {\n    throw new Error(\"ARRAY_AGG orderBy must be an array\");\n  }\n  return {\n    kind: \"arrayAgg\",\n    value: parseExpression(input.value),\n    options: {\n      distinct: input.distinct as boolean | undefined,\n      orderBy: input.orderBy as ArrayAggOptions[\"orderBy\"],\n      filter: input.filter as ArrayAggOptions[\"filter\"],\n    },\n  };\n}\n\n/** Renders ARRAY_AGG's value, ordering, and filter in SQL binding order. */\nexport function arrayAggToSql(\n  parsed: ParsedArrayAggExpression,\n  ctx: ExprContext,\n  valueCodec: ResultCodec,\n): SqlFragment {\n  const value = expressionToSql(parsed.value, ctx, valueCodec);\n  const ordering = joinFragments(\n    (parsed.options?.orderBy ?? []).flatMap((entry) => {\n      if (entry === undefined) return [];\n      const fragment = orderByToSql(entry, ctx);\n      return fragment ? [fragment] : [];\n    }),\n    \", \",\n  );\n  const filter = parsed.options?.filter;\n  const condition = filter === undefined ? undefined : ctx.conditionToSql(filter);\n  return {\n    sql: `array_agg(${parsed.options?.distinct ? \"DISTINCT \" : \"\"}${value.sql}${ordering.sql ? ` ORDER BY ${ordering.sql}` : \"\"})${condition ? ` FILTER (WHERE ${condition.sql})` : \"\"}`,\n    bindings: [...value.bindings, ...ordering.bindings, ...(condition?.bindings ?? [])],\n    refs: [...value.refs, ...ordering.refs, ...(condition?.refs ?? [])],\n  };\n}\n\n/** Distinguishes expanded options from nested object expressions. */\nfunction isArrayAggOptions(input: unknown): input is Record<string, unknown> {\n  return isObject(input) && (\"value\" in input || \"distinct\" in input || \"orderBy\" in input || \"filter\" in input);\n}\n"],"mappings":";;;;;;AA+BA,SAAgB,wBAAwB,OAA0C;CAChF,IAAI,iBAAiBA,yBAAAA,YAAY,CAAC,kBAAkB,KAAK,GACvD,OAAO;EAAE,MAAM;EAAY,OAAOC,gDAAAA,gBAAgB,KAAK;CAAE;CAE3D,gDAAA,UAAU,OAAO;EAAC;EAAS;EAAY;EAAW;CAAQ,CAAC;CAC3D,IAAI,EAAE,WAAW,QAAQ,MAAM,IAAI,MAAM,gCAAgC;CACzE,IAAI,MAAM,aAAa,KAAA,KAAa,OAAO,MAAM,aAAa,WAC5D,MAAM,IAAI,MAAM,sCAAsC;CAExD,IAAI,MAAM,YAAY,KAAA,KAAa,CAAC,MAAM,QAAQ,MAAM,OAAO,GAC7D,MAAM,IAAI,MAAM,oCAAoC;CAEtD,OAAO;EACL,MAAM;EACN,OAAOA,gDAAAA,gBAAgB,MAAM,KAAK;EAClC,SAAS;GACP,UAAU,MAAM;GAChB,SAAS,MAAM;GACf,QAAQ,MAAM;EAChB;CACF;AACF;;AAGA,SAAgB,cACd,QACA,KACA,YACa;CACb,MAAM,QAAQC,2CAAAA,gBAAgB,OAAO,OAAO,KAAK,UAAU;CAC3D,MAAM,WAAWC,yBAAAA,eACd,OAAO,SAAS,WAAW,CAAC,EAAA,CAAG,SAAS,UAAU;EACjD,IAAI,UAAU,KAAA,GAAW,OAAO,CAAC;EACjC,MAAM,WAAWC,yBAAAA,aAAa,OAAO,GAAG;EACxC,OAAO,WAAW,CAAC,QAAQ,IAAI,CAAC;CAClC,CAAC,GACD,IACF;CACA,MAAM,SAAS,OAAO,SAAS;CAC/B,MAAM,YAAY,WAAW,KAAA,IAAY,KAAA,IAAY,IAAI,eAAe,MAAM;CAC9E,OAAO;EACL,KAAK,aAAa,OAAO,SAAS,WAAW,cAAc,KAAK,MAAM,MAAM,SAAS,MAAM,aAAa,SAAS,QAAQ,GAAG,GAAG,YAAY,kBAAkB,UAAU,IAAI,KAAK;EAChL,UAAU;GAAC,GAAG,MAAM;GAAU,GAAG,SAAS;GAAU,GAAI,WAAW,YAAY,CAAC;EAAE;EAClF,MAAM;GAAC,GAAG,MAAM;GAAM,GAAG,SAAS;GAAM,GAAI,WAAW,QAAQ,CAAC;EAAE;CACpE;AACF;;AAGA,SAAS,kBAAkB,OAAkD;CAC3E,OAAOC,gDAAAA,SAAS,KAAK,MAAM,WAAW,SAAS,cAAc,SAAS,aAAa,SAAS,YAAY;AAC1G"}
+{"version":3,"file":"arrayAgg.cjs","names":["BaseExpr","parseExpression","expressionToSql","joinFragments","orderByToSql","isObject"],"sources":["../../../../src/queries/sql/expressions/arrayAgg.ts"],"sourcesContent":["import {\n  type ArrayAggOptions,\n  BaseExpr,\n  type ExprContext,\n  type ExprLike,\n  type SqlFragment,\n  joinFragments,\n  orderByToSql,\n} from \"src/queries/sql/Expr.ts\";\nimport { expressionToSql } from \"src/queries/sql/expressions/expression.ts\";\nimport { checkKeys, isObject, parseExpression } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\n\n/** The aggregate value alone, or the value together with PostgreSQL aggregate options. */\nexport interface ArrayAggInput {\n  readonly arrayAgg: ExprLike<unknown> | ArrayAggExpressionOptions;\n}\n\n/** Options for an inline ARRAY_AGG expression. */\nexport interface ArrayAggExpressionOptions extends ArrayAggOptions {\n  readonly value: unknown;\n}\n\n/** An ARRAY_AGG value and its aggregate options. */\nexport interface ParsedArrayAggExpression {\n  kind: \"arrayAgg\";\n  value: ParsedExpression;\n  options?: ArrayAggOptions;\n}\n\n/** Parses compact and expanded ARRAY_AGG inputs. */\nexport function parseArrayAggExpression(input: unknown): ParsedArrayAggExpression {\n  if (input instanceof BaseExpr || !isArrayAggOptions(input)) {\n    return { kind: \"arrayAgg\", value: parseExpression(input) };\n  }\n  checkKeys(input, [\"value\", \"distinct\", \"orderBy\", \"filter\"]);\n  if (!(\"value\" in input)) throw new Error(\"ARRAY_AGG options need a value\");\n  if (input.distinct !== undefined && typeof input.distinct !== \"boolean\") {\n    throw new Error(\"ARRAY_AGG distinct must be a boolean\");\n  }\n  if (input.orderBy !== undefined && !Array.isArray(input.orderBy)) {\n    throw new Error(\"ARRAY_AGG orderBy must be an array\");\n  }\n  return {\n    kind: \"arrayAgg\",\n    value: parseExpression(input.value),\n    options: {\n      distinct: input.distinct as boolean | undefined,\n      orderBy: input.orderBy as ArrayAggOptions[\"orderBy\"],\n      filter: input.filter as ArrayAggOptions[\"filter\"],\n    },\n  };\n}\n\n/** Renders ARRAY_AGG's value, ordering, and filter in SQL binding order. */\nexport function arrayAggToSql(\n  parsed: ParsedArrayAggExpression,\n  ctx: ExprContext,\n  valueCodec: ResultCodec,\n): SqlFragment {\n  const value = expressionToSql(parsed.value, ctx, valueCodec);\n  const ordering = joinFragments(\n    (parsed.options?.orderBy ?? []).flatMap((entry) => {\n      if (entry === undefined) return [];\n      const fragment = orderByToSql(entry, ctx);\n      return fragment ? [fragment] : [];\n    }),\n    \", \",\n  );\n  const filter = parsed.options?.filter;\n  const condition = filter === undefined ? undefined : ctx.conditionToSql(filter);\n  return {\n    sql: `array_agg(${parsed.options?.distinct ? \"DISTINCT \" : \"\"}${value.sql}${ordering.sql ? ` ORDER BY ${ordering.sql}` : \"\"})${condition ? ` FILTER (WHERE ${condition.sql})` : \"\"}`,\n    bindings: [...value.bindings, ...ordering.bindings, ...(condition?.bindings ?? [])],\n    refs: [...value.refs, ...ordering.refs, ...(condition?.refs ?? [])],\n  };\n}\n\n/** Distinguishes expanded options from nested object expressions. */\nfunction isArrayAggOptions(input: unknown): input is Record<string, unknown> {\n  return isObject(input) && (\"value\" in input || \"distinct\" in input || \"orderBy\" in input || \"filter\" in input);\n}\n"],"mappings":";;;;;;AA+BA,SAAgB,wBAAwB,OAA0C;CAChF,IAAI,iBAAiBA,yBAAAA,YAAY,CAAC,kBAAkB,KAAK,GACvD,OAAO;EAAE,MAAM;EAAY,OAAOC,gDAAAA,gBAAgB,KAAK;CAAE;CAE3D,gDAAA,UAAU,OAAO;EAAC;EAAS;EAAY;EAAW;CAAQ,CAAC;CAC3D,IAAI,EAAE,WAAW,QAAQ,MAAM,IAAI,MAAM,gCAAgC;CACzE,IAAI,MAAM,aAAa,KAAA,KAAa,OAAO,MAAM,aAAa,WAC5D,MAAM,IAAI,MAAM,sCAAsC;CAExD,IAAI,MAAM,YAAY,KAAA,KAAa,CAAC,MAAM,QAAQ,MAAM,OAAO,GAC7D,MAAM,IAAI,MAAM,oCAAoC;CAEtD,OAAO;EACL,MAAM;EACN,OAAOA,gDAAAA,gBAAgB,MAAM,KAAK;EAClC,SAAS;GACP,UAAU,MAAM;GAChB,SAAS,MAAM;GACf,QAAQ,MAAM;EAChB;CACF;AACF;;AAGA,SAAgB,cACd,QACA,KACA,YACa;CACb,MAAM,QAAQC,2CAAAA,gBAAgB,OAAO,OAAO,KAAK,UAAU;CAC3D,MAAM,WAAWC,yBAAAA,eACd,OAAO,SAAS,WAAW,CAAC,EAAA,CAAG,SAAS,UAAU;EACjD,IAAI,UAAU,KAAA,GAAW,OAAO,CAAC;EACjC,MAAM,WAAWC,yBAAAA,aAAa,OAAO,GAAG;EACxC,OAAO,WAAW,CAAC,QAAQ,IAAI,CAAC;CAClC,CAAC,GACD,IACF;CACA,MAAM,SAAS,OAAO,SAAS;CAC/B,MAAM,YAAY,WAAW,KAAA,IAAY,KAAA,IAAY,IAAI,eAAe,MAAM;CAC9E,OAAO;EACL,KAAK,aAAa,OAAO,SAAS,WAAW,cAAc,KAAK,MAAM,MAAM,SAAS,MAAM,aAAa,SAAS,QAAQ,GAAG,GAAG,YAAY,kBAAkB,UAAU,IAAI,KAAK;EAChL,UAAU;GAAC,GAAG,MAAM;GAAU,GAAG,SAAS;GAAU,GAAI,WAAW,YAAY,CAAC;EAAE;EAClF,MAAM;GAAC,GAAG,MAAM;GAAM,GAAG,SAAS;GAAM,GAAI,WAAW,QAAQ,CAAC;EAAE;CACpE;AACF;;AAGA,SAAS,kBAAkB,OAAkD;CAC3E,OAAOC,gDAAAA,SAAS,KAAK,MAAM,WAAW,SAAS,cAAc,SAAS,aAAa,SAAS,YAAY;AAC1G"}

package/build/queries/sql/expressions/arrayAgg.js.map

@@ -1 +1 @@
-{"version":3,"file":"arrayAgg.js","names":[],"sources":["../../../../src/queries/sql/expressions/arrayAgg.ts"],"sourcesContent":["import {\n  type ArrayAggOptions,\n  BaseExpr,\n  type ExprContext,\n  type ExprLike,\n  type SqlFragment,\n  joinFragments,\n  orderByToSql,\n} from \"../Expr.ts\";\nimport { expressionToSql } from \"./expression.ts\";\nimport { checkKeys, isObject, parseExpression } from \"./parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"./types.ts\";\n\n/** The aggregate value alone, or the value together with PostgreSQL aggregate options. */\nexport interface ArrayAggInput {\n  readonly arrayAgg: ExprLike<unknown> | ArrayAggExpressionOptions;\n}\n\n/** Options for an inline ARRAY_AGG expression. */\nexport interface ArrayAggExpressionOptions extends ArrayAggOptions {\n  readonly value: unknown;\n}\n\n/** An ARRAY_AGG value and its aggregate options. */\nexport interface ParsedArrayAggExpression {\n  kind: \"arrayAgg\";\n  value: ParsedExpression;\n  options?: ArrayAggOptions;\n}\n\n/** Parses compact and expanded ARRAY_AGG inputs. */\nexport function parseArrayAggExpression(input: unknown): ParsedArrayAggExpression {\n  if (input instanceof BaseExpr || !isArrayAggOptions(input)) {\n    return { kind: \"arrayAgg\", value: parseExpression(input) };\n  }\n  checkKeys(input, [\"value\", \"distinct\", \"orderBy\", \"filter\"]);\n  if (!(\"value\" in input)) throw new Error(\"ARRAY_AGG options need a value\");\n  if (input.distinct !== undefined && typeof input.distinct !== \"boolean\") {\n    throw new Error(\"ARRAY_AGG distinct must be a boolean\");\n  }\n  if (input.orderBy !== undefined && !Array.isArray(input.orderBy)) {\n    throw new Error(\"ARRAY_AGG orderBy must be an array\");\n  }\n  return {\n    kind: \"arrayAgg\",\n    value: parseExpression(input.value),\n    options: {\n      distinct: input.distinct as boolean | undefined,\n      orderBy: input.orderBy as ArrayAggOptions[\"orderBy\"],\n      filter: input.filter as ArrayAggOptions[\"filter\"],\n    },\n  };\n}\n\n/** Renders ARRAY_AGG's value, ordering, and filter in SQL binding order. */\nexport function arrayAggToSql(\n  parsed: ParsedArrayAggExpression,\n  ctx: ExprContext,\n  valueCodec: ResultCodec,\n): SqlFragment {\n  const value = expressionToSql(parsed.value, ctx, valueCodec);\n  const ordering = joinFragments(\n    (parsed.options?.orderBy ?? []).flatMap((entry) => {\n      if (entry === undefined) return [];\n      const fragment = orderByToSql(entry, ctx);\n      return fragment ? [fragment] : [];\n    }),\n    \", \",\n  );\n  const filter = parsed.options?.filter;\n  const condition = filter === undefined ? undefined : ctx.conditionToSql(filter);\n  return {\n    sql: `array_agg(${parsed.options?.distinct ? \"DISTINCT \" : \"\"}${value.sql}${ordering.sql ? ` ORDER BY ${ordering.sql}` : \"\"})${condition ? ` FILTER (WHERE ${condition.sql})` : \"\"}`,\n    bindings: [...value.bindings, ...ordering.bindings, ...(condition?.bindings ?? [])],\n    refs: [...value.refs, ...ordering.refs, ...(condition?.refs ?? [])],\n  };\n}\n\n/** Distinguishes expanded options from nested object expressions. */\nfunction isArrayAggOptions(input: unknown): input is Record<string, unknown> {\n  return isObject(input) && (\"value\" in input || \"distinct\" in input || \"orderBy\" in input || \"filter\" in input);\n}\n"],"mappings":";;;;;AA+BA,SAAgB,wBAAwB,OAA0C;CAChF,IAAI,iBAAiB,YAAY,CAAC,kBAAkB,KAAK,GACvD,OAAO;EAAE,MAAM;EAAY,OAAO,gBAAgB,KAAK;CAAE;CAE3D,UAAU,OAAO;EAAC;EAAS;EAAY;EAAW;CAAQ,CAAC;CAC3D,IAAI,EAAE,WAAW,QAAQ,MAAM,IAAI,MAAM,gCAAgC;CACzE,IAAI,MAAM,aAAa,KAAA,KAAa,OAAO,MAAM,aAAa,WAC5D,MAAM,IAAI,MAAM,sCAAsC;CAExD,IAAI,MAAM,YAAY,KAAA,KAAa,CAAC,MAAM,QAAQ,MAAM,OAAO,GAC7D,MAAM,IAAI,MAAM,oCAAoC;CAEtD,OAAO;EACL,MAAM;EACN,OAAO,gBAAgB,MAAM,KAAK;EAClC,SAAS;GACP,UAAU,MAAM;GAChB,SAAS,MAAM;GACf,QAAQ,MAAM;EAChB;CACF;AACF;;AAGA,SAAgB,cACd,QACA,KACA,YACa;CACb,MAAM,QAAQ,gBAAgB,OAAO,OAAO,KAAK,UAAU;CAC3D,MAAM,WAAW,eACd,OAAO,SAAS,WAAW,CAAC,EAAA,CAAG,SAAS,UAAU;EACjD,IAAI,UAAU,KAAA,GAAW,OAAO,CAAC;EACjC,MAAM,WAAW,aAAa,OAAO,GAAG;EACxC,OAAO,WAAW,CAAC,QAAQ,IAAI,CAAC;CAClC,CAAC,GACD,IACF;CACA,MAAM,SAAS,OAAO,SAAS;CAC/B,MAAM,YAAY,WAAW,KAAA,IAAY,KAAA,IAAY,IAAI,eAAe,MAAM;CAC9E,OAAO;EACL,KAAK,aAAa,OAAO,SAAS,WAAW,cAAc,KAAK,MAAM,MAAM,SAAS,MAAM,aAAa,SAAS,QAAQ,GAAG,GAAG,YAAY,kBAAkB,UAAU,IAAI,KAAK;EAChL,UAAU;GAAC,GAAG,MAAM;GAAU,GAAG,SAAS;GAAU,GAAI,WAAW,YAAY,CAAC;EAAE;EAClF,MAAM;GAAC,GAAG,MAAM;GAAM,GAAG,SAAS;GAAM,GAAI,WAAW,QAAQ,CAAC;EAAE;CACpE;AACF;;AAGA,SAAS,kBAAkB,OAAkD;CAC3E,OAAO,SAAS,KAAK,MAAM,WAAW,SAAS,cAAc,SAAS,aAAa,SAAS,YAAY;AAC1G"}
+{"version":3,"file":"arrayAgg.js","names":[],"sources":["../../../../src/queries/sql/expressions/arrayAgg.ts"],"sourcesContent":["import {\n  type ArrayAggOptions,\n  BaseExpr,\n  type ExprContext,\n  type ExprLike,\n  type SqlFragment,\n  joinFragments,\n  orderByToSql,\n} from \"src/queries/sql/Expr.ts\";\nimport { expressionToSql } from \"src/queries/sql/expressions/expression.ts\";\nimport { checkKeys, isObject, parseExpression } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\n\n/** The aggregate value alone, or the value together with PostgreSQL aggregate options. */\nexport interface ArrayAggInput {\n  readonly arrayAgg: ExprLike<unknown> | ArrayAggExpressionOptions;\n}\n\n/** Options for an inline ARRAY_AGG expression. */\nexport interface ArrayAggExpressionOptions extends ArrayAggOptions {\n  readonly value: unknown;\n}\n\n/** An ARRAY_AGG value and its aggregate options. */\nexport interface ParsedArrayAggExpression {\n  kind: \"arrayAgg\";\n  value: ParsedExpression;\n  options?: ArrayAggOptions;\n}\n\n/** Parses compact and expanded ARRAY_AGG inputs. */\nexport function parseArrayAggExpression(input: unknown): ParsedArrayAggExpression {\n  if (input instanceof BaseExpr || !isArrayAggOptions(input)) {\n    return { kind: \"arrayAgg\", value: parseExpression(input) };\n  }\n  checkKeys(input, [\"value\", \"distinct\", \"orderBy\", \"filter\"]);\n  if (!(\"value\" in input)) throw new Error(\"ARRAY_AGG options need a value\");\n  if (input.distinct !== undefined && typeof input.distinct !== \"boolean\") {\n    throw new Error(\"ARRAY_AGG distinct must be a boolean\");\n  }\n  if (input.orderBy !== undefined && !Array.isArray(input.orderBy)) {\n    throw new Error(\"ARRAY_AGG orderBy must be an array\");\n  }\n  return {\n    kind: \"arrayAgg\",\n    value: parseExpression(input.value),\n    options: {\n      distinct: input.distinct as boolean | undefined,\n      orderBy: input.orderBy as ArrayAggOptions[\"orderBy\"],\n      filter: input.filter as ArrayAggOptions[\"filter\"],\n    },\n  };\n}\n\n/** Renders ARRAY_AGG's value, ordering, and filter in SQL binding order. */\nexport function arrayAggToSql(\n  parsed: ParsedArrayAggExpression,\n  ctx: ExprContext,\n  valueCodec: ResultCodec,\n): SqlFragment {\n  const value = expressionToSql(parsed.value, ctx, valueCodec);\n  const ordering = joinFragments(\n    (parsed.options?.orderBy ?? []).flatMap((entry) => {\n      if (entry === undefined) return [];\n      const fragment = orderByToSql(entry, ctx);\n      return fragment ? [fragment] : [];\n    }),\n    \", \",\n  );\n  const filter = parsed.options?.filter;\n  const condition = filter === undefined ? undefined : ctx.conditionToSql(filter);\n  return {\n    sql: `array_agg(${parsed.options?.distinct ? \"DISTINCT \" : \"\"}${value.sql}${ordering.sql ? ` ORDER BY ${ordering.sql}` : \"\"})${condition ? ` FILTER (WHERE ${condition.sql})` : \"\"}`,\n    bindings: [...value.bindings, ...ordering.bindings, ...(condition?.bindings ?? [])],\n    refs: [...value.refs, ...ordering.refs, ...(condition?.refs ?? [])],\n  };\n}\n\n/** Distinguishes expanded options from nested object expressions. */\nfunction isArrayAggOptions(input: unknown): input is Record<string, unknown> {\n  return isObject(input) && (\"value\" in input || \"distinct\" in input || \"orderBy\" in input || \"filter\" in input);\n}\n"],"mappings":";;;;;AA+BA,SAAgB,wBAAwB,OAA0C;CAChF,IAAI,iBAAiB,YAAY,CAAC,kBAAkB,KAAK,GACvD,OAAO;EAAE,MAAM;EAAY,OAAO,gBAAgB,KAAK;CAAE;CAE3D,UAAU,OAAO;EAAC;EAAS;EAAY;EAAW;CAAQ,CAAC;CAC3D,IAAI,EAAE,WAAW,QAAQ,MAAM,IAAI,MAAM,gCAAgC;CACzE,IAAI,MAAM,aAAa,KAAA,KAAa,OAAO,MAAM,aAAa,WAC5D,MAAM,IAAI,MAAM,sCAAsC;CAExD,IAAI,MAAM,YAAY,KAAA,KAAa,CAAC,MAAM,QAAQ,MAAM,OAAO,GAC7D,MAAM,IAAI,MAAM,oCAAoC;CAEtD,OAAO;EACL,MAAM;EACN,OAAO,gBAAgB,MAAM,KAAK;EAClC,SAAS;GACP,UAAU,MAAM;GAChB,SAAS,MAAM;GACf,QAAQ,MAAM;EAChB;CACF;AACF;;AAGA,SAAgB,cACd,QACA,KACA,YACa;CACb,MAAM,QAAQ,gBAAgB,OAAO,OAAO,KAAK,UAAU;CAC3D,MAAM,WAAW,eACd,OAAO,SAAS,WAAW,CAAC,EAAA,CAAG,SAAS,UAAU;EACjD,IAAI,UAAU,KAAA,GAAW,OAAO,CAAC;EACjC,MAAM,WAAW,aAAa,OAAO,GAAG;EACxC,OAAO,WAAW,CAAC,QAAQ,IAAI,CAAC;CAClC,CAAC,GACD,IACF;CACA,MAAM,SAAS,OAAO,SAAS;CAC/B,MAAM,YAAY,WAAW,KAAA,IAAY,KAAA,IAAY,IAAI,eAAe,MAAM;CAC9E,OAAO;EACL,KAAK,aAAa,OAAO,SAAS,WAAW,cAAc,KAAK,MAAM,MAAM,SAAS,MAAM,aAAa,SAAS,QAAQ,GAAG,GAAG,YAAY,kBAAkB,UAAU,IAAI,KAAK;EAChL,UAAU;GAAC,GAAG,MAAM;GAAU,GAAG,SAAS;GAAU,GAAI,WAAW,YAAY,CAAC;EAAE;EAClF,MAAM;GAAC,GAAG,MAAM;GAAM,GAAG,SAAS;GAAM,GAAI,WAAW,QAAQ,CAAC;EAAE;CACpE;AACF;;AAGA,SAAS,kBAAkB,OAAkD;CAC3E,OAAO,SAAS,KAAK,MAAM,WAAW,SAAS,cAAc,SAAS,aAAa,SAAS,YAAY;AAC1G"}

package/build/queries/sql/expressions/case.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"case.cjs","names":["isObject","parseExpression","joinFragments","expressionToSql","expressionNullable"],"sources":["../../../../src/queries/sql/expressions/case.ts"],"sourcesContent":["import { type ExprContext, type SqlFragment, joinFragments } from \"../Expr.ts\";\nimport type { QueryCondition } from \"../query.ts\";\nimport { expressionNullable, expressionToSql } from \"./expression.ts\";\nimport { checkKeys, isObject, parseExpression } from \"./parseExpression.ts\";\nimport type { CheckExpression, ParsedExpression, ResultCodec } from \"./types.ts\";\n\n/** One condition and the value to return when it is true. */\nexport interface CaseWhen {\n  readonly when: QueryCondition | undefined;\n  readonly then: unknown;\n  readonly else?: never;\n}\n\n/** The fallback value, allowed only as the last entry in a CASE array. */\nexport interface CaseElse {\n  readonly else: unknown;\n  readonly when?: never;\n  readonly then?: never;\n}\n\n/** A single WHEN or an ordered array of WHEN entries with an optional final ELSE. */\nexport interface CaseInput {\n  readonly case: CaseWhen | readonly (CaseWhen | CaseElse)[];\n}\n\n/** The values returned by CASE's THEN and ELSE entries. */\nexport type CaseArmValue<A> = A extends readonly unknown[]\n  ? CaseArmValue<A[number]>\n  : A extends { readonly then: infer V }\n    ? V\n    : A extends { readonly else: infer V }\n      ? V\n      : never;\n\n/** A single CASE entry must be WHEN; an array can also have a final ELSE. */\nexport type CheckCase<A, R> = A extends readonly []\n  ? \"CASE needs at least one arm\"\n  : A extends readonly unknown[]\n    ? { readonly [K in keyof A]: CheckCaseEntry<A[K], R> } & CheckCaseOrder<A>\n    : A extends CaseWhen\n      ? CheckCaseEntry<A, R>\n      : never;\n\n/** Checks THEN/ELSE values and rejects extra keys on an entry. */\ntype CheckCaseEntry<A, R> = A extends CaseWhen\n  ? { readonly [K in keyof A]: K extends \"then\" ? CheckExpression<A[K], R> : K extends \"when\" ? unknown : never }\n  : A extends CaseElse\n    ? { readonly [K in keyof A]: K extends \"else\" ? CheckExpression<A[K], R> : never }\n    : never;\n\n/** Fixed CASE arrays can be checked now; dynamic arrays get the same checks at runtime. */\ntype CheckCaseOrder<A extends readonly unknown[], HasWhen extends boolean = false> = A extends readonly [\n  infer H,\n  ...infer T,\n]\n  ? H extends { readonly else: unknown }\n    ? HasWhen extends true\n      ? T extends readonly []\n        ? unknown\n        : \"CASE ELSE must be last\"\n      : \"CASE needs a WHEN arm before ELSE\"\n    : CheckCaseOrder<T, true>\n  : unknown;\n\n/** A CASE has at least one WHEN and an optional ELSE; no ELSE means SQL NULL. */\nexport interface ParsedCaseExpression {\n  kind: \"case\";\n  whens: [ParsedCaseWhen, ...ParsedCaseWhen[]];\n  else?: ParsedExpression;\n}\n\n/** A CASE condition and its parsed result expression. */\ninterface ParsedCaseWhen {\n  when: QueryCondition | undefined;\n  then: ParsedExpression;\n}\n\n/**\n * Parses WHEN entries and an optional final ELSE into a ParsedCaseExpression.\n * Requires at least one WHEN, even if its condition may later be pruned.\n */\nexport function parseCaseExpression(input: unknown): ParsedCaseExpression {\n  const entries = Array.isArray(input) ? input : [input];\n  const whens: ParsedCaseWhen[] = [];\n  let fallback: ParsedExpression | undefined;\n  for (const [i, entry] of entries.entries()) {\n    if (isObject(entry) && \"else\" in entry) {\n      checkKeys(entry, [\"else\"]);\n      if (whens.length === 0) throw new Error(\"CASE needs a WHEN arm before ELSE\");\n      if (i !== entries.length - 1) throw new Error(\"CASE ELSE must be last\");\n      fallback = parseExpression(entry.else);\n    } else {\n      if (!isObject(entry) || !(\"when\" in entry) || !(\"then\" in entry))\n        throw new Error(\"A CASE arm needs when and then\");\n      checkKeys(entry, [\"when\", \"then\"]);\n      whens.push({ when: entry.when as QueryCondition | undefined, then: parseExpression(entry.then) });\n    }\n  }\n  if (whens.length === 0) throw new Error(\"CASE needs at least one arm\");\n  const [first, ...rest] = whens;\n  return { kind: \"case\", whens: [first, ...rest], else: fallback };\n}\n\n/** Removes CASE entries with omitted conditions, falling back to ELSE or SQL NULL if none remain. */\nexport function caseToSql(parsed: ParsedCaseExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  const parts: SqlFragment[] = [];\n  for (const entry of parsed.whens) {\n    const when = entry.when === undefined ? undefined : ctx.conditionToSql(entry.when);\n    if (!when) continue;\n    const branch = joinFragments([when, expressionToSql(entry.then, ctx, codec)], \" THEN \");\n    parts.push({ ...branch, sql: `WHEN ${branch.sql}` });\n  }\n  const otherwise = expressionToSql(parsed.else ?? { kind: \"literal\", value: null }, ctx, codec);\n  if (parts.length === 0) return otherwise;\n  if (parsed.else) parts.push({ ...otherwise, sql: `ELSE ${otherwise.sql}` });\n  const body = joinFragments(parts, \" \");\n  return { ...body, sql: `(CASE ${body.sql} END)` };\n}\n\n/** CASE is definitely non-null only when every THEN value and the ELSE value are non-null. */\nexport function caseNullable(parsed: ParsedCaseExpression): boolean | undefined {\n  return parsed.else &&\n    expressionNullable(parsed.else) === false &&\n    parsed.whens.every((entry) => expressionNullable(entry.then) === false)\n    ? false\n    : undefined;\n}\n"],"mappings":";;;;;;;;;AAiFA,SAAgB,oBAAoB,OAAsC;CACxE,MAAM,UAAU,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK;CACrD,MAAM,QAA0B,CAAC;CACjC,IAAI;CACJ,KAAK,MAAM,CAAC,GAAG,UAAU,QAAQ,QAAQ,GACvC,IAAIA,gDAAAA,SAAS,KAAK,KAAK,UAAU,OAAO;EACtC,gDAAA,UAAU,OAAO,CAAC,MAAM,CAAC;EACzB,IAAI,MAAM,WAAW,GAAG,MAAM,IAAI,MAAM,mCAAmC;EAC3E,IAAI,MAAM,QAAQ,SAAS,GAAG,MAAM,IAAI,MAAM,wBAAwB;EACtE,WAAWC,gDAAAA,gBAAgB,MAAM,IAAI;CACvC,OAAO;EACL,IAAI,CAACD,gDAAAA,SAAS,KAAK,KAAK,EAAE,UAAU,UAAU,EAAE,UAAU,QACxD,MAAM,IAAI,MAAM,gCAAgC;EAClD,gDAAA,UAAU,OAAO,CAAC,QAAQ,MAAM,CAAC;EACjC,MAAM,KAAK;GAAE,MAAM,MAAM;GAAoC,MAAMC,gDAAAA,gBAAgB,MAAM,IAAI;EAAE,CAAC;CAClG;CAEF,IAAI,MAAM,WAAW,GAAG,MAAM,IAAI,MAAM,6BAA6B;CACrE,MAAM,CAAC,OAAO,GAAG,QAAQ;CACzB,OAAO;EAAE,MAAM;EAAQ,OAAO,CAAC,OAAO,GAAG,IAAI;EAAG,MAAM;CAAS;AACjE;;AAGA,SAAgB,UAAU,QAA8B,KAAkB,OAAiC;CACzG,MAAM,QAAuB,CAAC;CAC9B,KAAK,MAAM,SAAS,OAAO,OAAO;EAChC,MAAM,OAAO,MAAM,SAAS,KAAA,IAAY,KAAA,IAAY,IAAI,eAAe,MAAM,IAAI;EACjF,IAAI,CAAC,MAAM;EACX,MAAM,SAASC,yBAAAA,cAAc,CAAC,MAAMC,2CAAAA,gBAAgB,MAAM,MAAM,KAAK,KAAK,CAAC,GAAG,QAAQ;EACtF,MAAM,KAAK;GAAE,GAAG;GAAQ,KAAK,QAAQ,OAAO;EAAM,CAAC;CACrD;CACA,MAAM,YAAYA,2CAAAA,gBAAgB,OAAO,QAAQ;EAAE,MAAM;EAAW,OAAO;CAAK,GAAG,KAAK,KAAK;CAC7F,IAAI,MAAM,WAAW,GAAG,OAAO;CAC/B,IAAI,OAAO,MAAM,MAAM,KAAK;EAAE,GAAG;EAAW,KAAK,QAAQ,UAAU;CAAM,CAAC;CAC1E,MAAM,OAAOD,yBAAAA,cAAc,OAAO,GAAG;CACrC,OAAO;EAAE,GAAG;EAAM,KAAK,SAAS,KAAK,IAAI;CAAO;AAClD;;AAGA,SAAgB,aAAa,QAAmD;CAC9E,OAAO,OAAO,QACZE,2CAAAA,mBAAmB,OAAO,IAAI,MAAM,SACpC,OAAO,MAAM,OAAO,UAAUA,2CAAAA,mBAAmB,MAAM,IAAI,MAAM,KAAK,IACpE,QACA,KAAA;AACN"}
+{"version":3,"file":"case.cjs","names":["isObject","parseExpression","joinFragments","expressionToSql","expressionNullable"],"sources":["../../../../src/queries/sql/expressions/case.ts"],"sourcesContent":["import { type ExprContext, type SqlFragment, joinFragments } from \"src/queries/sql/Expr.ts\";\nimport { expressionNullable, expressionToSql } from \"src/queries/sql/expressions/expression.ts\";\nimport { checkKeys, isObject, parseExpression } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type { CheckExpression, ParsedExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\nimport type { QueryCondition } from \"src/queries/sql/query.ts\";\n\n/** One condition and the value to return when it is true. */\nexport interface CaseWhen {\n  readonly when: QueryCondition | undefined;\n  readonly then: unknown;\n  readonly else?: never;\n}\n\n/** The fallback value, allowed only as the last entry in a CASE array. */\nexport interface CaseElse {\n  readonly else: unknown;\n  readonly when?: never;\n  readonly then?: never;\n}\n\n/** A single WHEN or an ordered array of WHEN entries with an optional final ELSE. */\nexport interface CaseInput {\n  readonly case: CaseWhen | readonly (CaseWhen | CaseElse)[];\n}\n\n/** The values returned by CASE's THEN and ELSE entries. */\nexport type CaseArmValue<A> = A extends readonly unknown[]\n  ? CaseArmValue<A[number]>\n  : A extends { readonly then: infer V }\n    ? V\n    : A extends { readonly else: infer V }\n      ? V\n      : never;\n\n/** A single CASE entry must be WHEN; an array can also have a final ELSE. */\nexport type CheckCase<A, R> = A extends readonly []\n  ? \"CASE needs at least one arm\"\n  : A extends readonly unknown[]\n    ? { readonly [K in keyof A]: CheckCaseEntry<A[K], R> } & CheckCaseOrder<A>\n    : A extends CaseWhen\n      ? CheckCaseEntry<A, R>\n      : never;\n\n/** Checks THEN/ELSE values and rejects extra keys on an entry. */\ntype CheckCaseEntry<A, R> = A extends CaseWhen\n  ? { readonly [K in keyof A]: K extends \"then\" ? CheckExpression<A[K], R> : K extends \"when\" ? unknown : never }\n  : A extends CaseElse\n    ? { readonly [K in keyof A]: K extends \"else\" ? CheckExpression<A[K], R> : never }\n    : never;\n\n/** Fixed CASE arrays can be checked now; dynamic arrays get the same checks at runtime. */\ntype CheckCaseOrder<A extends readonly unknown[], HasWhen extends boolean = false> = A extends readonly [\n  infer H,\n  ...infer T,\n]\n  ? H extends { readonly else: unknown }\n    ? HasWhen extends true\n      ? T extends readonly []\n        ? unknown\n        : \"CASE ELSE must be last\"\n      : \"CASE needs a WHEN arm before ELSE\"\n    : CheckCaseOrder<T, true>\n  : unknown;\n\n/** A CASE has at least one WHEN and an optional ELSE; no ELSE means SQL NULL. */\nexport interface ParsedCaseExpression {\n  kind: \"case\";\n  whens: [ParsedCaseWhen, ...ParsedCaseWhen[]];\n  else?: ParsedExpression;\n}\n\n/** A CASE condition and its parsed result expression. */\ninterface ParsedCaseWhen {\n  when: QueryCondition | undefined;\n  then: ParsedExpression;\n}\n\n/**\n * Parses WHEN entries and an optional final ELSE into a ParsedCaseExpression.\n * Requires at least one WHEN, even if its condition may later be pruned.\n */\nexport function parseCaseExpression(input: unknown): ParsedCaseExpression {\n  const entries = Array.isArray(input) ? input : [input];\n  const whens: ParsedCaseWhen[] = [];\n  let fallback: ParsedExpression | undefined;\n  for (const [i, entry] of entries.entries()) {\n    if (isObject(entry) && \"else\" in entry) {\n      checkKeys(entry, [\"else\"]);\n      if (whens.length === 0) throw new Error(\"CASE needs a WHEN arm before ELSE\");\n      if (i !== entries.length - 1) throw new Error(\"CASE ELSE must be last\");\n      fallback = parseExpression(entry.else);\n    } else {\n      if (!isObject(entry) || !(\"when\" in entry) || !(\"then\" in entry))\n        throw new Error(\"A CASE arm needs when and then\");\n      checkKeys(entry, [\"when\", \"then\"]);\n      whens.push({ when: entry.when as QueryCondition | undefined, then: parseExpression(entry.then) });\n    }\n  }\n  if (whens.length === 0) throw new Error(\"CASE needs at least one arm\");\n  const [first, ...rest] = whens;\n  return { kind: \"case\", whens: [first, ...rest], else: fallback };\n}\n\n/** Removes CASE entries with omitted conditions, falling back to ELSE or SQL NULL if none remain. */\nexport function caseToSql(parsed: ParsedCaseExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  const parts: SqlFragment[] = [];\n  for (const entry of parsed.whens) {\n    const when = entry.when === undefined ? undefined : ctx.conditionToSql(entry.when);\n    if (!when) continue;\n    const branch = joinFragments([when, expressionToSql(entry.then, ctx, codec)], \" THEN \");\n    parts.push({ ...branch, sql: `WHEN ${branch.sql}` });\n  }\n  const otherwise = expressionToSql(parsed.else ?? { kind: \"literal\", value: null }, ctx, codec);\n  if (parts.length === 0) return otherwise;\n  if (parsed.else) parts.push({ ...otherwise, sql: `ELSE ${otherwise.sql}` });\n  const body = joinFragments(parts, \" \");\n  return { ...body, sql: `(CASE ${body.sql} END)` };\n}\n\n/** CASE is definitely non-null only when every THEN value and the ELSE value are non-null. */\nexport function caseNullable(parsed: ParsedCaseExpression): boolean | undefined {\n  return parsed.else &&\n    expressionNullable(parsed.else) === false &&\n    parsed.whens.every((entry) => expressionNullable(entry.then) === false)\n    ? false\n    : undefined;\n}\n"],"mappings":";;;;;;;;;AAiFA,SAAgB,oBAAoB,OAAsC;CACxE,MAAM,UAAU,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK;CACrD,MAAM,QAA0B,CAAC;CACjC,IAAI;CACJ,KAAK,MAAM,CAAC,GAAG,UAAU,QAAQ,QAAQ,GACvC,IAAIA,gDAAAA,SAAS,KAAK,KAAK,UAAU,OAAO;EACtC,gDAAA,UAAU,OAAO,CAAC,MAAM,CAAC;EACzB,IAAI,MAAM,WAAW,GAAG,MAAM,IAAI,MAAM,mCAAmC;EAC3E,IAAI,MAAM,QAAQ,SAAS,GAAG,MAAM,IAAI,MAAM,wBAAwB;EACtE,WAAWC,gDAAAA,gBAAgB,MAAM,IAAI;CACvC,OAAO;EACL,IAAI,CAACD,gDAAAA,SAAS,KAAK,KAAK,EAAE,UAAU,UAAU,EAAE,UAAU,QACxD,MAAM,IAAI,MAAM,gCAAgC;EAClD,gDAAA,UAAU,OAAO,CAAC,QAAQ,MAAM,CAAC;EACjC,MAAM,KAAK;GAAE,MAAM,MAAM;GAAoC,MAAMC,gDAAAA,gBAAgB,MAAM,IAAI;EAAE,CAAC;CAClG;CAEF,IAAI,MAAM,WAAW,GAAG,MAAM,IAAI,MAAM,6BAA6B;CACrE,MAAM,CAAC,OAAO,GAAG,QAAQ;CACzB,OAAO;EAAE,MAAM;EAAQ,OAAO,CAAC,OAAO,GAAG,IAAI;EAAG,MAAM;CAAS;AACjE;;AAGA,SAAgB,UAAU,QAA8B,KAAkB,OAAiC;CACzG,MAAM,QAAuB,CAAC;CAC9B,KAAK,MAAM,SAAS,OAAO,OAAO;EAChC,MAAM,OAAO,MAAM,SAAS,KAAA,IAAY,KAAA,IAAY,IAAI,eAAe,MAAM,IAAI;EACjF,IAAI,CAAC,MAAM;EACX,MAAM,SAASC,yBAAAA,cAAc,CAAC,MAAMC,2CAAAA,gBAAgB,MAAM,MAAM,KAAK,KAAK,CAAC,GAAG,QAAQ;EACtF,MAAM,KAAK;GAAE,GAAG;GAAQ,KAAK,QAAQ,OAAO;EAAM,CAAC;CACrD;CACA,MAAM,YAAYA,2CAAAA,gBAAgB,OAAO,QAAQ;EAAE,MAAM;EAAW,OAAO;CAAK,GAAG,KAAK,KAAK;CAC7F,IAAI,MAAM,WAAW,GAAG,OAAO;CAC/B,IAAI,OAAO,MAAM,MAAM,KAAK;EAAE,GAAG;EAAW,KAAK,QAAQ,UAAU;CAAM,CAAC;CAC1E,MAAM,OAAOD,yBAAAA,cAAc,OAAO,GAAG;CACrC,OAAO;EAAE,GAAG;EAAM,KAAK,SAAS,KAAK,IAAI;CAAO;AAClD;;AAGA,SAAgB,aAAa,QAAmD;CAC9E,OAAO,OAAO,QACZE,2CAAAA,mBAAmB,OAAO,IAAI,MAAM,SACpC,OAAO,MAAM,OAAO,UAAUA,2CAAAA,mBAAmB,MAAM,IAAI,MAAM,KAAK,IACpE,QACA,KAAA;AACN"}

package/build/queries/sql/expressions/case.js.map

@@ -1 +1 @@
-{"version":3,"file":"case.js","names":[],"sources":["../../../../src/queries/sql/expressions/case.ts"],"sourcesContent":["import { type ExprContext, type SqlFragment, joinFragments } from \"../Expr.ts\";\nimport type { QueryCondition } from \"../query.ts\";\nimport { expressionNullable, expressionToSql } from \"./expression.ts\";\nimport { checkKeys, isObject, parseExpression } from \"./parseExpression.ts\";\nimport type { CheckExpression, ParsedExpression, ResultCodec } from \"./types.ts\";\n\n/** One condition and the value to return when it is true. */\nexport interface CaseWhen {\n  readonly when: QueryCondition | undefined;\n  readonly then: unknown;\n  readonly else?: never;\n}\n\n/** The fallback value, allowed only as the last entry in a CASE array. */\nexport interface CaseElse {\n  readonly else: unknown;\n  readonly when?: never;\n  readonly then?: never;\n}\n\n/** A single WHEN or an ordered array of WHEN entries with an optional final ELSE. */\nexport interface CaseInput {\n  readonly case: CaseWhen | readonly (CaseWhen | CaseElse)[];\n}\n\n/** The values returned by CASE's THEN and ELSE entries. */\nexport type CaseArmValue<A> = A extends readonly unknown[]\n  ? CaseArmValue<A[number]>\n  : A extends { readonly then: infer V }\n    ? V\n    : A extends { readonly else: infer V }\n      ? V\n      : never;\n\n/** A single CASE entry must be WHEN; an array can also have a final ELSE. */\nexport type CheckCase<A, R> = A extends readonly []\n  ? \"CASE needs at least one arm\"\n  : A extends readonly unknown[]\n    ? { readonly [K in keyof A]: CheckCaseEntry<A[K], R> } & CheckCaseOrder<A>\n    : A extends CaseWhen\n      ? CheckCaseEntry<A, R>\n      : never;\n\n/** Checks THEN/ELSE values and rejects extra keys on an entry. */\ntype CheckCaseEntry<A, R> = A extends CaseWhen\n  ? { readonly [K in keyof A]: K extends \"then\" ? CheckExpression<A[K], R> : K extends \"when\" ? unknown : never }\n  : A extends CaseElse\n    ? { readonly [K in keyof A]: K extends \"else\" ? CheckExpression<A[K], R> : never }\n    : never;\n\n/** Fixed CASE arrays can be checked now; dynamic arrays get the same checks at runtime. */\ntype CheckCaseOrder<A extends readonly unknown[], HasWhen extends boolean = false> = A extends readonly [\n  infer H,\n  ...infer T,\n]\n  ? H extends { readonly else: unknown }\n    ? HasWhen extends true\n      ? T extends readonly []\n        ? unknown\n        : \"CASE ELSE must be last\"\n      : \"CASE needs a WHEN arm before ELSE\"\n    : CheckCaseOrder<T, true>\n  : unknown;\n\n/** A CASE has at least one WHEN and an optional ELSE; no ELSE means SQL NULL. */\nexport interface ParsedCaseExpression {\n  kind: \"case\";\n  whens: [ParsedCaseWhen, ...ParsedCaseWhen[]];\n  else?: ParsedExpression;\n}\n\n/** A CASE condition and its parsed result expression. */\ninterface ParsedCaseWhen {\n  when: QueryCondition | undefined;\n  then: ParsedExpression;\n}\n\n/**\n * Parses WHEN entries and an optional final ELSE into a ParsedCaseExpression.\n * Requires at least one WHEN, even if its condition may later be pruned.\n */\nexport function parseCaseExpression(input: unknown): ParsedCaseExpression {\n  const entries = Array.isArray(input) ? input : [input];\n  const whens: ParsedCaseWhen[] = [];\n  let fallback: ParsedExpression | undefined;\n  for (const [i, entry] of entries.entries()) {\n    if (isObject(entry) && \"else\" in entry) {\n      checkKeys(entry, [\"else\"]);\n      if (whens.length === 0) throw new Error(\"CASE needs a WHEN arm before ELSE\");\n      if (i !== entries.length - 1) throw new Error(\"CASE ELSE must be last\");\n      fallback = parseExpression(entry.else);\n    } else {\n      if (!isObject(entry) || !(\"when\" in entry) || !(\"then\" in entry))\n        throw new Error(\"A CASE arm needs when and then\");\n      checkKeys(entry, [\"when\", \"then\"]);\n      whens.push({ when: entry.when as QueryCondition | undefined, then: parseExpression(entry.then) });\n    }\n  }\n  if (whens.length === 0) throw new Error(\"CASE needs at least one arm\");\n  const [first, ...rest] = whens;\n  return { kind: \"case\", whens: [first, ...rest], else: fallback };\n}\n\n/** Removes CASE entries with omitted conditions, falling back to ELSE or SQL NULL if none remain. */\nexport function caseToSql(parsed: ParsedCaseExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  const parts: SqlFragment[] = [];\n  for (const entry of parsed.whens) {\n    const when = entry.when === undefined ? undefined : ctx.conditionToSql(entry.when);\n    if (!when) continue;\n    const branch = joinFragments([when, expressionToSql(entry.then, ctx, codec)], \" THEN \");\n    parts.push({ ...branch, sql: `WHEN ${branch.sql}` });\n  }\n  const otherwise = expressionToSql(parsed.else ?? { kind: \"literal\", value: null }, ctx, codec);\n  if (parts.length === 0) return otherwise;\n  if (parsed.else) parts.push({ ...otherwise, sql: `ELSE ${otherwise.sql}` });\n  const body = joinFragments(parts, \" \");\n  return { ...body, sql: `(CASE ${body.sql} END)` };\n}\n\n/** CASE is definitely non-null only when every THEN value and the ELSE value are non-null. */\nexport function caseNullable(parsed: ParsedCaseExpression): boolean | undefined {\n  return parsed.else &&\n    expressionNullable(parsed.else) === false &&\n    parsed.whens.every((entry) => expressionNullable(entry.then) === false)\n    ? false\n    : undefined;\n}\n"],"mappings":";;;;;;;;AAiFA,SAAgB,oBAAoB,OAAsC;CACxE,MAAM,UAAU,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK;CACrD,MAAM,QAA0B,CAAC;CACjC,IAAI;CACJ,KAAK,MAAM,CAAC,GAAG,UAAU,QAAQ,QAAQ,GACvC,IAAI,SAAS,KAAK,KAAK,UAAU,OAAO;EACtC,UAAU,OAAO,CAAC,MAAM,CAAC;EACzB,IAAI,MAAM,WAAW,GAAG,MAAM,IAAI,MAAM,mCAAmC;EAC3E,IAAI,MAAM,QAAQ,SAAS,GAAG,MAAM,IAAI,MAAM,wBAAwB;EACtE,WAAW,gBAAgB,MAAM,IAAI;CACvC,OAAO;EACL,IAAI,CAAC,SAAS,KAAK,KAAK,EAAE,UAAU,UAAU,EAAE,UAAU,QACxD,MAAM,IAAI,MAAM,gCAAgC;EAClD,UAAU,OAAO,CAAC,QAAQ,MAAM,CAAC;EACjC,MAAM,KAAK;GAAE,MAAM,MAAM;GAAoC,MAAM,gBAAgB,MAAM,IAAI;EAAE,CAAC;CAClG;CAEF,IAAI,MAAM,WAAW,GAAG,MAAM,IAAI,MAAM,6BAA6B;CACrE,MAAM,CAAC,OAAO,GAAG,QAAQ;CACzB,OAAO;EAAE,MAAM;EAAQ,OAAO,CAAC,OAAO,GAAG,IAAI;EAAG,MAAM;CAAS;AACjE;;AAGA,SAAgB,UAAU,QAA8B,KAAkB,OAAiC;CACzG,MAAM,QAAuB,CAAC;CAC9B,KAAK,MAAM,SAAS,OAAO,OAAO;EAChC,MAAM,OAAO,MAAM,SAAS,KAAA,IAAY,KAAA,IAAY,IAAI,eAAe,MAAM,IAAI;EACjF,IAAI,CAAC,MAAM;EACX,MAAM,SAAS,cAAc,CAAC,MAAM,gBAAgB,MAAM,MAAM,KAAK,KAAK,CAAC,GAAG,QAAQ;EACtF,MAAM,KAAK;GAAE,GAAG;GAAQ,KAAK,QAAQ,OAAO;EAAM,CAAC;CACrD;CACA,MAAM,YAAY,gBAAgB,OAAO,QAAQ;EAAE,MAAM;EAAW,OAAO;CAAK,GAAG,KAAK,KAAK;CAC7F,IAAI,MAAM,WAAW,GAAG,OAAO;CAC/B,IAAI,OAAO,MAAM,MAAM,KAAK;EAAE,GAAG;EAAW,KAAK,QAAQ,UAAU;CAAM,CAAC;CAC1E,MAAM,OAAO,cAAc,OAAO,GAAG;CACrC,OAAO;EAAE,GAAG;EAAM,KAAK,SAAS,KAAK,IAAI;CAAO;AAClD;;AAGA,SAAgB,aAAa,QAAmD;CAC9E,OAAO,OAAO,QACZ,mBAAmB,OAAO,IAAI,MAAM,SACpC,OAAO,MAAM,OAAO,UAAU,mBAAmB,MAAM,IAAI,MAAM,KAAK,IACpE,QACA,KAAA;AACN"}
+{"version":3,"file":"case.js","names":[],"sources":["../../../../src/queries/sql/expressions/case.ts"],"sourcesContent":["import { type ExprContext, type SqlFragment, joinFragments } from \"src/queries/sql/Expr.ts\";\nimport { expressionNullable, expressionToSql } from \"src/queries/sql/expressions/expression.ts\";\nimport { checkKeys, isObject, parseExpression } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type { CheckExpression, ParsedExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\nimport type { QueryCondition } from \"src/queries/sql/query.ts\";\n\n/** One condition and the value to return when it is true. */\nexport interface CaseWhen {\n  readonly when: QueryCondition | undefined;\n  readonly then: unknown;\n  readonly else?: never;\n}\n\n/** The fallback value, allowed only as the last entry in a CASE array. */\nexport interface CaseElse {\n  readonly else: unknown;\n  readonly when?: never;\n  readonly then?: never;\n}\n\n/** A single WHEN or an ordered array of WHEN entries with an optional final ELSE. */\nexport interface CaseInput {\n  readonly case: CaseWhen | readonly (CaseWhen | CaseElse)[];\n}\n\n/** The values returned by CASE's THEN and ELSE entries. */\nexport type CaseArmValue<A> = A extends readonly unknown[]\n  ? CaseArmValue<A[number]>\n  : A extends { readonly then: infer V }\n    ? V\n    : A extends { readonly else: infer V }\n      ? V\n      : never;\n\n/** A single CASE entry must be WHEN; an array can also have a final ELSE. */\nexport type CheckCase<A, R> = A extends readonly []\n  ? \"CASE needs at least one arm\"\n  : A extends readonly unknown[]\n    ? { readonly [K in keyof A]: CheckCaseEntry<A[K], R> } & CheckCaseOrder<A>\n    : A extends CaseWhen\n      ? CheckCaseEntry<A, R>\n      : never;\n\n/** Checks THEN/ELSE values and rejects extra keys on an entry. */\ntype CheckCaseEntry<A, R> = A extends CaseWhen\n  ? { readonly [K in keyof A]: K extends \"then\" ? CheckExpression<A[K], R> : K extends \"when\" ? unknown : never }\n  : A extends CaseElse\n    ? { readonly [K in keyof A]: K extends \"else\" ? CheckExpression<A[K], R> : never }\n    : never;\n\n/** Fixed CASE arrays can be checked now; dynamic arrays get the same checks at runtime. */\ntype CheckCaseOrder<A extends readonly unknown[], HasWhen extends boolean = false> = A extends readonly [\n  infer H,\n  ...infer T,\n]\n  ? H extends { readonly else: unknown }\n    ? HasWhen extends true\n      ? T extends readonly []\n        ? unknown\n        : \"CASE ELSE must be last\"\n      : \"CASE needs a WHEN arm before ELSE\"\n    : CheckCaseOrder<T, true>\n  : unknown;\n\n/** A CASE has at least one WHEN and an optional ELSE; no ELSE means SQL NULL. */\nexport interface ParsedCaseExpression {\n  kind: \"case\";\n  whens: [ParsedCaseWhen, ...ParsedCaseWhen[]];\n  else?: ParsedExpression;\n}\n\n/** A CASE condition and its parsed result expression. */\ninterface ParsedCaseWhen {\n  when: QueryCondition | undefined;\n  then: ParsedExpression;\n}\n\n/**\n * Parses WHEN entries and an optional final ELSE into a ParsedCaseExpression.\n * Requires at least one WHEN, even if its condition may later be pruned.\n */\nexport function parseCaseExpression(input: unknown): ParsedCaseExpression {\n  const entries = Array.isArray(input) ? input : [input];\n  const whens: ParsedCaseWhen[] = [];\n  let fallback: ParsedExpression | undefined;\n  for (const [i, entry] of entries.entries()) {\n    if (isObject(entry) && \"else\" in entry) {\n      checkKeys(entry, [\"else\"]);\n      if (whens.length === 0) throw new Error(\"CASE needs a WHEN arm before ELSE\");\n      if (i !== entries.length - 1) throw new Error(\"CASE ELSE must be last\");\n      fallback = parseExpression(entry.else);\n    } else {\n      if (!isObject(entry) || !(\"when\" in entry) || !(\"then\" in entry))\n        throw new Error(\"A CASE arm needs when and then\");\n      checkKeys(entry, [\"when\", \"then\"]);\n      whens.push({ when: entry.when as QueryCondition | undefined, then: parseExpression(entry.then) });\n    }\n  }\n  if (whens.length === 0) throw new Error(\"CASE needs at least one arm\");\n  const [first, ...rest] = whens;\n  return { kind: \"case\", whens: [first, ...rest], else: fallback };\n}\n\n/** Removes CASE entries with omitted conditions, falling back to ELSE or SQL NULL if none remain. */\nexport function caseToSql(parsed: ParsedCaseExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  const parts: SqlFragment[] = [];\n  for (const entry of parsed.whens) {\n    const when = entry.when === undefined ? undefined : ctx.conditionToSql(entry.when);\n    if (!when) continue;\n    const branch = joinFragments([when, expressionToSql(entry.then, ctx, codec)], \" THEN \");\n    parts.push({ ...branch, sql: `WHEN ${branch.sql}` });\n  }\n  const otherwise = expressionToSql(parsed.else ?? { kind: \"literal\", value: null }, ctx, codec);\n  if (parts.length === 0) return otherwise;\n  if (parsed.else) parts.push({ ...otherwise, sql: `ELSE ${otherwise.sql}` });\n  const body = joinFragments(parts, \" \");\n  return { ...body, sql: `(CASE ${body.sql} END)` };\n}\n\n/** CASE is definitely non-null only when every THEN value and the ELSE value are non-null. */\nexport function caseNullable(parsed: ParsedCaseExpression): boolean | undefined {\n  return parsed.else &&\n    expressionNullable(parsed.else) === false &&\n    parsed.whens.every((entry) => expressionNullable(entry.then) === false)\n    ? false\n    : undefined;\n}\n"],"mappings":";;;;;;;;AAiFA,SAAgB,oBAAoB,OAAsC;CACxE,MAAM,UAAU,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK;CACrD,MAAM,QAA0B,CAAC;CACjC,IAAI;CACJ,KAAK,MAAM,CAAC,GAAG,UAAU,QAAQ,QAAQ,GACvC,IAAI,SAAS,KAAK,KAAK,UAAU,OAAO;EACtC,UAAU,OAAO,CAAC,MAAM,CAAC;EACzB,IAAI,MAAM,WAAW,GAAG,MAAM,IAAI,MAAM,mCAAmC;EAC3E,IAAI,MAAM,QAAQ,SAAS,GAAG,MAAM,IAAI,MAAM,wBAAwB;EACtE,WAAW,gBAAgB,MAAM,IAAI;CACvC,OAAO;EACL,IAAI,CAAC,SAAS,KAAK,KAAK,EAAE,UAAU,UAAU,EAAE,UAAU,QACxD,MAAM,IAAI,MAAM,gCAAgC;EAClD,UAAU,OAAO,CAAC,QAAQ,MAAM,CAAC;EACjC,MAAM,KAAK;GAAE,MAAM,MAAM;GAAoC,MAAM,gBAAgB,MAAM,IAAI;EAAE,CAAC;CAClG;CAEF,IAAI,MAAM,WAAW,GAAG,MAAM,IAAI,MAAM,6BAA6B;CACrE,MAAM,CAAC,OAAO,GAAG,QAAQ;CACzB,OAAO;EAAE,MAAM;EAAQ,OAAO,CAAC,OAAO,GAAG,IAAI;EAAG,MAAM;CAAS;AACjE;;AAGA,SAAgB,UAAU,QAA8B,KAAkB,OAAiC;CACzG,MAAM,QAAuB,CAAC;CAC9B,KAAK,MAAM,SAAS,OAAO,OAAO;EAChC,MAAM,OAAO,MAAM,SAAS,KAAA,IAAY,KAAA,IAAY,IAAI,eAAe,MAAM,IAAI;EACjF,IAAI,CAAC,MAAM;EACX,MAAM,SAAS,cAAc,CAAC,MAAM,gBAAgB,MAAM,MAAM,KAAK,KAAK,CAAC,GAAG,QAAQ;EACtF,MAAM,KAAK;GAAE,GAAG;GAAQ,KAAK,QAAQ,OAAO;EAAM,CAAC;CACrD;CACA,MAAM,YAAY,gBAAgB,OAAO,QAAQ;EAAE,MAAM;EAAW,OAAO;CAAK,GAAG,KAAK,KAAK;CAC7F,IAAI,MAAM,WAAW,GAAG,OAAO;CAC/B,IAAI,OAAO,MAAM,MAAM,KAAK;EAAE,GAAG;EAAW,KAAK,QAAQ,UAAU;CAAM,CAAC;CAC1E,MAAM,OAAO,cAAc,OAAO,GAAG;CACrC,OAAO;EAAE,GAAG;EAAM,KAAK,SAAS,KAAK,IAAI;CAAO;AAClD;;AAGA,SAAgB,aAAa,QAAmD;CAC9E,OAAO,OAAO,QACZ,mBAAmB,OAAO,IAAI,MAAM,SACpC,OAAO,MAAM,OAAO,UAAU,mBAAmB,MAAM,IAAI,MAAM,KAAK,IACpE,QACA,KAAA;AACN"}

package/build/queries/sql/expressions/coalesce.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"coalesce.cjs","names":["parseNonEmptyOperands","functionToSql","expressionNullable"],"sources":["../../../../src/queries/sql/expressions/coalesce.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"../Expr.ts\";\nimport { expressionNullable, functionToSql } from \"./expression.ts\";\nimport { parseNonEmptyOperands } from \"./parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"./types.ts\";\n\n/** Candidates in order of preference; COALESCE returns the first non-null value. */\nexport interface CoalesceInput {\n  readonly coalesce: readonly unknown[];\n}\n\n/** A COALESCE with at least one candidate, in SQL evaluation order. */\nexport interface ParsedCoalesceExpression {\n  kind: \"coalesce\";\n  candidates: [ParsedExpression, ...ParsedExpression[]];\n}\n\n/** Parses COALESCE candidates and requires at least one value. */\nexport function parseCoalesceExpression(input: unknown): ParsedCoalesceExpression {\n  return { kind: \"coalesce\", candidates: parseNonEmptyOperands(input, \"COALESCE\") };\n}\n\n/** Renders COALESCE candidates in their original order. */\nexport function coalesceToSql(parsed: ParsedCoalesceExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  return functionToSql(\"COALESCE\", parsed.candidates, ctx, codec);\n}\n\n/** One non-null candidate guarantees a non-null COALESCE result. */\nexport function coalesceNullable(parsed: ParsedCoalesceExpression): boolean | undefined {\n  return parsed.candidates.some((candidate) => expressionNullable(candidate) === false) ? false : undefined;\n}\n"],"mappings":";;;;;AAiBA,SAAgB,wBAAwB,OAA0C;CAChF,OAAO;EAAE,MAAM;EAAY,YAAYA,gDAAAA,sBAAsB,OAAO,UAAU;CAAE;AAClF;;AAGA,SAAgB,cAAc,QAAkC,KAAkB,OAAiC;CACjH,OAAOC,2CAAAA,cAAc,YAAY,OAAO,YAAY,KAAK,KAAK;AAChE;;AAGA,SAAgB,iBAAiB,QAAuD;CACtF,OAAO,OAAO,WAAW,MAAM,cAAcC,2CAAAA,mBAAmB,SAAS,MAAM,KAAK,IAAI,QAAQ,KAAA;AAClG"}
+{"version":3,"file":"coalesce.cjs","names":["parseNonEmptyOperands","functionToSql","expressionNullable"],"sources":["../../../../src/queries/sql/expressions/coalesce.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"src/queries/sql/Expr.ts\";\nimport { expressionNullable, functionToSql } from \"src/queries/sql/expressions/expression.ts\";\nimport { parseNonEmptyOperands } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\n\n/** Candidates in order of preference; COALESCE returns the first non-null value. */\nexport interface CoalesceInput {\n  readonly coalesce: readonly unknown[];\n}\n\n/** A COALESCE with at least one candidate, in SQL evaluation order. */\nexport interface ParsedCoalesceExpression {\n  kind: \"coalesce\";\n  candidates: [ParsedExpression, ...ParsedExpression[]];\n}\n\n/** Parses COALESCE candidates and requires at least one value. */\nexport function parseCoalesceExpression(input: unknown): ParsedCoalesceExpression {\n  return { kind: \"coalesce\", candidates: parseNonEmptyOperands(input, \"COALESCE\") };\n}\n\n/** Renders COALESCE candidates in their original order. */\nexport function coalesceToSql(parsed: ParsedCoalesceExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  return functionToSql(\"COALESCE\", parsed.candidates, ctx, codec);\n}\n\n/** One non-null candidate guarantees a non-null COALESCE result. */\nexport function coalesceNullable(parsed: ParsedCoalesceExpression): boolean | undefined {\n  return parsed.candidates.some((candidate) => expressionNullable(candidate) === false) ? false : undefined;\n}\n"],"mappings":";;;;;AAiBA,SAAgB,wBAAwB,OAA0C;CAChF,OAAO;EAAE,MAAM;EAAY,YAAYA,gDAAAA,sBAAsB,OAAO,UAAU;CAAE;AAClF;;AAGA,SAAgB,cAAc,QAAkC,KAAkB,OAAiC;CACjH,OAAOC,2CAAAA,cAAc,YAAY,OAAO,YAAY,KAAK,KAAK;AAChE;;AAGA,SAAgB,iBAAiB,QAAuD;CACtF,OAAO,OAAO,WAAW,MAAM,cAAcC,2CAAAA,mBAAmB,SAAS,MAAM,KAAK,IAAI,QAAQ,KAAA;AAClG"}

package/build/queries/sql/expressions/coalesce.js.map

@@ -1 +1 @@
-{"version":3,"file":"coalesce.js","names":[],"sources":["../../../../src/queries/sql/expressions/coalesce.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"../Expr.ts\";\nimport { expressionNullable, functionToSql } from \"./expression.ts\";\nimport { parseNonEmptyOperands } from \"./parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"./types.ts\";\n\n/** Candidates in order of preference; COALESCE returns the first non-null value. */\nexport interface CoalesceInput {\n  readonly coalesce: readonly unknown[];\n}\n\n/** A COALESCE with at least one candidate, in SQL evaluation order. */\nexport interface ParsedCoalesceExpression {\n  kind: \"coalesce\";\n  candidates: [ParsedExpression, ...ParsedExpression[]];\n}\n\n/** Parses COALESCE candidates and requires at least one value. */\nexport function parseCoalesceExpression(input: unknown): ParsedCoalesceExpression {\n  return { kind: \"coalesce\", candidates: parseNonEmptyOperands(input, \"COALESCE\") };\n}\n\n/** Renders COALESCE candidates in their original order. */\nexport function coalesceToSql(parsed: ParsedCoalesceExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  return functionToSql(\"COALESCE\", parsed.candidates, ctx, codec);\n}\n\n/** One non-null candidate guarantees a non-null COALESCE result. */\nexport function coalesceNullable(parsed: ParsedCoalesceExpression): boolean | undefined {\n  return parsed.candidates.some((candidate) => expressionNullable(candidate) === false) ? false : undefined;\n}\n"],"mappings":";;;;AAiBA,SAAgB,wBAAwB,OAA0C;CAChF,OAAO;EAAE,MAAM;EAAY,YAAY,sBAAsB,OAAO,UAAU;CAAE;AAClF;;AAGA,SAAgB,cAAc,QAAkC,KAAkB,OAAiC;CACjH,OAAO,cAAc,YAAY,OAAO,YAAY,KAAK,KAAK;AAChE;;AAGA,SAAgB,iBAAiB,QAAuD;CACtF,OAAO,OAAO,WAAW,MAAM,cAAc,mBAAmB,SAAS,MAAM,KAAK,IAAI,QAAQ,KAAA;AAClG"}
+{"version":3,"file":"coalesce.js","names":[],"sources":["../../../../src/queries/sql/expressions/coalesce.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"src/queries/sql/Expr.ts\";\nimport { expressionNullable, functionToSql } from \"src/queries/sql/expressions/expression.ts\";\nimport { parseNonEmptyOperands } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\n\n/** Candidates in order of preference; COALESCE returns the first non-null value. */\nexport interface CoalesceInput {\n  readonly coalesce: readonly unknown[];\n}\n\n/** A COALESCE with at least one candidate, in SQL evaluation order. */\nexport interface ParsedCoalesceExpression {\n  kind: \"coalesce\";\n  candidates: [ParsedExpression, ...ParsedExpression[]];\n}\n\n/** Parses COALESCE candidates and requires at least one value. */\nexport function parseCoalesceExpression(input: unknown): ParsedCoalesceExpression {\n  return { kind: \"coalesce\", candidates: parseNonEmptyOperands(input, \"COALESCE\") };\n}\n\n/** Renders COALESCE candidates in their original order. */\nexport function coalesceToSql(parsed: ParsedCoalesceExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  return functionToSql(\"COALESCE\", parsed.candidates, ctx, codec);\n}\n\n/** One non-null candidate guarantees a non-null COALESCE result. */\nexport function coalesceNullable(parsed: ParsedCoalesceExpression): boolean | undefined {\n  return parsed.candidates.some((candidate) => expressionNullable(candidate) === false) ? false : undefined;\n}\n"],"mappings":";;;;AAiBA,SAAgB,wBAAwB,OAA0C;CAChF,OAAO;EAAE,MAAM;EAAY,YAAY,sBAAsB,OAAO,UAAU;CAAE;AAClF;;AAGA,SAAgB,cAAc,QAAkC,KAAkB,OAAiC;CACjH,OAAO,cAAc,YAAY,OAAO,YAAY,KAAK,KAAK;AAChE;;AAGA,SAAgB,iBAAiB,QAAuD;CACtF,OAAO,OAAO,WAAW,MAAM,cAAc,mBAAmB,SAAS,MAAM,KAAK,IAAI,QAAQ,KAAA;AAClG"}

package/build/queries/sql/expressions/codecs.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_TypeInfo = require("../../../TypeInfo.cjs");
+const require_serde_TypeInfo = require("../../../serde/TypeInfo.cjs");
 const require_queries_sql_Expr = require("../Expr.cjs");
 const require_utils = require("../../../utils.cjs");
 let node_util = require("node:util");
@@ -62,7 +62,7 @@ function expressionLeaves(parsed) {
 		case "arrayAgg": {
 			const valueCodec = chooseExpressionCodec(parsed.value);
 			return [{ codec: {
-				outputType: require_TypeInfo.arrayOutputType(valueCodec.outputType),
+				outputType: require_serde_TypeInfo.arrayOutputType(valueCodec.outputType),
 				encode: (value) => Array.isArray(value) ? value.map((element) => valueCodec.encode(element)) : value,
 				decode: (value) => Array.isArray(value) ? value.map((element) => valueCodec.decode(element)) : value
 			} }];

package/build/queries/sql/expressions/codecs.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"codecs.cjs","names":["BaseExpr","arrayOutputType","assertNever","inspect"],"sources":["../../../../src/queries/sql/expressions/codecs.ts"],"sourcesContent":["import { inspect } from \"node:util\";\n\nimport { type TypeInfo, arrayOutputType } from \"../../../TypeInfo.ts\";\nimport { assertNever } from \"../../../utils.ts\";\nimport { BaseExpr } from \"../Expr.ts\";\nimport type { ParsedExpression, ParsedLiteralExpression, ResultCodec } from \"./types.ts\";\n\n/**\n * Chooses one decoder for all possible result values. Columns must agree on a compatible SQL type and domain;\n * literals use that column's encoder. This is conservative: PostgreSQL may accept other combinations,\n * but Joist cannot safely choose their decoder. I.e. Author.id and Book.id both store integers but use different tags.\n */\nexport function chooseExpressionCodec(parsed: ParsedExpression): ResultCodec {\n  const leaves = expressionLeaves(parsed);\n  const expressions = leaves.flatMap((leaf) => (\"codec\" in leaf ? [leaf.codec] : []));\n  const first = expressions[0];\n  if (first) {\n    for (const other of expressions.slice(1)) {\n      if (other === first) continue;\n      const a = first.outputType;\n      const b = other.outputType;\n      if (!a || !b || !compatibleDbTypes(a.dbType, b.dbType) || a.domain !== b.domain || a.idMeta !== b.idMeta) {\n        const mismatches =\n          !a || !b\n            ? [\"unknown codec\"]\n            : [\n                ...(!compatibleDbTypes(a.dbType, b.dbType) ? [\"SQL type\"] : []),\n                ...(a.domain !== b.domain ? [\"domain\"] : []),\n                ...(a.idMeta !== b.idMeta ? [\"ID target\"] : []),\n              ];\n        throw new Error(\n          `Expression operands need matching SQL types and codecs: ${describeType(a)} vs ${describeType(b)}; mismatched ${mismatches.join(\", \")}`,\n        );\n      }\n    }\n    for (const leaf of leaves) if (\"literal\" in leaf) checkLiteral(leaf.literal.value, first.outputType);\n    return first;\n  }\n  const literals = leaves.flatMap((leaf) => (\"literal\" in leaf ? [leaf.literal] : []));\n  const types = literals.map((v) => literalType(v.value)).filter((v) => v !== undefined);\n  for (const literal of literals) checkLiteral(literal.value, types[0]);\n  return new LiteralCodec(types[0] ?? { dbType: \"text\", domain: String });\n}\n\n/** Gives literal-only expressions a SQL type so PostgreSQL does not return numbers as text. */\nclass LiteralCodec {\n  constructor(readonly outputType: TypeInfo) {}\n\n  encode(value: unknown): unknown {\n    return value;\n  }\n\n  decode(value: unknown): unknown {\n    return this.outputType.domain === BigInt ? BigInt(value as string) : value;\n  }\n}\n\n/**\n * Finds parsed operands that share a codec, including NULLIF's comparison operand but not CASE conditions.\n * Each kind selects its own value fields; only CASE's THEN and ELSE expressions contribute a result codec.\n */\nfunction expressionLeaves(parsed: ParsedExpression): CodecLeaf[] {\n  if (parsed instanceof BaseExpr) return [{ codec: parsed }];\n  switch (parsed.kind) {\n    case \"literal\":\n      return [{ literal: parsed }];\n    case \"arrayAgg\": {\n      const valueCodec = chooseExpressionCodec(parsed.value);\n      return [\n        {\n          codec: {\n            outputType: arrayOutputType(valueCodec.outputType),\n            encode: (value) => (Array.isArray(value) ? value.map((element) => valueCodec.encode(element)) : value),\n            decode: (value) => (Array.isArray(value) ? value.map((element) => valueCodec.decode(element)) : value),\n          },\n        },\n      ];\n    }\n    case \"coalesce\":\n      return parsed.candidates.flatMap((candidate) => expressionLeaves(candidate));\n    case \"nullIf\":\n      return [...expressionLeaves(parsed.value), ...expressionLeaves(parsed.equals)];\n    case \"greatest\":\n    case \"least\":\n      return parsed.values.flatMap((value) => expressionLeaves(value));\n    case \"case\":\n      return [\n        ...parsed.whens.flatMap((entry) => expressionLeaves(entry.then)),\n        ...(parsed.else ? expressionLeaves(parsed.else) : []),\n      ];\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** One result codec or one literal that will adopt a sibling codec. */\ntype CodecLeaf = { codec: ResultCodec } | { literal: ParsedLiteralExpression };\n\n/** Supplies predictable PostgreSQL types for standalone primitive literals. */\nfunction literalType(value: unknown): TypeInfo | undefined {\n  if (value === null) return undefined;\n  if (typeof value === \"string\") return { dbType: \"text\", domain: String, arrayElementSafe: true };\n  if (typeof value === \"number\") return { dbType: \"float8\", domain: Number, arrayElementSafe: true };\n  if (typeof value === \"boolean\") return { dbType: \"bool\", domain: Boolean, arrayElementSafe: true };\n  if (typeof value === \"bigint\") return { dbType: \"int8\", domain: BigInt };\n  if (value instanceof Date) return { dbType: \"timestamptz\", domain: Date };\n  throw new Error(\"Object and array literals need an expression with a matching codec\");\n}\n\n/** Rejects primitive literals that disagree with the column; custom values are checked by their encoder. */\nfunction checkLiteral(value: unknown, type: TypeInfo | undefined): void {\n  if (value === null || !type) return;\n  const domain = type.domain;\n  if (\n    (domain === String && typeof value !== \"string\") ||\n    (domain === Number && typeof value !== \"number\") ||\n    (domain === Boolean && typeof value !== \"boolean\") ||\n    (domain === BigInt && typeof value !== \"bigint\") ||\n    (domain === Date && !(value instanceof Date))\n  ) {\n    throw new Error(\n      `Expression values must have compatible types: expected ${describeType(type)}, got ${inspect(value)} (${typeof value})`,\n    );\n  }\n}\n\n/** Names the storage type, conversion domain, and entity tag involved in a codec mismatch. */\nfunction describeType(type: TypeInfo | undefined): string {\n  if (!type) return \"unknown codec\";\n  const domain = typeof type.domain === \"function\" ? type.domain.name : inspect(type.domain, { depth: 0 });\n  return `${type.dbType} (domain ${domain}${type.idMeta ? `, ID target ${type.idMeta.type}` : \"\"})`;\n}\n\nconst compatibleStringDbTypes = new Set([\"text\", \"varchar\"]);\n\n/** Allows PostgreSQL scalar string types that resolve to a common string result. */\nfunction compatibleDbTypes(a: string, b: string): boolean {\n  return a === b || (compatibleStringDbTypes.has(a) && compatibleStringDbTypes.has(b));\n}\n"],"mappings":"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"}
+{"version":3,"file":"codecs.cjs","names":["BaseExpr","arrayOutputType","assertNever","inspect"],"sources":["../../../../src/queries/sql/expressions/codecs.ts"],"sourcesContent":["import { inspect } from \"node:util\";\n\nimport { BaseExpr } from \"src/queries/sql/Expr.ts\";\nimport type { ParsedExpression, ParsedLiteralExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\nimport { type TypeInfo, arrayOutputType } from \"src/serde/TypeInfo.ts\";\nimport { assertNever } from \"src/utils.ts\";\n\n/**\n * Chooses one decoder for all possible result values. Columns must agree on a compatible SQL type and domain;\n * literals use that column's encoder. This is conservative: PostgreSQL may accept other combinations,\n * but Joist cannot safely choose their decoder. I.e. Author.id and Book.id both store integers but use different tags.\n */\nexport function chooseExpressionCodec(parsed: ParsedExpression): ResultCodec {\n  const leaves = expressionLeaves(parsed);\n  const expressions = leaves.flatMap((leaf) => (\"codec\" in leaf ? [leaf.codec] : []));\n  const first = expressions[0];\n  if (first) {\n    for (const other of expressions.slice(1)) {\n      if (other === first) continue;\n      const a = first.outputType;\n      const b = other.outputType;\n      if (!a || !b || !compatibleDbTypes(a.dbType, b.dbType) || a.domain !== b.domain || a.idMeta !== b.idMeta) {\n        const mismatches =\n          !a || !b\n            ? [\"unknown codec\"]\n            : [\n                ...(!compatibleDbTypes(a.dbType, b.dbType) ? [\"SQL type\"] : []),\n                ...(a.domain !== b.domain ? [\"domain\"] : []),\n                ...(a.idMeta !== b.idMeta ? [\"ID target\"] : []),\n              ];\n        throw new Error(\n          `Expression operands need matching SQL types and codecs: ${describeType(a)} vs ${describeType(b)}; mismatched ${mismatches.join(\", \")}`,\n        );\n      }\n    }\n    for (const leaf of leaves) if (\"literal\" in leaf) checkLiteral(leaf.literal.value, first.outputType);\n    return first;\n  }\n  const literals = leaves.flatMap((leaf) => (\"literal\" in leaf ? [leaf.literal] : []));\n  const types = literals.map((v) => literalType(v.value)).filter((v) => v !== undefined);\n  for (const literal of literals) checkLiteral(literal.value, types[0]);\n  return new LiteralCodec(types[0] ?? { dbType: \"text\", domain: String });\n}\n\n/** Gives literal-only expressions a SQL type so PostgreSQL does not return numbers as text. */\nclass LiteralCodec {\n  constructor(readonly outputType: TypeInfo) {}\n\n  encode(value: unknown): unknown {\n    return value;\n  }\n\n  decode(value: unknown): unknown {\n    return this.outputType.domain === BigInt ? BigInt(value as string) : value;\n  }\n}\n\n/**\n * Finds parsed operands that share a codec, including NULLIF's comparison operand but not CASE conditions.\n * Each kind selects its own value fields; only CASE's THEN and ELSE expressions contribute a result codec.\n */\nfunction expressionLeaves(parsed: ParsedExpression): CodecLeaf[] {\n  if (parsed instanceof BaseExpr) return [{ codec: parsed }];\n  switch (parsed.kind) {\n    case \"literal\":\n      return [{ literal: parsed }];\n    case \"arrayAgg\": {\n      const valueCodec = chooseExpressionCodec(parsed.value);\n      return [\n        {\n          codec: {\n            outputType: arrayOutputType(valueCodec.outputType),\n            encode: (value) => (Array.isArray(value) ? value.map((element) => valueCodec.encode(element)) : value),\n            decode: (value) => (Array.isArray(value) ? value.map((element) => valueCodec.decode(element)) : value),\n          },\n        },\n      ];\n    }\n    case \"coalesce\":\n      return parsed.candidates.flatMap((candidate) => expressionLeaves(candidate));\n    case \"nullIf\":\n      return [...expressionLeaves(parsed.value), ...expressionLeaves(parsed.equals)];\n    case \"greatest\":\n    case \"least\":\n      return parsed.values.flatMap((value) => expressionLeaves(value));\n    case \"case\":\n      return [\n        ...parsed.whens.flatMap((entry) => expressionLeaves(entry.then)),\n        ...(parsed.else ? expressionLeaves(parsed.else) : []),\n      ];\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** One result codec or one literal that will adopt a sibling codec. */\ntype CodecLeaf = { codec: ResultCodec } | { literal: ParsedLiteralExpression };\n\n/** Supplies predictable PostgreSQL types for standalone primitive literals. */\nfunction literalType(value: unknown): TypeInfo | undefined {\n  if (value === null) return undefined;\n  if (typeof value === \"string\") return { dbType: \"text\", domain: String, arrayElementSafe: true };\n  if (typeof value === \"number\") return { dbType: \"float8\", domain: Number, arrayElementSafe: true };\n  if (typeof value === \"boolean\") return { dbType: \"bool\", domain: Boolean, arrayElementSafe: true };\n  if (typeof value === \"bigint\") return { dbType: \"int8\", domain: BigInt };\n  if (value instanceof Date) return { dbType: \"timestamptz\", domain: Date };\n  throw new Error(\"Object and array literals need an expression with a matching codec\");\n}\n\n/** Rejects primitive literals that disagree with the column; custom values are checked by their encoder. */\nfunction checkLiteral(value: unknown, type: TypeInfo | undefined): void {\n  if (value === null || !type) return;\n  const domain = type.domain;\n  if (\n    (domain === String && typeof value !== \"string\") ||\n    (domain === Number && typeof value !== \"number\") ||\n    (domain === Boolean && typeof value !== \"boolean\") ||\n    (domain === BigInt && typeof value !== \"bigint\") ||\n    (domain === Date && !(value instanceof Date))\n  ) {\n    throw new Error(\n      `Expression values must have compatible types: expected ${describeType(type)}, got ${inspect(value)} (${typeof value})`,\n    );\n  }\n}\n\n/** Names the storage type, conversion domain, and entity tag involved in a codec mismatch. */\nfunction describeType(type: TypeInfo | undefined): string {\n  if (!type) return \"unknown codec\";\n  const domain = typeof type.domain === \"function\" ? type.domain.name : inspect(type.domain, { depth: 0 });\n  return `${type.dbType} (domain ${domain}${type.idMeta ? `, ID target ${type.idMeta.type}` : \"\"})`;\n}\n\nconst compatibleStringDbTypes = new Set([\"text\", \"varchar\"]);\n\n/** Allows PostgreSQL scalar string types that resolve to a common string result. */\nfunction compatibleDbTypes(a: string, b: string): boolean {\n  return a === b || (compatibleStringDbTypes.has(a) && compatibleStringDbTypes.has(b));\n}\n"],"mappings":"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"}

package/build/queries/sql/expressions/codecs.js

@@ -1,4 +1,4 @@
-import { arrayOutputType } from "../../../TypeInfo.js";
+import { arrayOutputType } from "../../../serde/TypeInfo.js";
 import { BaseExpr } from "../Expr.js";
 import { assertNever } from "../../../utils.js";
 import { inspect } from "node:util";

package/build/queries/sql/expressions/codecs.js.map

@@ -1 +1 @@
-{"version":3,"file":"codecs.js","names":[],"sources":["../../../../src/queries/sql/expressions/codecs.ts"],"sourcesContent":["import { inspect } from \"node:util\";\n\nimport { type TypeInfo, arrayOutputType } from \"../../../TypeInfo.ts\";\nimport { assertNever } from \"../../../utils.ts\";\nimport { BaseExpr } from \"../Expr.ts\";\nimport type { ParsedExpression, ParsedLiteralExpression, ResultCodec } from \"./types.ts\";\n\n/**\n * Chooses one decoder for all possible result values. Columns must agree on a compatible SQL type and domain;\n * literals use that column's encoder. This is conservative: PostgreSQL may accept other combinations,\n * but Joist cannot safely choose their decoder. I.e. Author.id and Book.id both store integers but use different tags.\n */\nexport function chooseExpressionCodec(parsed: ParsedExpression): ResultCodec {\n  const leaves = expressionLeaves(parsed);\n  const expressions = leaves.flatMap((leaf) => (\"codec\" in leaf ? [leaf.codec] : []));\n  const first = expressions[0];\n  if (first) {\n    for (const other of expressions.slice(1)) {\n      if (other === first) continue;\n      const a = first.outputType;\n      const b = other.outputType;\n      if (!a || !b || !compatibleDbTypes(a.dbType, b.dbType) || a.domain !== b.domain || a.idMeta !== b.idMeta) {\n        const mismatches =\n          !a || !b\n            ? [\"unknown codec\"]\n            : [\n                ...(!compatibleDbTypes(a.dbType, b.dbType) ? [\"SQL type\"] : []),\n                ...(a.domain !== b.domain ? [\"domain\"] : []),\n                ...(a.idMeta !== b.idMeta ? [\"ID target\"] : []),\n              ];\n        throw new Error(\n          `Expression operands need matching SQL types and codecs: ${describeType(a)} vs ${describeType(b)}; mismatched ${mismatches.join(\", \")}`,\n        );\n      }\n    }\n    for (const leaf of leaves) if (\"literal\" in leaf) checkLiteral(leaf.literal.value, first.outputType);\n    return first;\n  }\n  const literals = leaves.flatMap((leaf) => (\"literal\" in leaf ? [leaf.literal] : []));\n  const types = literals.map((v) => literalType(v.value)).filter((v) => v !== undefined);\n  for (const literal of literals) checkLiteral(literal.value, types[0]);\n  return new LiteralCodec(types[0] ?? { dbType: \"text\", domain: String });\n}\n\n/** Gives literal-only expressions a SQL type so PostgreSQL does not return numbers as text. */\nclass LiteralCodec {\n  constructor(readonly outputType: TypeInfo) {}\n\n  encode(value: unknown): unknown {\n    return value;\n  }\n\n  decode(value: unknown): unknown {\n    return this.outputType.domain === BigInt ? BigInt(value as string) : value;\n  }\n}\n\n/**\n * Finds parsed operands that share a codec, including NULLIF's comparison operand but not CASE conditions.\n * Each kind selects its own value fields; only CASE's THEN and ELSE expressions contribute a result codec.\n */\nfunction expressionLeaves(parsed: ParsedExpression): CodecLeaf[] {\n  if (parsed instanceof BaseExpr) return [{ codec: parsed }];\n  switch (parsed.kind) {\n    case \"literal\":\n      return [{ literal: parsed }];\n    case \"arrayAgg\": {\n      const valueCodec = chooseExpressionCodec(parsed.value);\n      return [\n        {\n          codec: {\n            outputType: arrayOutputType(valueCodec.outputType),\n            encode: (value) => (Array.isArray(value) ? value.map((element) => valueCodec.encode(element)) : value),\n            decode: (value) => (Array.isArray(value) ? value.map((element) => valueCodec.decode(element)) : value),\n          },\n        },\n      ];\n    }\n    case \"coalesce\":\n      return parsed.candidates.flatMap((candidate) => expressionLeaves(candidate));\n    case \"nullIf\":\n      return [...expressionLeaves(parsed.value), ...expressionLeaves(parsed.equals)];\n    case \"greatest\":\n    case \"least\":\n      return parsed.values.flatMap((value) => expressionLeaves(value));\n    case \"case\":\n      return [\n        ...parsed.whens.flatMap((entry) => expressionLeaves(entry.then)),\n        ...(parsed.else ? expressionLeaves(parsed.else) : []),\n      ];\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** One result codec or one literal that will adopt a sibling codec. */\ntype CodecLeaf = { codec: ResultCodec } | { literal: ParsedLiteralExpression };\n\n/** Supplies predictable PostgreSQL types for standalone primitive literals. */\nfunction literalType(value: unknown): TypeInfo | undefined {\n  if (value === null) return undefined;\n  if (typeof value === \"string\") return { dbType: \"text\", domain: String, arrayElementSafe: true };\n  if (typeof value === \"number\") return { dbType: \"float8\", domain: Number, arrayElementSafe: true };\n  if (typeof value === \"boolean\") return { dbType: \"bool\", domain: Boolean, arrayElementSafe: true };\n  if (typeof value === \"bigint\") return { dbType: \"int8\", domain: BigInt };\n  if (value instanceof Date) return { dbType: \"timestamptz\", domain: Date };\n  throw new Error(\"Object and array literals need an expression with a matching codec\");\n}\n\n/** Rejects primitive literals that disagree with the column; custom values are checked by their encoder. */\nfunction checkLiteral(value: unknown, type: TypeInfo | undefined): void {\n  if (value === null || !type) return;\n  const domain = type.domain;\n  if (\n    (domain === String && typeof value !== \"string\") ||\n    (domain === Number && typeof value !== \"number\") ||\n    (domain === Boolean && typeof value !== \"boolean\") ||\n    (domain === BigInt && typeof value !== \"bigint\") ||\n    (domain === Date && !(value instanceof Date))\n  ) {\n    throw new Error(\n      `Expression values must have compatible types: expected ${describeType(type)}, got ${inspect(value)} (${typeof value})`,\n    );\n  }\n}\n\n/** Names the storage type, conversion domain, and entity tag involved in a codec mismatch. */\nfunction describeType(type: TypeInfo | undefined): string {\n  if (!type) return \"unknown codec\";\n  const domain = typeof type.domain === \"function\" ? type.domain.name : inspect(type.domain, { depth: 0 });\n  return `${type.dbType} (domain ${domain}${type.idMeta ? `, ID target ${type.idMeta.type}` : \"\"})`;\n}\n\nconst compatibleStringDbTypes = new Set([\"text\", \"varchar\"]);\n\n/** Allows PostgreSQL scalar string types that resolve to a common string result. */\nfunction compatibleDbTypes(a: string, b: string): boolean {\n  return a === b || (compatibleStringDbTypes.has(a) && compatibleStringDbTypes.has(b));\n}\n"],"mappings":"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"}
+{"version":3,"file":"codecs.js","names":[],"sources":["../../../../src/queries/sql/expressions/codecs.ts"],"sourcesContent":["import { inspect } from \"node:util\";\n\nimport { BaseExpr } from \"src/queries/sql/Expr.ts\";\nimport type { ParsedExpression, ParsedLiteralExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\nimport { type TypeInfo, arrayOutputType } from \"src/serde/TypeInfo.ts\";\nimport { assertNever } from \"src/utils.ts\";\n\n/**\n * Chooses one decoder for all possible result values. Columns must agree on a compatible SQL type and domain;\n * literals use that column's encoder. This is conservative: PostgreSQL may accept other combinations,\n * but Joist cannot safely choose their decoder. I.e. Author.id and Book.id both store integers but use different tags.\n */\nexport function chooseExpressionCodec(parsed: ParsedExpression): ResultCodec {\n  const leaves = expressionLeaves(parsed);\n  const expressions = leaves.flatMap((leaf) => (\"codec\" in leaf ? [leaf.codec] : []));\n  const first = expressions[0];\n  if (first) {\n    for (const other of expressions.slice(1)) {\n      if (other === first) continue;\n      const a = first.outputType;\n      const b = other.outputType;\n      if (!a || !b || !compatibleDbTypes(a.dbType, b.dbType) || a.domain !== b.domain || a.idMeta !== b.idMeta) {\n        const mismatches =\n          !a || !b\n            ? [\"unknown codec\"]\n            : [\n                ...(!compatibleDbTypes(a.dbType, b.dbType) ? [\"SQL type\"] : []),\n                ...(a.domain !== b.domain ? [\"domain\"] : []),\n                ...(a.idMeta !== b.idMeta ? [\"ID target\"] : []),\n              ];\n        throw new Error(\n          `Expression operands need matching SQL types and codecs: ${describeType(a)} vs ${describeType(b)}; mismatched ${mismatches.join(\", \")}`,\n        );\n      }\n    }\n    for (const leaf of leaves) if (\"literal\" in leaf) checkLiteral(leaf.literal.value, first.outputType);\n    return first;\n  }\n  const literals = leaves.flatMap((leaf) => (\"literal\" in leaf ? [leaf.literal] : []));\n  const types = literals.map((v) => literalType(v.value)).filter((v) => v !== undefined);\n  for (const literal of literals) checkLiteral(literal.value, types[0]);\n  return new LiteralCodec(types[0] ?? { dbType: \"text\", domain: String });\n}\n\n/** Gives literal-only expressions a SQL type so PostgreSQL does not return numbers as text. */\nclass LiteralCodec {\n  constructor(readonly outputType: TypeInfo) {}\n\n  encode(value: unknown): unknown {\n    return value;\n  }\n\n  decode(value: unknown): unknown {\n    return this.outputType.domain === BigInt ? BigInt(value as string) : value;\n  }\n}\n\n/**\n * Finds parsed operands that share a codec, including NULLIF's comparison operand but not CASE conditions.\n * Each kind selects its own value fields; only CASE's THEN and ELSE expressions contribute a result codec.\n */\nfunction expressionLeaves(parsed: ParsedExpression): CodecLeaf[] {\n  if (parsed instanceof BaseExpr) return [{ codec: parsed }];\n  switch (parsed.kind) {\n    case \"literal\":\n      return [{ literal: parsed }];\n    case \"arrayAgg\": {\n      const valueCodec = chooseExpressionCodec(parsed.value);\n      return [\n        {\n          codec: {\n            outputType: arrayOutputType(valueCodec.outputType),\n            encode: (value) => (Array.isArray(value) ? value.map((element) => valueCodec.encode(element)) : value),\n            decode: (value) => (Array.isArray(value) ? value.map((element) => valueCodec.decode(element)) : value),\n          },\n        },\n      ];\n    }\n    case \"coalesce\":\n      return parsed.candidates.flatMap((candidate) => expressionLeaves(candidate));\n    case \"nullIf\":\n      return [...expressionLeaves(parsed.value), ...expressionLeaves(parsed.equals)];\n    case \"greatest\":\n    case \"least\":\n      return parsed.values.flatMap((value) => expressionLeaves(value));\n    case \"case\":\n      return [\n        ...parsed.whens.flatMap((entry) => expressionLeaves(entry.then)),\n        ...(parsed.else ? expressionLeaves(parsed.else) : []),\n      ];\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** One result codec or one literal that will adopt a sibling codec. */\ntype CodecLeaf = { codec: ResultCodec } | { literal: ParsedLiteralExpression };\n\n/** Supplies predictable PostgreSQL types for standalone primitive literals. */\nfunction literalType(value: unknown): TypeInfo | undefined {\n  if (value === null) return undefined;\n  if (typeof value === \"string\") return { dbType: \"text\", domain: String, arrayElementSafe: true };\n  if (typeof value === \"number\") return { dbType: \"float8\", domain: Number, arrayElementSafe: true };\n  if (typeof value === \"boolean\") return { dbType: \"bool\", domain: Boolean, arrayElementSafe: true };\n  if (typeof value === \"bigint\") return { dbType: \"int8\", domain: BigInt };\n  if (value instanceof Date) return { dbType: \"timestamptz\", domain: Date };\n  throw new Error(\"Object and array literals need an expression with a matching codec\");\n}\n\n/** Rejects primitive literals that disagree with the column; custom values are checked by their encoder. */\nfunction checkLiteral(value: unknown, type: TypeInfo | undefined): void {\n  if (value === null || !type) return;\n  const domain = type.domain;\n  if (\n    (domain === String && typeof value !== \"string\") ||\n    (domain === Number && typeof value !== \"number\") ||\n    (domain === Boolean && typeof value !== \"boolean\") ||\n    (domain === BigInt && typeof value !== \"bigint\") ||\n    (domain === Date && !(value instanceof Date))\n  ) {\n    throw new Error(\n      `Expression values must have compatible types: expected ${describeType(type)}, got ${inspect(value)} (${typeof value})`,\n    );\n  }\n}\n\n/** Names the storage type, conversion domain, and entity tag involved in a codec mismatch. */\nfunction describeType(type: TypeInfo | undefined): string {\n  if (!type) return \"unknown codec\";\n  const domain = typeof type.domain === \"function\" ? type.domain.name : inspect(type.domain, { depth: 0 });\n  return `${type.dbType} (domain ${domain}${type.idMeta ? `, ID target ${type.idMeta.type}` : \"\"})`;\n}\n\nconst compatibleStringDbTypes = new Set([\"text\", \"varchar\"]);\n\n/** Allows PostgreSQL scalar string types that resolve to a common string result. */\nfunction compatibleDbTypes(a: string, b: string): boolean {\n  return a === b || (compatibleStringDbTypes.has(a) && compatibleStringDbTypes.has(b));\n}\n"],"mappings":"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"}

package/build/queries/sql/expressions/expression.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"expression.cjs","names":["parseExpressionInput","BaseExpr","chooseExpressionCodec","nullIfNullable","coalesceNullable","greatestNullable","leastNullable","caseNullable","assertNever","arrayAggToSql","coalesceToSql","nullIfToSql","greatestToSql","leastToSql","caseToSql","joinFragments"],"sources":["../../../../src/queries/sql/expressions/expression.ts"],"sourcesContent":["import type { TypeInfo } from \"../../../TypeInfo.ts\";\nimport { assertNever } from \"../../../utils.ts\";\nimport { BaseExpr, type ExprContext, type SqlFragment, joinFragments } from \"../Expr.ts\";\nimport { arrayAggToSql } from \"./arrayAgg.ts\";\nimport { caseNullable, caseToSql } from \"./case.ts\";\nimport { coalesceNullable, coalesceToSql } from \"./coalesce.ts\";\nimport { chooseExpressionCodec } from \"./codecs.ts\";\nimport { greatestNullable, greatestToSql } from \"./greatest.ts\";\nimport { leastNullable, leastToSql } from \"./least.ts\";\nimport { nullIfNullable, nullIfToSql } from \"./nullIf.ts\";\nimport { parseExpressionInput } from \"./parseExpression.ts\";\nimport type { CheckInput, ExprFromInput, ExprInput, ParsedExpression, ResultCodec } from \"./types.ts\";\n\nexport type { CaseElse, CaseWhen } from \"./case.ts\";\nexport type { CheckInput, ExprFromInput, ExprInput, ExpressionSources, ExpressionValue } from \"./types.ts\";\n\n/** Builds a reusable SQL value expression, binding literal values as parameters. */\nexport function expr<const I extends ExprInput>(input: I & CheckInput<NoInfer<I>>): ExprFromInput<I> {\n  return buildExpr(input) as unknown as ExprFromInput<I>;\n}\n\n/** Parses explicit and inline inputs into a ParsedExpression, then wraps it in an Expr with a result codec. */\nexport function buildExpr(input: unknown): BaseExpr {\n  return new ObjectExpr(parseExpressionInput(input));\n}\n\n/** Exposes a ParsedExpression through the Expr methods, SQL rendering, and shared result codec. */\nclass ObjectExpr extends BaseExpr {\n  private readonly codec: ResultCodec;\n\n  constructor(private readonly parsed: ParsedExpression) {\n    super();\n    this.codec = chooseExpressionCodec(parsed);\n  }\n\n  get outputType(): TypeInfo | undefined {\n    return this.codec.outputType;\n  }\n\n  get sqlNullable(): boolean | undefined {\n    return expressionNullable(this.parsed);\n  }\n\n  toSql(ctx: ExprContext): SqlFragment {\n    return expressionToSql(this.parsed, ctx, this.codec);\n  }\n\n  decode(value: unknown): unknown {\n    return value == null ? value : this.codec.decode(value);\n  }\n\n  encode(value: unknown): unknown {\n    return value == null ? value : this.codec.encode(value);\n  }\n}\n\n/**\n * Reports nullability from the fields of each parsed expression kind.\n * A direct column can become null through a LEFT join, so only independent values prove NOT NULL here.\n */\nexport function expressionNullable(parsed: ParsedExpression): boolean | undefined {\n  if (parsed instanceof BaseExpr) return parsed.sqlSource ? undefined : parsed.sqlNullable;\n  switch (parsed.kind) {\n    case \"literal\":\n      return parsed.value === null;\n    case \"arrayAgg\":\n      return true;\n    case \"nullIf\":\n      return nullIfNullable();\n    case \"coalesce\":\n      return coalesceNullable(parsed);\n    case \"greatest\":\n      return greatestNullable(parsed);\n    case \"least\":\n      return leastNullable(parsed);\n    case \"case\":\n      return caseNullable(parsed);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/**\n * Renders a ParsedExpression in SQL binding order, resolving CASE conditions and collecting references for join pruning.\n * An omitted CASE condition removes its value as well. I.e. an unused Book.title branch must not keep the Book join.\n */\nexport function expressionToSql(parsed: ParsedExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  if (parsed instanceof BaseExpr) return parsed.toSql(ctx);\n  switch (parsed.kind) {\n    case \"literal\": {\n      const dbType = codec.outputType?.dbType;\n      return {\n        sql: dbType ? `?::${dbType}` : \"?\",\n        bindings: [parsed.value === null ? null : codec.encode(parsed.value)],\n        refs: [],\n      };\n    }\n    case \"arrayAgg\":\n      return arrayAggToSql(parsed, ctx, chooseExpressionCodec(parsed.value));\n    case \"coalesce\":\n      return coalesceToSql(parsed, ctx, codec);\n    case \"nullIf\":\n      return nullIfToSql(parsed, ctx, codec);\n    case \"greatest\":\n      return greatestToSql(parsed, ctx, codec);\n    case \"least\":\n      return leastToSql(parsed, ctx, codec);\n    case \"case\":\n      return caseToSql(parsed, ctx, codec);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** Renders a function call after its parsed kind has supplied the arguments in SQL order. */\nexport function functionToSql(\n  name: string,\n  args: readonly ParsedExpression[],\n  ctx: ExprContext,\n  codec: ResultCodec,\n): SqlFragment {\n  const parts = joinFragments(\n    args.map((arg) => expressionToSql(arg, ctx, codec)),\n    \", \",\n  );\n  return { ...parts, sql: `${name}(${parts.sql})` };\n}\n"],"mappings":";;;;;;;;;;;;;AAiBA,SAAgB,KAAgC,OAAqD;CACnG,OAAO,UAAU,KAAK;AACxB;;AAGA,SAAgB,UAAU,OAA0B;CAClD,OAAO,IAAI,WAAWA,gDAAAA,qBAAqB,KAAK,CAAC;AACnD;;AAGA,IAAM,aAAN,cAAyBC,yBAAAA,SAAS;CAGH;CAF7B;CAEA,YAAY,QAA2C;EACrD,MAAM;EADqB,KAAA,SAAA;EAE3B,KAAK,QAAQC,uCAAAA,sBAAsB,MAAM;CAC3C;CAEA,IAAI,aAAmC;EACrC,OAAO,KAAK,MAAM;CACpB;CAEA,IAAI,cAAmC;EACrC,OAAO,mBAAmB,KAAK,MAAM;CACvC;CAEA,MAAM,KAA+B;EACnC,OAAO,gBAAgB,KAAK,QAAQ,KAAK,KAAK,KAAK;CACrD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;AACF;;;;;AAMA,SAAgB,mBAAmB,QAA+C;CAChF,IAAI,kBAAkBD,yBAAAA,UAAU,OAAO,OAAO,YAAY,KAAA,IAAY,OAAO;CAC7E,QAAQ,OAAO,MAAf;EACE,KAAK,WACH,OAAO,OAAO,UAAU;EAC1B,KAAK,YACH,OAAO;EACT,KAAK,UACH,OAAOE,uCAAAA,eAAe;EACxB,KAAK,YACH,OAAOC,yCAAAA,iBAAiB,MAAM;EAChC,KAAK,YACH,OAAOC,yCAAAA,iBAAiB,MAAM;EAChC,KAAK,SACH,OAAOC,sCAAAA,cAAc,MAAM;EAC7B,KAAK,QACH,OAAOC,qCAAAA,aAAa,MAAM;EAC5B,SACE,OAAOC,cAAAA,YAAY,MAAM;CAC7B;AACF;;;;;AAMA,SAAgB,gBAAgB,QAA0B,KAAkB,OAAiC;CAC3G,IAAI,kBAAkBP,yBAAAA,UAAU,OAAO,OAAO,MAAM,GAAG;CACvD,QAAQ,OAAO,MAAf;EACE,KAAK,WAAW;GACd,MAAM,SAAS,MAAM,YAAY;GACjC,OAAO;IACL,KAAK,SAAS,MAAM,WAAW;IAC/B,UAAU,CAAC,OAAO,UAAU,OAAO,OAAO,MAAM,OAAO,OAAO,KAAK,CAAC;IACpE,MAAM,CAAC;GACT;EACF;EACA,KAAK,YACH,OAAOQ,yCAAAA,cAAc,QAAQ,KAAKP,uCAAAA,sBAAsB,OAAO,KAAK,CAAC;EACvE,KAAK,YACH,OAAOQ,yCAAAA,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,UACH,OAAOC,uCAAAA,YAAY,QAAQ,KAAK,KAAK;EACvC,KAAK,YACH,OAAOC,yCAAAA,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,SACH,OAAOC,sCAAAA,WAAW,QAAQ,KAAK,KAAK;EACtC,KAAK,QACH,OAAOC,qCAAAA,UAAU,QAAQ,KAAK,KAAK;EACrC,SACE,OAAON,cAAAA,YAAY,MAAM;CAC7B;AACF;;AAGA,SAAgB,cACd,MACA,MACA,KACA,OACa;CACb,MAAM,QAAQO,yBAAAA,cACZ,KAAK,KAAK,QAAQ,gBAAgB,KAAK,KAAK,KAAK,CAAC,GAClD,IACF;CACA,OAAO;EAAE,GAAG;EAAO,KAAK,GAAG,KAAK,GAAG,MAAM,IAAI;CAAG;AAClD"}
+{"version":3,"file":"expression.cjs","names":["parseExpressionInput","BaseExpr","chooseExpressionCodec","nullIfNullable","coalesceNullable","greatestNullable","leastNullable","caseNullable","assertNever","arrayAggToSql","coalesceToSql","nullIfToSql","greatestToSql","leastToSql","caseToSql","joinFragments"],"sources":["../../../../src/queries/sql/expressions/expression.ts"],"sourcesContent":["import { BaseExpr, type ExprContext, type SqlFragment, joinFragments } from \"src/queries/sql/Expr.ts\";\nimport { arrayAggToSql } from \"src/queries/sql/expressions/arrayAgg.ts\";\nimport { caseNullable, caseToSql } from \"src/queries/sql/expressions/case.ts\";\nimport { coalesceNullable, coalesceToSql } from \"src/queries/sql/expressions/coalesce.ts\";\nimport { chooseExpressionCodec } from \"src/queries/sql/expressions/codecs.ts\";\nimport { greatestNullable, greatestToSql } from \"src/queries/sql/expressions/greatest.ts\";\nimport { leastNullable, leastToSql } from \"src/queries/sql/expressions/least.ts\";\nimport { nullIfNullable, nullIfToSql } from \"src/queries/sql/expressions/nullIf.ts\";\nimport { parseExpressionInput } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type {\n  CheckInput,\n  ExprFromInput,\n  ExprInput,\n  ParsedExpression,\n  ResultCodec,\n} from \"src/queries/sql/expressions/types.ts\";\nimport type { TypeInfo } from \"src/serde/TypeInfo.ts\";\nimport { assertNever } from \"src/utils.ts\";\n\nexport type { CaseElse, CaseWhen } from \"src/queries/sql/expressions/case.ts\";\nexport type {\n  CheckInput,\n  ExprFromInput,\n  ExprInput,\n  ExpressionSources,\n  ExpressionValue,\n} from \"src/queries/sql/expressions/types.ts\";\n\n/** Builds a reusable SQL value expression, binding literal values as parameters. */\nexport function expr<const I extends ExprInput>(input: I & CheckInput<NoInfer<I>>): ExprFromInput<I> {\n  return buildExpr(input) as unknown as ExprFromInput<I>;\n}\n\n/** Parses explicit and inline inputs into a ParsedExpression, then wraps it in an Expr with a result codec. */\nexport function buildExpr(input: unknown): BaseExpr {\n  return new ObjectExpr(parseExpressionInput(input));\n}\n\n/** Exposes a ParsedExpression through the Expr methods, SQL rendering, and shared result codec. */\nclass ObjectExpr extends BaseExpr {\n  private readonly codec: ResultCodec;\n\n  constructor(private readonly parsed: ParsedExpression) {\n    super();\n    this.codec = chooseExpressionCodec(parsed);\n  }\n\n  get outputType(): TypeInfo | undefined {\n    return this.codec.outputType;\n  }\n\n  get sqlNullable(): boolean | undefined {\n    return expressionNullable(this.parsed);\n  }\n\n  toSql(ctx: ExprContext): SqlFragment {\n    return expressionToSql(this.parsed, ctx, this.codec);\n  }\n\n  decode(value: unknown): unknown {\n    return value == null ? value : this.codec.decode(value);\n  }\n\n  encode(value: unknown): unknown {\n    return value == null ? value : this.codec.encode(value);\n  }\n}\n\n/**\n * Reports nullability from the fields of each parsed expression kind.\n * A direct column can become null through a LEFT join, so only independent values prove NOT NULL here.\n */\nexport function expressionNullable(parsed: ParsedExpression): boolean | undefined {\n  if (parsed instanceof BaseExpr) return parsed.sqlSource ? undefined : parsed.sqlNullable;\n  switch (parsed.kind) {\n    case \"literal\":\n      return parsed.value === null;\n    case \"arrayAgg\":\n      return true;\n    case \"nullIf\":\n      return nullIfNullable();\n    case \"coalesce\":\n      return coalesceNullable(parsed);\n    case \"greatest\":\n      return greatestNullable(parsed);\n    case \"least\":\n      return leastNullable(parsed);\n    case \"case\":\n      return caseNullable(parsed);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/**\n * Renders a ParsedExpression in SQL binding order, resolving CASE conditions and collecting references for join pruning.\n * An omitted CASE condition removes its value as well. I.e. an unused Book.title branch must not keep the Book join.\n */\nexport function expressionToSql(parsed: ParsedExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  if (parsed instanceof BaseExpr) return parsed.toSql(ctx);\n  switch (parsed.kind) {\n    case \"literal\": {\n      const dbType = codec.outputType?.dbType;\n      return {\n        sql: dbType ? `?::${dbType}` : \"?\",\n        bindings: [parsed.value === null ? null : codec.encode(parsed.value)],\n        refs: [],\n      };\n    }\n    case \"arrayAgg\":\n      return arrayAggToSql(parsed, ctx, chooseExpressionCodec(parsed.value));\n    case \"coalesce\":\n      return coalesceToSql(parsed, ctx, codec);\n    case \"nullIf\":\n      return nullIfToSql(parsed, ctx, codec);\n    case \"greatest\":\n      return greatestToSql(parsed, ctx, codec);\n    case \"least\":\n      return leastToSql(parsed, ctx, codec);\n    case \"case\":\n      return caseToSql(parsed, ctx, codec);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** Renders a function call after its parsed kind has supplied the arguments in SQL order. */\nexport function functionToSql(\n  name: string,\n  args: readonly ParsedExpression[],\n  ctx: ExprContext,\n  codec: ResultCodec,\n): SqlFragment {\n  const parts = joinFragments(\n    args.map((arg) => expressionToSql(arg, ctx, codec)),\n    \", \",\n  );\n  return { ...parts, sql: `${name}(${parts.sql})` };\n}\n"],"mappings":";;;;;;;;;;;;;AA6BA,SAAgB,KAAgC,OAAqD;CACnG,OAAO,UAAU,KAAK;AACxB;;AAGA,SAAgB,UAAU,OAA0B;CAClD,OAAO,IAAI,WAAWA,gDAAAA,qBAAqB,KAAK,CAAC;AACnD;;AAGA,IAAM,aAAN,cAAyBC,yBAAAA,SAAS;CAGH;CAF7B;CAEA,YAAY,QAA2C;EACrD,MAAM;EADqB,KAAA,SAAA;EAE3B,KAAK,QAAQC,uCAAAA,sBAAsB,MAAM;CAC3C;CAEA,IAAI,aAAmC;EACrC,OAAO,KAAK,MAAM;CACpB;CAEA,IAAI,cAAmC;EACrC,OAAO,mBAAmB,KAAK,MAAM;CACvC;CAEA,MAAM,KAA+B;EACnC,OAAO,gBAAgB,KAAK,QAAQ,KAAK,KAAK,KAAK;CACrD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;AACF;;;;;AAMA,SAAgB,mBAAmB,QAA+C;CAChF,IAAI,kBAAkBD,yBAAAA,UAAU,OAAO,OAAO,YAAY,KAAA,IAAY,OAAO;CAC7E,QAAQ,OAAO,MAAf;EACE,KAAK,WACH,OAAO,OAAO,UAAU;EAC1B,KAAK,YACH,OAAO;EACT,KAAK,UACH,OAAOE,uCAAAA,eAAe;EACxB,KAAK,YACH,OAAOC,yCAAAA,iBAAiB,MAAM;EAChC,KAAK,YACH,OAAOC,yCAAAA,iBAAiB,MAAM;EAChC,KAAK,SACH,OAAOC,sCAAAA,cAAc,MAAM;EAC7B,KAAK,QACH,OAAOC,qCAAAA,aAAa,MAAM;EAC5B,SACE,OAAOC,cAAAA,YAAY,MAAM;CAC7B;AACF;;;;;AAMA,SAAgB,gBAAgB,QAA0B,KAAkB,OAAiC;CAC3G,IAAI,kBAAkBP,yBAAAA,UAAU,OAAO,OAAO,MAAM,GAAG;CACvD,QAAQ,OAAO,MAAf;EACE,KAAK,WAAW;GACd,MAAM,SAAS,MAAM,YAAY;GACjC,OAAO;IACL,KAAK,SAAS,MAAM,WAAW;IAC/B,UAAU,CAAC,OAAO,UAAU,OAAO,OAAO,MAAM,OAAO,OAAO,KAAK,CAAC;IACpE,MAAM,CAAC;GACT;EACF;EACA,KAAK,YACH,OAAOQ,yCAAAA,cAAc,QAAQ,KAAKP,uCAAAA,sBAAsB,OAAO,KAAK,CAAC;EACvE,KAAK,YACH,OAAOQ,yCAAAA,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,UACH,OAAOC,uCAAAA,YAAY,QAAQ,KAAK,KAAK;EACvC,KAAK,YACH,OAAOC,yCAAAA,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,SACH,OAAOC,sCAAAA,WAAW,QAAQ,KAAK,KAAK;EACtC,KAAK,QACH,OAAOC,qCAAAA,UAAU,QAAQ,KAAK,KAAK;EACrC,SACE,OAAON,cAAAA,YAAY,MAAM;CAC7B;AACF;;AAGA,SAAgB,cACd,MACA,MACA,KACA,OACa;CACb,MAAM,QAAQO,yBAAAA,cACZ,KAAK,KAAK,QAAQ,gBAAgB,KAAK,KAAK,KAAK,CAAC,GAClD,IACF;CACA,OAAO;EAAE,GAAG;EAAO,KAAK,GAAG,KAAK,GAAG,MAAM,IAAI;CAAG;AAClD"}

package/build/queries/sql/expressions/expression.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"expression.d.cts","names":[],"sources":["../../../../src/queries/sql/expressions/expression.ts"],"mappings":";;;;;iBAiBgB,WAAW,UAAU,WAAW,OAAO,IAAI,WAAW,QAAQ,MAAM,cAAc;;iBAKlF,UAAU,iBAAiB;;;;;iBAsC3B,mBAAmB,QAAQ;;;;;iBA0B3B,gBAAgB,QAAQ,kBAAkB,KAAK,aAAa,OAAO,cAAc;;iBA6BjF,cACd,cACA,eAAe,oBACf,KAAK,aACL,OAAO,cACN"}
+{"version":3,"file":"expression.d.cts","names":[],"sources":["../../../../src/queries/sql/expressions/expression.ts"],"mappings":";;;;;iBA6BgB,WAAW,UAAU,WAAW,OAAO,IAAI,WAAW,QAAQ,MAAM,cAAc;;iBAKlF,UAAU,iBAAiB;;;;;iBAsC3B,mBAAmB,QAAQ;;;;;iBA0B3B,gBAAgB,QAAQ,kBAAkB,KAAK,aAAa,OAAO,cAAc;;iBA6BjF,cACd,cACA,eAAe,oBACf,KAAK,aACL,OAAO,cACN"}

package/build/queries/sql/expressions/expression.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"expression.d.mts","names":[],"sources":["../../../../src/queries/sql/expressions/expression.ts"],"mappings":";;;;;iBAiBgB,WAAW,UAAU,WAAW,OAAO,IAAI,WAAW,QAAQ,MAAM,cAAc;;iBAKlF,UAAU,iBAAiB;;;;;iBAsC3B,mBAAmB,QAAQ;;;;;iBA0B3B,gBAAgB,QAAQ,kBAAkB,KAAK,aAAa,OAAO,cAAc;;iBA6BjF,cACd,cACA,eAAe,oBACf,KAAK,aACL,OAAO,cACN"}
+{"version":3,"file":"expression.d.mts","names":[],"sources":["../../../../src/queries/sql/expressions/expression.ts"],"mappings":";;;;;iBA6BgB,WAAW,UAAU,WAAW,OAAO,IAAI,WAAW,QAAQ,MAAM,cAAc;;iBAKlF,UAAU,iBAAiB;;;;;iBAsC3B,mBAAmB,QAAQ;;;;;iBA0B3B,gBAAgB,QAAQ,kBAAkB,KAAK,aAAa,OAAO,cAAc;;iBA6BjF,cACd,cACA,eAAe,oBACf,KAAK,aACL,OAAO,cACN"}

package/build/queries/sql/expressions/expression.js.map

@@ -1 +1 @@
-{"version":3,"file":"expression.js","names":[],"sources":["../../../../src/queries/sql/expressions/expression.ts"],"sourcesContent":["import type { TypeInfo } from \"../../../TypeInfo.ts\";\nimport { assertNever } from \"../../../utils.ts\";\nimport { BaseExpr, type ExprContext, type SqlFragment, joinFragments } from \"../Expr.ts\";\nimport { arrayAggToSql } from \"./arrayAgg.ts\";\nimport { caseNullable, caseToSql } from \"./case.ts\";\nimport { coalesceNullable, coalesceToSql } from \"./coalesce.ts\";\nimport { chooseExpressionCodec } from \"./codecs.ts\";\nimport { greatestNullable, greatestToSql } from \"./greatest.ts\";\nimport { leastNullable, leastToSql } from \"./least.ts\";\nimport { nullIfNullable, nullIfToSql } from \"./nullIf.ts\";\nimport { parseExpressionInput } from \"./parseExpression.ts\";\nimport type { CheckInput, ExprFromInput, ExprInput, ParsedExpression, ResultCodec } from \"./types.ts\";\n\nexport type { CaseElse, CaseWhen } from \"./case.ts\";\nexport type { CheckInput, ExprFromInput, ExprInput, ExpressionSources, ExpressionValue } from \"./types.ts\";\n\n/** Builds a reusable SQL value expression, binding literal values as parameters. */\nexport function expr<const I extends ExprInput>(input: I & CheckInput<NoInfer<I>>): ExprFromInput<I> {\n  return buildExpr(input) as unknown as ExprFromInput<I>;\n}\n\n/** Parses explicit and inline inputs into a ParsedExpression, then wraps it in an Expr with a result codec. */\nexport function buildExpr(input: unknown): BaseExpr {\n  return new ObjectExpr(parseExpressionInput(input));\n}\n\n/** Exposes a ParsedExpression through the Expr methods, SQL rendering, and shared result codec. */\nclass ObjectExpr extends BaseExpr {\n  private readonly codec: ResultCodec;\n\n  constructor(private readonly parsed: ParsedExpression) {\n    super();\n    this.codec = chooseExpressionCodec(parsed);\n  }\n\n  get outputType(): TypeInfo | undefined {\n    return this.codec.outputType;\n  }\n\n  get sqlNullable(): boolean | undefined {\n    return expressionNullable(this.parsed);\n  }\n\n  toSql(ctx: ExprContext): SqlFragment {\n    return expressionToSql(this.parsed, ctx, this.codec);\n  }\n\n  decode(value: unknown): unknown {\n    return value == null ? value : this.codec.decode(value);\n  }\n\n  encode(value: unknown): unknown {\n    return value == null ? value : this.codec.encode(value);\n  }\n}\n\n/**\n * Reports nullability from the fields of each parsed expression kind.\n * A direct column can become null through a LEFT join, so only independent values prove NOT NULL here.\n */\nexport function expressionNullable(parsed: ParsedExpression): boolean | undefined {\n  if (parsed instanceof BaseExpr) return parsed.sqlSource ? undefined : parsed.sqlNullable;\n  switch (parsed.kind) {\n    case \"literal\":\n      return parsed.value === null;\n    case \"arrayAgg\":\n      return true;\n    case \"nullIf\":\n      return nullIfNullable();\n    case \"coalesce\":\n      return coalesceNullable(parsed);\n    case \"greatest\":\n      return greatestNullable(parsed);\n    case \"least\":\n      return leastNullable(parsed);\n    case \"case\":\n      return caseNullable(parsed);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/**\n * Renders a ParsedExpression in SQL binding order, resolving CASE conditions and collecting references for join pruning.\n * An omitted CASE condition removes its value as well. I.e. an unused Book.title branch must not keep the Book join.\n */\nexport function expressionToSql(parsed: ParsedExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  if (parsed instanceof BaseExpr) return parsed.toSql(ctx);\n  switch (parsed.kind) {\n    case \"literal\": {\n      const dbType = codec.outputType?.dbType;\n      return {\n        sql: dbType ? `?::${dbType}` : \"?\",\n        bindings: [parsed.value === null ? null : codec.encode(parsed.value)],\n        refs: [],\n      };\n    }\n    case \"arrayAgg\":\n      return arrayAggToSql(parsed, ctx, chooseExpressionCodec(parsed.value));\n    case \"coalesce\":\n      return coalesceToSql(parsed, ctx, codec);\n    case \"nullIf\":\n      return nullIfToSql(parsed, ctx, codec);\n    case \"greatest\":\n      return greatestToSql(parsed, ctx, codec);\n    case \"least\":\n      return leastToSql(parsed, ctx, codec);\n    case \"case\":\n      return caseToSql(parsed, ctx, codec);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** Renders a function call after its parsed kind has supplied the arguments in SQL order. */\nexport function functionToSql(\n  name: string,\n  args: readonly ParsedExpression[],\n  ctx: ExprContext,\n  codec: ResultCodec,\n): SqlFragment {\n  const parts = joinFragments(\n    args.map((arg) => expressionToSql(arg, ctx, codec)),\n    \", \",\n  );\n  return { ...parts, sql: `${name}(${parts.sql})` };\n}\n"],"mappings":";;;;;;;;;;;;AAiBA,SAAgB,KAAgC,OAAqD;CACnG,OAAO,UAAU,KAAK;AACxB;;AAGA,SAAgB,UAAU,OAA0B;CAClD,OAAO,IAAI,WAAW,qBAAqB,KAAK,CAAC;AACnD;;AAGA,IAAM,aAAN,cAAyB,SAAS;CAGH;CAF7B;CAEA,YAAY,QAA2C;EACrD,MAAM;EADqB,KAAA,SAAA;EAE3B,KAAK,QAAQ,sBAAsB,MAAM;CAC3C;CAEA,IAAI,aAAmC;EACrC,OAAO,KAAK,MAAM;CACpB;CAEA,IAAI,cAAmC;EACrC,OAAO,mBAAmB,KAAK,MAAM;CACvC;CAEA,MAAM,KAA+B;EACnC,OAAO,gBAAgB,KAAK,QAAQ,KAAK,KAAK,KAAK;CACrD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;AACF;;;;;AAMA,SAAgB,mBAAmB,QAA+C;CAChF,IAAI,kBAAkB,UAAU,OAAO,OAAO,YAAY,KAAA,IAAY,OAAO;CAC7E,QAAQ,OAAO,MAAf;EACE,KAAK,WACH,OAAO,OAAO,UAAU;EAC1B,KAAK,YACH,OAAO;EACT,KAAK,UACH,OAAO,eAAe;EACxB,KAAK,YACH,OAAO,iBAAiB,MAAM;EAChC,KAAK,YACH,OAAO,iBAAiB,MAAM;EAChC,KAAK,SACH,OAAO,cAAc,MAAM;EAC7B,KAAK,QACH,OAAO,aAAa,MAAM;EAC5B,SACE,OAAO,YAAY,MAAM;CAC7B;AACF;;;;;AAMA,SAAgB,gBAAgB,QAA0B,KAAkB,OAAiC;CAC3G,IAAI,kBAAkB,UAAU,OAAO,OAAO,MAAM,GAAG;CACvD,QAAQ,OAAO,MAAf;EACE,KAAK,WAAW;GACd,MAAM,SAAS,MAAM,YAAY;GACjC,OAAO;IACL,KAAK,SAAS,MAAM,WAAW;IAC/B,UAAU,CAAC,OAAO,UAAU,OAAO,OAAO,MAAM,OAAO,OAAO,KAAK,CAAC;IACpE,MAAM,CAAC;GACT;EACF;EACA,KAAK,YACH,OAAO,cAAc,QAAQ,KAAK,sBAAsB,OAAO,KAAK,CAAC;EACvE,KAAK,YACH,OAAO,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,UACH,OAAO,YAAY,QAAQ,KAAK,KAAK;EACvC,KAAK,YACH,OAAO,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,SACH,OAAO,WAAW,QAAQ,KAAK,KAAK;EACtC,KAAK,QACH,OAAO,UAAU,QAAQ,KAAK,KAAK;EACrC,SACE,OAAO,YAAY,MAAM;CAC7B;AACF;;AAGA,SAAgB,cACd,MACA,MACA,KACA,OACa;CACb,MAAM,QAAQ,cACZ,KAAK,KAAK,QAAQ,gBAAgB,KAAK,KAAK,KAAK,CAAC,GAClD,IACF;CACA,OAAO;EAAE,GAAG;EAAO,KAAK,GAAG,KAAK,GAAG,MAAM,IAAI;CAAG;AAClD"}
+{"version":3,"file":"expression.js","names":[],"sources":["../../../../src/queries/sql/expressions/expression.ts"],"sourcesContent":["import { BaseExpr, type ExprContext, type SqlFragment, joinFragments } from \"src/queries/sql/Expr.ts\";\nimport { arrayAggToSql } from \"src/queries/sql/expressions/arrayAgg.ts\";\nimport { caseNullable, caseToSql } from \"src/queries/sql/expressions/case.ts\";\nimport { coalesceNullable, coalesceToSql } from \"src/queries/sql/expressions/coalesce.ts\";\nimport { chooseExpressionCodec } from \"src/queries/sql/expressions/codecs.ts\";\nimport { greatestNullable, greatestToSql } from \"src/queries/sql/expressions/greatest.ts\";\nimport { leastNullable, leastToSql } from \"src/queries/sql/expressions/least.ts\";\nimport { nullIfNullable, nullIfToSql } from \"src/queries/sql/expressions/nullIf.ts\";\nimport { parseExpressionInput } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type {\n  CheckInput,\n  ExprFromInput,\n  ExprInput,\n  ParsedExpression,\n  ResultCodec,\n} from \"src/queries/sql/expressions/types.ts\";\nimport type { TypeInfo } from \"src/serde/TypeInfo.ts\";\nimport { assertNever } from \"src/utils.ts\";\n\nexport type { CaseElse, CaseWhen } from \"src/queries/sql/expressions/case.ts\";\nexport type {\n  CheckInput,\n  ExprFromInput,\n  ExprInput,\n  ExpressionSources,\n  ExpressionValue,\n} from \"src/queries/sql/expressions/types.ts\";\n\n/** Builds a reusable SQL value expression, binding literal values as parameters. */\nexport function expr<const I extends ExprInput>(input: I & CheckInput<NoInfer<I>>): ExprFromInput<I> {\n  return buildExpr(input) as unknown as ExprFromInput<I>;\n}\n\n/** Parses explicit and inline inputs into a ParsedExpression, then wraps it in an Expr with a result codec. */\nexport function buildExpr(input: unknown): BaseExpr {\n  return new ObjectExpr(parseExpressionInput(input));\n}\n\n/** Exposes a ParsedExpression through the Expr methods, SQL rendering, and shared result codec. */\nclass ObjectExpr extends BaseExpr {\n  private readonly codec: ResultCodec;\n\n  constructor(private readonly parsed: ParsedExpression) {\n    super();\n    this.codec = chooseExpressionCodec(parsed);\n  }\n\n  get outputType(): TypeInfo | undefined {\n    return this.codec.outputType;\n  }\n\n  get sqlNullable(): boolean | undefined {\n    return expressionNullable(this.parsed);\n  }\n\n  toSql(ctx: ExprContext): SqlFragment {\n    return expressionToSql(this.parsed, ctx, this.codec);\n  }\n\n  decode(value: unknown): unknown {\n    return value == null ? value : this.codec.decode(value);\n  }\n\n  encode(value: unknown): unknown {\n    return value == null ? value : this.codec.encode(value);\n  }\n}\n\n/**\n * Reports nullability from the fields of each parsed expression kind.\n * A direct column can become null through a LEFT join, so only independent values prove NOT NULL here.\n */\nexport function expressionNullable(parsed: ParsedExpression): boolean | undefined {\n  if (parsed instanceof BaseExpr) return parsed.sqlSource ? undefined : parsed.sqlNullable;\n  switch (parsed.kind) {\n    case \"literal\":\n      return parsed.value === null;\n    case \"arrayAgg\":\n      return true;\n    case \"nullIf\":\n      return nullIfNullable();\n    case \"coalesce\":\n      return coalesceNullable(parsed);\n    case \"greatest\":\n      return greatestNullable(parsed);\n    case \"least\":\n      return leastNullable(parsed);\n    case \"case\":\n      return caseNullable(parsed);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/**\n * Renders a ParsedExpression in SQL binding order, resolving CASE conditions and collecting references for join pruning.\n * An omitted CASE condition removes its value as well. I.e. an unused Book.title branch must not keep the Book join.\n */\nexport function expressionToSql(parsed: ParsedExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  if (parsed instanceof BaseExpr) return parsed.toSql(ctx);\n  switch (parsed.kind) {\n    case \"literal\": {\n      const dbType = codec.outputType?.dbType;\n      return {\n        sql: dbType ? `?::${dbType}` : \"?\",\n        bindings: [parsed.value === null ? null : codec.encode(parsed.value)],\n        refs: [],\n      };\n    }\n    case \"arrayAgg\":\n      return arrayAggToSql(parsed, ctx, chooseExpressionCodec(parsed.value));\n    case \"coalesce\":\n      return coalesceToSql(parsed, ctx, codec);\n    case \"nullIf\":\n      return nullIfToSql(parsed, ctx, codec);\n    case \"greatest\":\n      return greatestToSql(parsed, ctx, codec);\n    case \"least\":\n      return leastToSql(parsed, ctx, codec);\n    case \"case\":\n      return caseToSql(parsed, ctx, codec);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** Renders a function call after its parsed kind has supplied the arguments in SQL order. */\nexport function functionToSql(\n  name: string,\n  args: readonly ParsedExpression[],\n  ctx: ExprContext,\n  codec: ResultCodec,\n): SqlFragment {\n  const parts = joinFragments(\n    args.map((arg) => expressionToSql(arg, ctx, codec)),\n    \", \",\n  );\n  return { ...parts, sql: `${name}(${parts.sql})` };\n}\n"],"mappings":";;;;;;;;;;;;AA6BA,SAAgB,KAAgC,OAAqD;CACnG,OAAO,UAAU,KAAK;AACxB;;AAGA,SAAgB,UAAU,OAA0B;CAClD,OAAO,IAAI,WAAW,qBAAqB,KAAK,CAAC;AACnD;;AAGA,IAAM,aAAN,cAAyB,SAAS;CAGH;CAF7B;CAEA,YAAY,QAA2C;EACrD,MAAM;EADqB,KAAA,SAAA;EAE3B,KAAK,QAAQ,sBAAsB,MAAM;CAC3C;CAEA,IAAI,aAAmC;EACrC,OAAO,KAAK,MAAM;CACpB;CAEA,IAAI,cAAmC;EACrC,OAAO,mBAAmB,KAAK,MAAM;CACvC;CAEA,MAAM,KAA+B;EACnC,OAAO,gBAAgB,KAAK,QAAQ,KAAK,KAAK,KAAK;CACrD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;AACF;;;;;AAMA,SAAgB,mBAAmB,QAA+C;CAChF,IAAI,kBAAkB,UAAU,OAAO,OAAO,YAAY,KAAA,IAAY,OAAO;CAC7E,QAAQ,OAAO,MAAf;EACE,KAAK,WACH,OAAO,OAAO,UAAU;EAC1B,KAAK,YACH,OAAO;EACT,KAAK,UACH,OAAO,eAAe;EACxB,KAAK,YACH,OAAO,iBAAiB,MAAM;EAChC,KAAK,YACH,OAAO,iBAAiB,MAAM;EAChC,KAAK,SACH,OAAO,cAAc,MAAM;EAC7B,KAAK,QACH,OAAO,aAAa,MAAM;EAC5B,SACE,OAAO,YAAY,MAAM;CAC7B;AACF;;;;;AAMA,SAAgB,gBAAgB,QAA0B,KAAkB,OAAiC;CAC3G,IAAI,kBAAkB,UAAU,OAAO,OAAO,MAAM,GAAG;CACvD,QAAQ,OAAO,MAAf;EACE,KAAK,WAAW;GACd,MAAM,SAAS,MAAM,YAAY;GACjC,OAAO;IACL,KAAK,SAAS,MAAM,WAAW;IAC/B,UAAU,CAAC,OAAO,UAAU,OAAO,OAAO,MAAM,OAAO,OAAO,KAAK,CAAC;IACpE,MAAM,CAAC;GACT;EACF;EACA,KAAK,YACH,OAAO,cAAc,QAAQ,KAAK,sBAAsB,OAAO,KAAK,CAAC;EACvE,KAAK,YACH,OAAO,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,UACH,OAAO,YAAY,QAAQ,KAAK,KAAK;EACvC,KAAK,YACH,OAAO,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,SACH,OAAO,WAAW,QAAQ,KAAK,KAAK;EACtC,KAAK,QACH,OAAO,UAAU,QAAQ,KAAK,KAAK;EACrC,SACE,OAAO,YAAY,MAAM;CAC7B;AACF;;AAGA,SAAgB,cACd,MACA,MACA,KACA,OACa;CACb,MAAM,QAAQ,cACZ,KAAK,KAAK,QAAQ,gBAAgB,KAAK,KAAK,KAAK,CAAC,GAClD,IACF;CACA,OAAO;EAAE,GAAG;EAAO,KAAK,GAAG,KAAK,GAAG,MAAM,IAAI;CAAG;AAClD"}

package/build/queries/sql/expressions/greatest.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"greatest.cjs","names":["parseNonEmptyOperands","functionToSql","expressionNullable"],"sources":["../../../../src/queries/sql/expressions/greatest.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"../Expr.ts\";\nimport { expressionNullable, functionToSql } from \"./expression.ts\";\nimport { parseNonEmptyOperands } from \"./parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"./types.ts\";\n\n/** Values whose largest non-null member is selected by PostgreSQL. */\nexport interface GreatestInput {\n  readonly greatest: readonly unknown[];\n}\n\n/** A GREATEST comparison with at least one value. */\nexport interface ParsedGreatestExpression {\n  kind: \"greatest\";\n  values: [ParsedExpression, ...ParsedExpression[]];\n}\n\n/** Parses GREATEST values and requires at least one operand. */\nexport function parseGreatestExpression(input: unknown): ParsedGreatestExpression {\n  return { kind: \"greatest\", values: parseNonEmptyOperands(input, \"GREATEST\") };\n}\n\n/** Renders the values compared by GREATEST. */\nexport function greatestToSql(parsed: ParsedGreatestExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  return functionToSql(\"GREATEST\", parsed.values, ctx, codec);\n}\n\n/** GREATEST ignores nulls, so one non-null value guarantees a non-null result. */\nexport function greatestNullable(parsed: ParsedGreatestExpression): boolean | undefined {\n  return parsed.values.some((value) => expressionNullable(value) === false) ? false : undefined;\n}\n"],"mappings":";;;;;AAiBA,SAAgB,wBAAwB,OAA0C;CAChF,OAAO;EAAE,MAAM;EAAY,QAAQA,gDAAAA,sBAAsB,OAAO,UAAU;CAAE;AAC9E;;AAGA,SAAgB,cAAc,QAAkC,KAAkB,OAAiC;CACjH,OAAOC,2CAAAA,cAAc,YAAY,OAAO,QAAQ,KAAK,KAAK;AAC5D;;AAGA,SAAgB,iBAAiB,QAAuD;CACtF,OAAO,OAAO,OAAO,MAAM,UAAUC,2CAAAA,mBAAmB,KAAK,MAAM,KAAK,IAAI,QAAQ,KAAA;AACtF"}
+{"version":3,"file":"greatest.cjs","names":["parseNonEmptyOperands","functionToSql","expressionNullable"],"sources":["../../../../src/queries/sql/expressions/greatest.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"src/queries/sql/Expr.ts\";\nimport { expressionNullable, functionToSql } from \"src/queries/sql/expressions/expression.ts\";\nimport { parseNonEmptyOperands } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\n\n/** Values whose largest non-null member is selected by PostgreSQL. */\nexport interface GreatestInput {\n  readonly greatest: readonly unknown[];\n}\n\n/** A GREATEST comparison with at least one value. */\nexport interface ParsedGreatestExpression {\n  kind: \"greatest\";\n  values: [ParsedExpression, ...ParsedExpression[]];\n}\n\n/** Parses GREATEST values and requires at least one operand. */\nexport function parseGreatestExpression(input: unknown): ParsedGreatestExpression {\n  return { kind: \"greatest\", values: parseNonEmptyOperands(input, \"GREATEST\") };\n}\n\n/** Renders the values compared by GREATEST. */\nexport function greatestToSql(parsed: ParsedGreatestExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  return functionToSql(\"GREATEST\", parsed.values, ctx, codec);\n}\n\n/** GREATEST ignores nulls, so one non-null value guarantees a non-null result. */\nexport function greatestNullable(parsed: ParsedGreatestExpression): boolean | undefined {\n  return parsed.values.some((value) => expressionNullable(value) === false) ? false : undefined;\n}\n"],"mappings":";;;;;AAiBA,SAAgB,wBAAwB,OAA0C;CAChF,OAAO;EAAE,MAAM;EAAY,QAAQA,gDAAAA,sBAAsB,OAAO,UAAU;CAAE;AAC9E;;AAGA,SAAgB,cAAc,QAAkC,KAAkB,OAAiC;CACjH,OAAOC,2CAAAA,cAAc,YAAY,OAAO,QAAQ,KAAK,KAAK;AAC5D;;AAGA,SAAgB,iBAAiB,QAAuD;CACtF,OAAO,OAAO,OAAO,MAAM,UAAUC,2CAAAA,mBAAmB,KAAK,MAAM,KAAK,IAAI,QAAQ,KAAA;AACtF"}

package/build/queries/sql/expressions/greatest.js.map

@@ -1 +1 @@
-{"version":3,"file":"greatest.js","names":[],"sources":["../../../../src/queries/sql/expressions/greatest.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"../Expr.ts\";\nimport { expressionNullable, functionToSql } from \"./expression.ts\";\nimport { parseNonEmptyOperands } from \"./parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"./types.ts\";\n\n/** Values whose largest non-null member is selected by PostgreSQL. */\nexport interface GreatestInput {\n  readonly greatest: readonly unknown[];\n}\n\n/** A GREATEST comparison with at least one value. */\nexport interface ParsedGreatestExpression {\n  kind: \"greatest\";\n  values: [ParsedExpression, ...ParsedExpression[]];\n}\n\n/** Parses GREATEST values and requires at least one operand. */\nexport function parseGreatestExpression(input: unknown): ParsedGreatestExpression {\n  return { kind: \"greatest\", values: parseNonEmptyOperands(input, \"GREATEST\") };\n}\n\n/** Renders the values compared by GREATEST. */\nexport function greatestToSql(parsed: ParsedGreatestExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  return functionToSql(\"GREATEST\", parsed.values, ctx, codec);\n}\n\n/** GREATEST ignores nulls, so one non-null value guarantees a non-null result. */\nexport function greatestNullable(parsed: ParsedGreatestExpression): boolean | undefined {\n  return parsed.values.some((value) => expressionNullable(value) === false) ? false : undefined;\n}\n"],"mappings":";;;;AAiBA,SAAgB,wBAAwB,OAA0C;CAChF,OAAO;EAAE,MAAM;EAAY,QAAQ,sBAAsB,OAAO,UAAU;CAAE;AAC9E;;AAGA,SAAgB,cAAc,QAAkC,KAAkB,OAAiC;CACjH,OAAO,cAAc,YAAY,OAAO,QAAQ,KAAK,KAAK;AAC5D;;AAGA,SAAgB,iBAAiB,QAAuD;CACtF,OAAO,OAAO,OAAO,MAAM,UAAU,mBAAmB,KAAK,MAAM,KAAK,IAAI,QAAQ,KAAA;AACtF"}
+{"version":3,"file":"greatest.js","names":[],"sources":["../../../../src/queries/sql/expressions/greatest.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"src/queries/sql/Expr.ts\";\nimport { expressionNullable, functionToSql } from \"src/queries/sql/expressions/expression.ts\";\nimport { parseNonEmptyOperands } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\n\n/** Values whose largest non-null member is selected by PostgreSQL. */\nexport interface GreatestInput {\n  readonly greatest: readonly unknown[];\n}\n\n/** A GREATEST comparison with at least one value. */\nexport interface ParsedGreatestExpression {\n  kind: \"greatest\";\n  values: [ParsedExpression, ...ParsedExpression[]];\n}\n\n/** Parses GREATEST values and requires at least one operand. */\nexport function parseGreatestExpression(input: unknown): ParsedGreatestExpression {\n  return { kind: \"greatest\", values: parseNonEmptyOperands(input, \"GREATEST\") };\n}\n\n/** Renders the values compared by GREATEST. */\nexport function greatestToSql(parsed: ParsedGreatestExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  return functionToSql(\"GREATEST\", parsed.values, ctx, codec);\n}\n\n/** GREATEST ignores nulls, so one non-null value guarantees a non-null result. */\nexport function greatestNullable(parsed: ParsedGreatestExpression): boolean | undefined {\n  return parsed.values.some((value) => expressionNullable(value) === false) ? false : undefined;\n}\n"],"mappings":";;;;AAiBA,SAAgB,wBAAwB,OAA0C;CAChF,OAAO;EAAE,MAAM;EAAY,QAAQ,sBAAsB,OAAO,UAAU;CAAE;AAC9E;;AAGA,SAAgB,cAAc,QAAkC,KAAkB,OAAiC;CACjH,OAAO,cAAc,YAAY,OAAO,QAAQ,KAAK,KAAK;AAC5D;;AAGA,SAAgB,iBAAiB,QAAuD;CACtF,OAAO,OAAO,OAAO,MAAM,UAAU,mBAAmB,KAAK,MAAM,KAAK,IAAI,QAAQ,KAAA;AACtF"}