@prisma-next/sql-relational-core 0.3.0-pr.93.5 → 0.3.0-pr.94.2

package/dist/exports/plan.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.mjs","names":[],"sources":["../../src/plan.ts"],"sourcesContent":["import type { ExecutionPlan, ParamDescriptor } from '@prisma-next/contract/types';\nimport type { StorageColumn } from '@prisma-next/sql-contract/types';\nimport type { QueryAst } from './ast/types';\n\n/**\n * SQL query plan produced by lanes before lowering.\n *\n * Lanes build ASTs and metadata but do not perform SQL lowering.\n * The `sql` field is absent - lowering happens in the runtime executor.\n *\n * Structurally aligns with ExecutionPlan<Row, QueryAst> (without sql field) to maintain\n * compatibility with ExecutionPlan/Plan-based utilities.\n * The generic parameter `_Row` is preserved for type extraction via ResultType.\n */\nexport interface SqlQueryPlan<_Row = unknown>\n  extends Pick<ExecutionPlan<_Row, QueryAst>, 'params' | 'meta'> {\n  readonly ast: QueryAst;\n  // Phantom property to preserve generic parameter for type extraction\n  // This allows ResultType to extract _Row for SqlQueryPlan values.\n  readonly _Row?: _Row;\n}\n\n/**\n * Augments the last ParamDescriptor in the array with codecId and nativeType from columnMeta.\n * This is used when building WHERE expressions to ensure param descriptors have type information.\n */\nexport function augmentDescriptorWithColumnMeta(\n  descriptors: ParamDescriptor[],\n  columnMeta: StorageColumn | undefined,\n): void {\n  const descriptor = descriptors[descriptors.length - 1];\n  if (descriptor && columnMeta) {\n    descriptors[descriptors.length - 1] = {\n      ...descriptor,\n      codecId: columnMeta.codecId,\n      nativeType: columnMeta.nativeType,\n    };\n  }\n}\n"],"mappings":";;;;;AA0BA,SAAgB,gCACd,aACA,YACM;CACN,MAAM,aAAa,YAAY,YAAY,SAAS;AACpD,KAAI,cAAc,WAChB,aAAY,YAAY,SAAS,KAAK;EACpC,GAAG;EACH,SAAS,WAAW;EACpB,YAAY,WAAW;EACxB"}

package/dist/exports/query-lane-context.d.mts

@@ -0,0 +1,2 @@
+import { t as QueryLaneContext } from "../query-lane-context-wr_XXnB5.mjs";
+export { QueryLaneContext };

package/dist/exports/query-lane-context.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/exports/schema.d.mts

@@ -0,0 +1,5 @@
+import "../query-lane-context-wr_XXnB5.mjs";
+import "../plan-9PvH-Tu3.mjs";
+import "../types-Bg2kUmUA.mjs";
+import { i as schema, n as SchemaHandle, r as TableBuilderImpl, t as ColumnBuilderImpl } from "../schema-Dse48uyP.mjs";
+export { ColumnBuilderImpl as Column, ColumnBuilderImpl, SchemaHandle, TableBuilderImpl as Table, TableBuilderImpl, schema };

package/dist/exports/schema.mjs

@@ -0,0 +1,4 @@
+import "../operations-registry-7R5KE2-5.mjs";
+import { n as TableBuilderImpl, r as schema, t as ColumnBuilderImpl } from "../schema-BsY2EXAf.mjs";
+
+export { ColumnBuilderImpl, TableBuilderImpl, schema };

package/dist/exports/types.d.mts

@@ -0,0 +1,4 @@
+import "../query-lane-context-wr_XXnB5.mjs";
+import "../plan-9PvH-Tu3.mjs";
+import { A as ParamPlaceholder, B as TableKey, C as ModelDef, D as OperationTypes, E as OperationTypeSignature, F as ResultType, G as isColumnBuilder, H as TablesOf, I as RuntimeError, L as SqlBuilderOptions, M as RawFunctionOptions, N as RawTemplateFactory, O as OperationsForTypeId, P as RawTemplateOptions, R as SqlPlan, S as Meta, T as NestedProjection, U as ValueSource, V as TableMetadata, W as createOrderBuilder, _ as InferProjectionRow, a as AnyOrderBuilder, b as JoinOnPredicate, c as BuildParamsMap, d as ColumnsOf, f as ComputeColumnJsType, g as InferNestedProjectionRow, h as HasIncludeManyCapabilities, i as AnyExpressionSource, j as RawFactory, k as OrderBuilder, l as CodecTypes, m as ExpressionBuilder, n as AnyColumnBuilder, o as BinaryBuilder, p as Expr, r as AnyColumnBuilderBase, s as BuildOptions, t as AnyBinaryBuilder, u as ColumnBuilder, v as InferReturningRow, w as ModelMetadata, x as META, y as JoinOnBuilder, z as TableDef } from "../types-Bg2kUmUA.mjs";
+export { AnyBinaryBuilder, AnyColumnBuilder, AnyColumnBuilderBase, AnyExpressionSource, AnyOrderBuilder, BinaryBuilder, BuildOptions, BuildParamsMap, CodecTypes, ColumnBuilder, ColumnsOf, ComputeColumnJsType, Expr, ExpressionBuilder, HasIncludeManyCapabilities, InferNestedProjectionRow, InferProjectionRow, InferReturningRow, JoinOnBuilder, JoinOnPredicate, META, Meta, ModelDef, ModelMetadata, NestedProjection, OperationTypeSignature, OperationTypes, OperationsForTypeId, OrderBuilder, ParamPlaceholder, RawFactory, RawFunctionOptions, RawTemplateFactory, RawTemplateOptions, ResultType, RuntimeError, SqlBuilderOptions, SqlPlan, TableDef, TableKey, TableMetadata, TablesOf, ValueSource, createOrderBuilder, isColumnBuilder };

package/dist/exports/types.mjs

@@ -0,0 +1,3 @@
+import { n as isColumnBuilder, t as createOrderBuilder } from "../types-D_FRJvm0.mjs";
+
+export { createOrderBuilder, isColumnBuilder };

package/dist/guards-4T0IByJo.mjs

@@ -0,0 +1,132 @@
+//#region src/utils/guards.ts
+/**
+* Helper to extract columnMeta from a ColumnBuilder or ExpressionBuilder.
+* Returns StorageColumn if present, undefined otherwise.
+* Both ColumnBuilder and ExpressionBuilder have columnMeta property.
+*/
+function getColumnMeta(expr) {
+	if ("columnMeta" in expr) return expr.columnMeta;
+}
+/**
+* Type predicate to check if a value is a ParamPlaceholder.
+*/
+function isParamPlaceholder(value) {
+	return typeof value === "object" && value !== null && "kind" in value && value.kind === "param-placeholder" && "name" in value && typeof value.name === "string";
+}
+/**
+* Recursively extracts the base ColumnRef from an OperationExpr.
+* If the expression is already a ColumnRef, it is returned directly.
+*/
+function extractBaseColumnRef(expr) {
+	if (expr.kind === "col") return expr;
+	return extractBaseColumnRef(expr.self);
+}
+/**
+* Recursively collects all ColumnRef nodes from an expression tree.
+* Handles nested OperationExpr structures by traversing both self and args.
+*/
+function collectColumnRefs(expr) {
+	if (expr.kind === "col") return [expr];
+	if (expr.kind === "operation") {
+		const refs = collectColumnRefs(expr.self);
+		for (const arg of expr.args) refs.push(...collectColumnRefs(arg));
+		return refs;
+	}
+	return [];
+}
+/**
+* Type predicate to check if an expression is an OperationExpr.
+*/
+function isOperationExpr(expr) {
+	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.
+*/
+function getColumnInfo(expr) {
+	if (isOperationExpr(expr)) {
+		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
+		};
+	}
+	const colBuilder = expr;
+	return {
+		table: colBuilder.table,
+		column: colBuilder.column
+	};
+}
+/**
+* Type predicate to check if a value is a ColumnBuilder.
+*/
+function isColumnBuilder(value) {
+	return typeof value === "object" && value !== null && "kind" in value && value.kind === "column";
+}
+/**
+* Type predicate to check if a value is an ExpressionBuilder.
+*/
+function isExpressionBuilder(value) {
+	return typeof value === "object" && value !== null && "kind" in value && value.kind === "expression";
+}
+/**
+* Type predicate to check if a value is an ExpressionSource (has toExpr method).
+*/
+function isExpressionSource(value) {
+	return typeof value === "object" && value !== null && "toExpr" in value && typeof value.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)
+*/
+function toExpression(source) {
+	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)
+*/
+function expressionFromSource(source) {
+	return source.toExpr();
+}
+/**
+* Type predicate to check if a value is a ValueSource.
+* ValueSource is either a ParamPlaceholder or an ExpressionSource.
+*/
+function isValueSource(value) {
+	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.
+*/
+function getOperationExpr(builder) {
+	if (isOperationExpr(builder)) return builder;
+	return builder._operationExpr;
+}
+
+//#endregion
+export { getColumnMeta as a, isExpressionBuilder as c, isParamPlaceholder as d, isValueSource as f, getColumnInfo as i, isExpressionSource as l, expressionFromSource as n, getOperationExpr as o, toExpression as p, extractBaseColumnRef as r, isColumnBuilder as s, collectColumnRefs as t, isOperationExpr as u };
+//# sourceMappingURL=guards-4T0IByJo.mjs.map

package/dist/guards-4T0IByJo.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards-4T0IByJo.mjs","names":["refs: ColumnRef[]"],"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":";;;;;;AAsBA,SAAgB,cAAc,MAAsD;AAGlF,KAAI,gBAAgB,KAClB,QAAO,KAAK;;;;;AAQhB,SAAgB,mBAAmB,OAA2C;AAC5E,QACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS,uBACtC,UAAU,SACV,OAAQ,MAA4B,SAAS;;;;;;AAQjD,SAAgB,qBAAqB,MAA4C;AAC/E,KAAI,KAAK,SAAS,MAChB,QAAO;AAET,QAAO,qBAAqB,KAAK,KAAK;;;;;;AAOxC,SAAgB,kBACd,MACa;AACb,KAAI,KAAK,SAAS,MAChB,QAAO,CAAC,KAAK;AAEf,KAAI,KAAK,SAAS,aAAa;EAC7B,MAAMA,OAAoB,kBAAkB,KAAK,KAAK;AACtD,OAAK,MAAM,OAAO,KAAK,KACrB,MAAK,KAAK,GAAG,kBAAkB,IAAI,CAAC;AAEtC,SAAO;;AAET,QAAO,EAAE;;;;;AAMX,SAAgB,gBACd,MACuB;AACvB,QAAO,OAAO,SAAS,YAAY,SAAS,QAAQ,UAAU,QAAQ,KAAK,SAAS;;;;;;AAOtF,SAAgB,cAAc,MAG5B;AACA,KAAI,gBAAgB,KAAK,EAAE;EACzB,MAAM,UAAU,qBAAqB,KAAK;AAC1C,SAAO;GAAE,OAAO,QAAQ;GAAO,QAAQ,QAAQ;GAAQ;;AAEzD,KAAI,oBAAoB,KAAK,EAAE;EAC7B,MAAM,UAAU,qBAAqB,KAAK,KAAK;AAC/C,SAAO;GAAE,OAAO,QAAQ;GAAO,QAAQ,QAAQ;GAAQ;;CAGzD,MAAM,aAAa;AACnB,QAAO;EAAE,OAAO,WAAW;EAAO,QAAQ,WAAW;EAAQ;;;;;AAM/D,SAAgB,gBAAgB,OAA2C;AACzE,QACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS;;;;;AAO1C,SAAgB,oBAAoB,OAA4C;AAC9E,QACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS;;;;;AAO1C,SAAgB,mBAAmB,OAA2C;AAC5E,QACE,OAAO,UAAU,YACjB,UAAU,QACV,YAAY,SACZ,OAAQ,MAA2B,WAAW;;;;;;;;;AAWlD,SAAgB,aAAa,QAAsC;AACjE,QAAO,OAAO,QAAQ;;;;;;;;;AAUxB,SAAgB,qBAAqB,QAAyC;AAC5E,QAAO,OAAO,QAAQ;;;;;;AAOxB,SAAgB,cAAc,OAAsC;AAClE,QAAO,mBAAmB,MAAM,IAAI,mBAAmB,MAAM;;;;;;;;;;;;;;AAe/D,SAAgB,iBACd,SAC2B;AAC3B,KAAI,gBAAgB,QAAQ,CAC1B,QAAO;AAGT,QADwB,QACD"}

package/dist/index.d.mts

@@ -0,0 +1,12 @@
+import { a as CodecInput, c as CodecRegistry, d as codec, f as createCodecRegistry, i as CodecId, l as ExtractCodecTypes, n as Codec, o as CodecMeta, p as defineCodecs, r as CodecDefBuilder, s as CodecOutput, t as QueryLaneContext, u as ExtractDataTypes } from "./query-lane-context-wr_XXnB5.mjs";
+import { C as UpdateAst, S as TableRef, _ as LoweredStatement, a as ColumnRef, b as QueryAst, c as ExistsExpr, d as IncludeAst, f as IncludeRef, g as LiteralExpr, h as JoinOnExpr, i as BinaryOp, l as Expression, m as JoinAst, n as augmentDescriptorWithColumnMeta, o as DeleteAst, p as InsertAst, r as BinaryExpr, s as Direction, t as SqlQueryPlan, u as ExpressionSource, v as OperationExpr, w as isOperationExpr, x as SelectAst, y as ParamRef } from "./plan-9PvH-Tu3.mjs";
+import { A as ParamPlaceholder, B as TableKey, C as ModelDef, D as OperationTypes, E as OperationTypeSignature, F as ResultType, G as isColumnBuilder, H as TablesOf, I as RuntimeError, L as SqlBuilderOptions, M as RawFunctionOptions, N as RawTemplateFactory, O as OperationsForTypeId, P as RawTemplateOptions, R as SqlPlan, S as Meta, T as NestedProjection, U as ValueSource, V as TableMetadata, W as createOrderBuilder, _ as InferProjectionRow, a as AnyOrderBuilder, b as JoinOnPredicate, c as BuildParamsMap, d as ColumnsOf, f as ComputeColumnJsType, g as InferNestedProjectionRow, h as HasIncludeManyCapabilities, i as AnyExpressionSource, j as RawFactory, k as OrderBuilder, l as CodecTypes, m as ExpressionBuilder, n as AnyColumnBuilder, o as BinaryBuilder, p as Expr, r as AnyColumnBuilderBase, s as BuildOptions, t as AnyBinaryBuilder, u as ColumnBuilder, v as InferReturningRow, w as ModelMetadata, x as META, y as JoinOnBuilder, z as TableDef } from "./types-Bg2kUmUA.mjs";
+import { Adapter, AdapterProfile, AdapterTarget, CreateDeleteAstOptions, CreateInsertAstOptions, CreateSelectAstOptions, CreateUpdateAstOptions, LoweredPayload, Lowerer, LowererContext, SqlDriver, SqlExecuteRequest, SqlExplainResult, SqlQueryResult, compact, createBinaryExpr, createColumnRef, createDeleteAst, createExistsExpr, createInsertAst, createJoin, createJoinOnBuilder, createJoinOnExpr, createLiteralExpr, createOperationExpr, createOrderByItem, createParamRef, createSelectAst, createTableRef, createUpdateAst } from "./exports/ast.mjs";
+import { n as planUnsupported, t as planInvalid } from "./errors-CLx1Ylq0.mjs";
+import { t as attachOperationsToColumnBuilder } from "./operations-registry-CIcn4f2P.mjs";
+import { n as param, t as Parameter } from "./param-B4LzVPv2.mjs";
+import "./exports/plan.mjs";
+import "./exports/query-lane-context.mjs";
+import { i as schema, n as SchemaHandle, r as TableBuilderImpl, t as ColumnBuilderImpl } from "./schema-Dse48uyP.mjs";
+import "./exports/types.mjs";
+export { Adapter, AdapterProfile, AdapterTarget, AnyBinaryBuilder, AnyColumnBuilder, AnyColumnBuilderBase, AnyExpressionSource, AnyOrderBuilder, BinaryBuilder, BinaryExpr, BinaryOp, BuildOptions, BuildParamsMap, Codec, CodecDefBuilder, CodecId, CodecInput, CodecMeta, CodecOutput, CodecRegistry, CodecTypes, ColumnBuilderImpl as Column, ColumnBuilderImpl, ColumnBuilder, ColumnRef, ColumnsOf, ComputeColumnJsType, CreateDeleteAstOptions, CreateInsertAstOptions, CreateSelectAstOptions, CreateUpdateAstOptions, DeleteAst, Direction, ExistsExpr, Expr, Expression, ExpressionBuilder, ExpressionSource, ExtractCodecTypes, ExtractDataTypes, HasIncludeManyCapabilities, IncludeAst, IncludeRef, InferNestedProjectionRow, InferProjectionRow, InferReturningRow, InsertAst, JoinAst, JoinOnBuilder, JoinOnExpr, JoinOnPredicate, LiteralExpr, LoweredPayload, LoweredStatement, Lowerer, LowererContext, META, Meta, ModelDef, ModelMetadata, NestedProjection, OperationExpr, OperationTypeSignature, OperationTypes, OperationsForTypeId, OrderBuilder, ParamPlaceholder, ParamRef, Parameter, QueryAst, QueryLaneContext, RawFactory, RawFunctionOptions, RawTemplateFactory, RawTemplateOptions, ResultType, RuntimeError, SchemaHandle, SelectAst, SqlBuilderOptions, SqlDriver, SqlExecuteRequest, SqlExplainResult, SqlPlan, SqlQueryPlan, SqlQueryResult, TableBuilderImpl as Table, TableBuilderImpl, TableDef, TableKey, TableMetadata, TableRef, TablesOf, UpdateAst, ValueSource, attachOperationsToColumnBuilder, augmentDescriptorWithColumnMeta, codec, compact, createBinaryExpr, createCodecRegistry, createColumnRef, createDeleteAst, createExistsExpr, createInsertAst, createJoin, createJoinOnBuilder, createJoinOnExpr, createLiteralExpr, createOperationExpr, createOrderBuilder, createOrderByItem, createParamRef, createSelectAst, createTableRef, createUpdateAst, defineCodecs, isColumnBuilder, isOperationExpr, param, planInvalid, planUnsupported, schema };

package/dist/index.mjs

@@ -0,0 +1,12 @@
+import { n as isColumnBuilder, t as createOrderBuilder } from "./types-D_FRJvm0.mjs";
+import { codec, compact, createBinaryExpr, createCodecRegistry, createColumnRef, createDeleteAst, createExistsExpr, createInsertAst, createJoin, createJoinOnBuilder, createJoinOnExpr, createLiteralExpr, createOperationExpr, createOrderByItem, createParamRef, createSelectAst, createTableRef, createUpdateAst, defineCodecs, isOperationExpr } from "./exports/ast.mjs";
+import { n as planUnsupported, t as planInvalid } from "./errors-BwxypN2Q.mjs";
+import { t as attachOperationsToColumnBuilder } from "./operations-registry-7R5KE2-5.mjs";
+import "./exports/operations-registry.mjs";
+import { t as param } from "./param-BFvNAaHR.mjs";
+import { augmentDescriptorWithColumnMeta } from "./exports/plan.mjs";
+import "./exports/query-lane-context.mjs";
+import { n as TableBuilderImpl, r as schema, t as ColumnBuilderImpl } from "./schema-BsY2EXAf.mjs";
+import "./exports/types.mjs";
+
+export { ColumnBuilderImpl, TableBuilderImpl, attachOperationsToColumnBuilder, augmentDescriptorWithColumnMeta, codec, compact, createBinaryExpr, createCodecRegistry, createColumnRef, createDeleteAst, createExistsExpr, createInsertAst, createJoin, createJoinOnBuilder, createJoinOnExpr, createLiteralExpr, createOperationExpr, createOrderBuilder, createOrderByItem, createParamRef, createSelectAst, createTableRef, createUpdateAst, defineCodecs, isColumnBuilder, isOperationExpr, param, planInvalid, planUnsupported, schema };

package/dist/operations-registry-7R5KE2-5.mjs

@@ -0,0 +1,152 @@
+import { d as isParamPlaceholder } from "./guards-4T0IByJo.mjs";
+import { planInvalid } from "@prisma-next/plan";
+import { hasAllCapabilities } from "@prisma-next/operations";
+
+//#region src/operations-registry.ts
+/**
+* Type guard to check if a value is an ExpressionSource (has toExpr method).
+*/
+function isExpressionSource(value) {
+	return typeof value === "object" && value !== null && "toExpr" in value && typeof value.toExpr === "function";
+}
+/**
+* Executes an operation and returns an ExpressionBuilder.
+* This is the canonical entrypoint for operation invocation, enabling
+* future enhancements like telemetry, caching, or tracing.
+*
+* The returned ExpressionBuilder:
+* - Has `kind: 'expression'` to distinguish it from ColumnBuilder
+* - Contains the operation expression in `expr`
+* - Provides `toExpr()` method to get the Expression
+* - Provides comparison and ordering methods for chaining
+*
+* @param signature - The operation signature from the registry
+* @param selfBuilder - The expression source that the operation is called on
+* @param args - The arguments passed to the operation
+* @param columnMeta - The metadata of the column the operation is called on
+* @returns An ExpressionBuilder containing the operation expression
+*/
+function executeOperation(signature, selfBuilder, args, columnMeta, operationRegistry, contractCapabilities) {
+	if (args.length !== signature.args.length) throw planInvalid(`Operation ${signature.method} expects ${signature.args.length} arguments, got ${args.length}`);
+	const selfExpr = selfBuilder.toExpr();
+	const operationArgs = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		const argSpec = signature.args[i];
+		if (!argSpec) throw planInvalid(`Missing argument spec for argument ${i}`);
+		if (argSpec.kind === "param") {
+			if (!isParamPlaceholder(arg)) throw planInvalid(`Argument ${i} must be a parameter placeholder`);
+			operationArgs.push({
+				kind: "param",
+				index: 0,
+				name: arg.name
+			});
+		} else if (argSpec.kind === "typeId") {
+			if (!isExpressionSource(arg)) throw planInvalid(`Argument ${i} must be an ExpressionSource (ColumnBuilder or ExpressionBuilder)`);
+			operationArgs.push(arg.toExpr());
+		} else if (argSpec.kind === "literal") operationArgs.push({
+			kind: "literal",
+			value: arg
+		});
+	}
+	const operationExpr = {
+		kind: "operation",
+		method: signature.method,
+		forTypeId: signature.forTypeId,
+		self: selfExpr,
+		args: operationArgs,
+		returns: signature.returns,
+		lowering: signature.lowering
+	};
+	const returnTypeId = signature.returns.kind === "typeId" ? signature.returns.type : void 0;
+	const returnColumnMeta = returnTypeId ? {
+		...columnMeta,
+		codecId: returnTypeId
+	} : columnMeta;
+	const createComparisonMethod = (op) => (value) => Object.freeze({
+		kind: "binary",
+		op,
+		left: operationExpr,
+		right: value
+	});
+	const baseResult = {
+		kind: "expression",
+		expr: operationExpr,
+		get columnMeta() {
+			return returnColumnMeta;
+		},
+		eq: createComparisonMethod("eq"),
+		neq: createComparisonMethod("neq"),
+		gt: createComparisonMethod("gt"),
+		lt: createComparisonMethod("lt"),
+		gte: createComparisonMethod("gte"),
+		lte: createComparisonMethod("lte"),
+		asc() {
+			return Object.freeze({
+				kind: "order",
+				expr: operationExpr,
+				dir: "asc"
+			});
+		},
+		desc() {
+			return Object.freeze({
+				kind: "order",
+				expr: operationExpr,
+				dir: "desc"
+			});
+		},
+		toExpr() {
+			return operationExpr;
+		},
+		get __jsType() {}
+	};
+	if (returnTypeId && operationRegistry) {
+		const resultWithOps = attachOperationsToExpressionBuilder(baseResult, returnColumnMeta, operationRegistry, contractCapabilities);
+		return Object.freeze(resultWithOps);
+	}
+	return Object.freeze(baseResult);
+}
+/**
+* Attaches operation methods to an ExpressionBuilder for chained operations.
+* When an operation returns a typeId, the result ExpressionBuilder needs
+* operation methods for that type.
+*/
+function attachOperationsToExpressionBuilder(expressionBuilder, columnMeta, registry, contractCapabilities) {
+	const codecId = columnMeta.codecId;
+	if (!codecId) return expressionBuilder;
+	const operations = registry.byType(codecId);
+	if (operations.length === 0) return expressionBuilder;
+	const builderWithOps = expressionBuilder;
+	for (const operation of operations) {
+		if (operation.capabilities && operation.capabilities.length > 0) {
+			if (!contractCapabilities) continue;
+			if (!hasAllCapabilities(operation.capabilities, contractCapabilities)) continue;
+		}
+		builderWithOps[operation.method] = function(...args) {
+			return executeOperation(operation, this, args, columnMeta, registry, contractCapabilities);
+		};
+	}
+	return builderWithOps;
+}
+function attachOperationsToColumnBuilder(columnBuilder, columnMeta, registry, contractCapabilities) {
+	if (!registry) return columnBuilder;
+	const codecId = columnMeta.codecId;
+	if (!codecId) return columnBuilder;
+	const operations = registry.byType(codecId);
+	if (operations.length === 0) return columnBuilder;
+	const builderWithOps = columnBuilder;
+	for (const operation of operations) {
+		if (operation.capabilities && operation.capabilities.length > 0) {
+			if (!contractCapabilities) continue;
+			if (!hasAllCapabilities(operation.capabilities, contractCapabilities)) continue;
+		}
+		builderWithOps[operation.method] = function(...args) {
+			return executeOperation(operation, this, args, columnMeta, registry, contractCapabilities);
+		};
+	}
+	return builderWithOps;
+}
+
+//#endregion
+export { attachOperationsToColumnBuilder as t };
+//# sourceMappingURL=operations-registry-7R5KE2-5.mjs.map

package/dist/operations-registry-7R5KE2-5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations-registry-7R5KE2-5.mjs","names":["selfExpr: Expression","operationArgs: Array<Expression | ParamRef | LiteralExpr>","operationExpr: OperationExpr","returnColumnMeta: StorageColumn","baseResult: ExpressionBuilder"],"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":";;;;;;;;AA0BA,SAAS,mBAAmB,OAA2C;AACrE,QACE,OAAO,UAAU,YACjB,UAAU,QACV,YAAY,SACZ,OAAQ,MAA2B,WAAW;;;;;;;;;;;;;;;;;;;AAqBlD,SAAS,iBACP,WACA,aACA,MACA,YACA,mBACA,sBACmB;AACnB,KAAI,KAAK,WAAW,UAAU,KAAK,OACjC,OAAM,YACJ,aAAa,UAAU,OAAO,WAAW,UAAU,KAAK,OAAO,kBAAkB,KAAK,SACvF;CAIH,MAAMA,WAAuB,YAAY,QAAQ;CAEjD,MAAMC,gBAA4D,EAAE;AACpE,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,MAAM,MAAM,KAAK;EACjB,MAAM,UAAU,UAAU,KAAK;AAC/B,MAAI,CAAC,QACH,OAAM,YAAY,sCAAsC,IAAI;AAG9D,MAAI,QAAQ,SAAS,SAAS;AAC5B,OAAI,CAAC,mBAAmB,IAAI,CAC1B,OAAM,YAAY,YAAY,EAAE,kCAAkC;AAEpE,iBAAc,KAAK;IACjB,MAAM;IACN,OAAO;IACP,MAAM,IAAI;IACX,CAAC;aACO,QAAQ,SAAS,UAAU;AAEpC,OAAI,CAAC,mBAAmB,IAAI,CAC1B,OAAM,YACJ,YAAY,EAAE,mEACf;AAGH,iBAAc,KAAK,IAAI,QAAQ,CAAC;aACvB,QAAQ,SAAS,UAC1B,eAAc,KAAK;GACjB,MAAM;GACN,OAAO;GACR,CAAC;;CAIN,MAAMC,gBAA+B;EACnC,MAAM;EACN,QAAQ,UAAU;EAClB,WAAW,UAAU;EACrB,MAAM;EACN,MAAM;EACN,SAAS,UAAU;EACnB,UAAU,UAAU;EACrB;CAED,MAAM,eAAe,UAAU,QAAQ,SAAS,WAAW,UAAU,QAAQ,OAAO;CACpF,MAAMC,mBAAkC,eACpC;EACE,GAAG;EACH,SAAS;EACV,GACD;CAEJ,MAAM,0BACH,QACA,UACC,OAAO,OAAO;EACZ,MAAM;EACN;EACA,MAAM;EACN,OAAO;EACR,CAAC;CAEN,MAAMC,aAAgC;EACpC,MAAM;EACN,MAAM;EACN,IAAI,aAAa;AACf,UAAO;;EAET,IAAI,uBAAuB,KAAK;EAChC,KAAK,uBAAuB,MAAM;EAClC,IAAI,uBAAuB,KAAK;EAChC,IAAI,uBAAuB,KAAK;EAChC,KAAK,uBAAuB,MAAM;EAClC,KAAK,uBAAuB,MAAM;EAClC,MAAuB;AACrB,UAAO,OAAO,OAAO;IACnB,MAAM;IACN,MAAM;IACN,KAAK;IACN,CAAC;;EAEJ,OAAwB;AACtB,UAAO,OAAO,OAAO;IACnB,MAAM;IACN,MAAM;IACN,KAAK;IACN,CAAC;;EAEJ,SAAwB;AACtB,UAAO;;EAET,IAAI,WAAoB;EAGzB;AAGD,KAAI,gBAAgB,mBAAmB;EACrC,MAAM,gBAAgB,oCACpB,YACA,kBACA,mBACA,qBACD;AACD,SAAO,OAAO,OAAO,cAAc;;AAGrC,QAAO,OAAO,OAAO,WAAW;;;;;;;AAQlC,SAAS,oCACP,mBACA,YACA,UACA,sBACmB;CACnB,MAAM,UAAU,WAAW;AAC3B,KAAI,CAAC,QACH,QAAO;CAGT,MAAM,aAAa,SAAS,OAAO,QAAQ;AAC3C,KAAI,WAAW,WAAW,EACxB,QAAO;CAGT,MAAM,iBAAiB;AAEvB,MAAK,MAAM,aAAa,YAAY;AAClC,MAAI,UAAU,gBAAgB,UAAU,aAAa,SAAS,GAAG;AAC/D,OAAI,CAAC,qBACH;AAGF,OAAI,CAAC,mBAAmB,UAAU,cAAc,qBAAqB,CACnE;;AAIJ,iBAAe,UAAU,UAAU,SAAmC,GAAG,MAAiB;AACxF,UAAO,iBAAiB,WAAW,MAAM,MAAM,YAAY,UAAU,qBAAqB;;;AAI9F,QAAO;;AAGT,SAAgB,gCAMd,eACA,YACA,UACA,sBAC2D;AAC3D,KAAI,CAAC,SACH,QAAO;CAIT,MAAM,UAAU,WAAW;AAC3B,KAAI,CAAC,QACH,QAAO;CAGT,MAAM,aAAa,SAAS,OAAO,QAAQ;AAC3C,KAAI,WAAW,WAAW,EACxB,QAAO;CAGT,MAAM,iBAAiB;AAOvB,MAAK,MAAM,aAAa,YAAY;AAClC,MAAI,UAAU,gBAAgB,UAAU,aAAa,SAAS,GAAG;AAC/D,OAAI,CAAC,qBACH;AAGF,OAAI,CAAC,mBAAmB,UAAU,cAAc,qBAAqB,CACnE;;AAKJ,EAAC,eAA2C,UAAU,UAAU,SAE9D,GAAG,MACH;AACA,UAAO,iBAAiB,WAAW,MAAM,MAAM,YAAY,UAAU,qBAAqB;;;AAI9F,QAAO"}

package/dist/operations-registry-CIcn4f2P.d.mts

@@ -0,0 +1,9 @@
+import { D as OperationTypes, u as ColumnBuilder } from "./types-Bg2kUmUA.mjs";
+import { OperationRegistry } from "@prisma-next/operations";
+import { StorageColumn } from "@prisma-next/sql-contract/types";
+
+//#region src/operations-registry.d.ts
+declare function attachOperationsToColumnBuilder<ColumnName extends string, ColumnMeta extends StorageColumn, JsType = unknown, Operations extends OperationTypes = Record<string, never>>(columnBuilder: ColumnBuilder<ColumnName, ColumnMeta, JsType, Record<string, never>>, columnMeta: ColumnMeta, registry: OperationRegistry | undefined, contractCapabilities?: Record<string, Record<string, boolean>>): ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;
+//#endregion
+export { attachOperationsToColumnBuilder as t };
+//# sourceMappingURL=operations-registry-CIcn4f2P.d.mts.map

package/dist/operations-registry-CIcn4f2P.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations-registry-CIcn4f2P.d.mts","names":[],"sources":["../src/operations-registry.ts"],"sourcesContent":[],"mappings":";;;;;iBA6NgB,8EAEK,oDAEA,iBAAiB,sCAErB,cAAc,YAAY,YAAY,QAAQ,oCACjD,sBACF,sDACa,eAAe,2BACrC,cAAc,YAAY,YAAY,QAAQ"}

package/dist/param-B4LzVPv2.d.mts

@@ -0,0 +1,8 @@
+import { A as ParamPlaceholder } from "./types-Bg2kUmUA.mjs";
+
+//#region src/param.d.ts
+type Parameter = ParamPlaceholder;
+declare function param(name: string): Parameter;
+//#endregion
+export { param as n, Parameter as t };
+//# sourceMappingURL=param-B4LzVPv2.d.mts.map

package/dist/param-B4LzVPv2.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"param-B4LzVPv2.d.mts","names":[],"sources":["../src/param.ts"],"sourcesContent":[],"mappings":";;;KAGY,SAAA,GAAY;iBAER,KAAA,gBAAqB"}

package/dist/param-BFvNAaHR.mjs

@@ -0,0 +1,14 @@
+import { planInvalid } from "@prisma-next/plan";
+
+//#region src/param.ts
+function param(name) {
+	if (typeof name !== "string" || name.length === 0) throw planInvalid("Parameter name must be a non-empty string");
+	return Object.freeze({
+		kind: "param-placeholder",
+		name
+	});
+}
+
+//#endregion
+export { param as t };
+//# sourceMappingURL=param-BFvNAaHR.mjs.map

package/dist/param-BFvNAaHR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"param-BFvNAaHR.mjs","names":[],"sources":["../src/param.ts"],"sourcesContent":["import { planInvalid } from '@prisma-next/plan';\nimport type { ParamPlaceholder } from './types';\n\nexport type Parameter = ParamPlaceholder;\n\nexport function param(name: string): Parameter {\n  if (typeof name !== 'string' || name.length === 0) {\n    throw planInvalid('Parameter name must be a non-empty string');\n  }\n\n  return Object.freeze({\n    kind: 'param-placeholder' as const,\n    name,\n  }) satisfies Parameter;\n}\n"],"mappings":";;;AAKA,SAAgB,MAAM,MAAyB;AAC7C,KAAI,OAAO,SAAS,YAAY,KAAK,WAAW,EAC9C,OAAM,YAAY,4CAA4C;AAGhE,QAAO,OAAO,OAAO;EACnB,MAAM;EACN;EACD,CAAC"}

package/dist/plan-9PvH-Tu3.d.mts

@@ -0,0 +1,157 @@
+import { ReturnSpec } from "@prisma-next/operations";
+import { SqlLoweringSpec } from "@prisma-next/sql-operations";
+import { ExecutionPlan, ParamDescriptor } from "@prisma-next/contract/types";
+import { StorageColumn } from "@prisma-next/sql-contract/types";
+
+//#region src/ast/types.d.ts
+type Direction = 'asc' | 'desc';
+interface TableRef {
+  readonly kind: 'table';
+  readonly name: string;
+}
+interface ColumnRef {
+  readonly kind: 'col';
+  readonly table: string;
+  readonly column: string;
+}
+interface ParamRef {
+  readonly kind: 'param';
+  readonly index: number;
+  readonly name?: string;
+}
+interface LiteralExpr {
+  readonly kind: 'literal';
+  readonly value: unknown;
+}
+interface OperationExpr {
+  readonly kind: 'operation';
+  readonly method: string;
+  readonly forTypeId: string;
+  readonly self: Expression;
+  readonly args: ReadonlyArray<Expression | ParamRef | LiteralExpr>;
+  readonly returns: ReturnSpec;
+  readonly lowering: SqlLoweringSpec;
+}
+/**
+ * Unified expression type - the canonical AST representation for column references
+ * and operation expressions. This is what all builders convert to via toExpr().
+ */
+type Expression = ColumnRef | OperationExpr;
+/**
+ * Interface for any builder that can produce an Expression.
+ * Implemented by ColumnBuilder and ExpressionBuilder.
+ */
+interface ExpressionSource {
+  toExpr(): Expression;
+}
+declare function isOperationExpr(expr: Expression): expr is OperationExpr;
+type BinaryOp = 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte';
+interface BinaryExpr {
+  readonly kind: 'bin';
+  readonly op: BinaryOp;
+  readonly left: Expression;
+  readonly right: Expression | ParamRef;
+}
+interface ExistsExpr {
+  readonly kind: 'exists';
+  readonly not: boolean;
+  readonly subquery: SelectAst;
+}
+type JoinOnExpr = {
+  readonly kind: 'eqCol';
+  readonly left: ColumnRef;
+  readonly right: ColumnRef;
+};
+interface JoinAst {
+  readonly kind: 'join';
+  readonly joinType: 'inner' | 'left' | 'right' | 'full';
+  readonly table: TableRef;
+  readonly on: JoinOnExpr;
+}
+interface IncludeRef {
+  readonly kind: 'includeRef';
+  readonly alias: string;
+}
+interface IncludeAst {
+  readonly kind: 'includeMany';
+  readonly alias: string;
+  readonly child: {
+    readonly table: TableRef;
+    readonly on: JoinOnExpr;
+    readonly where?: BinaryExpr | ExistsExpr;
+    readonly orderBy?: ReadonlyArray<{
+      expr: Expression;
+      dir: Direction;
+    }>;
+    readonly limit?: number;
+    readonly project: ReadonlyArray<{
+      alias: string;
+      expr: Expression;
+    }>;
+  };
+}
+interface SelectAst {
+  readonly kind: 'select';
+  readonly from: TableRef;
+  readonly joins?: ReadonlyArray<JoinAst>;
+  readonly includes?: ReadonlyArray<IncludeAst>;
+  readonly project: ReadonlyArray<{
+    alias: string;
+    expr: Expression | IncludeRef | LiteralExpr;
+  }>;
+  readonly where?: BinaryExpr | ExistsExpr;
+  readonly orderBy?: ReadonlyArray<{
+    expr: Expression;
+    dir: Direction;
+  }>;
+  readonly limit?: number;
+}
+interface InsertAst {
+  readonly kind: 'insert';
+  readonly table: TableRef;
+  readonly values: Record<string, ColumnRef | ParamRef>;
+  readonly returning?: ReadonlyArray<ColumnRef>;
+}
+interface UpdateAst {
+  readonly kind: 'update';
+  readonly table: TableRef;
+  readonly set: Record<string, ColumnRef | ParamRef>;
+  readonly where: BinaryExpr;
+  readonly returning?: ReadonlyArray<ColumnRef>;
+}
+interface DeleteAst {
+  readonly kind: 'delete';
+  readonly table: TableRef;
+  readonly where: BinaryExpr;
+  readonly returning?: ReadonlyArray<ColumnRef>;
+}
+type QueryAst = SelectAst | InsertAst | UpdateAst | DeleteAst;
+interface LoweredStatement {
+  readonly sql: string;
+  readonly params: readonly unknown[];
+  readonly annotations?: Record<string, unknown>;
+}
+//#endregion
+//#region src/plan.d.ts
+/**
+ * SQL query plan produced by lanes before lowering.
+ *
+ * Lanes build ASTs and metadata but do not perform SQL lowering.
+ * The `sql` field is absent - lowering happens in the runtime executor.
+ *
+ * Structurally aligns with ExecutionPlan<Row, QueryAst> (without sql field) to maintain
+ * compatibility with ExecutionPlan/Plan-based utilities.
+ * The generic parameter `_Row` is preserved for type extraction via ResultType.
+ */
+interface SqlQueryPlan<_Row = unknown> extends Pick<ExecutionPlan<_Row, QueryAst>, 'params' | 'meta'> {
+  readonly ast: QueryAst;
+  readonly _Row?: _Row;
+}
+/**
+ * Augments the last ParamDescriptor in the array with codecId and nativeType from columnMeta.
+ * This is used when building WHERE expressions to ensure param descriptors have type information.
+ */
+declare function augmentDescriptorWithColumnMeta(descriptors: ParamDescriptor[], columnMeta: StorageColumn | undefined): void;
+//#endregion
+export { UpdateAst as C, TableRef as S, LoweredStatement as _, ColumnRef as a, QueryAst as b, ExistsExpr as c, IncludeAst as d, IncludeRef as f, LiteralExpr as g, JoinOnExpr as h, BinaryOp as i, Expression as l, JoinAst as m, augmentDescriptorWithColumnMeta as n, DeleteAst as o, InsertAst as p, BinaryExpr as r, Direction as s, SqlQueryPlan as t, ExpressionSource as u, OperationExpr as v, isOperationExpr as w, SelectAst as x, ParamRef as y };
+//# sourceMappingURL=plan-9PvH-Tu3.d.mts.map

package/dist/plan-9PvH-Tu3.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-9PvH-Tu3.d.mts","names":[],"sources":["../src/ast/types.ts","../src/plan.ts"],"sourcesContent":[],"mappings":"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"}