@prisma-next/adapter-mongo 0.12.0-dev.5 → 0.12.0-dev.50

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

@@ -1,14 +1,24 @@
-import type { ContractMarkerRecord } from '@prisma-next/contract/types';
+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,
-  readMarker,
-  updateMarker,
-  writeLedgerEntry,
+  COLLECTION,
+  executeAggregate,
+  executeFindOneAndUpdate,
+  executeInsertOne,
+  MONGO_LEDGER_COLLECTION,
+  MONGO_MARKER_COLLECTION,
+  parseMongoMarkerDocSafely,
 } from './marker-ledger';
 import { extractDb } from './runner-deps';
 
@@ -16,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;
@@ -26,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(
@@ -44,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(
@@ -57,15 +117,122 @@ 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(
     driver: ControlDriverInstance<'mongo', 'mongo'>,
     space: string,
-    entry: { readonly edgeId: string; readonly from: string; readonly to: string },
+    entry: {
+      readonly edgeId: string;
+      readonly from: string;
+      readonly to: string;
+      readonly migrationName: string;
+      readonly migrationHash: string;
+      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[]> {
+    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/core/mongo-control-driver.ts

@@ -1,30 +1,8 @@
 import type { ControlDriverInstance } from '@prisma-next/framework-components/control';
-import type { Db, MongoClient } from 'mongodb';
+import type { MongoControlDriverInstance } from '@prisma-next/mongo-lowering';
 
-export interface MongoControlDriverInstance extends ControlDriverInstance<'mongo', 'mongo'> {
-  readonly db: Db;
-}
-
-class MongoControlDriverImpl implements MongoControlDriverInstance {
-  readonly familyId = 'mongo' as const;
-  readonly targetId = 'mongo' as const;
-  readonly db: Db;
-  readonly #client: MongoClient;
-
-  constructor(db: Db, client: MongoClient) {
-    this.db = db;
-    this.#client = client;
-  }
-
-  query(): Promise<never> {
-    throw new Error('MongoDB control driver does not support SQL queries');
-  }
-
-  async close(): Promise<void> {
-    await this.#client.close();
-  }
-}
-
-export function createMongoControlDriver(db: Db, client: MongoClient): MongoControlDriverInstance {
-  return new MongoControlDriverImpl(db, client);
+export function isMongoControlDriver(
+  driver: ControlDriverInstance<'mongo', string>,
+): driver is MongoControlDriverInstance {
+  return driver.familyId === 'mongo' && driver.targetId === 'mongo';
 }

package/src/core/runner-deps.ts

@@ -14,16 +14,16 @@ import type { Db } from 'mongodb';
 import { createMongoAdapter } from '../mongo-adapter';
 import { MongoCommandExecutor, MongoInspectionExecutor } from './command-executor';
 import { MongoControlAdapterImpl } from './mongo-control-adapter';
+import { isMongoControlDriver } from './mongo-control-driver';
 
 export function extractDb(driver: ControlDriverInstance<'mongo', 'mongo'>): Db {
-  const mongoDriver = driver as ControlDriverInstance<'mongo', 'mongo'> & { db?: Db };
-  if (!mongoDriver.db) {
+  if (!isMongoControlDriver(driver)) {
     throw new Error(
-      'Mongo control driver does not expose a db property. ' +
-        'Use mongoControlDriver.create() from `@prisma-next/driver-mongo/control`.',
+      'Expected a Mongo control driver created by ' +
+        'mongoControlDriver.create() from `@prisma-next/driver-mongo/control`.',
     );
   }
-  return mongoDriver.db;
+  return driver.db;
 }
 
 /**
@@ -57,6 +57,9 @@ export interface MarkerOperations {
       readonly edgeId: string;
       readonly from: string;
       readonly to: string;
+      readonly migrationName: string;
+      readonly migrationHash: string;
+      readonly operations: readonly unknown[];
     },
   ): Promise<void>;
 }
@@ -82,11 +85,11 @@ export interface MongoRunnerDependencies {
 export function createMongoRunnerDeps(
   controlDriver: ControlDriverInstance<'mongo', 'mongo'>,
   driver: MongoDriver,
-  // Vestigial after the M2.5 family→adapter SPI dispatch refactor: the runner
-  // dependencies now route every wire-level call through `controlAdapter`, so
-  // the `family` instance is no longer consulted. Kept on the signature to
-  // avoid rippling through ~14 call sites mid-orchestration; a follow-up that
-  // already touches this factory should drop the parameter outright.
+  // Vestigial after the family→adapter SPI refactor: the runner dependencies
+  // now route every wire-level call through `controlAdapter`, so the `family`
+  // instance is no longer consulted. Kept on the signature to avoid rippling
+  // through ~14 call sites; a follow-up that already touches this factory
+  // should drop the parameter outright.
   _family: ControlFamilyInstance<'mongo', MongoSchemaIR>,
   controlAdapter: MongoControlAdapter<'mongo'> = new MongoControlAdapterImpl(),
 ): MongoRunnerDependencies {

package/src/exports/control.ts

@@ -1,19 +1,13 @@
+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 type { MongoControlDriverInstance } from '@prisma-next/mongo-lowering';
 export { MongoCommandExecutor, MongoInspectionExecutor } from '../core/command-executor';
 export { introspectSchema } from '../core/introspect-schema';
-export {
-  initMarker,
-  readAllMarkers,
-  readMarker,
-  updateMarker,
-  writeLedgerEntry,
-} from '../core/marker-ledger';
 export { MongoControlAdapterImpl } from '../core/mongo-control-adapter';
-export {
-  createMongoControlDriver,
-  type MongoControlDriverInstance,
-} from '../core/mongo-control-driver';
+export { isMongoControlDriver } from '../core/mongo-control-driver';
 export {
   createMongoRunnerDeps,
   extractDb,
@@ -25,6 +19,74 @@ 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,
+    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',