@prisma-next/contract 0.11.0-dev.5 → 0.11.0-dev.50

package/src/canonicalization.ts

@@ -14,6 +14,25 @@ import type { Contract } from './contract-types';
  */
 export type SerializeContract = (contract: Contract) => JsonObject;
 
+/**
+ * Family-contributed predicate for the default-omission walk. Called when
+ * a value at `path` is a default (empty object/array or `false`); if this
+ * returns `true` the value is kept rather than stripped.
+ *
+ * The framework only calls the predicate inside the `isDefaultValue` branch,
+ * so there is no need to guard against non-default values.
+ */
+export type PreserveEmptyPredicate = (path: readonly string[]) => boolean;
+
+/**
+ * Family-contributed storage sort. Applied to the serialized `storage`
+ * subtree after the default-omission walk; the result replaces the
+ * `storage` field before the final key sort. Use to establish a
+ * deterministic order for storage arrays (indexes, uniques) that the
+ * family-agnostic `sortObjectKeys` pass cannot handle.
+ */
+export type StorageSort = (storage: unknown) => unknown;
+
 const TOP_LEVEL_ORDER = [
   'schemaVersion',
   'canonicalVersion',
@@ -42,13 +61,17 @@ function isDefaultValue(value: unknown): boolean {
   return false;
 }
 
-function omitDefaults(obj: unknown, path: readonly string[]): unknown {
+function omitDefaults(
+  obj: unknown,
+  path: readonly string[],
+  shouldPreserveEmpty: PreserveEmptyPredicate | undefined,
+): unknown {
   if (obj === null || typeof obj !== 'object') {
     return obj;
   }
 
   if (Array.isArray(obj)) {
-    return obj.map((item) => omitDefaults(item, path));
+    return obj.map((item) => omitDefaults(item, path, shouldPreserveEmpty));
   }
 
   const result: Record<string, unknown> = {};
@@ -74,20 +97,6 @@ function omitDefaults(obj: unknown, path: readonly string[]): unknown {
       const isNamespaceSlot =
         currentPath.length === 3 &&
         isArrayEqual([currentPath[0], currentPath[1]], ['storage', 'namespaces']);
-      const isRequiredNamespaceTables =
-        currentPath.length === 4 &&
-        currentPath[0] === 'storage' &&
-        currentPath[1] === 'namespaces' &&
-        currentPath[3] === 'tables';
-      // Preserve per-table payloads even when empty. SQL tables are never
-      // emitted empty; Mongo collections legitimately are (a declared
-      // collection with no schema is a valid representation), and the
-      // family-agnostic canonicalizer must not strip them.
-      const isNamespaceTableEntry =
-        currentPath.length === 5 &&
-        currentPath[0] === 'storage' &&
-        currentPath[1] === 'namespaces' &&
-        currentPath[3] === 'tables';
       const isRequiredRoots = isArrayEqual(currentPath, ['roots']);
       const isRequiredExtensionPacks = isArrayEqual(currentPath, ['extensionPacks']);
       const isRequiredCapabilities = isArrayEqual(currentPath, ['capabilities']);
@@ -104,50 +113,21 @@ function omitDefaults(obj: unknown, path: readonly string[]): unknown {
       const isModelStorage =
         currentPath.length === 3 &&
         isArrayEqual([currentPath[0], currentPath[2]], ['models', 'storage']);
-      const isNamespaceTableUniques =
-        currentPath.length === 6 &&
-        currentPath[0] === 'storage' &&
-        currentPath[1] === 'namespaces' &&
-        currentPath[3] === 'tables' &&
-        currentPath[5] === 'uniques';
-      const isNamespaceTableIndexes =
-        currentPath.length === 6 &&
-        currentPath[0] === 'storage' &&
-        currentPath[1] === 'namespaces' &&
-        currentPath[3] === 'tables' &&
-        currentPath[5] === 'indexes';
-      const isNamespaceTableForeignKeys =
-        currentPath.length === 6 &&
-        currentPath[0] === 'storage' &&
-        currentPath[1] === 'namespaces' &&
-        currentPath[3] === 'tables' &&
-        currentPath[5] === 'foreignKeys';
 
-      // `storage.types.<name>.typeParams` is part of the StorageTypeInstance
-      // shape (validators require it). Preserve it even when empty so the
-      // emitted contract.json remains structurally valid after a round-trip.
-      const isStorageTypeTypeParams =
-        currentPath.length === 4 &&
-        currentPath[0] === 'storage' &&
-        currentPath[1] === 'types' &&
+      const isDomainUnboundTypeParams =
+        currentPath.length === 5 &&
+        currentPath[0] === 'domain' &&
+        currentPath[2] === 'types' &&
         key === 'typeParams';
 
-      const isFkBooleanField =
-        currentPath.length === 7 &&
-        currentPath[0] === 'storage' &&
-        currentPath[1] === 'namespaces' &&
-        currentPath[3] === 'tables' &&
-        currentPath[5] === 'foreignKeys' &&
-        (key === 'constraint' || key === 'index');
-
       const isNullableField = key === 'nullable';
 
+      const isFamilyPreserved = shouldPreserveEmpty?.(currentPath) ?? false;
+
       if (
         !isRequiredModels &&
         !isRequiredNamespaces &&
         !isNamespaceSlot &&
-        !isRequiredNamespaceTables &&
-        !isNamespaceTableEntry &&
         !isRequiredRoots &&
         !isRequiredExtensionPacks &&
         !isRequiredCapabilities &&
@@ -156,18 +136,15 @@ function omitDefaults(obj: unknown, path: readonly string[]): unknown {
         !isExtensionNamespace &&
         !isModelRelations &&
         !isModelStorage &&
-        !isNamespaceTableUniques &&
-        !isNamespaceTableIndexes &&
-        !isNamespaceTableForeignKeys &&
-        !isFkBooleanField &&
         !isNullableField &&
-        !isStorageTypeTypeParams
+        !isDomainUnboundTypeParams &&
+        !isFamilyPreserved
       ) {
         continue;
       }
     }
 
-    result[key] = omitDefaults(value, currentPath);
+    result[key] = omitDefaults(value, currentPath, shouldPreserveEmpty);
   }
 
   return result;
@@ -191,88 +168,6 @@ function sortObjectKeys(obj: unknown): unknown {
   return sorted;
 }
 
-type NamespaceObject = {
-  tables?: Record<string, unknown>;
-  [key: string]: unknown;
-};
-
-type StorageObject = {
-  namespaces?: Record<string, unknown>;
-  [key: string]: unknown;
-};
-
-type TableObject = {
-  indexes?: unknown[];
-  uniques?: unknown[];
-  [key: string]: unknown;
-};
-
-function sortTableArrays(tableObj: TableObject): TableObject {
-  const sortedTable: TableObject = { ...tableObj };
-
-  if (Array.isArray(tableObj.indexes)) {
-    sortedTable.indexes = [...tableObj.indexes].sort((a, b) => {
-      const nameA = (a as { name?: string })?.name || '';
-      const nameB = (b as { name?: string })?.name || '';
-      return nameA.localeCompare(nameB);
-    });
-  }
-
-  if (Array.isArray(tableObj.uniques)) {
-    sortedTable.uniques = [...tableObj.uniques].sort((a, b) => {
-      const nameA = (a as { name?: string })?.name || '';
-      const nameB = (b as { name?: string })?.name || '';
-      return nameA.localeCompare(nameB);
-    });
-  }
-
-  return sortedTable;
-}
-
-function sortIndexesAndUniques(storage: unknown): unknown {
-  if (!storage || typeof storage !== 'object') {
-    return storage;
-  }
-
-  const storageObj = storage as StorageObject;
-  if (!storageObj.namespaces || typeof storageObj.namespaces !== 'object') {
-    return storage;
-  }
-
-  const namespaces = storageObj.namespaces;
-  const result: StorageObject = { ...storageObj, namespaces: {} };
-  const resultNamespaces = result.namespaces as Record<string, unknown>;
-
-  for (const nsId of Object.keys(namespaces)) {
-    const ns = namespaces[nsId];
-    if (!ns || typeof ns !== 'object') {
-      resultNamespaces[nsId] = ns;
-      continue;
-    }
-
-    const nsObj = ns as NamespaceObject;
-    if (!nsObj.tables || typeof nsObj.tables !== 'object') {
-      resultNamespaces[nsId] = ns;
-      continue;
-    }
-
-    const sortedTables: Record<string, unknown> = {};
-    const sortedTableNames = Object.keys(nsObj.tables).sort();
-    for (const tableName of sortedTableNames) {
-      const table = nsObj.tables[tableName];
-      if (!table || typeof table !== 'object') {
-        sortedTables[tableName] = table;
-        continue;
-      }
-      sortedTables[tableName] = sortTableArrays(table as TableObject);
-    }
-
-    resultNamespaces[nsId] = { ...nsObj, tables: sortedTables };
-  }
-
-  return result;
-}
-
 export function orderTopLevel(obj: Record<string, unknown>): Record<string, unknown> {
   const ordered: Record<string, unknown> = {};
   const remaining = new Set(Object.keys(obj));
@@ -304,6 +199,21 @@ export interface CanonicalizeContractOptions {
    * the per-target serializer not putting them in the JSON shape.
    */
   readonly serializeContract: SerializeContract;
+  /**
+   * Family-contributed preserve-empty predicate. When the walk encounters a
+   * default value (empty object/array or `false`) at `path`, calling this
+   * with the full path allows the family to veto the omission. If absent,
+   * only the framework's family-agnostic required-slot rules apply.
+   */
+  readonly shouldPreserveEmpty?: PreserveEmptyPredicate;
+  /**
+   * Family-contributed storage sort. Applied to the serialized `storage`
+   * subtree after the default-omission walk, before the final key sort.
+   * SQL family uses this to impose a deterministic order on `indexes` and
+   * `uniques` arrays within each namespace table. Families that require no
+   * special storage ordering omit this hook.
+   */
+  readonly sortStorage?: StorageSort;
 }
 
 /**
@@ -324,15 +234,20 @@ export function canonicalizeContractToObject(
     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'],
   };
-  const withDefaultsOmitted = omitDefaults(normalized, []) as Record<string, unknown>;
-  const withSortedIndexes = sortIndexesAndUniques(withDefaultsOmitted['storage']);
-  const withSortedStorage = { ...withDefaultsOmitted, storage: withSortedIndexes };
+  const withDefaultsOmitted = omitDefaults(normalized, [], options.shouldPreserveEmpty) as Record<
+    string,
+    unknown
+  >;
+  const withSortedStorage = options.sortStorage
+    ? { ...withDefaultsOmitted, storage: options.sortStorage(withDefaultsOmitted['storage']) }
+    : withDefaultsOmitted;
   const withSortedKeys = sortObjectKeys(withSortedStorage) as Record<string, unknown>;
   return orderTopLevel(withSortedKeys);
 }

package/src/contract-types.ts

@@ -1,3 +1,4 @@
+import type { CrossReference } from './cross-reference';
 import type { ContractModelBase, ContractValueObject } from './domain-types';
 import type {
   ExecutionHashBase,
@@ -43,7 +44,7 @@ export interface Contract<
 > {
   readonly target: string;
   readonly targetFamily: string;
-  readonly roots: Record<string, string>;
+  readonly roots: Record<string, CrossReference>;
   readonly models: TModels;
   readonly valueObjects?: Record<string, ContractValueObject>;
   /**

package/src/cross-reference.ts

@@ -0,0 +1,28 @@
+import { blindCast } from '@prisma-next/utils/casts';
+import { type Type, type } from 'arktype';
+import { asNamespaceId, type NamespaceId } from './namespace-id';
+
+export interface CrossReference {
+  readonly namespace: NamespaceId;
+  readonly model: string;
+}
+
+export const CrossReferenceSchema = blindCast<
+  Type<CrossReference>,
+  'namespace is validated as string at runtime and branded to NamespaceId by asNamespaceId in crossRef(); the schema accepts plain strings but the public type reflects the branded shape'
+>(
+  type({
+    '+': 'reject',
+    namespace: 'string',
+    model: 'string',
+  }),
+);
+
+const DEFAULT_CROSS_REF_NAMESPACE = '__unbound__';
+
+export function crossRef(
+  model: string,
+  namespace: string = DEFAULT_CROSS_REF_NAMESPACE,
+): CrossReference {
+  return { namespace: asNamespaceId(namespace), model };
+}

package/src/domain-types.ts

@@ -1,3 +1,5 @@
+import type { CrossReference } from './cross-reference';
+
 export type ScalarFieldType = {
   readonly kind: 'scalar';
   readonly codecId: string;
@@ -29,13 +31,13 @@ export type ContractRelationOn = {
 };
 
 export type ContractReferenceRelation = {
-  readonly to: string;
+  readonly to: CrossReference;
   readonly cardinality: '1:1' | '1:N' | 'N:1';
   readonly on: ContractRelationOn;
 };
 
 export type ContractEmbedRelation = {
-  readonly to: string;
+  readonly to: CrossReference;
   readonly cardinality: '1:1' | '1:N';
 };
 
@@ -61,7 +63,7 @@ export interface ContractModelBase<TModelStorage extends ModelStorageBase = Mode
   readonly storage: TModelStorage;
   readonly discriminator?: ContractDiscriminator;
   readonly variants?: Record<string, ContractVariantEntry>;
-  readonly base?: string;
+  readonly base?: CrossReference;
   readonly owner?: string;
 }
 

package/src/exports/hashing-utils.ts

@@ -0,0 +1,12 @@
+export {
+  createPreserveEmptyPredicate,
+  matchesPathPattern,
+  type PathPattern,
+  type PathSegment as PreserveEmptyPathSegment,
+} from '../canonicalization-path-match';
+export {
+  compareByNameProperty,
+  createStorageSort,
+  type NamedArraySortTarget,
+  type PathSegment as StorageSortPathSegment,
+} from '../canonicalization-storage-sort';

package/src/exports/hashing.ts

@@ -2,6 +2,8 @@ export {
   type CanonicalizeContractOptions,
   canonicalizeContract,
   canonicalizeContractToObject,
+  type PreserveEmptyPredicate,
   type SerializeContract,
+  type StorageSort,
 } from '../canonicalization';
 export { computeExecutionHash, computeProfileHash, computeStorageHash } from '../hashing';

package/src/exports/types.ts

@@ -1,4 +1,6 @@
 export type { Contract, ContractExecutionSection } from '../contract-types';
+export type { CrossReference } from '../cross-reference';
+export { CrossReferenceSchema, crossRef } from '../cross-reference';
 export type {
   ContractDiscriminator,
   ContractEmbedRelation,
@@ -18,6 +20,8 @@ export type {
   UnionFieldType,
   ValueObjectFieldType,
 } from '../domain-types';
+export type { NamespaceId } from '../namespace-id';
+export { asNamespaceId } from '../namespace-id';
 export type {
   $,
   Brand,

package/src/hashing.ts

@@ -1,6 +1,11 @@
 import { createHash } from 'node:crypto';
+import { ifDefined } from '@prisma-next/utils/defined';
 import type { JsonObject } from '@prisma-next/utils/json';
-import { canonicalizeContract } from './canonicalization';
+import {
+  canonicalizeContract,
+  type PreserveEmptyPredicate,
+  type StorageSort,
+} from './canonicalization';
 import type { Contract } from './contract-types';
 import type { ExecutionHashBase, ProfileHashBase, StorageHashBase } from './types';
 
@@ -12,7 +17,13 @@ function sha256(content: string): string {
   return `sha256:${hash.digest('hex')}`;
 }
 
-function hashContract(section: Record<string, unknown>): string {
+type HashContractSection = Record<string, unknown> & {
+  readonly shouldPreserveEmpty?: PreserveEmptyPredicate;
+  readonly sortStorage?: StorageSort;
+};
+
+function hashContract(section: HashContractSection): string {
+  const { shouldPreserveEmpty, sortStorage, ...sectionData } = section;
   // Blind cast: the synthesised object is a hash-only stand-in
   // — never returned to callers, never executed as a Contract.
   // `canonicalizeContract` only walks the storage / execution /
@@ -20,29 +31,35 @@ function hashContract(section: Record<string, unknown>): string {
   // missing precise Contract typing on the other slots is
   // immaterial for the hash result.
   const contract = {
-    targetFamily: section['targetFamily'],
-    target: section['target'],
+    targetFamily: sectionData['targetFamily'],
+    target: sectionData['target'],
     roots: {},
     models: {},
-    storage: section['storage'] ?? {},
-    execution: section['execution'],
+    storage: sectionData['storage'] ?? {},
+    execution: sectionData['execution'],
     extensionPacks: {},
-    capabilities: section['capabilities'] ?? {},
+    capabilities: sectionData['capabilities'] ?? {},
     meta: {},
     profileHash: '',
-    ...section,
+    ...sectionData,
   } as unknown as Contract;
   return canonicalizeContract(contract, {
     schemaVersion: SCHEMA_VERSION,
     serializeContract: (c) => JSON.parse(JSON.stringify(c)) as JsonObject,
+    ...ifDefined('shouldPreserveEmpty', shouldPreserveEmpty),
+    ...ifDefined('sortStorage', sortStorage),
   });
 }
 
-export function computeStorageHash(args: {
+export type ComputeStorageHashArgs = {
   target: string;
   targetFamily: string;
   storage: Record<string, unknown>;
-}): StorageHashBase<string> {
+  readonly shouldPreserveEmpty?: PreserveEmptyPredicate;
+  readonly sortStorage?: StorageSort;
+};
+
+export function computeStorageHash(args: ComputeStorageHashArgs): StorageHashBase<string> {
   return sha256(hashContract(args)) as StorageHashBase<string>;
 }
 

package/src/namespace-id.ts

@@ -0,0 +1,10 @@
+import { blindCast } from '@prisma-next/utils/casts';
+
+export type NamespaceId = string & { readonly __brand: 'NamespaceId' };
+
+export function asNamespaceId(value: string): NamespaceId {
+  return blindCast<
+    NamespaceId,
+    'NamespaceId is a compile-time-only brand on string; this factory is the sole assertion site'
+  >(value);
+}

package/src/testing-factories.ts

@@ -1,5 +1,7 @@
 import { ifDefined } from '@prisma-next/utils/defined';
+import type { PreserveEmptyPredicate, StorageSort } from './canonicalization';
 import type { Contract } from './contract-types';
+import type { CrossReference } from './cross-reference';
 import type {
   ContractModel,
   ContractModelBase,
@@ -16,7 +18,7 @@ type ContractOverrides<
 > = {
   target?: string;
   targetFamily?: string;
-  roots?: Record<string, string>;
+  roots?: Record<string, CrossReference>;
   models?: TModels;
   storage?: Omit<TStorage, 'storageHash'>;
   valueObjects?: Record<string, ContractValueObject>;
@@ -25,6 +27,8 @@ type ContractOverrides<
   execution?: Omit<ExecutionSection, 'executionHash'>;
   profileHash?: ProfileHashBase<string>;
   meta?: Record<string, unknown>;
+  shouldPreserveEmpty?: PreserveEmptyPredicate;
+  sortStorage?: StorageSort;
 };
 
 const DUMMY_HASH = coreHash('sha256:test');
@@ -56,6 +60,8 @@ export function createContract<
     target,
     targetFamily,
     storage: rawStorage as Record<string, unknown>,
+    ...ifDefined('shouldPreserveEmpty', overrides.shouldPreserveEmpty),
+    ...ifDefined('sortStorage', overrides.sortStorage),
   });
 
   const storage = {

package/src/validate-domain.ts

@@ -1,16 +1,17 @@
 import { ContractValidationError } from './contract-validation-error';
+import type { CrossReference } from './cross-reference';
 
 export interface DomainModelShape {
   readonly fields: Record<string, unknown>;
-  readonly relations?: Record<string, { readonly to: string }>;
+  readonly relations?: Record<string, { readonly to: CrossReference }>;
   readonly discriminator?: { readonly field: string };
   readonly variants?: Record<string, unknown>;
-  readonly base?: string;
+  readonly base?: CrossReference;
   readonly owner?: string;
 }
 
 export interface DomainContractShape {
-  readonly roots: Record<string, string>;
+  readonly roots: Record<string, CrossReference>;
   readonly models: Record<string, DomainModelShape>;
   readonly valueObjects?: Record<string, { readonly fields: Record<string, unknown> }>;
 }
@@ -41,11 +42,13 @@ function validateRoots(
   errors: string[],
 ): void {
   const seenValues = new Set<string>();
-  for (const [rootKey, modelName] of Object.entries(contract.roots)) {
-    if (seenValues.has(modelName)) {
+  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`);
     }
-    seenValues.add(modelName);
+    seenValues.add(dedupeKey);
 
     if (!modelNames.has(modelName)) {
       errors.push(
@@ -73,24 +76,27 @@ function validateVariantsAndBases(
         }
         const variantModel = models.get(variantName);
         if (!variantModel) continue;
-        if (variantModel.base !== modelName) {
+        if (variantModel.base?.model !== modelName) {
           errors.push(
-            `Variant "${variantName}" has base "${variantModel.base ?? '(none)'}" but expected "${modelName}"`,
+            `Variant "${variantName}" has base "${variantModel.base?.model ?? '(none)'}" but expected "${modelName}"`,
           );
         }
       }
     }
 
     if (model.base) {
-      if (!modelNames.has(model.base)) {
-        errors.push(`Model "${modelName}" has base "${model.base}" which does not exist in models`);
+      const baseModelName = model.base.model;
+      if (!modelNames.has(baseModelName)) {
+        errors.push(
+          `Model "${modelName}" has base "${baseModelName}" which does not exist in models`,
+        );
         continue;
       }
-      const baseModel = models.get(model.base);
+      const baseModel = models.get(baseModelName);
       if (!baseModel) continue;
       if (!baseModel.variants || !Object.hasOwn(baseModel.variants, modelName)) {
         errors.push(
-          `Model "${modelName}" has base "${model.base}" which does not list it as a variant`,
+          `Model "${modelName}" has base "${baseModelName}" which does not list it as a variant`,
         );
       }
     }
@@ -104,9 +110,10 @@ function validateRelationTargets(
 ): void {
   for (const [modelName, model] of Object.entries(contract.models)) {
     for (const [relName, relation] of Object.entries(model.relations ?? {})) {
-      if (!modelNames.has(relation.to)) {
+      const targetModelName = relation.to.model;
+      if (!modelNames.has(targetModelName)) {
         errors.push(
-          `Relation "${relName}" on model "${modelName}" targets "${relation.to}" which does not exist in models`,
+          `Relation "${relName}" on model "${modelName}" targets "${targetModelName}" which does not exist in models`,
         );
       }
     }
@@ -157,8 +164,8 @@ function validateOwnership(
       errors.push(`Model "${modelName}" has owner "${model.owner}" which does not exist in models`);
     }
 
-    for (const [rootKey, rootModel] of Object.entries(contract.roots)) {
-      if (rootModel === modelName) {
+    for (const [rootKey, rootRef] of Object.entries(contract.roots)) {
+      if (rootRef.model === modelName) {
         errors.push(
           `Owned model "${modelName}" must not appear in roots (found as root "${rootKey}")`,
         );

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

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

package/dist/hashing-rZiqFOlc.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"hashing-rZiqFOlc.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\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(obj: unknown, path: readonly string[]): 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));\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 isRequiredNamespaceTables =\n        currentPath.length === 4 &&\n        currentPath[0] === 'storage' &&\n        currentPath[1] === 'namespaces' &&\n        currentPath[3] === 'tables';\n      // Preserve per-table payloads even when empty. SQL tables are never\n      // emitted empty; Mongo collections legitimately are (a declared\n      // collection with no schema is a valid representation), and the\n      // family-agnostic canonicalizer must not strip them.\n      const isNamespaceTableEntry =\n        currentPath.length === 5 &&\n        currentPath[0] === 'storage' &&\n        currentPath[1] === 'namespaces' &&\n        currentPath[3] === 'tables';\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      const isNamespaceTableUniques =\n        currentPath.length === 6 &&\n        currentPath[0] === 'storage' &&\n        currentPath[1] === 'namespaces' &&\n        currentPath[3] === 'tables' &&\n        currentPath[5] === 'uniques';\n      const isNamespaceTableIndexes =\n        currentPath.length === 6 &&\n        currentPath[0] === 'storage' &&\n        currentPath[1] === 'namespaces' &&\n        currentPath[3] === 'tables' &&\n        currentPath[5] === 'indexes';\n      const isNamespaceTableForeignKeys =\n        currentPath.length === 6 &&\n        currentPath[0] === 'storage' &&\n        currentPath[1] === 'namespaces' &&\n        currentPath[3] === 'tables' &&\n        currentPath[5] === 'foreignKeys';\n\n      // `storage.types.<name>.typeParams` is part of the StorageTypeInstance\n      // shape (validators require it). Preserve it even when empty so the\n      // emitted contract.json remains structurally valid after a round-trip.\n      const isStorageTypeTypeParams =\n        currentPath.length === 4 &&\n        currentPath[0] === 'storage' &&\n        currentPath[1] === 'types' &&\n        key === 'typeParams';\n\n      const isFkBooleanField =\n        currentPath.length === 7 &&\n        currentPath[0] === 'storage' &&\n        currentPath[1] === 'namespaces' &&\n        currentPath[3] === 'tables' &&\n        currentPath[5] === 'foreignKeys' &&\n        (key === 'constraint' || key === 'index');\n\n      const isNullableField = key === 'nullable';\n\n      if (\n        !isRequiredModels &&\n        !isRequiredNamespaces &&\n        !isNamespaceSlot &&\n        !isRequiredNamespaceTables &&\n        !isNamespaceTableEntry &&\n        !isRequiredRoots &&\n        !isRequiredExtensionPacks &&\n        !isRequiredCapabilities &&\n        !isRequiredMeta &&\n        !isRequiredExecutionDefaults &&\n        !isExtensionNamespace &&\n        !isModelRelations &&\n        !isModelStorage &&\n        !isNamespaceTableUniques &&\n        !isNamespaceTableIndexes &&\n        !isNamespaceTableForeignKeys &&\n        !isFkBooleanField &&\n        !isNullableField &&\n        !isStorageTypeTypeParams\n      ) {\n        continue;\n      }\n    }\n\n    result[key] = omitDefaults(value, currentPath);\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\ntype NamespaceObject = {\n  tables?: Record<string, unknown>;\n  [key: string]: unknown;\n};\n\ntype StorageObject = {\n  namespaces?: Record<string, unknown>;\n  [key: string]: unknown;\n};\n\ntype TableObject = {\n  indexes?: unknown[];\n  uniques?: unknown[];\n  [key: string]: unknown;\n};\n\nfunction sortTableArrays(tableObj: TableObject): TableObject {\n  const sortedTable: TableObject = { ...tableObj };\n\n  if (Array.isArray(tableObj.indexes)) {\n    sortedTable.indexes = [...tableObj.indexes].sort((a, b) => {\n      const nameA = (a as { name?: string })?.name || '';\n      const nameB = (b as { name?: string })?.name || '';\n      return nameA.localeCompare(nameB);\n    });\n  }\n\n  if (Array.isArray(tableObj.uniques)) {\n    sortedTable.uniques = [...tableObj.uniques].sort((a, b) => {\n      const nameA = (a as { name?: string })?.name || '';\n      const nameB = (b as { name?: string })?.name || '';\n      return nameA.localeCompare(nameB);\n    });\n  }\n\n  return sortedTable;\n}\n\nfunction sortIndexesAndUniques(storage: unknown): unknown {\n  if (!storage || typeof storage !== 'object') {\n    return storage;\n  }\n\n  const storageObj = storage as StorageObject;\n  if (!storageObj.namespaces || typeof storageObj.namespaces !== 'object') {\n    return storage;\n  }\n\n  const namespaces = storageObj.namespaces;\n  const result: StorageObject = { ...storageObj, namespaces: {} };\n  const resultNamespaces = result.namespaces as Record<string, unknown>;\n\n  for (const nsId of Object.keys(namespaces)) {\n    const ns = namespaces[nsId];\n    if (!ns || typeof ns !== 'object') {\n      resultNamespaces[nsId] = ns;\n      continue;\n    }\n\n    const nsObj = ns as NamespaceObject;\n    if (!nsObj.tables || typeof nsObj.tables !== 'object') {\n      resultNamespaces[nsId] = ns;\n      continue;\n    }\n\n    const sortedTables: Record<string, unknown> = {};\n    const sortedTableNames = Object.keys(nsObj.tables).sort();\n    for (const tableName of sortedTableNames) {\n      const table = nsObj.tables[tableName];\n      if (!table || typeof table !== 'object') {\n        sortedTables[tableName] = table;\n        continue;\n      }\n      sortedTables[tableName] = sortTableArrays(table as TableObject);\n    }\n\n    resultNamespaces[nsId] = { ...nsObj, tables: sortedTables };\n  }\n\n  return result;\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\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    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, []) as Record<string, unknown>;\n  const withSortedIndexes = sortIndexesAndUniques(withDefaultsOmitted['storage']);\n  const withSortedStorage = { ...withDefaultsOmitted, storage: withSortedIndexes };\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 type { JsonObject } from '@prisma-next/utils/json';\nimport { canonicalizeContract } 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\nfunction hashContract(section: Record<string, unknown>): string {\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: section['targetFamily'],\n    target: section['target'],\n    roots: {},\n    models: {},\n    storage: section['storage'] ?? {},\n    execution: section['execution'],\n    extensionPacks: {},\n    capabilities: section['capabilities'] ?? {},\n    meta: {},\n    profileHash: '',\n    ...section,\n  } as unknown as Contract;\n  return canonicalizeContract(contract, {\n    schemaVersion: SCHEMA_VERSION,\n    serializeContract: (c) => JSON.parse(JSON.stringify(c)) as JsonObject,\n  });\n}\n\nexport function computeStorageHash(args: {\n  target: string;\n  targetFamily: string;\n  storage: Record<string, unknown>;\n}): 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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"}