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

package/dist/build-param-graph.mjs

@@ -1,410 +1,18 @@
-import { ModelAction } from "@prisma/dmmf";
-import {
-  EdgeFlag,
-  scalarTypeToMask
-} from "@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
-    };
-  }
-}
+import { DMMFTraverser } from "./dmmf-traverser";
+import { ParamGraphBuilder } from "./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 |= scalarTypeToMask(st.type);
-      if (st.isList) {
-        flags |= EdgeFlag.ParamListScalar;
-      } else {
-        flags |= EdgeFlag.ParamScalar;
-      }
-    }
-    for (const et of enumTypes) {
-      if (et.namespace === "model") {
-        enumNameId = builder.registerEnum(et.type);
-        if (et.isList) {
-          flags |= EdgeFlag.ParamListEnum;
-        } else {
-          flags |= EdgeFlag.ParamEnum;
-        }
-        break;
-      }
-    }
-    if (inputObjectTypes.length > 0) {
-      const hasObjectList = inputObjectTypes.some((iot) => iot.isList);
-      const hasSingleObject = inputObjectTypes.some((iot) => !iot.isList);
-      if (hasObjectList) {
-        flags |= EdgeFlag.ListObject;
-      }
-      if (hasSingleObject) {
-        flags |= 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(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 traverser = new 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 ParamGraphBuilder();
+  const traverser = new DMMFTraverser(builder, dmmf);
+  traverser.processRoots(dmmf.mappings.modelOperations);
+  return builder.buildAndSerialize();
 }
 export {
+  buildAndSerializeParamGraph,
   buildParamGraph
 };

package/dist/dmmf-traverser.d.ts

@@ -0,0 +1,36 @@
+/**
+ * DMMFTraverser: DMMF traversal logic for building ParamGraph.
+ *
+ * This class contains the traversal algorithms that walk DMMF structures
+ * and build the param graph. It uses ParamGraphBuilder for allocation
+ * and caching.
+ */
+import type * as DMMF from '@prisma/dmmf';
+import type { NodeId, ParamGraphBuilder } from './param-graph-builder';
+/**
+ * Traverses DMMF and populates a ParamGraphBuilder.
+ */
+export declare class DMMFTraverser {
+    #private;
+    constructor(builder: ParamGraphBuilder, dmmf: DMMF.Document);
+    /**
+     * Process all root operations from model mappings.
+     */
+    processRoots(mappings: readonly DMMF.ModelMapping[]): void;
+    /**
+     * Builds an input node from schema arguments.
+     */
+    buildInputNodeFromArgs(args: readonly DMMF.SchemaArg[]): NodeId | undefined;
+    /**
+     * Builds an input node for a named input type.
+     */
+    buildInputTypeNode(typeName: string): NodeId | undefined;
+    /**
+     * Builds a union node for multiple input types.
+     */
+    buildUnionNode(typeNames: string[]): NodeId | undefined;
+    /**
+     * Builds an output node for a named output type.
+     */
+    buildOutputTypeNode(typeName: string): NodeId | undefined;
+}