@prisma-next/sql-relational-core 0.3.0-dev.6 → 0.3.0-dev.63

package/dist/types-Cdi4Whda.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-Cdi4Whda.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["import type {\n  ResultType as CoreResultType,\n  ExecutionPlan,\n  PlanRefs,\n} from '@prisma-next/contract/types';\nimport type { ArgSpec, ReturnSpec } from '@prisma-next/operations';\nimport type { SqlContract, SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';\nimport type { SqlLoweringSpec } from '@prisma-next/sql-operations';\nimport type {\n  BinaryOp,\n  ColumnRef,\n  Direction,\n  Expression,\n  ExpressionSource,\n  OperationExpr,\n  ParamRef,\n  QueryAst,\n} from './ast/types';\nimport type { SqlQueryPlan } from './plan';\nimport type { ExecutionContext } from './query-lane-context';\n\nexport interface ParamPlaceholder {\n  readonly kind: 'param-placeholder';\n  readonly name: string;\n}\n\n/**\n * ValueSource represents any value that can appear in a comparison or as an argument.\n * This includes:\n * - ParamPlaceholder: A parameter placeholder (e.g., `param('userId')`)\n * - ExpressionSource: Something that can be converted to an Expression (ColumnBuilder, ExpressionBuilder)\n */\nexport type ValueSource = ParamPlaceholder | ExpressionSource;\n\nexport interface OrderBuilder<\n  _ColumnName extends string = string,\n  _ColumnMeta extends StorageColumn = StorageColumn,\n  _JsType = unknown,\n> {\n  readonly kind: 'order';\n  readonly expr: Expression;\n  readonly dir: Direction;\n}\n\n/**\n * Creates an OrderBuilder for use in orderBy clauses.\n */\nexport function createOrderBuilder(\n  expr: AnyColumnBuilder | OperationExpr,\n  dir: Direction,\n): AnyOrderBuilder {\n  return { kind: 'order', expr, dir } as AnyOrderBuilder;\n}\n\n/**\n * ColumnBuilder with optional operation methods based on the column's typeId.\n * When Operations is provided and the column's typeId matches, operation methods are included.\n * Implements ExpressionSource to provide type-safe conversion to ColumnRef.\n *\n * For nullable columns (ColumnMeta['nullable'] extends true), includes isNull() and isNotNull() methods.\n */\nexport type ColumnBuilder<\n  ColumnName extends string = string,\n  ColumnMeta extends StorageColumn = StorageColumn,\n  JsType = unknown,\n  Operations extends OperationTypes = Record<string, never>,\n> = {\n  readonly kind: 'column';\n  readonly table: string;\n  readonly column: ColumnName;\n  readonly columnMeta: ColumnMeta;\n  // Methods accept ValueSource (ParamPlaceholder or ExpressionSource)\n  eq(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  neq(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  gt(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  lt(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  gte(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  lte(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  asc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;\n  desc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;\n  /** Converts this column builder to a ColumnRef expression */\n  toExpr(): ColumnRef;\n  // Helper property for type extraction (not used at runtime)\n  readonly __jsType: JsType;\n} & (ColumnMeta['codecId'] extends string\n  ? ColumnMeta['codecId'] extends keyof Operations\n    ? OperationMethods<\n        OperationsForTypeId<ColumnMeta['codecId'] & string, Operations>,\n        ColumnName,\n        StorageColumn,\n        JsType\n      >\n    : Record<string, never>\n  : Record<string, never>) &\n  (ColumnMeta['nullable'] extends true\n    ? NullableMethods<ColumnName, ColumnMeta, JsType>\n    : Record<string, never>);\n\nexport interface BinaryBuilder<\n  _ColumnName extends string = string,\n  _ColumnMeta extends StorageColumn = StorageColumn,\n  _JsType = unknown,\n> {\n  readonly kind: 'binary';\n  readonly op: BinaryOp;\n  readonly left: Expression;\n  readonly right: ValueSource;\n}\n\n/**\n * Builder for IS NULL / IS NOT NULL checks.\n * Used to build unary null check expressions in WHERE clauses.\n */\nexport interface NullCheckBuilder<\n  _ColumnName extends string = string,\n  _ColumnMeta extends StorageColumn = StorageColumn,\n  _JsType = unknown,\n> {\n  readonly kind: 'nullCheck';\n  readonly expr: Expression;\n  readonly isNull: boolean;\n}\n\n/**\n * Union type for unary builders (currently just NullCheckBuilder).\n * Extensible for future unary operators.\n */\nexport type UnaryBuilder = NullCheckBuilder;\n\n// Forward declare AnyBinaryBuilder and AnyOrderBuilder for use in ExpressionBuilder\nexport type AnyBinaryBuilder = BinaryBuilder;\nexport type AnyOrderBuilder = OrderBuilder;\nexport type AnyUnaryBuilder = UnaryBuilder;\n\n/**\n * Methods available only on nullable columns.\n * These are conditionally added to ColumnBuilder when ColumnMeta['nullable'] is true.\n * Note: Index signature is required for compatibility with AnyColumnBuilderBase's index signature.\n */\nexport interface NullableMethods<\n  ColumnName extends string = string,\n  ColumnMeta extends StorageColumn = StorageColumn,\n  JsType = unknown,\n> {\n  /** Creates an IS NULL check for this column */\n  isNull(): NullCheckBuilder<ColumnName, ColumnMeta, JsType>;\n  /** Creates an IS NOT NULL check for this column */\n  isNotNull(): NullCheckBuilder<ColumnName, ColumnMeta, JsType>;\n  /** Index signature for compatibility with AnyColumnBuilderBase */\n  readonly [key: string]: unknown;\n}\n\n/**\n * ExpressionBuilder represents the result of an operation (e.g., col.distance(...)).\n * Unlike ColumnBuilder (which represents a column), ExpressionBuilder represents\n * an operation expression and provides the same DSL methods for chaining.\n *\n * Implements ExpressionSource to provide type-safe conversion to OperationExpr.\n */\nexport interface ExpressionBuilder<JsType = unknown> extends ExpressionSource {\n  readonly kind: 'expression';\n  readonly expr: OperationExpr;\n  readonly columnMeta: StorageColumn;\n\n  // Methods accept ValueSource (ParamPlaceholder or ExpressionSource)\n  eq(value: ValueSource): AnyBinaryBuilder;\n  neq(value: ValueSource): AnyBinaryBuilder;\n  gt(value: ValueSource): AnyBinaryBuilder;\n  lt(value: ValueSource): AnyBinaryBuilder;\n  gte(value: ValueSource): AnyBinaryBuilder;\n  lte(value: ValueSource): AnyBinaryBuilder;\n  asc(): AnyOrderBuilder;\n  desc(): AnyOrderBuilder;\n\n  /** Converts this expression builder to the underlying OperationExpr */\n  toExpr(): OperationExpr;\n\n  // Helper property for type extraction (not used at runtime)\n  readonly __jsType: JsType;\n}\n\n// Helper aliases for usage sites where the specific column parameters are irrelevant\n// Accepts any ColumnBuilder regardless of its Operations parameter\n// Note: We use `any` here because TypeScript's variance rules don't allow us to express\n// \"any type that extends OperationTypes\" in a way that works for assignment.\n// Contract-specific OperationTypes (e.g., PgVectorOperationTypes) are not assignable\n// to the base OperationTypes in generic parameter position, even though they extend it structurally.\n// Helper type that accepts any ColumnBuilder regardless of its generic parameters\n// This is needed because conditional types in ColumnBuilder create incompatible intersection types\n// when Operations differs, even though structurally they're compatible\nexport type AnyColumnBuilderBase = {\n  readonly kind: 'column';\n  readonly table: string;\n  readonly column: string;\n  readonly columnMeta: StorageColumn;\n  // Methods accept ValueSource (ParamPlaceholder or ExpressionSource)\n  eq(value: ValueSource): AnyBinaryBuilder;\n  neq(value: ValueSource): AnyBinaryBuilder;\n  gt(value: ValueSource): AnyBinaryBuilder;\n  lt(value: ValueSource): AnyBinaryBuilder;\n  gte(value: ValueSource): AnyBinaryBuilder;\n  lte(value: ValueSource): AnyBinaryBuilder;\n  asc(): AnyOrderBuilder;\n  desc(): AnyOrderBuilder;\n  toExpr(): ColumnRef;\n  readonly __jsType: unknown;\n  // Optional nullable methods (present when columnMeta.nullable is true)\n  isNull?(): AnyUnaryBuilder;\n  isNotNull?(): AnyUnaryBuilder;\n  // Allow any operation methods (from conditional type)\n  readonly [key: string]: unknown;\n};\n\nexport type AnyColumnBuilder =\n  | ColumnBuilder<\n      string,\n      StorageColumn,\n      unknown,\n      // biome-ignore lint/suspicious/noExplicitAny: AnyColumnBuilder must accept column builders with any operation types\n      any\n    >\n  | AnyColumnBuilderBase;\n\n/**\n * Union type for any builder that can produce an Expression.\n * Used in DSL method signatures where either a column or operation result can be passed.\n */\nexport type AnyExpressionSource = AnyColumnBuilder | ExpressionBuilder;\n\nexport function isColumnBuilder(value: unknown): value is AnyColumnBuilder {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'kind' in value &&\n    (value as { kind: unknown }).kind === 'column'\n  );\n}\n\nexport interface JoinOnBuilder {\n  eqCol(left: AnyColumnBuilder, right: AnyColumnBuilder): JoinOnPredicate;\n}\n\nexport interface JoinOnPredicate {\n  readonly kind: 'join-on';\n  readonly left: AnyColumnBuilder;\n  readonly right: AnyColumnBuilder;\n}\n\nexport type Expr = ColumnRef | ParamRef;\n\n/**\n * Helper type to extract codec output type from CodecTypes.\n * Returns never if the codecId is not found in CodecTypes.\n */\ntype ExtractCodecOutputType<\n  CodecId extends string,\n  CodecTypes extends Record<string, { readonly output: unknown }>,\n> = CodecId extends keyof CodecTypes\n  ? CodecTypes[CodecId] extends { readonly output: infer Output }\n    ? Output\n    : never\n  : never;\n\n/**\n * Extracts the model name for a given table from the contract mappings.\n */\ntype ExtractTableToModel<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n> = Contract['mappings'] extends {\n  readonly tableToModel: infer TableToModel;\n}\n  ? TableToModel extends Record<string, string>\n    ? TableName extends keyof TableToModel\n      ? TableToModel[TableName]\n      : never\n    : never\n  : never;\n\n/**\n * Extracts the field name for a given table column from the contract mappings.\n */\ntype ExtractColumnToField<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n  ColumnName extends string,\n> = Contract['mappings'] extends {\n  readonly columnToField: infer ColumnToField;\n}\n  ? ColumnToField extends Record<string, Record<string, string>>\n    ? TableName extends keyof ColumnToField\n      ? ColumnName extends keyof ColumnToField[TableName]\n        ? ColumnToField[TableName][ColumnName]\n        : never\n      : never\n    : never\n  : never;\n\n/**\n * Extracts the field value type from a model's fields.\n */\ntype ExtractFieldValue<\n  Contract extends SqlContract<SqlStorage>,\n  ModelName extends string,\n  FieldName extends string,\n> = Contract['models'] extends infer Models\n  ? Models extends Record<string, unknown>\n    ? ModelName extends keyof Models\n      ? Models[ModelName] extends { readonly fields: infer Fields }\n        ? Fields extends Record<string, unknown>\n          ? FieldName extends keyof Fields\n            ? Fields[FieldName]\n            : never\n          : never\n        : never\n      : never\n    : never\n  : never;\n\n/**\n * Extracts the JavaScript type for a column from model mappings if available.\n * Returns `never` if the column maps to a ModelField object (which indicates\n * a relation that should fall through to codec-based type resolution).\n *\n * The check for ModelField uses `Exclude<keyof FieldValue, 'column'> extends never`\n * to ensure we only skip pure `{ column: string }` marker objects, not richer\n * object types that happen to include a `column` property.\n */\ntype ExtractColumnJsTypeFromModels<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n  ColumnName extends string,\n> = ExtractTableToModel<Contract, TableName> extends infer ModelName\n  ? ModelName extends string\n    ? ExtractColumnToField<Contract, TableName, ColumnName> extends infer FieldName\n      ? FieldName extends string\n        ? ExtractFieldValue<Contract, ModelName, FieldName> extends infer FieldValue\n          ? FieldValue extends { readonly column: string }\n            ? Exclude<keyof FieldValue, 'column'> extends never\n              ? never\n              : FieldValue\n            : FieldValue\n          : never\n        : never\n      : never\n    : never\n  : never;\n\n/**\n * Resolves type params for a column from either:\n * - inline `columnMeta.typeParams`, or\n * - `columnMeta.typeRef` (resolving into `contract.storage.types[typeRef].typeParams`).\n */\ntype ResolveColumnTypeParams<\n  Contract extends SqlContract<SqlStorage>,\n  ColumnMeta extends StorageColumn,\n> = ColumnMeta extends { typeParams: infer Params }\n  ? Params extends object\n    ? Params\n    : undefined\n  : ColumnMeta extends { typeRef: infer TypeRef extends string }\n    ? Contract['storage'] extends { types: infer Types }\n      ? Types extends Record<string, unknown>\n        ? TypeRef extends keyof Types\n          ? Types[TypeRef] extends { typeParams: infer Params }\n            ? Params extends object\n              ? Params\n              : undefined\n            : undefined\n          : undefined\n        : undefined\n      : undefined\n    : undefined;\n\n/**\n * If a codec entry exposes a type-level parameterized output surface, compute the output type\n * for a specific params object. Falls back to `never` if not supported.\n *\n * This enables lane typing to incorporate `columnMeta.typeParams` without branching on codec IDs\n * in core lane code.\n */\ntype ExtractParameterizedCodecOutputType<\n  CodecId extends string,\n  Params,\n  CodecTypes extends Record<string, { readonly output: unknown }>,\n> = CodecId extends keyof CodecTypes\n  ? CodecTypes[CodecId] extends { readonly parameterizedOutput: infer Fn }\n    ? Fn extends (params: Params) => infer Out\n      ? Out\n      : never\n    : never\n  : never;\n\n/**\n * Type-level operation signature.\n * Represents an operation at the type level, similar to OperationSignature at runtime.\n */\nexport type OperationTypeSignature = {\n  readonly args: ReadonlyArray<ArgSpec>;\n  readonly returns: ReturnSpec;\n  readonly lowering: SqlLoweringSpec;\n  readonly capabilities?: ReadonlyArray<string>;\n};\n\n/**\n * Type-level operation registry.\n * Maps typeId → operations, where operations is a record of method name → operation signature.\n *\n * Example:\n * ```typescript\n * type MyOperations: OperationTypes = {\n *   'pg/vector@1': {\n *     cosineDistance: {\n *       args: [{ kind: 'typeId'; type: 'pg/vector@1' }];\n *       returns: { kind: 'builtin'; type: 'number' };\n *       lowering: { targetFamily: 'sql'; strategy: 'function'; template: '...' };\n *     };\n *   };\n * };\n * ```\n */\nexport type OperationTypes = Record<string, Record<string, OperationTypeSignature>>;\n\n/**\n * CodecTypes represents a map of typeId to codec definitions.\n * Each codec definition must have an `output` property indicating the JavaScript type.\n *\n * Example:\n * ```typescript\n * type MyCodecTypes: CodecTypes = {\n *   'pg/int4@1': { output: number };\n *   'pg/text@1': { output: string };\n * };\n * ```\n */\nexport type CodecTypes = Record<string, { readonly output: unknown }>;\n\n/**\n * Extracts operations for a given typeId from the operation registry.\n * Returns an empty record if the typeId is not found.\n *\n * @example\n * ```typescript\n * type Ops = OperationsForTypeId<'pg/vector@1', MyOperations>;\n * // Ops = { cosineDistance: { ... }, l2Distance: { ... } }\n * ```\n */\nexport type OperationsForTypeId<\n  TypeId extends string,\n  Operations extends OperationTypes,\n> = Operations extends Record<string, never>\n  ? Record<string, never>\n  : TypeId extends keyof Operations\n    ? Operations[TypeId]\n    : Record<string, never>;\n\n/**\n * Maps operation signatures to method signatures on ColumnBuilder.\n * Each operation becomes a method that returns a ColumnBuilder or BinaryBuilder\n * based on the return type.\n */\ntype OperationMethods<\n  Ops extends Record<string, OperationTypeSignature>,\n  ColumnName extends string,\n  ColumnMeta extends StorageColumn,\n  JsType,\n> = {\n  [K in keyof Ops]: Ops[K] extends OperationTypeSignature\n    ? (\n        ...args: OperationArgs<Ops[K]['args']>\n      ) => OperationReturn<Ops[K]['returns'], ColumnName, ColumnMeta, JsType>\n    : never;\n};\n\n/**\n * Maps operation argument specs to TypeScript argument types.\n * - typeId args: ColumnBuilder (accepts base columns or operation results)\n * - param args: ParamPlaceholder\n * - literal args: unknown (could be more specific in future)\n */\ntype OperationArgs<Args extends ReadonlyArray<ArgSpec>> = Args extends readonly [\n  infer First,\n  ...infer Rest,\n]\n  ? First extends ArgSpec\n    ? [ArgToType<First>, ...(Rest extends ReadonlyArray<ArgSpec> ? OperationArgs<Rest> : [])]\n    : []\n  : [];\n\ntype ArgToType<Arg extends ArgSpec> = Arg extends { kind: 'typeId' }\n  ? AnyExpressionSource\n  : Arg extends { kind: 'param' }\n    ? ParamPlaceholder\n    : Arg extends { kind: 'literal' }\n      ? unknown\n      : never;\n\n/**\n * Maps operation return spec to return type.\n * Operations return ExpressionBuilder, not ColumnBuilder, because the result\n * represents an expression (OperationExpr) rather than a column reference.\n */\ntype OperationReturn<\n  Returns extends ReturnSpec,\n  _ColumnName extends string,\n  _ColumnMeta extends StorageColumn,\n  _JsType,\n> = Returns extends { kind: 'builtin'; type: infer T }\n  ? T extends 'number'\n    ? ExpressionBuilder<number>\n    : T extends 'boolean'\n      ? ExpressionBuilder<boolean>\n      : T extends 'string'\n        ? ExpressionBuilder<string>\n        : ExpressionBuilder<unknown>\n  : Returns extends { kind: 'typeId' }\n    ? ExpressionBuilder<unknown>\n    : ExpressionBuilder<unknown>;\n\n/**\n * Computes JavaScript type for a column at column creation time.\n *\n * Type inference:\n * - Read columnMeta.codecId as typeId string literal\n * - Look up CodecTypes[typeId].output\n * - Apply nullability: nullable ? Output | null : Output\n */\ntype ColumnMetaTypeId<ColumnMeta> = ColumnMeta extends { codecId: infer CodecId extends string }\n  ? CodecId\n  : ColumnMeta extends { type: infer TypeId extends string }\n    ? TypeId\n    : never;\n\nexport type ComputeColumnJsType<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n  ColumnName extends string,\n  ColumnMeta extends StorageColumn,\n  CodecTypes extends Record<string, { readonly output: unknown }>,\n> = ExtractColumnJsTypeFromModels<Contract, TableName, ColumnName> extends infer FromModels\n  ? [FromModels] extends [never]\n    ? ColumnMeta extends { nullable: infer Nullable }\n      ? ColumnMetaTypeId<ColumnMeta> extends infer TypeId\n        ? TypeId extends string\n          ? ResolveColumnTypeParams<Contract, ColumnMeta> extends infer Params\n            ? Params extends object\n              ? ExtractParameterizedCodecOutputType<\n                  TypeId,\n                  Params,\n                  CodecTypes\n                > extends infer ParamOutput\n                ? [ParamOutput] extends [never]\n                  ? ExtractCodecOutputType<TypeId, CodecTypes> extends infer CodecOutput\n                    ? [CodecOutput] extends [never]\n                      ? unknown // Codec not found in CodecTypes\n                      : Nullable extends true\n                        ? CodecOutput | null\n                        : CodecOutput\n                    : unknown\n                  : Nullable extends true\n                    ? ParamOutput | null\n                    : ParamOutput\n                : unknown\n              : ExtractCodecOutputType<TypeId, CodecTypes> extends infer CodecOutput\n                ? [CodecOutput] extends [never]\n                  ? unknown // Codec not found in CodecTypes\n                  : Nullable extends true\n                    ? CodecOutput | null\n                    : CodecOutput\n                : unknown\n            : unknown\n          : unknown\n        : unknown\n      : unknown\n    : FromModels\n  : unknown;\n\n/**\n * Infers Row type from a projection object.\n * Maps Record<string, ColumnBuilder> to Record<string, JSType>\n *\n * Extracts the pre-computed JsType from each ColumnBuilder in the projection.\n */\n/**\n * Extracts the inferred JsType carried by a ColumnBuilder.\n */\ntype ExtractJsTypeFromColumnBuilder<CB extends AnyColumnBuilder> =\n  CB extends ColumnBuilder<\n    infer _ColumnName extends string,\n    infer _ColumnMeta extends StorageColumn,\n    infer JsType,\n    infer _Ops\n  >\n    ? JsType\n    : never;\n\nexport type InferProjectionRow<P extends Record<string, AnyColumnBuilder>> = {\n  [K in keyof P]: ExtractJsTypeFromColumnBuilder<P[K]>;\n};\n\n/**\n * Nested projection type - allows recursive nesting of ColumnBuilder, ExpressionBuilder, or nested objects.\n */\nexport type NestedProjection = Record<\n  string,\n  | AnyExpressionSource\n  | Record<\n      string,\n      | AnyExpressionSource\n      | Record<\n          string,\n          | AnyExpressionSource\n          | Record<string, AnyExpressionSource | Record<string, AnyExpressionSource>>\n        >\n    >\n>;\n\n/**\n * Helper type to extract include type from Includes map.\n * Returns the value type if K is a key of Includes, otherwise returns unknown.\n */\ntype ExtractIncludeType<\n  K extends string,\n  Includes extends Record<string, unknown>,\n> = K extends keyof Includes ? Includes[K] : unknown;\n\n/**\n * Infers Row type from a nested projection object.\n * Recursively maps Record<string, ColumnBuilder | boolean | NestedProjection> to nested object types.\n *\n * Extracts the pre-computed JsType from each ColumnBuilder at leaves.\n * When a value is `true`, it represents an include reference and infers `Array<ChildShape>`\n * by looking up the include alias in the Includes type map.\n */\nexport type InferNestedProjectionRow<\n  P extends Record<string, AnyExpressionSource | boolean | NestedProjection>,\n  CodecTypes extends Record<string, { readonly output: unknown }> = Record<string, never>,\n  Includes extends Record<string, unknown> = Record<string, never>,\n> = {\n  [K in keyof P]: P[K] extends ExpressionBuilder<infer JsType>\n    ? JsType\n    : P[K] extends AnyColumnBuilder\n      ? ExtractJsTypeFromColumnBuilder<P[K]>\n      : P[K] extends true\n        ? Array<ExtractIncludeType<K & string, Includes>> // Include reference - infers Array<ChildShape> from Includes map\n        : P[K] extends NestedProjection\n          ? InferNestedProjectionRow<P[K], CodecTypes, Includes>\n          : never;\n};\n\n/**\n * Infers Row type from a tuple of ColumnBuilders used in returning() clause.\n * Extracts column name and JsType from each ColumnBuilder and creates a Record.\n */\nexport type InferReturningRow<Columns extends readonly AnyColumnBuilder[]> =\n  Columns extends readonly [infer First, ...infer Rest]\n    ? First extends ColumnBuilder<\n        infer Name,\n        infer _Meta,\n        infer JsType,\n        infer _Ops extends OperationTypes\n      >\n      ? Name extends string\n        ? Rest extends readonly AnyColumnBuilder[]\n          ? { [K in Name]: JsType } & InferReturningRow<Rest>\n          : { [K in Name]: JsType }\n        : never\n      : never\n    : Record<string, never>;\n\n/**\n * Utility type to check if a contract has the required capabilities for includeMany.\n * Requires both `lateral` and `jsonAgg` to be `true` in the contract's capabilities for the target.\n * Capabilities are nested by target: `{ [target]: { lateral: true, jsonAgg: true } }`\n */\nexport type HasIncludeManyCapabilities<TContract extends SqlContract<SqlStorage>> =\n  TContract extends { capabilities: infer C; target: infer T }\n    ? T extends string\n      ? C extends Record<string, Record<string, boolean>>\n        ? C extends { [K in T]: infer TargetCaps }\n          ? TargetCaps extends { lateral: true; jsonAgg: true }\n            ? true\n            : false\n          : false\n        : false\n      : false\n    : false;\n\n/**\n * SQL-specific Plan type that refines the ast field to use QueryAst.\n * This is the type used by SQL query builders.\n */\nexport type SqlPlan<Row = unknown> = ExecutionPlan<Row, QueryAst>;\n\n/**\n * Helper types for extracting contract structure.\n */\nexport type TablesOf<TContract> = TContract extends {\n  storage: { tables: infer U };\n}\n  ? U\n  : never;\n\nexport type TableKey<TContract> = Extract<keyof TablesOf<TContract>, string>;\n\n// Common types for contract.d.ts generation (SQL-specific)\n// These types are used by emitted contract.d.ts files to provide type-safe DSL/ORM types\n\n/**\n * Unique symbol for metadata property to avoid collisions with user-defined properties\n */\nexport declare const META: unique symbol;\n\n/**\n * Extracts metadata from a type that has a META property\n */\nexport type Meta<T extends { [META]: unknown }> = T[typeof META];\n\n/**\n * Metadata interface for table definitions\n */\nexport interface TableMetadata<Name extends string> {\n  name: Name;\n}\n\n/**\n * Metadata interface for model definitions\n */\nexport interface ModelMetadata<Name extends string> {\n  name: Name;\n}\n\n/**\n * Base interface for table definitions with metadata\n * Used in contract.d.ts to define storage-level table types\n */\nexport interface TableDef<Name extends string> {\n  readonly [META]: TableMetadata<Name>;\n}\n\n/**\n * Base interface for model definitions with metadata\n * Used in contract.d.ts to define application-level model types\n */\nexport interface ModelDef<Name extends string> {\n  readonly [META]: ModelMetadata<Name>;\n}\n\nexport type ColumnsOf<\n  TContract,\n  K extends TableKey<TContract>,\n> = K extends keyof TablesOf<TContract>\n  ? TablesOf<TContract>[K] extends { columns: infer C }\n    ? C\n    : never\n  : never;\n\nexport interface RawTemplateOptions {\n  readonly refs?: PlanRefs;\n  readonly annotations?: Record<string, unknown>;\n  readonly projection?: ReadonlyArray<string>;\n}\n\nexport interface RawFunctionOptions extends RawTemplateOptions {\n  readonly params: ReadonlyArray<unknown>;\n}\n\nexport type RawTemplateFactory = (\n  strings: TemplateStringsArray,\n  ...values: readonly unknown[]\n) => ExecutionPlan;\n\nexport interface RawFactory extends RawTemplateFactory {\n  (text: string, options: RawFunctionOptions): ExecutionPlan;\n  with(options: RawTemplateOptions): RawTemplateFactory;\n}\n\nexport type { RuntimeError } from '@prisma-next/plan';\n\nexport interface BuildParamsMap {\n  readonly [name: string]: unknown;\n}\n\nexport interface BuildOptions {\n  readonly params?: BuildParamsMap;\n}\n\nexport interface SqlBuilderOptions<\n  TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>,\n> {\n  readonly context: ExecutionContext<TContract>;\n}\n\n/**\n * SQL-specific ResultType that works with both Plan and SqlQueryPlan.\n * This extends the core ResultType to also handle SqlQueryPlan.\n * Example: `type Row = ResultType<typeof plan>`\n */\nexport type ResultType<P> = P extends SqlQueryPlan<infer R> ? R : CoreResultType<P>;\n"],"mappings":";;;;AA+CA,SAAgB,mBACd,MACA,KACiB;AACjB,QAAO;EAAE,MAAM;EAAS;EAAM;EAAK;;AAkLrC,SAAgB,gBAAgB,OAA2C;AACzE,QACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS"}

package/package.json

@@ -1,23 +1,26 @@
 {
   "name": "@prisma-next/sql-relational-core",
-  "version": "0.3.0-dev.6",
+  "version": "0.3.0-dev.63",
   "type": "module",
   "sideEffects": false,
   "description": "Schema and column builders, operation attachment, and AST types for Prisma Next",
   "dependencies": {
+    "arktype": "^2.1.29",
     "ts-toolbelt": "^9.6.0",
-    "@prisma-next/contract": "0.3.0-dev.6",
-    "@prisma-next/operations": "0.3.0-dev.6",
-    "@prisma-next/plan": "0.3.0-dev.6",
-    "@prisma-next/sql-contract": "0.3.0-dev.6",
-    "@prisma-next/sql-operations": "0.3.0-dev.6"
+    "@prisma-next/contract": "0.3.0-dev.63",
+    "@prisma-next/operations": "0.3.0-dev.63",
+    "@prisma-next/plan": "0.3.0-dev.63",
+    "@prisma-next/sql-contract": "0.3.0-dev.63",
+    "@prisma-next/sql-operations": "0.3.0-dev.63",
+    "@prisma-next/utils": "0.3.0-dev.63"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "4.0.16",
-    "tsup": "8.5.1",
+    "tsdown": "0.18.4",
     "typescript": "5.9.3",
-    "vitest": "4.0.16",
-    "@prisma-next/sql-contract-ts": "0.3.0-dev.6",
+    "vitest": "4.0.17",
+    "@prisma-next/sql-contract-ts": "0.3.0-dev.63",
+    "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/tsdown": "0.0.0",
     "@prisma-next/test-utils": "0.0.1"
   },
   "files": [
@@ -25,55 +28,35 @@
     "src"
   ],
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    },
-    "./schema": {
-      "types": "./dist/exports/schema.d.ts",
-      "import": "./dist/exports/schema.js"
-    },
-    "./param": {
-      "types": "./dist/exports/param.d.ts",
-      "import": "./dist/exports/param.js"
-    },
-    "./types": {
-      "types": "./dist/exports/types.d.ts",
-      "import": "./dist/exports/types.js"
-    },
-    "./operations-registry": {
-      "types": "./dist/exports/operations-registry.d.ts",
-      "import": "./dist/exports/operations-registry.js"
-    },
-    "./errors": {
-      "types": "./dist/exports/errors.d.ts",
-      "import": "./dist/exports/errors.js"
-    },
-    "./ast": {
-      "types": "./dist/exports/ast.d.ts",
-      "import": "./dist/exports/ast.js"
-    },
-    "./plan": {
-      "types": "./dist/exports/plan.d.ts",
-      "import": "./dist/exports/plan.js"
-    },
-    "./query-lane-context": {
-      "types": "./dist/exports/query-lane-context.d.ts",
-      "import": "./dist/exports/query-lane-context.js"
-    },
-    "./utils/guards": {
-      "types": "./dist/exports/guards.d.ts",
-      "import": "./dist/exports/guards.js"
-    }
+    ".": "./dist/index.mjs",
+    "./ast": "./dist/exports/ast.mjs",
+    "./errors": "./dist/exports/errors.mjs",
+    "./guards": "./dist/exports/guards.mjs",
+    "./operations-registry": "./dist/exports/operations-registry.mjs",
+    "./param": "./dist/exports/param.mjs",
+    "./plan": "./dist/exports/plan.mjs",
+    "./query-lane-context": "./dist/exports/query-lane-context.mjs",
+    "./schema": "./dist/exports/schema.mjs",
+    "./types": "./dist/exports/types.mjs",
+    "./utils/guards": "./dist/exports/utils/guards.mjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma-next.git",
+    "directory": "packages/2-sql/4-lanes/relational-core"
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
+    "build": "tsdown",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc --project tsconfig.json --noEmit",
-    "lint": "biome check . --config-path ../../../../biome.json --error-on-warnings",
-    "lint:fix": "biome check --write . --config-path ../../../../biome.json",
-    "lint:fix:unsafe": "biome check --write --unsafe . --config-path ../../../../biome.json",
-    "clean": "node ../../../../scripts/clean.mjs"
+    "lint": "biome check . --error-on-warnings",
+    "lint:fix": "biome check --write .",
+    "lint:fix:unsafe": "biome check --write --unsafe .",
+    "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
   }
 }

package/src/ast/codec-types.ts

@@ -1,5 +1,32 @@
+import { ifDefined } from '@prisma-next/utils/defined';
+import type { Type } from 'arktype';
 import type { O } from 'ts-toolbelt';
 
+/**
+ * Descriptor for parameterized codecs that require type parameter validation.
+ * Shared between adapter (compile-time) and runtime layers to avoid duplication.
+ *
+ * @template TParams - The shape of the type parameters (e.g., `{ length: number }`)
+ * @template THelper - The type returned by the optional `init` hook
+ */
+export interface CodecParamsDescriptor<TParams = Record<string, unknown>, THelper = unknown> {
+  /** The codec ID this descriptor applies to (e.g., 'pg/vector@1') */
+  readonly codecId: string;
+
+  /**
+   * Arktype schema for validating typeParams.
+   * Used to validate both storage.types entries and inline column typeParams.
+   */
+  readonly paramsSchema: Type<TParams>;
+
+  /**
+   * Optional init hook called during runtime context creation.
+   * Receives validated params and returns a helper object to be stored in context.types.
+   * If not provided, the validated params are stored directly.
+   */
+  readonly init?: (params: TParams) => THelper;
+}
+
 /**
  * Codec metadata for database-specific type information.
  * Used for schema introspection and verification.
@@ -20,7 +47,13 @@ export interface CodecMeta {
  * Codecs are pure, synchronous functions with no side effects or IO.
  * They provide deterministic conversion between database wire types and JS values.
  */
-export interface Codec<Id extends string = string, TWire = unknown, TJs = unknown> {
+export interface Codec<
+  Id extends string = string,
+  TWire = unknown,
+  TJs = unknown,
+  TParams = Record<string, unknown>,
+  THelper = unknown,
+> {
   /**
    * Namespaced codec identifier in format 'namespace/name@version'
    * Examples: 'pg/text@1', 'pg/uuid@1', 'pg/timestamptz@1'
@@ -39,6 +72,31 @@ export interface Codec<Id extends string = string, TWire = unknown, TJs = unknow
    */
   readonly meta?: CodecMeta;
 
+  /**
+   * Optional params schema for parameterized codecs.
+   * If provided, typeParams are validated against this schema.
+   */
+  readonly paramsSchema?: Type<TParams>;
+
+  /**
+   * Optional init hook for building runtime helper state from validated params.
+   *
+   * Useful when parameterized types need derived data at runtime, for example:
+   * - normalize typeParams into a stable helper shape consumed by lanes/adapters
+   * - precompute reusable values once during context creation
+   * - avoid repeating typeParams parsing logic during query execution
+   *
+   * Example:
+   *   { length: 255 } -> { kind: 'variable', maxLength: 255 }
+   *
+   * **Convention for JSON/JSONB codecs**: When the helper includes a `validate`
+   * property of type `JsonSchemaValidateFn`, the runtime will use it to enforce
+   * JSON Schema conformance during encoding and decoding. The property is
+   * discovered via duck typing (`helper?.validate`) for flexibility across
+   * different codec types.
+   */
+  readonly init?: (params: TParams) => THelper;
+
   /**
    * Decode a wire value (from database) to JavaScript type.
    * Must be synchronous and pure (no side effects).
@@ -157,17 +215,27 @@ class CodecRegistryImpl implements CodecRegistry {
 /**
  * Codec factory - creates a codec with typeId and encode/decode functions.
  */
-export function codec<Id extends string, TWire, TJs>(config: {
+export function codec<
+  Id extends string,
+  TWire,
+  TJs,
+  TParams = Record<string, unknown>,
+  THelper = unknown,
+>(config: {
   typeId: Id;
   targetTypes: readonly string[];
   encode: (value: TJs) => TWire;
   decode: (wire: TWire) => TJs;
   meta?: CodecMeta;
-}): Codec<Id, TWire, TJs> {
+  paramsSchema?: Type<TParams>;
+  init?: (params: TParams) => THelper;
+}): Codec<Id, TWire, TJs, TParams, THelper> {
   return {
     id: config.typeId,
     targetTypes: config.targetTypes,
-    ...(config.meta ? { meta: config.meta } : {}),
+    ...ifDefined('meta', config.meta),
+    ...ifDefined('paramsSchema', config.paramsSchema),
+    ...ifDefined('init', config.init),
     encode: config.encode,
     decode: config.decode,
   };
@@ -176,11 +244,12 @@ export function codec<Id extends string, TWire, TJs>(config: {
 /**
  * Type helpers to extract codec types.
  */
-export type CodecId<T> = T extends Codec<infer Id, unknown, unknown>
-  ? Id
-  : T extends { readonly id: infer Id }
+export type CodecId<T> =
+  T extends Codec<infer Id, unknown, unknown>
     ? Id
-    : never;
+    : T extends { readonly id: infer Id }
+      ? Id
+      : never;
 export type CodecInput<T> = T extends Codec<string, unknown, infer JsT> ? JsT : never;
 export type CodecOutput<T> = T extends Codec<string, unknown, infer JsT> ? JsT : never;
 

package/src/ast/delete.ts

@@ -1,9 +1,9 @@
-import type { BinaryExpr, ColumnRef, DeleteAst, TableRef } from './types';
+import type { ColumnRef, DeleteAst, TableRef, WhereExpr } from './types';
 import { compact } from './util';
 
 export interface CreateDeleteAstOptions {
   readonly table: TableRef;
-  readonly where: BinaryExpr;
+  readonly where: WhereExpr;
   readonly returning?: ReadonlyArray<ColumnRef>;
 }
 

package/src/ast/driver-types.ts

@@ -13,13 +13,30 @@ export interface SqlExplainResult<Row = Record<string, unknown>> {
   readonly rows: ReadonlyArray<Row>;
 }
 
-export interface SqlDriver {
-  connect(): Promise<void>;
+export type SqlDriverState = 'unbound' | 'connected' | 'closed';
+
+export interface SqlDriver<TBinding = void> extends SqlQueryable {
+  readonly state?: SqlDriverState;
+  connect(binding: TBinding): Promise<void>;
+  acquireConnection(): Promise<SqlConnection>;
+  close(): Promise<void>;
+}
+
+export interface SqlConnection extends SqlQueryable {
+  beginTransaction(): Promise<SqlTransaction>;
+  release(): Promise<void>;
+}
+
+export interface SqlTransaction extends SqlQueryable {
+  commit(): Promise<void>;
+  rollback(): Promise<void>;
+}
+
+export interface SqlQueryable {
   execute<Row = Record<string, unknown>>(request: SqlExecuteRequest): AsyncIterable<Row>;
   explain?(request: SqlExecuteRequest): Promise<SqlExplainResult>;
   query<Row = Record<string, unknown>>(
     sql: string,
     params?: readonly unknown[],
   ): Promise<SqlQueryResult<Row>>;
-  close(): Promise<void>;
 }

package/src/ast/predicate.ts

@@ -1,17 +1,19 @@
 import type {
   BinaryExpr,
   BinaryOp,
-  ColumnRef,
   ExistsExpr,
-  OperationExpr,
+  Expression,
+  ListLiteralExpr,
+  LiteralExpr,
+  NullCheckExpr,
   ParamRef,
   SelectAst,
 } from './types';
 
 export function createBinaryExpr(
   op: BinaryOp,
-  left: ColumnRef | OperationExpr,
-  right: ColumnRef | ParamRef,
+  left: Expression,
+  right: Expression | ParamRef | LiteralExpr | ListLiteralExpr,
 ): BinaryExpr {
   return {
     kind: 'bin',
@@ -28,3 +30,11 @@ export function createExistsExpr(not: boolean, subquery: SelectAst): ExistsExpr
     subquery,
   };
 }
+
+export function createNullCheckExpr(expr: Expression, isNull: boolean): NullCheckExpr {
+  return {
+    kind: 'nullCheck',
+    expr,
+    isNull,
+  };
+}

package/src/ast/select.ts

@@ -1,14 +1,13 @@
 import type {
-  BinaryExpr,
   ColumnRef,
   Direction,
-  ExistsExpr,
   IncludeAst,
   IncludeRef,
   JoinAst,
   OperationExpr,
   SelectAst,
   TableRef,
+  WhereExpr,
 } from './types';
 import { compact } from './util';
 
@@ -20,9 +19,10 @@ export interface CreateSelectAstOptions {
     alias: string;
     expr: ColumnRef | IncludeRef | OperationExpr;
   }>;
-  readonly where?: BinaryExpr | ExistsExpr;
+  readonly where?: WhereExpr;
   readonly orderBy?: ReadonlyArray<{ expr: ColumnRef | OperationExpr; dir: Direction }>;
   readonly limit?: number;
+  readonly selectAllIntent?: { table?: string };
 }
 
 export function createSelectAst(options: CreateSelectAstOptions): SelectAst {
@@ -35,5 +35,6 @@ export function createSelectAst(options: CreateSelectAstOptions): SelectAst {
     where: options.where,
     orderBy: options.orderBy,
     limit: options.limit,
+    selectAllIntent: options.selectAllIntent,
   }) as SelectAst;
 }

package/src/ast/sql-codecs.ts

@@ -0,0 +1,67 @@
+import { type as arktype } from 'arktype';
+import { codec, defineCodecs } from './codec-types';
+
+export const SQL_CHAR_CODEC_ID = 'sql/char@1' as const;
+export const SQL_VARCHAR_CODEC_ID = 'sql/varchar@1' as const;
+export const SQL_INT_CODEC_ID = 'sql/int@1' as const;
+export const SQL_FLOAT_CODEC_ID = 'sql/float@1' as const;
+
+const lengthParamsSchema = arktype({
+  length: 'number.integer > 0',
+});
+
+type LengthTypeHelper = {
+  readonly kind: 'fixed' | 'variable';
+  readonly maxLength: number;
+};
+
+function createLengthTypeHelper(
+  kind: LengthTypeHelper['kind'],
+): (params: Record<string, unknown>) => LengthTypeHelper {
+  return (params) => ({
+    kind,
+    maxLength: params['length'] as number,
+  });
+}
+
+const sqlCharCodec = codec<typeof SQL_CHAR_CODEC_ID, string, string>({
+  typeId: SQL_CHAR_CODEC_ID,
+  targetTypes: ['char'],
+  encode: (value: string): string => value,
+  decode: (wire: string): string => wire.trimEnd(),
+  paramsSchema: lengthParamsSchema,
+  init: createLengthTypeHelper('fixed'),
+});
+
+const sqlVarcharCodec = codec<typeof SQL_VARCHAR_CODEC_ID, string, string>({
+  typeId: SQL_VARCHAR_CODEC_ID,
+  targetTypes: ['varchar'],
+  encode: (value: string): string => value,
+  decode: (wire: string): string => wire,
+  paramsSchema: lengthParamsSchema,
+  init: createLengthTypeHelper('variable'),
+});
+
+const sqlIntCodec = codec<typeof SQL_INT_CODEC_ID, number, number>({
+  typeId: SQL_INT_CODEC_ID,
+  targetTypes: ['int'],
+  encode: (value) => value,
+  decode: (wire) => wire,
+});
+
+const sqlFloatCodec = codec<typeof SQL_FLOAT_CODEC_ID, number, number>({
+  typeId: SQL_FLOAT_CODEC_ID,
+  targetTypes: ['float'],
+  encode: (value) => value,
+  decode: (wire) => wire,
+});
+
+const codecs = defineCodecs()
+  .add('char', sqlCharCodec)
+  .add('varchar', sqlVarcharCodec)
+  .add('int', sqlIntCodec)
+  .add('float', sqlFloatCodec);
+
+export const sqlCodecDefinitions = codecs.codecDefinitions;
+export const sqlDataTypes = codecs.dataTypes;
+export type SqlCodecTypes = typeof codecs.CodecTypes;

package/src/ast/types.ts

@@ -1,3 +1,4 @@
+import type { ParamDescriptor } from '@prisma-next/contract/types';
 import type { ReturnSpec } from '@prisma-next/operations';
 import type { SqlLoweringSpec } from '@prisma-next/sql-operations';
 
@@ -32,23 +33,62 @@ export interface OperationExpr {
   readonly kind: 'operation';
   readonly method: string;
   readonly forTypeId: string;
-  readonly self: ColumnRef | OperationExpr;
-  readonly args: ReadonlyArray<ColumnRef | ParamRef | LiteralExpr | OperationExpr>;
+  readonly self: Expression;
+  readonly args: ReadonlyArray<Expression | ParamRef | LiteralExpr>;
   readonly returns: ReturnSpec;
   readonly lowering: SqlLoweringSpec;
 }
 
-export function isOperationExpr(expr: ColumnRef | OperationExpr): expr is OperationExpr {
+/**
+ * Unified expression type - the canonical AST representation for column references
+ * and operation expressions. This is what all builders convert to via toExpr().
+ */
+export type Expression = ColumnRef | OperationExpr;
+
+/**
+ * Interface for any builder that can produce an Expression.
+ * Implemented by ColumnBuilder and ExpressionBuilder.
+ */
+export interface ExpressionSource {
+  toExpr(): Expression;
+}
+
+export function isOperationExpr(expr: Expression): expr is OperationExpr {
   return expr.kind === 'operation';
 }
 
-export type BinaryOp = 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte';
+export type BinaryOp =
+  | 'eq'
+  | 'neq'
+  | 'gt'
+  | 'lt'
+  | 'gte'
+  | 'lte'
+  | 'like'
+  | 'ilike'
+  | 'in'
+  | 'notIn';
 
 export interface BinaryExpr {
   readonly kind: 'bin';
   readonly op: BinaryOp;
-  readonly left: ColumnRef | OperationExpr;
-  readonly right: ColumnRef | ParamRef;
+  readonly left: Expression;
+  readonly right: Expression | ParamRef | LiteralExpr | ListLiteralExpr;
+}
+
+export interface ListLiteralExpr {
+  readonly kind: 'listLiteral';
+  readonly values: ReadonlyArray<ParamRef | LiteralExpr>;
+}
+
+export interface AndExpr {
+  readonly kind: 'and';
+  readonly exprs: ReadonlyArray<WhereExpr>;
+}
+
+export interface OrExpr {
+  readonly kind: 'or';
+  readonly exprs: ReadonlyArray<WhereExpr>;
 }
 
 export interface ExistsExpr {
@@ -57,11 +97,40 @@ export interface ExistsExpr {
   readonly subquery: SelectAst;
 }
 
-export type JoinOnExpr = {
-  readonly kind: 'eqCol';
-  readonly left: ColumnRef;
-  readonly right: ColumnRef;
-};
+/**
+ * Unary expression for IS NULL / IS NOT NULL checks.
+ * Used in WHERE clauses to check for null values.
+ */
+export interface NullCheckExpr {
+  readonly kind: 'nullCheck';
+  readonly expr: Expression;
+  readonly isNull: boolean;
+}
+
+/**
+ * Union type for WHERE clause expressions.
+ */
+export type WhereExpr = BinaryExpr | ExistsExpr | NullCheckExpr | AndExpr | OrExpr;
+
+export interface BoundWhereExpr {
+  readonly expr: WhereExpr;
+  readonly params: readonly unknown[];
+  readonly paramDescriptors: ReadonlyArray<ParamDescriptor>;
+}
+
+export interface ToWhereExpr {
+  toWhereExpr(): BoundWhereExpr;
+}
+
+export type WhereArg = WhereExpr | ToWhereExpr;
+
+export type JoinOnExpr =
+  | {
+      readonly kind: 'eqCol';
+      readonly left: ColumnRef;
+      readonly right: ColumnRef;
+    }
+  | WhereExpr;
 
 export interface JoinAst {
   readonly kind: 'join';
@@ -81,10 +150,10 @@ export interface IncludeAst {
   readonly child: {
     readonly table: TableRef;
     readonly on: JoinOnExpr;
-    readonly where?: BinaryExpr | ExistsExpr;
-    readonly orderBy?: ReadonlyArray<{ expr: ColumnRef | OperationExpr; dir: Direction }>;
+    readonly where?: WhereExpr;
+    readonly orderBy?: ReadonlyArray<{ expr: Expression; dir: Direction }>;
     readonly limit?: number;
-    readonly project: ReadonlyArray<{ alias: string; expr: ColumnRef | OperationExpr }>;
+    readonly project: ReadonlyArray<{ alias: string; expr: Expression }>;
   };
 }
 
@@ -95,11 +164,12 @@ export interface SelectAst {
   readonly includes?: ReadonlyArray<IncludeAst>;
   readonly project: ReadonlyArray<{
     alias: string;
-    expr: ColumnRef | IncludeRef | OperationExpr | LiteralExpr;
+    expr: Expression | IncludeRef | LiteralExpr;
   }>;
-  readonly where?: BinaryExpr | ExistsExpr;
-  readonly orderBy?: ReadonlyArray<{ expr: ColumnRef | OperationExpr; dir: Direction }>;
+  readonly where?: WhereExpr;
+  readonly orderBy?: ReadonlyArray<{ expr: Expression; dir: Direction }>;
   readonly limit?: number;
+  readonly selectAllIntent?: { table?: string };
 }
 
 export interface InsertAst {
@@ -113,14 +183,14 @@ export interface UpdateAst {
   readonly kind: 'update';
   readonly table: TableRef;
   readonly set: Record<string, ColumnRef | ParamRef>;
-  readonly where: BinaryExpr;
+  readonly where?: WhereExpr;
   readonly returning?: ReadonlyArray<ColumnRef>;
 }
 
 export interface DeleteAst {
   readonly kind: 'delete';
   readonly table: TableRef;
-  readonly where: BinaryExpr;
+  readonly where?: WhereExpr;
   readonly returning?: ReadonlyArray<ColumnRef>;
 }