effect-qb 0.16.0 → 0.19.0

package/src/internal/executor.ts

@@ -16,6 +16,8 @@ import * as Query from "./query.js"
 import * as QueryAst from "./query-ast.js"
 import * as Renderer from "./renderer.js"
 import * as Plan from "./row-set.js"
+import { columnPredicateKey } from "./predicate/runtime.js"
+import { isJsonValue } from "./runtime/normalize.js"
 
 /** Flat database row keyed by rendered projection aliases. */
 export type FlatRow = Readonly<Record<string, unknown>>
@@ -221,7 +223,7 @@ const effectiveRuntimeNullability = (
     return "always"
   }
   if (ast.kind === "column") {
-    const key = `${ast.tableName}.${ast.columnName}`
+    const key = columnPredicateKey(ast.tableName, ast.columnName)
     if (scope.absentSourceNames.has(ast.tableName) || scope.nullKeys.has(key)) {
       return "always"
     }
@@ -237,6 +239,20 @@ const effectiveRuntimeNullability = (
     : nullability
 }
 
+const dbTypeAllowsTopLevelJsonNull = (
+  dbType: Expression.DbType.Any
+): boolean => {
+  if ("base" in dbType) {
+    return dbTypeAllowsTopLevelJsonNull(dbType.base)
+  }
+  return ("variant" in dbType && dbType.variant === "json") || dbType.runtime === "json"
+}
+
+const schemaAcceptsNull = (
+  schema: Schema.Schema.Any | undefined
+): boolean =>
+  schema !== undefined && (Schema.is(schema) as (value: unknown) => boolean)(null)
+
 const decodeProjectionValue = (
   rendered: Renderer.RenderedQuery<any, any>,
   projection: Renderer.RenderedQuery<any, any>["projections"][number],
@@ -262,8 +278,12 @@ const decodeProjectionValue = (
   }
 
   const nullability = effectiveRuntimeNullability(expression, scope)
+  const schema = expressionRuntimeSchema(expression, { assumptions: scope.assumptions })
   if (normalized === null) {
     if (nullability === "never") {
+      if (dbTypeAllowsTopLevelJsonNull(expression[Expression.TypeId].dbType) && schemaAcceptsNull(schema)) {
+        return null
+      }
       throw makeRowDecodeError(
         rendered,
         projection,
@@ -289,7 +309,18 @@ const decodeProjectionValue = (
     )
   }
 
-  const schema = expressionRuntimeSchema(expression, { assumptions: scope.assumptions })
+  if (dbTypeAllowsTopLevelJsonNull(expression[Expression.TypeId].dbType) && !isJsonValue(normalized)) {
+    throw makeRowDecodeError(
+      rendered,
+      projection,
+      expression,
+      raw,
+      "schema",
+      new Error("Expected a JSON value"),
+      normalized
+    )
+  }
+
   if (schema === undefined) {
     return normalized
   }
@@ -316,8 +347,8 @@ export const makeRowDecoder = (
   const projections = flattenSelection(
     Query.getAst(plan).select as Record<string, unknown>
   )
-  const byAlias = new Map(
-    projections.map((projection) => [projection.alias, projection.expression] as const)
+  const byPath = new Map(
+    projections.map((projection) => [JSON.stringify(projection.path), projection.expression] as const)
   )
   const driverMode = options.driverMode ?? "raw"
   const valueMappings = options.valueMappings ?? rendered.valueMappings
@@ -325,12 +356,19 @@ export const makeRowDecoder = (
   return (row) => {
     const decoded: Record<string, unknown> = {}
     for (const projection of rendered.projections) {
-      if (!(projection.alias in row)) {
-        continue
-      }
-      const expression = byAlias.get(projection.alias)
+      const expression = byPath.get(JSON.stringify(projection.path))
       if (expression === undefined) {
-        continue
+        throw new Error(`Rendered projection path '${projection.path.join(".")}' does not exist in the query selection`)
+      }
+      if (!(projection.alias in row)) {
+        throw makeRowDecodeError(
+          rendered,
+          projection,
+          expression,
+          undefined,
+          "schema",
+          new Error(`Missing required projection alias '${projection.alias}'`)
+        )
       }
       setPath(
         decoded,
@@ -471,24 +509,28 @@ 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(
         sqlDriver.stream(rendered),
         (rows) => Chunk.unsafeFromArray(remapRows<any>(rendered, Chunk.toReadonlyArray(rows)))
-      )
+      ) 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>(

package/src/internal/expression-ast.ts

@@ -36,11 +36,12 @@ export interface CastNode<
 
 /** Explicit collation captured by the internal expression AST. */
 export interface CollateNode<
-  Value extends Expression.Any = Expression.Any
+  Value extends Expression.Any = Expression.Any,
+  Collation extends readonly [string, ...string[]] = readonly [string, ...string[]]
 > {
   readonly kind: "collate"
   readonly value: Value
-  readonly collation: readonly [string, ...string[]]
+  readonly collation: Collation
 }
 
 /** General SQL function call captured by the internal expression AST. */

package/src/internal/grouping-key.ts

@@ -1,9 +1,29 @@
 import * as Expression from "./scalar.js"
 import * as ExpressionAst from "./expression-ast.js"
+import * as JsonPath from "./json/path.js"
+import { columnPredicateKey } from "./predicate/runtime.js"
+
+const subqueryPlanIds = new WeakMap<object, string>()
+let nextSubqueryPlanId = 0
+
+const subqueryPlanGroupingKey = (plan: unknown): string => {
+  if (plan === null || typeof plan !== "object") {
+    return "unknown"
+  }
+  const existing = subqueryPlanIds.get(plan)
+  if (existing !== undefined) {
+    return existing
+  }
+  const next = `${nextSubqueryPlanId++}`
+  subqueryPlanIds.set(plan, next)
+  return next
+}
 
 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"
@@ -20,17 +40,150 @@ const literalGroupingKey = (value: unknown): string => {
   }
 }
 
+const isExpression = (value: unknown): value is Expression.Any =>
+  value !== null && typeof value === "object" && Expression.TypeId in value
+
+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, "\\\\")
+    .replace(/,/g, "\\,")
+    .replace(/\|/g, "\\|")
+    .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) {
+      case "key":
+        return `key:${escapeGroupingText((segment as JsonPath.KeySegment).key)}`
+      case "index":
+        return `index:${(segment as JsonPath.IndexSegment).index}`
+      case "wildcard":
+        return "wildcard"
+      case "slice": {
+        const slice = segment as JsonPath.SliceSegment
+        return `slice:${slice.start ?? ""}:${slice.end ?? ""}`
+      }
+      case "descend":
+        return "descend"
+    }
+  }
+  if (typeof segment === "string") {
+    return `key:${escapeGroupingText(segment)}`
+  }
+  if (typeof segment === "number") {
+    return `index:${segment}`
+  }
+  return "unknown"
+}
+
+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
+
+const jsonOpaquePathGroupingKey = (value: unknown): string => {
+  if (isJsonPath(value)) {
+    return `jsonpath:${jsonPathGroupingKey(value.segments)}`
+  }
+  if (typeof value === "string") {
+    return `jsonpath:${escapeGroupingText(value)}`
+  }
+  if (isExpression(value)) {
+    return `jsonpath:${groupingKeyOfExpression(value)}`
+  }
+  return "jsonpath:unknown"
+}
+
+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 & {
     readonly [ExpressionAst.TypeId]: ExpressionAst.Any
   })[ExpressionAst.TypeId]
   switch (ast.kind) {
     case "column":
-      return `column:${ast.tableName}.${ast.columnName}`
+      return `column:${columnPredicateKey(ast.tableName, ast.columnName)}`
     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(${requiredExpressionGroupingKey("collate", ast.value)},${collationGroupingKey(ast.collation)})`
+    case "function":
+      return `function(${functionCallNameGroupingKey(ast.name)},${functionCallArgsGroupingKey(ast.args)})`
     case "isNull":
     case "isNotNull":
     case "not":
@@ -39,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":
@@ -48,9 +201,16 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "gte":
     case "like":
     case "ilike":
+    case "regexMatch":
+    case "regexIMatch":
+    case "regexNotMatch":
+    case "regexNotIMatch":
     case "isDistinctFrom":
     case "isNotDistinctFrom":
-      return `${ast.kind}(${groupingKeyOfExpression(ast.left)},${groupingKeyOfExpression(ast.right)})`
+    case "contains":
+    case "containedBy":
+    case "overlaps":
+      return `${ast.kind}(${requiredBinaryExpressionGroupingKey(ast.kind, ast.left, ast.right)})`
     case "and":
     case "or":
     case "coalesce":
@@ -58,12 +218,59 @@ 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(${requiredExpressionGroupingKey("inSubquery", ast.left)},${subqueryPlanGroupingKey(ast.plan)})`
+    case "comparisonAny":
+    case "comparisonAll":
+      return `${ast.kind}(${ast.operator},${requiredExpressionGroupingKey(quantifiedComparisonGroupingName(ast.kind), ast.left)},${subqueryPlanGroupingKey(ast.plan)})`
+    case "jsonGet":
+    case "jsonPath":
+    case "jsonAccess":
+    case "jsonTraverse":
+    case "jsonGetText":
+    case "jsonPathText":
+    case "jsonAccessText":
+    case "jsonTraverseText":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonPathGroupingKey(ast.segments)})`
+    case "jsonHasKey":
+    case "jsonKeyExists":
+    case "jsonHasAnyKeys":
+    case "jsonHasAllKeys":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonKeysGroupingKey(ast.keys)})`
+    case "jsonConcat":
+    case "jsonMerge":
+      return `json(${ast.kind},${expressionGroupingKey(ast.left)},${expressionGroupingKey(ast.right)},)`
+    case "jsonDelete":
+    case "jsonDeletePath":
+    case "jsonRemove":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${expressionGroupingKey(undefined)},${jsonPathGroupingKey(ast.segments)})`
+    case "jsonSet":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${expressionGroupingKey(ast.newValue)},${jsonPathGroupingKey(ast.segments)})`
+    case "jsonInsert":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${expressionGroupingKey(ast.insert)},${jsonPathGroupingKey(ast.segments)})`
+    case "jsonPathExists":
+    case "jsonPathMatch":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonOpaquePathGroupingKey(ast.query)})`
+    case "jsonBuildObject":
+      return `json(${ast.kind},${jsonBuildObjectGroupingKey(ast.entries)})`
+    case "jsonBuildArray":
+      return `json(${ast.kind},${jsonBuildArrayGroupingKey(ast.values)})`
+    case "jsonToJson":
+    case "jsonToJsonb":
+    case "jsonTypeOf":
+    case "jsonLength":
+    case "jsonKeys":
+    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

@@ -5,6 +5,7 @@ import * as Table from "./table.js"
 import type { PredicateFormula } from "./predicate/formula.js"
 import {
   assumeFormulaTrue,
+  columnPredicateKey,
   contradictsFormula,
   guaranteedNonNullKeys,
   guaranteedNullKeys,
@@ -40,10 +41,10 @@ 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(`${ast.tableName}.${ast.columnName}`)
+      output.add(columnPredicateKey(ast.tableName, ast.columnName))
     }
     return
   }