effect-qb 0.16.0 → 4.0.0-beta.66

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"
@@ -16,6 +17,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>>
@@ -42,6 +45,10 @@ export interface RowDecodeError {
   readonly normalized?: unknown
   readonly stage: "normalize" | "schema"
   readonly cause: unknown
+  readonly schemaError?: {
+    readonly message: string
+    readonly issue: unknown
+  }
 }
 
 /**
@@ -181,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,
@@ -221,7 +237,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 +253,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.Top | 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 +292,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,20 +323,36 @@ 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
   }
 
-  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 = (
@@ -316,8 +366,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 +375,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,
@@ -352,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 = (
@@ -482,9 +539,9 @@ export const fromDriver = <
     },
     stream(plan: any) {
       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
       )
     }
   }
@@ -494,10 +551,10 @@ export const fromDriver = <
 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)
@@ -518,7 +575,7 @@ export const fromSqlClient = <Dialect extends string>(
     stream: (query) => streamFromSqlClient(query)
   }))
 
-/** Runs an effect within the ambient `@effect/sql` transaction service. */
+/** Runs an effect within the ambient `effect/unstable/sql` transaction service. */
 export const withTransaction = <A, E, R>(
   effect: Effect.Effect<A, E, R>
 ): Effect.Effect<A, E | SqlError.SqlError, R | SqlClient.SqlClient> =>
@@ -527,7 +584,7 @@ export const withTransaction = <A, E, R>(
 /**
  * Runs an effect in a nested transaction scope.
  *
- * When the ambient `@effect/sql` client is already inside a transaction, the
+ * When the ambient `effect/unstable/sql` client is already inside a transaction, the
  * underlying client implementation uses a savepoint.
  */
 export const withSavepoint = <A, E, R>(

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,5 +1,23 @@
 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) {
@@ -20,17 +38,84 @@ 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 escapeGroupingText = (value: string): string =>
+  value
+    .replace(/\\/g, "\\\\")
+    .replace(/,/g, "\\,")
+    .replace(/\|/g, "\\|")
+    .replace(/=/g, "\\=")
+    .replace(/>/g, "\\>")
+
+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: readonly unknown[] | undefined): string =>
+  (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 jsonEntryGroupingKey = (
+  entry: { readonly key: string; readonly value: Expression.Any }
+): string => `${escapeGroupingText(entry.key)}=>${groupingKeyOfExpression(entry.value)}`
+
 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})`
+    case "collate":
+      return `collate(${groupingKeyOfExpression(ast.value)},${ast.collation.map(escapeGroupingText).join(",")})`
+    case "function":
+      return `function(${escapeGroupingText(ast.name)},${ast.args.map(groupingKeyOfExpression).join(",")})`
     case "isNull":
     case "isNotNull":
     case "not":
@@ -48,8 +133,15 @@ 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":
+    case "contains":
+    case "containedBy":
+    case "overlaps":
       return `${ast.kind}(${groupingKeyOfExpression(ast.left)},${groupingKeyOfExpression(ast.right)})`
     case "and":
     case "or":
@@ -62,6 +154,54 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "case":
       return `case(${ast.branches.map((branch: ExpressionAst.CaseBranchNode) =>
         `when:${groupingKeyOfExpression(branch.when)}=>${groupingKeyOfExpression(branch.then)}`).join("|")};else:${groupingKeyOfExpression(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)})`
+    case "comparisonAny":
+    case "comparisonAll":
+      return `${ast.kind}(${ast.operator},${groupingKeyOfExpression(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)},${(ast.keys ?? []).map(escapeGroupingText).join(",")})`
+    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},${(ast.entries ?? []).map(jsonEntryGroupingKey).join("|")})`
+    case "jsonBuildArray":
+      return `json(${ast.kind},${(ast.values ?? []).map(groupingKeyOfExpression).join(",")})`
+    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")
   }

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,
@@ -43,7 +44,7 @@ const collectPresenceWitnesses = (
     const expression = selection as unknown 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
   }