@prisma-next/family-mongo 0.12.0-dev.3 → 0.12.0-dev.31

package/src/core/control-instance.ts

@@ -1,4 +1,8 @@
-import type { Contract, ContractMarkerRecord } from '@prisma-next/contract/types';
+import type {
+  Contract,
+  ContractMarkerRecord,
+  LedgerEntryRecord,
+} from '@prisma-next/contract/types';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
   ControlDriverInstance,
@@ -76,19 +80,6 @@ function asValidatedMongoContract(contract: unknown): MongoContract {
   return contract as MongoContract;
 }
 
-function isMongoControlAdapter(value: unknown): value is MongoControlAdapter<'mongo'> {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'readMarker' in value &&
-    typeof (value as { readMarker: unknown }).readMarker === 'function' &&
-    'readAllMarkers' in value &&
-    typeof (value as { readAllMarkers: unknown }).readAllMarkers === 'function' &&
-    'introspectSchema' in value &&
-    typeof (value as { introspectSchema: unknown }).introspectSchema === 'function'
-  );
-}
-
 function buildVerifyResult(opts: {
   ok: boolean;
   code?: string;
@@ -164,13 +155,7 @@ export function createMongoFamilyInstance(controlStack: ControlStack): MongoCont
     if (!adapter) {
       throw new Error('Mongo family requires an adapter descriptor in ControlStack');
     }
-    const controlAdapter = adapter.create(controlStack as ControlStack<'mongo', 'mongo'>);
-    if (!isMongoControlAdapter(controlAdapter)) {
-      throw new Error(
-        'Adapter does not implement MongoControlAdapter (missing readMarker, readAllMarkers, or introspectSchema)',
-      );
-    }
-    return controlAdapter;
+    return adapter.create(controlStack as ControlStack<'mongo', 'mongo'>);
   };
 
   // The family-level driver type is `ControlDriverInstance<'mongo', string>`,
@@ -371,6 +356,10 @@ export function createMongoFamilyInstance(controlStack: ControlStack): MongoCont
       return getControlAdapter().readAllMarkers(asMongoDriver(options.driver));
     },
 
+    async readLedger(options): Promise<readonly LedgerEntryRecord[]> {
+      return getControlAdapter().readLedger(asMongoDriver(options.driver), options.space);
+    },
+
     async introspect(options): Promise<MongoSchemaIR> {
       return getControlAdapter().introspectSchema(asMongoDriver(options.driver));
     },

package/src/core/default-namespace.ts

@@ -0,0 +1,4 @@
+export {
+  defaultMongoDomainNamespaceId,
+  defaultMongoStorageNamespaceId,
+} from '@prisma-next/mongo-contract';

package/src/core/ir/mongo-schema-verifier-base.ts

@@ -1,3 +1,5 @@
+import type { ControlPolicy } from '@prisma-next/contract/types';
+import { effectiveControlPolicy } from '@prisma-next/contract/types';
 import type {
   SchemaIssue,
   SchemaVerifier,
@@ -5,7 +7,8 @@ import type {
   SchemaVerifyResult,
 } from '@prisma-next/framework-components/control';
 import type { Namespace } from '@prisma-next/framework-components/ir';
-import type { MongoStorage } from '@prisma-next/mongo-contract';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import type { MongoCollection, MongoStorage } from '@prisma-next/mongo-contract';
 
 /**
  * Mongo family `SchemaVerifier` abstract base. Commits the Mongo family
@@ -29,7 +32,10 @@ import type { MongoStorage } from '@prisma-next/mongo-contract';
  * list when no extensions exist over the Mongo family alphabet.
  */
 export abstract class MongoSchemaVerifierBase<
-  TContract extends { readonly storage: MongoStorage },
+  TContract extends {
+    readonly storage: MongoStorage;
+    readonly defaultControlPolicy?: ControlPolicy;
+  },
   TSchema,
 > implements SchemaVerifier<TContract, TSchema>
 {
@@ -40,6 +46,22 @@ export abstract class MongoSchemaVerifierBase<
     return { ok: issues.length === 0, issues };
   }
 
+  protected effectiveCollectionControlPolicy(
+    contract: TContract,
+    collection: MongoCollection | undefined,
+  ): ControlPolicy {
+    return effectiveControlPolicy(collection?.control, contract.defaultControlPolicy);
+  }
+
+  protected collectionControlPolicyForName(
+    contract: TContract,
+    collectionName: string,
+  ): ControlPolicy {
+    const namespace = contract.storage.namespaces[UNBOUND_NAMESPACE_ID];
+    const collection = namespace?.collections[collectionName];
+    return this.effectiveCollectionControlPolicy(contract, collection);
+  }
+
   protected verifyCommonMongoSchema(
     options: SchemaVerifyOptions<TContract, TSchema>,
   ): readonly SchemaIssue[] {

package/src/core/schema-diff.ts

@@ -1,3 +1,4 @@
+import type { ControlPolicy } from '@prisma-next/contract/types';
 import type {
   SchemaIssue,
   SchemaVerificationNode,
@@ -9,11 +10,13 @@ import type {
   MongoSchemaIR,
 } from '@prisma-next/mongo-schema-ir';
 import { canonicalize, deepEqual } from '@prisma-next/mongo-schema-ir';
+import { emitMongoIssueAndNodeUnderControlPolicy } from './schema-verify/mongo-control-verify-emit';
 
 export function diffMongoSchemas(
   live: MongoSchemaIR,
   expected: MongoSchemaIR,
   strict: boolean,
+  collectionControlPolicy: (collectionName: string) => ControlPolicy,
 ): {
   root: SchemaVerificationNode;
   issues: SchemaIssue[];
@@ -32,54 +35,70 @@ export function diffMongoSchemas(
     const expectedColl = expected.collection(name);
 
     if (!liveColl && expectedColl) {
-      issues.push({
+      const controlPolicy = collectionControlPolicy(name);
+      const issue: SchemaIssue = {
         kind: 'missing_table',
         table: name,
         message: `Collection "${name}" is missing from the database`,
-      });
-      collectionChildren.push({
-        status: 'fail',
-        kind: 'collection',
-        name,
-        contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${name}`,
-        code: 'MISSING_COLLECTION',
-        message: `Collection "${name}" is missing`,
-        expected: name,
-        actual: null,
-        children: [],
-      });
-      fail++;
+      };
+      const disposition = emitMongoIssueAndNodeUnderControlPolicy(
+        controlPolicy,
+        issue,
+        {
+          status: 'fail',
+          kind: 'collection',
+          name,
+          contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${name}`,
+          code: 'MISSING_COLLECTION',
+          message: `Collection "${name}" is missing`,
+          expected: name,
+          actual: null,
+          children: [],
+        },
+        issues,
+        collectionChildren,
+      );
+      if (disposition === 'fail') fail++;
+      else if (disposition === 'warn') warn++;
       continue;
     }
 
     if (liveColl && !expectedColl) {
-      const status = strict ? 'fail' : 'warn';
-      issues.push({
+      const controlPolicy = collectionControlPolicy(name);
+      const issue: SchemaIssue = {
         kind: 'extra_table',
         table: name,
         message: `Extra collection "${name}" exists in the database but not in the contract`,
-      });
-      collectionChildren.push({
-        status,
-        kind: 'collection',
-        name,
-        contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${name}`,
-        code: 'EXTRA_COLLECTION',
-        message: `Extra collection "${name}" found`,
-        expected: null,
-        actual: name,
-        children: [],
-      });
-      if (status === 'fail') fail++;
-      else warn++;
+      };
+      const baseStatus = strict ? 'fail' : 'warn';
+      const disposition = emitMongoIssueAndNodeUnderControlPolicy(
+        controlPolicy,
+        issue,
+        {
+          status: baseStatus,
+          kind: 'collection',
+          name,
+          contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${name}`,
+          code: 'EXTRA_COLLECTION',
+          message: `Extra collection "${name}" found`,
+          expected: null,
+          actual: name,
+          children: [],
+        },
+        issues,
+        collectionChildren,
+      );
+      if (disposition === 'fail') fail++;
+      else if (disposition === 'warn') warn++;
       continue;
     }
 
     const lc = liveColl as MongoSchemaCollection;
     const ec = expectedColl as MongoSchemaCollection;
-    const indexChildren = diffIndexes(name, lc, ec, strict, issues);
-    const validatorChildren = diffValidator(name, lc, ec, strict, issues);
-    const optionsChildren = diffOptions(name, lc, ec, strict, issues);
+    const controlPolicy = collectionControlPolicy(name);
+    const indexChildren = diffIndexes(name, lc, ec, strict, controlPolicy, issues);
+    const validatorChildren = diffValidator(name, lc, ec, strict, controlPolicy, issues);
+    const optionsChildren = diffOptions(name, lc, ec, strict, controlPolicy, issues);
     const children = [...indexChildren, ...validatorChildren, ...optionsChildren];
 
     const worstStatus = children.reduce<'pass' | 'warn' | 'fail'>(
@@ -156,6 +175,7 @@ function diffIndexes(
   live: MongoSchemaCollection,
   expected: MongoSchemaCollection,
   strict: boolean,
+  collectionControlPolicy: ControlPolicy,
   issues: SchemaIssue[],
 ): SchemaVerificationNode[] {
   const nodes: SchemaVerificationNode[] = [];
@@ -179,46 +199,58 @@ function diffIndexes(
         children: [],
       });
     } else {
-      issues.push({
+      const issue: SchemaIssue = {
         kind: 'index_mismatch',
         table: collName,
         indexOrConstraint: formatIndexName(idx),
         message: `Index ${formatIndexName(idx)} missing on collection "${collName}"`,
-      });
-      nodes.push({
-        status: 'fail',
-        kind: 'index',
-        name: formatIndexName(idx),
-        contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${collName}.indexes`,
-        code: 'MISSING_INDEX',
-        message: `Index ${formatIndexName(idx)} missing`,
-        expected: key,
-        actual: null,
-        children: [],
-      });
+      };
+      emitMongoIssueAndNodeUnderControlPolicy(
+        collectionControlPolicy,
+        issue,
+        {
+          status: 'fail',
+          kind: 'index',
+          name: formatIndexName(idx),
+          contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${collName}.indexes`,
+          code: 'MISSING_INDEX',
+          message: `Index ${formatIndexName(idx)} missing`,
+          expected: key,
+          actual: null,
+          children: [],
+        },
+        issues,
+        nodes,
+      );
     }
   }
 
   for (const [key, idx] of liveLookup) {
     if (!expectedLookup.has(key)) {
-      const status = strict ? 'fail' : 'warn';
-      issues.push({
+      const issue: SchemaIssue = {
         kind: 'extra_index',
         table: collName,
         indexOrConstraint: formatIndexName(idx),
         message: `Extra index ${formatIndexName(idx)} on collection "${collName}"`,
-      });
-      nodes.push({
-        status,
-        kind: 'index',
-        name: formatIndexName(idx),
-        contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${collName}.indexes`,
-        code: 'EXTRA_INDEX',
-        message: `Extra index ${formatIndexName(idx)}`,
-        expected: null,
-        actual: key,
-        children: [],
-      });
+      };
+      const baseStatus = strict ? 'fail' : 'warn';
+      emitMongoIssueAndNodeUnderControlPolicy(
+        collectionControlPolicy,
+        issue,
+        {
+          status: baseStatus,
+          kind: 'index',
+          name: formatIndexName(idx),
+          contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${collName}.indexes`,
+          code: 'EXTRA_INDEX',
+          message: `Extra index ${formatIndexName(idx)}`,
+          expected: null,
+          actual: key,
+          children: [],
+        },
+        issues,
+        nodes,
+      );
     }
   }
 
@@ -230,17 +262,21 @@ function diffValidator(
   live: MongoSchemaCollection,
   expected: MongoSchemaCollection,
   strict: boolean,
+  collectionControlPolicy: ControlPolicy,
   issues: SchemaIssue[],
 ): SchemaVerificationNode[] {
   if (!live.validator && !expected.validator) return [];
 
   if (expected.validator && !live.validator) {
-    issues.push({
+    const issue: SchemaIssue = {
       kind: 'type_missing',
       table: collName,
       message: `Validator missing on collection "${collName}"`,
-    });
-    return [
+    };
+    const nodes: SchemaVerificationNode[] = [];
+    emitMongoIssueAndNodeUnderControlPolicy(
+      collectionControlPolicy,
+      issue,
       {
         status: 'fail',
         kind: 'validator',
@@ -252,19 +288,25 @@ function diffValidator(
         actual: null,
         children: [],
       },
-    ];
+      issues,
+      nodes,
+    );
+    return nodes;
   }
 
   if (!expected.validator && live.validator) {
-    const status = strict ? 'fail' : 'warn';
-    issues.push({
+    const issue: SchemaIssue = {
       kind: 'extra_validator',
       table: collName,
       message: `Extra validator on collection "${collName}"`,
-    });
-    return [
+    };
+    const nodes: SchemaVerificationNode[] = [];
+    const baseStatus = strict ? 'fail' : 'warn';
+    emitMongoIssueAndNodeUnderControlPolicy(
+      collectionControlPolicy,
+      issue,
       {
-        status,
+        status: baseStatus,
         kind: 'validator',
         name: 'validator',
         contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${collName}.validator`,
@@ -274,7 +316,10 @@ function diffValidator(
         actual: canonicalize(live.validator.jsonSchema),
         children: [],
       },
-    ];
+      issues,
+      nodes,
+    );
+    return nodes;
   }
 
   const liveVal = live.validator as NonNullable<typeof live.validator>;
@@ -287,14 +332,17 @@ function diffValidator(
     liveVal.validationLevel !== expectedVal.validationLevel ||
     liveVal.validationAction !== expectedVal.validationAction
   ) {
-    issues.push({
+    const issue: SchemaIssue = {
       kind: 'type_mismatch',
       table: collName,
       expected: expectedSchema,
       actual: liveSchema,
       message: `Validator mismatch on collection "${collName}"`,
-    });
-    return [
+    };
+    const nodes: SchemaVerificationNode[] = [];
+    emitMongoIssueAndNodeUnderControlPolicy(
+      collectionControlPolicy,
+      issue,
       {
         status: 'fail',
         kind: 'validator',
@@ -314,7 +362,10 @@ function diffValidator(
         },
         children: [],
       },
-    ];
+      issues,
+      nodes,
+    );
+    return nodes;
   }
 
   return [
@@ -337,21 +388,25 @@ function diffOptions(
   live: MongoSchemaCollection,
   expected: MongoSchemaCollection,
   strict: boolean,
+  collectionControlPolicy: ControlPolicy,
   issues: SchemaIssue[],
 ): SchemaVerificationNode[] {
   if (!live.options && !expected.options) return [];
 
   if (!expected.options && live.options) {
-    const status = strict ? 'fail' : 'warn';
-    issues.push({
+    const issue: SchemaIssue = {
       kind: 'type_mismatch',
       table: collName,
       actual: canonicalize(live.options),
       message: `Extra collection options on "${collName}"`,
-    });
-    return [
+    };
+    const nodes: SchemaVerificationNode[] = [];
+    const baseStatus = strict ? 'fail' : 'warn';
+    emitMongoIssueAndNodeUnderControlPolicy(
+      collectionControlPolicy,
+      issue,
       {
-        status,
+        status: baseStatus,
         kind: 'options',
         name: 'options',
         contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${collName}.options`,
@@ -361,7 +416,10 @@ function diffOptions(
         actual: live.options,
         children: [],
       },
-    ];
+      issues,
+      nodes,
+    );
+    return nodes;
   }
 
   if (deepEqual(live.options, expected.options)) {
@@ -380,14 +438,17 @@ function diffOptions(
     ];
   }
 
-  issues.push({
+  const issue: SchemaIssue = {
     kind: 'type_mismatch',
     table: collName,
     expected: canonicalize(expected.options),
     actual: canonicalize(live.options),
     message: `Collection options mismatch on "${collName}"`,
-  });
-  return [
+  };
+  const nodes: SchemaVerificationNode[] = [];
+  emitMongoIssueAndNodeUnderControlPolicy(
+    collectionControlPolicy,
+    issue,
     {
       status: 'fail',
       kind: 'options',
@@ -399,5 +460,8 @@ function diffOptions(
       actual: live.options,
       children: [],
     },
-  ];
+    issues,
+    nodes,
+  );
+  return nodes;
 }

package/src/core/schema-verify/mongo-control-verify-emit.ts

@@ -0,0 +1,53 @@
+import type { ControlPolicy } from '@prisma-next/contract/types';
+import type {
+  SchemaIssue,
+  SchemaVerificationNode,
+  VerifierOutcome,
+} from '@prisma-next/framework-components/control';
+import { verifierDisposition } from './verifier-disposition';
+
+/**
+ * Reconciles a control-policy disposition with the Mongo family's strict-mode
+ * contract for live-only extras — the single point where `strict` and the
+ * control policy meet.
+ *
+ * The control policy decides first; only a `fail` is reconciled against the
+ * caller's base node status. Call sites stamp a live-only extra with
+ * `strict ? 'fail' : 'warn'` and a declared missing/mismatch with `fail`, so
+ * this one step encodes the whole matrix:
+ *
+ * | live-vs-declared                    | strict   | non-strict |
+ * |-------------------------------------|----------|------------|
+ * | declared missing / mismatch         | fail     | fail       |
+ * | live-only extra (managed/tolerated) | fail     | warn       |
+ * | live-only extra (external)          | suppress (extras ignored, both modes) |
+ * | anything (observed)                 | warn (both modes)     |
+ *
+ * `tolerated` no longer diverges from `managed` on a non-strict extra index:
+ * both soften to `warn`, because the softening comes from the base status the
+ * caller already computed from `strict`, not from per-policy special-casing.
+ */
+function reconcileMongoOutcome(
+  controlPolicy: ControlPolicy,
+  issueKind: SchemaIssue['kind'],
+  baseStatus: SchemaVerificationNode['status'],
+): VerifierOutcome {
+  const disposition = verifierDisposition(controlPolicy, issueKind);
+  return disposition === 'fail' ? baseStatus : disposition;
+}
+
+export function emitMongoIssueAndNodeUnderControlPolicy(
+  controlPolicy: ControlPolicy,
+  issue: SchemaIssue,
+  node: SchemaVerificationNode,
+  issues: SchemaIssue[],
+  nodes: SchemaVerificationNode[],
+): VerifierOutcome {
+  const outcome = reconcileMongoOutcome(controlPolicy, issue.kind, node.status);
+  if (outcome === 'suppress') {
+    return 'suppress';
+  }
+  issues.push(issue);
+  nodes.push({ ...node, status: outcome });
+  return outcome;
+}

package/src/core/schema-verify/verifier-disposition.ts

@@ -0,0 +1,42 @@
+import type { ControlPolicy } from '@prisma-next/contract/types';
+import type {
+  SchemaIssue,
+  VerifierIssueCategory,
+  VerifierOutcome,
+} from '@prisma-next/framework-components/control';
+import { dispositionForCategory } from '@prisma-next/framework-components/control';
+
+/**
+ * Classifies the verifier issue kinds the Mongo schema differ emits into the
+ * target-neutral categories the framework grades. Mongo only emits the kinds
+ * listed below (missing/extra collections, missing/extra indexes, missing/extra
+ * validators, and validator/options mismatches coded as `type_mismatch`); any
+ * other kind never reaches this classifier and is graded conservatively as a
+ * declared-incompatible divergence. Mongo owns this mapping rather than
+ * importing the SQL classifier — the two families share only the framework's
+ * category grading.
+ */
+export function classifyMongoVerifierIssueKind(kind: SchemaIssue['kind']): VerifierIssueCategory {
+  switch (kind) {
+    case 'extra_table':
+      return 'extraTopLevelObject';
+    case 'extra_index':
+    case 'extra_validator':
+      return 'extraAuxiliary';
+    case 'missing_table':
+    case 'type_missing':
+      return 'declaredMissing';
+    case 'index_mismatch':
+    case 'type_mismatch':
+      return 'declaredIncompatible';
+    default:
+      return 'declaredIncompatible';
+  }
+}
+
+export function verifierDisposition(
+  controlPolicy: ControlPolicy,
+  issueKind: SchemaIssue['kind'],
+): VerifierOutcome {
+  return dispositionForCategory(controlPolicy, classifyMongoVerifierIssueKind(issueKind));
+}

package/src/core/schema-verify/verify-mongo-schema.ts

@@ -1,10 +1,12 @@
+import { type ControlPolicy, effectiveControlPolicy } from '@prisma-next/contract/types';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
   OperationContext,
   VerifyDatabaseSchemaResult,
 } from '@prisma-next/framework-components/control';
 import { VERIFY_CODE_SCHEMA_FAILURE } from '@prisma-next/framework-components/control';
-import type { MongoContract } from '@prisma-next/mongo-contract';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import type { MongoCollection, MongoContract } from '@prisma-next/mongo-contract';
 import type { MongoSchemaIR } from '@prisma-next/mongo-schema-ir';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { contractToMongoSchemaIR } from '../contract-to-schema';
@@ -35,7 +37,13 @@ export function verifyMongoSchema(options: VerifyMongoSchemaOptions): VerifyData
     schema,
     expectedIR,
   );
-  const { root, issues, counts } = diffMongoSchemas(canonicalLive, canonicalExpected, strict);
+  const collectionControlPolicy = resolveMongoCollectionControlPolicy(contract);
+  const { root, issues, counts } = diffMongoSchemas(
+    canonicalLive,
+    canonicalExpected,
+    strict,
+    collectionControlPolicy,
+  );
 
   const ok = counts.fail === 0;
   const profileHash = typeof contract.profileHash === 'string' ? contract.profileHash : '';
@@ -58,3 +66,13 @@ export function verifyMongoSchema(options: VerifyMongoSchemaOptions): VerifyData
     timings: { total: Date.now() - startTime },
   };
 }
+
+function resolveMongoCollectionControlPolicy(
+  contract: MongoContract,
+): (collectionName: string) => ControlPolicy {
+  const namespace = contract.storage.namespaces[UNBOUND_NAMESPACE_ID];
+  const collections: Record<string, MongoCollection> = namespace?.collections ?? {};
+  const defaultControlPolicy = contract.defaultControlPolicy;
+  return (collectionName: string) =>
+    effectiveControlPolicy(collections[collectionName]?.control, defaultControlPolicy);
+}

package/src/exports/runtime.ts

@@ -0,0 +1,4 @@
+export {
+  defaultMongoDomainNamespaceId,
+  defaultMongoStorageNamespaceId,
+} from '../core/default-namespace';