@prisma-next/mongo-contract 0.13.0 → 0.14.0-dev.10

package/src/contract-types.ts

@@ -2,13 +2,11 @@ import type {
   Contract,
   ContractField,
   ContractModel,
-  ContractModelDefinitions,
   ContractValueObject,
   ContractValueObjectDefinitions,
   StorageBase,
 } from '@prisma-next/contract/types';
-import type { Namespace } from '@prisma-next/framework-components/ir';
-import type { MongoCollection } from './ir/mongo-collection';
+import type { Namespace, UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type { MongoIndexOptionsInput } from './ir/mongo-index-options';
 
 export type MongoIndexFieldValue = 1 | -1 | 'text' | '2dsphere' | '2d' | 'hashed';
@@ -59,30 +57,38 @@ export type MongoModelDefinition = ContractModel<MongoModelStorage>;
  * `namespaces` field) or a fully-constructed class instance (with
  * `namespaces`). The class structurally satisfies this shape.
  */
+import type { MongoCollection } from './ir/mongo-collection';
+
+type MongoNamespaceEntries = Readonly<Record<string, Readonly<Record<string, unknown>>>> & {
+  readonly collection?: Readonly<Record<string, MongoCollection>>;
+};
+
 export type MongoStorageShape<THash extends string = string> = StorageBase<THash> & {
   readonly namespaces: Record<
     string,
     Namespace & {
-      readonly entries: Readonly<{
-        readonly collection: Readonly<Record<string, MongoCollection>>;
-      }>;
+      readonly entries: MongoNamespaceEntries;
     }
   >;
 };
 
-export type MongoContract<
-  S extends MongoStorageShape = MongoStorageShape,
-  M extends Record<string, MongoModelDefinition> = Record<string, MongoModelDefinition>,
-> = Contract<S, M>;
+export type MongoContract<S extends MongoStorageShape = MongoStorageShape> = Contract<S>;
 
-/** Model map inferred from a {@link MongoContract} (domain.namespaces union). */
-export type MongoModelsMap<TContract extends MongoContract> = ContractModelDefinitions<TContract>;
+/**
+ * Model map for the contract's sole (unbound) domain namespace. Mongo is
+ * structurally single-namespace, so its models live under
+ * {@link UNBOUND_NAMESPACE_ID} rather than in a flat cross-namespace union.
+ * Every Mongo type that needs the model map reads it through here, so none
+ * indexes the contract's namespaces directly.
+ */
+export type MongoModelsMap<TContract extends MongoContract> =
+  TContract['domain']['namespaces'][typeof UNBOUND_NAMESPACE_ID]['models'];
 
 export type RootModelName<
   TContract extends MongoContract,
   RootName extends keyof TContract['roots'] & string,
 > = TContract['roots'][RootName] extends { readonly model: infer M extends string }
-  ? M & keyof import('@prisma-next/contract/types').ContractModelDefinitions<TContract>
+  ? M & keyof MongoModelsMap<TContract>
   : never;
 
 export type MongoTypeMaps<
@@ -132,6 +138,26 @@ export type ExtractMongoFieldInputTypes<T> =
       : Record<string, never>
     : Record<string, never>;
 
+/**
+ * The per-model field-output map at the contract's unbound namespace. The
+ * framework emitter nests `FieldOutputTypes` by namespace id
+ * (`{ [ns]: { [model]: { [field]: <refined> } } }`); Mongo is structurally
+ * single-namespace, so its refined rows resolve the per-model map under
+ * {@link UNBOUND_NAMESPACE_ID}. A map without that coordinate (e.g. a contract
+ * carrying no type maps) resolves to `never`, which the row resolvers read as
+ * "no refined map" and fall back to codec-based inference.
+ */
+export type MongoUnboundFieldOutputTypes<T> =
+  ExtractMongoFieldOutputTypes<T> extends Record<typeof UNBOUND_NAMESPACE_ID, infer Inner>
+    ? Inner
+    : never;
+
+/** Input-side counterpart of {@link MongoUnboundFieldOutputTypes}. */
+export type MongoUnboundFieldInputTypes<T> =
+  ExtractMongoFieldInputTypes<T> extends Record<typeof UNBOUND_NAMESPACE_ID, infer Inner>
+    ? Inner
+    : never;
+
 type ExtractValueObjects<TContract extends Contract> = ContractValueObjectDefinitions<TContract>;
 
 type NormalizeContractFields<TFields> = {
@@ -184,11 +210,8 @@ type InferFieldType<
 
 export type InferModelRow<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof ContractModelDefinitions<TContract>,
-  TFields extends Record<
-    string,
-    ContractField
-  > = ContractModelDefinitions<TContract>[ModelName]['fields'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
+  TFields extends Record<string, ContractField> = MongoModelsMap<TContract>[ModelName]['fields'],
   TCodecTypes extends Record<string, { output: unknown }> = ExtractMongoCodecTypes<TContract>,
   TValueObjects extends Record<string, ContractValueObject> = ExtractValueObjects<TContract>,
 > = {

package/src/entity-kinds.ts

@@ -0,0 +1,34 @@
+import type {
+  AnyEntityKindDescriptor,
+  EntityKindDescriptor,
+} from '@prisma-next/framework-components/ir';
+import { StorageCollectionSchema } from './contract-schema';
+import { MongoCollection, type MongoCollectionInput } from './ir/mongo-collection';
+
+export const collectionEntityKind: EntityKindDescriptor<MongoCollectionInput, MongoCollection> = {
+  kind: 'collection',
+  schema: StorageCollectionSchema,
+  construct: (input) => new MongoCollection(input),
+};
+
+/**
+ * Assembles the `kind → descriptor` registry for Mongo namespaces: the built-in
+ * `collection` kind plus any target `packKinds`. This builds the lookup table —
+ * it does not touch contract data. `hydrateNamespaceEntities` later consumes
+ * this registry to turn a namespace's raw entries into IR instances. Throws on
+ * a duplicate kind.
+ */
+export function composeMongoEntityKinds(
+  packKinds: readonly AnyEntityKindDescriptor[] = [],
+): ReadonlyMap<string, AnyEntityKindDescriptor> {
+  const kinds = new Map<string, AnyEntityKindDescriptor>([['collection', collectionEntityKind]]);
+  for (const descriptor of packKinds) {
+    if (kinds.has(descriptor.kind)) {
+      throw new Error(
+        `composeMongoEntityKinds: duplicate entity kind "${descriptor.kind}" — each kind may be registered only once`,
+      );
+    }
+    kinds.set(descriptor.kind, descriptor);
+  }
+  return kinds;
+}

package/src/exports/entity-kinds.ts

@@ -0,0 +1 @@
+export { collectionEntityKind, composeMongoEntityKinds } from '../entity-kinds';

package/src/exports/index.ts

@@ -25,6 +25,8 @@ export type {
   MongoStorageShape,
   MongoTypeMaps,
   MongoTypeMapsPhantomKey,
+  MongoUnboundFieldInputTypes,
+  MongoUnboundFieldOutputTypes,
   MongoWildcardProjection,
   RootModelName,
 } from '../contract-types';
@@ -32,7 +34,7 @@ export {
   defaultMongoDomainNamespaceId,
   defaultMongoStorageNamespaceId,
 } from '../default-namespace';
-export { buildMongoNamespace, buildMongoNamespaceMap } from '../ir/build-mongo-namespace';
+export { buildMongoNamespace } from '../ir/build-mongo-namespace';
 export type { MongoChangeStreamPreAndPostImagesOptionsInput } from '../ir/mongo-change-stream-pre-and-post-images-options';
 export { MongoChangeStreamPreAndPostImagesOptions } from '../ir/mongo-change-stream-pre-and-post-images-options';
 export type {
@@ -63,7 +65,7 @@ export type { MongoIndexOptionDefaultsInput } from '../ir/mongo-index-option-def
 export { MongoIndexOptionDefaults } from '../ir/mongo-index-option-defaults';
 export type { MongoIndexOptionsInput } from '../ir/mongo-index-options';
 export { MongoIndexOptions } from '../ir/mongo-index-options';
-export type { MongoStorageInput } from '../ir/mongo-storage';
+export type { MongoNamespace, MongoNamespaceEntries, MongoStorageInput } from '../ir/mongo-storage';
 export { MongoStorage } from '../ir/mongo-storage';
 export type {
   MongoTimeSeriesCollectionOptionsInput,

package/src/ir/build-mongo-namespace.ts

@@ -1,58 +1,51 @@
 import {
   freezeNode,
-  type Namespace,
+  hydrateNamespaceEntities,
   NamespaceBase,
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
-import { blindCast, castAs } from '@prisma-next/utils/casts';
-import { MongoCollection } from './mongo-collection';
-import type { MongoNamespace, MongoNamespaceCollectionsInput } from './mongo-storage';
+import { blindCast } from '@prisma-next/utils/casts';
+import { composeMongoEntityKinds } from '../entity-kinds';
+import type { MongoCollection } from './mongo-collection';
+import type {
+  MongoNamespace,
+  MongoNamespaceCollectionsInput,
+  MongoNamespaceEntries,
+} from './mongo-storage';
 import { MongoUnboundNamespace } from './mongo-unbound-namespace';
 
 const MONGO_NAMESPACE_KIND = 'mongo-namespace' as const;
 
-function isMaterializedMongoNamespace(
-  ns: Namespace | MongoNamespaceCollectionsInput,
-): ns is MongoNamespace {
-  if (typeof ns !== 'object' || ns === null) {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(ns);
-  if (proto === Object.prototype || proto === null) {
-    return false;
-  }
-  return (ns as Namespace).kind === MONGO_NAMESPACE_KIND;
-}
-
 class MongoBoundNamespace extends NamespaceBase {
   declare readonly kind: string;
 
   readonly id: string;
-  readonly entries: Readonly<{
-    readonly collection: Readonly<Record<string, MongoCollection>>;
-  }>;
+  readonly entries: MongoNamespaceEntries;
 
   static fromCollectionsInput(input: MongoNamespaceCollectionsInput): MongoNamespace {
-    const collectionCount = Object.keys(input.entries.collection).length;
-    if (input.id === UNBOUND_NAMESPACE_ID && collectionCount === 0) {
-      return castAs<MongoNamespace>(MongoUnboundNamespace.instance);
+    const collectionMap = input.entries['collection'];
+    const collectionCount = collectionMap !== undefined ? Object.keys(collectionMap).length : 0;
+    const hasUnknownKinds = Object.keys(input.entries).some((kind) => kind !== 'collection');
+    if (input.id === UNBOUND_NAMESPACE_ID && collectionCount === 0 && !hasUnknownKinds) {
+      return MongoUnboundNamespace.instance;
     }
-    return castAs<MongoNamespace>(new MongoBoundNamespace(input));
+    return new MongoBoundNamespace(input);
   }
 
   private constructor(input: MongoNamespaceCollectionsInput) {
     super();
     this.id = input.id;
-    this.entries = Object.freeze({
-      collection: Object.freeze(
-        Object.fromEntries(
-          Object.entries(input.entries.collection).map(([name, c]) => [
-            name,
-            c instanceof MongoCollection ? c : new MongoCollection(c),
-          ]),
-        ),
-      ),
-    });
+
+    const rawEntries: Record<string, Readonly<Record<string, unknown>>> = {
+      collection: {},
+      ...input.entries,
+    };
+    this.entries = Object.freeze(
+      blindCast<
+        MongoNamespaceEntries,
+        'composeMongoEntityKinds() supplies the collection→MongoCollection descriptor, so this open-dict result holds the typed collection member MongoNamespaceEntries declares; the descriptor Map erases that per-kind Node type from the return.'
+      >(hydrateNamespaceEntities(rawEntries, composeMongoEntityKinds(), 'carry')),
+    );
     Object.defineProperty(this, 'kind', {
       value: MONGO_NAMESPACE_KIND,
       writable: false,
@@ -61,29 +54,12 @@ class MongoBoundNamespace extends NamespaceBase {
     });
     freezeNode(this);
   }
+
+  get collection(): Readonly<Record<string, MongoCollection>> {
+    return this.entries.collection ?? Object.freeze({});
+  }
 }
 
 export function buildMongoNamespace(input: MongoNamespaceCollectionsInput): MongoNamespace {
   return MongoBoundNamespace.fromCollectionsInput(input);
 }
-
-export function buildMongoNamespaceMap(
-  namespaces: Readonly<Record<string, Namespace | MongoNamespaceCollectionsInput>>,
-): Readonly<Record<string, MongoNamespace>> {
-  return Object.fromEntries(
-    Object.entries(namespaces).map(([nsKey, ns]) => [
-      nsKey,
-      isMaterializedMongoNamespace(ns)
-        ? blindCast<
-            MongoNamespace,
-            'a materialised Mongo-family namespace entry in a namespace map is a MongoNamespace'
-          >(ns)
-        : MongoBoundNamespace.fromCollectionsInput(
-            blindCast<
-              MongoNamespaceCollectionsInput,
-              'non-materialized Mongo namespace map entry is a MongoNamespaceCollectionsInput'
-            >(ns),
-          ),
-    ]),
-  );
-}

package/src/ir/mongo-index.ts

@@ -1,4 +1,5 @@
 import { freezeNode, IRNodeBase } from '@prisma-next/framework-components/ir';
+import type { CollationOptions } from '@prisma-next/mongo-value/mongodb-types';
 import type { MongoIndexKey } from '../contract-types';
 
 /**
@@ -14,7 +15,7 @@ export interface MongoIndexInput {
   readonly expireAfterSeconds?: number;
   readonly partialFilterExpression?: Record<string, unknown>;
   readonly wildcardProjection?: Record<string, 0 | 1>;
-  readonly collation?: Record<string, unknown>;
+  readonly collation?: CollationOptions;
   readonly weights?: Record<string, number>;
   readonly default_language?: string;
   readonly language_override?: string;
@@ -41,7 +42,7 @@ export class MongoIndex extends IRNodeBase {
   declare readonly expireAfterSeconds?: number;
   declare readonly partialFilterExpression?: Record<string, unknown>;
   declare readonly wildcardProjection?: Record<string, 0 | 1>;
-  declare readonly collation?: Record<string, unknown>;
+  declare readonly collation?: CollationOptions;
   declare readonly weights?: Record<string, number>;
   declare readonly default_language?: string;
   declare readonly language_override?: string;

package/src/ir/mongo-storage.ts

@@ -7,22 +7,17 @@ import {
 } from '@prisma-next/framework-components/ir';
 import type { MongoCollection, MongoCollectionInput } from './mongo-collection';
 
+export type MongoNamespaceEntries = Readonly<Record<string, Readonly<Record<string, unknown>>>> & {
+  readonly collection?: Readonly<Record<string, MongoCollection>>;
+};
+
 export interface MongoNamespaceCollectionsInput {
   readonly id: string;
-  readonly entries: {
-    readonly collection: Record<string, MongoCollection | MongoCollectionInput>;
-  };
+  readonly entries: Readonly<Record<string, Readonly<Record<string, MongoCollectionInput>>>>;
 }
 
-// Mongo concretions store `MongoCollection` instances under
-// `entries.collection` (Mongo idiom — distinct from the SQL family's
-// `entries.table`). Narrowing the namespace map here lets target/family-
-// level consumers iterate collection slots and recover the concrete type
-// without the framework's wider `Namespace` tripping them up.
 export type MongoNamespace = Namespace & {
-  readonly entries: Readonly<{
-    readonly collection: Readonly<Record<string, MongoCollection>>;
-  }>;
+  readonly entries: MongoNamespaceEntries;
 };
 
 export interface MongoStorageInput<THash extends string = string> {

package/src/ir/mongo-unbound-namespace.ts

@@ -3,15 +3,15 @@ import {
   NamespaceBase,
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
-import type { MongoCollection } from './mongo-collection';
+import type { MongoNamespaceEntries } from './mongo-storage';
 
 export class MongoUnboundNamespace extends NamespaceBase {
   static readonly instance: MongoUnboundNamespace = new MongoUnboundNamespace();
 
   readonly id = UNBOUND_NAMESPACE_ID;
-  readonly entries: Readonly<{
-    readonly collection: Readonly<Record<string, MongoCollection>>;
-  }> = Object.freeze({ collection: Object.freeze({}) });
+  readonly entries: MongoNamespaceEntries = Object.freeze({
+    collection: Object.freeze({}),
+  });
   declare readonly kind: string;
 
   private constructor() {

package/src/validate-storage.ts

@@ -9,7 +9,7 @@ function storageDeclaresCollection(
   collectionName: string,
 ): boolean {
   for (const ns of Object.values(storage.namespaces)) {
-    if (Object.hasOwn(ns.entries.collection, collectionName)) {
+    if (Object.hasOwn(ns.entries['collection'] ?? {}, collectionName)) {
       return true;
     }
   }