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

package/src/canonicalization.ts

@@ -1,7 +1,7 @@
 import { isArrayEqual } from '@prisma-next/utils/array-equal';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { JsonObject } from '@prisma-next/utils/json';
-
+import { matchesPathPattern, type PathPattern } from './canonicalization-path-match';
 import type { Contract } from './contract-types';
 
 /**
@@ -33,6 +33,30 @@ export type PreserveEmptyPredicate = (path: readonly string[]) => boolean;
  */
 export type StorageSort = (storage: unknown) => unknown;
 
+const DOMAIN_NAMESPACE_SLOT_PATTERN = ['domain', 'namespaces', '*'] as const satisfies PathPattern;
+const DOMAIN_MODELS_CONTAINER_PATTERN = [
+  'domain',
+  'namespaces',
+  '*',
+  'models',
+] as const satisfies PathPattern;
+const DOMAIN_MODEL_RELATIONS_PATTERN = [
+  'domain',
+  'namespaces',
+  '*',
+  'models',
+  '*',
+  'relations',
+] as const satisfies PathPattern;
+const DOMAIN_MODEL_STORAGE_PATTERN = [
+  'domain',
+  'namespaces',
+  '*',
+  'models',
+  '*',
+  'storage',
+] as const satisfies PathPattern;
+
 const TOP_LEVEL_ORDER = [
   'schemaVersion',
   'canonicalVersion',
@@ -40,8 +64,6 @@ const TOP_LEVEL_ORDER = [
   'target',
   'profileHash',
   'roots',
-  'models',
-  'valueObjects',
   'domain',
   'storage',
   'execution',
@@ -92,9 +114,14 @@ function omitDefaults(
     }
 
     if (isDefaultValue(value)) {
-      const isRequiredModels = isArrayEqual(currentPath, ['models']);
-      const isRequiredNamespaces = isArrayEqual(currentPath, ['storage', 'namespaces']);
-      const isNamespaceSlot =
+      const isRequiredDomainNamespaces = isArrayEqual(currentPath, ['domain', 'namespaces']);
+      const isDomainNamespaceSlot = matchesPathPattern(currentPath, DOMAIN_NAMESPACE_SLOT_PATTERN);
+      const isRequiredDomainModels = matchesPathPattern(
+        currentPath,
+        DOMAIN_MODELS_CONTAINER_PATTERN,
+      );
+      const isRequiredStorageNamespaces = isArrayEqual(currentPath, ['storage', 'namespaces']);
+      const isStorageNamespaceSlot =
         currentPath.length === 3 &&
         isArrayEqual([currentPath[0], currentPath[1]], ['storage', 'namespaces']);
       const isRequiredRoots = isArrayEqual(currentPath, ['roots']);
@@ -107,27 +134,19 @@ function omitDefaults(
         '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 isModelRelations = matchesPathPattern(currentPath, DOMAIN_MODEL_RELATIONS_PATTERN);
+      const isModelStorage = matchesPathPattern(currentPath, DOMAIN_MODEL_STORAGE_PATTERN);
 
       const isNullableField = key === 'nullable';
 
       const isFamilyPreserved = shouldPreserveEmpty?.(currentPath) ?? false;
 
       if (
-        !isRequiredModels &&
-        !isRequiredNamespaces &&
-        !isNamespaceSlot &&
+        !isRequiredDomainNamespaces &&
+        !isDomainNamespaceSlot &&
+        !isRequiredDomainModels &&
+        !isRequiredStorageNamespaces &&
+        !isStorageNamespaceSlot &&
         !isRequiredRoots &&
         !isRequiredExtensionPacks &&
         !isRequiredCapabilities &&
@@ -137,7 +156,6 @@ function omitDefaults(
         !isModelRelations &&
         !isModelStorage &&
         !isNullableField &&
-        !isDomainUnboundTypeParams &&
         !isFamilyPreserved
       ) {
         continue;
@@ -232,9 +250,7 @@ export function canonicalizeContractToObject(
     target: serialized['target'],
     profileHash: serialized['profileHash'],
     roots: serialized['roots'],
-    models: serialized['models'],
-    ...ifDefined('valueObjects', serialized['valueObjects']),
-    ...ifDefined('domain', serialized['domain']),
+    domain: serialized['domain'],
     storage: serialized['storage'],
     ...ifDefined('execution', serialized['execution']),
     extensionPacks: serialized['extensionPacks'],

package/src/contract-types.ts

@@ -1,4 +1,5 @@
 import type { CrossReference } from './cross-reference';
+import type { ApplicationDomain } from './domain-envelope';
 import type { ContractModelBase, ContractValueObject } from './domain-types';
 import type {
   ExecutionHashBase,
@@ -45,14 +46,11 @@ export interface Contract<
   readonly target: string;
   readonly targetFamily: string;
   readonly roots: Record<string, CrossReference>;
-  readonly models: TModels;
-  readonly valueObjects?: Record<string, ContractValueObject>;
   /**
-   * Domain plane keyed as `domain[plane][namespaceId][entityKind][entityName]`.
-   * Optional until downstream slices populate it; when absent the field is
-   * omitted from the on-disk envelope so emitted contracts stay byte-stable.
+   * Application plane (ADR 221): `domain.namespaces.<nsId>.{ models, valueObjects }`.
+   * `TModels` types the union of model entries across namespaces for family DSL inference.
    */
-  readonly domain?: Record<string, Record<string, Record<string, unknown>>>;
+  readonly domain: ApplicationDomain<TModels>;
   readonly storage: TStorage;
   readonly capabilities: Record<string, Record<string, boolean>>;
   readonly extensionPacks: Record<string, unknown>;
@@ -60,3 +58,30 @@ export interface Contract<
   readonly profileHash: ProfileHashBase<string>;
   readonly meta: Record<string, unknown>;
 }
+
+export type ContractModelsMap<TContract extends Contract> =
+  TContract extends Contract<StorageBase, infer TModels> ? TModels : never;
+
+type ExactlyOneKey<T extends Record<string, unknown>> = keyof T extends infer Only extends keyof T
+  ? [keyof T] extends [Only]
+    ? Only
+    : never
+  : never;
+
+type NamespaceValueObjectsOf<TNamespace> = TNamespace extends {
+  readonly valueObjects?: infer VO;
+}
+  ? VO extends Record<string, ContractValueObject>
+    ? VO
+    : Record<never, never>
+  : Record<never, never>;
+
+/** Value-object map for the contract's sole domain namespace (type-level single-namespace projection). */
+export type ContractValueObjectsMap<TContract extends Contract> =
+  NamespaceValueObjectsOf<
+    TContract['domain']['namespaces'][ExactlyOneKey<TContract['domain']['namespaces']>]
+  > extends infer Projected
+    ? Projected extends Record<string, ContractValueObject>
+      ? Projected
+      : Record<never, never>
+    : Record<never, never>;

package/src/contract-validation-error.ts

@@ -10,3 +10,10 @@ export class ContractValidationError extends Error {
     this.phase = phase;
   }
 }
+
+export class DomainNamespaceResolutionError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'DomainNamespaceResolutionError';
+  }
+}

package/src/domain-envelope.ts

@@ -0,0 +1,87 @@
+import { DomainNamespaceResolutionError } from './contract-validation-error';
+import type { ContractModelBase, ContractValueObject } from './domain-types';
+
+export const UNBOUND_DOMAIN_NAMESPACE_ID = '__unbound__' as const;
+
+/**
+ * One namespace's application-domain entities — models and optional value
+ * objects keyed by entity name within that namespace coordinate.
+ */
+export interface ApplicationDomainNamespace<
+  TModels extends Record<string, ContractModelBase> = Record<string, ContractModelBase>,
+> {
+  readonly models: TModels;
+  readonly valueObjects?: Record<string, ContractValueObject>;
+}
+
+/**
+ * Application-domain envelope: entity content keyed by namespace id.
+ * Mirrors the storage plane's `namespaces` segment (ADR 221).
+ */
+export interface ApplicationDomain<
+  TModels extends Record<string, ContractModelBase> = Record<string, ContractModelBase>,
+> {
+  readonly namespaces: Readonly<Record<string, ApplicationDomainNamespace<TModels>>>;
+}
+
+export type ContractWithDomain = {
+  readonly domain: ApplicationDomain;
+};
+
+export function resolveSingleDomainNamespaceId(
+  domain: ApplicationDomain,
+  namespaceId?: string,
+): string {
+  if (namespaceId !== undefined) {
+    if (!Object.hasOwn(domain.namespaces, namespaceId)) {
+      throw new DomainNamespaceResolutionError(
+        `domain namespace "${namespaceId}" is not present on the contract`,
+      );
+    }
+    return namespaceId;
+  }
+
+  const namespaceIds = Object.keys(domain.namespaces);
+  if (namespaceIds.length === 0) {
+    throw new DomainNamespaceResolutionError('domain has no namespaces');
+  }
+  if (namespaceIds.length > 1) {
+    throw new DomainNamespaceResolutionError(
+      `expected exactly one domain namespace, found ${namespaceIds.length} (${namespaceIds.join(', ')})`,
+    );
+  }
+  const [soleNamespaceId] = namespaceIds;
+  if (soleNamespaceId === undefined) {
+    throw new DomainNamespaceResolutionError('domain has no namespaces');
+  }
+  return soleNamespaceId;
+}
+
+// Transitional single-namespace projection; pending runtime-qualification slice.
+export function contractModels<TModels extends Record<string, ContractModelBase>>(
+  contract: { readonly domain: ApplicationDomain<TModels> },
+  namespaceId?: string,
+): TModels {
+  const resolved = resolveSingleDomainNamespaceId(contract.domain, namespaceId);
+  const domainNamespace = contract.domain.namespaces[resolved];
+  if (domainNamespace === undefined) {
+    throw new DomainNamespaceResolutionError(
+      `domain namespace "${resolved}" is not present on the contract`,
+    );
+  }
+  return domainNamespace.models;
+}
+
+export function contractValueObjects<TModels extends Record<string, ContractModelBase>>(
+  contract: { readonly domain: ApplicationDomain<TModels> },
+  namespaceId?: string,
+): Record<string, ContractValueObject> | undefined {
+  const resolved = resolveSingleDomainNamespaceId(contract.domain, namespaceId);
+  const domainNamespace = contract.domain.namespaces[resolved];
+  if (domainNamespace === undefined) {
+    throw new DomainNamespaceResolutionError(
+      `domain namespace "${resolved}" is not present on the contract`,
+    );
+  }
+  return domainNamespace.valueObjects;
+}

package/src/domain-types.ts

@@ -74,24 +74,20 @@ export interface ContractModel<TModelStorage extends ModelStorageBase = ModelSto
 
 // ── Relation key helpers ─────────────────────────────────────────────────────
 
-type HasModelsWithRelations = {
-  readonly models: Record<string, { readonly relations: Record<string, ContractRelation> }>;
-};
-
 export type ReferenceRelationKeys<
-  TContract extends HasModelsWithRelations,
-  ModelName extends string & keyof TContract['models'],
+  TModels extends Record<string, { readonly relations: Record<string, ContractRelation> }>,
+  ModelName extends string & keyof TModels,
 > = {
-  [K in keyof TContract['models'][ModelName]['relations']]: TContract['models'][ModelName]['relations'][K] extends ContractReferenceRelation
+  [K in keyof TModels[ModelName]['relations']]: TModels[ModelName]['relations'][K] extends ContractReferenceRelation
     ? K
     : never;
-}[keyof TContract['models'][ModelName]['relations']];
+}[keyof TModels[ModelName]['relations']];
 
 export type EmbedRelationKeys<
-  TContract extends HasModelsWithRelations,
-  ModelName extends string & keyof TContract['models'],
+  TModels extends Record<string, { readonly relations: Record<string, ContractRelation> }>,
+  ModelName extends string & keyof TModels,
 > = {
-  [K in keyof TContract['models'][ModelName]['relations']]: TContract['models'][ModelName]['relations'][K] extends ContractReferenceRelation
+  [K in keyof TModels[ModelName]['relations']]: TModels[ModelName]['relations'][K] extends ContractReferenceRelation
     ? never
     : K;
-}[keyof TContract['models'][ModelName]['relations']];
+}[keyof TModels[ModelName]['relations']];

package/src/exports/contract-validation-error.ts

@@ -1,4 +1,5 @@
 export {
   ContractValidationError,
   type ContractValidationPhase,
+  DomainNamespaceResolutionError,
 } from '../contract-validation-error';

package/src/exports/types.ts

@@ -1,6 +1,23 @@
-export type { Contract, ContractExecutionSection } from '../contract-types';
+export type {
+  Contract,
+  ContractExecutionSection,
+  ContractModelsMap,
+  ContractValueObjectsMap,
+} from '../contract-types';
+export { DomainNamespaceResolutionError } from '../contract-validation-error';
 export type { CrossReference } from '../cross-reference';
 export { CrossReferenceSchema, crossRef } from '../cross-reference';
+export type {
+  ApplicationDomain,
+  ApplicationDomainNamespace,
+  ContractWithDomain,
+} from '../domain-envelope';
+export {
+  contractModels,
+  contractValueObjects,
+  resolveSingleDomainNamespaceId,
+  UNBOUND_DOMAIN_NAMESPACE_ID,
+} from '../domain-envelope';
 export type {
   ContractDiscriminator,
   ContractEmbedRelation,

package/src/hashing.ts

@@ -34,7 +34,7 @@ function hashContract(section: HashContractSection): string {
     targetFamily: sectionData['targetFamily'],
     target: sectionData['target'],
     roots: {},
-    models: {},
+    domain: { namespaces: {} },
     storage: sectionData['storage'] ?? {},
     execution: sectionData['execution'],
     extensionPacks: {},