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

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

@@ -1,38 +1,143 @@
-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 type { MongoAdapter } from '@prisma-next/mongo-lowering';
+import {
+  type AnyMongoCommand,
+  MongoAggFieldRef,
+  MongoAggLiteral,
+  MongoAggOperator,
+  type MongoQueryPlan,
+} from '@prisma-next/mongo-query-ast/execution';
+import { expr, fn } from '@prisma-next/mongo-query-builder';
+import { collection } from '@prisma-next/mongo-query-builder/contract-free';
 import type { MongoSchemaIR } from '@prisma-next/mongo-schema-ir';
+import type { MongoValue } from '@prisma-next/mongo-value';
+import { blindCast } from '@prisma-next/utils/casts';
+import type { Document } from 'mongodb';
+import { createMongoAdapter } from '../mongo-adapter';
 import { introspectSchema } from './introspect-schema';
 import {
-  initMarker,
-  readAllMarkers,
-  readMarker,
-  updateMarker,
-  writeLedgerEntry,
+  MONGO_LEDGER_COLLECTION,
+  MONGO_MARKER_COLLECTION,
+  parseMongoMarkerDocSafely,
 } from './marker-ledger';
+import { MARKER_LEDGER_COLLECTION, type MarkerLedgerDocShape } from './marker-ledger-collection';
+import { isMongoControlDriver } from './mongo-control-driver';
 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.
+ * SPI. Every marker/ledger operation builds a canonical command inline via
+ * the contract-free fluent builder and dispatches it through the family
+ * adapter's lowering path (`createMongoAdapter().lower(plan, {})`) onto the
+ * Mongo wire transport (`driver.execute(wireCommand)`) — the same route SQL
+ * marker/ledger ops take through `adapter.lower()` → `driver.query()`.
  */
 export class MongoControlAdapterImpl implements MongoControlAdapter<'mongo'> {
   readonly familyId = 'mongo' as const;
   readonly targetId = 'mongo' as const;
+  readonly #adapter: MongoAdapter = createMongoAdapter();
+  readonly #markerLedgerCollection = collection<MarkerLedgerDocShape>(MARKER_LEDGER_COLLECTION);
+
+  async #execute(
+    driver: ControlDriverInstance<'mongo', 'mongo'>,
+    command: AnyMongoCommand,
+  ): Promise<Document[]> {
+    const plan: MongoQueryPlan = {
+      collection: MARKER_LEDGER_COLLECTION,
+      command,
+      meta: { target: 'mongo', targetFamily: 'mongo', storageHash: '', lane: 'control' },
+    };
+    const wireCommand = await this.#adapter.lower(plan, {});
+    if (!isMongoControlDriver(driver)) {
+      throw new Error(
+        'Mongo control adapter requires a Mongo control driver with an execute() transport. ' +
+          'Provide a MongoControlDriver from `@prisma-next/driver-mongo/control`.',
+      );
+    }
+    const rows: Document[] = [];
+    for await (const row of driver.execute<Document>(wireCommand)) {
+      rows.push(row);
+    }
+    return rows;
+  }
+
+  /**
+   * Server-side invariant-merge aggregation expression:
+   * `$sortArray({ input: $setUnion([$ifNull('$invariants', []), incoming]), sortBy: 1 })`.
+   *
+   * Built through the typed agg-expr layer — `fn.setUnion` plus the generic
+   * `MongoAggOperator` for `$ifNull` / `$sortArray` (neither has a named `fn`
+   * helper). Returns a `MongoAggOperator` that is passed directly to
+   * `f.stage.set({ invariants: ... })` in the update pipeline.
+   */
+  #invariantMergeExpr(incoming: readonly string[]): MongoAggOperator {
+    const existingOrEmpty = MongoAggOperator.of('$ifNull', [
+      MongoAggFieldRef.of('invariants'),
+      MongoAggLiteral.of([]),
+    ]);
+    const merged = fn.setUnion(
+      { _field: { codecId: 'mongo/array@1', nullable: false }, node: existingOrEmpty },
+      {
+        _field: { codecId: 'mongo/array@1', nullable: false },
+        node: MongoAggLiteral.of([...incoming]),
+      },
+    );
+    return MongoAggOperator.of('$sortArray', { input: merged.node, sortBy: MongoAggLiteral.of(1) });
+  }
 
   async readMarker(
     driver: ControlDriverInstance<'mongo', 'mongo'>,
     space: string,
   ): Promise<ContractMarkerRecord | null> {
-    return readMarker(extractDb(driver), space);
+    const markerContext = { space, markerLocation: MONGO_MARKER_COLLECTION };
+    const docs = await withMarkerReadErrorHandling(
+      () =>
+        this.#execute(
+          driver,
+          this.#markerLedgerCollection
+            .aggregate()
+            .match((f) => f._id.eq(space))
+            .match((f) => f.space.eq(space))
+            .limit(1)
+            .build(),
+        ),
+      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 markerContext = { space: 'app', markerLocation: MONGO_MARKER_COLLECTION };
+    const docs = await withMarkerReadErrorHandling(
+      () =>
+        this.#execute(
+          driver,
+          this.#markerLedgerCollection
+            .aggregate()
+            .match((f) => f._id.type('string'))
+            .match((f) => f.space.type('string'))
+            .match((f) => expr(fn.eq(f._id, f.space)))
+            .build(),
+        ),
+      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 +149,19 @@ export class MongoControlAdapterImpl implements MongoControlAdapter<'mongo'> {
       readonly invariants?: readonly string[];
     },
   ): Promise<void> {
-    await initMarker(extractDb(driver), space, destination);
+    const document: Record<string, MongoValue> = {
+      _id: space,
+      space,
+      storageHash: destination.storageHash,
+      profileHash: destination.profileHash,
+      contractJson: null,
+      canonicalVersion: null,
+      updatedAt: new Date(),
+      appTag: null,
+      meta: {},
+      invariants: [...(destination.invariants ?? [])],
+    };
+    await this.#execute(driver, this.#markerLedgerCollection.insertOne(document));
   }
 
   async updateMarker(
@@ -57,15 +174,118 @@ export class MongoControlAdapterImpl implements MongoControlAdapter<'mongo'> {
       readonly invariants?: readonly string[];
     },
   ): Promise<boolean> {
-    return updateMarker(extractDb(driver), space, expectedFrom, destination);
+    const { invariants } = destination;
+    const docs = await this.#execute(
+      driver,
+      this.#markerLedgerCollection
+        .match((f) => f._id.eq(space))
+        .match((f) => f.space.eq(space))
+        .match((f) => f.storageHash.eq(expectedFrom))
+        .findOneAndUpdate(
+          (f) => [
+            f.stage.set(
+              invariants === undefined
+                ? {
+                    storageHash: MongoAggLiteral.of(destination.storageHash),
+                    profileHash: MongoAggLiteral.of(destination.profileHash),
+                    updatedAt: MongoAggLiteral.of(new Date()),
+                  }
+                : {
+                    storageHash: MongoAggLiteral.of(destination.storageHash),
+                    profileHash: MongoAggLiteral.of(destination.profileHash),
+                    updatedAt: MongoAggLiteral.of(new Date()),
+                    invariants: this.#invariantMergeExpr(invariants),
+                  },
+            ),
+          ],
+          { upsert: false },
+        ),
+    );
+    return docs.length > 0;
   }
 
   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 document: Record<string, MongoValue> = {
+      type: 'ledger',
+      space,
+      edgeId: entry.edgeId,
+      from: entry.from,
+      to: entry.to,
+      migrationName: entry.migrationName,
+      migrationHash: entry.migrationHash,
+      operations: blindCast<ReadonlyArray<MongoValue>, 'ledger operation docs are BSON values'>(
+        entry.operations,
+      ),
+      appliedAt: new Date(),
+    };
+    await this.#execute(driver, this.#markerLedgerCollection.insertOne(document));
+  }
+
+  async readLedger(
+    driver: ControlDriverInstance<'mongo', 'mongo'>,
+    space?: string,
+  ): Promise<readonly LedgerEntryRecord[]> {
+    const ledgerContext = { space: space ?? '*', markerLocation: MONGO_LEDGER_COLLECTION };
+    const chain = this.#markerLedgerCollection.aggregate().match((f) => f.type.eq('ledger'));
+    const command =
+      space === undefined
+        ? chain.sort({ _id: 1 }).build()
+        : chain
+            .match((f) => f.space.eq(space))
+            .sort({ _id: 1 })
+            .build();
+    const docs = await withMarkerReadErrorHandling(
+      () => this.#execute(driver, command),
+      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,13 @@
 import type { ControlDriverInstance } from '@prisma-next/framework-components/control';
-import type { Db, MongoClient } from 'mongodb';
-
-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);
+import type { MongoControlDriverInstance } from '@prisma-next/mongo-lowering';
+
+export function isMongoControlDriver(
+  driver: ControlDriverInstance<'mongo', string>,
+): driver is MongoControlDriverInstance {
+  return (
+    driver.familyId === 'mongo' &&
+    driver.targetId === 'mongo' &&
+    'execute' in driver &&
+    typeof driver.execute === 'function'
+  );
 }

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,10 @@
 import type { MongoControlAdapterDescriptor } from '@prisma-next/family-mongo/control-adapter';
+import 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,
@@ -21,6 +12,7 @@ export {
   type MongoRunnerDependencies,
 } from '../core/runner-deps';
 export { createMongoAdapter } from '../mongo-adapter';
+export type { MongoControlDriverInstance };
 
 import { mongoCodecDescriptors } from '../core/codecs';
 import { MongoControlAdapterImpl } from '../core/mongo-control-adapter';