@prisma/param-graph-builder 7.4.0-integration-parameterization.5 → 7.4.0-integration-parameterization.7

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

@@ -1,13 +1,25 @@
 /**
- * Builds a ParamGraph from DMMF at client generation time.
+ * Entry point for building ParamGraph from DMMF.
  *
- * 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.
+ * This module provides the main API for client generators to build
+ * parameterization schemas from DMMF at generation time.
  */
 import type * as DMMF from '@prisma/dmmf';
-import { ParamGraph } from '@prisma/param-graph';
+import type { ParamGraphData, SerializedParamGraph } from '@prisma/param-graph';
 /**
- * Builds a ParamGraph from DMMF schema.
+ * Builds a ParamGraphData from DMMF schema.
+ *
+ * @param dmmf - The DMMF document from the schema
+ * @returns The param graph data structure
+ */
+export declare function buildParamGraph(dmmf: DMMF.Document): ParamGraphData;
+/**
+ * Builds and serializes a ParamGraph from DMMF schema.
+ *
+ * This is the primary API for generators - it returns the compact
+ * serialized format ready to be embedded in generated clients.
+ *
+ * @param dmmf - The DMMF document from the schema
+ * @returns The serialized param graph
  */
-export declare function buildParamGraph(dmmf: DMMF.Document): ParamGraph;
+export declare function buildAndSerializeParamGraph(dmmf: DMMF.Document): SerializedParamGraph;

package/dist/build-param-graph.js

@@ -18,414 +18,26 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var build_param_graph_exports = {};
 __export(build_param_graph_exports, {
+  buildAndSerializeParamGraph: () => buildAndSerializeParamGraph,
   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 = {};
-  inputTypeNodeCache = /* @__PURE__ */ new Map();
-  unionNodeCache = /* @__PURE__ */ new Map();
-  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,
-      e: this.enumNames,
-      i: this.inputNodes,
-      o: this.outputNodes,
-      r: this.roots
-    };
-  }
-}
+var import_dmmf_traverser = require("./dmmf-traverser");
+var import_param_graph_builder = require("./param-graph-builder");
 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(getTypeName(inputType.name, "prisma"), inputType);
-  }
-  for (const inputType of dmmf.schema.inputObjectTypes.model ?? []) {
-    inputTypeMap.set(getTypeName(inputType.name, "model"), inputType);
-  }
-  for (const outputType of dmmf.schema.outputObjectTypes.prisma ?? []) {
-    outputTypeMap.set(getTypeName(outputType.name, "prisma"), outputType);
-  }
-  for (const outputType of dmmf.schema.outputObjectTypes.model ?? []) {
-    outputTypeMap.set(getTypeName(outputType.name, "model"), 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) {
-    return mergeFieldVariants([arg]);
-  }
-  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);
-      if (mergedEdge) {
-        const stringIndex = builder.internString(fieldName);
-        mergedFields[stringIndex] = mergedEdge;
-        hasAnyField = true;
-      }
-    }
-    if (hasAnyField) {
-      builder.setInputNodeFields(nodeId, mergedFields);
-    }
-    return nodeId;
-  }
-  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) {
-        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 && ot.isList === inputType.isList
-            )) {
-              inputObjectTypes.push(inputType);
-            }
-            break;
-          case "fieldRefTypes":
-            break;
-          default:
-            inputType.location;
-        }
-      }
-    }
-    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;
-      }
-    }
-    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);
-      const hasSingleObject = inputObjectTypes.some((iot) => !iot.isList);
-      if (hasObjectList) {
-        flags |= import_param_graph.EdgeFlag.ListObject;
-      }
-      if (hasSingleObject) {
-        flags |= import_param_graph.EdgeFlag.Object;
-      }
-      if (inputObjectTypes.length === 1) {
-        childNodeId = buildInputTypeNode(getTypeName(inputObjectTypes[0].type, inputObjectTypes[0].namespace));
-      } else {
-        childNodeId = buildUnionNode(inputObjectTypes.map((iot) => getTypeName(iot.type, iot.namespace)));
-      }
-    }
-    if (flags === 0) {
-      return void 0;
-    }
-    const edge = { k: flags };
-    if (childNodeId !== void 0) {
-      edge.c = childNodeId;
-    }
-    if (scalarMask !== 0) {
-      edge.m = scalarMask;
-    }
-    if (enumNameId !== void 0) {
-      edge.e = enumNameId;
-    }
-    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(getTypeName(field.outputType.type, field.outputType.namespace));
-    }
-    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("prisma.Query");
-      if (queryType) {
-        rootField = queryType.fields.find((f) => f.name === fieldName);
-      }
-      if (!rootField) {
-        const mutationType = outputTypeMap.get("prisma.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(getTypeName(rootField.outputType.type, rootField.outputType.namespace));
-      }
-      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 });
-    }
-  }
+  const builder = new import_param_graph_builder.ParamGraphBuilder();
+  const traverser = new import_dmmf_traverser.DMMFTraverser(builder, dmmf);
+  traverser.processRoots(dmmf.mappings.modelOperations);
   return builder.build();
 }
-function getTypeName(name, namespace) {
-  if (namespace === void 0) {
-    return name;
-  }
-  return `${namespace}.${name}`;
+function buildAndSerializeParamGraph(dmmf) {
+  const builder = new import_param_graph_builder.ParamGraphBuilder();
+  const traverser = new import_dmmf_traverser.DMMFTraverser(builder, dmmf);
+  traverser.processRoots(dmmf.mappings.modelOperations);
+  return builder.buildAndSerialize();
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  buildAndSerializeParamGraph,
   buildParamGraph
 });