@prisma-next/adapter-mongo 0.3.0-dev.147 → 0.3.0-dev.162

package/src/core/mongo-runner.ts

@@ -0,0 +1,277 @@
+import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
+import type {
+  ControlDriverInstance,
+  MigrationOperationPolicy,
+  MigrationPlan,
+  MigrationPlanOperation,
+  MigrationRunner,
+  MigrationRunnerExecutionChecks,
+  MigrationRunnerFailure,
+  MigrationRunnerResult,
+} from '@prisma-next/framework-components/control';
+import type {
+  MongoMigrationCheck,
+  MongoMigrationPlanOperation,
+} from '@prisma-next/mongo-query-ast/control';
+import {
+  initMarker,
+  readMarker,
+  updateMarker,
+  writeLedgerEntry,
+} from '@prisma-next/target-mongo/control';
+import { notOk, ok } from '@prisma-next/utils/result';
+import type { Db } from 'mongodb';
+import { MongoCommandExecutor, MongoInspectionExecutor } from './command-executor';
+import { FilterEvaluator } from './filter-evaluator';
+import type { MongoControlDriverInstance } from './mongo-control-driver';
+import { deserializeMongoOps } from './mongo-ops-serializer';
+
+function runnerFailure(
+  code: string,
+  summary: string,
+  opts?: { why?: string; meta?: Record<string, unknown> },
+): MigrationRunnerResult {
+  return notOk<MigrationRunnerFailure>({
+    code,
+    summary,
+    ...opts,
+  });
+}
+
+function isMongoControlDriverInstance(
+  driver: ControlDriverInstance<'mongo', 'mongo'>,
+): driver is MongoControlDriverInstance {
+  return 'db' in driver && driver.db != null;
+}
+
+function extractDb(driver: ControlDriverInstance<'mongo', 'mongo'>): Db {
+  if (!isMongoControlDriverInstance(driver)) {
+    throw new Error(
+      'Mongo control driver does not expose a db property. ' +
+        'Use mongoControlDriver.create() from `@prisma-next/driver-mongo/control`.',
+    );
+  }
+  return driver.db;
+}
+
+export class MongoMigrationRunner implements MigrationRunner<'mongo', 'mongo'> {
+  async execute(options: {
+    readonly plan: MigrationPlan;
+    readonly driver: ControlDriverInstance<'mongo', 'mongo'>;
+    readonly destinationContract: unknown;
+    readonly policy: MigrationOperationPolicy;
+    readonly callbacks?: {
+      onOperationStart?(op: MigrationPlanOperation): void;
+      onOperationComplete?(op: MigrationPlanOperation): void;
+    };
+    readonly executionChecks?: MigrationRunnerExecutionChecks;
+    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'mongo', 'mongo'>>;
+  }): Promise<MigrationRunnerResult> {
+    const db = extractDb(options.driver);
+    const operations = deserializeMongoOps(options.plan.operations as readonly unknown[]);
+
+    const policyCheck = this.enforcePolicyCompatibility(options.policy, operations);
+    if (policyCheck) return policyCheck;
+
+    const existingMarker = await readMarker(db);
+
+    const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
+    if (markerCheck) return markerCheck;
+
+    const checks = options.executionChecks;
+    const runPrechecks = checks?.prechecks !== false;
+    const runPostchecks = checks?.postchecks !== false;
+    const runIdempotency = checks?.idempotencyChecks !== false;
+
+    const commandExecutor = new MongoCommandExecutor(db);
+    const inspectionExecutor = new MongoInspectionExecutor(db);
+    const filterEvaluator = new FilterEvaluator();
+
+    let operationsExecuted = 0;
+
+    for (const operation of operations) {
+      options.callbacks?.onOperationStart?.(operation);
+      try {
+        if (runPostchecks && runIdempotency) {
+          const allSatisfied = await this.allChecksSatisfied(
+            operation.postcheck,
+            inspectionExecutor,
+            filterEvaluator,
+          );
+          if (allSatisfied) continue;
+        }
+
+        if (runPrechecks) {
+          const precheckResult = await this.evaluateChecks(
+            operation.precheck,
+            inspectionExecutor,
+            filterEvaluator,
+          );
+          if (!precheckResult) {
+            return runnerFailure(
+              'PRECHECK_FAILED',
+              `Operation ${operation.id} failed during precheck`,
+              { meta: { operationId: operation.id } },
+            );
+          }
+        }
+
+        for (const step of operation.execute) {
+          await step.command.accept(commandExecutor);
+        }
+
+        if (runPostchecks) {
+          const postcheckResult = await this.evaluateChecks(
+            operation.postcheck,
+            inspectionExecutor,
+            filterEvaluator,
+          );
+          if (!postcheckResult) {
+            return runnerFailure(
+              'POSTCHECK_FAILED',
+              `Operation ${operation.id} failed during postcheck`,
+              { meta: { operationId: operation.id } },
+            );
+          }
+        }
+
+        operationsExecuted += 1;
+      } finally {
+        options.callbacks?.onOperationComplete?.(operation);
+      }
+    }
+
+    const destination = options.plan.destination;
+    const contract = options.destinationContract as { profileHash?: string };
+    const profileHash = contract.profileHash ?? destination.storageHash;
+
+    if (
+      operationsExecuted === 0 &&
+      existingMarker?.storageHash === destination.storageHash &&
+      existingMarker.profileHash === profileHash
+    ) {
+      return ok({ operationsPlanned: operations.length, operationsExecuted });
+    }
+
+    if (existingMarker) {
+      const updated = await updateMarker(db, existingMarker.storageHash, {
+        storageHash: destination.storageHash,
+        profileHash,
+      });
+      if (!updated) {
+        return runnerFailure(
+          'MARKER_CAS_FAILURE',
+          'Marker was modified by another process during migration execution.',
+          {
+            meta: {
+              expectedStorageHash: existingMarker.storageHash,
+              destinationStorageHash: destination.storageHash,
+            },
+          },
+        );
+      }
+    } else {
+      await initMarker(db, {
+        storageHash: destination.storageHash,
+        profileHash,
+      });
+    }
+
+    const originHash = existingMarker?.storageHash ?? '';
+    await writeLedgerEntry(db, {
+      edgeId: `${originHash}->${destination.storageHash}`,
+      from: originHash,
+      to: destination.storageHash,
+    });
+
+    return ok({ operationsPlanned: operations.length, operationsExecuted });
+  }
+
+  private async evaluateChecks(
+    checks: readonly MongoMigrationCheck[],
+    inspectionExecutor: MongoInspectionExecutor,
+    filterEvaluator: FilterEvaluator,
+  ): Promise<boolean> {
+    for (const check of checks) {
+      const documents = await check.source.accept(inspectionExecutor);
+      const matchFound = documents.some((doc) =>
+        filterEvaluator.evaluate(check.filter, doc as Record<string, unknown>),
+      );
+      const passed = check.expect === 'exists' ? matchFound : !matchFound;
+      if (!passed) return false;
+    }
+    return true;
+  }
+
+  private async allChecksSatisfied(
+    checks: readonly MongoMigrationCheck[],
+    inspectionExecutor: MongoInspectionExecutor,
+    filterEvaluator: FilterEvaluator,
+  ): Promise<boolean> {
+    if (checks.length === 0) return false;
+    return this.evaluateChecks(checks, inspectionExecutor, filterEvaluator);
+  }
+
+  private enforcePolicyCompatibility(
+    policy: MigrationOperationPolicy,
+    operations: readonly MongoMigrationPlanOperation[],
+  ): MigrationRunnerResult | undefined {
+    const allowedClasses = new Set(policy.allowedOperationClasses);
+    for (const operation of operations) {
+      if (!allowedClasses.has(operation.operationClass)) {
+        return runnerFailure(
+          'POLICY_VIOLATION',
+          `Operation ${operation.id} has class "${operation.operationClass}" which is not allowed by policy.`,
+          {
+            why: `Policy only allows: ${[...allowedClasses].join(', ')}.`,
+            meta: {
+              operationId: operation.id,
+              operationClass: operation.operationClass,
+            },
+          },
+        );
+      }
+    }
+    return undefined;
+  }
+
+  private ensureMarkerCompatibility(
+    marker: Awaited<ReturnType<typeof readMarker>>,
+    plan: MigrationPlan,
+  ): MigrationRunnerResult | undefined {
+    const origin = plan.origin ?? null;
+    if (!origin) {
+      if (marker) {
+        return runnerFailure(
+          'MARKER_ORIGIN_MISMATCH',
+          'Database already has a contract marker but the plan has no origin. This would silently overwrite the existing marker.',
+          { meta: { markerStorageHash: marker.storageHash } },
+        );
+      }
+      return undefined;
+    }
+
+    if (!marker) {
+      return runnerFailure(
+        'MARKER_ORIGIN_MISMATCH',
+        `Missing contract marker: expected origin storage hash ${origin.storageHash}.`,
+        { meta: { expectedOriginStorageHash: origin.storageHash } },
+      );
+    }
+
+    if (marker.storageHash !== origin.storageHash) {
+      return runnerFailure(
+        'MARKER_ORIGIN_MISMATCH',
+        `Existing contract marker (${marker.storageHash}) does not match plan origin (${origin.storageHash}).`,
+        {
+          meta: {
+            markerStorageHash: marker.storageHash,
+            expectedOriginStorageHash: origin.storageHash,
+          },
+        },
+      );
+    }
+
+    return undefined;
+  }
+}

package/src/exports/control.ts

@@ -1,4 +1,23 @@
 import type { ControlAdapterDescriptor } from '@prisma-next/framework-components/control';
+
+export {
+  initMarker,
+  readMarker,
+  updateMarker,
+  writeLedgerEntry,
+} from '@prisma-next/target-mongo/control';
+export { MongoCommandExecutor, MongoInspectionExecutor } from '../core/command-executor';
+export { contractToMongoSchemaIR } from '../core/contract-to-schema';
+export { formatMongoOperations } from '../core/ddl-formatter';
+export { introspectSchema } from '../core/introspect-schema';
+export {
+  createMongoControlDriver,
+  type MongoControlDriverInstance,
+} from '../core/mongo-control-driver';
+export { deserializeMongoOps, serializeMongoOps } from '../core/mongo-ops-serializer';
+export { MongoMigrationPlanner } from '../core/mongo-planner';
+export { MongoMigrationRunner } from '../core/mongo-runner';
+
 import {
   mongoBooleanCodec,
   mongoDateCodec,

package/src/lowering.ts

@@ -6,8 +6,8 @@ import type {
   MongoPipelineStage,
   MongoProjectionValue,
   MongoWindowField,
-} from '@prisma-next/mongo-query-ast';
-import { isExprArray, isRecordArgs } from '@prisma-next/mongo-query-ast';
+} from '@prisma-next/mongo-query-ast/execution';
+import { isExprArray, isRecordArgs } from '@prisma-next/mongo-query-ast/execution';
 import type { Document } from '@prisma-next/mongo-value';
 import { resolveValue } from './resolve-value';
 

package/src/mongo-adapter.ts

@@ -1,9 +1,10 @@
+import { createMongoCodecRegistry, type MongoCodecRegistry } from '@prisma-next/mongo-codec';
 import type { MongoAdapter } from '@prisma-next/mongo-lowering';
 import type {
   MongoQueryPlan,
   MongoUpdatePipelineStage,
   MongoUpdateSpec,
-} from '@prisma-next/mongo-query-ast';
+} from '@prisma-next/mongo-query-ast/execution';
 import type { Document, MongoExpr } from '@prisma-next/mongo-value';
 import type { AnyMongoWireCommand } from '@prisma-next/mongo-wire';
 import {
@@ -20,49 +21,58 @@ import {
 import { lowerFilter, lowerPipeline, lowerStage } from './lowering';
 import { resolveValue } from './resolve-value';
 
-function resolveDocument(expr: MongoExpr): Document {
-  const result: Record<string, unknown> = {};
-  for (const [key, val] of Object.entries(expr)) {
-    result[key] = resolveValue(val);
-  }
-  return result;
-}
-
 function isUpdatePipeline(
   update: MongoUpdateSpec,
 ): update is ReadonlyArray<MongoUpdatePipelineStage> {
   return Array.isArray(update);
 }
 
-function lowerUpdate(update: MongoUpdateSpec): Document | ReadonlyArray<Document> {
-  if (isUpdatePipeline(update)) {
-    return update.map((stage) => lowerStage(stage));
+class MongoAdapterImpl implements MongoAdapter {
+  readonly #codecs: MongoCodecRegistry | undefined;
+
+  constructor(codecs?: MongoCodecRegistry) {
+    this.#codecs = codecs;
+  }
+
+  #resolveDocument(expr: MongoExpr): Document {
+    const result: Record<string, unknown> = {};
+    for (const [key, val] of Object.entries(expr)) {
+      result[key] = resolveValue(val, this.#codecs);
+    }
+    return result;
+  }
+
+  #lowerUpdate(update: MongoUpdateSpec): Document | ReadonlyArray<Document> {
+    if (isUpdatePipeline(update)) {
+      return update.map((stage) => lowerStage(stage));
+    }
+    return this.#resolveDocument(update);
   }
-  return resolveDocument(update);
-}
 
-class MongoAdapterImpl implements MongoAdapter {
   lower(plan: MongoQueryPlan): AnyMongoWireCommand {
     const { command } = plan;
     switch (command.kind) {
       case 'insertOne':
-        return new InsertOneWireCommand(command.collection, resolveDocument(command.document));
+        return new InsertOneWireCommand(
+          command.collection,
+          this.#resolveDocument(command.document),
+        );
       case 'updateOne':
         return new UpdateOneWireCommand(
           command.collection,
           lowerFilter(command.filter),
-          lowerUpdate(command.update),
+          this.#lowerUpdate(command.update),
         );
       case 'insertMany':
         return new InsertManyWireCommand(
           command.collection,
-          command.documents.map((doc) => resolveDocument(doc)),
+          command.documents.map((doc) => this.#resolveDocument(doc)),
         );
       case 'updateMany':
         return new UpdateManyWireCommand(
           command.collection,
           lowerFilter(command.filter),
-          lowerUpdate(command.update),
+          this.#lowerUpdate(command.update),
         );
       case 'deleteOne':
         return new DeleteOneWireCommand(command.collection, lowerFilter(command.filter));
@@ -72,7 +82,7 @@ class MongoAdapterImpl implements MongoAdapter {
         return new FindOneAndUpdateWireCommand(
           command.collection,
           lowerFilter(command.filter),
-          lowerUpdate(command.update),
+          this.#lowerUpdate(command.update),
           command.upsert,
         );
       case 'findOneAndDelete':
@@ -111,6 +121,32 @@ class MongoAdapterImpl implements MongoAdapter {
   }
 }
 
-export function createMongoAdapter(): MongoAdapter {
-  return new MongoAdapterImpl();
+import {
+  mongoBooleanCodec,
+  mongoDateCodec,
+  mongoDoubleCodec,
+  mongoInt32Codec,
+  mongoObjectIdCodec,
+  mongoStringCodec,
+  mongoVectorCodec,
+} from './core/codecs';
+
+function defaultCodecRegistry(): MongoCodecRegistry {
+  const registry = createMongoCodecRegistry();
+  for (const codec of [
+    mongoObjectIdCodec,
+    mongoStringCodec,
+    mongoDoubleCodec,
+    mongoInt32Codec,
+    mongoBooleanCodec,
+    mongoDateCodec,
+    mongoVectorCodec,
+  ]) {
+    registry.register(codec);
+  }
+  return registry;
+}
+
+export function createMongoAdapter(codecs?: MongoCodecRegistry): MongoAdapter {
+  return new MongoAdapterImpl(codecs ?? defaultCodecRegistry());
 }

package/src/resolve-value.ts

@@ -1,8 +1,13 @@
+import type { MongoCodecRegistry } from '@prisma-next/mongo-codec';
 import type { MongoValue } from '@prisma-next/mongo-value';
 import { MongoParamRef } from '@prisma-next/mongo-value';
 
-export function resolveValue(value: MongoValue): unknown {
+export function resolveValue(value: MongoValue, codecs?: MongoCodecRegistry): unknown {
   if (value instanceof MongoParamRef) {
+    if (value.codecId && codecs) {
+      const codec = codecs.get(value.codecId);
+      if (codec?.encode) return codec.encode(value.value);
+    }
     return value.value;
   }
   if (value === null || typeof value !== 'object') {
@@ -12,11 +17,11 @@ export function resolveValue(value: MongoValue): unknown {
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((v) => resolveValue(v));
+    return value.map((v) => resolveValue(v, codecs));
   }
   const result: Record<string, unknown> = {};
   for (const [key, val] of Object.entries(value)) {
-    result[key] = resolveValue(val);
+    result[key] = resolveValue(val, codecs);
   }
   return result;
 }

package/dist/codec-ids-FBmJhfq-.mjs

@@ -1,12 +0,0 @@
-//#region src/core/codec-ids.ts
-const MONGO_OBJECTID_CODEC_ID = "mongo/objectId@1";
-const MONGO_STRING_CODEC_ID = "mongo/string@1";
-const MONGO_DOUBLE_CODEC_ID = "mongo/double@1";
-const MONGO_INT32_CODEC_ID = "mongo/int32@1";
-const MONGO_BOOLEAN_CODEC_ID = "mongo/bool@1";
-const MONGO_DATE_CODEC_ID = "mongo/date@1";
-const MONGO_VECTOR_CODEC_ID = "mongo/vector@1";
-
-//#endregion
-export { MONGO_OBJECTID_CODEC_ID as a, MONGO_INT32_CODEC_ID as i, MONGO_DATE_CODEC_ID as n, MONGO_STRING_CODEC_ID as o, MONGO_DOUBLE_CODEC_ID as r, MONGO_VECTOR_CODEC_ID as s, MONGO_BOOLEAN_CODEC_ID as t };
-//# sourceMappingURL=codec-ids-FBmJhfq-.mjs.map

package/dist/codec-ids-FBmJhfq-.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-ids-FBmJhfq-.mjs","names":[],"sources":["../src/core/codec-ids.ts"],"sourcesContent":["export const MONGO_OBJECTID_CODEC_ID = 'mongo/objectId@1' as const;\nexport const MONGO_STRING_CODEC_ID = 'mongo/string@1' as const;\nexport const MONGO_DOUBLE_CODEC_ID = 'mongo/double@1' as const;\nexport const MONGO_INT32_CODEC_ID = 'mongo/int32@1' as const;\nexport const MONGO_BOOLEAN_CODEC_ID = 'mongo/bool@1' as const;\nexport const MONGO_DATE_CODEC_ID = 'mongo/date@1' as const;\nexport const MONGO_VECTOR_CODEC_ID = 'mongo/vector@1' as const;\n"],"mappings":";AAAA,MAAa,0BAA0B;AACvC,MAAa,wBAAwB;AACrC,MAAa,wBAAwB;AACrC,MAAa,uBAAuB;AACpC,MAAa,yBAAyB;AACtC,MAAa,sBAAsB;AACnC,MAAa,wBAAwB"}