@prisma-next/target-mongo 0.4.0-dev.1 → 0.4.0-dev.3

package/package.json

@@ -1,14 +1,19 @@
 {
   "name": "@prisma-next/target-mongo",
-  "version": "0.4.0-dev.1",
+  "version": "0.4.0-dev.3",
   "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.1",
-    "@prisma-next/mongo-query-ast": "0.4.0-dev.1",
-    "@prisma-next/framework-components": "0.4.0-dev.1"
+    "@prisma-next/contract": "0.4.0-dev.3",
+    "@prisma-next/mongo-contract": "0.4.0-dev.3",
+    "@prisma-next/framework-components": "0.4.0-dev.3",
+    "@prisma-next/mongo-query-ast": "0.4.0-dev.3",
+    "@prisma-next/utils": "0.4.0-dev.3",
+    "@prisma-next/mongo-schema-ir": "0.4.0-dev.3",
+    "@prisma-next/mongo-value": "0.4.0-dev.3"
   },
   "devDependencies": {
     "mongodb-memory-server": "10.4.3",

package/src/core/contract-to-schema.ts

@@ -0,0 +1,63 @@
+import type {
+  MongoContract,
+  MongoStorageCollection,
+  MongoStorageCollectionOptions,
+  MongoStorageIndex,
+  MongoStorageValidator,
+} from '@prisma-next/mongo-contract';
+import {
+  MongoSchemaCollection,
+  MongoSchemaCollectionOptions,
+  MongoSchemaIndex,
+  MongoSchemaIR,
+  MongoSchemaValidator,
+} from '@prisma-next/mongo-schema-ir';
+
+function convertIndex(index: MongoStorageIndex): MongoSchemaIndex {
+  return new MongoSchemaIndex({
+    keys: index.keys,
+    unique: index.unique,
+    sparse: index.sparse,
+    expireAfterSeconds: index.expireAfterSeconds,
+    partialFilterExpression: index.partialFilterExpression,
+    wildcardProjection: index.wildcardProjection,
+    collation: index.collation,
+    weights: index.weights,
+    default_language: index.default_language,
+    language_override: index.language_override,
+  });
+}
+
+function convertValidator(v: MongoStorageValidator): MongoSchemaValidator {
+  return new MongoSchemaValidator({
+    jsonSchema: v.jsonSchema,
+    validationLevel: v.validationLevel,
+    validationAction: v.validationAction,
+  });
+}
+
+function convertOptions(o: MongoStorageCollectionOptions): MongoSchemaCollectionOptions {
+  return new MongoSchemaCollectionOptions(o);
+}
+
+function convertCollection(name: string, def: MongoStorageCollection): MongoSchemaCollection {
+  const indexes = (def.indexes ?? []).map(convertIndex);
+  return new MongoSchemaCollection({
+    name,
+    indexes,
+    ...(def.validator != null && { validator: convertValidator(def.validator) }),
+    ...(def.options != null && { options: convertOptions(def.options) }),
+  });
+}
+
+export function contractToMongoSchemaIR(contract: MongoContract | null): MongoSchemaIR {
+  if (!contract) {
+    return new MongoSchemaIR([]);
+  }
+
+  const collections = Object.entries(contract.storage.collections).map(([name, def]) =>
+    convertCollection(name, def),
+  );
+
+  return new MongoSchemaIR(collections);
+}

package/src/core/ddl-formatter.ts

@@ -0,0 +1,112 @@
+import type { MigrationPlanOperation } from '@prisma-next/framework-components/control';
+import type {
+  CollModCommand,
+  CreateCollectionCommand,
+  CreateIndexCommand,
+  DropCollectionCommand,
+  DropIndexCommand,
+  MongoDdlCommandVisitor,
+  MongoIndexKey,
+} from '@prisma-next/mongo-query-ast/control';
+
+function formatKeySpec(keys: ReadonlyArray<MongoIndexKey>): string {
+  const entries = keys.map((k) => `${JSON.stringify(k.field)}: ${JSON.stringify(k.direction)}`);
+  return `{ ${entries.join(', ')} }`;
+}
+
+function formatOptions(cmd: CreateIndexCommand): string | undefined {
+  const parts: string[] = [];
+  if (cmd.unique) parts.push('unique: true');
+  if (cmd.sparse) parts.push('sparse: true');
+  if (cmd.expireAfterSeconds !== undefined)
+    parts.push(`expireAfterSeconds: ${cmd.expireAfterSeconds}`);
+  if (cmd.name) parts.push(`name: ${JSON.stringify(cmd.name)}`);
+  if (cmd.collation) parts.push(`collation: ${JSON.stringify(cmd.collation)}`);
+  if (cmd.weights) parts.push(`weights: ${JSON.stringify(cmd.weights)}`);
+  if (cmd.default_language) parts.push(`default_language: ${JSON.stringify(cmd.default_language)}`);
+  if (cmd.language_override)
+    parts.push(`language_override: ${JSON.stringify(cmd.language_override)}`);
+  if (cmd.wildcardProjection)
+    parts.push(`wildcardProjection: ${JSON.stringify(cmd.wildcardProjection)}`);
+  if (cmd.partialFilterExpression)
+    parts.push(`partialFilterExpression: ${JSON.stringify(cmd.partialFilterExpression)}`);
+  if (parts.length === 0) return undefined;
+  return `{ ${parts.join(', ')} }`;
+}
+
+function formatCreateCollectionOptions(cmd: CreateCollectionCommand): string | undefined {
+  const parts: string[] = [];
+  if (cmd.capped) parts.push('capped: true');
+  if (cmd.size !== undefined) parts.push(`size: ${cmd.size}`);
+  if (cmd.max !== undefined) parts.push(`max: ${cmd.max}`);
+  if (cmd.timeseries) parts.push(`timeseries: ${JSON.stringify(cmd.timeseries)}`);
+  if (cmd.collation) parts.push(`collation: ${JSON.stringify(cmd.collation)}`);
+  if (cmd.clusteredIndex) parts.push(`clusteredIndex: ${JSON.stringify(cmd.clusteredIndex)}`);
+  if (cmd.validator) parts.push(`validator: ${JSON.stringify(cmd.validator)}`);
+  if (cmd.validationLevel) parts.push(`validationLevel: ${JSON.stringify(cmd.validationLevel)}`);
+  if (cmd.validationAction) parts.push(`validationAction: ${JSON.stringify(cmd.validationAction)}`);
+  if (cmd.changeStreamPreAndPostImages)
+    parts.push(`changeStreamPreAndPostImages: ${JSON.stringify(cmd.changeStreamPreAndPostImages)}`);
+  if (parts.length === 0) return undefined;
+  return `{ ${parts.join(', ')} }`;
+}
+
+class MongoDdlCommandFormatter implements MongoDdlCommandVisitor<string> {
+  createIndex(cmd: CreateIndexCommand): string {
+    const keySpec = formatKeySpec(cmd.keys);
+    const opts = formatOptions(cmd);
+    return opts
+      ? `db.${cmd.collection}.createIndex(${keySpec}, ${opts})`
+      : `db.${cmd.collection}.createIndex(${keySpec})`;
+  }
+
+  dropIndex(cmd: DropIndexCommand): string {
+    return `db.${cmd.collection}.dropIndex(${JSON.stringify(cmd.name)})`;
+  }
+
+  createCollection(cmd: CreateCollectionCommand): string {
+    const opts = formatCreateCollectionOptions(cmd);
+    return opts
+      ? `db.createCollection(${JSON.stringify(cmd.collection)}, ${opts})`
+      : `db.createCollection(${JSON.stringify(cmd.collection)})`;
+  }
+
+  dropCollection(cmd: DropCollectionCommand): string {
+    return `db.${cmd.collection}.drop()`;
+  }
+
+  collMod(cmd: CollModCommand): string {
+    const parts: string[] = [`collMod: ${JSON.stringify(cmd.collection)}`];
+    if (cmd.validator) parts.push(`validator: ${JSON.stringify(cmd.validator)}`);
+    if (cmd.validationLevel) parts.push(`validationLevel: ${JSON.stringify(cmd.validationLevel)}`);
+    if (cmd.validationAction)
+      parts.push(`validationAction: ${JSON.stringify(cmd.validationAction)}`);
+    if (cmd.changeStreamPreAndPostImages)
+      parts.push(
+        `changeStreamPreAndPostImages: ${JSON.stringify(cmd.changeStreamPreAndPostImages)}`,
+      );
+    return `db.runCommand({ ${parts.join(', ')} })`;
+  }
+}
+
+const formatter = new MongoDdlCommandFormatter();
+
+interface MongoExecuteStep {
+  readonly command: { readonly accept: <R>(visitor: MongoDdlCommandVisitor<R>) => R };
+}
+
+export function formatMongoOperations(operations: readonly MigrationPlanOperation[]): string[] {
+  const statements: string[] = [];
+  for (const operation of operations) {
+    const candidate = operation as unknown as Record<string, unknown>;
+    if (!('execute' in candidate) || !Array.isArray(candidate['execute'])) {
+      continue;
+    }
+    for (const step of candidate['execute'] as MongoExecuteStep[]) {
+      if (step.command && typeof step.command.accept === 'function') {
+        statements.push(step.command.accept(formatter));
+      }
+    }
+  }
+  return statements;
+}

package/src/core/filter-evaluator.ts

@@ -0,0 +1,84 @@
+import type {
+  MongoAndExpr,
+  MongoExistsExpr,
+  MongoExprFilter,
+  MongoFieldFilter,
+  MongoFilterExpr,
+  MongoFilterVisitor,
+  MongoNotExpr,
+  MongoOrExpr,
+} from '@prisma-next/mongo-query-ast/control';
+import { deepEqual } from '@prisma-next/mongo-schema-ir';
+import type { MongoValue } from '@prisma-next/mongo-value';
+
+function getNestedField(doc: Record<string, unknown>, path: string): unknown {
+  const parts = path.split('.');
+  let current: unknown = doc;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== 'object') {
+      return undefined;
+    }
+    const record = current as Record<string, unknown>;
+    if (!Object.hasOwn(record, part)) {
+      return undefined;
+    }
+    current = record[part];
+  }
+  return current;
+}
+
+function evaluateFieldOp(op: string, actual: unknown, expected: MongoValue): boolean {
+  switch (op) {
+    case '$eq':
+      return deepEqual(actual, expected);
+    case '$ne':
+      return !deepEqual(actual, expected);
+    case '$gt':
+      return typeof actual === typeof expected && (actual as number) > (expected as number);
+    case '$gte':
+      return typeof actual === typeof expected && (actual as number) >= (expected as number);
+    case '$lt':
+      return typeof actual === typeof expected && (actual as number) < (expected as number);
+    case '$lte':
+      return typeof actual === typeof expected && (actual as number) <= (expected as number);
+    case '$in':
+      return Array.isArray(expected) && expected.some((v) => deepEqual(actual, v));
+    default:
+      throw new Error(`Unsupported filter operator in migration check: ${op}`);
+  }
+}
+
+export class FilterEvaluator implements MongoFilterVisitor<boolean> {
+  private doc: Record<string, unknown> = {};
+
+  evaluate(filter: MongoFilterExpr, doc: Record<string, unknown>): boolean {
+    this.doc = doc;
+    return filter.accept(this);
+  }
+
+  field(expr: MongoFieldFilter): boolean {
+    const value = getNestedField(this.doc, expr.field);
+    return evaluateFieldOp(expr.op, value, expr.value);
+  }
+
+  and(expr: MongoAndExpr): boolean {
+    return expr.exprs.every((child) => child.accept(this));
+  }
+
+  or(expr: MongoOrExpr): boolean {
+    return expr.exprs.some((child) => child.accept(this));
+  }
+
+  not(expr: MongoNotExpr): boolean {
+    return !expr.expr.accept(this);
+  }
+
+  exists(expr: MongoExistsExpr): boolean {
+    const has = getNestedField(this.doc, expr.field) !== undefined;
+    return expr.exists ? has : !has;
+  }
+
+  expr(_expr: MongoExprFilter): boolean {
+    throw new Error('Aggregation expression filters are not supported in migration checks');
+  }
+}

package/src/core/migration-factories.ts

@@ -2,6 +2,7 @@ import type { MongoIndexKey } from '@prisma-next/mongo-query-ast/control';
 import {
   buildIndexOpId,
   CollModCommand,
+  type CollModOptions,
   CreateCollectionCommand,
   type CreateCollectionOptions,
   CreateIndexCommand,
@@ -16,6 +17,7 @@ import {
   MongoFieldFilter,
   type MongoMigrationPlanOperation,
 } from '@prisma-next/mongo-query-ast/control';
+import type { CollModMeta } from './op-factory-call';
 
 function formatKeys(keys: ReadonlyArray<MongoIndexKey>): string {
   return keys.map((k) => `${k.field}:${k.direction}`).join(', ');
@@ -177,6 +179,55 @@ export function setValidation(
   };
 }
 
+export function collMod(
+  collection: string,
+  options: CollModOptions,
+  meta?: CollModMeta,
+): MongoMigrationPlanOperation {
+  const hasValidator = options.validator != null && Object.keys(options.validator).length > 0;
+
+  return {
+    id: meta?.id ?? `collection.${collection}.collMod`,
+    label: meta?.label ?? `Modify collection ${collection}`,
+    operationClass: meta?.operationClass ?? 'destructive',
+    precheck:
+      options.validator != null
+        ? [
+            {
+              description: `collection ${collection} exists`,
+              source: new ListCollectionsCommand(),
+              filter: MongoFieldFilter.eq('name', collection),
+              expect: 'exists' as const,
+            },
+          ]
+        : [],
+    execute: [
+      {
+        description: `modify ${collection}`,
+        command: new CollModCommand(collection, options),
+      },
+    ],
+    postcheck: hasValidator
+      ? [
+          {
+            description: `validator applied on ${collection}`,
+            source: new ListCollectionsCommand(),
+            filter: MongoAndExpr.of([
+              MongoFieldFilter.eq('name', collection),
+              ...(options.validationLevel
+                ? [MongoFieldFilter.eq('options.validationLevel', options.validationLevel)]
+                : []),
+              ...(options.validationAction
+                ? [MongoFieldFilter.eq('options.validationAction', options.validationAction)]
+                : []),
+            ]),
+            expect: 'exists' as const,
+          },
+        ]
+      : [],
+  };
+}
+
 export function validatedCollection(
   name: string,
   schema: Record<string, unknown>,

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

@@ -0,0 +1,277 @@
+import type { MigrationOperationClass } from '@prisma-next/framework-components/control';
+import {
+  type AnyMongoDdlCommand,
+  type AnyMongoInspectionCommand,
+  CollModCommand,
+  CreateCollectionCommand,
+  CreateIndexCommand,
+  DropCollectionCommand,
+  DropIndexCommand,
+  ListCollectionsCommand,
+  ListIndexesCommand,
+  MongoAndExpr,
+  MongoExistsExpr,
+  MongoFieldFilter,
+  type MongoFilterExpr,
+  type MongoMigrationCheck,
+  type MongoMigrationPlanOperation,
+  type MongoMigrationStep,
+  MongoNotExpr,
+  MongoOrExpr,
+} from '@prisma-next/mongo-query-ast/control';
+import { type } from 'arktype';
+
+const IndexKeyDirection = type('1 | -1 | "text" | "2dsphere" | "2d" | "hashed"');
+const IndexKeyJson = type({ field: 'string', direction: IndexKeyDirection });
+
+const CreateIndexJson = type({
+  kind: '"createIndex"',
+  collection: 'string',
+  keys: IndexKeyJson.array().atLeastLength(1),
+  'unique?': 'boolean',
+  'sparse?': 'boolean',
+  'expireAfterSeconds?': 'number',
+  'partialFilterExpression?': 'Record<string, unknown>',
+  'name?': 'string',
+  'wildcardProjection?': 'Record<string, unknown>',
+  'collation?': 'Record<string, unknown>',
+  'weights?': 'Record<string, unknown>',
+  'default_language?': 'string',
+  'language_override?': 'string',
+});
+
+const DropIndexJson = type({
+  kind: '"dropIndex"',
+  collection: 'string',
+  name: 'string',
+});
+
+const CreateCollectionJson = type({
+  kind: '"createCollection"',
+  collection: 'string',
+  'validator?': 'Record<string, unknown>',
+  'validationLevel?': '"strict" | "moderate"',
+  'validationAction?': '"error" | "warn"',
+  'capped?': 'boolean',
+  'size?': 'number',
+  'max?': 'number',
+  'timeseries?': 'Record<string, unknown>',
+  'collation?': 'Record<string, unknown>',
+  'changeStreamPreAndPostImages?': 'Record<string, unknown>',
+  'clusteredIndex?': 'Record<string, unknown>',
+});
+
+const DropCollectionJson = type({
+  kind: '"dropCollection"',
+  collection: 'string',
+});
+
+const CollModJson = type({
+  kind: '"collMod"',
+  collection: 'string',
+  'validator?': 'Record<string, unknown>',
+  'validationLevel?': '"strict" | "moderate"',
+  'validationAction?': '"error" | "warn"',
+  'changeStreamPreAndPostImages?': 'Record<string, unknown>',
+});
+
+const ListIndexesJson = type({
+  kind: '"listIndexes"',
+  collection: 'string',
+});
+
+const ListCollectionsJson = type({
+  kind: '"listCollections"',
+});
+
+const FieldFilterJson = type({
+  kind: '"field"',
+  field: 'string',
+  op: 'string',
+  value: 'unknown',
+});
+
+const ExistsFilterJson = type({
+  kind: '"exists"',
+  field: 'string',
+  exists: 'boolean',
+});
+
+const CheckJson = type({
+  description: 'string',
+  source: 'Record<string, unknown>',
+  filter: 'Record<string, unknown>',
+  expect: '"exists" | "notExists"',
+});
+
+const StepJson = type({
+  description: 'string',
+  command: 'Record<string, unknown>',
+});
+
+const OperationJson = type({
+  id: 'string',
+  label: 'string',
+  operationClass: '"additive" | "widening" | "destructive"',
+  precheck: 'Record<string, unknown>[]',
+  execute: '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);
+  } catch (error) {
+    /* v8 ignore start -- assertion libraries always throw Error instances */
+    const message = error instanceof Error ? error.message : String(error);
+    /* v8 ignore stop */
+    throw new Error(`Invalid ${context}: ${message}`);
+  }
+}
+
+function deserializeFilterExpr(json: unknown): MongoFilterExpr {
+  const record = json as Record<string, unknown>;
+  const kind = record['kind'] as string;
+  switch (kind) {
+    case 'field': {
+      const data = validate(FieldFilterJson, json, 'field filter');
+      return MongoFieldFilter.of(data.field, data.op, data.value as never);
+    }
+    case 'and': {
+      const exprs = record['exprs'];
+      if (!Array.isArray(exprs)) throw new Error('Invalid and filter: missing exprs array');
+      return MongoAndExpr.of(exprs.map(deserializeFilterExpr));
+    }
+    case 'or': {
+      const exprs = record['exprs'];
+      if (!Array.isArray(exprs)) throw new Error('Invalid or filter: missing exprs array');
+      return MongoOrExpr.of(exprs.map(deserializeFilterExpr));
+    }
+    case 'not': {
+      const expr = record['expr'];
+      if (!expr || typeof expr !== 'object') throw new Error('Invalid not filter: missing expr');
+      return new MongoNotExpr(deserializeFilterExpr(expr));
+    }
+    case 'exists': {
+      const data = validate(ExistsFilterJson, json, 'exists filter');
+      return new MongoExistsExpr(data.field, data.exists);
+    }
+    default:
+      throw new Error(`Unknown filter expression kind: ${kind}`);
+  }
+}
+
+function deserializeDdlCommand(json: unknown): AnyMongoDdlCommand {
+  const record = json as Record<string, unknown>;
+  const kind = record['kind'] as string;
+  switch (kind) {
+    case 'createIndex': {
+      const data = validate(CreateIndexJson, json, 'createIndex command');
+      return new CreateIndexCommand(data.collection, data.keys, {
+        unique: data.unique,
+        sparse: data.sparse,
+        expireAfterSeconds: data.expireAfterSeconds,
+        partialFilterExpression: data.partialFilterExpression,
+        name: data.name,
+        wildcardProjection: data.wildcardProjection as Record<string, 0 | 1> | undefined,
+        collation: data.collation,
+        weights: data.weights as Record<string, number> | undefined,
+        default_language: data.default_language,
+        language_override: data.language_override,
+      });
+    }
+    case 'dropIndex': {
+      const data = validate(DropIndexJson, json, 'dropIndex command');
+      return new DropIndexCommand(data.collection, data.name);
+    }
+    case 'createCollection': {
+      const data = validate(CreateCollectionJson, json, 'createCollection command');
+      return new CreateCollectionCommand(data.collection, {
+        validator: data.validator,
+        validationLevel: data.validationLevel,
+        validationAction: data.validationAction,
+        capped: data.capped,
+        size: data.size,
+        max: data.max,
+        timeseries: data.timeseries as CreateCollectionCommand['timeseries'],
+        collation: data.collation,
+        changeStreamPreAndPostImages: data.changeStreamPreAndPostImages as
+          | { enabled: boolean }
+          | undefined,
+        clusteredIndex: data.clusteredIndex as CreateCollectionCommand['clusteredIndex'],
+      });
+    }
+    case 'dropCollection': {
+      const data = validate(DropCollectionJson, json, 'dropCollection command');
+      return new DropCollectionCommand(data.collection);
+    }
+    case 'collMod': {
+      const data = validate(CollModJson, json, 'collMod command');
+      return new CollModCommand(data.collection, {
+        validator: data.validator,
+        validationLevel: data.validationLevel,
+        validationAction: data.validationAction,
+        changeStreamPreAndPostImages: data.changeStreamPreAndPostImages as
+          | { enabled: boolean }
+          | undefined,
+      });
+    }
+    default:
+      throw new Error(`Unknown DDL command kind: ${kind}`);
+  }
+}
+
+function deserializeInspectionCommand(json: unknown): AnyMongoInspectionCommand {
+  const record = json as Record<string, unknown>;
+  const kind = record['kind'] as string;
+  switch (kind) {
+    case 'listIndexes': {
+      const data = validate(ListIndexesJson, json, 'listIndexes command');
+      return new ListIndexesCommand(data.collection);
+    }
+    case 'listCollections': {
+      validate(ListCollectionsJson, json, 'listCollections command');
+      return new ListCollectionsCommand();
+    }
+    default:
+      throw new Error(`Unknown inspection command kind: ${kind}`);
+  }
+}
+
+function deserializeCheck(json: unknown): MongoMigrationCheck {
+  const data = validate(CheckJson, json, 'migration check');
+  return {
+    description: data.description,
+    source: deserializeInspectionCommand(data.source),
+    filter: deserializeFilterExpr(data.filter),
+    expect: data.expect,
+  };
+}
+
+function deserializeStep(json: unknown): MongoMigrationStep {
+  const data = validate(StepJson, json, 'migration step');
+  return {
+    description: data.description,
+    command: deserializeDdlCommand(data.command),
+  };
+}
+
+export function deserializeMongoOp(json: unknown): MongoMigrationPlanOperation {
+  const data = validate(OperationJson, json, 'migration operation');
+  return {
+    id: data.id,
+    label: data.label,
+    operationClass: data.operationClass as MigrationOperationClass,
+    precheck: data.precheck.map(deserializeCheck),
+    execute: data.execute.map(deserializeStep),
+    postcheck: data.postcheck.map(deserializeCheck),
+  };
+}
+
+export function deserializeMongoOps(json: readonly unknown[]): MongoMigrationPlanOperation[] {
+  return json.map(deserializeMongoOp);
+}
+
+export function serializeMongoOps(ops: readonly MongoMigrationPlanOperation[]): string {
+  return JSON.stringify(ops, null, 2);
+}