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

package/dist/dmmf-traverser.js

@@ -0,0 +1,338 @@
+"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;
+  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
+        });
+      }
+    }
+  }
+  #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.
+   */
+  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);
+    const edges = {};
+    let hasAnyEdge = false;
+    for (const field of inputType.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);
+    }
+    return nodeId;
+  }
+  /**
+   * Builds a union node for multiple input types.
+   */
+  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);
+    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);
+    }
+    return nodeId;
+  }
+  /**
+   * 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:
+            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,314 @@
+import { ModelAction } from "@prisma/dmmf";
+import { EdgeFlag, scalarTypeToMask } from "@prisma/param-graph";
+class DMMFTraverser {
+  #builder;
+  #inputTypeMap;
+  #outputTypeMap;
+  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
+        });
+      }
+    }
+  }
+  #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.
+   */
+  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);
+    const edges = {};
+    let hasAnyEdge = false;
+    for (const field of inputType.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);
+    }
+    return nodeId;
+  }
+  /**
+   * Builds a union node for multiple input types.
+   */
+  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);
+    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);
+    }
+    return nodeId;
+  }
+  /**
+   * 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:
+            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 { ParamGraphBuilder } from './param-graph-builder';
+export type { NodeId } from './param-graph-builder';

package/dist/index.js

@@ -18,11 +18,19 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 __export(index_exports, {
+  DMMFTraverser: () => import_dmmf_traverser.DMMFTraverser,
+  ParamGraphBuilder: () => import_param_graph_builder.ParamGraphBuilder,
+  buildAndSerializeParamGraph: () => import_build_param_graph.buildAndSerializeParamGraph,
   buildParamGraph: () => import_build_param_graph.buildParamGraph
 });
 module.exports = __toCommonJS(index_exports);
 var import_build_param_graph = require("./build-param-graph");
+var import_dmmf_traverser = require("./dmmf-traverser");
+var import_param_graph_builder = require("./param-graph-builder");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DMMFTraverser,
+  ParamGraphBuilder,
+  buildAndSerializeParamGraph,
   buildParamGraph
 });

package/dist/index.mjs

@@ -1,4 +1,9 @@
-import { buildParamGraph } from "./build-param-graph";
+import { buildAndSerializeParamGraph, buildParamGraph } from "./build-param-graph";
+import { DMMFTraverser } from "./dmmf-traverser";
+import { ParamGraphBuilder } from "./param-graph-builder";
 export {
+  DMMFTraverser,
+  ParamGraphBuilder,
+  buildAndSerializeParamGraph,
   buildParamGraph
 };