@prisma/param-graph-builder 0.0.1

package/README.md

@@ -0,0 +1,9 @@
+# @prisma/param-graph-builder
+
+This package is intended for Prisma's internal use.
+
+Builds a ParamGraph from DMMF (Data Model Metadata Format) at client generation time.
+
+The ParamGraph is a compact data structure that enables schema-aware parameterization at runtime. It stores only parameterizable paths and uses a string table to de-duplicate field names.
+
+This package is used by both `@prisma/client-generator-js` and `@prisma/client-generator-ts` to generate the parameterization schema that is embedded in the generated Prisma Client.

package/dist/build-param-graph.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Builds a ParamGraph from DMMF at client generation time.
+ *
+ * The ParamGraph is a compact data structure that enables schema-aware
+ * parameterization at runtime. It only stores parameterizable paths,
+ * and uses a string table to de-duplicate field names.
+ */
+import type * as DMMF from '@prisma/dmmf';
+import { ParamGraph } from '@prisma/param-graph';
+/**
+ * Builds a ParamGraph from DMMF schema.
+ */
+export declare function buildParamGraph(dmmf: DMMF.Document): ParamGraph;

package/dist/build-param-graph.js

@@ -0,0 +1,492 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var build_param_graph_exports = {};
+__export(build_param_graph_exports, {
+  buildParamGraph: () => buildParamGraph
+});
+module.exports = __toCommonJS(build_param_graph_exports);
+var import_dmmf = require("@prisma/dmmf");
+var import_param_graph = require("@prisma/param-graph");
+class ParamGraphBuilder {
+  stringTable = [];
+  stringToIndex = /* @__PURE__ */ new Map();
+  enumNames = [];
+  enumToIndex = /* @__PURE__ */ new Map();
+  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.
+   */
+  internString(str) {
+    let index = this.stringToIndex.get(str);
+    if (index === void 0) {
+      index = this.stringTable.length;
+      this.stringTable.push(str);
+      this.stringToIndex.set(str, index);
+    }
+    return index;
+  }
+  /**
+   * Registers a user enum name, returning its index.
+   */
+  registerEnum(enumName) {
+    let index = this.enumToIndex.get(enumName);
+    if (index === void 0) {
+      index = this.enumNames.length;
+      this.enumNames.push(enumName);
+      this.enumToIndex.set(enumName, index);
+    }
+    return index;
+  }
+  /**
+   * Allocates a new input node and returns its ID.
+   */
+  allocateInputNode() {
+    const id = this.inputNodes.length;
+    this.inputNodes.push({});
+    return id;
+  }
+  /**
+   * Sets fields on an input node.
+   */
+  setInputNodeFields(nodeId, fields) {
+    if (Object.keys(fields).length > 0) {
+      this.inputNodes[nodeId].f = fields;
+    }
+  }
+  /**
+   * Allocates a new output node and returns its ID.
+   */
+  allocateOutputNode() {
+    const id = this.outputNodes.length;
+    this.outputNodes.push({});
+    return id;
+  }
+  /**
+   * Sets fields on an output node.
+   */
+  setOutputNodeFields(nodeId, fields) {
+    if (Object.keys(fields).length > 0) {
+      this.outputNodes[nodeId].f = fields;
+    }
+  }
+  /**
+   * Records a root entry for an operation.
+   */
+  setRoot(key, entry) {
+    if (entry.a !== void 0 || entry.o !== void 0) {
+      this.roots[key] = entry;
+    }
+  }
+  /**
+   * Gets or sets a cached input type node ID.
+   */
+  getInputTypeNode(typeName) {
+    return this.inputTypeNodeCache.get(typeName);
+  }
+  setInputTypeNode(typeName, nodeId) {
+    this.inputTypeNodeCache.set(typeName, nodeId);
+  }
+  hasInputTypeNode(typeName) {
+    return this.inputTypeNodeCache.has(typeName);
+  }
+  /**
+   * Gets or sets a cached union node ID.
+   */
+  getUnionNode(key) {
+    return this.unionNodeCache.get(key);
+  }
+  setUnionNode(key, nodeId) {
+    this.unionNodeCache.set(key, nodeId);
+  }
+  hasUnionNode(key) {
+    return this.unionNodeCache.has(key);
+  }
+  /**
+   * Gets or sets a cached output type node ID.
+   */
+  getOutputTypeNode(typeName) {
+    return this.outputTypeNodeCache.get(typeName);
+  }
+  setOutputTypeNode(typeName, nodeId) {
+    this.outputTypeNodeCache.set(typeName, nodeId);
+  }
+  hasOutputTypeNode(typeName) {
+    return this.outputTypeNodeCache.has(typeName);
+  }
+  /**
+   * Builds the final ParamGraph.
+   */
+  build() {
+    return {
+      s: this.stringTable,
+      en: this.enumNames,
+      i: this.inputNodes,
+      o: this.outputNodes,
+      r: this.roots
+    };
+  }
+}
+function buildParamGraph(dmmf) {
+  const builder = new ParamGraphBuilder();
+  const inputTypeMap = /* @__PURE__ */ new Map();
+  const outputTypeMap = /* @__PURE__ */ new Map();
+  const userEnumNames = /* @__PURE__ */ new Set();
+  for (const e of dmmf.datamodel.enums) {
+    userEnumNames.add(e.name);
+  }
+  for (const inputType of dmmf.schema.inputObjectTypes.prisma ?? []) {
+    inputTypeMap.set(inputType.name, inputType);
+  }
+  for (const inputType of dmmf.schema.inputObjectTypes.model ?? []) {
+    inputTypeMap.set(inputType.name, inputType);
+  }
+  for (const outputType of dmmf.schema.outputObjectTypes.prisma) {
+    outputTypeMap.set(outputType.name, outputType);
+  }
+  for (const outputType of dmmf.schema.outputObjectTypes.model) {
+    outputTypeMap.set(outputType.name, outputType);
+  }
+  function buildInputNodeFromArgs(args) {
+    const fields = {};
+    let hasAnyField = false;
+    for (const arg of args) {
+      const edge = buildInputEdge(arg);
+      if (edge) {
+        const stringIndex = builder.internString(arg.name);
+        fields[stringIndex] = edge;
+        hasAnyField = true;
+      }
+    }
+    if (!hasAnyField) {
+      return void 0;
+    }
+    const nodeId = builder.allocateInputNode();
+    builder.setInputNodeFields(nodeId, fields);
+    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;
+  }
+  function buildInputTypeNode(typeName) {
+    if (builder.hasInputTypeNode(typeName)) {
+      return builder.getInputTypeNode(typeName);
+    }
+    const inputType = inputTypeMap.get(typeName);
+    if (!inputType) {
+      builder.setInputTypeNode(typeName, void 0);
+      return void 0;
+    }
+    const nodeId = builder.allocateInputNode();
+    builder.setInputTypeNode(typeName, nodeId);
+    const fields = {};
+    let hasAnyField = false;
+    for (const field of inputType.fields) {
+      const edge = buildInputEdge(field);
+      if (edge) {
+        const stringIndex = builder.internString(field.name);
+        fields[stringIndex] = edge;
+        hasAnyField = true;
+      }
+    }
+    if (hasAnyField) {
+      builder.setInputNodeFields(nodeId, fields);
+      return nodeId;
+    }
+    return nodeId;
+  }
+  function buildUnionNode(typeNames) {
+    const sortedNames = [...typeNames].sort();
+    const cacheKey = sortedNames.join("|");
+    if (builder.hasUnionNode(cacheKey)) {
+      return builder.getUnionNode(cacheKey);
+    }
+    const nodeId = builder.allocateInputNode();
+    builder.setUnionNode(cacheKey, nodeId);
+    const fieldsByName = /* @__PURE__ */ new Map();
+    for (const typeName of typeNames) {
+      const inputType = inputTypeMap.get(typeName);
+      if (!inputType) continue;
+      for (const field of inputType.fields) {
+        let fieldsForName = fieldsByName.get(field.name);
+        if (!fieldsForName) {
+          fieldsForName = [];
+          fieldsByName.set(field.name, fieldsForName);
+        }
+        fieldsForName.push(field);
+      }
+    }
+    const mergedFields = {};
+    let hasAnyField = false;
+    for (const [fieldName, variantFields] of fieldsByName) {
+      const mergedEdge = mergeFieldVariants(variantFields, typeNames.length);
+      if (mergedEdge) {
+        const stringIndex = builder.internString(fieldName);
+        mergedFields[stringIndex] = mergedEdge;
+        hasAnyField = true;
+      }
+    }
+    if (hasAnyField) {
+      builder.setInputNodeFields(nodeId, mergedFields);
+    }
+    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;
+    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;
+          }
+        }
+      }
+    }
+    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;
+      } else {
+        flags |= import_param_graph.EdgeFlag.ParamScalar;
+      }
+    }
+    if (allObjectTypes.size > 0) {
+      if (hasObjectList) {
+        flags |= import_param_graph.EdgeFlag.ListObject;
+      } else if (hasObject) {
+        flags |= import_param_graph.EdgeFlag.Object;
+      }
+      const objectTypeArray = [...allObjectTypes];
+      if (objectTypeArray.length === 1) {
+        childNodeId = buildInputTypeNode(objectTypeArray[0]);
+      } else {
+        childNodeId = buildUnionNode(objectTypeArray);
+      }
+    }
+    if (variants.some((v) => v.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 (canParamScalar && combinedMask !== 0) {
+      edge.m = combinedMask;
+    }
+    return edge;
+  }
+  function buildOutputTypeNode(typeName) {
+    if (builder.hasOutputTypeNode(typeName)) {
+      return builder.getOutputTypeNode(typeName);
+    }
+    const outputType = outputTypeMap.get(typeName);
+    if (!outputType) {
+      builder.setOutputTypeNode(typeName, void 0);
+      return void 0;
+    }
+    const nodeId = builder.allocateOutputNode();
+    builder.setOutputTypeNode(typeName, nodeId);
+    const fields = {};
+    let hasAnyField = false;
+    for (const field of outputType.fields) {
+      const edge = buildOutputEdge(field);
+      if (edge) {
+        const stringIndex = builder.internString(field.name);
+        fields[stringIndex] = edge;
+        hasAnyField = true;
+      }
+    }
+    if (hasAnyField) {
+      builder.setOutputNodeFields(nodeId, fields);
+      return nodeId;
+    }
+    return nodeId;
+  }
+  function buildOutputEdge(field) {
+    let argsNodeId;
+    let childOutputNodeId;
+    if (field.args.length > 0) {
+      argsNodeId = buildInputNodeFromArgs(field.args);
+    }
+    if (field.outputType.location === "outputObjectTypes") {
+      childOutputNodeId = buildOutputTypeNode(field.outputType.type);
+    }
+    if (argsNodeId === void 0 && childOutputNodeId === void 0) {
+      return void 0;
+    }
+    const edge = {};
+    if (argsNodeId !== void 0) {
+      edge.a = argsNodeId;
+    }
+    if (childOutputNodeId !== void 0) {
+      edge.o = childOutputNodeId;
+    }
+    return edge;
+  }
+  for (const mapping of dmmf.mappings.modelOperations) {
+    const modelName = mapping.model;
+    const actions = Object.keys(import_dmmf.ModelAction);
+    for (const action of actions) {
+      const fieldName = mapping[action];
+      if (!fieldName) continue;
+      let rootField;
+      const queryType = outputTypeMap.get("Query");
+      if (queryType) {
+        rootField = queryType.fields.find((f) => f.name === fieldName);
+      }
+      if (!rootField) {
+        const mutationType = outputTypeMap.get("Mutation");
+        if (mutationType) {
+          rootField = mutationType.fields.find((f) => f.name === fieldName);
+        }
+      }
+      if (!rootField) continue;
+      const argsNodeId = buildInputNodeFromArgs(rootField.args);
+      let outputNodeId;
+      if (rootField.outputType.location === "outputObjectTypes") {
+        outputNodeId = buildOutputTypeNode(rootField.outputType.type);
+      }
+      const dmmfActionToJsonAction = {
+        create: "createOne",
+        update: "updateOne",
+        delete: "deleteOne",
+        upsert: "upsertOne"
+      };
+      const jsonAction = dmmfActionToJsonAction[action] ?? action;
+      const rootKey = `${modelName}.${jsonAction}`;
+      builder.setRoot(rootKey, { a: argsNodeId, o: outputNodeId });
+    }
+  }
+  return builder.build();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildParamGraph
+});

package/dist/build-param-graph.mjs

@@ -0,0 +1,472 @@
+import { ModelAction } from "@prisma/dmmf";
+import {
+  EdgeFlag,
+  ScalarMask,
+  scalarTypeToMask
+} from "@prisma/param-graph";
+class ParamGraphBuilder {
+  stringTable = [];
+  stringToIndex = /* @__PURE__ */ new Map();
+  enumNames = [];
+  enumToIndex = /* @__PURE__ */ new Map();
+  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.
+   */
+  internString(str) {
+    let index = this.stringToIndex.get(str);
+    if (index === void 0) {
+      index = this.stringTable.length;
+      this.stringTable.push(str);
+      this.stringToIndex.set(str, index);
+    }
+    return index;
+  }
+  /**
+   * Registers a user enum name, returning its index.
+   */
+  registerEnum(enumName) {
+    let index = this.enumToIndex.get(enumName);
+    if (index === void 0) {
+      index = this.enumNames.length;
+      this.enumNames.push(enumName);
+      this.enumToIndex.set(enumName, index);
+    }
+    return index;
+  }
+  /**
+   * Allocates a new input node and returns its ID.
+   */
+  allocateInputNode() {
+    const id = this.inputNodes.length;
+    this.inputNodes.push({});
+    return id;
+  }
+  /**
+   * Sets fields on an input node.
+   */
+  setInputNodeFields(nodeId, fields) {
+    if (Object.keys(fields).length > 0) {
+      this.inputNodes[nodeId].f = fields;
+    }
+  }
+  /**
+   * Allocates a new output node and returns its ID.
+   */
+  allocateOutputNode() {
+    const id = this.outputNodes.length;
+    this.outputNodes.push({});
+    return id;
+  }
+  /**
+   * Sets fields on an output node.
+   */
+  setOutputNodeFields(nodeId, fields) {
+    if (Object.keys(fields).length > 0) {
+      this.outputNodes[nodeId].f = fields;
+    }
+  }
+  /**
+   * Records a root entry for an operation.
+   */
+  setRoot(key, entry) {
+    if (entry.a !== void 0 || entry.o !== void 0) {
+      this.roots[key] = entry;
+    }
+  }
+  /**
+   * Gets or sets a cached input type node ID.
+   */
+  getInputTypeNode(typeName) {
+    return this.inputTypeNodeCache.get(typeName);
+  }
+  setInputTypeNode(typeName, nodeId) {
+    this.inputTypeNodeCache.set(typeName, nodeId);
+  }
+  hasInputTypeNode(typeName) {
+    return this.inputTypeNodeCache.has(typeName);
+  }
+  /**
+   * Gets or sets a cached union node ID.
+   */
+  getUnionNode(key) {
+    return this.unionNodeCache.get(key);
+  }
+  setUnionNode(key, nodeId) {
+    this.unionNodeCache.set(key, nodeId);
+  }
+  hasUnionNode(key) {
+    return this.unionNodeCache.has(key);
+  }
+  /**
+   * Gets or sets a cached output type node ID.
+   */
+  getOutputTypeNode(typeName) {
+    return this.outputTypeNodeCache.get(typeName);
+  }
+  setOutputTypeNode(typeName, nodeId) {
+    this.outputTypeNodeCache.set(typeName, nodeId);
+  }
+  hasOutputTypeNode(typeName) {
+    return this.outputTypeNodeCache.has(typeName);
+  }
+  /**
+   * Builds the final ParamGraph.
+   */
+  build() {
+    return {
+      s: this.stringTable,
+      en: this.enumNames,
+      i: this.inputNodes,
+      o: this.outputNodes,
+      r: this.roots
+    };
+  }
+}
+function buildParamGraph(dmmf) {
+  const builder = new ParamGraphBuilder();
+  const inputTypeMap = /* @__PURE__ */ new Map();
+  const outputTypeMap = /* @__PURE__ */ new Map();
+  const userEnumNames = /* @__PURE__ */ new Set();
+  for (const e of dmmf.datamodel.enums) {
+    userEnumNames.add(e.name);
+  }
+  for (const inputType of dmmf.schema.inputObjectTypes.prisma ?? []) {
+    inputTypeMap.set(inputType.name, inputType);
+  }
+  for (const inputType of dmmf.schema.inputObjectTypes.model ?? []) {
+    inputTypeMap.set(inputType.name, inputType);
+  }
+  for (const outputType of dmmf.schema.outputObjectTypes.prisma) {
+    outputTypeMap.set(outputType.name, outputType);
+  }
+  for (const outputType of dmmf.schema.outputObjectTypes.model) {
+    outputTypeMap.set(outputType.name, outputType);
+  }
+  function buildInputNodeFromArgs(args) {
+    const fields = {};
+    let hasAnyField = false;
+    for (const arg of args) {
+      const edge = buildInputEdge(arg);
+      if (edge) {
+        const stringIndex = builder.internString(arg.name);
+        fields[stringIndex] = edge;
+        hasAnyField = true;
+      }
+    }
+    if (!hasAnyField) {
+      return void 0;
+    }
+    const nodeId = builder.allocateInputNode();
+    builder.setInputNodeFields(nodeId, fields);
+    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;
+  }
+  function buildInputTypeNode(typeName) {
+    if (builder.hasInputTypeNode(typeName)) {
+      return builder.getInputTypeNode(typeName);
+    }
+    const inputType = inputTypeMap.get(typeName);
+    if (!inputType) {
+      builder.setInputTypeNode(typeName, void 0);
+      return void 0;
+    }
+    const nodeId = builder.allocateInputNode();
+    builder.setInputTypeNode(typeName, nodeId);
+    const fields = {};
+    let hasAnyField = false;
+    for (const field of inputType.fields) {
+      const edge = buildInputEdge(field);
+      if (edge) {
+        const stringIndex = builder.internString(field.name);
+        fields[stringIndex] = edge;
+        hasAnyField = true;
+      }
+    }
+    if (hasAnyField) {
+      builder.setInputNodeFields(nodeId, fields);
+      return nodeId;
+    }
+    return nodeId;
+  }
+  function buildUnionNode(typeNames) {
+    const sortedNames = [...typeNames].sort();
+    const cacheKey = sortedNames.join("|");
+    if (builder.hasUnionNode(cacheKey)) {
+      return builder.getUnionNode(cacheKey);
+    }
+    const nodeId = builder.allocateInputNode();
+    builder.setUnionNode(cacheKey, nodeId);
+    const fieldsByName = /* @__PURE__ */ new Map();
+    for (const typeName of typeNames) {
+      const inputType = inputTypeMap.get(typeName);
+      if (!inputType) continue;
+      for (const field of inputType.fields) {
+        let fieldsForName = fieldsByName.get(field.name);
+        if (!fieldsForName) {
+          fieldsForName = [];
+          fieldsByName.set(field.name, fieldsForName);
+        }
+        fieldsForName.push(field);
+      }
+    }
+    const mergedFields = {};
+    let hasAnyField = false;
+    for (const [fieldName, variantFields] of fieldsByName) {
+      const mergedEdge = mergeFieldVariants(variantFields, typeNames.length);
+      if (mergedEdge) {
+        const stringIndex = builder.internString(fieldName);
+        mergedFields[stringIndex] = mergedEdge;
+        hasAnyField = true;
+      }
+    }
+    if (hasAnyField) {
+      builder.setInputNodeFields(nodeId, mergedFields);
+    }
+    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;
+    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;
+          }
+        }
+      }
+    }
+    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;
+      } else {
+        flags |= EdgeFlag.ParamScalar;
+      }
+    }
+    if (allObjectTypes.size > 0) {
+      if (hasObjectList) {
+        flags |= EdgeFlag.ListObject;
+      } else if (hasObject) {
+        flags |= EdgeFlag.Object;
+      }
+      const objectTypeArray = [...allObjectTypes];
+      if (objectTypeArray.length === 1) {
+        childNodeId = buildInputTypeNode(objectTypeArray[0]);
+      } else {
+        childNodeId = buildUnionNode(objectTypeArray);
+      }
+    }
+    if (variants.some((v) => v.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 (canParamScalar && combinedMask !== 0) {
+      edge.m = combinedMask;
+    }
+    return edge;
+  }
+  function buildOutputTypeNode(typeName) {
+    if (builder.hasOutputTypeNode(typeName)) {
+      return builder.getOutputTypeNode(typeName);
+    }
+    const outputType = outputTypeMap.get(typeName);
+    if (!outputType) {
+      builder.setOutputTypeNode(typeName, void 0);
+      return void 0;
+    }
+    const nodeId = builder.allocateOutputNode();
+    builder.setOutputTypeNode(typeName, nodeId);
+    const fields = {};
+    let hasAnyField = false;
+    for (const field of outputType.fields) {
+      const edge = buildOutputEdge(field);
+      if (edge) {
+        const stringIndex = builder.internString(field.name);
+        fields[stringIndex] = edge;
+        hasAnyField = true;
+      }
+    }
+    if (hasAnyField) {
+      builder.setOutputNodeFields(nodeId, fields);
+      return nodeId;
+    }
+    return nodeId;
+  }
+  function buildOutputEdge(field) {
+    let argsNodeId;
+    let childOutputNodeId;
+    if (field.args.length > 0) {
+      argsNodeId = buildInputNodeFromArgs(field.args);
+    }
+    if (field.outputType.location === "outputObjectTypes") {
+      childOutputNodeId = buildOutputTypeNode(field.outputType.type);
+    }
+    if (argsNodeId === void 0 && childOutputNodeId === void 0) {
+      return void 0;
+    }
+    const edge = {};
+    if (argsNodeId !== void 0) {
+      edge.a = argsNodeId;
+    }
+    if (childOutputNodeId !== void 0) {
+      edge.o = childOutputNodeId;
+    }
+    return edge;
+  }
+  for (const mapping of dmmf.mappings.modelOperations) {
+    const modelName = mapping.model;
+    const actions = Object.keys(ModelAction);
+    for (const action of actions) {
+      const fieldName = mapping[action];
+      if (!fieldName) continue;
+      let rootField;
+      const queryType = outputTypeMap.get("Query");
+      if (queryType) {
+        rootField = queryType.fields.find((f) => f.name === fieldName);
+      }
+      if (!rootField) {
+        const mutationType = outputTypeMap.get("Mutation");
+        if (mutationType) {
+          rootField = mutationType.fields.find((f) => f.name === fieldName);
+        }
+      }
+      if (!rootField) continue;
+      const argsNodeId = buildInputNodeFromArgs(rootField.args);
+      let outputNodeId;
+      if (rootField.outputType.location === "outputObjectTypes") {
+        outputNodeId = buildOutputTypeNode(rootField.outputType.type);
+      }
+      const dmmfActionToJsonAction = {
+        create: "createOne",
+        update: "updateOne",
+        delete: "deleteOne",
+        upsert: "upsertOne"
+      };
+      const jsonAction = dmmfActionToJsonAction[action] ?? action;
+      const rootKey = `${modelName}.${jsonAction}`;
+      builder.setRoot(rootKey, { a: argsNodeId, o: outputNodeId });
+    }
+  }
+  return builder.build();
+}
+export {
+  buildParamGraph
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { buildParamGraph } from './build-param-graph';

package/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  buildParamGraph: () => import_build_param_graph.buildParamGraph
+});
+module.exports = __toCommonJS(index_exports);
+var import_build_param_graph = require("./build-param-graph");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildParamGraph
+});

package/dist/index.mjs

@@ -0,0 +1,4 @@
+import { buildParamGraph } from "./build-param-graph";
+export {
+  buildParamGraph
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@prisma/param-graph-builder",
+  "version": "0.0.1",
+  "description": "This package is intended for Prisma's internal use",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      }
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma.git",
+    "directory": "packages/param-graph-builder"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@prisma/dmmf": "workspace:*",
+    "@prisma/param-graph": "workspace:*"
+  },
+  "scripts": {
+    "dev": "DEV=true tsx helpers/build.ts",
+    "build": "tsx helpers/build.ts",
+    "prepublishOnly": "pnpm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false
+}