@prisma-next/sql-relational-core 0.11.0 → 0.12.0

package/dist/{types-BJHEQbci.d.mts → types-CkTDkFcK.d.mts}

@@ -1,5 +1,5 @@
-import { t as SqlExecutionPlan } from "./sql-execution-plan-B84vOmgK.mjs";
-import { t as SqlQueryPlan } from "./plan-D-Q5B-z_.mjs";
+import { t as SqlExecutionPlan } from "./sql-execution-plan-D4OimCVH.mjs";
+import { t as SqlQueryPlan } from "./plan-CG3sy5kw.mjs";
 import { RuntimeExecutor } from "@prisma-next/framework-components/runtime";
 
 //#region src/runtime-scope.d.ts
@@ -20,4 +20,4 @@ type SqlOrmPlan = SqlExecutionPlan | SqlQueryPlan;
 type RuntimeScope = Pick<RuntimeExecutor<SqlOrmPlan>, 'execute'>;
 //#endregion
 export { SqlOrmPlan as n, RuntimeScope as t };
-//# sourceMappingURL=types-BJHEQbci.d.mts.map
+//# sourceMappingURL=types-CkTDkFcK.d.mts.map

package/dist/types-CkTDkFcK.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-CkTDkFcK.d.mts","names":[],"sources":["../src/runtime-scope.ts"],"mappings":";;;;;;;;AASA;;KAAY,UAAA,GAAa,gBAAA,GAAmB,YAAY;;AAAA;AAUxD;;;;;;KAAY,YAAA,GAAe,IAAA,CAAK,eAAA,CAAgB,UAAA"}

package/dist/{types-DiV49xLs.d.mts → types-DoolOzqd.d.mts}

@@ -1,8 +1,8 @@
-import { J as ParamRef, g as ColumnRef } from "./types-DNGyueh7.mjs";
+import { J as ParamRef, g as ColumnRef } from "./types-C_1ZqLwZ.mjs";
 import { r as ExecutionContext } from "./query-lane-context-Dw1Tz0kv.mjs";
-import { t as SqlExecutionPlan } from "./sql-execution-plan-B84vOmgK.mjs";
+import { t as SqlExecutionPlan } from "./sql-execution-plan-D4OimCVH.mjs";
 import { ExtractFieldOutputTypes, SqlStorage, StorageColumn } from "@prisma-next/sql-contract/types";
-import { Contract } from "@prisma-next/contract/types";
+import { Contract, ContractModelsMap } from "@prisma-next/contract/types";
 import { ParamSpec } from "@prisma-next/operations";
 import { SqlLoweringSpec } from "@prisma-next/sql-operations";
 
@@ -12,7 +12,7 @@ type Expr = ColumnRef | ParamRef;
  * Extracts the model name for a given table by iterating models to find the one
  * whose `storage.table` matches.
  */
-type ExtractTableToModel<TContract extends Contract<SqlStorage>, TableName extends string> = TContract['models'] extends infer Models extends Record<string, unknown> ? { [M in keyof Models & string]: Models[M] extends {
+type ExtractTableToModel<TContract extends Contract<SqlStorage>, TableName extends string> = ContractModelsMap<TContract> extends infer Models extends Record<string, unknown> ? { [M in keyof Models & string]: Models[M] extends {
   readonly storage: {
     readonly table: TableName;
   };
@@ -21,7 +21,7 @@ type ExtractTableToModel<TContract extends Contract<SqlStorage>, TableName exten
  * Extracts the field name for a given column by finding the field in
  * `model.storage.fields` whose `column` matches.
  */
-type ExtractColumnToField<TContract extends Contract<SqlStorage>, TableName extends string, ColumnName extends string> = ExtractTableToModel<TContract, TableName> extends infer ModelName extends string ? TContract['models'] extends infer Models extends Record<string, unknown> ? ModelName & keyof Models extends infer MKey extends string ? Models[MKey] extends {
+type ExtractColumnToField<TContract extends Contract<SqlStorage>, TableName extends string, ColumnName extends string> = ExtractTableToModel<TContract, TableName> extends infer ModelName extends string ? ContractModelsMap<TContract> extends infer Models extends Record<string, unknown> ? ModelName & keyof Models extends infer MKey extends string ? Models[MKey] extends {
   readonly storage: {
     readonly fields: infer Fields extends Record<string, unknown>;
   };
@@ -190,4 +190,4 @@ interface SqlBuilderOptions<TContract extends Contract<SqlStorage> = Contract<Sq
 }
 //#endregion
 export { TableKey as C, TableDef as S, TablesOf as T, RawTemplateFactory as _, ComputeColumnJsType as a, SqlBuilderOptions as b, META as c, ModelMetadata as d, OperationTypeSignature as f, RawFunctionOptions as g, RawFactory as h, ColumnsOf as i, Meta as l, OperationsForTypeId as m, BuildParamsMap as n, Expr as o, OperationTypes as p, CodecTypes as r, HasIncludeManyCapabilities as s, BuildOptions as t, ModelDef as u, RawTemplateOptions as v, TableMetadata as w, SqlPlan as x, RuntimeError as y };
-//# sourceMappingURL=types-DiV49xLs.d.mts.map
+//# sourceMappingURL=types-DoolOzqd.d.mts.map

package/dist/types-DoolOzqd.d.mts.map

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

package/dist/util-DWmhUCEO.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"util-DWmhUCEO.mjs","names":[],"sources":["../src/ast/util.ts"],"sourcesContent":["import type { AnyParamRef, AnyQueryAst } from './types';\n\nexport function compact<T extends Record<string, unknown>>(o: T): T {\n  const out: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(o)) {\n    if (v === undefined || v === null) continue;\n    if (Array.isArray(v) && v.length === 0) continue;\n    out[k] = v;\n  }\n  return out as T;\n}\n\n/**\n * Walks an AST's parameter references in first-encounter order and dedupes\n * by ParamRef identity. The single canonical helper used by every consumer\n * that aligns `plan.params` with metadata-by-index — the SQL builder lane,\n * the SQL ORM client, the SQL runtime encoder, and the Postgres renderer's\n * `$N` index map — so the four walks cannot drift in dedupe semantics.\n *\n * SQLite's `?`-placeholder renderer intentionally does NOT use this helper\n * because it needs one params entry per occurrence in the SQL.\n */\nexport function collectOrderedParamRefs(ast: AnyQueryAst): ReadonlyArray<AnyParamRef> {\n  const seen = new Set<AnyParamRef>();\n  const ordered: AnyParamRef[] = [];\n  for (const ref of ast.collectParamRefs()) {\n    if (seen.has(ref)) continue;\n    seen.add(ref);\n    ordered.push(ref);\n  }\n  return Object.freeze(ordered);\n}\n"],"mappings":";AAEA,SAAgB,QAA2C,GAAS;CAClE,MAAM,MAA+B,EAAE;CACvC,KAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,EAAE,EAAE;EACtC,IAAI,MAAM,KAAA,KAAa,MAAM,MAAM;EACnC,IAAI,MAAM,QAAQ,EAAE,IAAI,EAAE,WAAW,GAAG;EACxC,IAAI,KAAK;;CAEX,OAAO;;;;;;;;;;;;AAaT,SAAgB,wBAAwB,KAA8C;CACpF,MAAM,uBAAO,IAAI,KAAkB;CACnC,MAAM,UAAyB,EAAE;CACjC,KAAK,MAAM,OAAO,IAAI,kBAAkB,EAAE;EACxC,IAAI,KAAK,IAAI,IAAI,EAAE;EACnB,KAAK,IAAI,IAAI;EACb,QAAQ,KAAK,IAAI;;CAEnB,OAAO,OAAO,OAAO,QAAQ"}
+{"version":3,"file":"util-DWmhUCEO.mjs","names":[],"sources":["../src/ast/util.ts"],"sourcesContent":["import type { AnyParamRef, AnyQueryAst } from './types';\n\nexport function compact<T extends Record<string, unknown>>(o: T): T {\n  const out: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(o)) {\n    if (v === undefined || v === null) continue;\n    if (Array.isArray(v) && v.length === 0) continue;\n    out[k] = v;\n  }\n  return out as T;\n}\n\n/**\n * Walks an AST's parameter references in first-encounter order and dedupes\n * by ParamRef identity. The single canonical helper used by every consumer\n * that aligns `plan.params` with metadata-by-index — the SQL builder lane,\n * the SQL ORM client, the SQL runtime encoder, and the Postgres renderer's\n * `$N` index map — so the four walks cannot drift in dedupe semantics.\n *\n * SQLite's `?`-placeholder renderer intentionally does NOT use this helper\n * because it needs one params entry per occurrence in the SQL.\n */\nexport function collectOrderedParamRefs(ast: AnyQueryAst): ReadonlyArray<AnyParamRef> {\n  const seen = new Set<AnyParamRef>();\n  const ordered: AnyParamRef[] = [];\n  for (const ref of ast.collectParamRefs()) {\n    if (seen.has(ref)) continue;\n    seen.add(ref);\n    ordered.push(ref);\n  }\n  return Object.freeze(ordered);\n}\n"],"mappings":";AAEA,SAAgB,QAA2C,GAAS;CAClE,MAAM,MAA+B,CAAC;CACtC,KAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,CAAC,GAAG;EACtC,IAAI,MAAM,KAAA,KAAa,MAAM,MAAM;EACnC,IAAI,MAAM,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG;EACxC,IAAI,KAAK;CACX;CACA,OAAO;AACT;;;;;;;;;;;AAYA,SAAgB,wBAAwB,KAA8C;CACpF,MAAM,uBAAO,IAAI,IAAiB;CAClC,MAAM,UAAyB,CAAC;CAChC,KAAK,MAAM,OAAO,IAAI,iBAAiB,GAAG;EACxC,IAAI,KAAK,IAAI,GAAG,GAAG;EACnB,KAAK,IAAI,GAAG;EACZ,QAAQ,KAAK,GAAG;CAClB;CACA,OAAO,OAAO,OAAO,OAAO;AAC9B"}

package/package.json

@@ -1,34 +1,43 @@
 {
   "name": "@prisma-next/sql-relational-core",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "AST types, query lane context, and type utilities for Prisma Next SQL lanes",
   "dependencies": {
-    "@prisma-next/contract": "0.11.0",
-    "@prisma-next/framework-components": "0.11.0",
-    "@prisma-next/operations": "0.11.0",
-    "@prisma-next/sql-contract": "0.11.0",
-    "@prisma-next/sql-operations": "0.11.0",
-    "@prisma-next/utils": "0.11.0",
+    "@prisma-next/contract": "0.12.0",
+    "@prisma-next/framework-components": "0.12.0",
+    "@prisma-next/operations": "0.12.0",
+    "@prisma-next/sql-contract": "0.12.0",
+    "@prisma-next/sql-operations": "0.12.0",
+    "@prisma-next/utils": "0.12.0",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.0",
     "ts-toolbelt": "^9.6.0"
   },
   "devDependencies": {
-    "@prisma-next/sql-contract-ts": "0.11.0",
-    "@prisma-next/test-utils": "0.11.0",
-    "@prisma-next/tsconfig": "0.11.0",
-    "@prisma-next/tsdown": "0.11.0",
+    "@prisma-next/sql-contract-ts": "0.12.0",
+    "@prisma-next/test-utils": "0.12.0",
+    "@prisma-next/tsconfig": "0.12.0",
+    "@prisma-next/tsdown": "0.12.0",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.6"
   },
+  "peerDependencies": {
+    "typescript": ">=5.9"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
   "files": [
     "dist",
     "src"
   ],
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": "./dist/index.mjs",
     "./ast": "./dist/exports/ast.mjs",
@@ -41,7 +50,9 @@
     "./types": "./dist/exports/types.mjs",
     "./package.json": "./package.json"
   },
-  "types": "./dist/index.d.mts",
+  "engines": {
+    "node": ">=24"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/prisma/prisma-next.git",

package/src/ast/adapter-types.ts

@@ -10,7 +10,10 @@ export interface MarkerStatement {
 }
 
 /**
- * Outcome of an adapter's marker read. `no-table` means the marker storage itself is absent (e.g. attaching to a database that was never `db init`'d); `absent` means the storage exists but holds no row for the requested space; `present` carries the parsed record. Callers distinguish these so runtime telemetry and `requireMarker` policy can react to each case appropriately.
+ * Outcome of an adapter's marker read. `no-table` means the marker storage itself is absent
+ * (e.g. attaching to a database that was never `db init`'d); `absent` means the storage exists
+ * but holds no row for the requested space; `present` carries the parsed record. Callers
+ * distinguish these to produce appropriate log diagnostics for each case.
  */
 export type MarkerReadResult =
   | { readonly kind: 'present'; readonly record: ContractMarkerRecord }

package/src/ast/types.ts

@@ -1,5 +1,6 @@
 import type { ParamSpec } from '@prisma-next/operations';
 import type { SqlLoweringSpec } from '@prisma-next/sql-operations';
+import { ifDefined } from '@prisma-next/utils/defined';
 import type { CodecRef } from './codec-types';
 
 export type Direction = 'asc' | 'desc';
@@ -10,6 +11,18 @@ export type AggregateCountFn = 'count';
 export type AggregateOpFn = 'sum' | 'avg' | 'min' | 'max';
 export type AggregateFn = AggregateCountFn | AggregateOpFn;
 
+/**
+ * Window function names. Currently only `row_number` is wired up — added
+ * to support `ROW_NUMBER() OVER (PARTITION BY ... ORDER BY ...) = 1`
+ * lowering for `.distinct(cols)` semantics in the SQL ORM client. `rank`
+ * and `dense_rank` are reserved here so future additions don't churn the
+ * type; renderers only need to dispatch on the function name string.
+ */
+export type WindowFn = 'row_number' | 'rank' | 'dense_rank';
+
+/** Scalar JS values that map directly to a SQL wire type. Values outside this set must be routed through `param(value, { codecId })` to declare the target codec explicitly. */
+export type RawSqlLiteral = number | bigint | string | boolean | Uint8Array;
+
 export interface ExpressionSource {
   toExpr(): AnyExpression;
 }
@@ -22,6 +35,7 @@ export interface ExpressionRewriter {
   literal?(expr: LiteralExpr): LiteralExpr;
   list?(expr: ListExpression): ListExpression | LiteralExpr;
   select?(ast: SelectAst): SelectAst;
+  rawExpr?(expr: RawExpr): AnyExpression;
 }
 
 export interface AstRewriter extends ExpressionRewriter {
@@ -35,6 +49,7 @@ export interface ExprVisitor<R> {
   subquery(expr: SubqueryExpr): R;
   operation(expr: OperationExpr): R;
   aggregate(expr: AggregateExpr): R;
+  windowFunc(expr: WindowFuncExpr): R;
   jsonObject(expr: JsonObjectExpr): R;
   jsonArrayAgg(expr: JsonArrayAggExpr): R;
   binary(expr: BinaryExpr): R;
@@ -47,6 +62,7 @@ export interface ExprVisitor<R> {
   param(expr: ParamRef): R;
   preparedParam(expr: PreparedParamRef): R;
   list(expr: ListExpression): R;
+  rawExpr(expr: RawExpr): R;
 }
 
 export interface ExpressionFolder<T> {
@@ -60,6 +76,7 @@ export interface ExpressionFolder<T> {
   literal?(expr: LiteralExpr): T;
   list?(expr: ListExpression): T;
   select?(ast: SelectAst): T;
+  rawExpr?(expr: RawExpr): T;
 }
 
 export type ProjectionExpr = AnyExpression;
@@ -606,6 +623,42 @@ export class OperationExpr extends Expression {
   }
 }
 
+export class RawExpr extends Expression {
+  readonly kind = 'raw-expr' as const;
+  readonly parts: ReadonlyArray<string | AnyExpression>;
+  readonly returns: ParamSpec;
+
+  constructor(options: {
+    readonly parts: ReadonlyArray<string | AnyExpression>;
+    readonly returns: ParamSpec;
+  }) {
+    super();
+    this.parts = frozenArrayCopy(options.parts);
+    this.returns = options.returns;
+    this.freeze();
+  }
+
+  override accept<R>(visitor: ExprVisitor<R>): R {
+    return visitor.rawExpr(this);
+  }
+
+  override rewrite(rewriter: ExpressionRewriter): AnyExpression {
+    return rewriter.rawExpr ? rewriter.rawExpr(this) : this;
+  }
+
+  override fold<T>(folder: ExpressionFolder<T>): T {
+    if (folder.rawExpr) {
+      return folder.rawExpr(this);
+    }
+    return combineAll(
+      folder,
+      this.parts
+        .filter((p): p is AnyExpression => typeof p !== 'string')
+        .map((p) => () => p.fold(folder)),
+    );
+  }
+}
+
 export class AggregateExpr extends Expression {
   readonly kind = 'aggregate' as const;
   readonly fn: AggregateFn;
@@ -654,6 +707,79 @@ export class AggregateExpr extends Expression {
   }
 }
 
+/**
+ * Window function call: `fn(args) OVER (PARTITION BY ... ORDER BY ...)`.
+ *
+ * Both `partitionBy` and `orderBy` are optional; an empty `OVER ()`
+ * clause is legal SQL but rarely useful. For `ROW_NUMBER`, `RANK`, and
+ * `DENSE_RANK` the standard mandates an `ORDER BY` for deterministic
+ * results — callers are expected to provide one, but the AST does not
+ * enforce it.
+ *
+ * The `args` slot exists for future window function additions that take
+ * arguments (e.g. `COUNT(*) OVER`, `SUM(x) OVER`); `ROW_NUMBER` and the
+ * other ranking functions take no arguments.
+ */
+export class WindowFuncExpr extends Expression {
+  readonly kind = 'window-func' as const;
+  readonly fn: WindowFn;
+  readonly args: ReadonlyArray<AnyExpression>;
+  readonly partitionBy: ReadonlyArray<AnyExpression> | undefined;
+  readonly orderBy: ReadonlyArray<OrderByItem> | undefined;
+
+  constructor(options: {
+    readonly fn: WindowFn;
+    readonly args?: ReadonlyArray<AnyExpression>;
+    readonly partitionBy?: ReadonlyArray<AnyExpression>;
+    readonly orderBy?: ReadonlyArray<OrderByItem>;
+  }) {
+    super();
+    this.fn = options.fn;
+    this.args = options.args && options.args.length > 0 ? frozenArrayCopy(options.args) : [];
+    this.partitionBy =
+      options.partitionBy && options.partitionBy.length > 0
+        ? frozenArrayCopy(options.partitionBy)
+        : undefined;
+    this.orderBy =
+      options.orderBy && options.orderBy.length > 0 ? frozenArrayCopy(options.orderBy) : undefined;
+    this.freeze();
+  }
+
+  static rowNumber(options: {
+    readonly partitionBy?: ReadonlyArray<AnyExpression>;
+    readonly orderBy?: ReadonlyArray<OrderByItem>;
+  }): WindowFuncExpr {
+    return new WindowFuncExpr({ fn: 'row_number', ...options });
+  }
+
+  override accept<R>(visitor: ExprVisitor<R>): R {
+    return visitor.windowFunc(this);
+  }
+
+  override rewrite(rewriter: ExpressionRewriter): AnyExpression {
+    return new WindowFuncExpr({
+      fn: this.fn,
+      args: this.args.map((arg) => arg.rewrite(rewriter)),
+      ...ifDefined(
+        'partitionBy',
+        this.partitionBy?.map((expr) => expr.rewrite(rewriter)),
+      ),
+      ...ifDefined(
+        'orderBy',
+        this.orderBy?.map((orderItem) => orderItem.rewrite(rewriter)),
+      ),
+    });
+  }
+
+  override fold<T>(folder: ExpressionFolder<T>): T {
+    return combineAll(folder, [
+      ...this.args.map((arg) => () => arg.fold(folder)),
+      ...(this.partitionBy ?? []).map((expr) => () => expr.fold(folder)),
+      ...(this.orderBy ?? []).map((orderItem) => () => orderItem.expr.fold(folder)),
+    ]);
+  }
+}
+
 export class JsonObjectExpr extends Expression {
   readonly kind = 'json-object' as const;
   readonly entries: ReadonlyArray<JsonObjectEntry>;
@@ -1758,6 +1884,7 @@ export type AnyExpression =
   | SubqueryExpr
   | OperationExpr
   | AggregateExpr
+  | WindowFuncExpr
   | JsonObjectExpr
   | JsonArrayAggExpr
   | ListExpression
@@ -1766,7 +1893,8 @@ export type AnyExpression =
   | OrExpr
   | ExistsExpr
   | NullCheckExpr
-  | NotExpr;
+  | NotExpr
+  | RawExpr;
 export type AnyParamRef = ParamRef | PreparedParamRef;
 export type AnyInsertOnConflictAction = DoNothingConflictAction | DoUpdateSetConflictAction;
 export type AnyInsertValue = ColumnRef | ParamRef | PreparedParamRef | DefaultValueExpr;

package/src/codec-ref-for-column.ts

@@ -38,9 +38,9 @@ export function codecRefForStorageColumn(
     let instance: unknown = storage.types?.[columnDef.typeRef];
     if (!instance) {
       for (const ns of Object.values(storage.namespaces)) {
-        const nsTypes = (ns as { types?: Record<string, unknown> }).types;
-        if (nsTypes) {
-          const nsEntry = nsTypes[columnDef.typeRef];
+        const nsEnums = (ns as { enum?: Record<string, unknown> }).enum;
+        if (nsEnums) {
+          const nsEntry = nsEnums[columnDef.typeRef];
           if (nsEntry !== undefined) {
             instance = nsEntry;
             break;

package/src/expression.ts

@@ -3,8 +3,8 @@ import type { ParamSpec } from '@prisma-next/operations';
 import type { QueryOperationReturn } from '@prisma-next/sql-contract/types';
 import type { SqlLoweringSpec } from '@prisma-next/sql-operations';
 import type { CodecRef } from './ast/codec-types';
-import type { AnyExpression as AstExpression } from './ast/types';
-import { OperationExpr, ParamRef } from './ast/types';
+import type { AnyExpression as AstExpression, RawSqlLiteral } from './ast/types';
+import { OperationExpr, ParamRef, RawExpr } from './ast/types';
 
 export type ScopeField = {
   codecId: string;
@@ -94,6 +94,13 @@ export function toExpr(value: unknown, codec?: CodecRef): AstExpression {
   return ParamRef.of(value, { codec });
 }
 
+/**
+ * Construct a `ParamRef` for a value whose codec identity is known at call time. Use this when interpolating a value into a raw SQL expression and the codec cannot be inferred from context — e.g. `param(myDate, { codecId: 'pg/timestamptz@1' })`.
+ */
+export function param<T>(value: T, opts: { codecId: string }): ParamRef {
+  return ParamRef.of(value, { codec: { codecId: opts.codecId } });
+}
+
 /**
  * Derive the {@link CodecRef} carried by an expression-like value.
  *
@@ -152,3 +159,102 @@ export function buildOperation<R extends ScopeField>(spec: BuildOperationSpec<R>
     buildAst: () => op,
   };
 }
+
+/**
+ * Resolves a codec id for a bare JavaScript value interpolated into a raw-SQL
+ * template — e.g. `` rawSql`SELECT ${42}` `` calls `inferCodec(42)` to pick
+ * the codec id (`pg/int4`, `sqlite/integer@1`, etc.) that will encode the
+ * value as a bound parameter.
+ *
+ * Targets implement this once per dialect: examine the JS value's runtime
+ * shape (number, bigint, string, boolean, `Uint8Array`) and return a codec
+ * id known to the target's codec registry. Throw when the value falls
+ * outside the supported set — callers should wrap such values with
+ * `param(value, { codecId })` to declare the codec explicitly.
+ */
+export interface RawCodecInferer {
+  inferCodec(value: RawSqlLiteral): string;
+}
+
+/** The one-method builder returned by a `RawSqlTag` template call before `.returns()` is called. */
+export interface RawSqlBuilder {
+  returns<S extends string>(spec: S): Expression<{ codecId: S; nullable: false }>;
+  returns<S extends string, N extends boolean = false>(spec: {
+    readonly codecId: S;
+    readonly nullable?: N;
+  }): Expression<{ codecId: S; nullable: N }>;
+}
+
+/** Tagged-template function returned by {@link createRawSql}. */
+export type RawSqlTag = (
+  strings: TemplateStringsArray,
+  ...values: RawSqlInterpolation[]
+) => RawSqlBuilder;
+
+type RawSqlInterpolation = Expression<ScopeField> | ParamRef | RawSqlLiteral;
+
+function resolveInterpolation(
+  adapter: RawCodecInferer,
+  value: RawSqlInterpolation,
+): AstExpression | ParamRef {
+  if (isExpressionLike(value)) {
+    return value.buildAst();
+  }
+  if (value instanceof ParamRef) {
+    return value;
+  }
+  if (
+    typeof value === 'number' ||
+    typeof value === 'bigint' ||
+    typeof value === 'string' ||
+    typeof value === 'boolean' ||
+    value instanceof Uint8Array
+  ) {
+    return ParamRef.of(value, { codec: { codecId: adapter.inferCodec(value) } });
+  }
+
+  value satisfies never;
+  throw runtimeError(
+    'RUNTIME.RAW_SQL_UNSUPPORTED_INTERPOLATION',
+    'unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec',
+  );
+}
+
+/**
+ * Create a tagged-template builder for raw SQL expressions. The returned tag accepts SQL string fragments interleaved with typed {@link Expression}, {@link ParamRef}, or bare {@link RawSqlLiteral} interpolations. Call `.returns(spec)` on the result to obtain a typed {@link Expression} whose AST is a {@link RawExpr}.
+ *
+ * Bare {@link RawSqlLiteral} interpolations are wrapped as `ParamRef` nodes with the codec resolved via `adapter.inferCodec(value)`. Use {@link param} when the codec cannot be inferred from the value alone (e.g. `Date`).
+ */
+export function createRawSql(adapter: RawCodecInferer): RawSqlTag {
+  return (strings, ...values) => {
+    const parts: (string | AstExpression | ParamRef)[] = [];
+    parts.push(strings[0] ?? '');
+    values.forEach((value, i) => {
+      parts.push(resolveInterpolation(adapter, value));
+      parts.push(strings[i + 1] ?? '');
+    });
+    return new RawSqlBuilderImpl(parts);
+  };
+}
+
+class RawSqlBuilderImpl implements RawSqlBuilder {
+  constructor(private readonly parts: readonly (string | AstExpression | ParamRef)[]) {}
+
+  returns<S extends string>(spec: S): Expression<{ codecId: S; nullable: false }>;
+  returns<S extends string, N extends boolean = false>(spec: {
+    readonly codecId: S;
+    readonly nullable?: N;
+  }): Expression<{ codecId: S; nullable: N }>;
+  returns(
+    spec: string | { readonly codecId: string; readonly nullable?: boolean },
+  ): Expression<{ codecId: string; nullable: boolean }> {
+    const codecId = typeof spec === 'string' ? spec : spec.codecId;
+    const nullable = typeof spec === 'string' ? false : (spec.nullable ?? false);
+    const paramSpec: ParamSpec = { codecId, nullable };
+    const node = new RawExpr({ parts: this.parts, returns: paramSpec });
+    return {
+      returnType: { codecId, nullable },
+      buildAst: () => node,
+    };
+  }
+}

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { Contract } from '@prisma-next/contract/types';
+import type { Contract, ContractModelsMap } from '@prisma-next/contract/types';
 import type { ParamSpec } from '@prisma-next/operations';
 import type {
   ExtractFieldOutputTypes,
@@ -16,18 +16,16 @@ export type Expr = ColumnRef | ParamRef;
  * Extracts the model name for a given table by iterating models to find the one
  * whose `storage.table` matches.
  */
-type ExtractTableToModel<
-  TContract extends Contract<SqlStorage>,
-  TableName extends string,
-> = TContract['models'] extends infer Models extends Record<string, unknown>
-  ? {
-      [M in keyof Models & string]: Models[M] extends {
-        readonly storage: { readonly table: TableName };
-      }
-        ? M
-        : never;
-    }[keyof Models & string]
-  : never;
+type ExtractTableToModel<TContract extends Contract<SqlStorage>, TableName extends string> =
+  ContractModelsMap<TContract> extends infer Models extends Record<string, unknown>
+    ? {
+        [M in keyof Models & string]: Models[M] extends {
+          readonly storage: { readonly table: TableName };
+        }
+          ? M
+          : never;
+      }[keyof Models & string]
+    : never;
 
 /**
  * Extracts the field name for a given column by finding the field in
@@ -39,7 +37,7 @@ type ExtractColumnToField<
   ColumnName extends string,
 > =
   ExtractTableToModel<TContract, TableName> extends infer ModelName extends string
-    ? TContract['models'] extends infer Models extends Record<string, unknown>
+    ? ContractModelsMap<TContract> extends infer Models extends Record<string, unknown>
       ? ModelName & keyof Models extends infer MKey extends string
         ? Models[MKey] extends {
             readonly storage: { readonly fields: infer Fields extends Record<string, unknown> };

package/dist/errors-Duz3ppqk.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-Duz3ppqk.d.mts","names":[],"sources":["../src/errors.ts"],"mappings":";;;iBAEgB,WAAA,CACd,OAAA,UACA,OAAA,GAAU,MAAA,mBACV,KAAA,sBACA,IAAA,uBACC,YAAA;AAAA,iBAkBa,eAAA,CACd,OAAA,UACA,OAAA,GAAU,MAAA,mBACV,KAAA,sBACA,IAAA,uBACC,YAAA"}

package/dist/middleware-DI2DqOSg.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"middleware-DI2DqOSg.d.mts","names":[],"sources":["../src/middleware/param-ref-mutator.ts"],"mappings":";;;;;;AAG8D;;;;;AAuB9D;;;cAXc,mBAAA;;;;;;AAoBd;;;;UATiB,cAAA;EAAA,UACL,mBAAA,GAAsB,QAAA;AAAA;;;;;;UAQjB,aAAA;EAAA,SACN,GAAA,EAAK,cAAA,CAAe,QAAA;EAAA,SACpB,KAAA;EAAA,SACA,OAAA,EAAS,QAAA;AAAA;AAWpB;;;;;;;;AAAA,KAAY,kBAAA,mBAAqC,MAAA,mCAC/B,SAAA,YAAqB,aAAA,CAAc,CAAA,UAAW,SAAA,aAC5D,aAAA;;;;;;;;;;;AA0BJ;;;;;;;;;;;;;;UAAiB,kBAAA,mBACG,MAAA,oBAA0B,MAAA,2BACpC,eAAA;EAmBU;EAjBlB,OAAA,IAAW,gBAAA,CAAiB,kBAAA,CAAmB,SAAA;EAFvC;;;;;;EAUR,YAAA,wBAAoC,SAAA,WAClC,GAAA,EAAK,cAAA,CAAe,QAAA,GACpB,QAAA,EAAU,SAAA,CAAU,QAAA;EAEtB,YAAA,CAAa,GAAA,EAAK,cAAA,aAA2B,QAAA;EAZlC;EAeX,aAAA,CACE,OAAA,EAAS,QAAA;IAAA,SACE,GAAA,EAAK,cAAA,QAAsB,SAAA;IAAA,SAC3B,QAAA;EAAA;AAAA;;;;;;;;;;;UAeE,0BAAA,mBACG,MAAA,oBAA0B,MAAA,2BACpC,kBAAA,CAAmB,SAAA;EAC3B,aAAA;AAAA;;;;;;;AAHF;;;;;;;;;iBAuBgB,wBAAA,mBACI,MAAA,oBAA0B,MAAA,kBAAA,CAC5C,IAAA,EAAM,gBAAA,GAAmB,0BAAA,CAA2B,SAAA"}

package/dist/plan-D-Q5B-z_.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plan-D-Q5B-z_.d.mts","names":[],"sources":["../src/plan.ts"],"mappings":";;;;;;;;AAkBA;;;;;;;;;;;UAAiB,YAAA,wBAAoC,SAAA,CAAU,GAAA;EAAA,SACpD,GAAA,EAAK,WAAA;EAAA,SACL,MAAA;AAAA;;AAoBX;;;;;;;;;;;;;;;;iBAAgB,WAAA,eAAA,CACd,GAAA,EAAK,WAAA,EACL,QAAA,EAAU,QAAA,CAAS,UAAA,GACnB,MAAA,YACC,YAAA,CAAa,GAAA"}

package/dist/sql-execution-plan-B84vOmgK.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sql-execution-plan-B84vOmgK.d.mts","names":[],"sources":["../src/sql-execution-plan.ts"],"mappings":";;;;;;AAuBA;;;;;;;;;;;;;;;;;;UAAiB,gBAAA,wBAAwC,aAAA,CAAc,GAAA;EAAA,SAC5D,GAAA;EAAA,SACA,MAAA;EAAA,SACA,GAAA,EAAK,WAAA;AAAA"}

package/dist/types-BJHEQbci.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-BJHEQbci.d.mts","names":[],"sources":["../src/runtime-scope.ts"],"mappings":";;;;;;;;AASA;;KAAY,UAAA,GAAa,gBAAA,GAAmB,YAAA;;;AAU5C;;;;;;KAAY,YAAA,GAAe,IAAA,CAAK,eAAA,CAAgB,UAAA"}