@prisma-next/target-mongo 0.4.0-dev.8 → 0.4.0-dev.9

package/package.json

@@ -1,21 +1,22 @@
 {
   "name": "@prisma-next/target-mongo",
-  "version": "0.4.0-dev.8",
+  "version": "0.4.0-dev.9",
   "type": "module",
   "sideEffects": false,
   "description": "MongoDB target pack for Prisma Next",
   "dependencies": {
     "arktype": "^2.1.29",
     "mongodb": "^6.16.0",
-    "@prisma-next/contract": "0.4.0-dev.8",
-    "@prisma-next/framework-components": "0.4.0-dev.8",
-    "@prisma-next/mongo-contract": "0.4.0-dev.8",
-    "@prisma-next/mongo-query-ast": "0.4.0-dev.8",
-    "@prisma-next/migration-tools": "0.4.0-dev.8",
-    "@prisma-next/errors": "0.4.0-dev.8",
-    "@prisma-next/mongo-value": "0.4.0-dev.8",
-    "@prisma-next/mongo-schema-ir": "0.4.0-dev.8",
-    "@prisma-next/utils": "0.4.0-dev.8"
+    "@prisma-next/contract": "0.4.0-dev.9",
+    "@prisma-next/migration-tools": "0.4.0-dev.9",
+    "@prisma-next/errors": "0.4.0-dev.9",
+    "@prisma-next/mongo-contract": "0.4.0-dev.9",
+    "@prisma-next/mongo-lowering": "0.4.0-dev.9",
+    "@prisma-next/mongo-schema-ir": "0.4.0-dev.9",
+    "@prisma-next/framework-components": "0.4.0-dev.9",
+    "@prisma-next/mongo-query-ast": "0.4.0-dev.9",
+    "@prisma-next/utils": "0.4.0-dev.9",
+    "@prisma-next/mongo-value": "0.4.0-dev.9"
   },
   "devDependencies": {
     "mongodb-memory-server": "10.4.3",
@@ -24,8 +25,8 @@
     "typescript": "5.9.3",
     "vitest": "4.0.17",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/tsdown": "0.0.0"
+    "@prisma-next/tsdown": "0.0.0",
+    "@prisma-next/tsconfig": "0.0.0"
   },
   "files": [
     "dist",

package/src/core/migration-factories.ts

@@ -1,4 +1,9 @@
-import type { MongoIndexKey } from '@prisma-next/mongo-query-ast/control';
+import type {
+  MongoDataTransformCheck,
+  MongoDataTransformOperation,
+  MongoFilterExpr,
+  MongoIndexKey,
+} from '@prisma-next/mongo-query-ast/control';
 import {
   buildIndexOpId,
   CollModCommand,
@@ -14,11 +19,74 @@ import {
   ListCollectionsCommand,
   ListIndexesCommand,
   MongoAndExpr,
+  MongoExistsExpr,
   MongoFieldFilter,
   type MongoMigrationPlanOperation,
 } from '@prisma-next/mongo-query-ast/control';
+import type { MongoQueryPlan } from '@prisma-next/mongo-query-ast/execution';
 import type { CollModMeta } from './op-factory-call';
 
+interface Buildable {
+  build(): MongoQueryPlan;
+}
+
+function isBuildable(value: unknown): value is Buildable {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'build' in value &&
+    typeof (value as { build: unknown }).build === 'function'
+  );
+}
+
+function resolveQuery(value: MongoQueryPlan | Buildable): MongoQueryPlan {
+  return isBuildable(value) ? value.build() : value;
+}
+
+// Every MongoDB document carries `_id`, so `exists('_id')` is equivalent to
+// "match all". The filter AST has no identity/always-true expression.
+const MATCH_ALL_FILTER: MongoFilterExpr = MongoExistsExpr.exists('_id');
+
+export function dataTransform(
+  name: string,
+  options: {
+    check?: {
+      source: () => MongoQueryPlan | Buildable;
+      filter?: MongoFilterExpr;
+      expect?: 'exists' | 'notExists';
+      description?: string;
+    };
+    run: () => MongoQueryPlan | Buildable;
+  },
+): MongoDataTransformOperation {
+  let precheck: readonly MongoDataTransformCheck[] = [];
+  let postcheck: readonly MongoDataTransformCheck[] = [];
+
+  if (options.check) {
+    const source = resolveQuery(options.check.source());
+    const filter = options.check.filter ?? MATCH_ALL_FILTER;
+    const description = options.check.description ?? `Check for data transform: ${name}`;
+    const precheckExpect = options.check.expect ?? 'exists';
+    const postcheckExpect: 'exists' | 'notExists' =
+      precheckExpect === 'exists' ? 'notExists' : 'exists';
+
+    precheck = [{ description, source, filter, expect: precheckExpect }];
+    postcheck = [{ description, source, filter, expect: postcheckExpect }];
+  }
+
+  const run: MongoQueryPlan[] = [resolveQuery(options.run())];
+
+  return {
+    id: `data_transform.${name}`,
+    label: `Data transform: ${name}`,
+    operationClass: 'data',
+    name,
+    precheck,
+    run,
+    postcheck,
+  };
+}
+
 function formatKeys(keys: ReadonlyArray<MongoIndexKey>): string {
   return keys.map((k) => `${k.field}:${k.direction}`).join(', ');
 }

package/src/core/mongo-ops-serializer.ts

@@ -1,7 +1,9 @@
+import type { PlanMeta } from '@prisma-next/contract/types';
 import type { MigrationOperationClass } from '@prisma-next/framework-components/control';
 import {
   type AnyMongoDdlCommand,
   type AnyMongoInspectionCommand,
+  type AnyMongoMigrationOperation,
   CollModCommand,
   CreateCollectionCommand,
   CreateIndexCommand,
@@ -10,6 +12,8 @@ import {
   ListCollectionsCommand,
   ListIndexesCommand,
   MongoAndExpr,
+  type MongoDataTransformCheck,
+  type MongoDataTransformOperation,
   MongoExistsExpr,
   MongoFieldFilter,
   type MongoFilterExpr,
@@ -19,6 +23,30 @@ import {
   MongoNotExpr,
   MongoOrExpr,
 } from '@prisma-next/mongo-query-ast/control';
+import {
+  AggregateCommand,
+  type AnyMongoCommand,
+  MongoAddFieldsStage,
+  MongoLimitStage,
+  MongoLookupStage,
+  MongoMatchStage,
+  MongoMergeStage,
+  type MongoPipelineStage,
+  MongoProjectStage,
+  type MongoQueryPlan,
+  MongoSortStage,
+  type MongoUpdatePipelineStage,
+  RawAggregateCommand,
+  RawDeleteManyCommand,
+  RawDeleteOneCommand,
+  RawFindOneAndDeleteCommand,
+  RawFindOneAndUpdateCommand,
+  RawInsertManyCommand,
+  RawInsertOneCommand,
+  RawUpdateManyCommand,
+  RawUpdateOneCommand,
+} from '@prisma-next/mongo-query-ast/execution';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { type } from 'arktype';
 
 const IndexKeyDirection = type('1 | -1 | "text" | "2dsphere" | "2d" | "hashed"');
@@ -97,6 +125,97 @@ const ExistsFilterJson = type({
   exists: 'boolean',
 });
 
+// ============================================================================
+// DML command schemas
+// ============================================================================
+
+const RawInsertOneJson = type({
+  kind: '"rawInsertOne"',
+  collection: 'string',
+  document: 'Record<string, unknown>',
+});
+
+const RawInsertManyJson = type({
+  kind: '"rawInsertMany"',
+  collection: 'string',
+  documents: 'Record<string, unknown>[]',
+});
+
+const RawUpdateOneJson = type({
+  kind: '"rawUpdateOne"',
+  collection: 'string',
+  filter: 'Record<string, unknown>',
+  update: 'Record<string, unknown> | Record<string, unknown>[]',
+});
+
+const RawUpdateManyJson = type({
+  kind: '"rawUpdateMany"',
+  collection: 'string',
+  filter: 'Record<string, unknown>',
+  update: 'Record<string, unknown> | Record<string, unknown>[]',
+});
+
+const RawDeleteOneJson = type({
+  kind: '"rawDeleteOne"',
+  collection: 'string',
+  filter: 'Record<string, unknown>',
+});
+
+const RawDeleteManyJson = type({
+  kind: '"rawDeleteMany"',
+  collection: 'string',
+  filter: 'Record<string, unknown>',
+});
+
+const RawAggregateJson = type({
+  kind: '"rawAggregate"',
+  collection: 'string',
+  pipeline: 'Record<string, unknown>[]',
+});
+
+const RawFindOneAndUpdateJson = type({
+  kind: '"rawFindOneAndUpdate"',
+  collection: 'string',
+  filter: 'Record<string, unknown>',
+  update: 'Record<string, unknown> | Record<string, unknown>[]',
+  upsert: 'boolean',
+});
+
+const RawFindOneAndDeleteJson = type({
+  kind: '"rawFindOneAndDelete"',
+  collection: 'string',
+  filter: 'Record<string, unknown>',
+});
+
+const TypedAggregateJson = type({
+  kind: '"aggregate"',
+  collection: 'string',
+  pipeline: 'Record<string, unknown>[]',
+});
+
+const PlanMetaJson = type({
+  target: 'string',
+  storageHash: 'string',
+  lane: 'string',
+  paramDescriptors: 'unknown[]',
+  'targetFamily?': 'string',
+  'profileHash?': 'string',
+  'annotations?': 'Record<string, unknown>',
+  'refs?': 'Record<string, unknown>',
+  'projection?': 'Record<string, string> | string[]',
+  'projectionTypes?': 'Record<string, string>',
+});
+
+const QueryPlanJson = type({
+  collection: 'string',
+  command: 'Record<string, unknown>',
+  meta: PlanMetaJson,
+});
+
+// ============================================================================
+// DDL check/step schemas
+// ============================================================================
+
 const CheckJson = type({
   description: 'string',
   source: 'Record<string, unknown>',
@@ -109,7 +228,7 @@ const StepJson = type({
   command: 'Record<string, unknown>',
 });
 
-const OperationJson = type({
+const DdlOperationJson = type({
   id: 'string',
   label: 'string',
   operationClass: '"additive" | "widening" | "destructive"',
@@ -118,6 +237,23 @@ const OperationJson = type({
   postcheck: 'Record<string, unknown>[]',
 });
 
+const DataTransformCheckJson = type({
+  description: 'string',
+  source: 'Record<string, unknown>',
+  filter: 'Record<string, unknown>',
+  expect: '"exists" | "notExists"',
+});
+
+const DataTransformOperationJson = type({
+  id: 'string',
+  label: 'string',
+  operationClass: '"data"',
+  name: 'string',
+  precheck: 'Record<string, unknown>[]',
+  run: 'Record<string, unknown>[]',
+  postcheck: 'Record<string, unknown>[]',
+});
+
 function validate<T>(schema: { assert: (data: unknown) => T }, data: unknown, context: string): T {
   try {
     return schema.assert(data);
@@ -161,6 +297,151 @@ function deserializeFilterExpr(json: unknown): MongoFilterExpr {
   }
 }
 
+// ============================================================================
+// Pipeline stage deserialization
+// ============================================================================
+
+export function deserializePipelineStage(json: unknown): MongoPipelineStage {
+  const record = json as Record<string, unknown>;
+  const kind = record['kind'] as string;
+  switch (kind) {
+    case 'match':
+      return new MongoMatchStage(deserializeFilterExpr(record['filter']));
+    case 'limit':
+      return new MongoLimitStage(record['limit'] as number);
+    case 'sort':
+      return new MongoSortStage(record['sort'] as Record<string, 1 | -1>);
+    case 'project':
+      return new MongoProjectStage(record['projection'] as Record<string, 0 | 1>);
+    case 'addFields':
+      return new MongoAddFieldsStage(record['fields'] as Record<string, never>);
+    case 'lookup': {
+      const opts: {
+        from: string;
+        as: string;
+        localField?: string;
+        foreignField?: string;
+        pipeline?: ReadonlyArray<MongoPipelineStage>;
+        let_?: Record<string, never>;
+      } = {
+        from: record['from'] as string,
+        as: record['as'] as string,
+      };
+      if (record['localField'] !== undefined) opts.localField = record['localField'] as string;
+      if (record['foreignField'] !== undefined)
+        opts.foreignField = record['foreignField'] as string;
+      if (record['pipeline'] !== undefined)
+        opts.pipeline = (record['pipeline'] as unknown[]).map(deserializePipelineStage);
+      if (record['let_'] !== undefined) opts.let_ = record['let_'] as Record<string, never>;
+      return new MongoLookupStage(opts);
+    }
+    case 'merge': {
+      const opts: {
+        into: string | { db: string; coll: string };
+        on?: string | ReadonlyArray<string>;
+        whenMatched?: string | ReadonlyArray<MongoUpdatePipelineStage>;
+        whenNotMatched?: string;
+      } = {
+        into: record['into'] as string | { db: string; coll: string },
+      };
+      if (record['on'] !== undefined) opts.on = record['on'] as string | string[];
+      if (record['whenMatched'] !== undefined) {
+        const wm = record['whenMatched'];
+        opts.whenMatched =
+          typeof wm === 'string'
+            ? wm
+            : ((wm as unknown[]).map(deserializePipelineStage) as MongoUpdatePipelineStage[]);
+      }
+      if (record['whenNotMatched'] !== undefined)
+        opts.whenNotMatched = record['whenNotMatched'] as string;
+      return new MongoMergeStage(opts);
+    }
+    default:
+      throw new Error(`Unknown pipeline stage kind: ${kind}`);
+  }
+}
+
+// ============================================================================
+// DML command deserialization
+// ============================================================================
+
+export function deserializeDmlCommand(json: unknown): AnyMongoCommand {
+  const record = json as Record<string, unknown>;
+  const kind = record['kind'] as string;
+  switch (kind) {
+    case 'rawInsertOne': {
+      const data = validate(RawInsertOneJson, json, 'rawInsertOne command');
+      return new RawInsertOneCommand(data.collection, data.document);
+    }
+    case 'rawInsertMany': {
+      const data = validate(RawInsertManyJson, json, 'rawInsertMany command');
+      return new RawInsertManyCommand(data.collection, data.documents);
+    }
+    case 'rawUpdateOne': {
+      const data = validate(RawUpdateOneJson, json, 'rawUpdateOne command');
+      return new RawUpdateOneCommand(data.collection, data.filter, data.update);
+    }
+    case 'rawUpdateMany': {
+      const data = validate(RawUpdateManyJson, json, 'rawUpdateMany command');
+      return new RawUpdateManyCommand(data.collection, data.filter, data.update);
+    }
+    case 'rawDeleteOne': {
+      const data = validate(RawDeleteOneJson, json, 'rawDeleteOne command');
+      return new RawDeleteOneCommand(data.collection, data.filter);
+    }
+    case 'rawDeleteMany': {
+      const data = validate(RawDeleteManyJson, json, 'rawDeleteMany command');
+      return new RawDeleteManyCommand(data.collection, data.filter);
+    }
+    case 'rawAggregate': {
+      const data = validate(RawAggregateJson, json, 'rawAggregate command');
+      return new RawAggregateCommand(data.collection, data.pipeline);
+    }
+    case 'rawFindOneAndUpdate': {
+      const data = validate(RawFindOneAndUpdateJson, json, 'rawFindOneAndUpdate command');
+      return new RawFindOneAndUpdateCommand(data.collection, data.filter, data.update, data.upsert);
+    }
+    case 'rawFindOneAndDelete': {
+      const data = validate(RawFindOneAndDeleteJson, json, 'rawFindOneAndDelete command');
+      return new RawFindOneAndDeleteCommand(data.collection, data.filter);
+    }
+    case 'aggregate': {
+      const data = validate(TypedAggregateJson, json, 'aggregate command');
+      const pipeline = data.pipeline.map(deserializePipelineStage);
+      return new AggregateCommand(data.collection, pipeline);
+    }
+    default:
+      throw new Error(`Unknown DML command kind: ${kind}`);
+  }
+}
+
+// ============================================================================
+// MongoQueryPlan deserialization
+// ============================================================================
+
+export function deserializeMongoQueryPlan(json: unknown): MongoQueryPlan {
+  const data = validate(QueryPlanJson, json, 'Mongo query plan');
+  const command = deserializeDmlCommand(data.command);
+  const m = data.meta;
+  const meta: PlanMeta = {
+    target: m.target,
+    storageHash: m.storageHash,
+    lane: m.lane,
+    paramDescriptors: m.paramDescriptors as PlanMeta['paramDescriptors'],
+    ...ifDefined('targetFamily', m.targetFamily),
+    ...ifDefined('profileHash', m.profileHash),
+    ...ifDefined('annotations', m.annotations),
+    ...ifDefined('refs', m.refs),
+    ...ifDefined('projection', m.projection),
+    ...ifDefined('projectionTypes', m.projectionTypes),
+  };
+  return { collection: data.collection, command, meta };
+}
+
+// ============================================================================
+// DDL command deserialization
+// ============================================================================
+
 function deserializeDdlCommand(json: unknown): AnyMongoDdlCommand {
   const record = json as Record<string, unknown>;
   const kind = record['kind'] as string;
@@ -256,8 +537,16 @@ function deserializeStep(json: unknown): MongoMigrationStep {
   };
 }
 
-export function deserializeMongoOp(json: unknown): MongoMigrationPlanOperation {
-  const data = validate(OperationJson, json, 'migration operation');
+function isDataTransformJson(json: unknown): boolean {
+  return (
+    typeof json === 'object' &&
+    json !== null &&
+    (json as Record<string, unknown>)['operationClass'] === 'data'
+  );
+}
+
+function deserializeDdlOp(json: unknown): MongoMigrationPlanOperation {
+  const data = validate(DdlOperationJson, json, 'migration operation');
   return {
     id: data.id,
     label: data.label,
@@ -268,10 +557,40 @@ export function deserializeMongoOp(json: unknown): MongoMigrationPlanOperation {
   };
 }
 
-export function deserializeMongoOps(json: readonly unknown[]): MongoMigrationPlanOperation[] {
+function deserializeDataTransformCheck(json: unknown): MongoDataTransformCheck {
+  const data = validate(DataTransformCheckJson, json, 'data transform check');
+  return {
+    description: data.description,
+    source: deserializeMongoQueryPlan(data.source),
+    filter: deserializeFilterExpr(data.filter),
+    expect: data.expect,
+  };
+}
+
+function deserializeDataTransformOp(json: unknown): MongoDataTransformOperation {
+  const data = validate(DataTransformOperationJson, json, 'data transform operation');
+  return {
+    id: data.id,
+    label: data.label,
+    operationClass: 'data',
+    name: data.name,
+    precheck: data.precheck.map(deserializeDataTransformCheck),
+    run: data.run.map(deserializeMongoQueryPlan),
+    postcheck: data.postcheck.map(deserializeDataTransformCheck),
+  };
+}
+
+export function deserializeMongoOp(json: unknown): AnyMongoMigrationOperation {
+  if (isDataTransformJson(json)) {
+    return deserializeDataTransformOp(json);
+  }
+  return deserializeDdlOp(json);
+}
+
+export function deserializeMongoOps(json: readonly unknown[]): AnyMongoMigrationOperation[] {
   return json.map(deserializeMongoOp);
 }
 
-export function serializeMongoOps(ops: readonly MongoMigrationPlanOperation[]): string {
+export function serializeMongoOps(ops: readonly AnyMongoMigrationOperation[]): string {
   return JSON.stringify(ops, null, 2);
 }