effect-qb 0.17.0 → 0.20.0

package/src/internal/dsl-transaction-ddl-runtime.ts

@@ -1,5 +1,4 @@
 import * as Plan from "./row-set.js"
-import * as Table from "./table.js"
 
 type DslTransactionDdlRuntimeContext = {
   readonly profile: {
@@ -11,16 +10,13 @@ type DslTransactionDdlRuntimeContext = {
   readonly defaultIndexName: (tableName: string, columns: readonly string[], unique: boolean) => string
 }
 
-const allowedIsolationLevels = new Set(["read committed", "repeatable read", "serializable"])
-
-export const renderTransactionIsolationLevel = (isolationLevel: unknown): string => {
+export const renderTransactionIsolationLevel = (
+  isolationLevel: unknown
+): string => {
   if (isolationLevel === undefined) {
     return ""
   }
-  if (typeof isolationLevel !== "string" || !allowedIsolationLevels.has(isolationLevel)) {
-    throw new Error("Unsupported transaction isolation level")
-  }
-  return `isolation level ${isolationLevel}`
+  return `isolation level ${isolationLevel as string}`
 }
 
 export const expectDdlClauseKind = <
@@ -28,53 +24,29 @@ export const expectDdlClauseKind = <
   Kind extends Ddl["kind"]
 >(
   ddl: Ddl | undefined,
-  kind: Kind
-): Extract<Ddl, { readonly kind: Kind }> => {
-  if (ddl === undefined || ddl.kind !== kind) {
-    throw new Error("Unsupported DDL statement kind")
-  }
-  return ddl as Extract<Ddl, { readonly kind: Kind }>
-}
+  _kind: Kind
+): Extract<Ddl, { readonly kind: Kind }> =>
+  ddl as Extract<Ddl, { readonly kind: Kind }>
 
 export const expectTruncateClause = <
   Truncate extends { readonly kind: string }
 >(
   truncate: Truncate | undefined
-): Extract<Truncate, { readonly kind: "truncate" }> => {
-  if (truncate === undefined || truncate.kind !== "truncate") {
-    throw new Error("Unsupported truncate statement kind")
-  }
-  return truncate as Extract<Truncate, { readonly kind: "truncate" }>
-}
+): Extract<Truncate, { readonly kind: "truncate" }> =>
+  truncate as Extract<Truncate, { readonly kind: "truncate" }>
 
-const validateIsolationLevel = (isolationLevel: unknown): void => {
-  renderTransactionIsolationLevel(isolationLevel)
-}
-
-export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContext) => {
-  const isRecord = (value: unknown): value is Record<PropertyKey, unknown> =>
-    typeof value === "object" && value !== null
-
-  const assertTableTarget = (target: unknown, apiName: string): void => {
-    if (!isRecord(target) || !(Table.TypeId in target) || !(Plan.TypeId in target)) {
-      throw new Error(`${apiName}(...) requires a table target`)
-    }
-  }
+export const normalizeStatementFlag = (value: unknown): boolean =>
+  (value as boolean | undefined) ?? false
 
-  const validateIndexColumns = (target: any, columns: readonly string[]): void => {
-    const fields = target[Table.TypeId]?.fields as Record<string, unknown> | undefined
-    if (fields === undefined) {
-      return
-    }
-    for (const columnName of columns) {
-      if (!(columnName in fields)) {
-        throw new Error(`effect-qb: unknown index column '${columnName}'`)
-      }
-    }
-  }
+export const normalizeStatementIdentifier = (
+  _apiName: string,
+  _identifierName: string,
+  value: unknown
+): string =>
+  value as string
 
+export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContext) => {
   const transaction = (options: { readonly isolationLevel?: any; readonly readOnly?: boolean } = {}) => {
-    validateIsolationLevel(options.isolationLevel)
     return ctx.makePlan({
       selection: {},
       required: [],
@@ -134,8 +106,8 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       orderBy: []
     }, undefined, "transaction", "rollback")
 
-  const savepoint = (name: string) =>
-    ctx.makePlan({
+  const savepoint = (name: string) => {
+    return ctx.makePlan({
       selection: {},
       required: [],
       available: {},
@@ -153,9 +125,10 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       groupBy: [],
       orderBy: []
     }, undefined, "transaction", "savepoint")
+  }
 
-  const rollbackTo = (name: string) =>
-    ctx.makePlan({
+  const rollbackTo = (name: string) => {
+    return ctx.makePlan({
       selection: {},
       required: [],
       available: {},
@@ -173,9 +146,10 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       groupBy: [],
       orderBy: []
     }, undefined, "transaction", "rollbackTo")
+  }
 
-  const releaseSavepoint = (name: string) =>
-    ctx.makePlan({
+  const releaseSavepoint = (name: string) => {
+    return ctx.makePlan({
       selection: {},
       required: [],
       available: {},
@@ -193,9 +167,10 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       groupBy: [],
       orderBy: []
     }, undefined, "transaction", "releaseSavepoint")
+  }
 
   const createTable = (target: any, options: { readonly ifNotExists?: boolean } = {}) => {
-    assertTableTarget(target, "createTable")
+    const ifNotExists = normalizeStatementFlag(options.ifNotExists)
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     return ctx.makePlan({
       selection: {},
@@ -213,7 +188,7 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       },
       ddl: {
         kind: "createTable",
-        ifNotExists: options.ifNotExists ?? false
+        ifNotExists
       },
       where: [],
       having: [],
@@ -224,7 +199,7 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
   }
 
   const dropTable = (target: any, options: { readonly ifExists?: boolean } = {}) => {
-    assertTableTarget(target, "dropTable")
+    const ifExists = normalizeStatementFlag(options.ifExists)
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     return ctx.makePlan({
       selection: {},
@@ -242,7 +217,7 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       },
       ddl: {
         kind: "dropTable",
-        ifExists: options.ifExists ?? false
+        ifExists
       },
       where: [],
       having: [],
@@ -253,9 +228,10 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
   }
 
   const createIndex = (target: any, columns: string | readonly string[], options: { readonly name?: string; readonly unique?: boolean; readonly ifNotExists?: boolean } = {}) => {
-    assertTableTarget(target, "createIndex")
     const normalizedColumns = ctx.normalizeColumnList(columns)
-    validateIndexColumns(target, normalizedColumns)
+    const unique = normalizeStatementFlag(options.unique)
+    const ifNotExists = normalizeStatementFlag(options.ifNotExists)
+    const name = options.name
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     return ctx.makePlan({
       selection: {},
@@ -273,10 +249,10 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       },
       ddl: {
         kind: "createIndex",
-        name: options.name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, options.unique ?? false),
+        name: name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, unique),
         columns: normalizedColumns,
-        unique: options.unique ?? false,
-        ifNotExists: options.ifNotExists ?? false
+        unique,
+        ifNotExists
       },
       where: [],
       having: [],
@@ -287,9 +263,9 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
   }
 
   const dropIndex = (target: any, columns: string | readonly string[], options: { readonly name?: string; readonly ifExists?: boolean } = {}) => {
-    assertTableTarget(target, "dropIndex")
     const normalizedColumns = ctx.normalizeColumnList(columns)
-    validateIndexColumns(target, normalizedColumns)
+    const ifExists = normalizeStatementFlag(options.ifExists)
+    const name = options.name
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     return ctx.makePlan({
       selection: {},
@@ -307,8 +283,8 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       },
       ddl: {
         kind: "dropIndex",
-        name: options.name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, false),
-        ifExists: options.ifExists ?? false
+        name: name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, false),
+        ifExists
       },
       where: [],
       having: [],

package/src/internal/executor.ts

@@ -1,9 +1,10 @@
 import * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
 import * as Option from "effect/Option"
 import * as Schema from "effect/Schema"
-import * as SqlClient from "@effect/sql/SqlClient"
-import * as SqlError from "@effect/sql/SqlError"
+import * as SqlClient from "effect/unstable/sql/SqlClient"
+import * as SqlError from "effect/unstable/sql/SqlError"
 import * as Stream from "effect/Stream"
 
 import * as Expression from "./scalar.js"
@@ -44,6 +45,10 @@ export interface RowDecodeError {
   readonly normalized?: unknown
   readonly stage: "normalize" | "schema"
   readonly cause: unknown
+  readonly schemaError?: {
+    readonly message: string
+    readonly issue: unknown
+  }
 }
 
 /**
@@ -183,26 +188,35 @@ const makeRowDecodeError = (
   stage: RowDecodeError["stage"],
   cause: unknown,
   normalized?: unknown
-): RowDecodeError => ({
-  _tag: "RowDecodeError",
-  message: stage === "normalize"
-    ? `Failed to normalize projection '${projection.alias}'`
-    : `Failed to decode projection '${projection.alias}' against its runtime schema`,
-  dialect: rendered.dialect,
-  query: {
-    sql: rendered.sql,
-    params: rendered.params
-  },
-  projection: {
-    alias: projection.alias,
-    path: projection.path
-  },
-  dbType: expression[Expression.TypeId].dbType,
-  raw,
-  normalized,
-  stage,
-  cause
-})
+): RowDecodeError => {
+  const schemaError = Schema.isSchemaError(cause)
+    ? {
+        message: cause.message,
+        issue: cause.issue
+      }
+    : undefined
+  return {
+    _tag: "RowDecodeError",
+    message: stage === "normalize"
+      ? `Failed to normalize projection '${projection.alias}'`
+      : `Failed to decode projection '${projection.alias}' against its runtime schema`,
+    dialect: rendered.dialect,
+    query: {
+      sql: rendered.sql,
+      params: rendered.params
+    },
+    projection: {
+      alias: projection.alias,
+      path: projection.path
+    },
+    dbType: expression[Expression.TypeId].dbType,
+    raw,
+    normalized,
+    stage,
+    cause,
+    ...(schemaError === undefined ? {} : { schemaError })
+  }
+}
 
 const hasOptionalSourceDependency = (
   expression: Expression.Any,
@@ -249,7 +263,7 @@ const dbTypeAllowsTopLevelJsonNull = (
 }
 
 const schemaAcceptsNull = (
-  schema: Schema.Schema.Any | undefined
+  schema: Schema.Top | undefined
 ): boolean =>
   schema !== undefined && (Schema.is(schema) as (value: unknown) => boolean)(null)
 
@@ -325,15 +339,20 @@ const decodeProjectionValue = (
     return normalized
   }
 
-  if ((Schema.is(schema as Schema.Schema.Any) as (value: unknown) => boolean)(normalized)) {
+  if ((Schema.is(schema as Schema.Top) as (value: unknown) => boolean)(normalized)) {
     return normalized
   }
 
-  try {
-    return (Schema.decodeUnknownSync as any)(schema)(normalized)
-  } catch (cause) {
-    throw makeRowDecodeError(rendered, projection, expression, raw, "schema", cause, normalized)
+  const decoded = (Schema.decodeUnknownExit as any)(schema)(normalized)
+  if (Exit.isSuccess(decoded)) {
+    return decoded.value
   }
+
+  const cause = Option.match(Exit.findErrorOption(decoded), {
+    onNone: () => decoded.cause,
+    onSome: (schemaError) => schemaError
+  })
+  throw makeRowDecodeError(rendered, projection, expression, raw, "schema", cause, normalized)
 }
 
 export const makeRowDecoder = (
@@ -390,7 +409,7 @@ export const decodeChunk = (
   } = {}
 ): Chunk.Chunk<any> => {
   const decodeRow = makeRowDecoder(rendered, plan, options)
-  return Chunk.unsafeFromArray(Chunk.toReadonlyArray(rows).map((row) => decodeRow(row)))
+  return Chunk.fromIterable(Chunk.toReadonlyArray(rows).map((row) => decodeRow(row)))
 }
 
 export const decodeRows = (
@@ -509,33 +528,37 @@ export const fromDriver = <
   renderer: Renderer.Renderer<Dialect>,
   sqlDriver: Driver<Dialect, Error, Context>
 ): Executor<Dialect, Error, Context> => {
-  const executor = {
+  const executor: Executor<Dialect, Error, Context> = {
     dialect: renderer.dialect,
-    execute(plan: any) {
+    execute<PlanValue extends Query.Plan.Any>(
+      plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
+    ) {
       const rendered = renderer.render(plan) as Renderer.RenderedQuery<any, Dialect>
       return Effect.map(
         sqlDriver.execute(rendered),
         (rows) => remapRows<any>(rendered, rows)
-      )
+      ) as Effect.Effect<Query.ResultRows<PlanValue>, Error, Context>
     },
-    stream(plan: any) {
+    stream<PlanValue extends Query.Plan.Any>(
+      plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
+    ) {
       const rendered = renderer.render(plan) as Renderer.RenderedQuery<any, Dialect>
-      return Stream.mapChunks(
+      return Stream.mapArray(
         sqlDriver.stream(rendered),
-        (rows) => Chunk.unsafeFromArray(remapRows<any>(rendered, Chunk.toReadonlyArray(rows)))
-      )
+        (rows) => remapRows<any>(rendered, rows) as never
+      ) as Stream.Stream<Query.ResultRow<PlanValue>, Error, Context>
     }
   }
-  return executor as unknown as Executor<Dialect, Error, Context>
+  return executor
 }
 
 export const streamFromSqlClient = <Dialect extends string>(
   query: Renderer.RenderedQuery<any, Dialect>
 ): Stream.Stream<FlatRow, SqlError.SqlError, SqlClient.SqlClient> =>
-  Stream.unwrapScoped(
+  Stream.unwrap(
     Effect.flatMap(SqlClient.SqlClient, (sql) =>
       Effect.flatMap(
-        Effect.serviceOption(SqlClient.TransactionConnection),
+        Effect.serviceOption(sql.transactionService),
         Option.match({
           onNone: () => sql.reserve,
           onSome: ([connection]) => Effect.succeed(connection)
@@ -556,19 +579,13 @@ export const fromSqlClient = <Dialect extends string>(
     stream: (query) => streamFromSqlClient(query)
   }))
 
-/** Runs an effect within the ambient `@effect/sql` transaction service. */
-export const withTransaction = <A, E, R>(
-  effect: Effect.Effect<A, E, R>
-): Effect.Effect<A, E | SqlError.SqlError, R | SqlClient.SqlClient> =>
-  Effect.flatMap(SqlClient.SqlClient, (sql) => sql.withTransaction(effect))
-
 /**
- * Runs an effect in a nested transaction scope.
+ * Runs an effect within the ambient `effect/unstable/sql` transaction service.
  *
- * When the ambient `@effect/sql` client is already inside a transaction, the
- * underlying client implementation uses a savepoint.
+ * Nested calls rely on the underlying client transaction implementation for
+ * savepoint behavior.
  */
-export const withSavepoint = <A, E, R>(
+export const withTransaction = <A, E, R>(
   effect: Effect.Effect<A, E, R>
 ): Effect.Effect<A, E | SqlError.SqlError, R | SqlClient.SqlClient> =>
   Effect.flatMap(SqlClient.SqlClient, (sql) => sql.withTransaction(effect))

package/src/internal/grouping-key.ts

@@ -21,7 +21,9 @@ const subqueryPlanGroupingKey = (plan: unknown): string => {
 
 const literalGroupingKey = (value: unknown): string => {
   if (value instanceof Date) {
-    return `date:${value.toISOString()}`
+    return Number.isNaN(value.getTime())
+      ? "date:invalid"
+      : `date:${value.toISOString()}`
   }
   if (value === null) {
     return "null"
@@ -44,6 +46,30 @@ const isExpression = (value: unknown): value is Expression.Any =>
 const expressionGroupingKey = (value: unknown): string =>
   isExpression(value) ? groupingKeyOfExpression(value) : "missing"
 
+const requiredExpressionGroupingKey = (
+  _functionName: string,
+  value: unknown
+): string => groupingKeyOfExpression(value as Expression.Any)
+
+const requiredBinaryExpressionGroupingKey = (
+  _functionName: string,
+  left: unknown,
+  right: unknown
+): string => `${groupingKeyOfExpression(left as Expression.Any)},${groupingKeyOfExpression(right as Expression.Any)}`
+
+const functionCallArgsGroupingKey = (args: unknown): string =>
+  (args as readonly Expression.Any[]).map(groupingKeyOfExpression).join(",")
+
+const variadicGroupingKey = (
+  _functionName: string,
+  values: unknown
+): string => (values as readonly Expression.Any[]).map(groupingKeyOfExpression).join(",")
+
+const castTargetGroupingKey = (target: unknown): string => {
+  const typed = target as { readonly dialect?: string; readonly kind?: string } | null | undefined
+  return `${typed?.dialect}:${typed?.kind}`
+}
+
 const escapeGroupingText = (value: string): string =>
   value
     .replace(/\\/g, "\\\\")
@@ -52,6 +78,30 @@ const escapeGroupingText = (value: string): string =>
     .replace(/=/g, "\\=")
     .replace(/>/g, "\\>")
 
+const functionCallNameGroupingKey = (name: unknown): string =>
+  escapeGroupingText(name as string)
+
+const quantifiedComparisonGroupingName = (
+  kind: "comparisonAny" | "comparisonAll"
+): "compareAny" | "compareAll" =>
+  kind === "comparisonAny" ? "compareAny" : "compareAll"
+
+const caseGroupingKey = (
+  branches: unknown,
+  fallback: unknown
+): string => {
+  const typedBranches = branches as readonly ExpressionAst.CaseBranchNode[]
+  return `case(${typedBranches.map((branch) =>
+    `when:${groupingKeyOfExpression(branch.when)}=>${groupingKeyOfExpression(branch.then)}`).join("|")};else:${groupingKeyOfExpression(fallback as Expression.Any)})`
+}
+
+const collationGroupingKey = (collation: unknown): string => {
+  if (Array.isArray(collation)) {
+    return collation.map((part) => escapeGroupingText(String(part))).join(",")
+  }
+  return escapeGroupingText(String(collation))
+}
+
 const jsonSegmentGroupingKey = (segment: unknown): string => {
   if (segment !== null && typeof segment === "object" && "kind" in segment) {
     switch ((segment as { readonly kind: string }).kind) {
@@ -78,8 +128,15 @@ const jsonSegmentGroupingKey = (segment: unknown): string => {
   return "unknown"
 }
 
-const jsonPathGroupingKey = (segments: readonly unknown[] | undefined): string =>
-  (segments ?? []).map(jsonSegmentGroupingKey).join(",")
+const jsonPathGroupingKey = (segments: unknown): string => {
+  if (segments === undefined) {
+    return ""
+  }
+  if (!Array.isArray(segments)) {
+    return "unknown"
+  }
+  return segments.map(jsonSegmentGroupingKey).join(",")
+}
 
 const isJsonPath = (value: unknown): value is JsonPath.Path =>
   value !== null && typeof value === "object" && JsonPath.TypeId in value
@@ -97,9 +154,20 @@ const jsonOpaquePathGroupingKey = (value: unknown): string => {
   return "jsonpath:unknown"
 }
 
-const jsonEntryGroupingKey = (
-  entry: { readonly key: string; readonly value: Expression.Any }
-): string => `${escapeGroupingText(entry.key)}=>${groupingKeyOfExpression(entry.value)}`
+const jsonKeysGroupingKey = (keys: unknown): string => {
+  if (!Array.isArray(keys) || keys.length === 0) {
+    return ""
+  }
+  return keys.map((key) => escapeGroupingText(String(key))).join(",")
+}
+
+const jsonBuildObjectGroupingKey = (entries: unknown): string => {
+  return (entries as readonly { readonly key: string; readonly value: Expression.Any }[]).map((entry) =>
+    `${escapeGroupingText(entry.key)}=>${groupingKeyOfExpression(entry.value)}`).join("|")
+}
+
+const jsonBuildArrayGroupingKey = (values: unknown): string =>
+  (values as readonly Expression.Any[]).map(groupingKeyOfExpression).join(",")
 
 export const groupingKeyOfExpression = (expression: Expression.Any): string => {
   const ast = (expression as Expression.Any & {
@@ -111,11 +179,11 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "literal":
       return `literal:${literalGroupingKey(ast.value)}`
     case "cast":
-      return `cast(${groupingKeyOfExpression(ast.value)} as ${ast.target.dialect}:${ast.target.kind})`
+      return `cast(${requiredExpressionGroupingKey("cast", ast.value)} as ${castTargetGroupingKey(ast.target)})`
     case "collate":
-      return `collate(${groupingKeyOfExpression(ast.value)},${ast.collation.map(escapeGroupingText).join(",")})`
+      return `collate(${requiredExpressionGroupingKey("collate", ast.value)},${collationGroupingKey(ast.collation)})`
     case "function":
-      return `function(${escapeGroupingText(ast.name)},${ast.args.map(groupingKeyOfExpression).join(",")})`
+      return `function(${functionCallNameGroupingKey(ast.name)},${functionCallArgsGroupingKey(ast.args)})`
     case "isNull":
     case "isNotNull":
     case "not":
@@ -124,7 +192,7 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "count":
     case "max":
     case "min":
-      return `${ast.kind}(${groupingKeyOfExpression(ast.value)})`
+      return `${ast.kind}(${requiredExpressionGroupingKey(ast.kind, ast.value)})`
     case "eq":
     case "neq":
     case "lt":
@@ -142,7 +210,7 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "contains":
     case "containedBy":
     case "overlaps":
-      return `${ast.kind}(${groupingKeyOfExpression(ast.left)},${groupingKeyOfExpression(ast.right)})`
+      return `${ast.kind}(${requiredBinaryExpressionGroupingKey(ast.kind, ast.left, ast.right)})`
     case "and":
     case "or":
     case "coalesce":
@@ -150,19 +218,18 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "in":
     case "notIn":
     case "between":
-      return `${ast.kind}(${ast.values.map(groupingKeyOfExpression).join(",")})`
+      return `${ast.kind}(${variadicGroupingKey(ast.kind, ast.values)})`
     case "case":
-      return `case(${ast.branches.map((branch: ExpressionAst.CaseBranchNode) =>
-        `when:${groupingKeyOfExpression(branch.when)}=>${groupingKeyOfExpression(branch.then)}`).join("|")};else:${groupingKeyOfExpression(ast.else)})`
+      return caseGroupingKey(ast.branches, ast.else)
     case "exists":
       return `exists(${subqueryPlanGroupingKey(ast.plan)})`
     case "scalarSubquery":
       return `scalarSubquery(${subqueryPlanGroupingKey(ast.plan)})`
     case "inSubquery":
-      return `inSubquery(${groupingKeyOfExpression(ast.left)},${subqueryPlanGroupingKey(ast.plan)})`
+      return `inSubquery(${requiredExpressionGroupingKey("inSubquery", ast.left)},${subqueryPlanGroupingKey(ast.plan)})`
     case "comparisonAny":
     case "comparisonAll":
-      return `${ast.kind}(${ast.operator},${groupingKeyOfExpression(ast.left)},${subqueryPlanGroupingKey(ast.plan)})`
+      return `${ast.kind}(${ast.operator},${requiredExpressionGroupingKey(quantifiedComparisonGroupingName(ast.kind), ast.left)},${subqueryPlanGroupingKey(ast.plan)})`
     case "jsonGet":
     case "jsonPath":
     case "jsonAccess":
@@ -176,7 +243,7 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "jsonKeyExists":
     case "jsonHasAnyKeys":
     case "jsonHasAllKeys":
-      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${(ast.keys ?? []).map(escapeGroupingText).join(",")})`
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonKeysGroupingKey(ast.keys)})`
     case "jsonConcat":
     case "jsonMerge":
       return `json(${ast.kind},${expressionGroupingKey(ast.left)},${expressionGroupingKey(ast.right)},)`
@@ -192,9 +259,9 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "jsonPathMatch":
       return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonOpaquePathGroupingKey(ast.query)})`
     case "jsonBuildObject":
-      return `json(${ast.kind},${(ast.entries ?? []).map(jsonEntryGroupingKey).join("|")})`
+      return `json(${ast.kind},${jsonBuildObjectGroupingKey(ast.entries)})`
     case "jsonBuildArray":
-      return `json(${ast.kind},${(ast.values ?? []).map(groupingKeyOfExpression).join(",")})`
+      return `json(${ast.kind},${jsonBuildArrayGroupingKey(ast.values)})`
     case "jsonToJson":
     case "jsonToJsonb":
     case "jsonTypeOf":
@@ -203,7 +270,7 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "jsonStripNulls":
       return `json(${ast.kind},${expressionGroupingKey(ast.value)})`
     default:
-      throw new Error("Unsupported expression for grouping key generation")
+      return `unknown:${typeof ast === "object" && ast !== null && "kind" in ast ? String((ast as { readonly kind: unknown }).kind) : "ast"}`
   }
 }
 

package/src/internal/implication-runtime.ts

@@ -41,7 +41,7 @@ const collectPresenceWitnesses = (
     return
   }
   if (Expression.TypeId in selection && ExpressionAst.TypeId in selection) {
-    const expression = selection as unknown as AstBackedExpression
+    const expression = selection as AstBackedExpression
     const ast = expression[ExpressionAst.TypeId]
     if (ast.kind === "column" && expression[Expression.TypeId].nullability === "never") {
       output.add(columnPredicateKey(ast.tableName, ast.columnName))