@prisma-next/adapter-mongo 0.12.0-dev.31 → 0.12.0-dev.33

package/package.json

@@ -1,37 +1,37 @@
 {
   "name": "@prisma-next/adapter-mongo",
-  "version": "0.12.0-dev.31",
+  "version": "0.12.0-dev.33",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "MongoDB adapter for Prisma Next (lowers commands to wire format)",
   "dependencies": {
-    "@prisma-next/config": "0.12.0-dev.31",
-    "@prisma-next/contract": "0.12.0-dev.31",
-    "@prisma-next/errors": "0.12.0-dev.31",
-    "@prisma-next/family-mongo": "0.12.0-dev.31",
-    "@prisma-next/framework-components": "0.12.0-dev.31",
-    "@prisma-next/migration-tools": "0.12.0-dev.31",
-    "@prisma-next/mongo-codec": "0.12.0-dev.31",
-    "@prisma-next/mongo-contract": "0.12.0-dev.31",
-    "@prisma-next/mongo-lowering": "0.12.0-dev.31",
-    "@prisma-next/mongo-query-ast": "0.12.0-dev.31",
-    "@prisma-next/mongo-schema-ir": "0.12.0-dev.31",
-    "@prisma-next/mongo-value": "0.12.0-dev.31",
-    "@prisma-next/mongo-wire": "0.12.0-dev.31",
-    "@prisma-next/operations": "0.12.0-dev.31",
-    "@prisma-next/utils": "0.12.0-dev.31",
+    "@prisma-next/config": "0.12.0-dev.33",
+    "@prisma-next/contract": "0.12.0-dev.33",
+    "@prisma-next/errors": "0.12.0-dev.33",
+    "@prisma-next/family-mongo": "0.12.0-dev.33",
+    "@prisma-next/framework-components": "0.12.0-dev.33",
+    "@prisma-next/migration-tools": "0.12.0-dev.33",
+    "@prisma-next/mongo-codec": "0.12.0-dev.33",
+    "@prisma-next/mongo-contract": "0.12.0-dev.33",
+    "@prisma-next/mongo-lowering": "0.12.0-dev.33",
+    "@prisma-next/mongo-query-ast": "0.12.0-dev.33",
+    "@prisma-next/mongo-schema-ir": "0.12.0-dev.33",
+    "@prisma-next/mongo-value": "0.12.0-dev.33",
+    "@prisma-next/mongo-wire": "0.12.0-dev.33",
+    "@prisma-next/operations": "0.12.0-dev.33",
+    "@prisma-next/utils": "0.12.0-dev.33",
     "arktype": "^2.2.0"
   },
   "devDependencies": {
     "mongodb": "^7.2.0",
-    "@prisma-next/driver-mongo": "0.12.0-dev.31",
-    "@prisma-next/errors": "0.12.0-dev.31",
-    "@prisma-next/mongo-contract-psl": "0.12.0-dev.31",
-    "@prisma-next/psl-parser": "0.12.0-dev.31",
-    "@prisma-next/test-utils": "0.12.0-dev.31",
-    "@prisma-next/tsconfig": "0.12.0-dev.31",
-    "@prisma-next/tsdown": "0.12.0-dev.31",
+    "@prisma-next/driver-mongo": "0.12.0-dev.33",
+    "@prisma-next/errors": "0.12.0-dev.33",
+    "@prisma-next/mongo-contract-psl": "0.12.0-dev.33",
+    "@prisma-next/psl-parser": "0.12.0-dev.33",
+    "@prisma-next/test-utils": "0.12.0-dev.33",
+    "@prisma-next/tsconfig": "0.12.0-dev.33",
+    "@prisma-next/tsdown": "0.12.0-dev.33",
     "mongodb-memory-server": "11.1.0",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",

package/src/core/marker-ledger.ts

@@ -1,7 +1,6 @@
-import type { ContractMarkerRecord, LedgerEntryRecord } from '@prisma-next/contract/types';
-import { parseMarkerRowSafely, withMarkerReadErrorHandling } from '@prisma-next/errors/execution';
-import { ledgerOriginFromStored } from '@prisma-next/migration-tools/ledger-origin';
-import {
+import type { ContractMarkerRecord } from '@prisma-next/contract/types';
+import { parseMarkerRowSafely } from '@prisma-next/errors/execution';
+import type {
   RawAggregateCommand,
   RawFindOneAndUpdateCommand,
   RawInsertOneCommand,
@@ -9,21 +8,10 @@ import {
 import { type } from 'arktype';
 import type { Db, Document, UpdateFilter } from 'mongodb';
 
-const COLLECTION = '_prisma_migrations';
-const MONGO_MARKER_COLLECTION = `_prisma_migrations marker documents in ${COLLECTION}`;
-const MONGO_LEDGER_COLLECTION = `_prisma_migrations ledger documents in ${COLLECTION}`;
+export const COLLECTION = '_prisma_migrations';
+export const MONGO_MARKER_COLLECTION = `_prisma_migrations marker documents in ${COLLECTION}`;
+export const MONGO_LEDGER_COLLECTION = `_prisma_migrations ledger documents in ${COLLECTION}`;
 
-/**
- * Marker doc shape.
- *
- * Same fields as the SQL marker row but camelCase + Mongo-native types:
- * `Date` is BSON-hydrated, `meta` is a native object (not JSON-stringified),
- * `_id` and any extension fields are tolerated. `invariants?` is optional —
- * absent reads as `[]` (schemaless default); present-but-malformed throws.
- *
- * `space` is required: every marker doc is keyed by its space id (`_id`)
- * and stamped with a matching `space` field for partitioned reads.
- */
 const MongoMarkerDocSchema = type({
   space: 'string',
   storageHash: 'string',
@@ -37,7 +25,7 @@ const MongoMarkerDocSchema = type({
   '+': 'delete',
 });
 
-function parseMongoMarkerDoc(doc: unknown): ContractMarkerRecord {
+export function parseMongoMarkerDoc(doc: unknown): ContractMarkerRecord {
   const result = MongoMarkerDocSchema(doc);
   if (result instanceof type.errors) {
     throw new Error(`Invalid marker doc on ${COLLECTION}: ${result.summary}`);
@@ -54,258 +42,31 @@ function parseMongoMarkerDoc(doc: unknown): ContractMarkerRecord {
   };
 }
 
-function parseMongoMarkerDocSafely(doc: unknown, space: string): ContractMarkerRecord {
+export function parseMongoMarkerDocSafely(doc: unknown, space: string): ContractMarkerRecord {
   return parseMarkerRowSafely(doc, parseMongoMarkerDoc, {
     space,
     markerLocation: MONGO_MARKER_COLLECTION,
   });
 }
 
-async function executeAggregate(db: Db, cmd: RawAggregateCommand): Promise<Document[]> {
+export async function executeAggregate(db: Db, cmd: RawAggregateCommand): Promise<Document[]> {
   return db
     .collection(cmd.collection)
     .aggregate(cmd.pipeline as Record<string, unknown>[])
     .toArray();
 }
 
-async function executeInsertOne(db: Db, cmd: RawInsertOneCommand): Promise<void> {
+export async function executeInsertOne(db: Db, cmd: RawInsertOneCommand): Promise<void> {
   await db.collection(cmd.collection).insertOne(cmd.document);
 }
 
-async function executeFindOneAndUpdate(
+export async function executeFindOneAndUpdate(
   db: Db,
   cmd: RawFindOneAndUpdateCommand,
 ): Promise<Document | null> {
-  // `cmd.update` is `Document | ReadonlyArray<Document>` per the AST. The
-  // MongoDB driver's `findOneAndUpdate` accepts the same shape under the
-  // type `UpdateFilter<T> | Document[]`. The driver's runtime path handles
-  // both forms identically — pipelines (array) and update docs (object).
-  // One cast to that union keeps the call single-arm.
   return db
     .collection(cmd.collection)
     .findOneAndUpdate(cmd.filter, cmd.update as UpdateFilter<Document> | Document[], {
       upsert: cmd.upsert,
     });
 }
-
-/**
- * Reads the marker document for the given contract space, or returns
- * `null` if no marker has been written for that space yet. Each space
- * owns one row keyed by `_id: <space>` — see ADR 212 for the per-space
- * mechanism this enables.
- */
-export async function readMarker(db: Db, space: string): Promise<ContractMarkerRecord | null> {
-  const markerContext = { space, markerLocation: MONGO_MARKER_COLLECTION };
-  const docs = await withMarkerReadErrorHandling(
-    () =>
-      executeAggregate(
-        db,
-        new RawAggregateCommand(COLLECTION, [{ $match: { _id: space, space } }, { $limit: 1 }]),
-      ),
-    markerContext,
-  );
-  const doc = docs[0];
-  if (!doc) return null;
-  return parseMongoMarkerDocSafely(doc, space);
-}
-
-/**
- * Reads every marker doc in the collection (one per contract space)
- * and returns them keyed by `space`. Used by the per-space verifier
- * to detect marker-vs-on-disk drift and orphan marker rows. Returns
- * an empty map when no marker docs have been written yet.
- *
- * Marker docs are keyed by `_id: <space>` (string); ledger entries
- * live in the same collection but use a driver-generated `ObjectId`
- * `_id` plus `type: 'ledger'`. The filter selects string-keyed docs
- * with a `space` field, which excludes ledger entries by construction.
- */
-export async function readAllMarkers(db: Db): Promise<ReadonlyMap<string, ContractMarkerRecord>> {
-  const markerContext = { space: 'app', markerLocation: MONGO_MARKER_COLLECTION };
-  const docs = await withMarkerReadErrorHandling(
-    () =>
-      executeAggregate(
-        db,
-        new RawAggregateCommand(COLLECTION, [
-          {
-            $match: {
-              _id: { $type: 'string' },
-              space: { $type: 'string' },
-              $expr: { $eq: ['$_id', '$space'] },
-            },
-          },
-        ]),
-      ),
-    markerContext,
-  );
-  const out = new Map<string, ContractMarkerRecord>();
-  for (const doc of docs) {
-    const space = doc['space'];
-    /* v8 ignore next -- @preserve type-narrowing guard: the $match stage above filters on `space: { $type: 'string' }`, so this branch is unreachable at runtime. The check exists so the `out.set(space, ...)` call below can accept `string`. */
-    if (typeof space !== 'string') continue;
-    out.set(space, parseMongoMarkerDocSafely(doc, space));
-  }
-  return out;
-}
-
-export async function initMarker(
-  db: Db,
-  space: string,
-  destination: {
-    readonly storageHash: string;
-    readonly profileHash: string;
-    readonly invariants?: readonly string[];
-  },
-): Promise<void> {
-  const cmd = new RawInsertOneCommand(COLLECTION, {
-    _id: space,
-    space,
-    storageHash: destination.storageHash,
-    profileHash: destination.profileHash,
-    contractJson: null,
-    canonicalVersion: null,
-    updatedAt: new Date(),
-    appTag: null,
-    meta: {},
-    invariants: destination.invariants ?? [],
-  });
-  await executeInsertOne(db, cmd);
-}
-
-/**
- * Updates the marker doc for the given space atomically (CAS on
- * `expectedFrom`).
- *
- * `destination.invariants`:
- * - `undefined` → existing field left untouched.
- * - explicit value → merged into the existing field server-side via an
- *   aggregation pipeline (`$setUnion + $sortArray`), atomic at the
- *   document level. `[]` is a no-op merge.
- */
-export async function updateMarker(
-  db: Db,
-  space: string,
-  expectedFrom: string,
-  destination: {
-    readonly storageHash: string;
-    readonly profileHash: string;
-    readonly invariants?: readonly string[];
-  },
-): Promise<boolean> {
-  const setBase: Record<string, unknown> = {
-    storageHash: destination.storageHash,
-    profileHash: destination.profileHash,
-    updatedAt: new Date(),
-  };
-  // When invariants is supplied, use an aggregation pipeline so the
-  // merge runs server-side against the doc's current value (atomic, no
-  // read-then-write window). When omitted, a regular update doc keeps
-  // the field untouched.
-  const update: Document | Document[] =
-    destination.invariants === undefined
-      ? { $set: setBase }
-      : [
-          {
-            $set: {
-              ...setBase,
-              invariants: {
-                $sortArray: {
-                  input: { $setUnion: [{ $ifNull: ['$invariants', []] }, destination.invariants] },
-                  sortBy: 1,
-                },
-              },
-            },
-          },
-        ];
-  const cmd = new RawFindOneAndUpdateCommand(
-    COLLECTION,
-    { _id: space, space, storageHash: expectedFrom },
-    update,
-    false,
-  );
-  const result = await executeFindOneAndUpdate(db, cmd);
-  return result !== null;
-}
-
-/**
- * Reads per-migration ledger entries in apply order. When `space` is omitted,
- * returns rows for every space. Returns `[]` when no ledger documents exist yet.
- */
-export async function readLedger(db: Db, space?: string): Promise<readonly LedgerEntryRecord[]> {
-  const ledgerContext = { space: space ?? '*', markerLocation: MONGO_LEDGER_COLLECTION };
-  const matchStage: Record<string, unknown> = { type: 'ledger' };
-  if (space !== undefined) {
-    matchStage['space'] = space;
-  }
-  const docs = await withMarkerReadErrorHandling(
-    () =>
-      executeAggregate(
-        db,
-        new RawAggregateCommand(COLLECTION, [{ $match: matchStage }, { $sort: { _id: 1 } }]),
-      ),
-    ledgerContext,
-  );
-
-  const entries: LedgerEntryRecord[] = [];
-  for (const doc of docs) {
-    const migrationName = doc['migrationName'];
-    const migrationHash = doc['migrationHash'];
-    const from = doc['from'];
-    const to = doc['to'];
-    const docSpace = doc['space'];
-    if (typeof migrationName !== 'string' || typeof migrationHash !== 'string') {
-      continue;
-    }
-    if (typeof from !== 'string' || typeof to !== 'string') {
-      continue;
-    }
-    if (typeof docSpace !== 'string') {
-      continue;
-    }
-    const appliedAt = doc['appliedAt'];
-    const appliedAtDate =
-      appliedAt instanceof Date
-        ? appliedAt
-        : appliedAt !== undefined
-          ? new Date(String(appliedAt))
-          : new Date();
-    const operations = doc['operations'];
-    const opList = Array.isArray(operations) ? operations : [];
-    entries.push({
-      space: docSpace,
-      migrationName,
-      migrationHash,
-      from: ledgerOriginFromStored(from),
-      to,
-      appliedAt: appliedAtDate,
-      operationCount: opList.length,
-    });
-  }
-  return entries;
-}
-
-export async function writeLedgerEntry(
-  db: Db,
-  space: string,
-  entry: {
-    readonly edgeId: string;
-    readonly from: string;
-    readonly to: string;
-    readonly migrationName: string;
-    readonly migrationHash: string;
-    readonly operations: readonly unknown[];
-  },
-): Promise<void> {
-  const cmd = new RawInsertOneCommand(COLLECTION, {
-    type: 'ledger',
-    space,
-    edgeId: entry.edgeId,
-    from: entry.from,
-    to: entry.to,
-    migrationName: entry.migrationName,
-    migrationHash: entry.migrationHash,
-    operations: entry.operations,
-    appliedAt: new Date(),
-  });
-  await executeInsertOne(db, cmd);
-}

package/src/core/mongo-control-adapter.ts

@@ -1,15 +1,24 @@
 import type { ContractMarkerRecord, LedgerEntryRecord } from '@prisma-next/contract/types';
+import { withMarkerReadErrorHandling } from '@prisma-next/errors/execution';
 import type { MongoControlAdapter } from '@prisma-next/family-mongo/control-adapter';
 import type { ControlDriverInstance } from '@prisma-next/framework-components/control';
+import { ledgerOriginFromStored } from '@prisma-next/migration-tools/ledger-origin';
+import {
+  RawAggregateCommand,
+  RawFindOneAndUpdateCommand,
+  RawInsertOneCommand,
+} from '@prisma-next/mongo-query-ast/execution';
 import type { MongoSchemaIR } from '@prisma-next/mongo-schema-ir';
+import type { Document } from 'mongodb';
 import { introspectSchema } from './introspect-schema';
 import {
-  initMarker,
-  readAllMarkers,
-  readLedger,
-  readMarker,
-  updateMarker,
-  writeLedgerEntry,
+  COLLECTION,
+  executeAggregate,
+  executeFindOneAndUpdate,
+  executeInsertOne,
+  MONGO_LEDGER_COLLECTION,
+  MONGO_MARKER_COLLECTION,
+  parseMongoMarkerDocSafely,
 } from './marker-ledger';
 import { extractDb } from './runner-deps';
 
@@ -17,7 +26,7 @@ import { extractDb } from './runner-deps';
  * Mongo control adapter for control-plane operations like introspection
  * and marker-ledger CAS. Implements the family-level `MongoControlAdapter`
  * SPI by extracting the underlying `Db` from the framework-shaped driver
- * and forwarding to the wire-level helpers in this package.
+ * per call.
  */
 export class MongoControlAdapterImpl implements MongoControlAdapter<'mongo'> {
   readonly familyId = 'mongo' as const;
@@ -27,13 +36,50 @@ export class MongoControlAdapterImpl implements MongoControlAdapter<'mongo'> {
     driver: ControlDriverInstance<'mongo', 'mongo'>,
     space: string,
   ): Promise<ContractMarkerRecord | null> {
-    return readMarker(extractDb(driver), space);
+    const db = extractDb(driver);
+    const markerContext = { space, markerLocation: MONGO_MARKER_COLLECTION };
+    const docs = await withMarkerReadErrorHandling(
+      () =>
+        executeAggregate(
+          db,
+          new RawAggregateCommand(COLLECTION, [{ $match: { _id: space, space } }, { $limit: 1 }]),
+        ),
+      markerContext,
+    );
+    const doc = docs[0];
+    if (!doc) return null;
+    return parseMongoMarkerDocSafely(doc, space);
   }
 
   async readAllMarkers(
     driver: ControlDriverInstance<'mongo', 'mongo'>,
   ): Promise<ReadonlyMap<string, ContractMarkerRecord>> {
-    return readAllMarkers(extractDb(driver));
+    const db = extractDb(driver);
+    const markerContext = { space: 'app', markerLocation: MONGO_MARKER_COLLECTION };
+    const docs = await withMarkerReadErrorHandling(
+      () =>
+        executeAggregate(
+          db,
+          new RawAggregateCommand(COLLECTION, [
+            {
+              $match: {
+                _id: { $type: 'string' },
+                space: { $type: 'string' },
+                $expr: { $eq: ['$_id', '$space'] },
+              },
+            },
+          ]),
+        ),
+      markerContext,
+    );
+    const out = new Map<string, ContractMarkerRecord>();
+    for (const doc of docs) {
+      const space = doc['space'];
+      /* v8 ignore next -- @preserve type-narrowing guard: the $match stage above filters on `space: { $type: 'string' }`, so this branch is unreachable at runtime. The check exists so the `out.set(space, ...)` call below can accept `string`. */
+      if (typeof space !== 'string') continue;
+      out.set(space, parseMongoMarkerDocSafely(doc, space));
+    }
+    return out;
   }
 
   async initMarker(
@@ -45,7 +91,20 @@ export class MongoControlAdapterImpl implements MongoControlAdapter<'mongo'> {
       readonly invariants?: readonly string[];
     },
   ): Promise<void> {
-    await initMarker(extractDb(driver), space, destination);
+    const db = extractDb(driver);
+    const cmd = new RawInsertOneCommand(COLLECTION, {
+      _id: space,
+      space,
+      storageHash: destination.storageHash,
+      profileHash: destination.profileHash,
+      contractJson: null,
+      canonicalVersion: null,
+      updatedAt: new Date(),
+      appTag: null,
+      meta: {},
+      invariants: destination.invariants ?? [],
+    });
+    await executeInsertOne(db, cmd);
   }
 
   async updateMarker(
@@ -58,7 +117,38 @@ export class MongoControlAdapterImpl implements MongoControlAdapter<'mongo'> {
       readonly invariants?: readonly string[];
     },
   ): Promise<boolean> {
-    return updateMarker(extractDb(driver), space, expectedFrom, destination);
+    const db = extractDb(driver);
+    const setBase: Record<string, unknown> = {
+      storageHash: destination.storageHash,
+      profileHash: destination.profileHash,
+      updatedAt: new Date(),
+    };
+    const update: Document | Document[] =
+      destination.invariants === undefined
+        ? { $set: setBase }
+        : [
+            {
+              $set: {
+                ...setBase,
+                invariants: {
+                  $sortArray: {
+                    input: {
+                      $setUnion: [{ $ifNull: ['$invariants', []] }, destination.invariants],
+                    },
+                    sortBy: 1,
+                  },
+                },
+              },
+            },
+          ];
+    const cmd = new RawFindOneAndUpdateCommand(
+      COLLECTION,
+      { _id: space, space, storageHash: expectedFrom },
+      update,
+      false,
+    );
+    const result = await executeFindOneAndUpdate(db, cmd);
+    return result !== null;
   }
 
   async writeLedgerEntry(
@@ -73,14 +163,76 @@ export class MongoControlAdapterImpl implements MongoControlAdapter<'mongo'> {
       readonly operations: readonly unknown[];
     },
   ): Promise<void> {
-    await writeLedgerEntry(extractDb(driver), space, entry);
+    const db = extractDb(driver);
+    const cmd = new RawInsertOneCommand(COLLECTION, {
+      type: 'ledger',
+      space,
+      edgeId: entry.edgeId,
+      from: entry.from,
+      to: entry.to,
+      migrationName: entry.migrationName,
+      migrationHash: entry.migrationHash,
+      operations: entry.operations,
+      appliedAt: new Date(),
+    });
+    await executeInsertOne(db, cmd);
   }
 
   async readLedger(
     driver: ControlDriverInstance<'mongo', 'mongo'>,
     space?: string,
   ): Promise<readonly LedgerEntryRecord[]> {
-    return readLedger(extractDb(driver), space);
+    const db = extractDb(driver);
+    const ledgerContext = { space: space ?? '*', markerLocation: MONGO_LEDGER_COLLECTION };
+    const matchStage: Record<string, unknown> = { type: 'ledger' };
+    if (space !== undefined) {
+      matchStage['space'] = space;
+    }
+    const docs = await withMarkerReadErrorHandling(
+      () =>
+        executeAggregate(
+          db,
+          new RawAggregateCommand(COLLECTION, [{ $match: matchStage }, { $sort: { _id: 1 } }]),
+        ),
+      ledgerContext,
+    );
+
+    const entries: LedgerEntryRecord[] = [];
+    for (const doc of docs) {
+      const migrationName = doc['migrationName'];
+      const migrationHash = doc['migrationHash'];
+      const from = doc['from'];
+      const to = doc['to'];
+      const docSpace = doc['space'];
+      if (typeof migrationName !== 'string' || typeof migrationHash !== 'string') {
+        continue;
+      }
+      if (typeof from !== 'string' || typeof to !== 'string') {
+        continue;
+      }
+      if (typeof docSpace !== 'string') {
+        continue;
+      }
+      const appliedAt = doc['appliedAt'];
+      const appliedAtDate =
+        appliedAt instanceof Date
+          ? appliedAt
+          : appliedAt !== undefined
+            ? new Date(String(appliedAt))
+            : new Date();
+      const operations = doc['operations'];
+      const opList = Array.isArray(operations) ? operations : [];
+      entries.push({
+        space: docSpace,
+        migrationName,
+        migrationHash,
+        from: ledgerOriginFromStored(from),
+        to,
+        appliedAt: appliedAtDate,
+        operationCount: opList.length,
+      });
+    }
+    return entries;
   }
 
   async introspectSchema(driver: ControlDriverInstance<'mongo', 'mongo'>): Promise<MongoSchemaIR> {

package/src/exports/control.ts

@@ -1,15 +1,10 @@
+import type { ContractMarkerRecord, LedgerEntryRecord } from '@prisma-next/contract/types';
 import type { MongoControlAdapterDescriptor } from '@prisma-next/family-mongo/control-adapter';
+import type { ControlDriverInstance } from '@prisma-next/framework-components/control';
+import type { Db } from 'mongodb';
 
 export { MongoCommandExecutor, MongoInspectionExecutor } from '../core/command-executor';
 export { introspectSchema } from '../core/introspect-schema';
-export {
-  initMarker,
-  readAllMarkers,
-  readLedger,
-  readMarker,
-  updateMarker,
-  writeLedgerEntry,
-} from '../core/marker-ledger';
 export { MongoControlAdapterImpl } from '../core/mongo-control-adapter';
 export {
   createMongoControlDriver,
@@ -26,6 +21,75 @@ export { createMongoAdapter } from '../mongo-adapter';
 import { mongoCodecDescriptors } from '../core/codecs';
 import { MongoControlAdapterImpl } from '../core/mongo-control-adapter';
 
+const defaultControlAdapter = new MongoControlAdapterImpl();
+
+function controlDriverFromDb(db: Db): ControlDriverInstance<'mongo', 'mongo'> & { db: Db } {
+  return {
+    familyId: 'mongo',
+    targetId: 'mongo',
+    db,
+    query: () => Promise.reject(new Error('MongoDB control driver does not support SQL queries')),
+    close: async () => {},
+  };
+}
+
+export async function readMarker(db: Db, space: string): Promise<ContractMarkerRecord | null> {
+  return defaultControlAdapter.readMarker(controlDriverFromDb(db), space);
+}
+
+export async function readAllMarkers(db: Db): Promise<ReadonlyMap<string, ContractMarkerRecord>> {
+  return defaultControlAdapter.readAllMarkers(controlDriverFromDb(db));
+}
+
+export async function initMarker(
+  db: Db,
+  space: string,
+  destination: {
+    readonly storageHash: string;
+    readonly profileHash: string;
+    readonly invariants?: readonly string[];
+  },
+): Promise<void> {
+  await defaultControlAdapter.initMarker(controlDriverFromDb(db), space, destination);
+}
+
+export async function updateMarker(
+  db: Db,
+  space: string,
+  expectedFrom: string,
+  destination: {
+    readonly storageHash: string;
+    readonly profileHash: string;
+    readonly invariants?: readonly string[];
+  },
+): Promise<boolean> {
+  return defaultControlAdapter.updateMarker(
+    controlDriverFromDb(db),
+    space,
+    expectedFrom,
+    destination,
+  );
+}
+
+export async function readLedger(db: Db, space?: string): Promise<readonly LedgerEntryRecord[]> {
+  return defaultControlAdapter.readLedger(controlDriverFromDb(db), space);
+}
+
+export async function writeLedgerEntry(
+  db: Db,
+  space: string,
+  entry: {
+    readonly edgeId: string;
+    readonly from: string;
+    readonly to: string;
+    readonly migrationName: string;
+    readonly migrationHash: string;
+    readonly operations: readonly unknown[];
+  },
+): Promise<void> {
+  await defaultControlAdapter.writeLedgerEntry(controlDriverFromDb(db), space, entry);
+}
+
 export const mongoAdapterDescriptor: MongoControlAdapterDescriptor<'mongo'> = {
   kind: 'adapter',
   id: 'mongo',