@prisma/param-graph 7.7.0-integration-feat-prisma-bootstrap.7 → 7.7.0-integration-feat-bootstrap-ux-fixes.2

package/dist/index.mjs

@@ -1,6 +1,456 @@
-import { ParamGraph } from "./param-graph";
-import { EdgeFlag, getScalarMask, hasFlag, ScalarMask, scalarTypeToMask } from "./param-graph";
-import { deserializeParamGraph, serializeParamGraph } from "./serialization";
+// src/serialization.ts
+function serializeParamGraph(data) {
+  return new Serializer(data).serialize();
+}
+function deserializeParamGraph(serialized) {
+  return new Deserializer(serialized).deserialize();
+}
+function encodeBase64url(bytes) {
+  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64url");
+}
+function decodeBase64url(str) {
+  return Buffer.from(str, "base64url");
+}
+function varuintSize(value) {
+  let size = 1;
+  while (value >= 128) {
+    size++;
+    value >>>= 7;
+  }
+  return size;
+}
+var Serializer = class {
+  #data;
+  #buffer;
+  #view;
+  #offset = 0;
+  #rootKeys;
+  constructor(data) {
+    this.#data = data;
+    this.#rootKeys = Object.keys(data.roots);
+    const size = this.#calculateBufferSize();
+    this.#buffer = new ArrayBuffer(size);
+    this.#view = new DataView(this.#buffer);
+  }
+  serialize() {
+    this.#writeHeader();
+    this.#writeInputNodes();
+    this.#writeOutputNodes();
+    this.#writeRoots();
+    return {
+      strings: this.#data.strings,
+      graph: encodeBase64url(new Uint8Array(this.#buffer, 0, this.#offset))
+    };
+  }
+  #writeVaruint(value) {
+    while (value >= 128) {
+      this.#view.setUint8(this.#offset++, value & 127 | 128);
+      value >>>= 7;
+    }
+    this.#view.setUint8(this.#offset++, value);
+  }
+  #writeOptionalVaruint(value) {
+    this.#writeVaruint(value === void 0 ? 0 : value + 1);
+  }
+  #writeByte(value) {
+    this.#view.setUint8(this.#offset, value);
+    this.#offset += 1;
+  }
+  #writeU16(value) {
+    this.#view.setUint16(this.#offset, value, true);
+    this.#offset += 2;
+  }
+  #calculateBufferSize() {
+    let size = 0;
+    size += varuintSize(this.#data.inputNodes.length);
+    size += varuintSize(this.#data.outputNodes.length);
+    size += varuintSize(this.#rootKeys.length);
+    for (const node of this.#data.inputNodes) {
+      const fieldIndices = Object.keys(node.edges).map(Number);
+      size += varuintSize(fieldIndices.length);
+      for (const fieldIndex of fieldIndices) {
+        const edge = node.edges[fieldIndex];
+        size += varuintSize(fieldIndex);
+        size += 2;
+        size += varuintSize(edge.childNodeId === void 0 ? 0 : edge.childNodeId + 1);
+        size += varuintSize(edge.enumNameIndex === void 0 ? 0 : edge.enumNameIndex + 1);
+        size += 1;
+      }
+    }
+    for (const node of this.#data.outputNodes) {
+      const fieldIndices = Object.keys(node.edges).map(Number);
+      size += varuintSize(fieldIndices.length);
+      for (const fieldIndex of fieldIndices) {
+        const edge = node.edges[fieldIndex];
+        size += varuintSize(fieldIndex);
+        size += varuintSize(edge.argsNodeId === void 0 ? 0 : edge.argsNodeId + 1);
+        size += varuintSize(edge.outputNodeId === void 0 ? 0 : edge.outputNodeId + 1);
+      }
+    }
+    for (const key of this.#rootKeys) {
+      const root = this.#data.roots[key];
+      const keyIndex = this.#data.strings.indexOf(key);
+      size += varuintSize(keyIndex);
+      size += varuintSize(root.argsNodeId === void 0 ? 0 : root.argsNodeId + 1);
+      size += varuintSize(root.outputNodeId === void 0 ? 0 : root.outputNodeId + 1);
+    }
+    return size;
+  }
+  #writeHeader() {
+    this.#writeVaruint(this.#data.inputNodes.length);
+    this.#writeVaruint(this.#data.outputNodes.length);
+    this.#writeVaruint(this.#rootKeys.length);
+  }
+  #writeInputNodes() {
+    for (const node of this.#data.inputNodes) {
+      const fieldIndices = Object.keys(node.edges).map(Number);
+      this.#writeVaruint(fieldIndices.length);
+      for (const fieldIndex of fieldIndices) {
+        const edge = node.edges[fieldIndex];
+        this.#writeVaruint(fieldIndex);
+        this.#writeU16(edge.scalarMask ?? 0);
+        this.#writeOptionalVaruint(edge.childNodeId);
+        this.#writeOptionalVaruint(edge.enumNameIndex);
+        this.#writeByte(edge.flags);
+      }
+    }
+  }
+  #writeOutputNodes() {
+    for (const node of this.#data.outputNodes) {
+      const fieldIndices = Object.keys(node.edges).map(Number);
+      this.#writeVaruint(fieldIndices.length);
+      for (const fieldIndex of fieldIndices) {
+        const edge = node.edges[fieldIndex];
+        this.#writeVaruint(fieldIndex);
+        this.#writeOptionalVaruint(edge.argsNodeId);
+        this.#writeOptionalVaruint(edge.outputNodeId);
+      }
+    }
+  }
+  #writeRoots() {
+    for (const key of this.#rootKeys) {
+      const root = this.#data.roots[key];
+      const keyIndex = this.#data.strings.indexOf(key);
+      if (keyIndex === -1) {
+        throw new Error(`Root key "${key}" not found in strings table`);
+      }
+      this.#writeVaruint(keyIndex);
+      this.#writeOptionalVaruint(root.argsNodeId);
+      this.#writeOptionalVaruint(root.outputNodeId);
+    }
+  }
+};
+var Deserializer = class {
+  #serialized;
+  #view;
+  #offset = 0;
+  constructor(serialized) {
+    this.#serialized = serialized;
+    const bytes = decodeBase64url(serialized.graph);
+    this.#view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+  deserialize() {
+    const { inputNodeCount, outputNodeCount, rootCount } = this.#readHeader();
+    const inputNodes = this.#readInputNodes(inputNodeCount);
+    const outputNodes = this.#readOutputNodes(outputNodeCount);
+    const roots = this.#readRoots(rootCount);
+    return {
+      strings: this.#serialized.strings,
+      inputNodes,
+      outputNodes,
+      roots
+    };
+  }
+  #readVaruint() {
+    let value = 0;
+    let shift = 0;
+    let byte;
+    do {
+      byte = this.#view.getUint8(this.#offset++);
+      value |= (byte & 127) << shift;
+      shift += 7;
+    } while (byte >= 128);
+    return value;
+  }
+  #readOptionalVaruint() {
+    const value = this.#readVaruint();
+    return value === 0 ? void 0 : value - 1;
+  }
+  #readByte() {
+    const value = this.#view.getUint8(this.#offset);
+    this.#offset += 1;
+    return value;
+  }
+  #readU16() {
+    const value = this.#view.getUint16(this.#offset, true);
+    this.#offset += 2;
+    return value;
+  }
+  #readHeader() {
+    const inputNodeCount = this.#readVaruint();
+    const outputNodeCount = this.#readVaruint();
+    const rootCount = this.#readVaruint();
+    return { inputNodeCount, outputNodeCount, rootCount };
+  }
+  #readInputNodes(count) {
+    const inputNodes = [];
+    for (let i = 0; i < count; i++) {
+      const edgeCount = this.#readVaruint();
+      const edges = {};
+      for (let j = 0; j < edgeCount; j++) {
+        const fieldIndex = this.#readVaruint();
+        const scalarMask = this.#readU16();
+        const childNodeId = this.#readOptionalVaruint();
+        const enumNameIndex = this.#readOptionalVaruint();
+        const flags = this.#readByte();
+        const edge = { flags };
+        if (scalarMask !== 0) edge.scalarMask = scalarMask;
+        if (childNodeId !== void 0) edge.childNodeId = childNodeId;
+        if (enumNameIndex !== void 0) edge.enumNameIndex = enumNameIndex;
+        edges[fieldIndex] = edge;
+      }
+      inputNodes.push({ edges });
+    }
+    return inputNodes;
+  }
+  #readOutputNodes(count) {
+    const outputNodes = [];
+    for (let i = 0; i < count; i++) {
+      const edgeCount = this.#readVaruint();
+      const edges = {};
+      for (let j = 0; j < edgeCount; j++) {
+        const fieldIndex = this.#readVaruint();
+        const argsNodeId = this.#readOptionalVaruint();
+        const outputNodeId = this.#readOptionalVaruint();
+        const edge = {};
+        if (argsNodeId !== void 0) edge.argsNodeId = argsNodeId;
+        if (outputNodeId !== void 0) edge.outputNodeId = outputNodeId;
+        edges[fieldIndex] = edge;
+      }
+      outputNodes.push({ edges });
+    }
+    return outputNodes;
+  }
+  #readRoots(count) {
+    const roots = {};
+    for (let i = 0; i < count; i++) {
+      const keyIndex = this.#readVaruint();
+      const argsNodeId = this.#readOptionalVaruint();
+      const outputNodeId = this.#readOptionalVaruint();
+      const key = this.#serialized.strings[keyIndex];
+      const root = {};
+      if (argsNodeId !== void 0) root.argsNodeId = argsNodeId;
+      if (outputNodeId !== void 0) root.outputNodeId = outputNodeId;
+      roots[key] = root;
+    }
+    return roots;
+  }
+};
+
+// src/param-graph.ts
+var ParamGraph = 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];
+  }
+};
+var EdgeFlag = {
+  /**
+   * Field may be parameterized as a scalar value.
+   * Check ScalarMask to validate the value type.
+   */
+  ParamScalar: 1,
+  /**
+   * Field may be parameterized as an enum.
+   * Check enum ID to validate the value type.
+   */
+  ParamEnum: 2,
+  /**
+   * Field accepts list-of-scalar values.
+   * Parameterize the whole list if all elements match ScalarMask.
+   */
+  ParamListScalar: 4,
+  /**
+   * Field accepts list-of-enum values.
+   * Parameterize the whole list if all elements match enum ID.
+   */
+  ParamListEnum: 8,
+  /**
+   * Field accepts list-of-object values.
+   * Recurse into each element using the child node.
+   */
+  ListObject: 16,
+  /**
+   * Field accepts object values.
+   * Recurse into child input node.
+   */
+  Object: 32
+};
+var ScalarMask = {
+  String: 1,
+  Int: 2,
+  BigInt: 4,
+  Float: 8,
+  Decimal: 16,
+  Boolean: 32,
+  DateTime: 64,
+  Json: 128,
+  Bytes: 256
+};
+function hasFlag(edge, flag) {
+  return (edge.flags & flag) !== 0;
+}
+function getScalarMask(edge) {
+  return edge.scalarMask;
+}
+function scalarTypeToMask(typeName) {
+  switch (typeName) {
+    case "String":
+    case "UUID":
+      return ScalarMask.String;
+    case "Int":
+      return ScalarMask.Int;
+    case "BigInt":
+      return ScalarMask.BigInt;
+    case "Float":
+      return ScalarMask.Float;
+    case "Decimal":
+      return ScalarMask.Decimal;
+    case "Boolean":
+      return ScalarMask.Boolean;
+    case "DateTime":
+      return ScalarMask.DateTime;
+    case "Json":
+      return ScalarMask.Json;
+    case "Bytes":
+      return ScalarMask.Bytes;
+    default:
+      return 0;
+  }
+}
 export {
   EdgeFlag,
   ParamGraph,

package/dist/param-graph.d.ts

@@ -7,11 +7,15 @@
  */
 import type { SerializedParamGraph } from './serialization';
 import type { InputEdgeData, InputNodeData, OutputEdgeData, OutputNodeData, ParamGraphData, RootEntryData } from './types';
+/**
+ * Map of enum names to their respective values.
+ */
+export type EnumNameToValueMap = Record<string, string>;
 /**
  * Function type for looking up enum values by name.
  * This allows ParamGraph to remain decoupled from RuntimeDataModel.
  */
-export type EnumLookup = (enumName: string) => readonly string[] | undefined;
+export type EnumLookup = (enumName: string) => Readonly<EnumNameToValueMap> | undefined;
 /**
  * Readable view of root entry.
  */
@@ -88,7 +92,7 @@ export declare class ParamGraph {
      * 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;
+    enumValues(edge: InputEdge | undefined): Readonly<EnumNameToValueMap> | undefined;
     /**
      * Get a string from the string table by index.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/param-graph",
-  "version": "7.7.0-integration-feat-prisma-bootstrap.7",
+  "version": "7.7.0-integration-feat-bootstrap-ux-fixes.2",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",