@prisma-next/family-mongo 0.10.0-dev.9 → 0.11.0

package/dist/control.mjs

@@ -1,5 +1,5 @@
 import { i as contractToMongoSchemaIR, n as canonicalizeSchemasForVerification, r as diffMongoSchemas, t as verifyMongoSchema } from "./verify-mongo-schema-Bhxvdah3.mjs";
-import { t as MongoContractSerializer } from "./mongo-contract-serializer-D9zGIqE9.mjs";
+import { t as MongoContractSerializer } from "./mongo-contract-serializer-qnignx7Y.mjs";
 import { mongoEmission } from "@prisma-next/mongo-emitter";
 import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH } from "@prisma-next/framework-components/control";
 import { assertDescriptorSelfConsistency } from "@prisma-next/migration-tools/spaces";

package/dist/ir.d.mts

@@ -1,5 +1,6 @@
 import { ContractSerializer, SchemaIssue, SchemaVerifier, SchemaVerifyOptions, SchemaVerifyResult } from "@prisma-next/framework-components/control";
 import { MongoContract, MongoStorage } from "@prisma-next/mongo-contract";
+import { Type } from "arktype";
 import { Namespace } from "@prisma-next/framework-components/ir";
 import { JsonObject } from "@prisma-next/utils/json";
 
@@ -26,6 +27,8 @@ import { JsonObject } from "@prisma-next/utils/json";
  * canonicalization override `serializeContract`.
  */
 declare abstract class MongoContractSerializerBase<TContract> implements ContractSerializer<TContract> {
+  private readonly contractSchema;
+  constructor(validatorFragments?: ReadonlyMap<string, Type<unknown>>);
   deserializeContract<T extends TContract = TContract>(json: unknown): T;
   serializeContract(contract: TContract): JsonObject;
   /**

package/dist/ir.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ir.d.mts","names":[],"sources":["../src/core/ir/mongo-contract-serializer-base.ts","../src/core/ir/mongo-contract-serializer.ts","../src/core/ir/mongo-schema-verifier-base.ts"],"mappings":";;;;;;;;;AAiCA;;;;;;;;;;;;;;;;;;uBAAsB,2BAAA,uBACT,kBAAA,CAAmB,SAAA;EAE9B,mBAAA,WAA8B,SAAA,GAAY,SAAA,CAAA,CAAW,IAAA,YAAgB,CAAA;EAKrE,iBAAA,CAAkB,QAAA,EAAU,SAAA,GAAY,UAAA;EALpB;;;;;;;;;;;;;;;;EAAA,UA4BV,2BAAA,CAA4B,IAAA,YAAgB,aAAA;EAwEA;;;;;;EAAA,UAtC5C,oBAAA,CAAqB,QAAA,EAAU,aAAA,GAAgB,aAAA;;ACrF3D;;;;;;;qBD2HqB,uBAAA,CAAwB,SAAA,EAAW,aAAA,GAAgB,SAAA;AAAA;;;;;;;AAvGxE;;;;;;cCpBa,uBAAA,SAAgC,2BAAA,CAA4B,aAAA;EAAA,UAC7D,uBAAA,CAAwB,SAAA,EAAW,aAAA,GAAgB,aAAA;AAAA;;;;;;ADmB/D;;;;;;;;;;;;;;;;;;uBEHsB,uBAAA;EAAA,SACS,OAAA,EAAS,YAAA;AAAA,uBAE3B,cAAA,CAAe,SAAA,EAAW,OAAA;EAErC,YAAA,CAAa,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,IAAW,kBAAA;EAAA,UAOtD,uBAAA,CACR,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,WAAA;EFR8B;;;;;;;;EAAA,mBEmCvB,eAAA,CAAgB,OAAA;IAAA,SACxB,QAAA,EAAU,SAAA;IAAA,SACV,MAAA,EAAQ,OAAA;IAAA,SACR,WAAA;IAAA,SACA,SAAA,EAAW,SAAA;EAAA,aACT,WAAA;EF4DM;;;;;EAAA,mBErDA,sBAAA,CACjB,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,WAAA;AAAA"}
+{"version":3,"file":"ir.d.mts","names":[],"sources":["../src/core/ir/mongo-contract-serializer-base.ts","../src/core/ir/mongo-contract-serializer.ts","../src/core/ir/mongo-schema-verifier-base.ts"],"mappings":";;;;;;;;;;AAkCA;;;;;;;;;;;;;;;;;;uBAAsB,2BAAA,uBACT,kBAAA,CAAmB,SAAA;EAAA,iBAEb,cAAA;cAEL,kBAAA,GAAqB,WAAA,SAAoB,IAAA;EAUrD,mBAAA,WAA8B,SAAA,GAAY,SAAA,CAAA,CAAW,IAAA,YAAgB,CAAA;EAKrE,iBAAA,CAAkB,QAAA,EAAU,SAAA,GAAY,UAAA;;;;;;;;;;;;;;;;;YAuB9B,2BAAA,CAA4B,IAAA,YAAgB,aAAA;EAmC5C;;;;;;EAAA,UAAA,oBAAA,CAAqB,QAAA,EAAU,aAAA,GAAgB,aAAA;EAsCa;;;;;;ACzIxE;;EDyIwE,mBAAnD,uBAAA,CAAwB,SAAA,EAAW,aAAA,GAAgB,SAAA;AAAA;;;;;;;;AApHxE;;;;;cCrBa,uBAAA,SAAgC,2BAAA,CAA4B,aAAA;EAAA,UAC7D,uBAAA,CAAwB,SAAA,EAAW,aAAA,GAAgB,aAAA;AAAA;;;;;;;ADoB/D;;;;;;;;;;;;;;;;;uBEJsB,uBAAA;EAAA,SACS,OAAA,EAAS,YAAA;AAAA,uBAE3B,cAAA,CAAe,SAAA,EAAW,OAAA;EAErC,YAAA,CAAa,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,IAAW,kBAAA;EAAA,UAOtD,uBAAA,CACR,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,WAAA;EFPK;;;;;;;;EAAA,mBEkCE,eAAA,CAAgB,OAAA;IAAA,SACxB,QAAA,EAAU,SAAA;IAAA,SACV,MAAA,EAAQ,OAAA;IAAA,SACR,WAAA;IAAA,SACA,SAAA,EAAW,SAAA;EAAA,aACT,WAAA;EFtB2B;;;;;EAAA,mBE6BrB,sBAAA,CACjB,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,WAAA;AAAA"}

package/dist/ir.mjs

@@ -1,4 +1,4 @@
-import { n as MongoContractSerializerBase, t as MongoContractSerializer } from "./mongo-contract-serializer-D9zGIqE9.mjs";
+import { n as MongoContractSerializerBase, t as MongoContractSerializer } from "./mongo-contract-serializer-qnignx7Y.mjs";
 //#region src/core/ir/mongo-schema-verifier-base.ts
 /**
 * Mongo family `SchemaVerifier` abstract base. Commits the Mongo family

package/dist/{mongo-contract-serializer-D9zGIqE9.mjs → mongo-contract-serializer-qnignx7Y.mjs}

@@ -1,5 +1,5 @@
 import { validateContractDomain } from "@prisma-next/contract/validate-domain";
-import { MongoCollection, MongoContractSchema, validateMongoStorage } from "@prisma-next/mongo-contract";
+import { MongoCollection, MongoContractSchema, createMongoContractSchema, validateMongoStorage } from "@prisma-next/mongo-contract";
 import { type } from "arktype";
 //#region src/core/ir/mongo-contract-serializer-base.ts
 /**
@@ -24,6 +24,10 @@ import { type } from "arktype";
 * canonicalization override `serializeContract`.
 */
 var MongoContractSerializerBase = class {
+	contractSchema;
+	constructor(validatorFragments) {
+		this.contractSchema = validatorFragments !== void 0 && validatorFragments.size > 0 ? createMongoContractSchema(validatorFragments) : void 0;
+	}
 	deserializeContract(json) {
 		const validated = this.parseMongoContractStructure(json);
 		return this.constructTargetContract(validated);
@@ -48,7 +52,7 @@ var MongoContractSerializerBase = class {
 	* subsystems and don't sit behind this SPI.
 	*/
 	parseMongoContractStructure(json) {
-		const parsed = MongoContractSchema(json);
+		const parsed = (this.contractSchema ?? MongoContractSchema)(json);
 		if (parsed instanceof type.errors) throw new Error(`Contract structural validation failed: ${parsed.summary}`);
 		const validatedShape = parsed;
 		const hydratedContract = this.hydrateMongoContract(validatedShape);
@@ -102,4 +106,4 @@ var MongoContractSerializer = class extends MongoContractSerializerBase {
 //#endregion
 export { MongoContractSerializerBase as n, MongoContractSerializer as t };
 
-//# sourceMappingURL=mongo-contract-serializer-D9zGIqE9.mjs.map
+//# sourceMappingURL=mongo-contract-serializer-qnignx7Y.mjs.map

package/dist/mongo-contract-serializer-qnignx7Y.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongo-contract-serializer-qnignx7Y.mjs","names":["arktypeType"],"sources":["../src/core/ir/mongo-contract-serializer-base.ts","../src/core/ir/mongo-contract-serializer.ts"],"sourcesContent":["import { validateContractDomain } from '@prisma-next/contract/validate-domain';\nimport type { ContractSerializer } from '@prisma-next/framework-components/control';\nimport {\n  createMongoContractSchema,\n  MongoCollection,\n  type MongoCollectionInput,\n  type MongoContract,\n  MongoContractSchema,\n  validateMongoStorage,\n} from '@prisma-next/mongo-contract';\nimport type { JsonObject } from '@prisma-next/utils/json';\nimport { type as arktypeType, type Type } from 'arktype';\n\n/**\n * Mongo family `ContractSerializer` abstract base. Owns the family-shared\n * deserialization pipeline:\n *\n * 1. Structural validation against the Mongo contract arktype schema\n *    (`MongoContractSchema`).\n * 2. Framework-shared domain validation (`validateContractDomain`).\n * 3. Family-shared storage validation (`validateMongoStorage`).\n *\n * The validated value is handed to the target via the\n * `constructTargetContract` hook, which wraps the plain-JSON shape in\n * the family-layer `MongoStorage` class instance (carrying the\n * target-supplied `namespaces` map). Targets that need to add\n * structural checks beyond the family default can override\n * `parseMongoContractStructure`.\n *\n * Default `serializeContract` is identity over the contract — Mongo\n * target classes carry JSON-clean fields by construction, so the value\n * can be `JSON.stringify`'d directly. Targets that need on-the-way-out\n * canonicalization override `serializeContract`.\n */\nexport abstract class MongoContractSerializerBase<TContract>\n  implements ContractSerializer<TContract>\n{\n  private readonly contractSchema: Type<unknown> | undefined;\n\n  constructor(validatorFragments?: ReadonlyMap<string, Type<unknown>>) {\n    // Mirrors the SQL base: only build a fragments-aware schema when\n    // pack contributions exist; otherwise the cached module-level\n    // default in `contract-schema.ts` covers the validation path.\n    this.contractSchema =\n      validatorFragments !== undefined && validatorFragments.size > 0\n        ? createMongoContractSchema(validatorFragments)\n        : undefined;\n  }\n\n  deserializeContract<T extends TContract = TContract>(json: unknown): T {\n    const validated = this.parseMongoContractStructure(json);\n    return this.constructTargetContract(validated) as T;\n  }\n\n  serializeContract(contract: TContract): JsonObject {\n    // Mongo contract class fields are JSON-clean by construction; the\n    // cast asserts that. Targets that need to canonicalize on the way\n    // out override this method.\n    return contract as unknown as JsonObject;\n  }\n\n  /**\n   * Family-shared structural validation: parse against the Mongo\n   * contract arktype schema, then run framework-shared domain + Mongo\n   * family storage checks, then hydrate the validated tree into Mongo\n   * Contract IR class instances. Targets can override to add\n   * target-specific structural checks; most targets accept the family\n   * default.\n   *\n   * The returned `MongoContract` carries class instances under\n   * `storage.namespaces[namespaceId].collections[collectionName]` (each value is a\n   * `MongoCollection`, with nested `MongoIndex` / `MongoValidator` /\n   * `MongoCollectionOptions` constructed by the `MongoCollection` constructor).\n   * The rest of the contract envelope (models, valueObjects, capabilities, …)\n   * remains in plain-JSON form; those IR layers are handled by sibling\n   * subsystems and don't sit behind this SPI.\n   */\n  protected parseMongoContractStructure(json: unknown): MongoContract {\n    const schema = this.contractSchema ?? MongoContractSchema;\n    const parsed = schema(json);\n    if (parsed instanceof arktypeType.errors) {\n      throw new Error(`Contract structural validation failed: ${parsed.summary}`);\n    }\n\n    // arktype's `infer`d type for `MongoContractSchema` is structurally\n    // equivalent to `MongoContract` (both describe the same on-disk JSON\n    // envelope) but not nominally so: the arktype DSL produces a type whose\n    // optional/readonly profile, narrowed string-literal positions, and\n    // utility-type wrappings (`Type.infer`, `Out`, …) differ from the\n    // hand-authored `MongoContract<S, M>` generic surface. The schema and\n    // the type are kept in lockstep by the round-trip fixtures under\n    // `test/validate.test.ts`. The hydration walk below additionally\n    // re-shapes `storage.namespaces.*.collections` from plain data into IR-class\n    // instances, so the `MongoContract` returned here carries class identity\n    // under those collections maps (and transitively under `indexes` / `validator`\n    // / `options`).\n    const validatedShape = parsed as unknown as MongoContract;\n\n    const hydratedContract = this.hydrateMongoContract(validatedShape);\n\n    validateContractDomain(hydratedContract);\n    validateMongoStorage(hydratedContract);\n\n    return hydratedContract;\n  }\n\n  /**\n   * Walk a structurally-validated Mongo contract and convert each\n   * `storage.namespaces[nsId].collections[collectionName]` entry from plain\n   * data into `MongoCollection` IR-class instances. Idempotent: already-class\n   * instances pass through unchanged.\n   */\n  protected hydrateMongoContract(contract: MongoContract): MongoContract {\n    const rawNamespaces = contract.storage.namespaces;\n    const hydratedNamespaces = Object.fromEntries(\n      Object.entries(rawNamespaces).map(([nsId, nsEnvelope]) => {\n        const rawCollections = nsEnvelope.collections ?? {};\n        const hydratedCollections = Object.fromEntries(\n          Object.entries(rawCollections).map(([name, raw]) => [\n            name,\n            raw instanceof MongoCollection ? raw : new MongoCollection(raw as MongoCollectionInput),\n          ]),\n        );\n        return [\n          nsId,\n          {\n            ...nsEnvelope,\n            id: nsEnvelope.id,\n            collections: hydratedCollections,\n          },\n        ];\n      }),\n    );\n    return {\n      ...contract,\n      storage: {\n        ...contract.storage,\n        namespaces: hydratedNamespaces,\n      },\n    };\n  }\n\n  /**\n   * Target-specific class construction from the validated structural\n   * data. The target wraps the contract envelope in the family-layer\n   * `MongoStorage` class instance, supplying the `namespaces` map\n   * (target concretions like `MongoTargetUnboundDatabase`). The\n   * leaf collection / index shapes are already family-layer IR-class\n   * instances after the hydration walk above.\n   */\n  protected abstract constructTargetContract(validated: MongoContract): TContract;\n}\n","import type { MongoContract } from '@prisma-next/mongo-contract';\nimport { MongoContractSerializerBase } from './mongo-contract-serializer-base';\n\n/**\n * Default Mongo family `ContractSerializer` concretion. Inherits the\n * Mongo-shared deserialization pipeline (structural validation +\n * collection-level hydration) and falls through `constructTargetContract`\n * with the validated `MongoContract` shape. Family-level call sites\n * (family-instance methods, family-layer tests that don't reach into\n * a target descriptor) instantiate this directly; targets with their\n * own storage concretion (`target-mongo`'s `MongoTargetContractSerializer`)\n * override `constructTargetContract` to wrap the storage shape.\n */\nexport class MongoContractSerializer extends MongoContractSerializerBase<MongoContract> {\n  protected constructTargetContract(validated: MongoContract): MongoContract {\n    return validated;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAsB,8BAAtB,MAEA;CACE;CAEA,YAAY,oBAAyD;EAInE,KAAK,iBACH,uBAAuB,KAAA,KAAa,mBAAmB,OAAO,IAC1D,0BAA0B,mBAAmB,GAC7C,KAAA;;CAGR,oBAAqD,MAAkB;EACrE,MAAM,YAAY,KAAK,4BAA4B,KAAK;EACxD,OAAO,KAAK,wBAAwB,UAAU;;CAGhD,kBAAkB,UAAiC;EAIjD,OAAO;;;;;;;;;;;;;;;;;;CAmBT,4BAAsC,MAA8B;EAElE,MAAM,UADS,KAAK,kBAAkB,qBAChB,KAAK;EAC3B,IAAI,kBAAkBA,KAAY,QAChC,MAAM,IAAI,MAAM,0CAA0C,OAAO,UAAU;EAe7E,MAAM,iBAAiB;EAEvB,MAAM,mBAAmB,KAAK,qBAAqB,eAAe;EAElE,uBAAuB,iBAAiB;EACxC,qBAAqB,iBAAiB;EAEtC,OAAO;;;;;;;;CAST,qBAA+B,UAAwC;EACrE,MAAM,gBAAgB,SAAS,QAAQ;EACvC,MAAM,qBAAqB,OAAO,YAChC,OAAO,QAAQ,cAAc,CAAC,KAAK,CAAC,MAAM,gBAAgB;GACxD,MAAM,iBAAiB,WAAW,eAAe,EAAE;GACnD,MAAM,sBAAsB,OAAO,YACjC,OAAO,QAAQ,eAAe,CAAC,KAAK,CAAC,MAAM,SAAS,CAClD,MACA,eAAe,kBAAkB,MAAM,IAAI,gBAAgB,IAA4B,CACxF,CAAC,CACH;GACD,OAAO,CACL,MACA;IACE,GAAG;IACH,IAAI,WAAW;IACf,aAAa;IACd,CACF;IACD,CACH;EACD,OAAO;GACL,GAAG;GACH,SAAS;IACP,GAAG,SAAS;IACZ,YAAY;IACb;GACF;;;;;;;;;;;;;;;AC9HL,IAAa,0BAAb,cAA6C,4BAA2C;CACtF,wBAAkC,WAAyC;EACzE,OAAO"}

package/package.json

@@ -1,30 +1,30 @@
 {
   "name": "@prisma-next/family-mongo",
-  "version": "0.10.0-dev.9",
+  "version": "0.11.0",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Mongo family descriptor for Prisma Next",
   "dependencies": {
-    "@prisma-next/contract": "0.10.0-dev.9",
-    "@prisma-next/emitter": "0.10.0-dev.9",
-    "@prisma-next/errors": "0.10.0-dev.9",
-    "@prisma-next/framework-components": "0.10.0-dev.9",
-    "@prisma-next/migration-tools": "0.10.0-dev.9",
-    "@prisma-next/mongo-contract": "0.10.0-dev.9",
-    "@prisma-next/mongo-emitter": "0.10.0-dev.9",
-    "@prisma-next/mongo-query-ast": "0.10.0-dev.9",
-    "@prisma-next/mongo-schema-ir": "0.10.0-dev.9",
-    "@prisma-next/utils": "0.10.0-dev.9",
+    "@prisma-next/contract": "0.11.0",
+    "@prisma-next/emitter": "0.11.0",
+    "@prisma-next/errors": "0.11.0",
+    "@prisma-next/framework-components": "0.11.0",
+    "@prisma-next/migration-tools": "0.11.0",
+    "@prisma-next/mongo-contract": "0.11.0",
+    "@prisma-next/mongo-emitter": "0.11.0",
+    "@prisma-next/mongo-query-ast": "0.11.0",
+    "@prisma-next/mongo-schema-ir": "0.11.0",
+    "@prisma-next/utils": "0.11.0",
     "arktype": "^2.2.0",
     "mongodb": "^6.16.0",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/mongo-contract-ts": "0.10.0-dev.9",
-    "@prisma-next/test-utils": "0.10.0-dev.9",
-    "@prisma-next/tsconfig": "0.10.0-dev.9",
-    "@prisma-next/tsdown": "0.10.0-dev.9",
+    "@prisma-next/mongo-contract-ts": "0.11.0",
+    "@prisma-next/test-utils": "0.11.0",
+    "@prisma-next/tsconfig": "0.11.0",
+    "@prisma-next/tsdown": "0.11.0",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.6"

package/src/core/ir/mongo-contract-serializer-base.ts

@@ -1,6 +1,7 @@
 import { validateContractDomain } from '@prisma-next/contract/validate-domain';
 import type { ContractSerializer } from '@prisma-next/framework-components/control';
 import {
+  createMongoContractSchema,
   MongoCollection,
   type MongoCollectionInput,
   type MongoContract,
@@ -8,7 +9,7 @@ import {
   validateMongoStorage,
 } from '@prisma-next/mongo-contract';
 import type { JsonObject } from '@prisma-next/utils/json';
-import { type as arktypeType } from 'arktype';
+import { type as arktypeType, type Type } from 'arktype';
 
 /**
  * Mongo family `ContractSerializer` abstract base. Owns the family-shared
@@ -34,6 +35,18 @@ import { type as arktypeType } from 'arktype';
 export abstract class MongoContractSerializerBase<TContract>
   implements ContractSerializer<TContract>
 {
+  private readonly contractSchema: Type<unknown> | undefined;
+
+  constructor(validatorFragments?: ReadonlyMap<string, Type<unknown>>) {
+    // Mirrors the SQL base: only build a fragments-aware schema when
+    // pack contributions exist; otherwise the cached module-level
+    // default in `contract-schema.ts` covers the validation path.
+    this.contractSchema =
+      validatorFragments !== undefined && validatorFragments.size > 0
+        ? createMongoContractSchema(validatorFragments)
+        : undefined;
+  }
+
   deserializeContract<T extends TContract = TContract>(json: unknown): T {
     const validated = this.parseMongoContractStructure(json);
     return this.constructTargetContract(validated) as T;
@@ -63,7 +76,8 @@ export abstract class MongoContractSerializerBase<TContract>
    * subsystems and don't sit behind this SPI.
    */
   protected parseMongoContractStructure(json: unknown): MongoContract {
-    const parsed = MongoContractSchema(json);
+    const schema = this.contractSchema ?? MongoContractSchema;
+    const parsed = schema(json);
     if (parsed instanceof arktypeType.errors) {
       throw new Error(`Contract structural validation failed: ${parsed.summary}`);
     }

package/dist/mongo-contract-serializer-D9zGIqE9.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"mongo-contract-serializer-D9zGIqE9.mjs","names":["arktypeType"],"sources":["../src/core/ir/mongo-contract-serializer-base.ts","../src/core/ir/mongo-contract-serializer.ts"],"sourcesContent":["import { validateContractDomain } from '@prisma-next/contract/validate-domain';\nimport type { ContractSerializer } from '@prisma-next/framework-components/control';\nimport {\n  MongoCollection,\n  type MongoCollectionInput,\n  type MongoContract,\n  MongoContractSchema,\n  validateMongoStorage,\n} from '@prisma-next/mongo-contract';\nimport type { JsonObject } from '@prisma-next/utils/json';\nimport { type as arktypeType } from 'arktype';\n\n/**\n * Mongo family `ContractSerializer` abstract base. Owns the family-shared\n * deserialization pipeline:\n *\n * 1. Structural validation against the Mongo contract arktype schema\n *    (`MongoContractSchema`).\n * 2. Framework-shared domain validation (`validateContractDomain`).\n * 3. Family-shared storage validation (`validateMongoStorage`).\n *\n * The validated value is handed to the target via the\n * `constructTargetContract` hook, which wraps the plain-JSON shape in\n * the family-layer `MongoStorage` class instance (carrying the\n * target-supplied `namespaces` map). Targets that need to add\n * structural checks beyond the family default can override\n * `parseMongoContractStructure`.\n *\n * Default `serializeContract` is identity over the contract — Mongo\n * target classes carry JSON-clean fields by construction, so the value\n * can be `JSON.stringify`'d directly. Targets that need on-the-way-out\n * canonicalization override `serializeContract`.\n */\nexport abstract class MongoContractSerializerBase<TContract>\n  implements ContractSerializer<TContract>\n{\n  deserializeContract<T extends TContract = TContract>(json: unknown): T {\n    const validated = this.parseMongoContractStructure(json);\n    return this.constructTargetContract(validated) as T;\n  }\n\n  serializeContract(contract: TContract): JsonObject {\n    // Mongo contract class fields are JSON-clean by construction; the\n    // cast asserts that. Targets that need to canonicalize on the way\n    // out override this method.\n    return contract as unknown as JsonObject;\n  }\n\n  /**\n   * Family-shared structural validation: parse against the Mongo\n   * contract arktype schema, then run framework-shared domain + Mongo\n   * family storage checks, then hydrate the validated tree into Mongo\n   * Contract IR class instances. Targets can override to add\n   * target-specific structural checks; most targets accept the family\n   * default.\n   *\n   * The returned `MongoContract` carries class instances under\n   * `storage.namespaces[namespaceId].collections[collectionName]` (each value is a\n   * `MongoCollection`, with nested `MongoIndex` / `MongoValidator` /\n   * `MongoCollectionOptions` constructed by the `MongoCollection` constructor).\n   * The rest of the contract envelope (models, valueObjects, capabilities, …)\n   * remains in plain-JSON form; those IR layers are handled by sibling\n   * subsystems and don't sit behind this SPI.\n   */\n  protected parseMongoContractStructure(json: unknown): MongoContract {\n    const parsed = MongoContractSchema(json);\n    if (parsed instanceof arktypeType.errors) {\n      throw new Error(`Contract structural validation failed: ${parsed.summary}`);\n    }\n\n    // arktype's `infer`d type for `MongoContractSchema` is structurally\n    // equivalent to `MongoContract` (both describe the same on-disk JSON\n    // envelope) but not nominally so: the arktype DSL produces a type whose\n    // optional/readonly profile, narrowed string-literal positions, and\n    // utility-type wrappings (`Type.infer`, `Out`, …) differ from the\n    // hand-authored `MongoContract<S, M>` generic surface. The schema and\n    // the type are kept in lockstep by the round-trip fixtures under\n    // `test/validate.test.ts`. The hydration walk below additionally\n    // re-shapes `storage.namespaces.*.collections` from plain data into IR-class\n    // instances, so the `MongoContract` returned here carries class identity\n    // under those collections maps (and transitively under `indexes` / `validator`\n    // / `options`).\n    const validatedShape = parsed as unknown as MongoContract;\n\n    const hydratedContract = this.hydrateMongoContract(validatedShape);\n\n    validateContractDomain(hydratedContract);\n    validateMongoStorage(hydratedContract);\n\n    return hydratedContract;\n  }\n\n  /**\n   * Walk a structurally-validated Mongo contract and convert each\n   * `storage.namespaces[nsId].collections[collectionName]` entry from plain\n   * data into `MongoCollection` IR-class instances. Idempotent: already-class\n   * instances pass through unchanged.\n   */\n  protected hydrateMongoContract(contract: MongoContract): MongoContract {\n    const rawNamespaces = contract.storage.namespaces;\n    const hydratedNamespaces = Object.fromEntries(\n      Object.entries(rawNamespaces).map(([nsId, nsEnvelope]) => {\n        const rawCollections = nsEnvelope.collections ?? {};\n        const hydratedCollections = Object.fromEntries(\n          Object.entries(rawCollections).map(([name, raw]) => [\n            name,\n            raw instanceof MongoCollection ? raw : new MongoCollection(raw as MongoCollectionInput),\n          ]),\n        );\n        return [\n          nsId,\n          {\n            ...nsEnvelope,\n            id: nsEnvelope.id,\n            collections: hydratedCollections,\n          },\n        ];\n      }),\n    );\n    return {\n      ...contract,\n      storage: {\n        ...contract.storage,\n        namespaces: hydratedNamespaces,\n      },\n    };\n  }\n\n  /**\n   * Target-specific class construction from the validated structural\n   * data. The target wraps the contract envelope in the family-layer\n   * `MongoStorage` class instance, supplying the `namespaces` map\n   * (target concretions like `MongoTargetUnboundDatabase`). The\n   * leaf collection / index shapes are already family-layer IR-class\n   * instances after the hydration walk above.\n   */\n  protected abstract constructTargetContract(validated: MongoContract): TContract;\n}\n","import type { MongoContract } from '@prisma-next/mongo-contract';\nimport { MongoContractSerializerBase } from './mongo-contract-serializer-base';\n\n/**\n * Default Mongo family `ContractSerializer` concretion. Inherits the\n * Mongo-shared deserialization pipeline (structural validation +\n * collection-level hydration) and falls through `constructTargetContract`\n * with the validated `MongoContract` shape. Family-level call sites\n * (family-instance methods, family-layer tests that don't reach into\n * a target descriptor) instantiate this directly; targets with their\n * own storage concretion (`target-mongo`'s `MongoTargetContractSerializer`)\n * override `constructTargetContract` to wrap the storage shape.\n */\nexport class MongoContractSerializer extends MongoContractSerializerBase<MongoContract> {\n  protected constructTargetContract(validated: MongoContract): MongoContract {\n    return validated;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAsB,8BAAtB,MAEA;CACE,oBAAqD,MAAkB;EACrE,MAAM,YAAY,KAAK,4BAA4B,KAAK;EACxD,OAAO,KAAK,wBAAwB,UAAU;;CAGhD,kBAAkB,UAAiC;EAIjD,OAAO;;;;;;;;;;;;;;;;;;CAmBT,4BAAsC,MAA8B;EAClE,MAAM,SAAS,oBAAoB,KAAK;EACxC,IAAI,kBAAkBA,KAAY,QAChC,MAAM,IAAI,MAAM,0CAA0C,OAAO,UAAU;EAe7E,MAAM,iBAAiB;EAEvB,MAAM,mBAAmB,KAAK,qBAAqB,eAAe;EAElE,uBAAuB,iBAAiB;EACxC,qBAAqB,iBAAiB;EAEtC,OAAO;;;;;;;;CAST,qBAA+B,UAAwC;EACrE,MAAM,gBAAgB,SAAS,QAAQ;EACvC,MAAM,qBAAqB,OAAO,YAChC,OAAO,QAAQ,cAAc,CAAC,KAAK,CAAC,MAAM,gBAAgB;GACxD,MAAM,iBAAiB,WAAW,eAAe,EAAE;GACnD,MAAM,sBAAsB,OAAO,YACjC,OAAO,QAAQ,eAAe,CAAC,KAAK,CAAC,MAAM,SAAS,CAClD,MACA,eAAe,kBAAkB,MAAM,IAAI,gBAAgB,IAA4B,CACxF,CAAC,CACH;GACD,OAAO,CACL,MACA;IACE,GAAG;IACH,IAAI,WAAW;IACf,aAAa;IACd,CACF;IACD,CACH;EACD,OAAO;GACL,GAAG;GACH,SAAS;IACP,GAAG,SAAS;IACZ,YAAY;IACb;GACF;;;;;;;;;;;;;;;AChHL,IAAa,0BAAb,cAA6C,4BAA2C;CACtF,wBAAkC,WAAyC;EACzE,OAAO"}