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

package/src/core/command-executor.ts

@@ -0,0 +1,89 @@
+import type {
+  CollModCommand,
+  CreateCollectionCommand,
+  CreateIndexCommand,
+  DropCollectionCommand,
+  DropIndexCommand,
+  ListCollectionsCommand,
+  ListIndexesCommand,
+  MongoDdlCommandVisitor,
+  MongoInspectionCommandVisitor,
+} from '@prisma-next/mongo-query-ast/control';
+import { keysToKeySpec } from '@prisma-next/mongo-query-ast/control';
+import { type Db, type Document, MongoServerError } from 'mongodb';
+
+export class MongoCommandExecutor implements MongoDdlCommandVisitor<Promise<void>> {
+  constructor(private readonly db: Db) {}
+
+  async createIndex(cmd: CreateIndexCommand): Promise<void> {
+    const keySpec: Document = keysToKeySpec(cmd.keys);
+    const options: Record<string, unknown> = {};
+    if (cmd.unique !== undefined) options['unique'] = cmd.unique;
+    if (cmd.sparse !== undefined) options['sparse'] = cmd.sparse;
+    if (cmd.expireAfterSeconds !== undefined)
+      options['expireAfterSeconds'] = cmd.expireAfterSeconds;
+    if (cmd.partialFilterExpression !== undefined)
+      options['partialFilterExpression'] = cmd.partialFilterExpression;
+    if (cmd.name !== undefined) options['name'] = cmd.name;
+    if (cmd.wildcardProjection !== undefined)
+      options['wildcardProjection'] = cmd.wildcardProjection;
+    if (cmd.collation !== undefined) options['collation'] = cmd.collation;
+    if (cmd.weights !== undefined) options['weights'] = cmd.weights;
+    if (cmd.default_language !== undefined) options['default_language'] = cmd.default_language;
+    if (cmd.language_override !== undefined) options['language_override'] = cmd.language_override;
+    await this.db.collection(cmd.collection).createIndex(keySpec, options);
+  }
+
+  async dropIndex(cmd: DropIndexCommand): Promise<void> {
+    await this.db.collection(cmd.collection).dropIndex(cmd.name);
+  }
+
+  async createCollection(cmd: CreateCollectionCommand): Promise<void> {
+    const options: Record<string, unknown> = {};
+    if (cmd.capped !== undefined) options['capped'] = cmd.capped;
+    if (cmd.size !== undefined) options['size'] = cmd.size;
+    if (cmd.max !== undefined) options['max'] = cmd.max;
+    if (cmd.timeseries !== undefined) options['timeseries'] = cmd.timeseries;
+    if (cmd.collation !== undefined) options['collation'] = cmd.collation;
+    if (cmd.clusteredIndex !== undefined) options['clusteredIndex'] = cmd.clusteredIndex;
+    if (cmd.validator !== undefined) options['validator'] = cmd.validator;
+    if (cmd.validationLevel !== undefined) options['validationLevel'] = cmd.validationLevel;
+    if (cmd.validationAction !== undefined) options['validationAction'] = cmd.validationAction;
+    if (cmd.changeStreamPreAndPostImages !== undefined)
+      options['changeStreamPreAndPostImages'] = cmd.changeStreamPreAndPostImages;
+    await this.db.createCollection(cmd.collection, options);
+  }
+
+  async dropCollection(cmd: DropCollectionCommand): Promise<void> {
+    await this.db.collection(cmd.collection).drop();
+  }
+
+  async collMod(cmd: CollModCommand): Promise<void> {
+    const command: Record<string, unknown> = { collMod: cmd.collection };
+    if (cmd.validator !== undefined) command['validator'] = cmd.validator;
+    if (cmd.validationLevel !== undefined) command['validationLevel'] = cmd.validationLevel;
+    if (cmd.validationAction !== undefined) command['validationAction'] = cmd.validationAction;
+    if (cmd.changeStreamPreAndPostImages !== undefined)
+      command['changeStreamPreAndPostImages'] = cmd.changeStreamPreAndPostImages;
+    await this.db.command(command);
+  }
+}
+
+export class MongoInspectionExecutor implements MongoInspectionCommandVisitor<Promise<Document[]>> {
+  constructor(private readonly db: Db) {}
+
+  async listIndexes(cmd: ListIndexesCommand): Promise<Document[]> {
+    try {
+      return await this.db.collection(cmd.collection).listIndexes().toArray();
+    } catch (error: unknown) {
+      if (error instanceof MongoServerError && error.code === 26) {
+        return [];
+      }
+      throw error;
+    }
+  }
+
+  async listCollections(_cmd: ListCollectionsCommand): Promise<Document[]> {
+    return this.db.listCollections().toArray();
+  }
+}

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/introspect-schema.ts

@@ -0,0 +1,118 @@
+import type { MongoIndexKey, MongoIndexKeyDirection } from '@prisma-next/mongo-contract';
+import {
+  MongoSchemaCollection,
+  MongoSchemaCollectionOptions,
+  MongoSchemaIndex,
+  MongoSchemaIR,
+  MongoSchemaValidator,
+} from '@prisma-next/mongo-schema-ir';
+import type { Db, Document } from 'mongodb';
+
+const PRISMA_MIGRATIONS_COLLECTION = '_prisma_migrations';
+
+function parseIndexKeys(keySpec: Record<string, unknown>): MongoIndexKey[] {
+  const keys: MongoIndexKey[] = [];
+  for (const [field, direction] of Object.entries(keySpec)) {
+    keys.push({ field, direction: direction as MongoIndexKeyDirection });
+  }
+  return keys;
+}
+
+function isDefaultIdIndex(doc: Document): boolean {
+  const key = doc['key'] as Record<string, unknown> | undefined;
+  if (!key) return false;
+  const entries = Object.entries(key);
+  return entries.length === 1 && entries[0]?.[0] === '_id' && entries[0]?.[1] === 1;
+}
+
+function parseIndex(doc: Document): MongoSchemaIndex {
+  const keySpec = doc['key'] as Record<string, unknown>;
+  return new MongoSchemaIndex({
+    keys: parseIndexKeys(keySpec),
+    unique: doc['unique'] as boolean | undefined,
+    sparse: doc['sparse'] as boolean | undefined,
+    expireAfterSeconds: doc['expireAfterSeconds'] as number | undefined,
+    partialFilterExpression: doc['partialFilterExpression'] as Record<string, unknown> | undefined,
+    wildcardProjection: doc['wildcardProjection'] as Record<string, 0 | 1> | undefined,
+    collation: doc['collation'] as Record<string, unknown> | undefined,
+    weights: doc['weights'] as Record<string, number> | undefined,
+    default_language: doc['default_language'] as string | undefined,
+    language_override: doc['language_override'] as string | undefined,
+  });
+}
+
+function parseValidator(options: Document): MongoSchemaValidator | undefined {
+  const validator = options['validator'] as Record<string, unknown> | undefined;
+  if (!validator) return undefined;
+
+  const jsonSchema = validator['$jsonSchema'] as Record<string, unknown> | undefined;
+  if (!jsonSchema) return undefined;
+
+  return new MongoSchemaValidator({
+    jsonSchema,
+    validationLevel: (options['validationLevel'] as 'strict' | 'moderate') ?? 'strict',
+    validationAction: (options['validationAction'] as 'error' | 'warn') ?? 'error',
+  });
+}
+
+function parseCollectionOptions(info: Document): MongoSchemaCollectionOptions | undefined {
+  const options = info['options'] as Record<string, unknown> | undefined;
+  if (!options) return undefined;
+
+  const capped = options['capped'] as boolean | undefined;
+  const size = options['size'] as number | undefined;
+  const max = options['max'] as number | undefined;
+  const timeseries = options['timeseries'] as
+    | { timeField: string; metaField?: string; granularity?: 'seconds' | 'minutes' | 'hours' }
+    | undefined;
+  const collation = options['collation'] as Record<string, unknown> | undefined;
+  const changeStreamPreAndPostImages = options['changeStreamPreAndPostImages'] as
+    | { enabled: boolean }
+    | undefined;
+  const clusteredIndex = options['clusteredIndex'] as { name?: string } | undefined;
+
+  const hasMeaningfulOptions =
+    capped || timeseries || collation || changeStreamPreAndPostImages || clusteredIndex;
+  if (!hasMeaningfulOptions) return undefined;
+
+  return new MongoSchemaCollectionOptions({
+    ...(capped ? { capped: { size: size ?? 0, ...(max != null ? { max } : {}) } } : {}),
+    ...(timeseries ? { timeseries } : {}),
+    ...(collation ? { collation } : {}),
+    ...(changeStreamPreAndPostImages ? { changeStreamPreAndPostImages } : {}),
+    ...(clusteredIndex ? { clusteredIndex } : {}),
+  });
+}
+
+export async function introspectSchema(db: Db): Promise<MongoSchemaIR> {
+  const collectionInfos = await db.listCollections().toArray();
+
+  const collections: MongoSchemaCollection[] = [];
+
+  for (const info of collectionInfos) {
+    const name = info['name'] as string;
+    const type = info['type'] as string | undefined;
+
+    if (name === PRISMA_MIGRATIONS_COLLECTION) continue;
+    if (name.startsWith('system.')) continue;
+    if (type === 'view') continue;
+
+    const indexDocs = await db.collection(name).listIndexes().toArray();
+    const indexes = indexDocs.filter((doc) => !isDefaultIdIndex(doc)).map(parseIndex);
+
+    const infoOptions = 'options' in info ? (info['options'] as Record<string, unknown>) : {};
+    const validator = parseValidator(infoOptions);
+    const options = parseCollectionOptions(info);
+
+    collections.push(
+      new MongoSchemaCollection({
+        name,
+        indexes,
+        ...(validator ? { validator } : {}),
+        ...(options ? { options } : {}),
+      }),
+    );
+  }
+
+  return new MongoSchemaIR(collections);
+}

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

@@ -0,0 +1,30 @@
+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);
+}