@prisma-next/mongo-contract 0.11.0 → 0.12.0

package/src/ir/mongo-storage.ts

@@ -3,73 +3,15 @@ import {
   freezeNode,
   IRNodeBase,
   type Namespace,
-  NamespaceBase,
   type Storage,
-  UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
-import { MongoCollection, type MongoCollectionInput } from './mongo-collection';
-import { MongoUnboundNamespace } from './mongo-unbound-namespace';
+import type { MongoCollection, MongoCollectionInput } from './mongo-collection';
 
 export interface MongoNamespaceCollectionsInput {
   readonly id: string;
   readonly collections?: Record<string, MongoCollection | MongoCollectionInput>;
 }
 
-export interface MongoStorageInput<THash extends string = string> {
-  readonly storageHash: StorageHashBase<THash>;
-  readonly namespaces?: Readonly<Record<string, Namespace | MongoNamespaceCollectionsInput>>;
-}
-
-const DEFAULT_NAMESPACES: Readonly<Record<string, Namespace>> = Object.freeze({
-  [UNBOUND_NAMESPACE_ID]: MongoUnboundNamespace.instance,
-});
-
-class MongoNamespacePayload extends NamespaceBase {
-  declare readonly kind: string;
-
-  readonly id: string;
-  readonly collections: Readonly<Record<string, MongoCollection>>;
-
-  constructor(input: MongoNamespaceCollectionsInput) {
-    super();
-    this.id = input.id;
-    this.collections = Object.freeze(
-      Object.fromEntries(
-        Object.entries(input.collections ?? {}).map(([name, c]) => [
-          name,
-          c instanceof MongoCollection ? c : new MongoCollection(c),
-        ]),
-      ),
-    );
-    Object.defineProperty(this, 'kind', {
-      value: 'mongo-namespace',
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    });
-    freezeNode(this);
-  }
-}
-
-function normaliseNamespaceEntry(
-  nsKey: string,
-  ns: Namespace | MongoNamespaceCollectionsInput,
-): Namespace {
-  if (ns instanceof NamespaceBase) {
-    return ns;
-  }
-  // The framework `Namespace` interface only promises `id`; the remaining
-  // arm of this union — plain-object inputs accepted by `MongoStorageInput`
-  // — is `MongoNamespaceCollectionsInput`. The `instanceof` guard above
-  // discriminates the two; TypeScript can't narrow further without a hint.
-  const input = ns as MongoNamespaceCollectionsInput;
-  const collectionCount = Object.keys(input.collections ?? {}).length;
-  if (nsKey === UNBOUND_NAMESPACE_ID && collectionCount === 0) {
-    return MongoUnboundNamespace.instance;
-  }
-  return new MongoNamespacePayload(input);
-}
-
 // Mongo concretions always store `MongoCollection` instances in
 // `collections` (Mongo idiom — distinct from the SQL family's `tables`).
 // Narrowing the namespace map here lets target/family-level consumers
@@ -80,6 +22,11 @@ export type MongoNamespace = Namespace & {
   readonly collections: Readonly<Record<string, MongoCollection>>;
 };
 
+export interface MongoStorageInput<THash extends string = string> {
+  readonly storageHash: StorageHashBase<THash>;
+  readonly namespaces: Readonly<Record<string, MongoNamespace>>;
+}
+
 export class MongoStorage<THash extends string = string> extends IRNodeBase implements Storage {
   declare readonly kind: 'mongo-storage';
   readonly storageHash: StorageHashBase<THash>;
@@ -94,14 +41,7 @@ export class MongoStorage<THash extends string = string> extends IRNodeBase impl
       configurable: true,
     });
     this.storageHash = input.storageHash;
-    this.namespaces = Object.freeze(
-      Object.fromEntries(
-        Object.entries(input.namespaces ?? DEFAULT_NAMESPACES).map(([nsKey, ns]) => [
-          nsKey,
-          normaliseNamespaceEntry(nsKey, ns) as MongoNamespace,
-        ]),
-      ),
-    );
+    this.namespaces = Object.freeze(input.namespaces);
     freezeNode(this);
   }
 }

package/src/validate-storage.ts

@@ -1,4 +1,8 @@
-import type { MongoContract } from './contract-types';
+import type { MongoContract, MongoModelDefinition } from './contract-types';
+
+function formatCrossRef(crossRef: { readonly namespace: string; readonly model: string }): string {
+  return `${crossRef.namespace}.${crossRef.model}`;
+}
 
 function storageDeclaresCollection(
   storage: MongoContract['storage'],
@@ -15,62 +19,65 @@ function storageDeclaresCollection(
 export function validateMongoStorage(contract: MongoContract): void {
   const errors: string[] = [];
 
-  for (const [modelName, model] of Object.entries(contract.models)) {
-    if (
-      model.storage.collection &&
-      !storageDeclaresCollection(contract.storage, model.storage.collection)
-    ) {
-      errors.push(
-        `Model "${modelName}" references collection "${model.storage.collection}" which is not declared under any namespace's collections map`,
-      );
-    }
+  for (const [namespaceId, namespace] of Object.entries(contract.domain.namespaces)) {
+    const models = namespace.models as Record<string, MongoModelDefinition>;
+    for (const [modelName, model] of Object.entries(models)) {
+      const qualifiedName = `${namespaceId}:${modelName}`;
+      if (
+        model.storage.collection &&
+        !storageDeclaresCollection(contract.storage, model.storage.collection)
+      ) {
+        errors.push(
+          `Model "${qualifiedName}" references collection "${model.storage.collection}" which is not declared under any namespace's collections map`,
+        );
+      }
 
-    // Mongo does not support multi-table inheritance (ADR 2): all variants of a base
-    // must share the same collection (single-table inheritance only).
-    if (model.base) {
-      const baseModel = contract.models[model.base];
-      if (baseModel) {
-        const variantCollection = model.storage.collection;
-        const baseCollection = baseModel.storage.collection;
-        if (variantCollection !== baseCollection) {
-          errors.push(
-            `Mongo does not support multi-table inheritance; variant "${modelName}" must share its base's collection ("${baseCollection ?? '(none)'}"), but has "${variantCollection ?? '(none)'}"`,
-          );
+      if (model.base) {
+        const baseModel = models[model.base.model];
+        if (baseModel) {
+          const variantCollection = model.storage.collection;
+          const baseCollection = baseModel.storage.collection;
+          if (variantCollection !== baseCollection) {
+            errors.push(
+              `Mongo does not support multi-table inheritance; variant "${qualifiedName}" must share its base's collection ("${baseCollection ?? '(none)'}"), but has "${variantCollection ?? '(none)'}"`,
+            );
+          }
         }
       }
-    }
 
-    for (const [relName, relation] of Object.entries(model.relations ?? {})) {
-      const targetModel = contract.models[relation.to];
+      for (const [relName, relation] of Object.entries(model.relations ?? {})) {
+        const targetModel = models[relation.to.model];
+        const targetLabel = formatCrossRef(relation.to);
 
-      if (targetModel?.owner) {
-        if (targetModel.owner !== modelName) {
-          errors.push(
-            `Embed relation "${relName}" targets "${relation.to}" which is owned by "${targetModel.owner}", not "${modelName}"`,
-          );
-        }
-        if (targetModel.storage.collection) {
-          errors.push(
-            `Embed relation "${relName}" targets "${relation.to}" which must not have a collection`,
-          );
-        }
-      } else if ('on' in relation && relation.on) {
-        for (const localField of relation.on.localFields) {
-          if (!(localField in model.fields)) {
+        if (targetModel?.owner) {
+          if (targetModel.owner !== modelName) {
             errors.push(
-              `Reference relation "${relName}": localField "${localField}" is not a field on model "${modelName}"`,
+              `Embed relation "${relName}" targets "${targetLabel}" which is owned by "${targetModel.owner}", not "${qualifiedName}"`,
             );
           }
-        }
-
-        if (targetModel) {
-          for (const targetField of relation.on.targetFields) {
-            if (!(targetField in targetModel.fields)) {
+          if (targetModel.storage.collection) {
+            errors.push(
+              `Embed relation "${relName}" targets "${targetLabel}" which must not have a collection`,
+            );
+          }
+        } else if ('on' in relation && relation.on) {
+          for (const localField of relation.on.localFields) {
+            if (!(localField in model.fields)) {
               errors.push(
-                `Reference relation "${relName}": targetField "${targetField}" is not a field on model "${relation.to}"`,
+                `Reference relation "${relName}": localField "${localField}" is not a field on model "${qualifiedName}"`,
               );
             }
           }
+
+          if (targetModel) {
+            for (const targetField of relation.on.targetFields) {
+              if (!(targetField in targetModel.fields)) {
+                errors.push(
+                  `Reference relation "${relName}": targetField "${targetField}" is not a field on model "${targetLabel}"`,
+                );
+              }
+            }
+          }
         }
       }
     }