@prisma/param-graph-builder 7.3.0-integration-parameterization.7 → 7.3.0-integration-parameterization.8

package/dist/build-param-graph.js

@@ -31,11 +31,8 @@ class ParamGraphBuilder {
   inputNodes = [];
   outputNodes = [];
   roots = {};
-  // Cache for input type nodes to avoid rebuilding
   inputTypeNodeCache = /* @__PURE__ */ new Map();
-  // Cache for union nodes keyed by sorted type names
   unionNodeCache = /* @__PURE__ */ new Map();
-  // Cache for output type nodes
   outputTypeNodeCache = /* @__PURE__ */ new Map();
   /**
    * Interns a string into the string table, returning its index.
@@ -143,7 +140,7 @@ class ParamGraphBuilder {
   build() {
     return {
       s: this.stringTable,
-      en: this.enumNames,
+      e: this.enumNames,
       i: this.inputNodes,
       o: this.outputNodes,
       r: this.roots
@@ -159,16 +156,16 @@ function buildParamGraph(dmmf) {
     userEnumNames.add(e.name);
   }
   for (const inputType of dmmf.schema.inputObjectTypes.prisma ?? []) {
-    inputTypeMap.set(inputType.name, inputType);
+    inputTypeMap.set(getTypeName(inputType.name, "prisma"), inputType);
   }
   for (const inputType of dmmf.schema.inputObjectTypes.model ?? []) {
-    inputTypeMap.set(inputType.name, inputType);
+    inputTypeMap.set(getTypeName(inputType.name, "model"), inputType);
   }
   for (const outputType of dmmf.schema.outputObjectTypes.prisma) {
-    outputTypeMap.set(outputType.name, outputType);
+    outputTypeMap.set(getTypeName(outputType.name, "prisma"), outputType);
   }
   for (const outputType of dmmf.schema.outputObjectTypes.model) {
-    outputTypeMap.set(outputType.name, outputType);
+    outputTypeMap.set(getTypeName(outputType.name, "model"), outputType);
   }
   function buildInputNodeFromArgs(args) {
     const fields = {};
@@ -189,83 +186,7 @@ function buildParamGraph(dmmf) {
     return nodeId;
   }
   function buildInputEdge(arg) {
-    let flags = 0;
-    let scalarMask = 0;
-    let childNodeId;
-    let enumNameId;
-    const scalarTypes = [];
-    const enumTypes = [];
-    const inputObjectTypes = [];
-    for (const inputType of arg.inputTypes) {
-      switch (inputType.location) {
-        case "scalar":
-          scalarTypes.push(inputType);
-          break;
-        case "enumTypes":
-          enumTypes.push(inputType);
-          break;
-        case "inputObjectTypes":
-          inputObjectTypes.push(inputType);
-          break;
-        case "fieldRefTypes":
-          break;
-      }
-    }
-    for (const st of scalarTypes) {
-      scalarMask |= (0, import_param_graph.scalarTypeToMask)(st.type);
-    }
-    const hasStringScalar = (scalarMask & import_param_graph.ScalarMask.String) !== 0;
-    for (const et of enumTypes) {
-      const isUserEnum = userEnumNames.has(et.type);
-      const isPrismaEnum = et.namespace === "prisma";
-      if (isUserEnum) {
-        if (!hasStringScalar) {
-          enumNameId = builder.registerEnum(et.type);
-        }
-        scalarMask |= import_param_graph.ScalarMask.String;
-      } else if (!isPrismaEnum) {
-        scalarMask |= import_param_graph.ScalarMask.String;
-      }
-    }
-    const canParamScalar = arg.isParameterizable && scalarMask !== 0;
-    if (canParamScalar) {
-      const hasScalarList = scalarTypes.some((st) => st.isList) || enumTypes.some((et) => et.isList && (userEnumNames.has(et.type) || et.namespace !== "prisma"));
-      if (hasScalarList) {
-        flags |= import_param_graph.EdgeFlag.ListScalar;
-      } else {
-        flags |= import_param_graph.EdgeFlag.ParamScalar;
-      }
-    }
-    if (inputObjectTypes.length > 0) {
-      const hasObjectList = inputObjectTypes.some((iot) => iot.isList);
-      if (hasObjectList) {
-        flags |= import_param_graph.EdgeFlag.ListObject;
-      } else {
-        flags |= import_param_graph.EdgeFlag.Object;
-      }
-      if (inputObjectTypes.length === 1) {
-        childNodeId = buildInputTypeNode(inputObjectTypes[0].type);
-      } else {
-        childNodeId = buildUnionNode(inputObjectTypes.map((iot) => iot.type));
-      }
-    }
-    if (arg.isNullable) {
-      flags |= import_param_graph.EdgeFlag.Nullable;
-    }
-    if (flags === 0 && childNodeId === void 0) {
-      return void 0;
-    }
-    const edge = { k: flags };
-    if (childNodeId !== void 0) {
-      edge.c = childNodeId;
-    }
-    if (scalarMask !== 0 && canParamScalar) {
-      edge.m = scalarMask;
-    }
-    if (enumNameId !== void 0) {
-      edge.e = enumNameId;
-    }
-    return edge;
+    return mergeFieldVariants([arg]);
   }
   function buildInputTypeNode(typeName) {
     if (builder.hasInputTypeNode(typeName)) {
@@ -318,7 +239,7 @@ function buildParamGraph(dmmf) {
     const mergedFields = {};
     let hasAnyField = false;
     for (const [fieldName, variantFields] of fieldsByName) {
-      const mergedEdge = mergeFieldVariants(variantFields, typeNames.length);
+      const mergedEdge = mergeFieldVariants(variantFields);
       if (mergedEdge) {
         const stringIndex = builder.internString(fieldName);
         mergedFields[stringIndex] = mergedEdge;
@@ -330,75 +251,83 @@ function buildParamGraph(dmmf) {
     }
     return nodeId;
   }
-  function mergeFieldVariants(variants, _totalVariants) {
-    const parameterizableCount = variants.filter((v) => v.isParameterizable).length;
-    const allAgreeOnParam = parameterizableCount === 0 || parameterizableCount === variants.length;
-    if (!allAgreeOnParam) {
-    }
-    let combinedMask = 0;
-    const masks = [];
-    for (const variant of variants) {
-      let variantMask = 0;
-      for (const inputType of variant.inputTypes) {
-        if (inputType.location === "scalar") {
-          variantMask |= (0, import_param_graph.scalarTypeToMask)(inputType.type);
-        }
-      }
-      masks.push(variantMask);
-      combinedMask |= variantMask;
-    }
-    const allAgreeOnScalars = masks.every((m) => m === masks[0]);
-    const allObjectTypes = /* @__PURE__ */ new Set();
-    let hasObjectList = false;
-    let hasObject = false;
+  function mergeFieldVariants(variants) {
+    let flags = 0;
+    let scalarMask = 0;
+    let childNodeId;
+    let enumNameId;
+    const scalarTypes = [];
+    const enumTypes = [];
+    const inputObjectTypes = [];
     for (const variant of variants) {
       for (const inputType of variant.inputTypes) {
-        if (inputType.location === "inputObjectTypes") {
-          allObjectTypes.add(inputType.type);
-          if (inputType.isList) {
-            hasObjectList = true;
-          } else {
-            hasObject = true;
-          }
+        switch (inputType.location) {
+          case "scalar":
+            if (variant.isParameterizable) {
+              scalarTypes.push(inputType);
+            }
+            break;
+          case "enumTypes":
+            if (variant.isParameterizable) {
+              enumTypes.push(inputType);
+            }
+            break;
+          case "inputObjectTypes":
+            if (!inputObjectTypes.some((ot) => ot.type === inputType.type && ot.namespace === inputType.namespace)) {
+              inputObjectTypes.push(inputType);
+            }
+            break;
+          case "fieldRefTypes":
+            break;
+          default:
+            inputType.location;
         }
       }
     }
-    let flags = 0;
-    let childNodeId;
-    const canParamScalar = allAgreeOnParam && allAgreeOnScalars && variants.every((v) => v.isParameterizable) && combinedMask !== 0;
-    if (canParamScalar) {
-      const hasScalarList = variants.some((v) => v.inputTypes.some((it) => it.location === "scalar" && it.isList));
-      if (hasScalarList) {
-        flags |= import_param_graph.EdgeFlag.ListScalar;
+    for (const st of scalarTypes) {
+      scalarMask |= (0, import_param_graph.scalarTypeToMask)(st.type);
+      if (st.isList) {
+        flags |= import_param_graph.EdgeFlag.ParamListScalar;
       } else {
         flags |= import_param_graph.EdgeFlag.ParamScalar;
       }
     }
-    if (allObjectTypes.size > 0) {
+    for (const et of enumTypes) {
+      if (et.namespace === "model") {
+        enumNameId = builder.registerEnum(et.type);
+        if (et.isList) {
+          flags |= import_param_graph.EdgeFlag.ParamListEnum;
+        } else {
+          flags |= import_param_graph.EdgeFlag.ParamEnum;
+        }
+        break;
+      }
+    }
+    if (inputObjectTypes.length > 0) {
+      const hasObjectList = inputObjectTypes.some((iot) => iot.isList);
       if (hasObjectList) {
         flags |= import_param_graph.EdgeFlag.ListObject;
-      } else if (hasObject) {
+      } else {
         flags |= import_param_graph.EdgeFlag.Object;
       }
-      const objectTypeArray = [...allObjectTypes];
-      if (objectTypeArray.length === 1) {
-        childNodeId = buildInputTypeNode(objectTypeArray[0]);
+      if (inputObjectTypes.length === 1) {
+        childNodeId = buildInputTypeNode(getTypeName(inputObjectTypes[0].type, inputObjectTypes[0].namespace));
       } else {
-        childNodeId = buildUnionNode(objectTypeArray);
+        childNodeId = buildUnionNode(inputObjectTypes.map((iot) => getTypeName(iot.type, iot.namespace)));
       }
     }
-    if (variants.some((v) => v.isNullable)) {
-      flags |= import_param_graph.EdgeFlag.Nullable;
-    }
-    if (flags === 0 && childNodeId === void 0) {
+    if (flags === 0) {
       return void 0;
     }
     const edge = { k: flags };
     if (childNodeId !== void 0) {
       edge.c = childNodeId;
     }
-    if (canParamScalar && combinedMask !== 0) {
-      edge.m = combinedMask;
+    if (scalarMask !== 0) {
+      edge.m = scalarMask;
+    }
+    if (enumNameId !== void 0) {
+      edge.e = enumNameId;
     }
     return edge;
   }
@@ -436,7 +365,7 @@ function buildParamGraph(dmmf) {
       argsNodeId = buildInputNodeFromArgs(field.args);
     }
     if (field.outputType.location === "outputObjectTypes") {
-      childOutputNodeId = buildOutputTypeNode(field.outputType.type);
+      childOutputNodeId = buildOutputTypeNode(getTypeName(field.outputType.type, field.outputType.namespace));
     }
     if (argsNodeId === void 0 && childOutputNodeId === void 0) {
       return void 0;
@@ -457,12 +386,12 @@ function buildParamGraph(dmmf) {
       const fieldName = mapping[action];
       if (!fieldName) continue;
       let rootField;
-      const queryType = outputTypeMap.get("Query");
+      const queryType = outputTypeMap.get("prisma.Query");
       if (queryType) {
         rootField = queryType.fields.find((f) => f.name === fieldName);
       }
       if (!rootField) {
-        const mutationType = outputTypeMap.get("Mutation");
+        const mutationType = outputTypeMap.get("prisma.Mutation");
         if (mutationType) {
           rootField = mutationType.fields.find((f) => f.name === fieldName);
         }
@@ -471,7 +400,7 @@ function buildParamGraph(dmmf) {
       const argsNodeId = buildInputNodeFromArgs(rootField.args);
       let outputNodeId;
       if (rootField.outputType.location === "outputObjectTypes") {
-        outputNodeId = buildOutputTypeNode(rootField.outputType.type);
+        outputNodeId = buildOutputTypeNode(getTypeName(rootField.outputType.type, rootField.outputType.namespace));
       }
       const dmmfActionToJsonAction = {
         create: "createOne",
@@ -486,6 +415,12 @@ function buildParamGraph(dmmf) {
   }
   return builder.build();
 }
+function getTypeName(name, namespace) {
+  if (namespace === void 0) {
+    return name;
+  }
+  return `${namespace}.${name}`;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildParamGraph

package/dist/build-param-graph.mjs

@@ -1,7 +1,6 @@
 import { ModelAction } from "@prisma/dmmf";
 import {
   EdgeFlag,
-  ScalarMask,
   scalarTypeToMask
 } from "@prisma/param-graph";
 class ParamGraphBuilder {
@@ -12,11 +11,8 @@ class ParamGraphBuilder {
   inputNodes = [];
   outputNodes = [];
   roots = {};
-  // Cache for input type nodes to avoid rebuilding
   inputTypeNodeCache = /* @__PURE__ */ new Map();
-  // Cache for union nodes keyed by sorted type names
   unionNodeCache = /* @__PURE__ */ new Map();
-  // Cache for output type nodes
   outputTypeNodeCache = /* @__PURE__ */ new Map();
   /**
    * Interns a string into the string table, returning its index.
@@ -124,7 +120,7 @@ class ParamGraphBuilder {
   build() {
     return {
       s: this.stringTable,
-      en: this.enumNames,
+      e: this.enumNames,
       i: this.inputNodes,
       o: this.outputNodes,
       r: this.roots
@@ -140,16 +136,16 @@ function buildParamGraph(dmmf) {
     userEnumNames.add(e.name);
   }
   for (const inputType of dmmf.schema.inputObjectTypes.prisma ?? []) {
-    inputTypeMap.set(inputType.name, inputType);
+    inputTypeMap.set(getTypeName(inputType.name, "prisma"), inputType);
   }
   for (const inputType of dmmf.schema.inputObjectTypes.model ?? []) {
-    inputTypeMap.set(inputType.name, inputType);
+    inputTypeMap.set(getTypeName(inputType.name, "model"), inputType);
   }
   for (const outputType of dmmf.schema.outputObjectTypes.prisma) {
-    outputTypeMap.set(outputType.name, outputType);
+    outputTypeMap.set(getTypeName(outputType.name, "prisma"), outputType);
   }
   for (const outputType of dmmf.schema.outputObjectTypes.model) {
-    outputTypeMap.set(outputType.name, outputType);
+    outputTypeMap.set(getTypeName(outputType.name, "model"), outputType);
   }
   function buildInputNodeFromArgs(args) {
     const fields = {};
@@ -170,83 +166,7 @@ function buildParamGraph(dmmf) {
     return nodeId;
   }
   function buildInputEdge(arg) {
-    let flags = 0;
-    let scalarMask = 0;
-    let childNodeId;
-    let enumNameId;
-    const scalarTypes = [];
-    const enumTypes = [];
-    const inputObjectTypes = [];
-    for (const inputType of arg.inputTypes) {
-      switch (inputType.location) {
-        case "scalar":
-          scalarTypes.push(inputType);
-          break;
-        case "enumTypes":
-          enumTypes.push(inputType);
-          break;
-        case "inputObjectTypes":
-          inputObjectTypes.push(inputType);
-          break;
-        case "fieldRefTypes":
-          break;
-      }
-    }
-    for (const st of scalarTypes) {
-      scalarMask |= scalarTypeToMask(st.type);
-    }
-    const hasStringScalar = (scalarMask & ScalarMask.String) !== 0;
-    for (const et of enumTypes) {
-      const isUserEnum = userEnumNames.has(et.type);
-      const isPrismaEnum = et.namespace === "prisma";
-      if (isUserEnum) {
-        if (!hasStringScalar) {
-          enumNameId = builder.registerEnum(et.type);
-        }
-        scalarMask |= ScalarMask.String;
-      } else if (!isPrismaEnum) {
-        scalarMask |= ScalarMask.String;
-      }
-    }
-    const canParamScalar = arg.isParameterizable && scalarMask !== 0;
-    if (canParamScalar) {
-      const hasScalarList = scalarTypes.some((st) => st.isList) || enumTypes.some((et) => et.isList && (userEnumNames.has(et.type) || et.namespace !== "prisma"));
-      if (hasScalarList) {
-        flags |= EdgeFlag.ListScalar;
-      } else {
-        flags |= EdgeFlag.ParamScalar;
-      }
-    }
-    if (inputObjectTypes.length > 0) {
-      const hasObjectList = inputObjectTypes.some((iot) => iot.isList);
-      if (hasObjectList) {
-        flags |= EdgeFlag.ListObject;
-      } else {
-        flags |= EdgeFlag.Object;
-      }
-      if (inputObjectTypes.length === 1) {
-        childNodeId = buildInputTypeNode(inputObjectTypes[0].type);
-      } else {
-        childNodeId = buildUnionNode(inputObjectTypes.map((iot) => iot.type));
-      }
-    }
-    if (arg.isNullable) {
-      flags |= EdgeFlag.Nullable;
-    }
-    if (flags === 0 && childNodeId === void 0) {
-      return void 0;
-    }
-    const edge = { k: flags };
-    if (childNodeId !== void 0) {
-      edge.c = childNodeId;
-    }
-    if (scalarMask !== 0 && canParamScalar) {
-      edge.m = scalarMask;
-    }
-    if (enumNameId !== void 0) {
-      edge.e = enumNameId;
-    }
-    return edge;
+    return mergeFieldVariants([arg]);
   }
   function buildInputTypeNode(typeName) {
     if (builder.hasInputTypeNode(typeName)) {
@@ -299,7 +219,7 @@ function buildParamGraph(dmmf) {
     const mergedFields = {};
     let hasAnyField = false;
     for (const [fieldName, variantFields] of fieldsByName) {
-      const mergedEdge = mergeFieldVariants(variantFields, typeNames.length);
+      const mergedEdge = mergeFieldVariants(variantFields);
       if (mergedEdge) {
         const stringIndex = builder.internString(fieldName);
         mergedFields[stringIndex] = mergedEdge;
@@ -311,75 +231,83 @@ function buildParamGraph(dmmf) {
     }
     return nodeId;
   }
-  function mergeFieldVariants(variants, _totalVariants) {
-    const parameterizableCount = variants.filter((v) => v.isParameterizable).length;
-    const allAgreeOnParam = parameterizableCount === 0 || parameterizableCount === variants.length;
-    if (!allAgreeOnParam) {
-    }
-    let combinedMask = 0;
-    const masks = [];
-    for (const variant of variants) {
-      let variantMask = 0;
-      for (const inputType of variant.inputTypes) {
-        if (inputType.location === "scalar") {
-          variantMask |= scalarTypeToMask(inputType.type);
-        }
-      }
-      masks.push(variantMask);
-      combinedMask |= variantMask;
-    }
-    const allAgreeOnScalars = masks.every((m) => m === masks[0]);
-    const allObjectTypes = /* @__PURE__ */ new Set();
-    let hasObjectList = false;
-    let hasObject = false;
+  function mergeFieldVariants(variants) {
+    let flags = 0;
+    let scalarMask = 0;
+    let childNodeId;
+    let enumNameId;
+    const scalarTypes = [];
+    const enumTypes = [];
+    const inputObjectTypes = [];
     for (const variant of variants) {
       for (const inputType of variant.inputTypes) {
-        if (inputType.location === "inputObjectTypes") {
-          allObjectTypes.add(inputType.type);
-          if (inputType.isList) {
-            hasObjectList = true;
-          } else {
-            hasObject = true;
-          }
+        switch (inputType.location) {
+          case "scalar":
+            if (variant.isParameterizable) {
+              scalarTypes.push(inputType);
+            }
+            break;
+          case "enumTypes":
+            if (variant.isParameterizable) {
+              enumTypes.push(inputType);
+            }
+            break;
+          case "inputObjectTypes":
+            if (!inputObjectTypes.some((ot) => ot.type === inputType.type && ot.namespace === inputType.namespace)) {
+              inputObjectTypes.push(inputType);
+            }
+            break;
+          case "fieldRefTypes":
+            break;
+          default:
+            inputType.location;
         }
       }
     }
-    let flags = 0;
-    let childNodeId;
-    const canParamScalar = allAgreeOnParam && allAgreeOnScalars && variants.every((v) => v.isParameterizable) && combinedMask !== 0;
-    if (canParamScalar) {
-      const hasScalarList = variants.some((v) => v.inputTypes.some((it) => it.location === "scalar" && it.isList));
-      if (hasScalarList) {
-        flags |= EdgeFlag.ListScalar;
+    for (const st of scalarTypes) {
+      scalarMask |= scalarTypeToMask(st.type);
+      if (st.isList) {
+        flags |= EdgeFlag.ParamListScalar;
       } else {
         flags |= EdgeFlag.ParamScalar;
       }
     }
-    if (allObjectTypes.size > 0) {
+    for (const et of enumTypes) {
+      if (et.namespace === "model") {
+        enumNameId = builder.registerEnum(et.type);
+        if (et.isList) {
+          flags |= EdgeFlag.ParamListEnum;
+        } else {
+          flags |= EdgeFlag.ParamEnum;
+        }
+        break;
+      }
+    }
+    if (inputObjectTypes.length > 0) {
+      const hasObjectList = inputObjectTypes.some((iot) => iot.isList);
       if (hasObjectList) {
         flags |= EdgeFlag.ListObject;
-      } else if (hasObject) {
+      } else {
         flags |= EdgeFlag.Object;
       }
-      const objectTypeArray = [...allObjectTypes];
-      if (objectTypeArray.length === 1) {
-        childNodeId = buildInputTypeNode(objectTypeArray[0]);
+      if (inputObjectTypes.length === 1) {
+        childNodeId = buildInputTypeNode(getTypeName(inputObjectTypes[0].type, inputObjectTypes[0].namespace));
       } else {
-        childNodeId = buildUnionNode(objectTypeArray);
+        childNodeId = buildUnionNode(inputObjectTypes.map((iot) => getTypeName(iot.type, iot.namespace)));
       }
     }
-    if (variants.some((v) => v.isNullable)) {
-      flags |= EdgeFlag.Nullable;
-    }
-    if (flags === 0 && childNodeId === void 0) {
+    if (flags === 0) {
       return void 0;
     }
     const edge = { k: flags };
     if (childNodeId !== void 0) {
       edge.c = childNodeId;
     }
-    if (canParamScalar && combinedMask !== 0) {
-      edge.m = combinedMask;
+    if (scalarMask !== 0) {
+      edge.m = scalarMask;
+    }
+    if (enumNameId !== void 0) {
+      edge.e = enumNameId;
     }
     return edge;
   }
@@ -417,7 +345,7 @@ function buildParamGraph(dmmf) {
       argsNodeId = buildInputNodeFromArgs(field.args);
     }
     if (field.outputType.location === "outputObjectTypes") {
-      childOutputNodeId = buildOutputTypeNode(field.outputType.type);
+      childOutputNodeId = buildOutputTypeNode(getTypeName(field.outputType.type, field.outputType.namespace));
     }
     if (argsNodeId === void 0 && childOutputNodeId === void 0) {
       return void 0;
@@ -438,12 +366,12 @@ function buildParamGraph(dmmf) {
       const fieldName = mapping[action];
       if (!fieldName) continue;
       let rootField;
-      const queryType = outputTypeMap.get("Query");
+      const queryType = outputTypeMap.get("prisma.Query");
       if (queryType) {
         rootField = queryType.fields.find((f) => f.name === fieldName);
       }
       if (!rootField) {
-        const mutationType = outputTypeMap.get("Mutation");
+        const mutationType = outputTypeMap.get("prisma.Mutation");
         if (mutationType) {
           rootField = mutationType.fields.find((f) => f.name === fieldName);
         }
@@ -452,7 +380,7 @@ function buildParamGraph(dmmf) {
       const argsNodeId = buildInputNodeFromArgs(rootField.args);
       let outputNodeId;
       if (rootField.outputType.location === "outputObjectTypes") {
-        outputNodeId = buildOutputTypeNode(rootField.outputType.type);
+        outputNodeId = buildOutputTypeNode(getTypeName(rootField.outputType.type, rootField.outputType.namespace));
       }
       const dmmfActionToJsonAction = {
         create: "createOne",
@@ -467,6 +395,12 @@ function buildParamGraph(dmmf) {
   }
   return builder.build();
 }
+function getTypeName(name, namespace) {
+  if (namespace === void 0) {
+    return name;
+  }
+  return `${namespace}.${name}`;
+}
 export {
   buildParamGraph
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/param-graph-builder",
-  "version": "7.3.0-integration-parameterization.7",
+  "version": "7.3.0-integration-parameterization.8",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -24,8 +24,8 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@prisma/dmmf": "7.3.0-integration-parameterization.7",
-    "@prisma/param-graph": "7.3.0-integration-parameterization.7"
+    "@prisma/dmmf": "7.3.0-integration-parameterization.8",
+    "@prisma/param-graph": "7.3.0-integration-parameterization.8"
   },
   "files": [
     "dist"