@prisma/param-graph-builder 7.3.0-integration-parameterization.15 → 7.4.0-dev.22

package/dist/dmmf-traverser.js

@@ -0,0 +1,367 @@
+"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 dmmf_traverser_exports = {};
+__export(dmmf_traverser_exports, {
+  DMMFTraverser: () => DMMFTraverser
+});
+module.exports = __toCommonJS(dmmf_traverser_exports);
+var import_dmmf = require("@prisma/dmmf");
+var import_param_graph = require("@prisma/param-graph");
+class DMMFTraverser {
+  #builder;
+  #inputTypeMap;
+  #outputTypeMap;
+  #pendingInputNodes = [];
+  #pendingUnionNodes = [];
+  constructor(builder, dmmf) {
+    this.#builder = builder;
+    this.#inputTypeMap = /* @__PURE__ */ new Map();
+    this.#outputTypeMap = /* @__PURE__ */ new Map();
+    for (const inputType of dmmf.schema.inputObjectTypes.prisma ?? []) {
+      this.#inputTypeMap.set(getTypeName(inputType.name, "prisma"), inputType);
+    }
+    for (const inputType of dmmf.schema.inputObjectTypes.model ?? []) {
+      this.#inputTypeMap.set(getTypeName(inputType.name, "model"), inputType);
+    }
+    for (const outputType of dmmf.schema.outputObjectTypes.prisma ?? []) {
+      this.#outputTypeMap.set(getTypeName(outputType.name, "prisma"), outputType);
+    }
+    for (const outputType of dmmf.schema.outputObjectTypes.model ?? []) {
+      this.#outputTypeMap.set(getTypeName(outputType.name, "model"), outputType);
+    }
+  }
+  /**
+   * Process all root operations from model mappings.
+   */
+  processRoots(mappings) {
+    for (const mapping of mappings) {
+      const modelName = mapping.model;
+      const actions = Object.keys(import_dmmf.ModelAction);
+      for (const action of actions) {
+        const fieldName = mapping[action];
+        if (!fieldName) continue;
+        const rootField = this.#findRootField(fieldName);
+        if (!rootField) continue;
+        const argsNodeId = this.buildInputNodeFromArgs(rootField.args);
+        let outputNodeId;
+        if (rootField.outputType.location === "outputObjectTypes") {
+          outputNodeId = this.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}`;
+        this.#builder.setRoot(rootKey, {
+          argsNodeId,
+          outputNodeId
+        });
+      }
+    }
+    this.#drainPendingWork();
+  }
+  /**
+   * Iteratively processes all pending input and union nodes.
+   * This avoids deep recursion that can cause stack overflow on complex schemas.
+   */
+  #drainPendingWork() {
+    while (this.#pendingInputNodes.length > 0 || this.#pendingUnionNodes.length > 0) {
+      while (this.#pendingInputNodes.length > 0) {
+        const pending = this.#pendingInputNodes.pop();
+        this.#processInputNodeFields(pending.nodeId, pending.fields);
+      }
+      while (this.#pendingUnionNodes.length > 0) {
+        const pending = this.#pendingUnionNodes.pop();
+        this.#processUnionNodeFields(pending.nodeId, pending.typeNames);
+      }
+    }
+  }
+  #findRootField(fieldName) {
+    const queryType = this.#outputTypeMap.get("prisma.Query");
+    if (queryType) {
+      const field = queryType.fields.find((f) => f.name === fieldName);
+      if (field) return field;
+    }
+    const mutationType = this.#outputTypeMap.get("prisma.Mutation");
+    if (mutationType) {
+      const field = mutationType.fields.find((f) => f.name === fieldName);
+      if (field) return field;
+    }
+    return void 0;
+  }
+  /**
+   * Builds an input node from schema arguments.
+   */
+  buildInputNodeFromArgs(args) {
+    const edges = {};
+    let hasAnyEdge = false;
+    for (const arg of args) {
+      const edge = this.#mergeFieldVariants([arg]);
+      if (edge) {
+        const stringIndex = this.#builder.internString(arg.name);
+        edges[stringIndex] = edge;
+        hasAnyEdge = true;
+      }
+    }
+    if (!hasAnyEdge) {
+      return void 0;
+    }
+    const nodeId = this.#builder.allocateInputNode();
+    this.#builder.setInputNodeEdges(nodeId, edges);
+    return nodeId;
+  }
+  /**
+   * Builds an input node for a named input type.
+   * Node allocation happens immediately, but field processing is deferred
+   * to avoid deep recursion.
+   */
+  buildInputTypeNode(typeName) {
+    if (this.#builder.hasInputTypeNode(typeName)) {
+      return this.#builder.getInputTypeNode(typeName);
+    }
+    const inputType = this.#inputTypeMap.get(typeName);
+    if (!inputType) {
+      this.#builder.setInputTypeNode(typeName, void 0);
+      return void 0;
+    }
+    const nodeId = this.#builder.allocateInputNode();
+    this.#builder.setInputTypeNode(typeName, nodeId);
+    this.#pendingInputNodes.push({ nodeId, fields: inputType.fields });
+    return nodeId;
+  }
+  /**
+   * Process fields for an input node (called from drainPendingWork).
+   */
+  #processInputNodeFields(nodeId, fields) {
+    const edges = {};
+    let hasAnyEdge = false;
+    for (const field of fields) {
+      const edge = this.#mergeFieldVariants([field]);
+      if (edge) {
+        const stringIndex = this.#builder.internString(field.name);
+        edges[stringIndex] = edge;
+        hasAnyEdge = true;
+      }
+    }
+    if (hasAnyEdge) {
+      this.#builder.setInputNodeEdges(nodeId, edges);
+    }
+  }
+  /**
+   * Builds a union node for multiple input types.
+   * Node allocation happens immediately, but field processing is deferred
+   * to avoid deep recursion.
+   */
+  buildUnionNode(typeNames) {
+    const sortedNames = [...typeNames].sort();
+    const cacheKey = sortedNames.join("|");
+    if (this.#builder.hasUnionNode(cacheKey)) {
+      return this.#builder.getUnionNode(cacheKey);
+    }
+    const nodeId = this.#builder.allocateInputNode();
+    this.#builder.setUnionNode(cacheKey, nodeId);
+    this.#pendingUnionNodes.push({ nodeId, typeNames });
+    return nodeId;
+  }
+  /**
+   * Process fields for a union node (called from drainPendingWork).
+   */
+  #processUnionNodeFields(nodeId, typeNames) {
+    const fieldsByName = /* @__PURE__ */ new Map();
+    for (const typeName of typeNames) {
+      const inputType = this.#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 mergedEdges = {};
+    let hasAnyEdge = false;
+    for (const [fieldName, variantFields] of fieldsByName) {
+      const mergedEdge = this.#mergeFieldVariants(variantFields);
+      if (mergedEdge) {
+        const stringIndex = this.#builder.internString(fieldName);
+        mergedEdges[stringIndex] = mergedEdge;
+        hasAnyEdge = true;
+      }
+    }
+    if (hasAnyEdge) {
+      this.#builder.setInputNodeEdges(nodeId, mergedEdges);
+    }
+  }
+  /**
+   * Merges field variants to produce a single edge descriptor.
+   * This is the most complex part of the traversal - it handles
+   * union types and determines what kinds of values a field accepts.
+   */
+  #mergeFieldVariants(variants) {
+    let flags = 0;
+    let scalarMask = 0;
+    let childNodeId;
+    let enumNameIndex;
+    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:
+            throw new Error(`Invalid location ${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") {
+        enumNameIndex = this.#builder.internString(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 = this.buildInputTypeNode(getTypeName(inputObjectTypes[0].type, inputObjectTypes[0].namespace));
+      } else {
+        childNodeId = this.buildUnionNode(inputObjectTypes.map((iot) => getTypeName(iot.type, iot.namespace)));
+      }
+    }
+    if (flags === 0) {
+      return void 0;
+    }
+    const edge = { flags };
+    if (childNodeId !== void 0) {
+      edge.childNodeId = childNodeId;
+    }
+    if (scalarMask !== 0) {
+      edge.scalarMask = scalarMask;
+    }
+    if (enumNameIndex !== void 0) {
+      edge.enumNameIndex = enumNameIndex;
+    }
+    return edge;
+  }
+  /**
+   * Builds an output node for a named output type.
+   */
+  buildOutputTypeNode(typeName) {
+    if (this.#builder.hasOutputTypeNode(typeName)) {
+      return this.#builder.getOutputTypeNode(typeName);
+    }
+    const outputType = this.#outputTypeMap.get(typeName);
+    if (!outputType) {
+      this.#builder.setOutputTypeNode(typeName, void 0);
+      return void 0;
+    }
+    const nodeId = this.#builder.allocateOutputNode();
+    this.#builder.setOutputTypeNode(typeName, nodeId);
+    const edges = {};
+    let hasAnyEdge = false;
+    for (const field of outputType.fields) {
+      const edge = this.#buildOutputEdge(field);
+      if (edge) {
+        const stringIndex = this.#builder.internString(field.name);
+        edges[stringIndex] = edge;
+        hasAnyEdge = true;
+      }
+    }
+    if (hasAnyEdge) {
+      this.#builder.setOutputNodeEdges(nodeId, edges);
+    }
+    return nodeId;
+  }
+  #buildOutputEdge(field) {
+    let argsNodeId;
+    let outputNodeId;
+    if (field.args.length > 0) {
+      argsNodeId = this.buildInputNodeFromArgs(field.args);
+    }
+    if (field.outputType.location === "outputObjectTypes") {
+      outputNodeId = this.buildOutputTypeNode(getTypeName(field.outputType.type, field.outputType.namespace));
+    }
+    if (argsNodeId === void 0 && outputNodeId === void 0) {
+      return void 0;
+    }
+    const edge = {};
+    if (argsNodeId !== void 0) {
+      edge.argsNodeId = argsNodeId;
+    }
+    if (outputNodeId !== void 0) {
+      edge.outputNodeId = outputNodeId;
+    }
+    return edge;
+  }
+}
+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 = {
+  DMMFTraverser
+});

package/dist/dmmf-traverser.mjs

@@ -0,0 +1,343 @@
+import { ModelAction } from "@prisma/dmmf";
+import { EdgeFlag, scalarTypeToMask } from "@prisma/param-graph";
+class DMMFTraverser {
+  #builder;
+  #inputTypeMap;
+  #outputTypeMap;
+  #pendingInputNodes = [];
+  #pendingUnionNodes = [];
+  constructor(builder, dmmf) {
+    this.#builder = builder;
+    this.#inputTypeMap = /* @__PURE__ */ new Map();
+    this.#outputTypeMap = /* @__PURE__ */ new Map();
+    for (const inputType of dmmf.schema.inputObjectTypes.prisma ?? []) {
+      this.#inputTypeMap.set(getTypeName(inputType.name, "prisma"), inputType);
+    }
+    for (const inputType of dmmf.schema.inputObjectTypes.model ?? []) {
+      this.#inputTypeMap.set(getTypeName(inputType.name, "model"), inputType);
+    }
+    for (const outputType of dmmf.schema.outputObjectTypes.prisma ?? []) {
+      this.#outputTypeMap.set(getTypeName(outputType.name, "prisma"), outputType);
+    }
+    for (const outputType of dmmf.schema.outputObjectTypes.model ?? []) {
+      this.#outputTypeMap.set(getTypeName(outputType.name, "model"), outputType);
+    }
+  }
+  /**
+   * Process all root operations from model mappings.
+   */
+  processRoots(mappings) {
+    for (const mapping of mappings) {
+      const modelName = mapping.model;
+      const actions = Object.keys(ModelAction);
+      for (const action of actions) {
+        const fieldName = mapping[action];
+        if (!fieldName) continue;
+        const rootField = this.#findRootField(fieldName);
+        if (!rootField) continue;
+        const argsNodeId = this.buildInputNodeFromArgs(rootField.args);
+        let outputNodeId;
+        if (rootField.outputType.location === "outputObjectTypes") {
+          outputNodeId = this.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}`;
+        this.#builder.setRoot(rootKey, {
+          argsNodeId,
+          outputNodeId
+        });
+      }
+    }
+    this.#drainPendingWork();
+  }
+  /**
+   * Iteratively processes all pending input and union nodes.
+   * This avoids deep recursion that can cause stack overflow on complex schemas.
+   */
+  #drainPendingWork() {
+    while (this.#pendingInputNodes.length > 0 || this.#pendingUnionNodes.length > 0) {
+      while (this.#pendingInputNodes.length > 0) {
+        const pending = this.#pendingInputNodes.pop();
+        this.#processInputNodeFields(pending.nodeId, pending.fields);
+      }
+      while (this.#pendingUnionNodes.length > 0) {
+        const pending = this.#pendingUnionNodes.pop();
+        this.#processUnionNodeFields(pending.nodeId, pending.typeNames);
+      }
+    }
+  }
+  #findRootField(fieldName) {
+    const queryType = this.#outputTypeMap.get("prisma.Query");
+    if (queryType) {
+      const field = queryType.fields.find((f) => f.name === fieldName);
+      if (field) return field;
+    }
+    const mutationType = this.#outputTypeMap.get("prisma.Mutation");
+    if (mutationType) {
+      const field = mutationType.fields.find((f) => f.name === fieldName);
+      if (field) return field;
+    }
+    return void 0;
+  }
+  /**
+   * Builds an input node from schema arguments.
+   */
+  buildInputNodeFromArgs(args) {
+    const edges = {};
+    let hasAnyEdge = false;
+    for (const arg of args) {
+      const edge = this.#mergeFieldVariants([arg]);
+      if (edge) {
+        const stringIndex = this.#builder.internString(arg.name);
+        edges[stringIndex] = edge;
+        hasAnyEdge = true;
+      }
+    }
+    if (!hasAnyEdge) {
+      return void 0;
+    }
+    const nodeId = this.#builder.allocateInputNode();
+    this.#builder.setInputNodeEdges(nodeId, edges);
+    return nodeId;
+  }
+  /**
+   * Builds an input node for a named input type.
+   * Node allocation happens immediately, but field processing is deferred
+   * to avoid deep recursion.
+   */
+  buildInputTypeNode(typeName) {
+    if (this.#builder.hasInputTypeNode(typeName)) {
+      return this.#builder.getInputTypeNode(typeName);
+    }
+    const inputType = this.#inputTypeMap.get(typeName);
+    if (!inputType) {
+      this.#builder.setInputTypeNode(typeName, void 0);
+      return void 0;
+    }
+    const nodeId = this.#builder.allocateInputNode();
+    this.#builder.setInputTypeNode(typeName, nodeId);
+    this.#pendingInputNodes.push({ nodeId, fields: inputType.fields });
+    return nodeId;
+  }
+  /**
+   * Process fields for an input node (called from drainPendingWork).
+   */
+  #processInputNodeFields(nodeId, fields) {
+    const edges = {};
+    let hasAnyEdge = false;
+    for (const field of fields) {
+      const edge = this.#mergeFieldVariants([field]);
+      if (edge) {
+        const stringIndex = this.#builder.internString(field.name);
+        edges[stringIndex] = edge;
+        hasAnyEdge = true;
+      }
+    }
+    if (hasAnyEdge) {
+      this.#builder.setInputNodeEdges(nodeId, edges);
+    }
+  }
+  /**
+   * Builds a union node for multiple input types.
+   * Node allocation happens immediately, but field processing is deferred
+   * to avoid deep recursion.
+   */
+  buildUnionNode(typeNames) {
+    const sortedNames = [...typeNames].sort();
+    const cacheKey = sortedNames.join("|");
+    if (this.#builder.hasUnionNode(cacheKey)) {
+      return this.#builder.getUnionNode(cacheKey);
+    }
+    const nodeId = this.#builder.allocateInputNode();
+    this.#builder.setUnionNode(cacheKey, nodeId);
+    this.#pendingUnionNodes.push({ nodeId, typeNames });
+    return nodeId;
+  }
+  /**
+   * Process fields for a union node (called from drainPendingWork).
+   */
+  #processUnionNodeFields(nodeId, typeNames) {
+    const fieldsByName = /* @__PURE__ */ new Map();
+    for (const typeName of typeNames) {
+      const inputType = this.#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 mergedEdges = {};
+    let hasAnyEdge = false;
+    for (const [fieldName, variantFields] of fieldsByName) {
+      const mergedEdge = this.#mergeFieldVariants(variantFields);
+      if (mergedEdge) {
+        const stringIndex = this.#builder.internString(fieldName);
+        mergedEdges[stringIndex] = mergedEdge;
+        hasAnyEdge = true;
+      }
+    }
+    if (hasAnyEdge) {
+      this.#builder.setInputNodeEdges(nodeId, mergedEdges);
+    }
+  }
+  /**
+   * Merges field variants to produce a single edge descriptor.
+   * This is the most complex part of the traversal - it handles
+   * union types and determines what kinds of values a field accepts.
+   */
+  #mergeFieldVariants(variants) {
+    let flags = 0;
+    let scalarMask = 0;
+    let childNodeId;
+    let enumNameIndex;
+    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:
+            throw new Error(`Invalid location ${inputType.location}`);
+        }
+      }
+    }
+    for (const st of scalarTypes) {
+      scalarMask |= scalarTypeToMask(st.type);
+      if (st.isList) {
+        flags |= EdgeFlag.ParamListScalar;
+      } else {
+        flags |= EdgeFlag.ParamScalar;
+      }
+    }
+    for (const et of enumTypes) {
+      if (et.namespace === "model") {
+        enumNameIndex = this.#builder.internString(et.type);
+        if (et.isList) {
+          flags |= EdgeFlag.ParamListEnum;
+        } else {
+          flags |= EdgeFlag.ParamEnum;
+        }
+        break;
+      }
+    }
+    if (inputObjectTypes.length > 0) {
+      const hasObjectList = inputObjectTypes.some((iot) => iot.isList);
+      const hasSingleObject = inputObjectTypes.some((iot) => !iot.isList);
+      if (hasObjectList) {
+        flags |= EdgeFlag.ListObject;
+      }
+      if (hasSingleObject) {
+        flags |= EdgeFlag.Object;
+      }
+      if (inputObjectTypes.length === 1) {
+        childNodeId = this.buildInputTypeNode(getTypeName(inputObjectTypes[0].type, inputObjectTypes[0].namespace));
+      } else {
+        childNodeId = this.buildUnionNode(inputObjectTypes.map((iot) => getTypeName(iot.type, iot.namespace)));
+      }
+    }
+    if (flags === 0) {
+      return void 0;
+    }
+    const edge = { flags };
+    if (childNodeId !== void 0) {
+      edge.childNodeId = childNodeId;
+    }
+    if (scalarMask !== 0) {
+      edge.scalarMask = scalarMask;
+    }
+    if (enumNameIndex !== void 0) {
+      edge.enumNameIndex = enumNameIndex;
+    }
+    return edge;
+  }
+  /**
+   * Builds an output node for a named output type.
+   */
+  buildOutputTypeNode(typeName) {
+    if (this.#builder.hasOutputTypeNode(typeName)) {
+      return this.#builder.getOutputTypeNode(typeName);
+    }
+    const outputType = this.#outputTypeMap.get(typeName);
+    if (!outputType) {
+      this.#builder.setOutputTypeNode(typeName, void 0);
+      return void 0;
+    }
+    const nodeId = this.#builder.allocateOutputNode();
+    this.#builder.setOutputTypeNode(typeName, nodeId);
+    const edges = {};
+    let hasAnyEdge = false;
+    for (const field of outputType.fields) {
+      const edge = this.#buildOutputEdge(field);
+      if (edge) {
+        const stringIndex = this.#builder.internString(field.name);
+        edges[stringIndex] = edge;
+        hasAnyEdge = true;
+      }
+    }
+    if (hasAnyEdge) {
+      this.#builder.setOutputNodeEdges(nodeId, edges);
+    }
+    return nodeId;
+  }
+  #buildOutputEdge(field) {
+    let argsNodeId;
+    let outputNodeId;
+    if (field.args.length > 0) {
+      argsNodeId = this.buildInputNodeFromArgs(field.args);
+    }
+    if (field.outputType.location === "outputObjectTypes") {
+      outputNodeId = this.buildOutputTypeNode(getTypeName(field.outputType.type, field.outputType.namespace));
+    }
+    if (argsNodeId === void 0 && outputNodeId === void 0) {
+      return void 0;
+    }
+    const edge = {};
+    if (argsNodeId !== void 0) {
+      edge.argsNodeId = argsNodeId;
+    }
+    if (outputNodeId !== void 0) {
+      edge.outputNodeId = outputNodeId;
+    }
+    return edge;
+  }
+}
+function getTypeName(name, namespace) {
+  if (namespace === void 0) {
+    return name;
+  }
+  return `${namespace}.${name}`;
+}
+export {
+  DMMFTraverser
+};

package/dist/index.d.ts

@@ -1 +1,4 @@
-export { buildParamGraph } from './build-param-graph';
+export { buildAndSerializeParamGraph, buildParamGraph } from './build-param-graph';
+export { DMMFTraverser } from './dmmf-traverser';
+export type { NodeId } from './param-graph-builder';
+export { ParamGraphBuilder } from './param-graph-builder';