@prisma-next/target-mongo 0.3.0 → 0.4.0-dev.2

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

@@ -0,0 +1,244 @@
+import type { MongoIndexKey } from '@prisma-next/mongo-query-ast/control';
+import {
+  buildIndexOpId,
+  CollModCommand,
+  type CollModOptions,
+  CreateCollectionCommand,
+  type CreateCollectionOptions,
+  CreateIndexCommand,
+  type CreateIndexOptions,
+  DropCollectionCommand,
+  DropIndexCommand,
+  defaultMongoIndexName,
+  keysToKeySpec,
+  ListCollectionsCommand,
+  ListIndexesCommand,
+  MongoAndExpr,
+  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(', ');
+}
+
+function isTextIndex(keys: ReadonlyArray<MongoIndexKey>): boolean {
+  return keys.some((k) => k.direction === 'text');
+}
+
+function keyFilter(keys: ReadonlyArray<MongoIndexKey>) {
+  return isTextIndex(keys)
+    ? MongoFieldFilter.eq('key._fts', 'text')
+    : MongoFieldFilter.eq('key', keysToKeySpec(keys));
+}
+
+export function createIndex(
+  collection: string,
+  keys: ReadonlyArray<MongoIndexKey>,
+  options?: CreateIndexOptions,
+): MongoMigrationPlanOperation {
+  const name = defaultMongoIndexName(keys);
+  const filter = keyFilter(keys);
+  const fullFilter = options?.unique
+    ? MongoAndExpr.of([filter, MongoFieldFilter.eq('unique', true)])
+    : filter;
+
+  return {
+    id: buildIndexOpId('create', collection, keys),
+    label: `Create index on ${collection} (${formatKeys(keys)})`,
+    operationClass: 'additive',
+    precheck: [
+      {
+        description: `index does not already exist on ${collection}`,
+        source: new ListIndexesCommand(collection),
+        filter,
+        expect: 'notExists',
+      },
+    ],
+    execute: [
+      {
+        description: `create index on ${collection}`,
+        command: new CreateIndexCommand(collection, keys, {
+          ...options,
+          unique: options?.unique ?? undefined,
+          name,
+        }),
+      },
+    ],
+    postcheck: [
+      {
+        description: `index exists on ${collection}`,
+        source: new ListIndexesCommand(collection),
+        filter: fullFilter,
+        expect: 'exists',
+      },
+    ],
+  };
+}
+
+export function dropIndex(
+  collection: string,
+  keys: ReadonlyArray<MongoIndexKey>,
+): MongoMigrationPlanOperation {
+  const indexName = defaultMongoIndexName(keys);
+  const filter = keyFilter(keys);
+
+  return {
+    id: buildIndexOpId('drop', collection, keys),
+    label: `Drop index on ${collection} (${formatKeys(keys)})`,
+    operationClass: 'destructive',
+    precheck: [
+      {
+        description: `index exists on ${collection}`,
+        source: new ListIndexesCommand(collection),
+        filter,
+        expect: 'exists',
+      },
+    ],
+    execute: [
+      {
+        description: `drop index on ${collection}`,
+        command: new DropIndexCommand(collection, indexName),
+      },
+    ],
+    postcheck: [
+      {
+        description: `index no longer exists on ${collection}`,
+        source: new ListIndexesCommand(collection),
+        filter,
+        expect: 'notExists',
+      },
+    ],
+  };
+}
+
+export function createCollection(
+  collection: string,
+  options?: CreateCollectionOptions,
+): MongoMigrationPlanOperation {
+  return {
+    id: `collection.${collection}.create`,
+    label: `Create collection ${collection}`,
+    operationClass: 'additive',
+    precheck: [
+      {
+        description: `collection ${collection} does not exist`,
+        source: new ListCollectionsCommand(),
+        filter: MongoFieldFilter.eq('name', collection),
+        expect: 'notExists',
+      },
+    ],
+    execute: [
+      {
+        description: `create collection ${collection}`,
+        command: new CreateCollectionCommand(collection, options),
+      },
+    ],
+    postcheck: [],
+  };
+}
+
+export function dropCollection(collection: string): MongoMigrationPlanOperation {
+  return {
+    id: `collection.${collection}.drop`,
+    label: `Drop collection ${collection}`,
+    operationClass: 'destructive',
+    precheck: [],
+    execute: [
+      {
+        description: `drop collection ${collection}`,
+        command: new DropCollectionCommand(collection),
+      },
+    ],
+    postcheck: [],
+  };
+}
+
+export function setValidation(
+  collection: string,
+  schema: Record<string, unknown>,
+  options?: { validationLevel?: 'strict' | 'moderate'; validationAction?: 'error' | 'warn' },
+): MongoMigrationPlanOperation {
+  return {
+    id: `collection.${collection}.setValidation`,
+    label: `Set validation on ${collection}`,
+    operationClass: 'destructive',
+    precheck: [],
+    execute: [
+      {
+        description: `set validation on ${collection}`,
+        command: new CollModCommand(collection, {
+          validator: { $jsonSchema: schema },
+          validationLevel: options?.validationLevel,
+          validationAction: options?.validationAction,
+        }),
+      },
+    ],
+    postcheck: [],
+  };
+}
+
+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>,
+  indexes: ReadonlyArray<{ keys: MongoIndexKey[]; unique?: boolean }>,
+): MongoMigrationPlanOperation[] {
+  return [
+    createCollection(name, {
+      validator: { $jsonSchema: schema },
+      validationLevel: 'strict',
+      validationAction: 'error',
+    }),
+    ...indexes.map((idx) => createIndex(name, idx.keys, { unique: idx.unique })),
+  ];
+}