@prisma/client-engine-runtime 7.6.0 → 7.7.0-dev.2

package/dist/index.d.mts

@@ -4,6 +4,9 @@ import { ConnectionInfo } from '@prisma/driver-adapter-utils';
 import { Context } from '@opentelemetry/api';
 import { Decimal } from '@prisma/client-runtime-utils';
 import type { IsolationLevel } from '@prisma/driver-adapter-utils';
+import type { JsonBatchQuery } from '@prisma/json-protocol';
+import type { JsonQuery } from '@prisma/json-protocol';
+import { ParamGraph } from '@prisma/param-graph';
 import { Span } from '@opentelemetry/api';
 import { SpanOptions } from '@opentelemetry/api';
 import type { SqlCommenterContext } from '@prisma/sqlcommenter';
@@ -224,6 +227,44 @@ export declare type Pagination = {
     skip: number | null;
 };
 
+/**
+ * Parameterizes a batch of queries using the schema-aware approach.
+ *
+ * @param batch - The batch to parameterize
+ * @param view - The ParamGraph for schema lookups
+ * @returns The parameterized batch with extracted placeholder values
+ */
+export declare function parameterizeBatch(batch: JsonBatchQuery, view: ParamGraph): ParameterizeBatchResult;
+
+/**
+ * Result of parameterizing a batch of queries.
+ */
+declare interface ParameterizeBatchResult {
+    /** The batch with user data values replaced by placeholders */
+    parameterizedBatch: JsonBatchQuery;
+    /** Combined map of placeholder names to their actual values */
+    placeholderValues: Record<string, unknown>;
+}
+
+/**
+ * Parameterizes a single query using the schema-aware approach.
+ *
+ * @param query - The query to parameterize
+ * @param view - The ParamGraph for schema lookups
+ * @returns The parameterized query with extracted placeholder values
+ */
+export declare function parameterizeQuery(query: JsonQuery, view: ParamGraph): ParameterizeResult;
+
+/**
+ * Result of parameterizing a single query.
+ */
+declare interface ParameterizeResult {
+    /** The query with user data values replaced by placeholders */
+    parameterizedQuery: JsonQuery;
+    /** Map of placeholder names to their actual values */
+    placeholderValues: Record<string, unknown>;
+}
+
 export declare interface PlaceholderFormat {
     prefix: string;
     hasNumbering: boolean;

package/dist/index.d.ts

@@ -4,6 +4,9 @@ import { ConnectionInfo } from '@prisma/driver-adapter-utils';
 import { Context } from '@opentelemetry/api';
 import { Decimal } from '@prisma/client-runtime-utils';
 import type { IsolationLevel } from '@prisma/driver-adapter-utils';
+import type { JsonBatchQuery } from '@prisma/json-protocol';
+import type { JsonQuery } from '@prisma/json-protocol';
+import { ParamGraph } from '@prisma/param-graph';
 import { Span } from '@opentelemetry/api';
 import { SpanOptions } from '@opentelemetry/api';
 import type { SqlCommenterContext } from '@prisma/sqlcommenter';
@@ -224,6 +227,44 @@ export declare type Pagination = {
     skip: number | null;
 };
 
+/**
+ * Parameterizes a batch of queries using the schema-aware approach.
+ *
+ * @param batch - The batch to parameterize
+ * @param view - The ParamGraph for schema lookups
+ * @returns The parameterized batch with extracted placeholder values
+ */
+export declare function parameterizeBatch(batch: JsonBatchQuery, view: ParamGraph): ParameterizeBatchResult;
+
+/**
+ * Result of parameterizing a batch of queries.
+ */
+declare interface ParameterizeBatchResult {
+    /** The batch with user data values replaced by placeholders */
+    parameterizedBatch: JsonBatchQuery;
+    /** Combined map of placeholder names to their actual values */
+    placeholderValues: Record<string, unknown>;
+}
+
+/**
+ * Parameterizes a single query using the schema-aware approach.
+ *
+ * @param query - The query to parameterize
+ * @param view - The ParamGraph for schema lookups
+ * @returns The parameterized query with extracted placeholder values
+ */
+export declare function parameterizeQuery(query: JsonQuery, view: ParamGraph): ParameterizeResult;
+
+/**
+ * Result of parameterizing a single query.
+ */
+declare interface ParameterizeResult {
+    /** The query with user data values replaced by placeholders */
+    parameterizedQuery: JsonQuery;
+    /** Map of placeholder names to their actual values */
+    placeholderValues: Record<string, unknown>;
+}
+
 export declare interface PlaceholderFormat {
     prefix: string;
     hasNumbering: boolean;

package/dist/index.js

@@ -45,6 +45,8 @@ __export(index_exports, {
   noopTracingHelper: () => noopTracingHelper,
   normalizeJsonProtocolValues: () => normalizeJsonProtocolValues,
   normalizeRawJsonProtocolResponse: () => normalizeRawJsonProtocolResponse,
+  parameterizeBatch: () => parameterizeBatch,
+  parameterizeQuery: () => parameterizeQuery,
   safeJsonStringify: () => safeJsonStringify
 });
 module.exports = __toCommonJS(index_exports);
@@ -1070,10 +1072,11 @@ function renderQuery(dbQuery, scope, generators, maxChunkSize) {
     case "templateSql": {
       const chunks = dbQuery.chunkable ? chunkParams(dbQuery.fragments, args, maxChunkSize) : [args];
       return chunks.map((params) => {
-        if (maxChunkSize !== void 0 && params.length > maxChunkSize) {
+        const rendered = renderTemplateSql(dbQuery.fragments, dbQuery.placeholderFormat, params, dbQuery.argTypes);
+        if (maxChunkSize !== void 0 && rendered.args.length > maxChunkSize) {
           throw new UserFacingError("The query parameter limit supported by your database is exceeded.", "P2029");
         }
-        return renderTemplateSql(dbQuery.fragments, dbQuery.placeholderFormat, params, dbQuery.argTypes);
+        return rendered;
       });
     }
     default:
@@ -1988,6 +1991,443 @@ function cloneObject(value) {
   return (0, import_klona2.klona)(value);
 }
 
+// src/parameterization/parameterize.ts
+var import_param_graph = require("@prisma/param-graph");
+
+// src/parameterization/classify.ts
+var SCALAR_TAGS = /* @__PURE__ */ new Set(["DateTime", "Decimal", "BigInt", "Bytes", "Json", "Raw"]);
+function classifyValue(value) {
+  if (value === null || value === void 0) {
+    return { kind: "null" };
+  }
+  if (typeof value === "string") {
+    return { kind: "primitive", value };
+  }
+  if (typeof value === "number") {
+    return { kind: "primitive", value };
+  }
+  if (typeof value === "boolean") {
+    return { kind: "primitive", value };
+  }
+  if (Array.isArray(value)) {
+    return { kind: "array", items: value };
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    if ("$type" in obj && typeof obj.$type === "string") {
+      const tag = obj.$type;
+      if (SCALAR_TAGS.has(tag)) {
+        return { kind: "taggedScalar", tag, value: obj.value };
+      }
+      return { kind: "structural", value: obj.value };
+    }
+    return { kind: "object", entries: obj };
+  }
+  return { kind: "structural", value };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !("$type" in value);
+}
+function isTaggedValue2(value) {
+  return typeof value === "object" && value !== null && "$type" in value && typeof value.$type === "string";
+}
+
+// src/parameterization/parameterize.ts
+function parameterizeQuery(query, view) {
+  const parameterizer = new Parameterizer(view);
+  const rootKey = query.modelName ? `${query.modelName}.${query.action}` : query.action;
+  const root = view.root(rootKey);
+  const parameterizedQuery = {
+    ...query,
+    query: parameterizer.parameterizeFieldSelection(query.query, root?.argsNodeId, root?.outputNodeId)
+  };
+  return {
+    parameterizedQuery,
+    placeholderValues: parameterizer.getPlaceholderValues()
+  };
+}
+function parameterizeBatch(batch, view) {
+  const parameterizer = new Parameterizer(view);
+  const parameterizedQueries = [];
+  for (let i = 0; i < batch.batch.length; i++) {
+    const query = batch.batch[i];
+    const rootKey = query.modelName ? `${query.modelName}.${query.action}` : query.action;
+    const root = view.root(rootKey);
+    parameterizedQueries.push({
+      ...query,
+      query: parameterizer.parameterizeFieldSelection(query.query, root?.argsNodeId, root?.outputNodeId)
+    });
+  }
+  return {
+    parameterizedBatch: { ...batch, batch: parameterizedQueries },
+    placeholderValues: parameterizer.getPlaceholderValues()
+  };
+}
+var Parameterizer = class {
+  #view;
+  #placeholders = /* @__PURE__ */ new Map();
+  #valueToPlaceholder = /* @__PURE__ */ new Map();
+  #nextPlaceholderId = 1;
+  constructor(view) {
+    this.#view = view;
+  }
+  /**
+   * Returns the collected placeholder values as a plain object.
+   */
+  getPlaceholderValues() {
+    return Object.fromEntries(this.#placeholders);
+  }
+  /**
+   * Gets or creates a placeholder for the given value.
+   * If a placeholder already exists for this value, returns a reference to the existing name.
+   * Otherwise, registers a new placeholder with a sequential name.
+   * We reuse the placeholders for equal values because the query compiler needs to be able
+   * to compare the values for equality for certain optimizations (at the time of writing,
+   * only for deciding whether to use native or emulated upserts).
+   */
+  #getOrCreatePlaceholder(value, type) {
+    const valueKey = createValueKey(value, type);
+    const existingName = this.#valueToPlaceholder.get(valueKey);
+    if (existingName !== void 0) {
+      return createPlaceholder(existingName, type);
+    }
+    const name = `%${this.#nextPlaceholderId++}`;
+    this.#valueToPlaceholder.set(valueKey, name);
+    this.#placeholders.set(name, value);
+    return createPlaceholder(name, type);
+  }
+  /**
+   * Parameterizes a field selection (arguments + selection).
+   */
+  parameterizeFieldSelection(sel, argsNodeId, outNodeId) {
+    const argsNode = this.#view.inputNode(argsNodeId);
+    const outNode = this.#view.outputNode(outNodeId);
+    const result = { ...sel };
+    if (sel.arguments && sel.arguments.$type !== "Raw") {
+      result.arguments = this.#parameterizeObject(sel.arguments, argsNode);
+    }
+    if (sel.selection) {
+      result.selection = this.#parameterizeSelection(sel.selection, outNode);
+    }
+    return result;
+  }
+  /**
+   * Parameterizes an object by traversing its fields with the input node.
+   */
+  #parameterizeObject(obj, node) {
+    if (!node) {
+      return obj;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const edge = this.#view.inputEdge(node, key);
+      if (edge) {
+        result[key] = this.#parameterizeValue(value, edge);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  /**
+   * Core parameterization logic for a single value.
+   */
+  #parameterizeValue(value, edge) {
+    const classified = classifyValue(value);
+    switch (classified.kind) {
+      case "null":
+        return value;
+      case "structural":
+        return value;
+      case "primitive":
+        return this.#handlePrimitive(classified.value, edge);
+      case "taggedScalar":
+        return this.#handleTaggedScalar(value, classified.tag, edge);
+      case "array":
+        return this.#handleArray(classified.items, value, edge);
+      case "object":
+        return this.#handleObject(classified.entries, edge);
+      default:
+        throw new Error(`Unknown value kind ${classified.kind}`);
+    }
+  }
+  /**
+   * Handles parameterization of primitive values (string, number, boolean).
+   */
+  #handlePrimitive(value, edge) {
+    if ((0, import_param_graph.hasFlag)(edge, import_param_graph.EdgeFlag.ParamEnum) && edge.enumNameIndex !== void 0 && typeof value === "string") {
+      const enumValues = this.#view.enumValues(edge);
+      if (enumValues && Object.hasOwn(enumValues, value)) {
+        const type2 = { type: "Enum" };
+        return this.#getOrCreatePlaceholder(enumValues[value], type2);
+      }
+    }
+    if (!(0, import_param_graph.hasFlag)(edge, import_param_graph.EdgeFlag.ParamScalar)) {
+      return value;
+    }
+    const mask = (0, import_param_graph.getScalarMask)(edge);
+    if (mask === 0) {
+      return value;
+    }
+    const type = getPrimitivePlaceholderType(value);
+    if (!matchesPrimitiveMask(type, mask)) {
+      return value;
+    }
+    if (mask & import_param_graph.ScalarMask.Json) {
+      value = JSON.stringify(value);
+    }
+    return this.#getOrCreatePlaceholder(value, type);
+  }
+  /**
+   * Handles parameterization of tagged scalar values (DateTime, Decimal, etc.).
+   */
+  #handleTaggedScalar(tagged, tag, edge) {
+    if (!(0, import_param_graph.hasFlag)(edge, import_param_graph.EdgeFlag.ParamScalar)) {
+      return tagged;
+    }
+    const mask = (0, import_param_graph.getScalarMask)(edge);
+    if (mask === 0 || !matchesTaggedMask(tag, mask)) {
+      return tagged;
+    }
+    const type = getTaggedPlaceholderType(tagged.$type);
+    const decoded = decodeTaggedValue(tagged);
+    return this.#getOrCreatePlaceholder(decoded, type);
+  }
+  /**
+   * Handles parameterization of array values.
+   */
+  #handleArray(items, originalValue, edge) {
+    if ((0, import_param_graph.hasFlag)(edge, import_param_graph.EdgeFlag.ParamScalar) && (0, import_param_graph.getScalarMask)(edge) & import_param_graph.ScalarMask.Json) {
+      const jsonValue = safeJsonStringify(deserializeJsonObject(items));
+      const type = { type: "Json" };
+      return this.#getOrCreatePlaceholder(jsonValue, type);
+    }
+    if ((0, import_param_graph.hasFlag)(edge, import_param_graph.EdgeFlag.ParamEnum)) {
+      const enumValues = this.#view.enumValues(edge);
+      if (enumValues && items.every((item) => typeof item === "string" && Object.hasOwn(enumValues, item))) {
+        const type = { type: "List", inner: { type: "Enum" } };
+        return this.#getOrCreatePlaceholder(items, type);
+      }
+    }
+    if ((0, import_param_graph.hasFlag)(edge, import_param_graph.EdgeFlag.ParamListScalar)) {
+      const allValid = items.every((item) => validateListElement(item, edge));
+      if (allValid && items.length > 0) {
+        const decodedItems = items.map((item) => decodeIfTagged(item));
+        const innerType = inferListElementType(items);
+        const type = { type: "List", inner: innerType };
+        return this.#getOrCreatePlaceholder(decodedItems, type);
+      }
+    }
+    if ((0, import_param_graph.hasFlag)(edge, import_param_graph.EdgeFlag.ListObject)) {
+      const childNode = this.#view.inputNode(edge.childNodeId);
+      if (childNode) {
+        return items.map((item) => {
+          if (isPlainObject(item)) {
+            return this.#parameterizeObject(item, childNode);
+          }
+          return item;
+        });
+      }
+    }
+    return originalValue;
+  }
+  /**
+   * Handles parameterization of object values.
+   */
+  #handleObject(obj, edge) {
+    if ((0, import_param_graph.hasFlag)(edge, import_param_graph.EdgeFlag.Object)) {
+      const childNode = this.#view.inputNode(edge.childNodeId);
+      if (childNode) {
+        return this.#parameterizeObject(obj, childNode);
+      }
+    }
+    const mask = (0, import_param_graph.getScalarMask)(edge);
+    if (mask & import_param_graph.ScalarMask.Json) {
+      const jsonValue = safeJsonStringify(deserializeJsonObject(obj));
+      const type = { type: "Json" };
+      return this.#getOrCreatePlaceholder(jsonValue, type);
+    }
+    return obj;
+  }
+  /**
+   * Parameterizes a selection set using output nodes.
+   */
+  #parameterizeSelection(selection, node) {
+    if (!selection || !node) {
+      return selection;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(selection)) {
+      if (key === "$scalars" || key === "$composites" || typeof value === "boolean") {
+        result[key] = value;
+        continue;
+      }
+      const edge = this.#view.outputEdge(node, key);
+      if (edge) {
+        const nested = value;
+        const argsNode = this.#view.inputNode(edge.argsNodeId);
+        const childOutNode = this.#view.outputNode(edge.outputNodeId);
+        const processedValue = {
+          selection: nested.selection ? this.#parameterizeSelection(nested.selection, childOutNode) : {}
+        };
+        if (nested.arguments) {
+          processedValue.arguments = this.#parameterizeObject(nested.arguments, argsNode);
+        }
+        result[key] = processedValue;
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+};
+function createPlaceholder(name, type) {
+  return { $type: "Param", value: { name, ...type } };
+}
+function serializePlaceholderType(type) {
+  if (type.type === "List") {
+    return `List<${serializePlaceholderType(type.inner)}>`;
+  }
+  return type.type;
+}
+function serializeValue(value) {
+  if (ArrayBuffer.isView(value)) {
+    const bufView = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+    return bufView.toString("base64");
+  }
+  return JSON.stringify(value);
+}
+function createValueKey(value, type) {
+  const typeKey = serializePlaceholderType(type);
+  const valueKey = serializeValue(value);
+  return `${typeKey}:${valueKey}`;
+}
+var MAX_INT = 2 ** 31 - 1;
+var MIN_INT = -(2 ** 31);
+function getPrimitivePlaceholderType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return { type: "Boolean" };
+    case "number":
+      if (!Number.isInteger(value)) {
+        return { type: "Float" };
+      }
+      if (MIN_INT <= value && value <= MAX_INT) {
+        return { type: "Int" };
+      }
+      return { type: "BigInt" };
+    case "string":
+      return { type: "String" };
+    default:
+      throw new Error("unreachable");
+  }
+}
+function matchesPrimitiveMask({ type }, mask) {
+  switch (type) {
+    case "Boolean":
+      return (mask & import_param_graph.ScalarMask.Boolean) !== 0;
+    case "Int":
+      return (mask & (import_param_graph.ScalarMask.Int | import_param_graph.ScalarMask.BigInt | import_param_graph.ScalarMask.Float)) !== 0;
+    case "BigInt":
+      return (mask & import_param_graph.ScalarMask.BigInt) !== 0;
+    case "Float":
+      return (mask & import_param_graph.ScalarMask.Float) !== 0;
+    case "String":
+      return (mask & import_param_graph.ScalarMask.String) !== 0;
+    default:
+      return false;
+  }
+}
+function getTaggedPlaceholderType(tag) {
+  switch (tag) {
+    case "BigInt":
+    case "Bytes":
+    case "DateTime":
+    case "Json":
+      return { type: tag };
+    case "Decimal":
+      return { type: "Float" };
+    default:
+      return void 0;
+  }
+}
+function inferListElementType(items) {
+  let widest = { type: "Any" };
+  for (const item of items) {
+    const classified = classifyValue(item);
+    let itemType;
+    switch (classified.kind) {
+      case "primitive":
+        itemType = getPrimitivePlaceholderType(classified.value);
+        break;
+      case "taggedScalar":
+        itemType = getTaggedPlaceholderType(classified.tag) ?? { type: "Any" };
+        break;
+      default:
+        return { type: "Any" };
+    }
+    widest = widenType(widest, itemType);
+  }
+  return widest;
+}
+function widenType(a, b) {
+  if (a.type === "Any") return b;
+  if (b.type === "Any") return a;
+  if (a.type === b.type) return a;
+  const NUMERIC_WIDTH = { Int: 0, BigInt: 1, Float: 2 };
+  const aWidth = NUMERIC_WIDTH[a.type];
+  const bWidth = NUMERIC_WIDTH[b.type];
+  if (aWidth !== void 0 && bWidth !== void 0) {
+    return aWidth >= bWidth ? a : b;
+  }
+  return { type: "Any" };
+}
+function matchesTaggedMask(tag, mask) {
+  switch (tag) {
+    case "DateTime":
+      return (mask & import_param_graph.ScalarMask.DateTime) !== 0;
+    case "Decimal":
+      return (mask & import_param_graph.ScalarMask.Decimal) !== 0;
+    case "BigInt":
+      return (mask & import_param_graph.ScalarMask.BigInt) !== 0;
+    case "Bytes":
+      return (mask & import_param_graph.ScalarMask.Bytes) !== 0;
+    case "Json":
+      return (mask & import_param_graph.ScalarMask.Json) !== 0;
+    default:
+      return false;
+  }
+}
+function validateListElement(item, edge) {
+  const classified = classifyValue(item);
+  switch (classified.kind) {
+    case "structural":
+      return false;
+    case "null":
+      return false;
+    case "primitive": {
+      const type = getPrimitivePlaceholderType(classified.value);
+      const mask = (0, import_param_graph.getScalarMask)(edge);
+      return mask !== 0 && matchesPrimitiveMask(type, mask);
+    }
+    case "taggedScalar": {
+      const mask = (0, import_param_graph.getScalarMask)(edge);
+      return mask !== 0 && matchesTaggedMask(classified.tag, mask);
+    }
+    default:
+      return false;
+  }
+}
+function decodeIfTagged(value) {
+  if (isTaggedValue2(value)) {
+    return decodeTaggedValue(value);
+  }
+  return value;
+}
+function decodeTaggedValue(tagged) {
+  return tagged.value;
+}
+
 // src/raw-json-protocol.ts
 var import_client_runtime_utils4 = require("@prisma/client-runtime-utils");
 function normalizeRawJsonProtocolResponse(response) {
@@ -2477,5 +2917,7 @@ function createTimeoutIfDefined(cb, ms) {
   noopTracingHelper,
   normalizeJsonProtocolValues,
   normalizeRawJsonProtocolResponse,
+  parameterizeBatch,
+  parameterizeQuery,
   safeJsonStringify
 });

package/dist/index.mjs

@@ -1019,10 +1019,11 @@ function renderQuery(dbQuery, scope, generators, maxChunkSize) {
     case "templateSql": {
       const chunks = dbQuery.chunkable ? chunkParams(dbQuery.fragments, args, maxChunkSize) : [args];
       return chunks.map((params) => {
-        if (maxChunkSize !== void 0 && params.length > maxChunkSize) {
+        const rendered = renderTemplateSql(dbQuery.fragments, dbQuery.placeholderFormat, params, dbQuery.argTypes);
+        if (maxChunkSize !== void 0 && rendered.args.length > maxChunkSize) {
           throw new UserFacingError("The query parameter limit supported by your database is exceeded.", "P2029");
         }
-        return renderTemplateSql(dbQuery.fragments, dbQuery.placeholderFormat, params, dbQuery.argTypes);
+        return rendered;
       });
     }
     default:
@@ -1937,6 +1938,443 @@ function cloneObject(value) {
   return klona2(value);
 }
 
+// src/parameterization/parameterize.ts
+import { EdgeFlag, getScalarMask, hasFlag, ScalarMask } from "@prisma/param-graph";
+
+// src/parameterization/classify.ts
+var SCALAR_TAGS = /* @__PURE__ */ new Set(["DateTime", "Decimal", "BigInt", "Bytes", "Json", "Raw"]);
+function classifyValue(value) {
+  if (value === null || value === void 0) {
+    return { kind: "null" };
+  }
+  if (typeof value === "string") {
+    return { kind: "primitive", value };
+  }
+  if (typeof value === "number") {
+    return { kind: "primitive", value };
+  }
+  if (typeof value === "boolean") {
+    return { kind: "primitive", value };
+  }
+  if (Array.isArray(value)) {
+    return { kind: "array", items: value };
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    if ("$type" in obj && typeof obj.$type === "string") {
+      const tag = obj.$type;
+      if (SCALAR_TAGS.has(tag)) {
+        return { kind: "taggedScalar", tag, value: obj.value };
+      }
+      return { kind: "structural", value: obj.value };
+    }
+    return { kind: "object", entries: obj };
+  }
+  return { kind: "structural", value };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !("$type" in value);
+}
+function isTaggedValue2(value) {
+  return typeof value === "object" && value !== null && "$type" in value && typeof value.$type === "string";
+}
+
+// src/parameterization/parameterize.ts
+function parameterizeQuery(query, view) {
+  const parameterizer = new Parameterizer(view);
+  const rootKey = query.modelName ? `${query.modelName}.${query.action}` : query.action;
+  const root = view.root(rootKey);
+  const parameterizedQuery = {
+    ...query,
+    query: parameterizer.parameterizeFieldSelection(query.query, root?.argsNodeId, root?.outputNodeId)
+  };
+  return {
+    parameterizedQuery,
+    placeholderValues: parameterizer.getPlaceholderValues()
+  };
+}
+function parameterizeBatch(batch, view) {
+  const parameterizer = new Parameterizer(view);
+  const parameterizedQueries = [];
+  for (let i = 0; i < batch.batch.length; i++) {
+    const query = batch.batch[i];
+    const rootKey = query.modelName ? `${query.modelName}.${query.action}` : query.action;
+    const root = view.root(rootKey);
+    parameterizedQueries.push({
+      ...query,
+      query: parameterizer.parameterizeFieldSelection(query.query, root?.argsNodeId, root?.outputNodeId)
+    });
+  }
+  return {
+    parameterizedBatch: { ...batch, batch: parameterizedQueries },
+    placeholderValues: parameterizer.getPlaceholderValues()
+  };
+}
+var Parameterizer = class {
+  #view;
+  #placeholders = /* @__PURE__ */ new Map();
+  #valueToPlaceholder = /* @__PURE__ */ new Map();
+  #nextPlaceholderId = 1;
+  constructor(view) {
+    this.#view = view;
+  }
+  /**
+   * Returns the collected placeholder values as a plain object.
+   */
+  getPlaceholderValues() {
+    return Object.fromEntries(this.#placeholders);
+  }
+  /**
+   * Gets or creates a placeholder for the given value.
+   * If a placeholder already exists for this value, returns a reference to the existing name.
+   * Otherwise, registers a new placeholder with a sequential name.
+   * We reuse the placeholders for equal values because the query compiler needs to be able
+   * to compare the values for equality for certain optimizations (at the time of writing,
+   * only for deciding whether to use native or emulated upserts).
+   */
+  #getOrCreatePlaceholder(value, type) {
+    const valueKey = createValueKey(value, type);
+    const existingName = this.#valueToPlaceholder.get(valueKey);
+    if (existingName !== void 0) {
+      return createPlaceholder(existingName, type);
+    }
+    const name = `%${this.#nextPlaceholderId++}`;
+    this.#valueToPlaceholder.set(valueKey, name);
+    this.#placeholders.set(name, value);
+    return createPlaceholder(name, type);
+  }
+  /**
+   * Parameterizes a field selection (arguments + selection).
+   */
+  parameterizeFieldSelection(sel, argsNodeId, outNodeId) {
+    const argsNode = this.#view.inputNode(argsNodeId);
+    const outNode = this.#view.outputNode(outNodeId);
+    const result = { ...sel };
+    if (sel.arguments && sel.arguments.$type !== "Raw") {
+      result.arguments = this.#parameterizeObject(sel.arguments, argsNode);
+    }
+    if (sel.selection) {
+      result.selection = this.#parameterizeSelection(sel.selection, outNode);
+    }
+    return result;
+  }
+  /**
+   * Parameterizes an object by traversing its fields with the input node.
+   */
+  #parameterizeObject(obj, node) {
+    if (!node) {
+      return obj;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const edge = this.#view.inputEdge(node, key);
+      if (edge) {
+        result[key] = this.#parameterizeValue(value, edge);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  /**
+   * Core parameterization logic for a single value.
+   */
+  #parameterizeValue(value, edge) {
+    const classified = classifyValue(value);
+    switch (classified.kind) {
+      case "null":
+        return value;
+      case "structural":
+        return value;
+      case "primitive":
+        return this.#handlePrimitive(classified.value, edge);
+      case "taggedScalar":
+        return this.#handleTaggedScalar(value, classified.tag, edge);
+      case "array":
+        return this.#handleArray(classified.items, value, edge);
+      case "object":
+        return this.#handleObject(classified.entries, edge);
+      default:
+        throw new Error(`Unknown value kind ${classified.kind}`);
+    }
+  }
+  /**
+   * Handles parameterization of primitive values (string, number, boolean).
+   */
+  #handlePrimitive(value, edge) {
+    if (hasFlag(edge, EdgeFlag.ParamEnum) && edge.enumNameIndex !== void 0 && typeof value === "string") {
+      const enumValues = this.#view.enumValues(edge);
+      if (enumValues && Object.hasOwn(enumValues, value)) {
+        const type2 = { type: "Enum" };
+        return this.#getOrCreatePlaceholder(enumValues[value], type2);
+      }
+    }
+    if (!hasFlag(edge, EdgeFlag.ParamScalar)) {
+      return value;
+    }
+    const mask = getScalarMask(edge);
+    if (mask === 0) {
+      return value;
+    }
+    const type = getPrimitivePlaceholderType(value);
+    if (!matchesPrimitiveMask(type, mask)) {
+      return value;
+    }
+    if (mask & ScalarMask.Json) {
+      value = JSON.stringify(value);
+    }
+    return this.#getOrCreatePlaceholder(value, type);
+  }
+  /**
+   * Handles parameterization of tagged scalar values (DateTime, Decimal, etc.).
+   */
+  #handleTaggedScalar(tagged, tag, edge) {
+    if (!hasFlag(edge, EdgeFlag.ParamScalar)) {
+      return tagged;
+    }
+    const mask = getScalarMask(edge);
+    if (mask === 0 || !matchesTaggedMask(tag, mask)) {
+      return tagged;
+    }
+    const type = getTaggedPlaceholderType(tagged.$type);
+    const decoded = decodeTaggedValue(tagged);
+    return this.#getOrCreatePlaceholder(decoded, type);
+  }
+  /**
+   * Handles parameterization of array values.
+   */
+  #handleArray(items, originalValue, edge) {
+    if (hasFlag(edge, EdgeFlag.ParamScalar) && getScalarMask(edge) & ScalarMask.Json) {
+      const jsonValue = safeJsonStringify(deserializeJsonObject(items));
+      const type = { type: "Json" };
+      return this.#getOrCreatePlaceholder(jsonValue, type);
+    }
+    if (hasFlag(edge, EdgeFlag.ParamEnum)) {
+      const enumValues = this.#view.enumValues(edge);
+      if (enumValues && items.every((item) => typeof item === "string" && Object.hasOwn(enumValues, item))) {
+        const type = { type: "List", inner: { type: "Enum" } };
+        return this.#getOrCreatePlaceholder(items, type);
+      }
+    }
+    if (hasFlag(edge, EdgeFlag.ParamListScalar)) {
+      const allValid = items.every((item) => validateListElement(item, edge));
+      if (allValid && items.length > 0) {
+        const decodedItems = items.map((item) => decodeIfTagged(item));
+        const innerType = inferListElementType(items);
+        const type = { type: "List", inner: innerType };
+        return this.#getOrCreatePlaceholder(decodedItems, type);
+      }
+    }
+    if (hasFlag(edge, EdgeFlag.ListObject)) {
+      const childNode = this.#view.inputNode(edge.childNodeId);
+      if (childNode) {
+        return items.map((item) => {
+          if (isPlainObject(item)) {
+            return this.#parameterizeObject(item, childNode);
+          }
+          return item;
+        });
+      }
+    }
+    return originalValue;
+  }
+  /**
+   * Handles parameterization of object values.
+   */
+  #handleObject(obj, edge) {
+    if (hasFlag(edge, EdgeFlag.Object)) {
+      const childNode = this.#view.inputNode(edge.childNodeId);
+      if (childNode) {
+        return this.#parameterizeObject(obj, childNode);
+      }
+    }
+    const mask = getScalarMask(edge);
+    if (mask & ScalarMask.Json) {
+      const jsonValue = safeJsonStringify(deserializeJsonObject(obj));
+      const type = { type: "Json" };
+      return this.#getOrCreatePlaceholder(jsonValue, type);
+    }
+    return obj;
+  }
+  /**
+   * Parameterizes a selection set using output nodes.
+   */
+  #parameterizeSelection(selection, node) {
+    if (!selection || !node) {
+      return selection;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(selection)) {
+      if (key === "$scalars" || key === "$composites" || typeof value === "boolean") {
+        result[key] = value;
+        continue;
+      }
+      const edge = this.#view.outputEdge(node, key);
+      if (edge) {
+        const nested = value;
+        const argsNode = this.#view.inputNode(edge.argsNodeId);
+        const childOutNode = this.#view.outputNode(edge.outputNodeId);
+        const processedValue = {
+          selection: nested.selection ? this.#parameterizeSelection(nested.selection, childOutNode) : {}
+        };
+        if (nested.arguments) {
+          processedValue.arguments = this.#parameterizeObject(nested.arguments, argsNode);
+        }
+        result[key] = processedValue;
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+};
+function createPlaceholder(name, type) {
+  return { $type: "Param", value: { name, ...type } };
+}
+function serializePlaceholderType(type) {
+  if (type.type === "List") {
+    return `List<${serializePlaceholderType(type.inner)}>`;
+  }
+  return type.type;
+}
+function serializeValue(value) {
+  if (ArrayBuffer.isView(value)) {
+    const bufView = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+    return bufView.toString("base64");
+  }
+  return JSON.stringify(value);
+}
+function createValueKey(value, type) {
+  const typeKey = serializePlaceholderType(type);
+  const valueKey = serializeValue(value);
+  return `${typeKey}:${valueKey}`;
+}
+var MAX_INT = 2 ** 31 - 1;
+var MIN_INT = -(2 ** 31);
+function getPrimitivePlaceholderType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return { type: "Boolean" };
+    case "number":
+      if (!Number.isInteger(value)) {
+        return { type: "Float" };
+      }
+      if (MIN_INT <= value && value <= MAX_INT) {
+        return { type: "Int" };
+      }
+      return { type: "BigInt" };
+    case "string":
+      return { type: "String" };
+    default:
+      throw new Error("unreachable");
+  }
+}
+function matchesPrimitiveMask({ type }, mask) {
+  switch (type) {
+    case "Boolean":
+      return (mask & ScalarMask.Boolean) !== 0;
+    case "Int":
+      return (mask & (ScalarMask.Int | ScalarMask.BigInt | ScalarMask.Float)) !== 0;
+    case "BigInt":
+      return (mask & ScalarMask.BigInt) !== 0;
+    case "Float":
+      return (mask & ScalarMask.Float) !== 0;
+    case "String":
+      return (mask & ScalarMask.String) !== 0;
+    default:
+      return false;
+  }
+}
+function getTaggedPlaceholderType(tag) {
+  switch (tag) {
+    case "BigInt":
+    case "Bytes":
+    case "DateTime":
+    case "Json":
+      return { type: tag };
+    case "Decimal":
+      return { type: "Float" };
+    default:
+      return void 0;
+  }
+}
+function inferListElementType(items) {
+  let widest = { type: "Any" };
+  for (const item of items) {
+    const classified = classifyValue(item);
+    let itemType;
+    switch (classified.kind) {
+      case "primitive":
+        itemType = getPrimitivePlaceholderType(classified.value);
+        break;
+      case "taggedScalar":
+        itemType = getTaggedPlaceholderType(classified.tag) ?? { type: "Any" };
+        break;
+      default:
+        return { type: "Any" };
+    }
+    widest = widenType(widest, itemType);
+  }
+  return widest;
+}
+function widenType(a, b) {
+  if (a.type === "Any") return b;
+  if (b.type === "Any") return a;
+  if (a.type === b.type) return a;
+  const NUMERIC_WIDTH = { Int: 0, BigInt: 1, Float: 2 };
+  const aWidth = NUMERIC_WIDTH[a.type];
+  const bWidth = NUMERIC_WIDTH[b.type];
+  if (aWidth !== void 0 && bWidth !== void 0) {
+    return aWidth >= bWidth ? a : b;
+  }
+  return { type: "Any" };
+}
+function matchesTaggedMask(tag, mask) {
+  switch (tag) {
+    case "DateTime":
+      return (mask & ScalarMask.DateTime) !== 0;
+    case "Decimal":
+      return (mask & ScalarMask.Decimal) !== 0;
+    case "BigInt":
+      return (mask & ScalarMask.BigInt) !== 0;
+    case "Bytes":
+      return (mask & ScalarMask.Bytes) !== 0;
+    case "Json":
+      return (mask & ScalarMask.Json) !== 0;
+    default:
+      return false;
+  }
+}
+function validateListElement(item, edge) {
+  const classified = classifyValue(item);
+  switch (classified.kind) {
+    case "structural":
+      return false;
+    case "null":
+      return false;
+    case "primitive": {
+      const type = getPrimitivePlaceholderType(classified.value);
+      const mask = getScalarMask(edge);
+      return mask !== 0 && matchesPrimitiveMask(type, mask);
+    }
+    case "taggedScalar": {
+      const mask = getScalarMask(edge);
+      return mask !== 0 && matchesTaggedMask(classified.tag, mask);
+    }
+    default:
+      return false;
+  }
+}
+function decodeIfTagged(value) {
+  if (isTaggedValue2(value)) {
+    return decodeTaggedValue(value);
+  }
+  return value;
+}
+function decodeTaggedValue(tagged) {
+  return tagged.value;
+}
+
 // src/raw-json-protocol.ts
 import { Decimal as Decimal4 } from "@prisma/client-runtime-utils";
 function normalizeRawJsonProtocolResponse(response) {
@@ -2425,5 +2863,7 @@ export {
   noopTracingHelper,
   normalizeJsonProtocolValues,
   normalizeRawJsonProtocolResponse,
+  parameterizeBatch,
+  parameterizeQuery,
   safeJsonStringify
 };

package/dist/parameterization/classify.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Value classification for parameterization.
+ *
+ * This module classifies runtime values into categories before applying
+ * schema rules during parameterization.
+ */
+import { JsonInputTaggedValue } from '@prisma/json-protocol';
+/**
+ * Classification result for a runtime value.
+ * Used to determine how to handle the value during parameterization.
+ */
+export type ValueClass = {
+    kind: 'null';
+} | {
+    kind: 'primitive';
+    value: string | number | boolean;
+} | {
+    kind: 'taggedScalar';
+    tag: JsonInputTaggedValue['$type'];
+    value: unknown;
+} | {
+    kind: 'structural';
+    value: unknown;
+} | {
+    kind: 'array';
+    items: unknown[];
+} | {
+    kind: 'object';
+    entries: Record<string, unknown>;
+};
+/**
+ * Classifies a runtime value for parameterization purposes.
+ *
+ * @param value - The value to classify
+ * @returns The classification result indicating how to handle the value
+ */
+export declare function classifyValue(value: unknown): ValueClass;
+/**
+ * Checks if a value is a plain object (not a tagged value or array).
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Checks if a value is a tagged value with a $type property.
+ */
+export declare function isTaggedValue(value: unknown): value is {
+    $type: string;
+    value: unknown;
+};

package/dist/parameterization/classify.test.d.ts

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

package/dist/parameterization/parameterize-tests/batch.test.d.ts

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

package/dist/parameterization/parameterize-tests/cache-key.test.d.ts

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

package/dist/parameterization/parameterize-tests/filter-operators.test.d.ts

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

package/dist/parameterization/parameterize-tests/nested-queries.test.d.ts

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

package/dist/parameterization/parameterize-tests/placeholder-naming.test.d.ts

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

package/dist/parameterization/parameterize-tests/placeholder-reuse.test.d.ts

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

package/dist/parameterization/parameterize-tests/scalar-values.test.d.ts

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

package/dist/parameterization/parameterize-tests/structural-values.test.d.ts

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

package/dist/parameterization/parameterize-tests/tagged-values.test.d.ts

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

package/dist/parameterization/parameterize-tests/test-fixtures.d.ts

@@ -0,0 +1,18 @@
+import { ParamGraph } from '@prisma/param-graph';
+export declare const testRuntimeDataModel: {
+    models: {};
+    enums: {
+        Status: {
+            values: {
+                name: string;
+                dbName: null;
+            }[];
+            dbName: null;
+        };
+    };
+    types: {};
+};
+/**
+ * Returns the ParamGraph for the test schema, building it on first call.
+ */
+export declare function getParamGraph(): ParamGraph;

package/dist/parameterization/parameterize.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Schema-aware traversal algorithm for parameterization.
+ *
+ * This module implements the core parameterization logic that walks the
+ * JsonQuery tree guided by ParamGraph. It only parameterizes values when
+ * both schema rules and runtime value types agree.
+ */
+import type { JsonBatchQuery, JsonQuery } from '@prisma/json-protocol';
+import { ParamGraph } from '@prisma/param-graph';
+/**
+ * Result of parameterizing a single query.
+ */
+export interface ParameterizeResult {
+    /** The query with user data values replaced by placeholders */
+    parameterizedQuery: JsonQuery;
+    /** Map of placeholder names to their actual values */
+    placeholderValues: Record<string, unknown>;
+}
+/**
+ * Result of parameterizing a batch of queries.
+ */
+export interface ParameterizeBatchResult {
+    /** The batch with user data values replaced by placeholders */
+    parameterizedBatch: JsonBatchQuery;
+    /** Combined map of placeholder names to their actual values */
+    placeholderValues: Record<string, unknown>;
+}
+/**
+ * Parameterizes a single query using the schema-aware approach.
+ *
+ * @param query - The query to parameterize
+ * @param view - The ParamGraph for schema lookups
+ * @returns The parameterized query with extracted placeholder values
+ */
+export declare function parameterizeQuery(query: JsonQuery, view: ParamGraph): ParameterizeResult;
+/**
+ * Parameterizes a batch of queries using the schema-aware approach.
+ *
+ * @param batch - The batch to parameterize
+ * @param view - The ParamGraph for schema lookups
+ * @returns The parameterized batch with extracted placeholder values
+ */
+export declare function parameterizeBatch(batch: JsonBatchQuery, view: ParamGraph): ParameterizeBatchResult;

package/dist/parameterization/parameterize.test.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/client-engine-runtime",
-  "version": "7.6.0",
+  "version": "7.7.0-dev.2",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -31,16 +31,20 @@
     "nanoid": "5.1.5",
     "ulid": "3.0.0",
     "uuid": "11.1.0",
-    "@prisma/client-runtime-utils": "7.6.0",
-    "@prisma/debug": "7.6.0",
-    "@prisma/sqlcommenter": "7.6.0",
-    "@prisma/driver-adapter-utils": "7.6.0"
+    "@prisma/client-runtime-utils": "7.7.0-dev.2",
+    "@prisma/param-graph": "7.7.0-dev.2",
+    "@prisma/debug": "7.7.0-dev.2",
+    "@prisma/sqlcommenter": "7.7.0-dev.2",
+    "@prisma/json-protocol": "7.7.0-dev.2",
+    "@prisma/driver-adapter-utils": "7.7.0-dev.2"
   },
   "devDependencies": {
     "@codspeed/benchmark.js-plugin": "4.0.0",
     "@types/benchmark": "2.1.5",
     "@types/node": "~20.19.24",
-    "benchmark": "2.1.4"
+    "benchmark": "2.1.4",
+    "@prisma/get-dmmf": "7.7.0-dev.2",
+    "@prisma/param-graph-builder": "7.7.0-dev.2"
   },
   "files": [
     "dist"