effect-qb 0.19.0 → 0.20.0

package/src/internal/datatypes/shape.ts

@@ -56,10 +56,12 @@ export interface DatatypeTraits {
 export interface DatatypeFamilySpec<
   CompareGroup extends string = string,
   CastTargets extends readonly string[] = readonly string[],
+  ImplicitTargets extends readonly string[] = readonly string[],
   Traits extends DatatypeTraits = DatatypeTraits
 > {
   readonly compareGroup: CompareGroup
   readonly castTargets: CastTargets
+  readonly implicitTargets?: ImplicitTargets
   readonly traits: Traits
 }
 

package/src/internal/dialect-renderers/mysql.ts

@@ -5,6 +5,7 @@ import * as Expression from "../scalar.js"
 import * as Table from "../table.js"
 import * as QueryAst from "../query-ast.js"
 import { renderDbTypeName, type RenderState, type RenderValueContext, type SqlDialect } from "../dialect.js"
+import { renderPortableDatatypeCastType, renderPortableDatatypeDdlType } from "../datatypes/matrix.js"
 import * as ExpressionAst from "../expression-ast.js"
 import * as JsonPath from "../json/path.js"
 import { renderMysqlMutationLockMode, renderSelectLockMode } from "../dsl-plan-runtime.js"
@@ -25,10 +26,7 @@ const renderDbType = (
   dialect: SqlDialect,
   dbType: Expression.DbType.Any
 ): string => {
-  if (dialect.name === "mysql" && dbType.kind === "uuid") {
-    return "char(36)"
-  }
-  return renderDbTypeName(dbType.kind)
+  return renderDbTypeName(renderPortableDatatypeDdlType(dialect.name, dbType.kind) ?? dbType.kind)
 }
 
 const isArrayDbType = (dbType: Expression.DbType.Any): boolean =>
@@ -39,6 +37,10 @@ const renderCastType = (
   dbType: unknown
 ): string => {
   const kind = (dbType as { readonly kind?: string } | undefined)?.kind as string
+  const portableType = renderPortableDatatypeCastType(dialect.name, kind)
+  if (portableType !== undefined) {
+    return renderDbTypeName(portableType)
+  }
   if (dialect.name !== "mysql") {
     return renderDbTypeName(kind)
   }

package/src/internal/dialect-renderers/postgres.ts

@@ -5,6 +5,7 @@ import * as Expression from "../scalar.js"
 import * as Table from "../table.js"
 import * as QueryAst from "../query-ast.js"
 import { renderDbTypeName, type RenderState, type RenderValueContext, type SqlDialect } from "../dialect.js"
+import { renderPortableDatatypeCastType, renderPortableDatatypeDdlType } from "../datatypes/matrix.js"
 import * as ExpressionAst from "../expression-ast.js"
 import * as JsonPath from "../json/path.js"
 import { renderSelectLockMode } from "../dsl-plan-runtime.js"
@@ -26,10 +27,7 @@ const renderDbType = (
   dialect: SqlDialect,
   dbType: Expression.DbType.Any
 ): string => {
-  if (dialect.name === "postgres" && dbType.kind === "blob") {
-    return "bytea"
-  }
-  return renderDbTypeName(dbType.kind)
+  return renderDbTypeName(renderPortableDatatypeDdlType(dialect.name, dbType.kind) ?? dbType.kind)
 }
 
 const isArrayDbType = (dbType: Expression.DbType.Any): boolean =>
@@ -40,6 +38,10 @@ const renderCastType = (
   dbType: unknown
 ): string => {
   const kind = (dbType as { readonly kind?: string } | undefined)?.kind as string
+  const portableType = renderPortableDatatypeCastType(dialect.name, kind)
+  if (portableType !== undefined) {
+    return renderDbTypeName(portableType)
+  }
   if (dialect.name !== "mysql") {
     return renderDbTypeName(kind)
   }

package/src/internal/dialect-renderers/sqlite.ts

@@ -5,6 +5,7 @@ import * as Expression from "../scalar.js"
 import * as Table from "../table.js"
 import * as QueryAst from "../query-ast.js"
 import { renderDbTypeName, type RenderState, type RenderValueContext, type SqlDialect } from "../dialect.js"
+import { renderPortableDatatypeCastType, renderPortableDatatypeDdlType } from "../datatypes/matrix.js"
 import * as ExpressionAst from "../expression-ast.js"
 import * as JsonPath from "../json/path.js"
 import { expectConflictClause } from "../dsl-mutation-runtime.js"
@@ -24,10 +25,7 @@ const renderDbType = (
   dialect: SqlDialect,
   dbType: Expression.DbType.Any
 ): string => {
-  if (dialect.name === "sqlite" && dbType.kind === "uuid") {
-    return "text"
-  }
-  return renderDbTypeName(dbType.kind)
+  return renderDbTypeName(renderPortableDatatypeDdlType(dialect.name, dbType.kind) ?? dbType.kind)
 }
 
 const isArrayDbType = (dbType: Expression.DbType.Any): boolean =>
@@ -38,6 +36,10 @@ const renderCastType = (
   dbType: unknown
 ): string => {
   const kind = (dbType as { readonly kind?: string } | undefined)?.kind as string
+  const portableType = renderPortableDatatypeCastType(dialect.name, kind)
+  if (portableType !== undefined) {
+    return renderDbTypeName(portableType)
+  }
   if (dialect.name !== "sqlite") {
     return renderDbTypeName(kind)
   }

package/src/internal/dialect.ts

@@ -32,7 +32,7 @@ export interface RenderState {
 
 export interface RenderValueContext {
   readonly dbType?: Expression.DbType.Any
-  readonly runtimeSchema?: Schema.Schema.Any
+  readonly runtimeSchema?: Schema.Top
   readonly driverValueMapping?: Expression.DriverValueMapping
 }
 

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 = (
@@ -524,9 +543,9 @@ export const fromDriver = <
       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>
     }
   }
@@ -536,10 +555,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)
@@ -560,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/json/path-access.ts

@@ -0,0 +1,351 @@
+import { pipeArguments, type Pipeable } from "effect/Pipeable"
+
+import * as ExpressionAst from "../expression-ast.js"
+import * as Expression from "../scalar.js"
+import * as JsonPath from "./path.js"
+import type { JsonValueAtPath } from "./types.js"
+
+const WrappedTypeId: unique symbol = Symbol.for("effect-qb/JsonPathAccess")
+
+type JsonDb = Expression.DbType.Json<any, any>
+
+type AnyJsonExpression = Expression.Scalar<
+  any,
+  JsonDb,
+  Expression.Nullability,
+  string,
+  Expression.ScalarKind,
+  Expression.BindingId
+>
+
+type JsonNullabilityOf<Output> =
+  null extends Output
+    ? Exclude<Output, null> extends never ? "always" : "maybe"
+    : "never"
+
+type IsAny<Value> = 0 extends (1 & Value) ? true : false
+
+type SegmentTuple<Segments> = Segments extends readonly JsonPath.CanonicalSegment[]
+  ? Segments
+  : readonly JsonPath.CanonicalSegment[]
+
+type JsonAccessAst<Value> = Value extends {
+  readonly [ExpressionAst.TypeId]: infer Ast
+} ? Ast : never
+
+type JsonAccessParts<
+  Value,
+  Acc extends readonly JsonPath.CanonicalSegment[] = readonly [],
+  Depth extends readonly unknown[] = []
+> =
+  Depth["length"] extends 8 ? readonly [Value, Acc] :
+    [JsonAccessAst<Value>] extends [never]
+      ? readonly [Value, Acc]
+      : JsonAccessAst<Value> extends ExpressionAst.JsonAccessNode<any, infer Base extends Expression.Any, infer Segments>
+      ? JsonAccessParts<Base, readonly [...SegmentTuple<Segments>, ...Acc], readonly [...Depth, unknown]>
+      : readonly [Value, Acc]
+
+type JsonAccessRoot<Value> =
+  JsonAccessParts<Value> extends readonly [infer Base, readonly JsonPath.CanonicalSegment[]]
+    ? Base
+    : Value
+
+type JsonAccessSegments<Value> =
+  JsonAccessParts<Value> extends readonly [any, infer Segments extends readonly JsonPath.CanonicalSegment[]]
+    ? Segments
+    : readonly []
+
+type JsonAccessBase<Value> =
+  JsonAccessRoot<Value> extends Expression.Any ? JsonAccessRoot<Value> : Value
+
+type JsonPathOutput<
+  Root,
+  Segments extends readonly JsonPath.CanonicalSegment[],
+  Operation extends string
+> =
+  JsonValueAtPath<Exclude<Root, null>, JsonPath.Path<Segments>, Operation> |
+  (null extends Root ? null : never)
+
+type JsonAccessExpression<
+  Base extends AnyJsonExpression,
+  Segments extends readonly JsonPath.CanonicalSegment[]
+> = WithJsonPathAccess<
+  Expression.Scalar<
+    JsonPathOutput<Expression.RuntimeOf<JsonAccessBase<Base>>, Segments, "json.get">,
+    Expression.DbTypeOf<JsonAccessBase<Base>>,
+    JsonNullabilityOf<JsonPathOutput<Expression.RuntimeOf<JsonAccessBase<Base>>, Segments, "json.get">>,
+    Expression.DbTypeOf<JsonAccessBase<Base>>["dialect"],
+    Expression.KindOf<JsonAccessBase<Base>>,
+    Expression.DependenciesOf<JsonAccessBase<Base>>
+  > & {
+    readonly [ExpressionAst.TypeId]: ExpressionAst.JsonAccessNode<
+      JsonPath.IsExactPath<JsonPath.Path<Segments>> extends true ? "jsonPath" : "jsonTraverse",
+      JsonAccessBase<Base>,
+      Segments
+    >
+  }
+>
+
+type JsonKeyAccess<
+  Base extends AnyJsonExpression,
+  Key extends string
+> = JsonAccessExpression<Base, readonly [...JsonAccessSegments<Base>, JsonPath.KeySegment<Key>]>
+
+type JsonIndexAccess<
+  Base extends AnyJsonExpression,
+  Index extends number
+> = JsonAccessExpression<Base, readonly [...JsonAccessSegments<Base>, JsonPath.IndexSegment<Index>]>
+
+type ReservedPathKey =
+  | "pipe"
+  | "then"
+  | "toString"
+  | "toJSON"
+  | "valueOf"
+  | "constructor"
+  | "__proto__"
+  | "prototype"
+  | "inspect"
+  | "schema"
+  | "metadata"
+  | "columns"
+  | "name"
+
+type KeysOfUnion<Value> = Value extends unknown ? keyof Value : never
+
+type JsonObjectKey<Key> = Key extends string
+  ? Key extends ReservedPathKey ? never :
+    Key extends `${number}` ? never :
+      Key
+  : never
+
+type TupleNumberKey<Key> = Key extends `${infer Index extends number}` ? Index : never
+
+type JsonTupleAccessors<
+  Base extends AnyJsonExpression,
+  Runtime extends readonly unknown[]
+> = {
+  readonly [Key in Extract<keyof Runtime, `${number}`> as TupleNumberKey<Key>]: JsonIndexAccess<Base, TupleNumberKey<Key>>
+} & {
+  readonly [index: number]: JsonIndexAccess<Base, number>
+}
+
+type JsonArrayAccessors<
+  Base extends AnyJsonExpression,
+  Runtime extends readonly unknown[]
+> = number extends Runtime["length"]
+  ? {
+      readonly [index: number]: JsonIndexAccess<Base, number>
+    }
+  : JsonTupleAccessors<Base, Runtime>
+
+type JsonObjectAccessors<
+  Base extends AnyJsonExpression,
+  Runtime extends object
+> = {
+  readonly [Key in KeysOfUnion<Runtime> as JsonObjectKey<Key>]: JsonKeyAccess<Base, JsonObjectKey<Key>>
+}
+
+type JsonObjectPredicateKeys<Runtime> =
+  Runtime extends readonly unknown[]
+    ? never
+    : Runtime extends object
+      ? Extract<KeysOfUnion<Runtime>, string>
+      : never
+
+export type JsonObjectKeyOf<Value extends Expression.Any> =
+  IsAny<Expression.RuntimeOf<Value>> extends true
+    ? string
+    : Exclude<Expression.RuntimeOf<Value>, null> extends infer Runtime
+      ? string extends JsonObjectPredicateKeys<Runtime>
+        ? string
+        : JsonObjectPredicateKeys<Runtime>
+      : never
+
+type JsonPathAccessors<Base extends AnyJsonExpression> =
+  IsAny<Expression.RuntimeOf<Base>> extends true
+    ? {}
+    : Exclude<Expression.RuntimeOf<Base>, null> extends infer Runtime
+      ? Runtime extends readonly unknown[]
+        ? JsonArrayAccessors<Base, Runtime>
+        : Runtime extends object
+          ? JsonObjectAccessors<Base, Runtime>
+          : {}
+      : {}
+
+export type WithJsonPathAccess<Value> = Value extends AnyJsonExpression
+  ? Value & JsonPathAccessors<Value>
+  : Value
+
+const accessKinds = new Set<string>([
+  "jsonGet",
+  "jsonPath",
+  "jsonAccess",
+  "jsonTraverse",
+  "jsonGetText",
+  "jsonPathText",
+  "jsonAccessText",
+  "jsonTraverseText"
+])
+
+const reservedKeys = new Set<string>([
+  "pipe",
+  "then",
+  "toString",
+  "toJSON",
+  "valueOf",
+  "constructor",
+  "__proto__",
+  "prototype",
+  "inspect",
+  "schema",
+  "metadata",
+  "columns",
+  "name"
+])
+
+const isObjectLike = (value: unknown): value is object =>
+  (typeof value === "object" || typeof value === "function") && value !== null
+
+const isExpression = (value: unknown): value is Expression.Any =>
+  isObjectLike(value) && Expression.TypeId in value
+
+const isJsonExpression = (value: unknown): value is AnyJsonExpression => {
+  if (!isExpression(value)) {
+    return false
+  }
+  const dbType = value[Expression.TypeId].dbType as { readonly kind?: string; readonly variant?: string }
+  return dbType.kind === "json" || dbType.kind === "jsonb" || dbType.variant === "json" || dbType.variant === "jsonb"
+}
+
+const isWrapped = (value: object): boolean =>
+  (value as { readonly [WrappedTypeId]?: true })[WrappedTypeId] === true
+
+const normalizeSegment = (segment: JsonPath.CanonicalSegment): JsonPath.CanonicalSegment => {
+  switch (segment.kind) {
+    case "key":
+      return JsonPath.key(segment.key)
+    case "index":
+      return JsonPath.index(segment.index)
+    case "wildcard":
+      return JsonPath.wildcard()
+    case "slice":
+      return JsonPath.slice(segment.start, segment.end)
+    case "descend":
+      return JsonPath.descend()
+  }
+}
+
+const accessPathOf = (value: Expression.Any): {
+  readonly base: Expression.Any
+  readonly segments: readonly JsonPath.CanonicalSegment[]
+} => {
+  const segments: JsonPath.CanonicalSegment[] = []
+  let base: Expression.Any = value
+  while (isExpression(base)) {
+    const ast = (base as Expression.Any & {
+      readonly [ExpressionAst.TypeId]?: ExpressionAst.Any
+    })[ExpressionAst.TypeId] as { readonly kind?: unknown; readonly base?: unknown; readonly segments?: unknown } | undefined
+    if (ast === undefined || typeof ast.kind !== "string" || !accessKinds.has(ast.kind) || !isExpression(ast.base) || !Array.isArray(ast.segments)) {
+      break
+    }
+    segments.unshift(...ast.segments.map(normalizeSegment))
+    base = ast.base
+  }
+  return { base, segments }
+}
+
+const isIntegerProperty = (property: string): boolean =>
+  /^(?:-?(?:0|[1-9][0-9]*))$/.test(property)
+
+const jsonAccessKind = (
+  segments: readonly JsonPath.CanonicalSegment[]
+): ExpressionAst.JsonAccessKind =>
+  segments.every((segment) => segment.kind === "key" || segment.kind === "index")
+    ? segments.length === 1 ? "jsonGet" : "jsonPath"
+    : "jsonTraverse"
+
+const makeExpression = <
+  Runtime,
+  Db extends Expression.DbType.Any,
+  Nullable extends Expression.Nullability,
+  Dialect extends string,
+  Kind extends Expression.ScalarKind,
+  Deps extends Expression.BindingId,
+  Ast extends ExpressionAst.Any
+>(
+  state: Expression.State<Runtime, Db, Nullable, Dialect, Kind, Deps>,
+  ast: Ast
+): Expression.Scalar<Runtime, Db, Nullable, Dialect, Kind, Deps> & {
+  readonly [ExpressionAst.TypeId]: Ast
+} => {
+  const expression = Object.create(null) as Expression.Scalar<Runtime, Db, Nullable, Dialect, Kind, Deps> & {
+    [ExpressionAst.TypeId]: Ast
+    [Expression.TypeId]: Expression.State<Runtime, Db, Nullable, Dialect, Kind, Deps>
+    pipe: Pipeable["pipe"]
+  }
+  Object.defineProperty(expression, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function(this: Pipeable) {
+      return pipeArguments(expression, arguments)
+    }
+  })
+  expression[Expression.TypeId] = state
+  expression[ExpressionAst.TypeId] = ast
+  return expression
+}
+
+const makePathExpression = (
+  value: AnyJsonExpression,
+  segment: JsonPath.CanonicalSegment
+): AnyJsonExpression => {
+  const access = accessPathOf(value)
+  const segments = [...access.segments, normalizeSegment(segment)]
+  const base = access.base as AnyJsonExpression
+  const baseState = base[Expression.TypeId]
+  return withJsonPathAccess(makeExpression(
+    {
+      ...baseState,
+      runtime: undefined,
+      nullability: undefined as unknown as Expression.Nullability
+    },
+    {
+      kind: jsonAccessKind(segments),
+      base,
+      segments
+    } satisfies ExpressionAst.JsonAccessNode<any, any, any>
+  ) as AnyJsonExpression)
+}
+
+const pathProxyHandler: ProxyHandler<AnyJsonExpression> = {
+  get(target, property, receiver) {
+    if (typeof property === "symbol") {
+      return Reflect.get(target, property, receiver)
+    }
+    if (Reflect.has(target, property) || reservedKeys.has(property)) {
+      return Reflect.get(target, property, receiver)
+    }
+    const segment = isIntegerProperty(property)
+      ? JsonPath.index(Number(property))
+      : JsonPath.key(property)
+    return makePathExpression(target, segment)
+  },
+  has(target, property) {
+    return Reflect.has(target, property)
+  }
+}
+
+export const withJsonPathAccess = <Value>(value: Value): WithJsonPathAccess<Value> => {
+  if (!isObjectLike(value) || !isJsonExpression(value) || isWrapped(value)) {
+    return value as WithJsonPathAccess<Value>
+  }
+  const proxy = new Proxy(value, pathProxyHandler) as unknown as WithJsonPathAccess<Value> & {
+    [WrappedTypeId]: true
+  }
+  Object.defineProperty(proxy, WrappedTypeId, {
+    configurable: false,
+    value: true
+  })
+  return proxy
+}

package/src/internal/query.d.ts

@@ -770,7 +770,7 @@ export declare const mergeManyDependencies: <Values extends readonly Expression.
 export declare const makeExpression: <Runtime, Db extends Expression.DbType.Any, Nullable extends Expression.Nullability, Dialect extends string, Kind extends Expression.ScalarKind, Deps extends string = never, Ast extends ExpressionAst.Any = ExpressionAst.Any, GroupKey extends string = GroupingKeyOfAst<Ast>>(state: {
     readonly runtime: Runtime;
     readonly dbType: Db;
-    readonly runtimeSchema?: Schema.Schema.Any | undefined;
+    readonly runtimeSchema?: Schema.Top | undefined;
     readonly nullability: Nullable;
     readonly dialect: Dialect;
     readonly kind?: Kind | undefined;

package/src/internal/query.ts

@@ -2459,7 +2459,7 @@ export const makeExpression = <
   state: {
     readonly runtime: Runtime
     readonly dbType: Db
-    readonly runtimeSchema?: Schema.Schema.Any
+    readonly runtimeSchema?: Schema.Top
     readonly driverValueMapping?: Expression.DriverValueMapping
     readonly nullability: Nullable
     readonly dialect: Dialect

package/src/internal/runtime/driver-value-mapping.ts

@@ -9,7 +9,7 @@ export type DriverValueMappings = Expression.DriverValueMappings
 export interface DriverValueContext {
   readonly dialect?: string
   readonly dbType?: Expression.DbType.Any
-  readonly runtimeSchema?: Schema.Schema.Any
+  readonly runtimeSchema?: Schema.Top
   readonly driverValueMapping?: DriverValueMapping
   readonly valueMappings?: DriverValueMappings
 }
@@ -99,13 +99,13 @@ const isJsonDbType = (dbType: Expression.DbType.Any | undefined): boolean => {
 }
 
 const schemaAccepts = (
-  schema: Schema.Schema.Any | undefined,
+  schema: Schema.Top | undefined,
   value: unknown
 ): boolean =>
   schema !== undefined && (Schema.is(schema) as (candidate: unknown) => boolean)(value)
 
 const encodeWithSchema = (
-  schema: Schema.Schema.Any | undefined,
+  schema: Schema.Top | undefined,
   value: unknown
 ): { readonly value: unknown; readonly encoded: boolean } => {
   if (schema === undefined) {