effect-qb 0.17.0 → 0.20.0

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/predicate/runtime.ts

@@ -474,6 +474,9 @@ const valueKeyOfLiteral = (value: unknown): string => {
     return "null"
   }
   if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      throw new Error("Expected a valid Date value")
+    }
     return `date:${value.toISOString()}`
   }
   return "unknown"

package/src/internal/query.d.ts

@@ -37,6 +37,31 @@ export interface QueryState<Outstanding extends string, AvailableNames extends s
 }
 /** Effective SQL dialect carried by an expression. */
 export type DialectOf<Value extends Expression.Any> = Value[typeof Expression.TypeId]["dialect"];
+type ConcreteDialect<D> = D extends "standard" ? never : D;
+type IsDialectUnion<Union, All = Union> = Union extends any ? [
+    All
+] extends [Union] ? false : true : false;
+export type DialectConflictError<A extends string, B extends string> = string & {
+    readonly _tag: "DialectConflict";
+    readonly left: A;
+    readonly right: B;
+};
+export type MergeDialect<A extends string, B extends string> = [
+    ConcreteDialect<A>,
+    ConcreteDialect<B>
+] extends [never, never] ? "standard" : [
+    ConcreteDialect<A>,
+    ConcreteDialect<B>
+] extends [never, infer C extends string] ? C : [
+    ConcreteDialect<A>,
+    ConcreteDialect<B>
+] extends [infer C extends string, never] ? C : ConcreteDialect<A> extends ConcreteDialect<B> ? ConcreteDialect<B> extends ConcreteDialect<A> ? A : DialectConflictError<A, B> : DialectConflictError<A, B>;
+/** Collapses the portable standard tag out of a dialect union. */
+export type NormalizeDialect<Dialect extends string> = [
+    Dialect
+] extends [never] ? never : [
+    Exclude<Dialect, "standard">
+] extends [never] ? "standard" : IsDialectUnion<Exclude<Dialect, "standard">> extends true ? DialectConflictError<Exclude<Dialect, "standard">, Exclude<Dialect, "standard">> : Exclude<Dialect, "standard">;
 /** Source dependency union carried by an expression. */
 export type DependenciesOf<Value extends Expression.Any> = Expression.DependenciesOf<Value>;
 /** Aggregation kind carried by an expression. */
@@ -135,10 +160,11 @@ export type SelectionShape = Expression.Any | {
 export type ExtractRequired<Selection> = Selection extends Expression.Any ? RequiredFromDependencies<DependenciesOf<Selection>> : Selection extends Record<string, any> ? {
     [K in keyof Selection]: ExtractRequired<Selection[K]>;
 }[keyof Selection] : never;
-/** Walks a selection tree and unions the dialects referenced by its leaves. */
-export type ExtractDialect<Selection> = Selection extends Expression.Any ? DialectOf<Selection> : Selection extends Record<string, any> ? {
-    [K in keyof Selection]: ExtractDialect<Selection[K]>;
+type ExtractDialectRaw<Selection> = Selection extends Expression.Any ? DialectOf<Selection> : Selection extends Record<string, any> ? {
+    [K in keyof Selection]: ExtractDialectRaw<Selection[K]>;
 }[keyof Selection] : never;
+/** Walks a selection tree and extracts the effective dialects referenced by its leaves. */
+export type ExtractDialect<Selection> = NormalizeDialect<Extract<ExtractDialectRaw<Selection>, string>>;
 /**
  * Minimal table-like shape required by `from(...)` and joins.
  *
@@ -419,8 +445,7 @@ export type MutationTargetNamesOf<Target extends MutationTargetInput> = Target e
 export type UpdateInputOfTarget<Target extends MutationTargetInput> = Target extends MutationTargetLike ? MutationInputOf<Table.UpdateOf<Target>> : Target extends MutationTargetTuple ? Simplify<{
     readonly [K in MutationTargetNamesOf<Target>]?: MutationInputOf<Table.UpdateOf<MutationTargetByName<Target, K>>>;
 }> : never;
-/** Extracts the effective dialect from a source. */
-export type SourceDialectOf<Source extends SourceLike> = Source extends TableLike<any, infer Dialect> ? Dialect : Source extends {
+type SourceDialectOfRaw<Source extends SourceLike> = Source extends TableLike<any, infer Dialect> ? Dialect : Source extends {
     readonly kind: "derived";
     readonly plan: infer PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>;
 } ? PlanDialectOf<PlanValue> : Source extends {
@@ -432,6 +457,8 @@ export type SourceDialectOf<Source extends SourceLike> = Source extends TableLik
 } ? PlanDialectOf<PlanValue> : Source extends {
     readonly dialect: infer Dialect extends string;
 } ? Dialect : never;
+/** Extracts the effective dialect from a source. */
+export type SourceDialectOf<Source extends SourceLike> = NormalizeDialect<SourceDialectOfRaw<Source>>;
 /** Extracts the base table name from a source. */
 export type SourceBaseNameOf<Source extends SourceLike> = Source extends TableLike<any, any> ? Source[typeof Table.TypeId]["baseName"] : Source extends {
     readonly kind: "derived";
@@ -493,7 +520,7 @@ export type RequiredOfPlan<PlanValue extends QueryPlan<any, any, any, any, any,
 /** Extracts the available-source scope carried by a query plan. */
 export type AvailableOfPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>> = QueryPlanParts<PlanValue>["available"];
 /** Extracts the effective dialect carried by a query plan. */
-export type PlanDialectOf<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>> = QueryPlanParts<PlanValue>["dialect"];
+export type PlanDialectOf<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>> = NormalizeDialect<QueryPlanParts<PlanValue>["dialect"]>;
 /** Extracts the grouped-source phantom carried by a query plan. */
 export type GroupedOfPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>> = QueryPlanState<PlanValue>["grouped"];
 /** Extracts the available-name phantom carried by a query plan. */
@@ -562,7 +589,7 @@ type MergeNullability<Left extends Expression.Nullability, Right extends Express
 /** Folds nullability across a tuple for null-propagating scalar operators. */
 export type MergeNullabilityTuple<Values extends readonly Expression.Any[], Current extends Expression.Nullability = "never"> = Values extends readonly [infer Head extends Expression.Any, ...infer Tail extends readonly Expression.Any[]] ? MergeNullabilityTuple<Tail, MergeNullability<Current, Expression.NullabilityOf<Head>>> : Current;
 /** Dialect union across a tuple of expressions. */
-export type TupleDialect<Values extends readonly Expression.Any[]> = Values[number] extends never ? never : DialectOf<Values[number]>;
+export type TupleDialect<Values extends readonly Expression.Any[]> = Values[number] extends never ? never : NormalizeDialect<DialectOf<Values[number]>>;
 /** Dependency union across a tuple of scalar expressions. */
 export type TupleDependencies<Values extends readonly Expression.Any[]> = Values[number] extends never ? never : DependenciesOf<Values[number]>;
 /** Builds the canonical dependency union from a string union of table names. */
@@ -661,7 +688,7 @@ type AggregationCompatibilityError<PlanValue extends QueryPlan<any, any, any, an
 };
 type DialectCompatibilityError<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>, EngineDialect extends string> = PlanValue & {
     readonly __effect_qb_error__: "effect-qb: plan dialect is not compatible with the target renderer or executor";
-    readonly __effect_qb_plan_dialect__: PlanValue[typeof RowSet.TypeId]["dialect"];
+    readonly __effect_qb_plan_dialect__: PlanDialectOf<PlanValue>;
     readonly __effect_qb_target_dialect__: EngineDialect;
     readonly __effect_qb_hint__: "Use the matching dialect module or renderer/executor";
 };
@@ -678,11 +705,11 @@ export type AggregationCompatiblePlan<PlanValue extends QueryPlan<any, any, any,
 /** Narrows a query plan to aggregate-compatible, source-complete plans. */
 export type CompletePlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> = StatementOfPlan<PlanValue> extends "insert" ? InsertSourceStateOfPlan<PlanValue> extends "missing" ? InsertHasOptionalDefaults<PlanValue> extends true ? PlanValue : InsertSourceCompletenessError<PlanValue> : HasKnownOutstanding<RequiredOfPlan<PlanValue>> extends true ? SourceCompletenessError<PlanValue, Extract<RequiredOfPlan<PlanValue>, string>> : IsAggregationCompatibleSelection<SelectionOfPlan<PlanValue>, GroupedOfPlan<PlanValue>> extends true ? PlanValue : AggregationCompatibilityError<PlanValue> : HasKnownOutstanding<RequiredOfPlan<PlanValue>> extends true ? SourceCompletenessError<PlanValue, Extract<RequiredOfPlan<PlanValue>, string>> : IsAggregationCompatibleSelection<SelectionOfPlan<PlanValue>, GroupedOfPlan<PlanValue>> extends true ? PlanValue : AggregationCompatibilityError<PlanValue>;
 /** Whether a plan dialect is compatible with a target engine dialect. */
-type IsDialectCompatible<PlanDialect extends string, EngineDialect extends string> = [PlanDialect] extends [never] ? true : Extract<PlanDialect, EngineDialect> extends never ? false : true;
+type IsDialectCompatible<PlanDialect extends string, EngineDialect extends string> = [PlanDialect] extends [never] ? true : Exclude<PlanDialect, EngineDialect | "standard"> extends never ? true : false;
 /** Narrows a complete plan to those compatible with a target engine dialect. */
-export type DialectCompatiblePlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>, EngineDialect extends string> = IsDialectCompatible<PlanValue[typeof RowSet.TypeId]["dialect"], EngineDialect> extends true ? CompletePlan<PlanValue> : DialectCompatibilityError<PlanValue, EngineDialect>;
+export type DialectCompatiblePlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>, EngineDialect extends string> = IsDialectCompatible<PlanDialectOf<PlanValue>, EngineDialect> extends true ? CompletePlan<PlanValue> : DialectCompatibilityError<PlanValue, EngineDialect>;
 /** Nested-plan compatibility used by subquery expressions such as `exists(...)`. */
-export type DialectCompatibleNestedPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>, EngineDialect extends string> = IsDialectCompatible<PlanValue[typeof RowSet.TypeId]["dialect"], EngineDialect> extends true ? AggregationCompatiblePlan<PlanValue> : DialectCompatibilityError<PlanValue, EngineDialect>;
+export type DialectCompatibleNestedPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>, EngineDialect extends string> = IsDialectCompatible<PlanDialectOf<PlanValue>, EngineDialect> extends true ? AggregationCompatiblePlan<PlanValue> : DialectCompatibilityError<PlanValue, EngineDialect>;
 type SetOperandStatement = "select" | "set";
 type IsUnion<Value, All = Value> = Value extends any ? ([All] extends [Value] ? false : true) : never;
 type SingleSelectedExpressionError<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> = PlanValue & {
@@ -743,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;