@prisma-next/contract 0.11.0-dev.67 → 0.11.0-dev.69

package/src/validate-domain.ts

@@ -1,5 +1,7 @@
 import { ContractValidationError } from './contract-validation-error';
 import type { CrossReference } from './cross-reference';
+import type { ContractWithDomain } from './domain-envelope';
+import { asNamespaceId, type NamespaceId } from './namespace-id';
 
 export interface DomainModelShape {
   readonly fields: Record<string, unknown>;
@@ -10,23 +12,57 @@ export interface DomainModelShape {
   readonly owner?: string;
 }
 
-export interface DomainContractShape {
+export interface DomainContractShape extends ContractWithDomain {
   readonly roots: Record<string, CrossReference>;
-  readonly models: Record<string, DomainModelShape>;
-  readonly valueObjects?: Record<string, { readonly fields: Record<string, unknown> }>;
+}
+
+interface IndexedModel {
+  readonly namespaceId: NamespaceId;
+  readonly name: string;
+  readonly model: DomainModelShape;
+}
+
+type ModelIndex = Map<NamespaceId, Map<string, IndexedModel>>;
+
+function indexDomainModels(contract: DomainContractShape): ModelIndex {
+  const index: ModelIndex = new Map();
+  for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {
+    const namespaceId = asNamespaceId(namespaceKey);
+    let modelsInNamespace = index.get(namespaceId);
+    if (modelsInNamespace === undefined) {
+      modelsInNamespace = new Map();
+      index.set(namespaceId, modelsInNamespace);
+    }
+    for (const [name, model] of Object.entries(namespace.models)) {
+      modelsInNamespace.set(name, { namespaceId, name, model });
+    }
+  }
+  return index;
+}
+
+function lookupModel(index: ModelIndex, ref: CrossReference): IndexedModel | undefined {
+  return index.get(ref.namespace)?.get(ref.model);
+}
+
+function* iterateIndexedModels(index: ModelIndex): IterableIterator<IndexedModel> {
+  for (const modelsInNamespace of index.values()) {
+    for (const entry of modelsInNamespace.values()) {
+      yield entry;
+    }
+  }
 }
 
 export function validateContractDomain(contract: DomainContractShape): void {
   const errors: string[] = [];
-  const modelNames = new Set(Object.keys(contract.models));
+  const modelIndex = indexDomainModels(contract);
 
-  validateRoots(contract, modelNames, errors);
-  validateVariantsAndBases(contract, modelNames, errors);
-  validateRelationTargets(contract, modelNames, errors);
-  validateDiscriminators(contract, errors);
-  validateOwnership(contract, modelNames, errors);
+  validateRoots(contract, modelIndex, errors);
+  validateVariantsAndBases(modelIndex, errors);
+  validateRelationTargets(modelIndex, errors);
+  validateDiscriminators(modelIndex, errors);
+  validateOwnership(contract, modelIndex, errors);
   validateValueObjectReferences(contract, errors);
-  validateFieldModifiers(contract, errors);
+  validateFieldModifiers(modelIndex, contract, errors);
 
   if (errors.length > 0) {
     throw new ContractValidationError(
@@ -38,111 +74,104 @@ export function validateContractDomain(contract: DomainContractShape): void {
 
 function validateRoots(
   contract: DomainContractShape,
-  modelNames: Set<string>,
+  modelIndex: ModelIndex,
   errors: string[],
 ): void {
-  const seenValues = new Set<string>();
+  const seenRootTargets = new Map<NamespaceId, Set<string>>();
   for (const [rootKey, crossRef] of Object.entries(contract.roots)) {
-    const modelName = crossRef.model;
-    const dedupeKey = `${crossRef.namespace}:${modelName}`;
-    if (seenValues.has(dedupeKey)) {
-      errors.push(`Duplicate root value: "${modelName}" is mapped by multiple root keys`);
+    let modelsInNamespace = seenRootTargets.get(crossRef.namespace);
+    if (modelsInNamespace === undefined) {
+      modelsInNamespace = new Set();
+      seenRootTargets.set(crossRef.namespace, modelsInNamespace);
     }
-    seenValues.add(dedupeKey);
+    if (modelsInNamespace.has(crossRef.model)) {
+      errors.push(
+        `Duplicate root value: "${crossRef.namespace}:${crossRef.model}" is mapped by multiple root keys`,
+      );
+    }
+    modelsInNamespace.add(crossRef.model);
 
-    if (!modelNames.has(modelName)) {
+    if (!lookupModel(modelIndex, crossRef)) {
       errors.push(
-        `Root "${rootKey}" references model "${modelName}" which does not exist in models`,
+        `Root "${rootKey}" references model "${crossRef.namespace}:${crossRef.model}" which does not exist in domain.namespaces`,
       );
     }
   }
 }
 
-function validateVariantsAndBases(
-  contract: DomainContractShape,
-  modelNames: Set<string>,
-  errors: string[],
-): void {
-  const models = new Map(Object.entries(contract.models));
-
-  for (const [modelName, model] of models) {
+function validateVariantsAndBases(modelIndex: ModelIndex, errors: string[]): void {
+  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {
     if (model.variants) {
       for (const variantName of Object.keys(model.variants)) {
-        if (!modelNames.has(variantName)) {
+        const variantRef: CrossReference = { namespace: namespaceId, model: variantName };
+        const variantEntry = lookupModel(modelIndex, variantRef);
+        if (!variantEntry) {
           errors.push(
-            `Model "${modelName}" lists variant "${variantName}" which does not exist in models`,
+            `Model "${namespaceId}:${modelName}" lists variant "${variantName}" which does not exist at that namespace coordinate`,
           );
           continue;
         }
-        const variantModel = models.get(variantName);
-        if (!variantModel) continue;
-        if (variantModel.base?.model !== modelName) {
+        const variantBase = variantEntry.model.base;
+        if (variantBase?.namespace !== namespaceId || variantBase?.model !== modelName) {
           errors.push(
-            `Variant "${variantName}" has base "${variantModel.base?.model ?? '(none)'}" but expected "${modelName}"`,
+            `Variant "${namespaceId}:${variantName}" has base "${variantBase?.namespace ?? '?'}:${variantBase?.model ?? '(none)'}" but expected "${namespaceId}:${modelName}"`,
           );
         }
       }
     }
 
     if (model.base) {
-      const baseModelName = model.base.model;
-      if (!modelNames.has(baseModelName)) {
+      const baseEntry = lookupModel(modelIndex, model.base);
+      if (!baseEntry) {
         errors.push(
-          `Model "${modelName}" has base "${baseModelName}" which does not exist in models`,
+          `Model "${namespaceId}:${modelName}" has base "${model.base.namespace}:${model.base.model}" which does not exist in domain.namespaces`,
         );
         continue;
       }
-      const baseModel = models.get(baseModelName);
-      if (!baseModel) continue;
-      if (!baseModel.variants || !Object.hasOwn(baseModel.variants, modelName)) {
+      if (!baseEntry.model.variants || !Object.hasOwn(baseEntry.model.variants, modelName)) {
         errors.push(
-          `Model "${modelName}" has base "${baseModelName}" which does not list it as a variant`,
+          `Model "${namespaceId}:${modelName}" has base "${model.base.namespace}:${model.base.model}" which does not list it as a variant`,
         );
       }
     }
   }
 }
 
-function validateRelationTargets(
-  contract: DomainContractShape,
-  modelNames: Set<string>,
-  errors: string[],
-): void {
-  for (const [modelName, model] of Object.entries(contract.models)) {
+function validateRelationTargets(modelIndex: ModelIndex, errors: string[]): void {
+  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {
     for (const [relName, relation] of Object.entries(model.relations ?? {})) {
-      const targetModelName = relation.to.model;
-      if (!modelNames.has(targetModelName)) {
+      if (!lookupModel(modelIndex, relation.to)) {
         errors.push(
-          `Relation "${relName}" on model "${modelName}" targets "${targetModelName}" which does not exist in models`,
+          `Relation "${relName}" on model "${namespaceId}:${modelName}" targets "${relation.to.namespace}:${relation.to.model}" which does not exist in domain.namespaces`,
         );
       }
     }
   }
 }
 
-function validateDiscriminators(contract: DomainContractShape, errors: string[]): void {
-  for (const [modelName, model] of Object.entries(contract.models)) {
+function validateDiscriminators(modelIndex: ModelIndex, errors: string[]): void {
+  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {
     if (model.discriminator) {
       if (!model.variants || Object.keys(model.variants).length === 0) {
-        errors.push(`Model "${modelName}" has discriminator but no variants`);
+        errors.push(`Model "${namespaceId}:${modelName}" has discriminator but no variants`);
       }
       if (!Object.hasOwn(model.fields, model.discriminator.field)) {
         errors.push(
-          `Discriminator field "${model.discriminator.field}" is not a field on model "${modelName}"`,
+          `Discriminator field "${model.discriminator.field}" is not a field on model "${namespaceId}:${modelName}"`,
         );
       }
     }
 
     if (model.variants && Object.keys(model.variants).length > 0 && !model.discriminator) {
-      errors.push(`Model "${modelName}" has variants but no discriminator`);
+      errors.push(`Model "${namespaceId}:${modelName}" has variants but no discriminator`);
     }
 
     if (model.base) {
       if (model.discriminator) {
-        errors.push(`Model "${modelName}" has base and must not have discriminator`);
+        errors.push(`Model "${namespaceId}:${modelName}" has base and must not have discriminator`);
       }
       if (model.variants && Object.keys(model.variants).length > 0) {
-        errors.push(`Model "${modelName}" has base and must not have variants`);
+        errors.push(`Model "${namespaceId}:${modelName}" has base and must not have variants`);
       }
     }
   }
@@ -150,24 +179,27 @@ function validateDiscriminators(contract: DomainContractShape, errors: string[])
 
 function validateOwnership(
   contract: DomainContractShape,
-  modelNames: Set<string>,
+  modelIndex: ModelIndex,
   errors: string[],
 ): void {
-  for (const [modelName, model] of Object.entries(contract.models)) {
+  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {
     if (!model.owner) continue;
 
     if (model.owner === modelName) {
-      errors.push(`Model "${modelName}" cannot own itself`);
+      errors.push(`Model "${namespaceId}:${modelName}" cannot own itself`);
     }
 
-    if (!modelNames.has(model.owner)) {
-      errors.push(`Model "${modelName}" has owner "${model.owner}" which does not exist in models`);
+    const ownerRef: CrossReference = { namespace: namespaceId, model: model.owner };
+    if (!lookupModel(modelIndex, ownerRef)) {
+      errors.push(
+        `Model "${namespaceId}:${modelName}" has owner "${namespaceId}:${model.owner}" which does not exist in domain.namespaces`,
+      );
     }
 
     for (const [rootKey, rootRef] of Object.entries(contract.roots)) {
-      if (rootRef.model === modelName) {
+      if (rootRef.namespace === namespaceId && rootRef.model === modelName) {
         errors.push(
-          `Owned model "${modelName}" must not appear in roots (found as root "${rootKey}")`,
+          `Owned model "${namespaceId}:${modelName}" must not appear in roots (found as root "${rootKey}")`,
         );
       }
     }
@@ -186,49 +218,78 @@ interface FieldLike {
   readonly dict?: boolean;
 }
 
-function forEachContractField(
-  contract: DomainContractShape,
-  callback: (field: unknown, location: string) => void,
-): void {
-  for (const [modelName, model] of Object.entries(contract.models)) {
-    for (const [fieldName, field] of Object.entries(model.fields)) {
-      callback(field, `Model "${modelName}" field "${fieldName}"`);
-    }
-  }
-  for (const [voName, vo] of Object.entries(contract.valueObjects ?? {})) {
-    for (const [fieldName, field] of Object.entries(vo.fields)) {
-      callback(field, `Value object "${voName}" field "${fieldName}"`);
-    }
-  }
-}
-
 function validateValueObjectReferences(contract: DomainContractShape, errors: string[]): void {
-  const voNames = new Set(Object.keys(contract.valueObjects ?? {}));
+  const voNamesByNamespace = new Map<NamespaceId, Set<string>>();
+  for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {
+    const namespaceId = asNamespaceId(namespaceKey);
+    voNamesByNamespace.set(namespaceId, new Set(Object.keys(namespace.valueObjects ?? {})));
+  }
 
-  function checkType(type: FieldTypeLike | undefined, location: string): void {
+  function checkType(
+    type: FieldTypeLike | undefined,
+    location: string,
+    namespaceId: NamespaceId,
+  ): void {
     if (!type) return;
+    const voNames = voNamesByNamespace.get(namespaceId) ?? new Set<string>();
     if (type.kind === 'valueObject' && type.name && !voNames.has(type.name)) {
       errors.push(
-        `${location} references value object "${type.name}" which does not exist in valueObjects`,
+        `${location} references value object "${namespaceId}:${type.name}" which does not exist in that namespace's valueObjects`,
       );
       return;
     }
     if (type.kind === 'union') {
-      for (const member of type.members ?? []) checkType(member, location);
+      for (const member of type.members ?? []) checkType(member, location, namespaceId);
     }
   }
 
-  forEachContractField(contract, (field, location) => {
-    const f = field as FieldLike | undefined;
-    checkType(f?.type, location);
-  });
+  for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {
+    const namespaceId = asNamespaceId(namespaceKey);
+    for (const [modelName, model] of Object.entries(namespace.models)) {
+      for (const [fieldName, field] of Object.entries(model.fields)) {
+        const f = field as FieldLike | undefined;
+        checkType(f?.type, `Model "${namespaceId}:${modelName}" field "${fieldName}"`, namespaceId);
+      }
+    }
+    for (const [voName, vo] of Object.entries(namespace.valueObjects ?? {})) {
+      for (const [fieldName, field] of Object.entries(vo.fields)) {
+        const f = field as FieldLike | undefined;
+        checkType(
+          f?.type,
+          `Value object "${namespaceId}:${voName}" field "${fieldName}"`,
+          namespaceId,
+        );
+      }
+    }
+  }
 }
 
-function validateFieldModifiers(contract: DomainContractShape, errors: string[]): void {
-  forEachContractField(contract, (field, location) => {
-    const f = field as FieldLike | undefined;
-    if (f?.many && f?.dict) {
-      errors.push(`${location} cannot have both "many" and "dict" modifiers`);
+function validateFieldModifiers(
+  modelIndex: ModelIndex,
+  contract: DomainContractShape,
+  errors: string[],
+): void {
+  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {
+    for (const [fieldName, field] of Object.entries(model.fields)) {
+      const f = field as FieldLike | undefined;
+      if (f?.many && f?.dict) {
+        errors.push(
+          `Model "${namespaceId}:${modelName}" field "${fieldName}" cannot have both "many" and "dict" modifiers`,
+        );
+      }
     }
-  });
+  }
+  for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {
+    const namespaceId = asNamespaceId(namespaceKey);
+    for (const [voName, vo] of Object.entries(namespace.valueObjects ?? {})) {
+      for (const [fieldName, field] of Object.entries(vo.fields)) {
+        const f = field as FieldLike | undefined;
+        if (f?.many && f?.dict) {
+          errors.push(
+            `Value object "${namespaceId}:${voName}" field "${fieldName}" cannot have both "many" and "dict" modifiers`,
+          );
+        }
+      }
+    }
+  }
 }

package/dist/canonicalization-C3dTO0j1.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"canonicalization-C3dTO0j1.d.mts","names":[],"sources":["../src/canonicalization.ts"],"mappings":";;;;;;AAcA;;;;;;KAAY,iBAAA,IAAqB,QAAA,EAAU,QAAA,KAAa,UAAU;;AAAA;AAUlE;;;;AAA6D;AAS7D;KATY,sBAAA,IAA0B,IAAuB;;;AASlB;AA2J3C;;;;KA3JY,WAAA,IAAe,OAAgB;AAAA,UA2J1B,2BAAA;EAAA,SACN,aAAA;EAAA;;;;;;;;AA0ByB;AAQpC;EAlCW,SAWA,iBAAA,EAAmB,iBAAA;;;;;;;WAOnB,mBAAA,GAAsB,sBAAA;EAiB/B;;;;;AAEO;AA4BT;EA9BE,SATS,WAAA,GAAc,WAAA;AAAA;;;;;;iBAQT,4BAAA,CACd,QAAA,EAAU,QAAA,EACV,OAAA,EAAS,2BAAA,GACR,MAAA;AAAA,iBA4Ba,oBAAA,CACd,QAAA,EAAU,QAAA,EACV,OAAA,EAAS,2BAA2B"}

package/dist/contract-types-CZPm4Ooy.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract-types-CZPm4Ooy.d.mts","names":[],"sources":["../src/domain-types.ts","../src/types.ts","../src/contract-types.ts"],"mappings":"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"}

package/dist/contract-validation-error-Dp2vHZt5.mjs

@@ -1,14 +0,0 @@
-//#region src/contract-validation-error.ts
-var ContractValidationError = class extends Error {
-	code = "CONTRACT.VALIDATION_FAILED";
-	phase;
-	constructor(message, phase) {
-		super(message);
-		this.name = "ContractValidationError";
-		this.phase = phase;
-	}
-};
-//#endregion
-export { ContractValidationError as t };
-
-//# sourceMappingURL=contract-validation-error-Dp2vHZt5.mjs.map

package/dist/contract-validation-error-Dp2vHZt5.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract-validation-error-Dp2vHZt5.mjs","names":[],"sources":["../src/contract-validation-error.ts"],"sourcesContent":["export type ContractValidationPhase = 'structural' | 'domain' | 'storage';\n\nexport class ContractValidationError extends Error {\n  readonly code = 'CONTRACT.VALIDATION_FAILED';\n  readonly phase: ContractValidationPhase;\n\n  constructor(message: string, phase: ContractValidationPhase) {\n    super(message);\n    this.name = 'ContractValidationError';\n    this.phase = phase;\n  }\n}\n"],"mappings":";AAEA,IAAa,0BAAb,cAA6C,MAAM;CACjD,OAAgB;CAChB;CAEA,YAAY,SAAiB,OAAgC;EAC3D,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,QAAQ;CACf;AACF"}

package/dist/contract-validation-error.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract-validation-error.d.mts","names":[],"sources":["../src/contract-validation-error.ts"],"mappings":";KAAY,uBAAA;AAAA,cAEC,uBAAA,SAAgC,KAAA;EAAA,SAClC,IAAA;EAAA,SACA,KAAA,EAAO,uBAAA;cAEJ,OAAA,UAAiB,KAAA,EAAO,uBAAA;AAAA"}

package/dist/cross-reference-t0TDbBTP.d.mts

@@ -1,18 +0,0 @@
-import * as _$arktype_internal_variants_object_ts0 from "arktype/internal/variants/object.ts";
-
-//#region src/namespace-id.d.ts
-type NamespaceId = string & {
-  readonly __brand: 'NamespaceId';
-};
-declare function asNamespaceId(value: string): NamespaceId;
-//#endregion
-//#region src/cross-reference.d.ts
-interface CrossReference {
-  readonly namespace: NamespaceId;
-  readonly model: string;
-}
-declare const CrossReferenceSchema: _$arktype_internal_variants_object_ts0.ObjectType<CrossReference, {}>;
-declare function crossRef(model: string, namespace?: string): CrossReference;
-//#endregion
-export { asNamespaceId as a, NamespaceId as i, CrossReferenceSchema as n, crossRef as r, CrossReference as t };
-//# sourceMappingURL=cross-reference-t0TDbBTP.d.mts.map

package/dist/cross-reference-t0TDbBTP.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cross-reference-t0TDbBTP.d.mts","names":[],"sources":["../src/namespace-id.ts","../src/cross-reference.ts"],"mappings":";;;KAEY,WAAA;EAAA,SAAkC,OAAO;AAAA;AAAA,iBAErC,aAAA,CAAc,KAAA,WAAgB,WAAW;;;UCAxC,cAAA;EAAA,SACN,SAAA,EAAW,WAAW;EAAA,SACtB,KAAA;AAAA;AAAA,cAGE,oBAAA,EAAoB,sCAAA,CAAA,UAAA,CAAA,cAAA;AAAA,iBAajB,QAAA,CACd,KAAA,UACA,SAAA,YACC,cAAc"}

package/dist/hashing-C25nwocN.mjs

@@ -1,151 +0,0 @@
-import { isArrayEqual } from "@prisma-next/utils/array-equal";
-import { ifDefined } from "@prisma-next/utils/defined";
-import { createHash } from "node:crypto";
-//#region src/canonicalization.ts
-const TOP_LEVEL_ORDER = [
-	"schemaVersion",
-	"canonicalVersion",
-	"targetFamily",
-	"target",
-	"profileHash",
-	"roots",
-	"models",
-	"valueObjects",
-	"domain",
-	"storage",
-	"execution",
-	"capabilities",
-	"extensionPacks",
-	"meta"
-];
-function isDefaultValue(value) {
-	if (value === false) return true;
-	if (value === null) return false;
-	if (Array.isArray(value) && value.length === 0) return true;
-	if (typeof value === "object" && value !== null) return Object.keys(value).length === 0;
-	return false;
-}
-function omitDefaults(obj, path, shouldPreserveEmpty) {
-	if (obj === null || typeof obj !== "object") return obj;
-	if (Array.isArray(obj)) return obj.map((item) => omitDefaults(item, path, shouldPreserveEmpty));
-	const result = {};
-	for (const [key, value] of Object.entries(obj)) {
-		const currentPath = [...path, key];
-		if (key === "_generated") continue;
-		if (key === "generated" && value === false) continue;
-		if ((key === "onDelete" || key === "onUpdate") && value === "noAction") continue;
-		if (isDefaultValue(value)) {
-			const isRequiredModels = isArrayEqual(currentPath, ["models"]);
-			const isRequiredNamespaces = isArrayEqual(currentPath, ["storage", "namespaces"]);
-			const isNamespaceSlot = currentPath.length === 3 && isArrayEqual([currentPath[0], currentPath[1]], ["storage", "namespaces"]);
-			const isRequiredRoots = isArrayEqual(currentPath, ["roots"]);
-			const isRequiredExtensionPacks = isArrayEqual(currentPath, ["extensionPacks"]);
-			const isRequiredCapabilities = isArrayEqual(currentPath, ["capabilities"]);
-			const isRequiredMeta = isArrayEqual(currentPath, ["meta"]);
-			const isRequiredExecutionDefaults = isArrayEqual(currentPath, [
-				"execution",
-				"mutations",
-				"defaults"
-			]);
-			const isExtensionNamespace = currentPath.length === 2 && currentPath[0] === "extensionPacks";
-			const isModelRelations = currentPath.length === 3 && isArrayEqual([currentPath[0], currentPath[2]], ["models", "relations"]);
-			const isModelStorage = currentPath.length === 3 && isArrayEqual([currentPath[0], currentPath[2]], ["models", "storage"]);
-			const isDomainUnboundTypeParams = currentPath.length === 5 && currentPath[0] === "domain" && currentPath[2] === "types" && key === "typeParams";
-			const isNullableField = key === "nullable";
-			const isFamilyPreserved = shouldPreserveEmpty?.(currentPath) ?? false;
-			if (!isRequiredModels && !isRequiredNamespaces && !isNamespaceSlot && !isRequiredRoots && !isRequiredExtensionPacks && !isRequiredCapabilities && !isRequiredMeta && !isRequiredExecutionDefaults && !isExtensionNamespace && !isModelRelations && !isModelStorage && !isNullableField && !isDomainUnboundTypeParams && !isFamilyPreserved) continue;
-		}
-		result[key] = omitDefaults(value, currentPath, shouldPreserveEmpty);
-	}
-	return result;
-}
-function sortObjectKeys(obj) {
-	if (obj === null || typeof obj !== "object") return obj;
-	if (Array.isArray(obj)) return obj.map((item) => sortObjectKeys(item));
-	const sorted = {};
-	const keys = Object.keys(obj).sort();
-	for (const key of keys) sorted[key] = sortObjectKeys(obj[key]);
-	return sorted;
-}
-function orderTopLevel(obj) {
-	const ordered = {};
-	const remaining = new Set(Object.keys(obj));
-	for (const key of TOP_LEVEL_ORDER) if (remaining.has(key)) {
-		ordered[key] = obj[key];
-		remaining.delete(key);
-	}
-	for (const key of Array.from(remaining).sort()) ordered[key] = obj[key];
-	return ordered;
-}
-/**
-* Object-form variant of {@link canonicalizeContract}. Exported because the
-* emitter writes the canonical contract through a separate JSON-stringify
-* pass and consumes the structured object directly.
-*/
-function canonicalizeContractToObject(contract, options) {
-	const serialized = options.serializeContract(contract);
-	const withDefaultsOmitted = omitDefaults({
-		...ifDefined("schemaVersion", options.schemaVersion),
-		targetFamily: serialized["targetFamily"],
-		target: serialized["target"],
-		profileHash: serialized["profileHash"],
-		roots: serialized["roots"],
-		models: serialized["models"],
-		...ifDefined("valueObjects", serialized["valueObjects"]),
-		...ifDefined("domain", serialized["domain"]),
-		storage: serialized["storage"],
-		...ifDefined("execution", serialized["execution"]),
-		extensionPacks: serialized["extensionPacks"],
-		capabilities: serialized["capabilities"],
-		meta: serialized["meta"]
-	}, [], options.shouldPreserveEmpty);
-	return orderTopLevel(sortObjectKeys(options.sortStorage ? {
-		...withDefaultsOmitted,
-		storage: options.sortStorage(withDefaultsOmitted["storage"])
-	} : withDefaultsOmitted));
-}
-function canonicalizeContract(contract, options) {
-	return JSON.stringify(canonicalizeContractToObject(contract, options), null, 2);
-}
-//#endregion
-//#region src/hashing.ts
-const SCHEMA_VERSION = "1";
-function sha256(content) {
-	const hash = createHash("sha256");
-	hash.update(content);
-	return `sha256:${hash.digest("hex")}`;
-}
-function hashContract(section) {
-	const { shouldPreserveEmpty, sortStorage, ...sectionData } = section;
-	return canonicalizeContract({
-		targetFamily: sectionData["targetFamily"],
-		target: sectionData["target"],
-		roots: {},
-		models: {},
-		storage: sectionData["storage"] ?? {},
-		execution: sectionData["execution"],
-		extensionPacks: {},
-		capabilities: sectionData["capabilities"] ?? {},
-		meta: {},
-		profileHash: "",
-		...sectionData
-	}, {
-		schemaVersion: SCHEMA_VERSION,
-		serializeContract: (c) => JSON.parse(JSON.stringify(c)),
-		...ifDefined("shouldPreserveEmpty", shouldPreserveEmpty),
-		...ifDefined("sortStorage", sortStorage)
-	});
-}
-function computeStorageHash(args) {
-	return sha256(hashContract(args));
-}
-function computeExecutionHash(args) {
-	return sha256(hashContract(args));
-}
-function computeProfileHash(args) {
-	return sha256(hashContract(args));
-}
-//#endregion
-export { canonicalizeContractToObject as a, canonicalizeContract as i, computeProfileHash as n, computeStorageHash as r, computeExecutionHash as t };
-
-//# sourceMappingURL=hashing-C25nwocN.mjs.map

package/dist/hashing-C25nwocN.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"hashing-C25nwocN.mjs","names":[],"sources":["../src/canonicalization.ts","../src/hashing.ts"],"sourcesContent":["import { isArrayEqual } from '@prisma-next/utils/array-equal';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { JsonObject } from '@prisma-next/utils/json';\n\nimport type { Contract } from './contract-types';\n\n/**\n * Per-target contract serializer hook. The framework canonicalizer uses\n * this to convert an in-memory contract (which may carry class-instance\n * IR nodes whose runtime-only fields must not appear in the on-disk\n * envelope) into a plain JsonObject before applying the family-agnostic\n * canonical-key ordering / default-omission / sort steps. Targets whose\n * contract is JSON-clean by construction return the contract unchanged.\n */\nexport type SerializeContract = (contract: Contract) => JsonObject;\n\n/**\n * Family-contributed predicate for the default-omission walk. Called when\n * a value at `path` is a default (empty object/array or `false`); if this\n * returns `true` the value is kept rather than stripped.\n *\n * The framework only calls the predicate inside the `isDefaultValue` branch,\n * so there is no need to guard against non-default values.\n */\nexport type PreserveEmptyPredicate = (path: readonly string[]) => boolean;\n\n/**\n * Family-contributed storage sort. Applied to the serialized `storage`\n * subtree after the default-omission walk; the result replaces the\n * `storage` field before the final key sort. Use to establish a\n * deterministic order for storage arrays (indexes, uniques) that the\n * family-agnostic `sortObjectKeys` pass cannot handle.\n */\nexport type StorageSort = (storage: unknown) => unknown;\n\nconst TOP_LEVEL_ORDER = [\n  'schemaVersion',\n  'canonicalVersion',\n  'targetFamily',\n  'target',\n  'profileHash',\n  'roots',\n  'models',\n  'valueObjects',\n  'domain',\n  'storage',\n  'execution',\n  'capabilities',\n  'extensionPacks',\n  'meta',\n] as const;\n\nfunction isDefaultValue(value: unknown): boolean {\n  if (value === false) return true;\n  if (value === null) return false;\n  if (Array.isArray(value) && value.length === 0) return true;\n  if (typeof value === 'object' && value !== null) {\n    const keys = Object.keys(value);\n    return keys.length === 0;\n  }\n  return false;\n}\n\nfunction omitDefaults(\n  obj: unknown,\n  path: readonly string[],\n  shouldPreserveEmpty: PreserveEmptyPredicate | undefined,\n): unknown {\n  if (obj === null || typeof obj !== 'object') {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map((item) => omitDefaults(item, path, shouldPreserveEmpty));\n  }\n\n  const result: Record<string, unknown> = {};\n\n  for (const [key, value] of Object.entries(obj)) {\n    const currentPath = [...path, key];\n\n    if (key === '_generated') {\n      continue;\n    }\n\n    if (key === 'generated' && value === false) {\n      continue;\n    }\n\n    if ((key === 'onDelete' || key === 'onUpdate') && value === 'noAction') {\n      continue;\n    }\n\n    if (isDefaultValue(value)) {\n      const isRequiredModels = isArrayEqual(currentPath, ['models']);\n      const isRequiredNamespaces = isArrayEqual(currentPath, ['storage', 'namespaces']);\n      const isNamespaceSlot =\n        currentPath.length === 3 &&\n        isArrayEqual([currentPath[0], currentPath[1]], ['storage', 'namespaces']);\n      const isRequiredRoots = isArrayEqual(currentPath, ['roots']);\n      const isRequiredExtensionPacks = isArrayEqual(currentPath, ['extensionPacks']);\n      const isRequiredCapabilities = isArrayEqual(currentPath, ['capabilities']);\n      const isRequiredMeta = isArrayEqual(currentPath, ['meta']);\n      const isRequiredExecutionDefaults = isArrayEqual(currentPath, [\n        'execution',\n        'mutations',\n        'defaults',\n      ]);\n      const isExtensionNamespace = currentPath.length === 2 && currentPath[0] === 'extensionPacks';\n      const isModelRelations =\n        currentPath.length === 3 &&\n        isArrayEqual([currentPath[0], currentPath[2]], ['models', 'relations']);\n      const isModelStorage =\n        currentPath.length === 3 &&\n        isArrayEqual([currentPath[0], currentPath[2]], ['models', 'storage']);\n\n      const isDomainUnboundTypeParams =\n        currentPath.length === 5 &&\n        currentPath[0] === 'domain' &&\n        currentPath[2] === 'types' &&\n        key === 'typeParams';\n\n      const isNullableField = key === 'nullable';\n\n      const isFamilyPreserved = shouldPreserveEmpty?.(currentPath) ?? false;\n\n      if (\n        !isRequiredModels &&\n        !isRequiredNamespaces &&\n        !isNamespaceSlot &&\n        !isRequiredRoots &&\n        !isRequiredExtensionPacks &&\n        !isRequiredCapabilities &&\n        !isRequiredMeta &&\n        !isRequiredExecutionDefaults &&\n        !isExtensionNamespace &&\n        !isModelRelations &&\n        !isModelStorage &&\n        !isNullableField &&\n        !isDomainUnboundTypeParams &&\n        !isFamilyPreserved\n      ) {\n        continue;\n      }\n    }\n\n    result[key] = omitDefaults(value, currentPath, shouldPreserveEmpty);\n  }\n\n  return result;\n}\n\nfunction sortObjectKeys(obj: unknown): unknown {\n  if (obj === null || typeof obj !== 'object') {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map((item) => sortObjectKeys(item));\n  }\n\n  const sorted: Record<string, unknown> = {};\n  const keys = Object.keys(obj).sort();\n  for (const key of keys) {\n    sorted[key] = sortObjectKeys((obj as Record<string, unknown>)[key]);\n  }\n\n  return sorted;\n}\n\nexport function orderTopLevel(obj: Record<string, unknown>): Record<string, unknown> {\n  const ordered: Record<string, unknown> = {};\n  const remaining = new Set(Object.keys(obj));\n\n  for (const key of TOP_LEVEL_ORDER) {\n    if (remaining.has(key)) {\n      ordered[key] = obj[key];\n      remaining.delete(key);\n    }\n  }\n\n  for (const key of Array.from(remaining).sort()) {\n    ordered[key] = obj[key];\n  }\n\n  return ordered;\n}\n\nexport interface CanonicalizeContractOptions {\n  readonly schemaVersion?: string;\n  /**\n   * Per-target hook that converts the in-memory contract (which may\n   * carry class-instance IR nodes) into a plain JsonObject before the\n   * family-agnostic canonicalization steps run.\n   *\n   * Routing through the hook is what lets each target decide which\n   * fields appear in the on-disk envelope; runtime-only class API\n   * fields stay invisible to the canonicalization walk by virtue of\n   * the per-target serializer not putting them in the JSON shape.\n   */\n  readonly serializeContract: SerializeContract;\n  /**\n   * Family-contributed preserve-empty predicate. When the walk encounters a\n   * default value (empty object/array or `false`) at `path`, calling this\n   * with the full path allows the family to veto the omission. If absent,\n   * only the framework's family-agnostic required-slot rules apply.\n   */\n  readonly shouldPreserveEmpty?: PreserveEmptyPredicate;\n  /**\n   * Family-contributed storage sort. Applied to the serialized `storage`\n   * subtree after the default-omission walk, before the final key sort.\n   * SQL family uses this to impose a deterministic order on `indexes` and\n   * `uniques` arrays within each namespace table. Families that require no\n   * special storage ordering omit this hook.\n   */\n  readonly sortStorage?: StorageSort;\n}\n\n/**\n * Object-form variant of {@link canonicalizeContract}. Exported because the\n * emitter writes the canonical contract through a separate JSON-stringify\n * pass and consumes the structured object directly.\n */\nexport function canonicalizeContractToObject(\n  contract: Contract,\n  options: CanonicalizeContractOptions,\n): Record<string, unknown> {\n  const serialized = options.serializeContract(contract);\n  const normalized: Record<string, unknown> = {\n    ...ifDefined('schemaVersion', options.schemaVersion),\n    targetFamily: serialized['targetFamily'],\n    target: serialized['target'],\n    profileHash: serialized['profileHash'],\n    roots: serialized['roots'],\n    models: serialized['models'],\n    ...ifDefined('valueObjects', serialized['valueObjects']),\n    ...ifDefined('domain', serialized['domain']),\n    storage: serialized['storage'],\n    ...ifDefined('execution', serialized['execution']),\n    extensionPacks: serialized['extensionPacks'],\n    capabilities: serialized['capabilities'],\n    meta: serialized['meta'],\n  };\n  const withDefaultsOmitted = omitDefaults(normalized, [], options.shouldPreserveEmpty) as Record<\n    string,\n    unknown\n  >;\n  const withSortedStorage = options.sortStorage\n    ? { ...withDefaultsOmitted, storage: options.sortStorage(withDefaultsOmitted['storage']) }\n    : withDefaultsOmitted;\n  const withSortedKeys = sortObjectKeys(withSortedStorage) as Record<string, unknown>;\n  return orderTopLevel(withSortedKeys);\n}\n\nexport function canonicalizeContract(\n  contract: Contract,\n  options: CanonicalizeContractOptions,\n): string {\n  return JSON.stringify(canonicalizeContractToObject(contract, options), null, 2);\n}\n","import { createHash } from 'node:crypto';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { JsonObject } from '@prisma-next/utils/json';\nimport {\n  canonicalizeContract,\n  type PreserveEmptyPredicate,\n  type StorageSort,\n} from './canonicalization';\nimport type { Contract } from './contract-types';\nimport type { ExecutionHashBase, ProfileHashBase, StorageHashBase } from './types';\n\nconst SCHEMA_VERSION = '1';\n\nfunction sha256(content: string): string {\n  const hash = createHash('sha256');\n  hash.update(content);\n  return `sha256:${hash.digest('hex')}`;\n}\n\ntype HashContractSection = Record<string, unknown> & {\n  readonly shouldPreserveEmpty?: PreserveEmptyPredicate;\n  readonly sortStorage?: StorageSort;\n};\n\nfunction hashContract(section: HashContractSection): string {\n  const { shouldPreserveEmpty, sortStorage, ...sectionData } = section;\n  // Blind cast: the synthesised object is a hash-only stand-in\n  // — never returned to callers, never executed as a Contract.\n  // `canonicalizeContract` only walks the storage / execution /\n  // capabilities slices, all of which are populated above, so the\n  // missing precise Contract typing on the other slots is\n  // immaterial for the hash result.\n  const contract = {\n    targetFamily: sectionData['targetFamily'],\n    target: sectionData['target'],\n    roots: {},\n    models: {},\n    storage: sectionData['storage'] ?? {},\n    execution: sectionData['execution'],\n    extensionPacks: {},\n    capabilities: sectionData['capabilities'] ?? {},\n    meta: {},\n    profileHash: '',\n    ...sectionData,\n  } as unknown as Contract;\n  return canonicalizeContract(contract, {\n    schemaVersion: SCHEMA_VERSION,\n    serializeContract: (c) => JSON.parse(JSON.stringify(c)) as JsonObject,\n    ...ifDefined('shouldPreserveEmpty', shouldPreserveEmpty),\n    ...ifDefined('sortStorage', sortStorage),\n  });\n}\n\nexport type ComputeStorageHashArgs = {\n  target: string;\n  targetFamily: string;\n  storage: Record<string, unknown>;\n  readonly shouldPreserveEmpty?: PreserveEmptyPredicate;\n  readonly sortStorage?: StorageSort;\n};\n\nexport function computeStorageHash(args: ComputeStorageHashArgs): StorageHashBase<string> {\n  return sha256(hashContract(args)) as StorageHashBase<string>;\n}\n\nexport function computeExecutionHash(args: {\n  target: string;\n  targetFamily: string;\n  execution: Record<string, unknown>;\n}): ExecutionHashBase<string> {\n  return sha256(hashContract(args)) as ExecutionHashBase<string>;\n}\n\nexport function computeProfileHash(args: {\n  target: string;\n  targetFamily: string;\n  capabilities: Record<string, Record<string, boolean>>;\n}): ProfileHashBase<string> {\n  return sha256(hashContract(args)) as ProfileHashBase<string>;\n}\n"],"mappings":"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"}