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

package/dist/guards-0ycyntYX.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-0ycyntYX.mjs.map

package/dist/guards-0ycyntYX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards-0ycyntYX.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/guards-DCCpAlOL.d.mts

@@ -0,0 +1,87 @@
+import { S as OperationExpr, d as Expression, f as ExpressionSource, s as ColumnRef, w as ParamRef, y as LiteralExpr } from "./plan-BhSWuTfw.mjs";
+import { N as ParamPlaceholder, h as ExpressionBuilder, i as AnyExpressionSource, n as AnyColumnBuilder, q as ValueSource } from "./types-CEUzDuDC.mjs";
+import { StorageColumn } from "@prisma-next/sql-contract/types";
+
+//#region src/utils/guards.d.ts
+
+/**
+ * Helper to extract columnMeta from a ColumnBuilder or ExpressionBuilder.
+ * Returns StorageColumn if present, undefined otherwise.
+ * Both ColumnBuilder and ExpressionBuilder have columnMeta property.
+ */
+declare function getColumnMeta(expr: AnyExpressionSource): StorageColumn | undefined;
+/**
+ * Type predicate to check if a value is a ParamPlaceholder.
+ */
+declare function isParamPlaceholder(value: unknown): value is ParamPlaceholder;
+/**
+ * Recursively extracts the base ColumnRef from an OperationExpr.
+ * If the expression is already a ColumnRef, it is returned directly.
+ */
+declare function extractBaseColumnRef(expr: ColumnRef | OperationExpr): ColumnRef;
+/**
+ * Recursively collects all ColumnRef nodes from an expression tree.
+ * Handles nested OperationExpr structures by traversing both self and args.
+ */
+declare function collectColumnRefs(expr: ColumnRef | ParamRef | LiteralExpr | OperationExpr): ColumnRef[];
+/**
+ * Type predicate to check if an expression is an OperationExpr.
+ */
+declare function isOperationExpr(expr: AnyExpressionSource | OperationExpr | Expression): expr is OperationExpr;
+/**
+ * Helper to extract table and column from a ColumnBuilder, ExpressionBuilder, or OperationExpr.
+ * For ExpressionBuilder or OperationExpr, recursively unwraps to find the base ColumnRef.
+ */
+declare function getColumnInfo(expr: AnyExpressionSource | OperationExpr): {
+  table: string;
+  column: string;
+};
+/**
+ * Type predicate to check if a value is a ColumnBuilder.
+ */
+declare function isColumnBuilder(value: unknown): value is AnyColumnBuilder;
+/**
+ * Type predicate to check if a value is an ExpressionBuilder.
+ */
+declare function isExpressionBuilder(value: unknown): value is ExpressionBuilder;
+/**
+ * Type predicate to check if a value is an ExpressionSource (has toExpr method).
+ */
+declare function isExpressionSource(value: unknown): value is ExpressionSource;
+/**
+ * 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)
+ */
+declare function toExpression(source: ExpressionSource): Expression;
+/**
+ * Converts an AnyExpressionSource to an Expression.
+ * Handles both ColumnBuilder and ExpressionBuilder.
+ *
+ * @param source - A ColumnBuilder or ExpressionBuilder
+ * @returns The corresponding Expression (ColumnRef or OperationExpr)
+ */
+declare function expressionFromSource(source: AnyExpressionSource): Expression;
+/**
+ * Type predicate to check if a value is a ValueSource.
+ * ValueSource is either a ParamPlaceholder or an ExpressionSource.
+ */
+declare function isValueSource(value: unknown): value is ValueSource;
+/**
+ * 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.
+ */
+declare function getOperationExpr(builder: AnyColumnBuilder | OperationExpr): OperationExpr | undefined;
+//#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-DCCpAlOL.d.mts.map

package/dist/guards-DCCpAlOL.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards-DCCpAlOL.d.mts","names":[],"sources":["../src/utils/guards.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAsBA;AAYA;AAeA;AAA2C,iBA3B3B,aAAA,CA2B2B,IAAA,EA3BP,mBA2BO,CAAA,EA3Be,aA2Bf,GAAA,SAAA;;;;AAW3B,iBA1BA,kBAAA,CA0BiB,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IA1B4B,gBA0B5B;;;;;AAE9B,iBAba,oBAAA,CAab,IAAA,EAbwC,SAaxC,GAboD,aAapD,CAAA,EAboE,SAapE;;AAiBH;;;AAC8C,iBApB9B,iBAAA,CAoB8B,IAAA,EAnBtC,SAmBsC,GAnB1B,QAmB0B,GAnBf,WAmBe,GAnBD,aAmBC,CAAA,EAlB3C,SAkB2C,EAAA;;;AAS9C;AAoBgB,iBA9BA,eAAA,CA8B0C,IAAA,EA7BlD,mBA6BkE,GA7B5C,aA6B4C,GA7B5B,UA6B4B,CAAA,EAAA,IAAA,IA5B/D,aA4B+D;AAY1E;AAYA;AAgBA;AAWA;AAQgB,iBA/EA,aAAA,CA+EwC,IAAA,EA/EpB,mBA+E+B,GA/ET,aA+ES,CAAA,EAAA;EAgBnD,KAAA,EAAA,MAAA;EACL,MAAA,EAAA,MAAA;CAAmB;;;;iBA5Ed,eAAA,2BAA0C;;;;iBAY1C,mBAAA,2BAA8C;;;;iBAY9C,kBAAA,2BAA6C;;;;;;;;iBAgB7C,YAAA,SAAqB,mBAAmB;;;;;;;;iBAWxC,oBAAA,SAA6B,sBAAsB;;;;;iBAQnD,aAAA,2BAAwC;;;;;;;;;;;;;iBAgBxC,gBAAA,UACL,mBAAmB,gBAC3B"}

package/dist/index.d.mts

@@ -0,0 +1,12 @@
+import { S as defineCodecs, _ as CodecRegistry, a as JsonSchemaValidationResult, b as codec, c as MutationDefaultsOptions, d as CodecDefBuilder, f as CodecId, g as CodecParamsDescriptor, h as CodecOutput, i as JsonSchemaValidationError, l as TypeHelperRegistry, m as CodecMeta, n as ExecutionContext, o as JsonSchemaValidatorRegistry, p as CodecInput, r as JsonSchemaValidateFn, s as MutationDefaultsOp, t as AppliedMutationDefault, u as Codec, v as ExtractCodecTypes, x as createCodecRegistry, y as ExtractDataTypes } from "./query-lane-context-CgkPuKaR.mjs";
+import { A as WhereArg, C as OrExpr, D as TableRef, E as SelectAst, M as isOperationExpr, O as ToWhereExpr, S as OperationExpr, T as QueryAst, _ as JoinOnExpr, a as BinaryOp, b as LoweredStatement, c as DeleteAst, d as Expression, f as ExpressionSource, g as JoinAst, h as InsertAst, i as BinaryExpr, j as WhereExpr, k as UpdateAst, l as Direction, m as IncludeRef, n as augmentDescriptorWithColumnMeta, o as BoundWhereExpr, p as IncludeAst, r as AndExpr, s as ColumnRef, t as SqlQueryPlan, u as ExistsExpr, v as ListLiteralExpr, w as ParamRef, x as NullCheckExpr, y as LiteralExpr } from "./plan-BhSWuTfw.mjs";
+import { A as OperationTypes, B as SqlBuilderOptions, C as Meta, D as NullCheckBuilder, E as NestedProjection, F as RawFunctionOptions, G as TablesOf, H as TableDef, I as RawTemplateFactory, J as createOrderBuilder, K as UnaryBuilder, L as RawTemplateOptions, M as OrderBuilder, N as ParamPlaceholder, O as NullableMethods, P as RawFactory, R as ResultType, S as META, T as ModelMetadata, U as TableKey, V as SqlPlan, W as TableMetadata, Y as isColumnBuilder, _ as InferNestedProjectionRow, a as AnyOrderBuilder, b as JoinOnBuilder, c as BuildOptions, d as ColumnBuilder, f as ColumnsOf, g as HasIncludeManyCapabilities, h as ExpressionBuilder, i as AnyExpressionSource, j as OperationsForTypeId, k as OperationTypeSignature, l as BuildParamsMap, m as Expr, n as AnyColumnBuilder, o as AnyUnaryBuilder, p as ComputeColumnJsType, q as ValueSource, r as AnyColumnBuilderBase, s as BinaryBuilder, t as AnyBinaryBuilder, u as CodecTypes, v as InferProjectionRow, w as ModelDef, x as JoinOnPredicate, y as InferReturningRow, z as RuntimeError } from "./types-CEUzDuDC.mjs";
+import { Adapter, AdapterProfile, AdapterTarget, CreateDeleteAstOptions, CreateInsertAstOptions, CreateSelectAstOptions, CreateUpdateAstOptions, LoweredPayload, Lowerer, LowererContext, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_VARCHAR_CODEC_ID, SqlCodecTypes, SqlConnection, SqlDriver, SqlDriverState, SqlExecuteRequest, SqlExplainResult, SqlQueryResult, SqlQueryable, SqlTransaction, compact, createBinaryExpr, createColumnRef, createDeleteAst, createExistsExpr, createInsertAst, createJoin, createJoinOnBuilder, createJoinOnExpr, createLiteralExpr, createNullCheckExpr, createOperationExpr, createOrderByItem, createParamRef, createSelectAst, createTableRef, createUpdateAst, sqlCodecDefinitions, sqlDataTypes } from "./exports/ast.mjs";
+import { n as planUnsupported, t as planInvalid } from "./errors-DVufq9PT.mjs";
+import { t as attachOperationsToColumnBuilder } from "./operations-registry-wVEaiLyt.mjs";
+import { n as param, t as Parameter } from "./param-C4n0OW59.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-CgrEMqEd.mjs";
+import "./exports/types.mjs";
+export { Adapter, AdapterProfile, AdapterTarget, AndExpr, AnyBinaryBuilder, AnyColumnBuilder, AnyColumnBuilderBase, AnyExpressionSource, AnyOrderBuilder, AnyUnaryBuilder, AppliedMutationDefault, BinaryBuilder, BinaryExpr, BinaryOp, BoundWhereExpr, BuildOptions, BuildParamsMap, Codec, CodecDefBuilder, CodecId, CodecInput, CodecMeta, CodecOutput, CodecParamsDescriptor, CodecRegistry, CodecTypes, ColumnBuilderImpl as Column, ColumnBuilderImpl, ColumnBuilder, ColumnRef, ColumnsOf, ComputeColumnJsType, CreateDeleteAstOptions, CreateInsertAstOptions, CreateSelectAstOptions, CreateUpdateAstOptions, DeleteAst, Direction, ExecutionContext, ExistsExpr, Expr, Expression, ExpressionBuilder, ExpressionSource, ExtractCodecTypes, ExtractDataTypes, HasIncludeManyCapabilities, IncludeAst, IncludeRef, InferNestedProjectionRow, InferProjectionRow, InferReturningRow, InsertAst, JoinAst, JoinOnBuilder, JoinOnExpr, JoinOnPredicate, JsonSchemaValidateFn, JsonSchemaValidationError, JsonSchemaValidationResult, JsonSchemaValidatorRegistry, ListLiteralExpr, LiteralExpr, LoweredPayload, LoweredStatement, Lowerer, LowererContext, META, Meta, ModelDef, ModelMetadata, MutationDefaultsOp, MutationDefaultsOptions, NestedProjection, NullCheckBuilder, NullCheckExpr, NullableMethods, OperationExpr, OperationTypeSignature, OperationTypes, OperationsForTypeId, OrExpr, OrderBuilder, ParamPlaceholder, ParamRef, Parameter, QueryAst, RawFactory, RawFunctionOptions, RawTemplateFactory, RawTemplateOptions, ResultType, RuntimeError, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_VARCHAR_CODEC_ID, SchemaHandle, SelectAst, SqlBuilderOptions, SqlCodecTypes, SqlConnection, SqlDriver, SqlDriverState, SqlExecuteRequest, SqlExplainResult, SqlPlan, SqlQueryPlan, SqlQueryResult, SqlQueryable, SqlTransaction, TableBuilderImpl as Table, TableBuilderImpl, TableDef, TableKey, TableMetadata, TableRef, TablesOf, ToWhereExpr, TypeHelperRegistry, UnaryBuilder, UpdateAst, ValueSource, WhereArg, WhereExpr, attachOperationsToColumnBuilder, augmentDescriptorWithColumnMeta, codec, compact, createBinaryExpr, createCodecRegistry, createColumnRef, createDeleteAst, createExistsExpr, createInsertAst, createJoin, createJoinOnBuilder, createJoinOnExpr, createLiteralExpr, createNullCheckExpr, createOperationExpr, createOrderBuilder, createOrderByItem, createParamRef, createSelectAst, createTableRef, createUpdateAst, defineCodecs, isColumnBuilder, isOperationExpr, param, planInvalid, planUnsupported, schema, sqlCodecDefinitions, sqlDataTypes };

package/dist/index.mjs

@@ -0,0 +1,12 @@
+import { n as isColumnBuilder, t as createOrderBuilder } from "./types-Cdi4Whda.mjs";
+import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_VARCHAR_CODEC_ID, codec, compact, createBinaryExpr, createCodecRegistry, createColumnRef, createDeleteAst, createExistsExpr, createInsertAst, createJoin, createJoinOnBuilder, createJoinOnExpr, createLiteralExpr, createNullCheckExpr, createOperationExpr, createOrderByItem, createParamRef, createSelectAst, createTableRef, createUpdateAst, defineCodecs, isOperationExpr, sqlCodecDefinitions, sqlDataTypes } from "./exports/ast.mjs";
+import { n as planUnsupported, t as planInvalid } from "./errors-7_V3El9I.mjs";
+import { t as attachOperationsToColumnBuilder } from "./operations-registry-DPZ5aElH.mjs";
+import "./exports/operations-registry.mjs";
+import { t as param } from "./param-DMU3OWfI.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-Bi5p4aAc.mjs";
+import "./exports/types.mjs";
+
+export { ColumnBuilderImpl, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_VARCHAR_CODEC_ID, TableBuilderImpl, attachOperationsToColumnBuilder, augmentDescriptorWithColumnMeta, codec, compact, createBinaryExpr, createCodecRegistry, createColumnRef, createDeleteAst, createExistsExpr, createInsertAst, createJoin, createJoinOnBuilder, createJoinOnExpr, createLiteralExpr, createNullCheckExpr, createOperationExpr, createOrderBuilder, createOrderByItem, createParamRef, createSelectAst, createTableRef, createUpdateAst, defineCodecs, isColumnBuilder, isOperationExpr, param, planInvalid, planUnsupported, schema, sqlCodecDefinitions, sqlDataTypes };

package/dist/operations-registry-DPZ5aElH.mjs

@@ -0,0 +1,152 @@
+import { d as isParamPlaceholder } from "./guards-0ycyntYX.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-DPZ5aElH.mjs.map

package/dist/operations-registry-DPZ5aElH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations-registry-DPZ5aElH.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":"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"}

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

@@ -0,0 +1,9 @@
+import { A as OperationTypes, d as ColumnBuilder } from "./types-CEUzDuDC.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-wVEaiLyt.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operations-registry-wVEaiLyt.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-C4n0OW59.d.mts

@@ -0,0 +1,8 @@
+import { N as ParamPlaceholder } from "./types-CEUzDuDC.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-C4n0OW59.d.mts.map

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

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

package/dist/param-DMU3OWfI.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-DMU3OWfI.mjs.map

package/dist/param-DMU3OWfI.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"param-DMU3OWfI.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"}