@prisma-next/utils 0.5.0-dev.49 → 0.5.0-dev.50

package/dist/canonical-stringify.d.mts

@@ -0,0 +1,50 @@
+//#region src/canonical-stringify.d.ts
+/**
+ * Produces a deterministic, JSON-like string representation of a value.
+ *
+ * Designed for use as a stable identity / cache key. Two values that are
+ * structurally equivalent — regardless of object key insertion order —
+ * produce the same string. Two values that differ in any meaningful way
+ * (including types that JSON would conflate, like `BigInt(1)` vs `1`)
+ * produce different strings.
+ *
+ * Supported inputs:
+ * - `null`, `undefined` (distinguishable: `null` → `"null"`, `undefined` → `"undefined"`)
+ * - `boolean`, `string`, `number` (including `NaN`, `Infinity`, `-Infinity`)
+ * - `bigint` (suffixed with `n` to disambiguate from `number`)
+ * - `Date` (tagged + ISO string)
+ * - `Buffer` / `Uint8Array` (tagged + hex-encoded as `Bytes(<hex>)`)
+ * - Other `ArrayBuffer` views — `Int8Array`, `Uint16Array`, `Float64Array`,
+ *   `DataView`, etc. (tagged with the constructor name + hex-encoded over
+ *   the underlying bytes, e.g. `Uint16Array(<hex>)`). Note that the bytes
+ *   are read in host byte order, so callers that need cross-platform
+ *   stability for multi-byte typed arrays should normalize endianness
+ *   before passing the value in.
+ * - Arrays (order-preserving)
+ * - Plain objects (key-sorted) — only objects whose prototype is
+ *   `Object.prototype` or `null`. Non-plain objects (`Map`, `Set`,
+ *   `RegExp`, class instances, etc.) are rejected so they cannot silently
+ *   collapse to `{}` and collide with each other.
+ *
+ * Throws on `function`, `symbol`, circular references, non-plain objects,
+ * and objects with symbol-keyed properties (which `Object.keys` would
+ * silently drop). Callers that need to canonicalize any of these must
+ * convert them to a supported representation first.
+ *
+ * The output format is intentionally not JSON: the type tags and BigInt
+ * suffix mean it cannot be round-tripped via `JSON.parse`. The goal is
+ * keying, not serialization.
+ *
+ * @example
+ * ```typescript
+ * canonicalStringify({ a: 1, b: 2 }) === canonicalStringify({ b: 2, a: 1 })
+ * // → true
+ *
+ * canonicalStringify(1n) !== canonicalStringify(1)
+ * // → true
+ * ```
+ */
+declare function canonicalStringify(value: unknown): string;
+//#endregion
+export { canonicalStringify };
+//# sourceMappingURL=canonical-stringify.d.mts.map

package/dist/canonical-stringify.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-stringify.d.mts","names":[],"sources":["../src/canonical-stringify.ts"],"sourcesContent":[],"mappings":";;AA6CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,kBAAA"}

package/dist/canonical-stringify.mjs

@@ -0,0 +1,104 @@
+//#region src/canonical-stringify.ts
+/**
+* Produces a deterministic, JSON-like string representation of a value.
+*
+* Designed for use as a stable identity / cache key. Two values that are
+* structurally equivalent — regardless of object key insertion order —
+* produce the same string. Two values that differ in any meaningful way
+* (including types that JSON would conflate, like `BigInt(1)` vs `1`)
+* produce different strings.
+*
+* Supported inputs:
+* - `null`, `undefined` (distinguishable: `null` → `"null"`, `undefined` → `"undefined"`)
+* - `boolean`, `string`, `number` (including `NaN`, `Infinity`, `-Infinity`)
+* - `bigint` (suffixed with `n` to disambiguate from `number`)
+* - `Date` (tagged + ISO string)
+* - `Buffer` / `Uint8Array` (tagged + hex-encoded as `Bytes(<hex>)`)
+* - Other `ArrayBuffer` views — `Int8Array`, `Uint16Array`, `Float64Array`,
+*   `DataView`, etc. (tagged with the constructor name + hex-encoded over
+*   the underlying bytes, e.g. `Uint16Array(<hex>)`). Note that the bytes
+*   are read in host byte order, so callers that need cross-platform
+*   stability for multi-byte typed arrays should normalize endianness
+*   before passing the value in.
+* - Arrays (order-preserving)
+* - Plain objects (key-sorted) — only objects whose prototype is
+*   `Object.prototype` or `null`. Non-plain objects (`Map`, `Set`,
+*   `RegExp`, class instances, etc.) are rejected so they cannot silently
+*   collapse to `{}` and collide with each other.
+*
+* Throws on `function`, `symbol`, circular references, non-plain objects,
+* and objects with symbol-keyed properties (which `Object.keys` would
+* silently drop). Callers that need to canonicalize any of these must
+* convert them to a supported representation first.
+*
+* The output format is intentionally not JSON: the type tags and BigInt
+* suffix mean it cannot be round-tripped via `JSON.parse`. The goal is
+* keying, not serialization.
+*
+* @example
+* ```typescript
+* canonicalStringify({ a: 1, b: 2 }) === canonicalStringify({ b: 2, a: 1 })
+* // → true
+*
+* canonicalStringify(1n) !== canonicalStringify(1)
+* // → true
+* ```
+*/
+function canonicalStringify(value) {
+	return write(value, /* @__PURE__ */ new Set());
+}
+function write(value, seen) {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	switch (typeof value) {
+		case "boolean": return value ? "true" : "false";
+		case "number": return writeNumber(value);
+		case "bigint": return `${value.toString()}n`;
+		case "string": return JSON.stringify(value);
+		case "function": throw new TypeError("canonicalStringify: functions are not supported");
+		case "symbol": throw new TypeError("canonicalStringify: symbols are not supported");
+	}
+	const obj = value;
+	if (value instanceof Date) return `Date(${value.toISOString()})`;
+	if (value instanceof Uint8Array) return `Bytes(${bytesToHex(value)})`;
+	if (ArrayBuffer.isView(value)) return `${value.constructor.name}(${bytesToHex(new Uint8Array(value.buffer, value.byteOffset, value.byteLength))})`;
+	if (seen.has(obj)) throw new TypeError("canonicalStringify: circular reference detected");
+	seen.add(obj);
+	try {
+		if (Array.isArray(value)) return `[${value.map((item) => write(item, seen)).join(",")}]`;
+		return writePlainObject(obj, seen);
+	} finally {
+		seen.delete(obj);
+	}
+}
+function writeNumber(value) {
+	if (Number.isNaN(value)) return "NaN";
+	if (value === Number.POSITIVE_INFINITY) return "Infinity";
+	if (value === Number.NEGATIVE_INFINITY) return "-Infinity";
+	if (value === 0 && 1 / value === Number.NEGATIVE_INFINITY) return "-0";
+	return String(value);
+}
+function writePlainObject(obj, seen) {
+	const proto = Object.getPrototypeOf(obj);
+	if (proto !== Object.prototype && proto !== null) {
+		const tag = proto?.constructor?.name ?? "unknown";
+		throw new TypeError(`canonicalStringify: non-plain objects are not supported (got ${tag})`);
+	}
+	if (Object.getOwnPropertySymbols(obj).length > 0) throw new TypeError("canonicalStringify: objects with symbol-keyed properties are not supported");
+	const keys = Object.keys(obj).sort();
+	const parts = [];
+	for (const key of keys) parts.push(`${JSON.stringify(key)}:${write(obj[key], seen)}`);
+	return `{${parts.join(",")}}`;
+}
+function bytesToHex(bytes) {
+	let out = "";
+	for (let i = 0; i < bytes.length; i++) {
+		const byte = bytes[i];
+		out += byte.toString(16).padStart(2, "0");
+	}
+	return out;
+}
+
+//#endregion
+export { canonicalStringify };
+//# sourceMappingURL=canonical-stringify.mjs.map

package/dist/canonical-stringify.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-stringify.mjs","names":["parts: string[]"],"sources":["../src/canonical-stringify.ts"],"sourcesContent":["/**\n * Produces a deterministic, JSON-like string representation of a value.\n *\n * Designed for use as a stable identity / cache key. Two values that are\n * structurally equivalent — regardless of object key insertion order —\n * produce the same string. Two values that differ in any meaningful way\n * (including types that JSON would conflate, like `BigInt(1)` vs `1`)\n * produce different strings.\n *\n * Supported inputs:\n * - `null`, `undefined` (distinguishable: `null` → `\"null\"`, `undefined` → `\"undefined\"`)\n * - `boolean`, `string`, `number` (including `NaN`, `Infinity`, `-Infinity`)\n * - `bigint` (suffixed with `n` to disambiguate from `number`)\n * - `Date` (tagged + ISO string)\n * - `Buffer` / `Uint8Array` (tagged + hex-encoded as `Bytes(<hex>)`)\n * - Other `ArrayBuffer` views — `Int8Array`, `Uint16Array`, `Float64Array`,\n *   `DataView`, etc. (tagged with the constructor name + hex-encoded over\n *   the underlying bytes, e.g. `Uint16Array(<hex>)`). Note that the bytes\n *   are read in host byte order, so callers that need cross-platform\n *   stability for multi-byte typed arrays should normalize endianness\n *   before passing the value in.\n * - Arrays (order-preserving)\n * - Plain objects (key-sorted) — only objects whose prototype is\n *   `Object.prototype` or `null`. Non-plain objects (`Map`, `Set`,\n *   `RegExp`, class instances, etc.) are rejected so they cannot silently\n *   collapse to `{}` and collide with each other.\n *\n * Throws on `function`, `symbol`, circular references, non-plain objects,\n * and objects with symbol-keyed properties (which `Object.keys` would\n * silently drop). Callers that need to canonicalize any of these must\n * convert them to a supported representation first.\n *\n * The output format is intentionally not JSON: the type tags and BigInt\n * suffix mean it cannot be round-tripped via `JSON.parse`. The goal is\n * keying, not serialization.\n *\n * @example\n * ```typescript\n * canonicalStringify({ a: 1, b: 2 }) === canonicalStringify({ b: 2, a: 1 })\n * // → true\n *\n * canonicalStringify(1n) !== canonicalStringify(1)\n * // → true\n * ```\n */\nexport function canonicalStringify(value: unknown): string {\n  return write(value, new Set());\n}\n\nfunction write(value: unknown, seen: Set<object>): string {\n  if (value === null) return 'null';\n  if (value === undefined) return 'undefined';\n\n  switch (typeof value) {\n    case 'boolean':\n      return value ? 'true' : 'false';\n    case 'number':\n      return writeNumber(value);\n    case 'bigint':\n      return `${value.toString()}n`;\n    case 'string':\n      return JSON.stringify(value);\n    case 'function':\n      throw new TypeError('canonicalStringify: functions are not supported');\n    case 'symbol':\n      throw new TypeError('canonicalStringify: symbols are not supported');\n  }\n\n  // From here, value is a non-null object.\n  const obj = value as object;\n\n  // Leaf object types are handled before touching `seen`: they can never\n  // contain back-references, so cycle tracking is wasted work for them.\n  if (value instanceof Date) {\n    return `Date(${value.toISOString()})`;\n  }\n\n  // `Buffer` is a `Uint8Array` subclass; this branch covers both, and\n  // emits the legacy `Bytes(<hex>)` tag so a `Buffer` and a same-content\n  // `Uint8Array` digest identically.\n  if (value instanceof Uint8Array) {\n    return `Bytes(${bytesToHex(value)})`;\n  }\n\n  // Any other `ArrayBuffer` view — typed arrays (`Int8Array`,\n  // `Uint16Array`, `Float64Array`, …) and `DataView`. Without this\n  // branch they would fall through to the plain-object writer and\n  // canonicalize as `{\"0\":1,\"1\":2,...}`, which would silently collide\n  // with a same-keyed plain object. Tagging by constructor name keeps\n  // distinct view families distinct.\n  if (ArrayBuffer.isView(value)) {\n    const tag = value.constructor.name;\n    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);\n    return `${tag}(${bytesToHex(bytes)})`;\n  }\n\n  if (seen.has(obj)) {\n    throw new TypeError('canonicalStringify: circular reference detected');\n  }\n  seen.add(obj);\n  try {\n    if (Array.isArray(value)) {\n      const parts = value.map((item) => write(item, seen));\n      return `[${parts.join(',')}]`;\n    }\n\n    return writePlainObject(obj as Record<string, unknown>, seen);\n  } finally {\n    seen.delete(obj);\n  }\n}\n\nfunction writeNumber(value: number): string {\n  if (Number.isNaN(value)) return 'NaN';\n  if (value === Number.POSITIVE_INFINITY) return 'Infinity';\n  if (value === Number.NEGATIVE_INFINITY) return '-Infinity';\n  // Distinguish `+0` from `-0` so they hash differently.\n  if (value === 0 && 1 / value === Number.NEGATIVE_INFINITY) return '-0';\n  return String(value);\n}\n\nfunction writePlainObject(obj: Record<string, unknown>, seen: Set<object>): string {\n  // Only true plain objects are accepted here. Without this guard, anything\n  // that fell through the type-tagged branches above (`Map`, `Set`,\n  // `RegExp`, class instances, …) would canonicalize to `{}` because\n  // `Object.keys` returns no enumerable string keys for them — silently\n  // colliding with each other and with the literal `{}`.\n  const proto = Object.getPrototypeOf(obj);\n  if (proto !== Object.prototype && proto !== null) {\n    const tag = proto?.constructor?.name ?? 'unknown';\n    throw new TypeError(`canonicalStringify: non-plain objects are not supported (got ${tag})`);\n  }\n\n  // `Object.keys` ignores symbol-keyed properties, so they would be\n  // silently dropped from the canonical form. Force callers to handle\n  // them explicitly instead of producing a key that omits real data.\n  if (Object.getOwnPropertySymbols(obj).length > 0) {\n    throw new TypeError(\n      'canonicalStringify: objects with symbol-keyed properties are not supported',\n    );\n  }\n\n  const keys = Object.keys(obj).sort();\n  const parts: string[] = [];\n  for (const key of keys) {\n    parts.push(`${JSON.stringify(key)}:${write(obj[key], seen)}`);\n  }\n  return `{${parts.join(',')}}`;\n}\n\nfunction bytesToHex(bytes: Uint8Array): string {\n  let out = '';\n  for (let i = 0; i < bytes.length; i++) {\n    const byte = bytes[i] as number;\n    out += byte.toString(16).padStart(2, '0');\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,mBAAmB,OAAwB;AACzD,QAAO,MAAM,uBAAO,IAAI,KAAK,CAAC;;AAGhC,SAAS,MAAM,OAAgB,MAA2B;AACxD,KAAI,UAAU,KAAM,QAAO;AAC3B,KAAI,UAAU,OAAW,QAAO;AAEhC,SAAQ,OAAO,OAAf;EACE,KAAK,UACH,QAAO,QAAQ,SAAS;EAC1B,KAAK,SACH,QAAO,YAAY,MAAM;EAC3B,KAAK,SACH,QAAO,GAAG,MAAM,UAAU,CAAC;EAC7B,KAAK,SACH,QAAO,KAAK,UAAU,MAAM;EAC9B,KAAK,WACH,OAAM,IAAI,UAAU,kDAAkD;EACxE,KAAK,SACH,OAAM,IAAI,UAAU,gDAAgD;;CAIxE,MAAM,MAAM;AAIZ,KAAI,iBAAiB,KACnB,QAAO,QAAQ,MAAM,aAAa,CAAC;AAMrC,KAAI,iBAAiB,WACnB,QAAO,SAAS,WAAW,MAAM,CAAC;AASpC,KAAI,YAAY,OAAO,MAAM,CAG3B,QAAO,GAFK,MAAM,YAAY,KAEhB,GAAG,WADH,IAAI,WAAW,MAAM,QAAQ,MAAM,YAAY,MAAM,WAAW,CAC5C,CAAC;AAGrC,KAAI,KAAK,IAAI,IAAI,CACf,OAAM,IAAI,UAAU,kDAAkD;AAExE,MAAK,IAAI,IAAI;AACb,KAAI;AACF,MAAI,MAAM,QAAQ,MAAM,CAEtB,QAAO,IADO,MAAM,KAAK,SAAS,MAAM,MAAM,KAAK,CAAC,CACnC,KAAK,IAAI,CAAC;AAG7B,SAAO,iBAAiB,KAAgC,KAAK;WACrD;AACR,OAAK,OAAO,IAAI;;;AAIpB,SAAS,YAAY,OAAuB;AAC1C,KAAI,OAAO,MAAM,MAAM,CAAE,QAAO;AAChC,KAAI,UAAU,OAAO,kBAAmB,QAAO;AAC/C,KAAI,UAAU,OAAO,kBAAmB,QAAO;AAE/C,KAAI,UAAU,KAAK,IAAI,UAAU,OAAO,kBAAmB,QAAO;AAClE,QAAO,OAAO,MAAM;;AAGtB,SAAS,iBAAiB,KAA8B,MAA2B;CAMjF,MAAM,QAAQ,OAAO,eAAe,IAAI;AACxC,KAAI,UAAU,OAAO,aAAa,UAAU,MAAM;EAChD,MAAM,MAAM,OAAO,aAAa,QAAQ;AACxC,QAAM,IAAI,UAAU,gEAAgE,IAAI,GAAG;;AAM7F,KAAI,OAAO,sBAAsB,IAAI,CAAC,SAAS,EAC7C,OAAM,IAAI,UACR,6EACD;CAGH,MAAM,OAAO,OAAO,KAAK,IAAI,CAAC,MAAM;CACpC,MAAMA,QAAkB,EAAE;AAC1B,MAAK,MAAM,OAAO,KAChB,OAAM,KAAK,GAAG,KAAK,UAAU,IAAI,CAAC,GAAG,MAAM,IAAI,MAAM,KAAK,GAAG;AAE/D,QAAO,IAAI,MAAM,KAAK,IAAI,CAAC;;AAG7B,SAAS,WAAW,OAA2B;CAC7C,IAAI,MAAM;AACV,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,OAAO,MAAM;AACnB,SAAO,KAAK,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI;;AAE3C,QAAO"}

package/dist/{defined-CV9lG7rM.mjs → defined-1jOuAm8c.mjs}

@@ -27,4 +27,4 @@ function ifDefined(key, value) {
 
 //#endregion
 export { ifDefined as t };
-//# sourceMappingURL=defined-CV9lG7rM.mjs.map
+//# sourceMappingURL=defined-1jOuAm8c.mjs.map

package/dist/{defined-CV9lG7rM.mjs.map → defined-1jOuAm8c.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"defined-CV9lG7rM.mjs","names":[],"sources":["../src/defined.ts"],"sourcesContent":["/**\n * Returns an object with the key/value if value is defined, otherwise an empty object.\n *\n * Use with spread to conditionally include optional properties while satisfying\n * exactOptionalPropertyTypes. This is explicit about which properties are optional\n * and won't inadvertently strip other undefined values.\n *\n * @example\n * ```typescript\n * // Instead of:\n * const obj = {\n *   required: 'value',\n *   ...(optional ? { optional } : {}),\n * };\n *\n * // Use:\n * const obj = {\n *   required: 'value',\n *   ...ifDefined('optional', optional),\n * };\n * ```\n */\nexport function ifDefined<K extends string, V>(\n  key: K,\n  value: V | undefined,\n): Record<never, never> | { [P in K]: V } {\n  return value !== undefined ? ({ [key]: value } as { [P in K]: V }) : {};\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,UACd,KACA,OACwC;AACxC,QAAO,UAAU,SAAa,GAAG,MAAM,OAAO,GAAuB,EAAE"}
+{"version":3,"file":"defined-1jOuAm8c.mjs","names":[],"sources":["../src/defined.ts"],"sourcesContent":["/**\n * Returns an object with the key/value if value is defined, otherwise an empty object.\n *\n * Use with spread to conditionally include optional properties while satisfying\n * exactOptionalPropertyTypes. This is explicit about which properties are optional\n * and won't inadvertently strip other undefined values.\n *\n * @example\n * ```typescript\n * // Instead of:\n * const obj = {\n *   required: 'value',\n *   ...(optional ? { optional } : {}),\n * };\n *\n * // Use:\n * const obj = {\n *   required: 'value',\n *   ...ifDefined('optional', optional),\n * };\n * ```\n */\nexport function ifDefined<K extends string, V>(\n  key: K,\n  value: V | undefined,\n): Record<never, never> | { [P in K]: V } {\n  return value !== undefined ? ({ [key]: value } as { [P in K]: V }) : {};\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,UACd,KACA,OACwC;AACxC,QAAO,UAAU,SAAa,GAAG,MAAM,OAAO,GAAuB,EAAE"}

package/dist/defined.mjs

@@ -1,3 +1,3 @@
-import { t as ifDefined } from "./defined-CV9lG7rM.mjs";
+import { t as ifDefined } from "./defined-1jOuAm8c.mjs";
 
 export { ifDefined };

package/dist/hash-content.d.mts

@@ -0,0 +1,58 @@
+//#region src/hash-content.d.ts
+/**
+ * Hashes a canonical-string representation of an execution into a bounded,
+ * opaque cache-key digest.
+ *
+ * Designed for use as the final step of `RuntimeMiddlewareContext.contentHash`
+ * implementations: family runtimes compose a canonical string from
+ * `meta.storageHash`, the rendered statement (or wire command), and
+ * canonicalized parameters via `canonicalStringify`, then pipe the result
+ * through this helper.
+ *
+ * Why hash the canonical string instead of using it directly as a `Map` key:
+ *
+ * 1. **Bounded memory.** A raw canonical key includes concrete parameter
+ *    values, so a query bound to a 10 MB JSON column or binary blob produces
+ *    a 10 MB cache key. With `maxEntries = 1000`, that scales to gigabytes
+ *    of cache keys alone. SHA-512 pins per-key cost at a fixed digest
+ *    length regardless of input size.
+ *
+ * 2. **Sensitive-data isolation.** The canonical string contains parameter
+ *    values verbatim. Cache keys flow into debug logs, Redis `KEYS`/`MONITOR`
+ *    output, persistence dumps, monitoring tools, and any user-supplied
+ *    `CacheStore` implementation. Hashing prevents PII / credentials /
+ *    tokens that appear in query parameters from showing up in any of those
+ *    surfaces.
+ *
+ * Algorithm choice — SHA-512 (`SHA-512` via the WebCrypto API):
+ *
+ * - **Portability.** WebCrypto (`globalThis.crypto.subtle`) is available in
+ *   every modern JavaScript runtime — Node, Deno, Bun, browsers, edge
+ *   workers — without importing a Node-specific module. This keeps the
+ *   helper usable in non-Node hosts where `node:crypto` is not available.
+ * - **Collision space.** 512 bits of output makes accidental collisions
+ *   astronomically improbable — far beyond what a cache needs, but the
+ *   incremental cost over 256-bit output is negligible and the headroom
+ *   is free.
+ * - **No additional dependency.** SHA-512 is part of the WebCrypto standard
+ *   set of digest algorithms; no third-party package needed.
+ *
+ * The function is `async` because the WebCrypto digest API is async by
+ * design. Callers must await the result.
+ *
+ * Output format: `sha512:HEXDIGEST` (128-char hex with the algorithm tag
+ * prefix). Self-describing so a future migration to a different hash
+ * produces visibly distinct keys, and consistent with the
+ * `sha256:HEXDIGEST` shape already used by `meta.storageHash`.
+ *
+ * @example
+ * ```typescript
+ * const canonical = `${exec.meta.storageHash}|${exec.sql}|${canonicalStringify(exec.params)}`;
+ * return await hashContent(canonical);
+ * // → 'sha512:8f3...e1c' (always 135 chars: 'sha512:' + 128 hex chars)
+ * ```
+ */
+declare function hashContent(value: string): Promise<string>;
+//#endregion
+export { hashContent };
+//# sourceMappingURL=hash-content.d.mts.map

package/dist/hash-content.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-content.d.mts","names":[],"sources":["../src/hash-content.ts"],"sourcesContent":[],"mappings":";;AAqDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,WAAA,iBAA4B"}

package/dist/hash-content.mjs

@@ -0,0 +1,63 @@
+//#region src/hash-content.ts
+/**
+* Hashes a canonical-string representation of an execution into a bounded,
+* opaque cache-key digest.
+*
+* Designed for use as the final step of `RuntimeMiddlewareContext.contentHash`
+* implementations: family runtimes compose a canonical string from
+* `meta.storageHash`, the rendered statement (or wire command), and
+* canonicalized parameters via `canonicalStringify`, then pipe the result
+* through this helper.
+*
+* Why hash the canonical string instead of using it directly as a `Map` key:
+*
+* 1. **Bounded memory.** A raw canonical key includes concrete parameter
+*    values, so a query bound to a 10 MB JSON column or binary blob produces
+*    a 10 MB cache key. With `maxEntries = 1000`, that scales to gigabytes
+*    of cache keys alone. SHA-512 pins per-key cost at a fixed digest
+*    length regardless of input size.
+*
+* 2. **Sensitive-data isolation.** The canonical string contains parameter
+*    values verbatim. Cache keys flow into debug logs, Redis `KEYS`/`MONITOR`
+*    output, persistence dumps, monitoring tools, and any user-supplied
+*    `CacheStore` implementation. Hashing prevents PII / credentials /
+*    tokens that appear in query parameters from showing up in any of those
+*    surfaces.
+*
+* Algorithm choice — SHA-512 (`SHA-512` via the WebCrypto API):
+*
+* - **Portability.** WebCrypto (`globalThis.crypto.subtle`) is available in
+*   every modern JavaScript runtime — Node, Deno, Bun, browsers, edge
+*   workers — without importing a Node-specific module. This keeps the
+*   helper usable in non-Node hosts where `node:crypto` is not available.
+* - **Collision space.** 512 bits of output makes accidental collisions
+*   astronomically improbable — far beyond what a cache needs, but the
+*   incremental cost over 256-bit output is negligible and the headroom
+*   is free.
+* - **No additional dependency.** SHA-512 is part of the WebCrypto standard
+*   set of digest algorithms; no third-party package needed.
+*
+* The function is `async` because the WebCrypto digest API is async by
+* design. Callers must await the result.
+*
+* Output format: `sha512:HEXDIGEST` (128-char hex with the algorithm tag
+* prefix). Self-describing so a future migration to a different hash
+* produces visibly distinct keys, and consistent with the
+* `sha256:HEXDIGEST` shape already used by `meta.storageHash`.
+*
+* @example
+* ```typescript
+* const canonical = `${exec.meta.storageHash}|${exec.sql}|${canonicalStringify(exec.params)}`;
+* return await hashContent(canonical);
+* // → 'sha512:8f3...e1c' (always 135 chars: 'sha512:' + 128 hex chars)
+* ```
+*/
+async function hashContent(value) {
+	const bytes = new TextEncoder().encode(value);
+	const digest = await crypto.subtle.digest("SHA-512", bytes);
+	return `sha512:${Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+
+//#endregion
+export { hashContent };
+//# sourceMappingURL=hash-content.mjs.map

package/dist/hash-content.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-content.mjs","names":[],"sources":["../src/hash-content.ts"],"sourcesContent":["/**\n * Hashes a canonical-string representation of an execution into a bounded,\n * opaque cache-key digest.\n *\n * Designed for use as the final step of `RuntimeMiddlewareContext.contentHash`\n * implementations: family runtimes compose a canonical string from\n * `meta.storageHash`, the rendered statement (or wire command), and\n * canonicalized parameters via `canonicalStringify`, then pipe the result\n * through this helper.\n *\n * Why hash the canonical string instead of using it directly as a `Map` key:\n *\n * 1. **Bounded memory.** A raw canonical key includes concrete parameter\n *    values, so a query bound to a 10 MB JSON column or binary blob produces\n *    a 10 MB cache key. With `maxEntries = 1000`, that scales to gigabytes\n *    of cache keys alone. SHA-512 pins per-key cost at a fixed digest\n *    length regardless of input size.\n *\n * 2. **Sensitive-data isolation.** The canonical string contains parameter\n *    values verbatim. Cache keys flow into debug logs, Redis `KEYS`/`MONITOR`\n *    output, persistence dumps, monitoring tools, and any user-supplied\n *    `CacheStore` implementation. Hashing prevents PII / credentials /\n *    tokens that appear in query parameters from showing up in any of those\n *    surfaces.\n *\n * Algorithm choice — SHA-512 (`SHA-512` via the WebCrypto API):\n *\n * - **Portability.** WebCrypto (`globalThis.crypto.subtle`) is available in\n *   every modern JavaScript runtime — Node, Deno, Bun, browsers, edge\n *   workers — without importing a Node-specific module. This keeps the\n *   helper usable in non-Node hosts where `node:crypto` is not available.\n * - **Collision space.** 512 bits of output makes accidental collisions\n *   astronomically improbable — far beyond what a cache needs, but the\n *   incremental cost over 256-bit output is negligible and the headroom\n *   is free.\n * - **No additional dependency.** SHA-512 is part of the WebCrypto standard\n *   set of digest algorithms; no third-party package needed.\n *\n * The function is `async` because the WebCrypto digest API is async by\n * design. Callers must await the result.\n *\n * Output format: `sha512:HEXDIGEST` (128-char hex with the algorithm tag\n * prefix). Self-describing so a future migration to a different hash\n * produces visibly distinct keys, and consistent with the\n * `sha256:HEXDIGEST` shape already used by `meta.storageHash`.\n *\n * @example\n * ```typescript\n * const canonical = `${exec.meta.storageHash}|${exec.sql}|${canonicalStringify(exec.params)}`;\n * return await hashContent(canonical);\n * // → 'sha512:8f3...e1c' (always 135 chars: 'sha512:' + 128 hex chars)\n * ```\n */\nexport async function hashContent(value: string): Promise<string> {\n  const bytes = new TextEncoder().encode(value);\n  const digest = await crypto.subtle.digest('SHA-512', bytes);\n  const hex = Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, '0')).join('');\n  return `sha512:${hex}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDA,eAAsB,YAAY,OAAgC;CAChE,MAAM,QAAQ,IAAI,aAAa,CAAC,OAAO,MAAM;CAC7C,MAAM,SAAS,MAAM,OAAO,OAAO,OAAO,WAAW,MAAM;AAE3D,QAAO,UADK,MAAM,KAAK,IAAI,WAAW,OAAO,GAAG,MAAM,EAAE,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,KAAK,GAAG"}

package/dist/redact-db-url.mjs

@@ -1,4 +1,4 @@
-import { t as ifDefined } from "./defined-CV9lG7rM.mjs";
+import { t as ifDefined } from "./defined-1jOuAm8c.mjs";
 
 //#region src/redact-db-url.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma-next/utils",
-  "version": "0.5.0-dev.49",
+  "version": "0.5.0-dev.50",
   "type": "module",
   "sideEffects": false,
   "description": "Shared utility functions for Prisma Next",
@@ -22,7 +22,9 @@
     "./abortable": "./dist/abortable.mjs",
     "./array-equal": "./dist/array-equal.mjs",
     "./assertions": "./dist/assertions.mjs",
+    "./canonical-stringify": "./dist/canonical-stringify.mjs",
     "./defined": "./dist/defined.mjs",
+    "./hash-content": "./dist/hash-content.mjs",
     "./redact-db-url": "./dist/redact-db-url.mjs",
     "./result": "./dist/result.mjs",
     "./simplify-deep": "./dist/simplify-deep.mjs",

package/src/canonical-stringify.ts

@@ -0,0 +1,158 @@
+/**
+ * Produces a deterministic, JSON-like string representation of a value.
+ *
+ * Designed for use as a stable identity / cache key. Two values that are
+ * structurally equivalent — regardless of object key insertion order —
+ * produce the same string. Two values that differ in any meaningful way
+ * (including types that JSON would conflate, like `BigInt(1)` vs `1`)
+ * produce different strings.
+ *
+ * Supported inputs:
+ * - `null`, `undefined` (distinguishable: `null` → `"null"`, `undefined` → `"undefined"`)
+ * - `boolean`, `string`, `number` (including `NaN`, `Infinity`, `-Infinity`)
+ * - `bigint` (suffixed with `n` to disambiguate from `number`)
+ * - `Date` (tagged + ISO string)
+ * - `Buffer` / `Uint8Array` (tagged + hex-encoded as `Bytes(<hex>)`)
+ * - Other `ArrayBuffer` views — `Int8Array`, `Uint16Array`, `Float64Array`,
+ *   `DataView`, etc. (tagged with the constructor name + hex-encoded over
+ *   the underlying bytes, e.g. `Uint16Array(<hex>)`). Note that the bytes
+ *   are read in host byte order, so callers that need cross-platform
+ *   stability for multi-byte typed arrays should normalize endianness
+ *   before passing the value in.
+ * - Arrays (order-preserving)
+ * - Plain objects (key-sorted) — only objects whose prototype is
+ *   `Object.prototype` or `null`. Non-plain objects (`Map`, `Set`,
+ *   `RegExp`, class instances, etc.) are rejected so they cannot silently
+ *   collapse to `{}` and collide with each other.
+ *
+ * Throws on `function`, `symbol`, circular references, non-plain objects,
+ * and objects with symbol-keyed properties (which `Object.keys` would
+ * silently drop). Callers that need to canonicalize any of these must
+ * convert them to a supported representation first.
+ *
+ * The output format is intentionally not JSON: the type tags and BigInt
+ * suffix mean it cannot be round-tripped via `JSON.parse`. The goal is
+ * keying, not serialization.
+ *
+ * @example
+ * ```typescript
+ * canonicalStringify({ a: 1, b: 2 }) === canonicalStringify({ b: 2, a: 1 })
+ * // → true
+ *
+ * canonicalStringify(1n) !== canonicalStringify(1)
+ * // → true
+ * ```
+ */
+export function canonicalStringify(value: unknown): string {
+  return write(value, new Set());
+}
+
+function write(value: unknown, seen: Set<object>): string {
+  if (value === null) return 'null';
+  if (value === undefined) return 'undefined';
+
+  switch (typeof value) {
+    case 'boolean':
+      return value ? 'true' : 'false';
+    case 'number':
+      return writeNumber(value);
+    case 'bigint':
+      return `${value.toString()}n`;
+    case 'string':
+      return JSON.stringify(value);
+    case 'function':
+      throw new TypeError('canonicalStringify: functions are not supported');
+    case 'symbol':
+      throw new TypeError('canonicalStringify: symbols are not supported');
+  }
+
+  // From here, value is a non-null object.
+  const obj = value as object;
+
+  // Leaf object types are handled before touching `seen`: they can never
+  // contain back-references, so cycle tracking is wasted work for them.
+  if (value instanceof Date) {
+    return `Date(${value.toISOString()})`;
+  }
+
+  // `Buffer` is a `Uint8Array` subclass; this branch covers both, and
+  // emits the legacy `Bytes(<hex>)` tag so a `Buffer` and a same-content
+  // `Uint8Array` digest identically.
+  if (value instanceof Uint8Array) {
+    return `Bytes(${bytesToHex(value)})`;
+  }
+
+  // Any other `ArrayBuffer` view — typed arrays (`Int8Array`,
+  // `Uint16Array`, `Float64Array`, …) and `DataView`. Without this
+  // branch they would fall through to the plain-object writer and
+  // canonicalize as `{"0":1,"1":2,...}`, which would silently collide
+  // with a same-keyed plain object. Tagging by constructor name keeps
+  // distinct view families distinct.
+  if (ArrayBuffer.isView(value)) {
+    const tag = value.constructor.name;
+    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    return `${tag}(${bytesToHex(bytes)})`;
+  }
+
+  if (seen.has(obj)) {
+    throw new TypeError('canonicalStringify: circular reference detected');
+  }
+  seen.add(obj);
+  try {
+    if (Array.isArray(value)) {
+      const parts = value.map((item) => write(item, seen));
+      return `[${parts.join(',')}]`;
+    }
+
+    return writePlainObject(obj as Record<string, unknown>, seen);
+  } finally {
+    seen.delete(obj);
+  }
+}
+
+function writeNumber(value: number): string {
+  if (Number.isNaN(value)) return 'NaN';
+  if (value === Number.POSITIVE_INFINITY) return 'Infinity';
+  if (value === Number.NEGATIVE_INFINITY) return '-Infinity';
+  // Distinguish `+0` from `-0` so they hash differently.
+  if (value === 0 && 1 / value === Number.NEGATIVE_INFINITY) return '-0';
+  return String(value);
+}
+
+function writePlainObject(obj: Record<string, unknown>, seen: Set<object>): string {
+  // Only true plain objects are accepted here. Without this guard, anything
+  // that fell through the type-tagged branches above (`Map`, `Set`,
+  // `RegExp`, class instances, …) would canonicalize to `{}` because
+  // `Object.keys` returns no enumerable string keys for them — silently
+  // colliding with each other and with the literal `{}`.
+  const proto = Object.getPrototypeOf(obj);
+  if (proto !== Object.prototype && proto !== null) {
+    const tag = proto?.constructor?.name ?? 'unknown';
+    throw new TypeError(`canonicalStringify: non-plain objects are not supported (got ${tag})`);
+  }
+
+  // `Object.keys` ignores symbol-keyed properties, so they would be
+  // silently dropped from the canonical form. Force callers to handle
+  // them explicitly instead of producing a key that omits real data.
+  if (Object.getOwnPropertySymbols(obj).length > 0) {
+    throw new TypeError(
+      'canonicalStringify: objects with symbol-keyed properties are not supported',
+    );
+  }
+
+  const keys = Object.keys(obj).sort();
+  const parts: string[] = [];
+  for (const key of keys) {
+    parts.push(`${JSON.stringify(key)}:${write(obj[key], seen)}`);
+  }
+  return `{${parts.join(',')}}`;
+}
+
+function bytesToHex(bytes: Uint8Array): string {
+  let out = '';
+  for (let i = 0; i < bytes.length; i++) {
+    const byte = bytes[i] as number;
+    out += byte.toString(16).padStart(2, '0');
+  }
+  return out;
+}

package/src/exports/canonical-stringify.ts

@@ -0,0 +1 @@
+export { canonicalStringify } from '../canonical-stringify';

package/src/exports/hash-content.ts

@@ -0,0 +1 @@
+export { hashContent } from '../hash-content';

package/src/hash-content.ts

@@ -0,0 +1,59 @@
+/**
+ * Hashes a canonical-string representation of an execution into a bounded,
+ * opaque cache-key digest.
+ *
+ * Designed for use as the final step of `RuntimeMiddlewareContext.contentHash`
+ * implementations: family runtimes compose a canonical string from
+ * `meta.storageHash`, the rendered statement (or wire command), and
+ * canonicalized parameters via `canonicalStringify`, then pipe the result
+ * through this helper.
+ *
+ * Why hash the canonical string instead of using it directly as a `Map` key:
+ *
+ * 1. **Bounded memory.** A raw canonical key includes concrete parameter
+ *    values, so a query bound to a 10 MB JSON column or binary blob produces
+ *    a 10 MB cache key. With `maxEntries = 1000`, that scales to gigabytes
+ *    of cache keys alone. SHA-512 pins per-key cost at a fixed digest
+ *    length regardless of input size.
+ *
+ * 2. **Sensitive-data isolation.** The canonical string contains parameter
+ *    values verbatim. Cache keys flow into debug logs, Redis `KEYS`/`MONITOR`
+ *    output, persistence dumps, monitoring tools, and any user-supplied
+ *    `CacheStore` implementation. Hashing prevents PII / credentials /
+ *    tokens that appear in query parameters from showing up in any of those
+ *    surfaces.
+ *
+ * Algorithm choice — SHA-512 (`SHA-512` via the WebCrypto API):
+ *
+ * - **Portability.** WebCrypto (`globalThis.crypto.subtle`) is available in
+ *   every modern JavaScript runtime — Node, Deno, Bun, browsers, edge
+ *   workers — without importing a Node-specific module. This keeps the
+ *   helper usable in non-Node hosts where `node:crypto` is not available.
+ * - **Collision space.** 512 bits of output makes accidental collisions
+ *   astronomically improbable — far beyond what a cache needs, but the
+ *   incremental cost over 256-bit output is negligible and the headroom
+ *   is free.
+ * - **No additional dependency.** SHA-512 is part of the WebCrypto standard
+ *   set of digest algorithms; no third-party package needed.
+ *
+ * The function is `async` because the WebCrypto digest API is async by
+ * design. Callers must await the result.
+ *
+ * Output format: `sha512:HEXDIGEST` (128-char hex with the algorithm tag
+ * prefix). Self-describing so a future migration to a different hash
+ * produces visibly distinct keys, and consistent with the
+ * `sha256:HEXDIGEST` shape already used by `meta.storageHash`.
+ *
+ * @example
+ * ```typescript
+ * const canonical = `${exec.meta.storageHash}|${exec.sql}|${canonicalStringify(exec.params)}`;
+ * return await hashContent(canonical);
+ * // → 'sha512:8f3...e1c' (always 135 chars: 'sha512:' + 128 hex chars)
+ * ```
+ */
+export async function hashContent(value: string): Promise<string> {
+  const bytes = new TextEncoder().encode(value);
+  const digest = await crypto.subtle.digest('SHA-512', bytes);
+  const hex = Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, '0')).join('');
+  return `sha512:${hex}`;
+}