@prisma-next/sql-relational-core 0.3.0-pr.95.1 → 0.3.0-pr.96.1

package/src/types.ts

@@ -10,8 +10,6 @@ import type {
   BinaryOp,
   ColumnRef,
   Direction,
-  Expression,
-  ExpressionSource,
   OperationExpr,
   ParamRef,
   QueryAst,
@@ -24,21 +22,13 @@ export interface ParamPlaceholder {
   readonly name: string;
 }
 
-/**
- * ValueSource represents any value that can appear in a comparison or as an argument.
- * This includes:
- * - ParamPlaceholder: A parameter placeholder (e.g., `param('userId')`)
- * - ExpressionSource: Something that can be converted to an Expression (ColumnBuilder, ExpressionBuilder)
- */
-export type ValueSource = ParamPlaceholder | ExpressionSource;
-
 export interface OrderBuilder<
-  _ColumnName extends string = string,
-  _ColumnMeta extends StorageColumn = StorageColumn,
-  _JsType = unknown,
+  ColumnName extends string = string,
+  ColumnMeta extends StorageColumn = StorageColumn,
+  JsType = unknown,
 > {
   readonly kind: 'order';
-  readonly expr: Expression;
+  readonly expr: ColumnBuilder<ColumnName, ColumnMeta, JsType> | OperationExpr;
   readonly dir: Direction;
 }
 
@@ -55,7 +45,6 @@ export function createOrderBuilder(
 /**
  * ColumnBuilder with optional operation methods based on the column's typeId.
  * When Operations is provided and the column's typeId matches, operation methods are included.
- * Implements ExpressionSource to provide type-safe conversion to ColumnRef.
  */
 export type ColumnBuilder<
   ColumnName extends string = string,
@@ -67,17 +56,20 @@ export type ColumnBuilder<
   readonly table: string;
   readonly column: ColumnName;
   readonly columnMeta: ColumnMeta;
-  // Methods accept ValueSource (ParamPlaceholder or ExpressionSource)
-  eq(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-  neq(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-  gt(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-  lt(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-  gte(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-  lte(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
+  eq(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
+  neq(
+    value: ParamPlaceholder | AnyColumnBuilderBase,
+  ): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
+  gt(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
+  lt(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
+  gte(
+    value: ParamPlaceholder | AnyColumnBuilderBase,
+  ): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
+  lte(
+    value: ParamPlaceholder | AnyColumnBuilderBase,
+  ): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
   asc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;
   desc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;
-  /** Converts this column builder to a ColumnRef expression */
-  toExpr(): ColumnRef;
   // Helper property for type extraction (not used at runtime)
   readonly __jsType: JsType;
 } & (ColumnMeta['codecId'] extends string
@@ -92,47 +84,14 @@ export type ColumnBuilder<
   : Record<string, never>);
 
 export interface BinaryBuilder<
-  _ColumnName extends string = string,
-  _ColumnMeta extends StorageColumn = StorageColumn,
-  _JsType = unknown,
+  ColumnName extends string = string,
+  ColumnMeta extends StorageColumn = StorageColumn,
+  JsType = unknown,
 > {
   readonly kind: 'binary';
   readonly op: BinaryOp;
-  readonly left: Expression;
-  readonly right: ValueSource;
-}
-
-// Forward declare AnyBinaryBuilder and AnyOrderBuilder for use in ExpressionBuilder
-export type AnyBinaryBuilder = BinaryBuilder;
-export type AnyOrderBuilder = OrderBuilder;
-
-/**
- * ExpressionBuilder represents the result of an operation (e.g., col.distance(...)).
- * Unlike ColumnBuilder (which represents a column), ExpressionBuilder represents
- * an operation expression and provides the same DSL methods for chaining.
- *
- * Implements ExpressionSource to provide type-safe conversion to OperationExpr.
- */
-export interface ExpressionBuilder<JsType = unknown> extends ExpressionSource {
-  readonly kind: 'expression';
-  readonly expr: OperationExpr;
-  readonly columnMeta: StorageColumn;
-
-  // Methods accept ValueSource (ParamPlaceholder or ExpressionSource)
-  eq(value: ValueSource): AnyBinaryBuilder;
-  neq(value: ValueSource): AnyBinaryBuilder;
-  gt(value: ValueSource): AnyBinaryBuilder;
-  lt(value: ValueSource): AnyBinaryBuilder;
-  gte(value: ValueSource): AnyBinaryBuilder;
-  lte(value: ValueSource): AnyBinaryBuilder;
-  asc(): AnyOrderBuilder;
-  desc(): AnyOrderBuilder;
-
-  /** Converts this expression builder to the underlying OperationExpr */
-  toExpr(): OperationExpr;
-
-  // Helper property for type extraction (not used at runtime)
-  readonly __jsType: JsType;
+  readonly left: ColumnBuilder<ColumnName, ColumnMeta, JsType> | OperationExpr;
+  readonly right: ParamPlaceholder | AnyColumnBuilderBase;
 }
 
 // Helper aliases for usage sites where the specific column parameters are irrelevant
@@ -149,16 +108,14 @@ export type AnyColumnBuilderBase = {
   readonly table: string;
   readonly column: string;
   readonly columnMeta: StorageColumn;
-  // Methods accept ValueSource (ParamPlaceholder or ExpressionSource)
-  eq(value: ValueSource): AnyBinaryBuilder;
-  neq(value: ValueSource): AnyBinaryBuilder;
-  gt(value: ValueSource): AnyBinaryBuilder;
-  lt(value: ValueSource): AnyBinaryBuilder;
-  gte(value: ValueSource): AnyBinaryBuilder;
-  lte(value: ValueSource): AnyBinaryBuilder;
+  eq(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
+  neq(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
+  gt(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
+  lt(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
+  gte(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
+  lte(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
   asc(): AnyOrderBuilder;
   desc(): AnyOrderBuilder;
-  toExpr(): ColumnRef;
   readonly __jsType: unknown;
   // Allow any operation methods (from conditional type)
   readonly [key: string]: unknown;
@@ -173,12 +130,8 @@ export type AnyColumnBuilder =
       any
     >
   | AnyColumnBuilderBase;
-
-/**
- * Union type for any builder that can produce an Expression.
- * Used in DSL method signatures where either a column or operation result can be passed.
- */
-export type AnyExpressionSource = AnyColumnBuilder | ExpressionBuilder;
+export type AnyBinaryBuilder = BinaryBuilder<string, StorageColumn, unknown>;
+export type AnyOrderBuilder = OrderBuilder<string, StorageColumn, unknown>;
 
 export function isColumnBuilder(value: unknown): value is AnyColumnBuilder {
   return (
@@ -311,7 +264,7 @@ type OperationArgs<Args extends ReadonlyArray<ArgSpec>> = Args extends readonly
   : [];
 
 type ArgToType<Arg extends ArgSpec> = Arg extends { kind: 'typeId' }
-  ? AnyExpressionSource
+  ? AnyColumnBuilder
   : Arg extends { kind: 'param' }
     ? ParamPlaceholder
     : Arg extends { kind: 'literal' }
@@ -320,25 +273,25 @@ type ArgToType<Arg extends ArgSpec> = Arg extends { kind: 'typeId' }
 
 /**
  * Maps operation return spec to return type.
- * Operations return ExpressionBuilder, not ColumnBuilder, because the result
- * represents an expression (OperationExpr) rather than a column reference.
+ * - builtin types: ColumnBuilder with appropriate JsType (matches runtime behavior)
+ * - typeId types: ColumnBuilder (for now, could be more specific in future)
  */
 type OperationReturn<
   Returns extends ReturnSpec,
-  _ColumnName extends string,
-  _ColumnMeta extends StorageColumn,
+  ColumnName extends string,
+  ColumnMeta extends StorageColumn,
   _JsType,
 > = Returns extends { kind: 'builtin'; type: infer T }
   ? T extends 'number'
-    ? ExpressionBuilder<number>
+    ? ColumnBuilder<ColumnName, ColumnMeta, number>
     : T extends 'boolean'
-      ? ExpressionBuilder<boolean>
+      ? ColumnBuilder<ColumnName, ColumnMeta, boolean>
       : T extends 'string'
-        ? ExpressionBuilder<string>
-        : ExpressionBuilder<unknown>
+        ? ColumnBuilder<ColumnName, ColumnMeta, string>
+        : ColumnBuilder<ColumnName, ColumnMeta, unknown>
   : Returns extends { kind: 'typeId' }
-    ? ExpressionBuilder<unknown>
-    : ExpressionBuilder<unknown>;
+    ? AnyColumnBuilder
+    : ColumnBuilder<ColumnName, ColumnMeta, unknown>;
 
 /**
  * Computes JavaScript type for a column at column creation time.
@@ -398,18 +351,17 @@ export type InferProjectionRow<P extends Record<string, AnyColumnBuilder>> = {
 };
 
 /**
- * Nested projection type - allows recursive nesting of ColumnBuilder, ExpressionBuilder, or nested objects.
+ * Nested projection type - allows recursive nesting of ColumnBuilder or nested objects.
  */
 export type NestedProjection = Record<
   string,
-  | AnyExpressionSource
+  | AnyColumnBuilder
   | Record<
       string,
-      | AnyExpressionSource
+      | AnyColumnBuilder
       | Record<
           string,
-          | AnyExpressionSource
-          | Record<string, AnyExpressionSource | Record<string, AnyExpressionSource>>
+          AnyColumnBuilder | Record<string, AnyColumnBuilder | Record<string, AnyColumnBuilder>>
         >
     >
 >;
@@ -432,19 +384,17 @@ type ExtractIncludeType<
  * by looking up the include alias in the Includes type map.
  */
 export type InferNestedProjectionRow<
-  P extends Record<string, AnyExpressionSource | boolean | NestedProjection>,
+  P extends Record<string, AnyColumnBuilder | boolean | NestedProjection>,
   CodecTypes extends Record<string, { readonly output: unknown }> = Record<string, never>,
   Includes extends Record<string, unknown> = Record<string, never>,
 > = {
-  [K in keyof P]: P[K] extends ExpressionBuilder<infer JsType>
-    ? JsType
-    : P[K] extends AnyColumnBuilder
-      ? ExtractJsTypeFromColumnBuilder<P[K]>
-      : P[K] extends true
-        ? Array<ExtractIncludeType<K & string, Includes>> // Include reference - infers Array<ChildShape> from Includes map
-        : P[K] extends NestedProjection
-          ? InferNestedProjectionRow<P[K], CodecTypes, Includes>
-          : never;
+  [K in keyof P]: P[K] extends AnyColumnBuilder
+    ? ExtractJsTypeFromColumnBuilder<P[K]>
+    : P[K] extends true
+      ? Array<ExtractIncludeType<K & string, Includes>> // Include reference - infers Array<ChildShape> from Includes map
+      : P[K] extends NestedProjection
+        ? InferNestedProjectionRow<P[K], CodecTypes, Includes>
+        : never;
 };
 
 /**

package/src/utils/guards.ts

@@ -1,27 +1,16 @@
 import type { StorageColumn } from '@prisma-next/sql-contract/types';
-import type {
-  ColumnRef,
-  Expression,
-  ExpressionSource,
-  LiteralExpr,
-  OperationExpr,
-  ParamRef,
-} from '../ast/types';
-import type {
-  AnyColumnBuilder,
-  AnyExpressionSource,
-  ExpressionBuilder,
-  ParamPlaceholder,
-  ValueSource,
-} from '../types';
+import type { ColumnRef, LiteralExpr, OperationExpr, ParamRef } from '../ast/types';
+import type { AnyColumnBuilder, ParamPlaceholder } from '../types';
 
 /**
- * Helper to extract columnMeta from a ColumnBuilder or ExpressionBuilder.
+ * Helper to extract columnMeta from a ColumnBuilder.
  * Returns StorageColumn if present, undefined otherwise.
- * Both ColumnBuilder and ExpressionBuilder have columnMeta property.
+ * AnyColumnBuilder is a union that includes types with columnMeta property,
+ * so we can safely access it after checking for existence.
  */
-export function getColumnMeta(expr: AnyExpressionSource): StorageColumn | undefined {
-  // Both ColumnBuilder and ExpressionBuilder have columnMeta: StorageColumn
+export function getColumnMeta(expr: AnyColumnBuilder): StorageColumn | undefined {
+  // AnyColumnBuilder includes AnyColumnBuilderBase which has columnMeta: StorageColumn
+  // and ColumnBuilder which has columnMeta: ColumnMeta extends StorageColumn
   // TypeScript should narrow the type after the 'in' check
   if ('columnMeta' in expr) {
     return expr.columnMeta;
@@ -77,17 +66,15 @@ export function collectColumnRefs(
 /**
  * Type predicate to check if an expression is an OperationExpr.
  */
-export function isOperationExpr(
-  expr: AnyExpressionSource | OperationExpr | Expression,
-): expr is OperationExpr {
+export function isOperationExpr(expr: AnyColumnBuilder | OperationExpr): expr is OperationExpr {
   return typeof expr === 'object' && expr !== null && 'kind' in expr && expr.kind === 'operation';
 }
 
 /**
- * Helper to extract table and column from a ColumnBuilder, ExpressionBuilder, or OperationExpr.
- * For ExpressionBuilder or OperationExpr, recursively unwraps to find the base ColumnRef.
+ * Helper to extract table and column from a ColumnBuilder or OperationExpr.
+ * For OperationExpr, recursively unwraps to find the base ColumnRef.
  */
-export function getColumnInfo(expr: AnyExpressionSource | OperationExpr): {
+export function getColumnInfo(expr: AnyColumnBuilder | OperationExpr): {
   table: string;
   column: string;
 } {
@@ -95,10 +82,6 @@ export function getColumnInfo(expr: AnyExpressionSource | OperationExpr): {
     const baseCol = extractBaseColumnRef(expr);
     return { table: baseCol.table, column: baseCol.column };
   }
-  if (isExpressionBuilder(expr)) {
-    const baseCol = extractBaseColumnRef(expr.expr);
-    return { table: baseCol.table, column: baseCol.column };
-  }
   // expr is ColumnBuilder - TypeScript can't narrow properly
   const colBuilder = expr as unknown as { table: string; column: string };
   return { table: colBuilder.table, column: colBuilder.column };
@@ -116,71 +99,18 @@ export function isColumnBuilder(value: unknown): value is AnyColumnBuilder {
   );
 }
 
-/**
- * Type predicate to check if a value is an ExpressionBuilder.
- */
-export function isExpressionBuilder(value: unknown): value is ExpressionBuilder {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'kind' in value &&
-    (value as { kind: unknown }).kind === 'expression'
-  );
-}
-
-/**
- * Type predicate to check if a value is an ExpressionSource (has toExpr method).
- */
-export function isExpressionSource(value: unknown): value is ExpressionSource {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'toExpr' in value &&
-    typeof (value as ExpressionSource).toExpr === 'function'
-  );
-}
-
-/**
- * Converts any ExpressionSource to an Expression.
- * This is the canonical way to get an AST Expression from a builder.
- *
- * @param source - A ColumnBuilder or ExpressionBuilder
- * @returns The corresponding Expression (ColumnRef or OperationExpr)
- */
-export function toExpression(source: ExpressionSource): Expression {
-  return source.toExpr();
-}
-
-/**
- * Converts an AnyExpressionSource to an Expression.
- * Handles both ColumnBuilder and ExpressionBuilder.
- *
- * @param source - A ColumnBuilder or ExpressionBuilder
- * @returns The corresponding Expression (ColumnRef or OperationExpr)
- */
-export function expressionFromSource(source: AnyExpressionSource): Expression {
-  return source.toExpr();
-}
-
-/**
- * Type predicate to check if a value is a ValueSource.
- * ValueSource is either a ParamPlaceholder or an ExpressionSource.
- */
-export function isValueSource(value: unknown): value is ValueSource {
-  return isParamPlaceholder(value) || isExpressionSource(value);
-}
-
 /**
  * Extracts and returns an OperationExpr from a builder.
  * Returns the OperationExpr if the builder is an OperationExpr or has an _operationExpr property,
  * otherwise returns undefined.
  *
- * @deprecated Use isExpressionBuilder() instead. This function exists for backward compatibility
- * with code that uses the hidden _operationExpr property pattern.
- *
  * @design-note: This function accesses the hidden `_operationExpr` property, which is a code smell.
- * The ExpressionBuilder type (introduced in the operation-expr-refactoring) provides a cleaner
- * approach by explicitly representing operation results as a distinct type.
+ * The issue is that `executeOperation()` in relational-core returns a ColumnBuilder-shaped object
+ * with a hidden `_operationExpr` property, creating coupling between lanes and relational-core
+ * implementation details. A cleaner design would be to have operation results be a separate
+ * type (e.g., `OperationResultBuilder`) that properly represents expression nodes rather than
+ * pretending to be a ColumnBuilder. This would require refactoring the operation execution
+ * system in relational-core to return proper expression types.
  */
 export function getOperationExpr(
   builder: AnyColumnBuilder | OperationExpr,

package/dist/chunk-2BWK6XEY.js.map

@@ -1 +0,0 @@
-{"version":3,"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 { QueryLaneContext } 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 */\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\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// Forward declare AnyBinaryBuilder and AnyOrderBuilder for use in ExpressionBuilder\nexport type AnyBinaryBuilder = BinaryBuilder;\nexport type AnyOrderBuilder = OrderBuilder;\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  // 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 * 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> = ColumnMeta extends { nullable: infer Nullable }\n  ? ColumnMetaTypeId<ColumnMeta> extends infer TypeId\n    ? TypeId extends string\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\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: QueryLaneContext<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+CO,SAAS,mBACd,MACA,KACiB;AACjB,SAAO,EAAE,MAAM,SAAS,MAAM,IAAI;AACpC;AAkIO,SAAS,gBAAgB,OAA2C;AACzE,SACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS;AAE1C;","names":[]}

package/dist/chunk-2MAKNVCP.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils/guards.ts"],"sourcesContent":["import type { StorageColumn } from '@prisma-next/sql-contract/types';\nimport type {\n  ColumnRef,\n  Expression,\n  ExpressionSource,\n  LiteralExpr,\n  OperationExpr,\n  ParamRef,\n} from '../ast/types';\nimport type {\n  AnyColumnBuilder,\n  AnyExpressionSource,\n  ExpressionBuilder,\n  ParamPlaceholder,\n  ValueSource,\n} from '../types';\n\n/**\n * Helper to extract columnMeta from a ColumnBuilder or ExpressionBuilder.\n * Returns StorageColumn if present, undefined otherwise.\n * Both ColumnBuilder and ExpressionBuilder have columnMeta property.\n */\nexport function getColumnMeta(expr: AnyExpressionSource): StorageColumn | undefined {\n  // Both ColumnBuilder and ExpressionBuilder have columnMeta: StorageColumn\n  // TypeScript should narrow the type after the 'in' check\n  if ('columnMeta' in expr) {\n    return expr.columnMeta;\n  }\n  return undefined;\n}\n\n/**\n * Type predicate to check if a value is a ParamPlaceholder.\n */\nexport function isParamPlaceholder(value: unknown): value is ParamPlaceholder {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'kind' in value &&\n    (value as { kind: unknown }).kind === 'param-placeholder' &&\n    'name' in value &&\n    typeof (value as { name: unknown }).name === 'string'\n  );\n}\n\n/**\n * Recursively extracts the base ColumnRef from an OperationExpr.\n * If the expression is already a ColumnRef, it is returned directly.\n */\nexport function extractBaseColumnRef(expr: ColumnRef | OperationExpr): ColumnRef {\n  if (expr.kind === 'col') {\n    return expr;\n  }\n  return extractBaseColumnRef(expr.self);\n}\n\n/**\n * Recursively collects all ColumnRef nodes from an expression tree.\n * Handles nested OperationExpr structures by traversing both self and args.\n */\nexport function collectColumnRefs(\n  expr: ColumnRef | ParamRef | LiteralExpr | OperationExpr,\n): ColumnRef[] {\n  if (expr.kind === 'col') {\n    return [expr];\n  }\n  if (expr.kind === 'operation') {\n    const refs: ColumnRef[] = collectColumnRefs(expr.self);\n    for (const arg of expr.args) {\n      refs.push(...collectColumnRefs(arg));\n    }\n    return refs;\n  }\n  return [];\n}\n\n/**\n * Type predicate to check if an expression is an OperationExpr.\n */\nexport function isOperationExpr(\n  expr: AnyExpressionSource | OperationExpr | Expression,\n): expr is OperationExpr {\n  return typeof expr === 'object' && expr !== null && 'kind' in expr && expr.kind === 'operation';\n}\n\n/**\n * Helper to extract table and column from a ColumnBuilder, ExpressionBuilder, or OperationExpr.\n * For ExpressionBuilder or OperationExpr, recursively unwraps to find the base ColumnRef.\n */\nexport function getColumnInfo(expr: AnyExpressionSource | OperationExpr): {\n  table: string;\n  column: string;\n} {\n  if (isOperationExpr(expr)) {\n    const baseCol = extractBaseColumnRef(expr);\n    return { table: baseCol.table, column: baseCol.column };\n  }\n  if (isExpressionBuilder(expr)) {\n    const baseCol = extractBaseColumnRef(expr.expr);\n    return { table: baseCol.table, column: baseCol.column };\n  }\n  // expr is ColumnBuilder - TypeScript can't narrow properly\n  const colBuilder = expr as unknown as { table: string; column: string };\n  return { table: colBuilder.table, column: colBuilder.column };\n}\n\n/**\n * Type predicate to check if a value is a ColumnBuilder.\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\n/**\n * Type predicate to check if a value is an ExpressionBuilder.\n */\nexport function isExpressionBuilder(value: unknown): value is ExpressionBuilder {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'kind' in value &&\n    (value as { kind: unknown }).kind === 'expression'\n  );\n}\n\n/**\n * Type predicate to check if a value is an ExpressionSource (has toExpr method).\n */\nexport function isExpressionSource(value: unknown): value is ExpressionSource {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'toExpr' in value &&\n    typeof (value as ExpressionSource).toExpr === 'function'\n  );\n}\n\n/**\n * Converts any ExpressionSource to an Expression.\n * This is the canonical way to get an AST Expression from a builder.\n *\n * @param source - A ColumnBuilder or ExpressionBuilder\n * @returns The corresponding Expression (ColumnRef or OperationExpr)\n */\nexport function toExpression(source: ExpressionSource): Expression {\n  return source.toExpr();\n}\n\n/**\n * Converts an AnyExpressionSource to an Expression.\n * Handles both ColumnBuilder and ExpressionBuilder.\n *\n * @param source - A ColumnBuilder or ExpressionBuilder\n * @returns The corresponding Expression (ColumnRef or OperationExpr)\n */\nexport function expressionFromSource(source: AnyExpressionSource): Expression {\n  return source.toExpr();\n}\n\n/**\n * Type predicate to check if a value is a ValueSource.\n * ValueSource is either a ParamPlaceholder or an ExpressionSource.\n */\nexport function isValueSource(value: unknown): value is ValueSource {\n  return isParamPlaceholder(value) || isExpressionSource(value);\n}\n\n/**\n * Extracts and returns an OperationExpr from a builder.\n * Returns the OperationExpr if the builder is an OperationExpr or has an _operationExpr property,\n * otherwise returns undefined.\n *\n * @deprecated Use isExpressionBuilder() instead. This function exists for backward compatibility\n * with code that uses the hidden _operationExpr property pattern.\n *\n * @design-note: This function accesses the hidden `_operationExpr` property, which is a code smell.\n * The ExpressionBuilder type (introduced in the operation-expr-refactoring) provides a cleaner\n * approach by explicitly representing operation results as a distinct type.\n */\nexport function getOperationExpr(\n  builder: AnyColumnBuilder | OperationExpr,\n): OperationExpr | undefined {\n  if (isOperationExpr(builder)) {\n    return builder;\n  }\n  const builderWithExpr = builder as unknown as { _operationExpr?: OperationExpr };\n  return builderWithExpr._operationExpr;\n}\n"],"mappings":";AAsBO,SAAS,cAAc,MAAsD;AAGlF,MAAI,gBAAgB,MAAM;AACxB,WAAO,KAAK;AAAA,EACd;AACA,SAAO;AACT;AAKO,SAAS,mBAAmB,OAA2C;AAC5E,SACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS,uBACtC,UAAU,SACV,OAAQ,MAA4B,SAAS;AAEjD;AAMO,SAAS,qBAAqB,MAA4C;AAC/E,MAAI,KAAK,SAAS,OAAO;AACvB,WAAO;AAAA,EACT;AACA,SAAO,qBAAqB,KAAK,IAAI;AACvC;AAMO,SAAS,kBACd,MACa;AACb,MAAI,KAAK,SAAS,OAAO;AACvB,WAAO,CAAC,IAAI;AAAA,EACd;AACA,MAAI,KAAK,SAAS,aAAa;AAC7B,UAAM,OAAoB,kBAAkB,KAAK,IAAI;AACrD,eAAW,OAAO,KAAK,MAAM;AAC3B,WAAK,KAAK,GAAG,kBAAkB,GAAG,CAAC;AAAA,IACrC;AACA,WAAO;AAAA,EACT;AACA,SAAO,CAAC;AACV;AAKO,SAAS,gBACd,MACuB;AACvB,SAAO,OAAO,SAAS,YAAY,SAAS,QAAQ,UAAU,QAAQ,KAAK,SAAS;AACtF;AAMO,SAAS,cAAc,MAG5B;AACA,MAAI,gBAAgB,IAAI,GAAG;AACzB,UAAM,UAAU,qBAAqB,IAAI;AACzC,WAAO,EAAE,OAAO,QAAQ,OAAO,QAAQ,QAAQ,OAAO;AAAA,EACxD;AACA,MAAI,oBAAoB,IAAI,GAAG;AAC7B,UAAM,UAAU,qBAAqB,KAAK,IAAI;AAC9C,WAAO,EAAE,OAAO,QAAQ,OAAO,QAAQ,QAAQ,OAAO;AAAA,EACxD;AAEA,QAAM,aAAa;AACnB,SAAO,EAAE,OAAO,WAAW,OAAO,QAAQ,WAAW,OAAO;AAC9D;AAKO,SAAS,gBAAgB,OAA2C;AACzE,SACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS;AAE1C;AAKO,SAAS,oBAAoB,OAA4C;AAC9E,SACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS;AAE1C;AAKO,SAAS,mBAAmB,OAA2C;AAC5E,SACE,OAAO,UAAU,YACjB,UAAU,QACV,YAAY,SACZ,OAAQ,MAA2B,WAAW;AAElD;AASO,SAAS,aAAa,QAAsC;AACjE,SAAO,OAAO,OAAO;AACvB;AASO,SAAS,qBAAqB,QAAyC;AAC5E,SAAO,OAAO,OAAO;AACvB;AAMO,SAAS,cAAc,OAAsC;AAClE,SAAO,mBAAmB,KAAK,KAAK,mBAAmB,KAAK;AAC9D;AAcO,SAAS,iBACd,SAC2B;AAC3B,MAAI,gBAAgB,OAAO,GAAG;AAC5B,WAAO;AAAA,EACT;AACA,QAAM,kBAAkB;AACxB,SAAO,gBAAgB;AACzB;","names":[]}

package/dist/chunk-3F4RFQIB.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/operations-registry.ts"],"sourcesContent":["import type { OperationRegistry } from '@prisma-next/operations';\nimport { hasAllCapabilities } from '@prisma-next/operations';\nimport { planInvalid } from '@prisma-next/plan';\nimport type { StorageColumn } from '@prisma-next/sql-contract/types';\nimport type { SqlOperationSignature } from '@prisma-next/sql-operations';\nimport type {\n  BinaryOp,\n  Expression,\n  ExpressionSource,\n  LiteralExpr,\n  OperationExpr,\n  ParamRef,\n} from './ast/types';\nimport type {\n  AnyBinaryBuilder,\n  AnyOrderBuilder,\n  ColumnBuilder,\n  ExpressionBuilder,\n  OperationTypes,\n  ParamPlaceholder,\n} from './types';\nimport { isParamPlaceholder } from './utils/guards';\n\n/**\n * Type guard to check if a value is an ExpressionSource (has toExpr method).\n */\nfunction isExpressionSource(value: unknown): value is ExpressionSource {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'toExpr' in value &&\n    typeof (value as ExpressionSource).toExpr === 'function'\n  );\n}\n\n/**\n * Executes an operation and returns an ExpressionBuilder.\n * This is the canonical entrypoint for operation invocation, enabling\n * future enhancements like telemetry, caching, or tracing.\n *\n * The returned ExpressionBuilder:\n * - Has `kind: 'expression'` to distinguish it from ColumnBuilder\n * - Contains the operation expression in `expr`\n * - Provides `toExpr()` method to get the Expression\n * - Provides comparison and ordering methods for chaining\n *\n * @param signature - The operation signature from the registry\n * @param selfBuilder - The expression source that the operation is called on\n * @param args - The arguments passed to the operation\n * @param columnMeta - The metadata of the column the operation is called on\n * @returns An ExpressionBuilder containing the operation expression\n */\nfunction executeOperation(\n  signature: SqlOperationSignature,\n  selfBuilder: ExpressionSource,\n  args: unknown[],\n  columnMeta: StorageColumn,\n  operationRegistry?: OperationRegistry,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ExpressionBuilder {\n  if (args.length !== signature.args.length) {\n    throw planInvalid(\n      `Operation ${signature.method} expects ${signature.args.length} arguments, got ${args.length}`,\n    );\n  }\n\n  // Get the Expression from the self builder using toExpr()\n  const selfExpr: Expression = selfBuilder.toExpr();\n\n  const operationArgs: Array<Expression | ParamRef | LiteralExpr> = [];\n  for (let i = 0; i < args.length; i++) {\n    const arg = args[i];\n    const argSpec = signature.args[i];\n    if (!argSpec) {\n      throw planInvalid(`Missing argument spec for argument ${i}`);\n    }\n\n    if (argSpec.kind === 'param') {\n      if (!isParamPlaceholder(arg)) {\n        throw planInvalid(`Argument ${i} must be a parameter placeholder`);\n      }\n      operationArgs.push({\n        kind: 'param',\n        index: 0,\n        name: arg.name,\n      });\n    } else if (argSpec.kind === 'typeId') {\n      // Accept ExpressionSource (ColumnBuilder or ExpressionBuilder)\n      if (!isExpressionSource(arg)) {\n        throw planInvalid(\n          `Argument ${i} must be an ExpressionSource (ColumnBuilder or ExpressionBuilder)`,\n        );\n      }\n      // Use toExpr() to get the Expression\n      operationArgs.push(arg.toExpr());\n    } else if (argSpec.kind === 'literal') {\n      operationArgs.push({\n        kind: 'literal',\n        value: arg,\n      });\n    }\n  }\n\n  const operationExpr: OperationExpr = {\n    kind: 'operation',\n    method: signature.method,\n    forTypeId: signature.forTypeId,\n    self: selfExpr,\n    args: operationArgs,\n    returns: signature.returns,\n    lowering: signature.lowering,\n  };\n\n  const returnTypeId = signature.returns.kind === 'typeId' ? signature.returns.type : undefined;\n  const returnColumnMeta: StorageColumn = returnTypeId\n    ? {\n        ...columnMeta,\n        codecId: returnTypeId,\n      }\n    : columnMeta;\n\n  const createComparisonMethod =\n    (op: BinaryOp) =>\n    (value: ParamPlaceholder | ExpressionSource): AnyBinaryBuilder =>\n      Object.freeze({\n        kind: 'binary' as const,\n        op,\n        left: operationExpr,\n        right: value,\n      }) as AnyBinaryBuilder;\n\n  const baseResult: ExpressionBuilder = {\n    kind: 'expression' as const,\n    expr: operationExpr,\n    get columnMeta() {\n      return returnColumnMeta;\n    },\n    eq: createComparisonMethod('eq'),\n    neq: createComparisonMethod('neq'),\n    gt: createComparisonMethod('gt'),\n    lt: createComparisonMethod('lt'),\n    gte: createComparisonMethod('gte'),\n    lte: createComparisonMethod('lte'),\n    asc(): AnyOrderBuilder {\n      return Object.freeze({\n        kind: 'order' as const,\n        expr: operationExpr,\n        dir: 'asc' as const,\n      });\n    },\n    desc(): AnyOrderBuilder {\n      return Object.freeze({\n        kind: 'order' as const,\n        expr: operationExpr,\n        dir: 'desc' as const,\n      });\n    },\n    toExpr(): OperationExpr {\n      return operationExpr;\n    },\n    get __jsType(): unknown {\n      return undefined;\n    },\n  };\n\n  // If the return type is a typeId, attach operations for that type\n  if (returnTypeId && operationRegistry) {\n    const resultWithOps = attachOperationsToExpressionBuilder(\n      baseResult,\n      returnColumnMeta,\n      operationRegistry,\n      contractCapabilities,\n    );\n    return Object.freeze(resultWithOps);\n  }\n\n  return Object.freeze(baseResult);\n}\n\n/**\n * Attaches operation methods to an ExpressionBuilder for chained operations.\n * When an operation returns a typeId, the result ExpressionBuilder needs\n * operation methods for that type.\n */\nfunction attachOperationsToExpressionBuilder(\n  expressionBuilder: ExpressionBuilder,\n  columnMeta: StorageColumn,\n  registry: OperationRegistry,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ExpressionBuilder {\n  const codecId = columnMeta.codecId;\n  if (!codecId) {\n    return expressionBuilder;\n  }\n\n  const operations = registry.byType(codecId) as SqlOperationSignature[];\n  if (operations.length === 0) {\n    return expressionBuilder;\n  }\n\n  const builderWithOps = expressionBuilder as ExpressionBuilder & Record<string, unknown>;\n\n  for (const operation of operations) {\n    if (operation.capabilities && operation.capabilities.length > 0) {\n      if (!contractCapabilities) {\n        continue;\n      }\n\n      if (!hasAllCapabilities(operation.capabilities, contractCapabilities)) {\n        continue;\n      }\n    }\n    // Method sugar: attach operation as a method on the expression builder\n    builderWithOps[operation.method] = function (this: ExpressionBuilder, ...args: unknown[]) {\n      return executeOperation(operation, this, args, columnMeta, registry, contractCapabilities);\n    };\n  }\n\n  return builderWithOps;\n}\n\nexport function attachOperationsToColumnBuilder<\n  ColumnName extends string,\n  ColumnMeta extends StorageColumn,\n  JsType = unknown,\n  Operations extends OperationTypes = Record<string, never>,\n>(\n  columnBuilder: ColumnBuilder<ColumnName, ColumnMeta, JsType, Record<string, never>>,\n  columnMeta: ColumnMeta,\n  registry: OperationRegistry | undefined,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations> {\n  if (!registry) {\n    return columnBuilder as ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;\n  }\n\n  // Use codecId to look up operations registered for this column's type\n  const codecId = columnMeta.codecId;\n  if (!codecId) {\n    return columnBuilder as ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;\n  }\n\n  const operations = registry.byType(codecId) as SqlOperationSignature[];\n  if (operations.length === 0) {\n    return columnBuilder as ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;\n  }\n\n  const builderWithOps = columnBuilder as unknown as ColumnBuilder<\n    ColumnName,\n    ColumnMeta,\n    JsType,\n    Operations\n  >;\n\n  for (const operation of operations) {\n    if (operation.capabilities && operation.capabilities.length > 0) {\n      if (!contractCapabilities) {\n        continue;\n      }\n\n      if (!hasAllCapabilities(operation.capabilities, contractCapabilities)) {\n        continue;\n      }\n    }\n    // Method sugar: attach operation as a method on the column builder\n    // Operations return ExpressionBuilder, not ColumnBuilder\n    (builderWithOps as Record<string, unknown>)[operation.method] = function (\n      this: ColumnBuilder<ColumnName, ColumnMeta, JsType, Record<string, never>>,\n      ...args: unknown[]\n    ) {\n      return executeOperation(operation, this, args, columnMeta, registry, contractCapabilities);\n    };\n  }\n\n  return builderWithOps;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-L2FZU4IV.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/schema.ts"],"sourcesContent":["import type { OperationRegistry } from '@prisma-next/operations';\nimport { planInvalid } from '@prisma-next/plan';\nimport type {\n  ExtractCodecTypes,\n  ExtractOperationTypes,\n  SqlContract,\n  SqlStorage,\n  StorageColumn,\n} from '@prisma-next/sql-contract/types';\nimport type { BinaryOp, ColumnRef, ExpressionSource, TableRef } from './ast/types';\nimport { attachOperationsToColumnBuilder } from './operations-registry';\nimport type { QueryLaneContext } from './query-lane-context';\nimport type {\n  BinaryBuilder,\n  CodecTypes as CodecTypesType,\n  ColumnBuilder,\n  ComputeColumnJsType,\n  OperationTypeSignature,\n  OperationTypes,\n  OrderBuilder,\n  ParamPlaceholder,\n} from './types';\n\ntype TableColumns<Table extends { columns: Record<string, StorageColumn> }> = Table['columns'];\n\ntype ColumnBuilders<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n  Columns extends Record<string, StorageColumn>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n> = {\n  readonly [K in keyof Columns]: ColumnBuilder<\n    K & string,\n    Columns[K],\n    ComputeColumnJsType<Contract, TableName, K & string, Columns[K], CodecTypes>,\n    Operations\n  >;\n};\n\nexport class ColumnBuilderImpl<\n  ColumnName extends string,\n  ColumnMeta extends StorageColumn,\n  JsType = unknown,\n> implements ExpressionSource\n{\n  readonly kind = 'column' as const;\n\n  constructor(\n    readonly table: string,\n    readonly column: ColumnName,\n    private readonly storageColumn: ColumnMeta,\n  ) {}\n\n  get columnMeta(): ColumnMeta {\n    return this.storageColumn;\n  }\n\n  // Type-level helper property (not used at runtime)\n  get __jsType(): JsType {\n    return undefined as unknown as JsType;\n  }\n\n  /**\n   * Converts this column builder to a ColumnRef expression.\n   * This is the canonical way to get an AST node from a builder.\n   */\n  toExpr(): ColumnRef {\n    return Object.freeze({\n      kind: 'col' as const,\n      table: this.table,\n      column: this.column,\n    });\n  }\n\n  private createBinaryBuilder(\n    op: BinaryOp,\n    value: ParamPlaceholder | ExpressionSource,\n  ): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    if (value == null) {\n      throw planInvalid(\n        'Parameter placeholder or expression source required for column comparison',\n      );\n    }\n    // Check for ExpressionSource first (has toExpr method)\n    if ('toExpr' in value && typeof value.toExpr === 'function') {\n      return Object.freeze({\n        kind: 'binary' as const,\n        op,\n        left: this.toExpr(),\n        right: value,\n      }) as BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n    }\n    // Must be a ParamPlaceholder\n    if ('kind' in value && value.kind === 'param-placeholder') {\n      return Object.freeze({\n        kind: 'binary' as const,\n        op,\n        left: this.toExpr(),\n        right: value,\n      }) as BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n    }\n    throw planInvalid('Parameter placeholder or expression source required for column comparison');\n  }\n\n  eq(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('eq', value);\n  }\n\n  neq(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('neq', value);\n  }\n\n  gt(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('gt', value);\n  }\n\n  lt(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('lt', value);\n  }\n\n  gte(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('gte', value);\n  }\n\n  lte(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('lte', value);\n  }\n\n  asc(): OrderBuilder<ColumnName, ColumnMeta, JsType> {\n    return Object.freeze({\n      kind: 'order' as const,\n      expr: this.toExpr(),\n      dir: 'asc' as const,\n    }) as OrderBuilder<ColumnName, ColumnMeta, JsType>;\n  }\n\n  desc(): OrderBuilder<ColumnName, ColumnMeta, JsType> {\n    return Object.freeze({\n      kind: 'order' as const,\n      expr: this.toExpr(),\n      dir: 'desc' as const,\n    }) as OrderBuilder<ColumnName, ColumnMeta, JsType>;\n  }\n}\n\nexport class TableBuilderImpl<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n  Columns extends Record<string, StorageColumn>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n> implements TableRef\n{\n  readonly kind = 'table' as const;\n  readonly columns: ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>;\n  private readonly _name: TableName;\n\n  constructor(\n    name: TableName,\n    columns: ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>,\n  ) {\n    this._name = name;\n    this.columns = columns;\n  }\n\n  get name(): string {\n    return this._name;\n  }\n}\n\nfunction buildColumns<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends keyof Contract['storage']['tables'] & string,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n>(\n  tableName: TableName,\n  storage: SqlStorage,\n  _contract: Contract,\n  operationRegistry?: OperationRegistry,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ColumnBuilders<\n  Contract,\n  TableName,\n  Contract['storage']['tables'][TableName]['columns'],\n  CodecTypes,\n  Operations\n> {\n  const table = storage.tables[tableName];\n\n  if (!table) {\n    throw planInvalid(`Unknown table ${tableName}`);\n  }\n\n  type Columns = Contract['storage']['tables'][TableName]['columns'];\n  const tableColumns = table.columns as Columns;\n\n  const result = {} as {\n    [K in keyof Columns]: ColumnBuilder<\n      K & string,\n      Columns[K],\n      ComputeColumnJsType<Contract, TableName, K & string, Columns[K], CodecTypes>,\n      Operations\n    >;\n  };\n\n  const assignColumn = <ColumnKey extends keyof Columns & string>(\n    columnName: ColumnKey,\n    columnDef: Columns[ColumnKey],\n  ) => {\n    type JsType = ComputeColumnJsType<\n      Contract,\n      TableName,\n      ColumnKey,\n      Columns[ColumnKey],\n      CodecTypes\n    >;\n\n    const columnBuilder = new ColumnBuilderImpl<ColumnKey, Columns[ColumnKey], JsType>(\n      tableName,\n      columnName,\n      columnDef,\n    );\n\n    const builderWithOps = attachOperationsToColumnBuilder<\n      ColumnKey,\n      Columns[ColumnKey],\n      JsType,\n      Operations\n    >(\n      columnBuilder as unknown as ColumnBuilder<\n        ColumnKey,\n        Columns[ColumnKey],\n        JsType,\n        Record<string, never>\n      >,\n      columnDef,\n      operationRegistry,\n      contractCapabilities,\n    );\n\n    (result as Record<string, unknown>)[columnName] = builderWithOps;\n  };\n\n  for (const columnName of Object.keys(tableColumns) as Array<keyof Columns & string>) {\n    const columnDef = tableColumns[columnName];\n    if (!columnDef) continue;\n    assignColumn(columnName, columnDef);\n  }\n\n  return result as ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>;\n}\n\n/**\n * Creates a Proxy that enables accessing table columns directly on the table object,\n * in addition to the standard `table.columns.columnName` syntax.\n *\n * This allows both access patterns:\n * - `tables.user.columns.id` (standard access)\n * - `tables.user.id` (convenience access via proxy)\n *\n * The proxy intercepts property access and routes column name lookups to\n * `table.columns[prop]`, while preserving direct access to table properties\n * like `name`, `kind`, and `columns`.\n */\nfunction createTableProxy<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n  Columns extends Record<string, StorageColumn>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n>(\n  table: TableBuilderImpl<Contract, TableName, Columns, CodecTypes, Operations>,\n): TableBuilderImpl<Contract, TableName, Columns, CodecTypes, Operations> {\n  return new Proxy(table, {\n    get(target, prop) {\n      if (prop === 'name' || prop === 'kind' || prop === 'columns') {\n        return Reflect.get(target, prop);\n      }\n      if (typeof prop === 'string' && prop in target.columns) {\n        return target.columns[prop as keyof typeof target.columns];\n      }\n      return undefined;\n    },\n  });\n}\n\ntype ExtractSchemaTables<\n  Contract extends SqlContract<SqlStorage>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n> = {\n  readonly [TableName in keyof Contract['storage']['tables']]: TableBuilderImpl<\n    Contract,\n    TableName & string,\n    TableColumns<Contract['storage']['tables'][TableName]>,\n    CodecTypes,\n    Operations\n  > &\n    TableRef;\n};\n\nexport type SchemaHandle<\n  Contract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>,\n  CodecTypes extends CodecTypesType = CodecTypesType,\n  Operations extends OperationTypes = Record<string, never>,\n> = {\n  readonly tables: ExtractSchemaTables<Contract, CodecTypes, Operations>;\n};\n\ntype SchemaReturnType<Contract extends SqlContract<SqlStorage>> = SchemaHandle<\n  Contract,\n  ExtractCodecTypes<Contract>,\n  ToOperationTypes<ExtractOperationTypes<Contract>>\n>;\n\ntype NormalizeOperationTypes<T> = {\n  [TypeId in keyof T]: {\n    [Method in keyof T[TypeId]]: T[TypeId][Method] extends OperationTypeSignature\n      ? T[TypeId][Method]\n      : OperationTypeSignature;\n  };\n};\n\ntype ToOperationTypes<T> = T extends OperationTypes ? T : NormalizeOperationTypes<T>;\n\n/**\n * Creates a schema handle for building SQL queries.\n *\n * @param context - Query lane context containing contract, codec and operation registries\n * @returns A schema handle with typed table builders\n *\n * @example\n * ```typescript\n * const schemaHandle = schema<Contract>(context);\n * const userTable = schemaHandle.tables.user;\n * ```\n */\nexport function schema<Contract extends SqlContract<SqlStorage>>(\n  context: QueryLaneContext<Contract>,\n): SchemaReturnType<Contract> {\n  const contract = context.contract;\n  const storage = contract.storage;\n  type CodecTypes = ExtractCodecTypes<Contract>;\n  type Operations = ToOperationTypes<ExtractOperationTypes<Contract>>;\n  const tables = {} as ExtractSchemaTables<Contract, CodecTypes, Operations>;\n  const contractCapabilities = contract.capabilities;\n\n  const operationRegistry = context.operations;\n\n  for (const tableName of Object.keys(storage.tables) as Array<\n    keyof Contract['storage']['tables'] & string\n  >) {\n    const columns = buildColumns<Contract, typeof tableName, CodecTypes, Operations>(\n      tableName,\n      storage,\n      contract,\n      operationRegistry,\n      contractCapabilities,\n    );\n    const table = new TableBuilderImpl<\n      Contract,\n      typeof tableName & string,\n      Contract['storage']['tables'][typeof tableName]['columns'],\n      CodecTypes,\n      Operations\n    >(tableName, columns);\n    const proxiedTable = createTableProxy<\n      Contract,\n      typeof tableName & string,\n      Contract['storage']['tables'][typeof tableName]['columns'],\n      CodecTypes,\n      Operations\n    >(table);\n    (tables as Record<string, unknown>)[tableName] = Object.freeze(\n      proxiedTable,\n    ) as ExtractSchemaTables<Contract, CodecTypes, Operations>[typeof tableName];\n  }\n\n  return Object.freeze({ tables }) as SchemaReturnType<Contract>;\n}\n\nexport type { ColumnBuilderImpl as Column, TableBuilderImpl as Table };\n"],"mappings":"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","names":[]}