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

package/dist/index.d.ts

@@ -1,2 +1,7 @@
-export type { EdgeFlagValue, InputEdge, InputNode, NodeId, OutputEdge, OutputNode, ParamGraph, RootEntry, ScalarMaskValue, } from './param-graph';
+export { ParamGraph } from './param-graph';
+export type { EnumLookup, InputEdge, InputNode, OutputEdge, OutputNode, RootEntry } from './param-graph';
+export type { InputEdgeData, InputNodeData, OutputEdgeData, OutputNodeData, ParamGraphData, RootEntryData, } from './param-graph';
 export { EdgeFlag, getScalarMask, hasFlag, ScalarMask, scalarTypeToMask } from './param-graph';
+export type { EdgeFlagValue, ScalarMaskValue } from './param-graph';
+export { deserializeParamGraph, serializeParamGraph } from './serialization';
+export type { SerializedParamGraph } from './serialization';

package/dist/index.js

@@ -18,19 +18,27 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 __export(index_exports, {
-  EdgeFlag: () => import_param_graph.EdgeFlag,
-  ScalarMask: () => import_param_graph.ScalarMask,
-  getScalarMask: () => import_param_graph.getScalarMask,
-  hasFlag: () => import_param_graph.hasFlag,
-  scalarTypeToMask: () => import_param_graph.scalarTypeToMask
+  EdgeFlag: () => import_param_graph2.EdgeFlag,
+  ParamGraph: () => import_param_graph.ParamGraph,
+  ScalarMask: () => import_param_graph2.ScalarMask,
+  deserializeParamGraph: () => import_serialization.deserializeParamGraph,
+  getScalarMask: () => import_param_graph2.getScalarMask,
+  hasFlag: () => import_param_graph2.hasFlag,
+  scalarTypeToMask: () => import_param_graph2.scalarTypeToMask,
+  serializeParamGraph: () => import_serialization.serializeParamGraph
 });
 module.exports = __toCommonJS(index_exports);
 var import_param_graph = require("./param-graph");
+var import_param_graph2 = require("./param-graph");
+var import_serialization = require("./serialization");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   EdgeFlag,
+  ParamGraph,
   ScalarMask,
+  deserializeParamGraph,
   getScalarMask,
   hasFlag,
-  scalarTypeToMask
+  scalarTypeToMask,
+  serializeParamGraph
 });

package/dist/index.mjs

@@ -1,8 +1,13 @@
+import { ParamGraph } from "./param-graph";
 import { EdgeFlag, getScalarMask, hasFlag, ScalarMask, scalarTypeToMask } from "./param-graph";
+import { deserializeParamGraph, serializeParamGraph } from "./serialization";
 export {
   EdgeFlag,
+  ParamGraph,
   ScalarMask,
+  deserializeParamGraph,
   getScalarMask,
   hasFlag,
-  scalarTypeToMask
+  scalarTypeToMask,
+  serializeParamGraph
 };

package/dist/param-graph.d.ts

@@ -1,117 +1,101 @@
 /**
- * ParamGraph: Compact schema for runtime parameterization.
+ * ParamGraph: Runtime class for schema-aware parameterization.
  *
- * This data structure is generated from DMMF at client generation time
- * and embedded in the generated client. It enables schema-aware
- * parameterization where values are only parameterized when both schema
- * rules and runtime value types agree.
+ * This class provides a readable API for navigating the param graph structure
+ * at runtime. It's created once per PrismaClient instance from the serialized
+ * format embedded in the generated client.
  */
+import type { SerializedParamGraph } from './serialization';
+import type { InputEdgeData, InputNodeData, OutputEdgeData, OutputNodeData, ParamGraphData, RootEntryData } from './types';
 /**
- * Compact schema embedded in the generated client.
+ * Function type for looking up enum values by name.
+ * This allows ParamGraph to remain decoupled from RuntimeDataModel.
  */
-export type ParamGraph = {
-    /**
-     * String table to avoid repeating field names.
-     * Field names are referenced by index throughout the graph.
-     */
-    s: string[];
-    /**
-     * User enum names for runtime membership checks.
-     * Values are looked up via `runtimeDataModel.enums[enumName].values`.
-     */
-    e: string[];
-    /**
-     * Input nodes used for argument objects and input types.
-     * Each node describes which fields are parameterizable or lead to
-     * parameterizable descendants.
-     */
-    i: InputNode[];
-    /**
-     * Output nodes used for selection traversal.
-     * Each node describes which fields have arguments or lead to
-     * nested selections with arguments.
-     */
-    o: OutputNode[];
-    /**
-     * Root mapping: "Model.action" or "action" (for non-model ops).
-     * Points to the args node (input) and root output node.
-     */
-    r: Record<string, RootEntry>;
-};
+export type EnumLookup = (enumName: string) => readonly string[] | undefined;
 /**
- * Entry point for a root operation.
+ * Readable view of root entry.
  */
-export type RootEntry = {
-    /** Args node id (into `i` array) */
-    a?: NodeId;
-    /** Output node id (into `o` array) */
-    o?: NodeId;
-};
+export interface RootEntry {
+    readonly argsNodeId: number | undefined;
+    readonly outputNodeId: number | undefined;
+}
 /**
- * Node ID is an index into `i` or `o` array.
+ * Readable view of input node.
  */
-export type NodeId = number;
+export interface InputNode {
+    readonly id: number;
+}
 /**
- * Input node: describes parameterizable fields in an input object.
- * Only fields that are parameterizable or lead to parameterizable
- * descendants are present.
+ * Readable view of output node.
  */
-export type InputNode = {
-    /**
-     * Map from string-table index to edge descriptor.
-     * Omitted if the node has no fields (shouldn't happen in practice).
-     */
-    f?: Record<number, InputEdge>;
-};
+export interface OutputNode {
+    readonly id: number;
+}
 /**
- * Output node: describes fields in a selection set that have args
- * or nested selections that may contain parameterizable args.
+ * Readable view of input edge.
  */
-export type OutputNode = {
-    /**
-     * Map from string-table index to edge descriptor.
-     */
-    f?: Record<number, OutputEdge>;
-};
+export interface InputEdge {
+    readonly flags: number;
+    readonly childNodeId: number | undefined;
+    readonly scalarMask: number;
+    readonly enumNameIndex: number | undefined;
+}
+/**
+ * Readable view of output edge.
+ */
+export interface OutputEdge {
+    readonly argsNodeId: number | undefined;
+    readonly outputNodeId: number | undefined;
+}
 /**
- * Edge descriptor for input fields.
- * Encodes what kinds of values the field accepts and how to handle them.
+ * ParamGraph provides runtime access to the schema information
+ * needed for parameterization decisions.
  */
-export type InputEdge = {
+export declare class ParamGraph {
+    #private;
+    private constructor();
     /**
-     * Bit flags describing field capabilities.
-     * See EdgeFlag enum below.
+     * Creates a ParamGraph from serialized format.
+     * This is the primary factory method for runtime use.
      */
-    k: number;
+    static deserialize(serialized: SerializedParamGraph, enumLookup: EnumLookup): ParamGraph;
     /**
-     * Child input node id (for object values or list of objects).
-     * Present when the field accepts input object types.
+     * Creates a ParamGraph from builder data.
+     * Used by the builder for testing and direct construction.
      */
-    c?: NodeId;
+    static fromData(data: ParamGraphData, enumLookup: EnumLookup): ParamGraph;
     /**
-     * Scalar type mask for allowed scalar categories.
-     * Present when field accepts scalar values.
-     * See ScalarMask enum below.
+     * Look up a root entry by "Model.action" or "action".
      */
-    m?: number;
+    root(key: string): RootEntry | undefined;
     /**
-     * Enum name id (index into `en` array).
-     * Present when field accepts a user enum without a plain String scalar.
-     * Used for runtime membership validation.
+     * Get an input node by ID.
      */
-    e?: number;
-};
-/**
- * Edge descriptor for output fields.
- */
-export type OutputEdge = {
-    /** Args node for this field (if it accepts arguments) */
-    a?: NodeId;
-    /** Next output node for nested selection traversal */
-    o?: NodeId;
-};
+    inputNode(id: number | undefined): InputNode | undefined;
+    /**
+     * Get an output node by ID.
+     */
+    outputNode(id: number | undefined): OutputNode | undefined;
+    /**
+     * Get an input edge for a field name within a node.
+     */
+    inputEdge(node: InputNode | undefined, fieldName: string): InputEdge | undefined;
+    /**
+     * Get an output edge for a field name within a node.
+     */
+    outputEdge(node: OutputNode | undefined, fieldName: string): OutputEdge | undefined;
+    /**
+     * Get enum values for an edge that references a user enum.
+     * Returns undefined if the edge doesn't reference an enum.
+     */
+    enumValues(edge: InputEdge | undefined): readonly string[] | undefined;
+    /**
+     * Get a string from the string table by index.
+     */
+    getString(index: number): string | undefined;
+}
 /**
- * Bit flags for InputEdge.k describing what the field accepts.
+ * Bit flags for InputEdge.flags describing what the field accepts.
  */
 export declare const EdgeFlag: {
     /**
@@ -148,7 +132,7 @@ export declare const EdgeFlag: {
 export type EdgeFlagValue = (typeof EdgeFlag)[keyof typeof EdgeFlag];
 /**
  * Bit mask for scalar type categories.
- * Used in InputEdge.m to validate runtime value types.
+ * Used in InputEdge.scalarMask to validate runtime value types.
  */
 export declare const ScalarMask: {
     readonly String: 1;
@@ -174,3 +158,4 @@ export declare function getScalarMask(edge: InputEdge): number;
  * Maps DMMF scalar type names to ScalarMask values.
  */
 export declare function scalarTypeToMask(typeName: string): number;
+export type { InputEdgeData, InputNodeData, OutputEdgeData, OutputNodeData, ParamGraphData, RootEntryData };

package/dist/param-graph.js

@@ -19,12 +19,143 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var param_graph_exports = {};
 __export(param_graph_exports, {
   EdgeFlag: () => EdgeFlag,
+  ParamGraph: () => ParamGraph,
   ScalarMask: () => ScalarMask,
   getScalarMask: () => getScalarMask,
   hasFlag: () => hasFlag,
   scalarTypeToMask: () => scalarTypeToMask
 });
 module.exports = __toCommonJS(param_graph_exports);
+var import_serialization = require("./serialization");
+class ParamGraph {
+  #data;
+  #stringIndex;
+  #enumLookup;
+  constructor(data, enumLookup) {
+    this.#data = data;
+    this.#enumLookup = enumLookup;
+    this.#stringIndex = /* @__PURE__ */ new Map();
+    for (let i = 0; i < data.strings.length; i++) {
+      this.#stringIndex.set(data.strings[i], i);
+    }
+  }
+  /**
+   * Creates a ParamGraph from serialized format.
+   * This is the primary factory method for runtime use.
+   */
+  static deserialize(serialized, enumLookup) {
+    const data = (0, import_serialization.deserializeParamGraph)(serialized);
+    return new ParamGraph(data, enumLookup);
+  }
+  /**
+   * Creates a ParamGraph from builder data.
+   * Used by the builder for testing and direct construction.
+   */
+  static fromData(data, enumLookup) {
+    return new ParamGraph(data, enumLookup);
+  }
+  /**
+   * Look up a root entry by "Model.action" or "action".
+   */
+  root(key) {
+    const entry = this.#data.roots[key];
+    if (!entry) {
+      return void 0;
+    }
+    return {
+      argsNodeId: entry.argsNodeId,
+      outputNodeId: entry.outputNodeId
+    };
+  }
+  /**
+   * Get an input node by ID.
+   */
+  inputNode(id) {
+    if (id === void 0 || id < 0 || id >= this.#data.inputNodes.length) {
+      return void 0;
+    }
+    return { id };
+  }
+  /**
+   * Get an output node by ID.
+   */
+  outputNode(id) {
+    if (id === void 0 || id < 0 || id >= this.#data.outputNodes.length) {
+      return void 0;
+    }
+    return { id };
+  }
+  /**
+   * Get an input edge for a field name within a node.
+   */
+  inputEdge(node, fieldName) {
+    if (!node) {
+      return void 0;
+    }
+    const nodeData = this.#data.inputNodes[node.id];
+    if (!nodeData) {
+      return void 0;
+    }
+    const fieldIndex = this.#stringIndex.get(fieldName);
+    if (fieldIndex === void 0) {
+      return void 0;
+    }
+    const edge = nodeData.edges[fieldIndex];
+    if (!edge) {
+      return void 0;
+    }
+    return {
+      flags: edge.flags,
+      childNodeId: edge.childNodeId,
+      scalarMask: edge.scalarMask ?? 0,
+      enumNameIndex: edge.enumNameIndex
+    };
+  }
+  /**
+   * Get an output edge for a field name within a node.
+   */
+  outputEdge(node, fieldName) {
+    if (!node) {
+      return void 0;
+    }
+    const nodeData = this.#data.outputNodes[node.id];
+    if (!nodeData) {
+      return void 0;
+    }
+    const fieldIndex = this.#stringIndex.get(fieldName);
+    if (fieldIndex === void 0) {
+      return void 0;
+    }
+    const edge = nodeData.edges[fieldIndex];
+    if (!edge) {
+      return void 0;
+    }
+    return {
+      argsNodeId: edge.argsNodeId,
+      outputNodeId: edge.outputNodeId
+    };
+  }
+  /**
+   * Get enum values for an edge that references a user enum.
+   * Returns undefined if the edge doesn't reference an enum.
+   */
+  enumValues(edge) {
+    if (edge?.enumNameIndex === void 0) {
+      return void 0;
+    }
+    const enumName = this.#data.strings[edge.enumNameIndex];
+    if (!enumName) {
+      return void 0;
+    }
+    return this.#enumLookup(enumName);
+  }
+  /**
+   * Get a string from the string table by index.
+   */
+  getString(index) {
+    return this.#data.strings[index];
+  }
+}
 const EdgeFlag = {
   /**
    * Field may be parameterized as a scalar value.
@@ -69,10 +200,10 @@ const ScalarMask = {
   Bytes: 256
 };
 function hasFlag(edge, flag) {
-  return (edge.k & flag) !== 0;
+  return (edge.flags & flag) !== 0;
 }
 function getScalarMask(edge) {
-  return edge.m ?? 0;
+  return edge.scalarMask;
 }
 function scalarTypeToMask(typeName) {
   switch (typeName) {
@@ -102,6 +233,7 @@ function scalarTypeToMask(typeName) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   EdgeFlag,
+  ParamGraph,
   ScalarMask,
   getScalarMask,
   hasFlag,

package/dist/param-graph.mjs

@@ -1,3 +1,133 @@
+import { deserializeParamGraph } from "./serialization";
+class ParamGraph {
+  #data;
+  #stringIndex;
+  #enumLookup;
+  constructor(data, enumLookup) {
+    this.#data = data;
+    this.#enumLookup = enumLookup;
+    this.#stringIndex = /* @__PURE__ */ new Map();
+    for (let i = 0; i < data.strings.length; i++) {
+      this.#stringIndex.set(data.strings[i], i);
+    }
+  }
+  /**
+   * Creates a ParamGraph from serialized format.
+   * This is the primary factory method for runtime use.
+   */
+  static deserialize(serialized, enumLookup) {
+    const data = deserializeParamGraph(serialized);
+    return new ParamGraph(data, enumLookup);
+  }
+  /**
+   * Creates a ParamGraph from builder data.
+   * Used by the builder for testing and direct construction.
+   */
+  static fromData(data, enumLookup) {
+    return new ParamGraph(data, enumLookup);
+  }
+  /**
+   * Look up a root entry by "Model.action" or "action".
+   */
+  root(key) {
+    const entry = this.#data.roots[key];
+    if (!entry) {
+      return void 0;
+    }
+    return {
+      argsNodeId: entry.argsNodeId,
+      outputNodeId: entry.outputNodeId
+    };
+  }
+  /**
+   * Get an input node by ID.
+   */
+  inputNode(id) {
+    if (id === void 0 || id < 0 || id >= this.#data.inputNodes.length) {
+      return void 0;
+    }
+    return { id };
+  }
+  /**
+   * Get an output node by ID.
+   */
+  outputNode(id) {
+    if (id === void 0 || id < 0 || id >= this.#data.outputNodes.length) {
+      return void 0;
+    }
+    return { id };
+  }
+  /**
+   * Get an input edge for a field name within a node.
+   */
+  inputEdge(node, fieldName) {
+    if (!node) {
+      return void 0;
+    }
+    const nodeData = this.#data.inputNodes[node.id];
+    if (!nodeData) {
+      return void 0;
+    }
+    const fieldIndex = this.#stringIndex.get(fieldName);
+    if (fieldIndex === void 0) {
+      return void 0;
+    }
+    const edge = nodeData.edges[fieldIndex];
+    if (!edge) {
+      return void 0;
+    }
+    return {
+      flags: edge.flags,
+      childNodeId: edge.childNodeId,
+      scalarMask: edge.scalarMask ?? 0,
+      enumNameIndex: edge.enumNameIndex
+    };
+  }
+  /**
+   * Get an output edge for a field name within a node.
+   */
+  outputEdge(node, fieldName) {
+    if (!node) {
+      return void 0;
+    }
+    const nodeData = this.#data.outputNodes[node.id];
+    if (!nodeData) {
+      return void 0;
+    }
+    const fieldIndex = this.#stringIndex.get(fieldName);
+    if (fieldIndex === void 0) {
+      return void 0;
+    }
+    const edge = nodeData.edges[fieldIndex];
+    if (!edge) {
+      return void 0;
+    }
+    return {
+      argsNodeId: edge.argsNodeId,
+      outputNodeId: edge.outputNodeId
+    };
+  }
+  /**
+   * Get enum values for an edge that references a user enum.
+   * Returns undefined if the edge doesn't reference an enum.
+   */
+  enumValues(edge) {
+    if (edge?.enumNameIndex === void 0) {
+      return void 0;
+    }
+    const enumName = this.#data.strings[edge.enumNameIndex];
+    if (!enumName) {
+      return void 0;
+    }
+    return this.#enumLookup(enumName);
+  }
+  /**
+   * Get a string from the string table by index.
+   */
+  getString(index) {
+    return this.#data.strings[index];
+  }
+}
 const EdgeFlag = {
   /**
    * Field may be parameterized as a scalar value.
@@ -42,10 +172,10 @@ const ScalarMask = {
   Bytes: 256
 };
 function hasFlag(edge, flag) {
-  return (edge.k & flag) !== 0;
+  return (edge.flags & flag) !== 0;
 }
 function getScalarMask(edge) {
-  return edge.m ?? 0;
+  return edge.scalarMask;
 }
 function scalarTypeToMask(typeName) {
   switch (typeName) {
@@ -74,6 +204,7 @@ function scalarTypeToMask(typeName) {
 }
 export {
   EdgeFlag,
+  ParamGraph,
   ScalarMask,
   getScalarMask,
   hasFlag,

package/dist/serialization.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Binary serialization for ParamGraph.
+ *
+ * This module handles compact binary encoding/decoding of the param graph structure.
+ * The format uses a hybrid approach: JSON string array for field names + binary blob
+ * for structural data (nodes, edges, roots).
+ */
+import type { ParamGraphData } from './types';
+/**
+ * Serialized format stored in the generated client.
+ */
+export interface SerializedParamGraph {
+    /** String table (field names, enum names, root keys) */
+    strings: string[];
+    /** Base64url-encoded binary blob for structural data */
+    graph: string;
+}
+/**
+ * Serializes a ParamGraphData to the compact binary format.
+ */
+export declare function serializeParamGraph(data: ParamGraphData): SerializedParamGraph;
+/**
+ * Deserializes a binary-encoded ParamGraph.
+ */
+export declare function deserializeParamGraph(serialized: SerializedParamGraph): ParamGraphData;