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

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);
+}

package/src/core/mongo-planner.ts

@@ -0,0 +1,306 @@
+import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
+import type {
+  MigrationOperationClass,
+  MigrationOperationPolicy,
+  MigrationPlanner,
+  MigrationPlannerConflict,
+  MigrationPlannerResult,
+} from '@prisma-next/framework-components/control';
+import type { MongoContract } from '@prisma-next/mongo-contract';
+import type {
+  MongoSchemaCollection,
+  MongoSchemaCollectionOptions,
+  MongoSchemaIndex,
+  MongoSchemaIR,
+  MongoSchemaValidator,
+} from '@prisma-next/mongo-schema-ir';
+import { canonicalize, deepEqual } from '@prisma-next/mongo-schema-ir';
+import { contractToMongoSchemaIR } from './contract-to-schema';
+import type { OpFactoryCall } from './op-factory-call';
+import {
+  CollModCall,
+  CreateCollectionCall,
+  CreateIndexCall,
+  DropCollectionCall,
+  DropIndexCall,
+  schemaCollectionToCreateCollectionOptions,
+  schemaIndexToCreateIndexOptions,
+} from './op-factory-call';
+import { renderOps } from './render-ops';
+
+function buildIndexLookupKey(index: MongoSchemaIndex): string {
+  const keys = index.keys.map((k) => `${k.field}:${k.direction}`).join(',');
+  const opts = [
+    index.unique ? 'unique' : '',
+    index.sparse ? 'sparse' : '',
+    index.expireAfterSeconds != null ? `ttl:${index.expireAfterSeconds}` : '',
+    index.partialFilterExpression ? `pfe:${canonicalize(index.partialFilterExpression)}` : '',
+    index.wildcardProjection ? `wp:${canonicalize(index.wildcardProjection)}` : '',
+    index.collation ? `col:${canonicalize(index.collation)}` : '',
+    index.weights ? `wt:${canonicalize(index.weights)}` : '',
+    index.default_language ? `dl:${index.default_language}` : '',
+    index.language_override ? `lo:${index.language_override}` : '',
+  ]
+    .filter(Boolean)
+    .join(';');
+  return opts ? `${keys}|${opts}` : keys;
+}
+
+function validatorsEqual(
+  a: MongoSchemaValidator | undefined,
+  b: MongoSchemaValidator | undefined,
+): boolean {
+  if (!a && !b) return true;
+  if (!a || !b) return false;
+  return (
+    a.validationLevel === b.validationLevel &&
+    a.validationAction === b.validationAction &&
+    canonicalize(a.jsonSchema) === canonicalize(b.jsonSchema)
+  );
+}
+
+function classifyValidatorUpdate(
+  origin: MongoSchemaValidator,
+  dest: MongoSchemaValidator,
+): 'widening' | 'destructive' {
+  let hasDestructive = false;
+
+  if (canonicalize(origin.jsonSchema) !== canonicalize(dest.jsonSchema)) {
+    hasDestructive = true;
+  }
+
+  if (origin.validationAction !== dest.validationAction) {
+    if (dest.validationAction === 'error') hasDestructive = true;
+  }
+
+  if (origin.validationLevel !== dest.validationLevel) {
+    if (dest.validationLevel === 'strict') hasDestructive = true;
+  }
+
+  return hasDestructive ? 'destructive' : 'widening';
+}
+
+function hasImmutableOptionChange(
+  origin: MongoSchemaCollectionOptions | undefined,
+  dest: MongoSchemaCollectionOptions | undefined,
+): string | undefined {
+  if (canonicalize(origin?.capped) !== canonicalize(dest?.capped)) return 'capped';
+  if (canonicalize(origin?.timeseries) !== canonicalize(dest?.timeseries)) return 'timeseries';
+  if (canonicalize(origin?.collation) !== canonicalize(dest?.collation)) return 'collation';
+  if (canonicalize(origin?.clusteredIndex) !== canonicalize(dest?.clusteredIndex))
+    return 'clusteredIndex';
+  return undefined;
+}
+
+function collectionHasOptions(coll: MongoSchemaCollection): boolean {
+  return !!(coll.options || coll.validator);
+}
+
+export type PlanCallsResult =
+  | { readonly kind: 'success'; readonly calls: OpFactoryCall[] }
+  | { readonly kind: 'failure'; readonly conflicts: MigrationPlannerConflict[] };
+
+export class MongoMigrationPlanner implements MigrationPlanner<'mongo', 'mongo'> {
+  planCalls(options: {
+    readonly contract: unknown;
+    readonly schema: unknown;
+    readonly policy: MigrationOperationPolicy;
+    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'mongo', 'mongo'>>;
+  }): PlanCallsResult {
+    const contract = options.contract as MongoContract;
+    const originIR = options.schema as MongoSchemaIR;
+    const destinationIR = contractToMongoSchemaIR(contract);
+
+    const collCreates: OpFactoryCall[] = [];
+    const drops: OpFactoryCall[] = [];
+    const creates: OpFactoryCall[] = [];
+    const validatorOps: OpFactoryCall[] = [];
+    const mutableOptionOps: OpFactoryCall[] = [];
+    const collDrops: OpFactoryCall[] = [];
+    const conflicts: MigrationPlannerConflict[] = [];
+
+    const allCollectionNames = new Set([
+      ...originIR.collectionNames,
+      ...destinationIR.collectionNames,
+    ]);
+
+    for (const collName of [...allCollectionNames].sort()) {
+      const originColl = originIR.collection(collName);
+      const destColl = destinationIR.collection(collName);
+
+      if (!originColl) {
+        if (destColl && collectionHasOptions(destColl)) {
+          const opts = schemaCollectionToCreateCollectionOptions(destColl);
+          collCreates.push(new CreateCollectionCall(collName, opts));
+        }
+      } else if (!destColl) {
+        collDrops.push(new DropCollectionCall(collName));
+      } else {
+        const immutableChange = hasImmutableOptionChange(originColl.options, destColl.options);
+        if (immutableChange) {
+          conflicts.push({
+            kind: 'policy-violation',
+            summary: `Cannot change immutable collection option '${immutableChange}' on ${collName}`,
+            why: `MongoDB does not support modifying the '${immutableChange}' option after collection creation`,
+          });
+        }
+
+        const mutableCall = planMutableOptionsDiffCall(
+          collName,
+          originColl.options,
+          destColl.options,
+        );
+        if (mutableCall) mutableOptionOps.push(mutableCall);
+
+        const validatorCall = planValidatorDiffCall(
+          collName,
+          originColl.validator,
+          destColl.validator,
+        );
+        if (validatorCall) validatorOps.push(validatorCall);
+      }
+
+      const originLookup = new Map<string, MongoSchemaIndex>();
+      if (originColl) {
+        for (const idx of originColl.indexes) {
+          originLookup.set(buildIndexLookupKey(idx), idx);
+        }
+      }
+
+      const destLookup = new Map<string, MongoSchemaIndex>();
+      if (destColl) {
+        for (const idx of destColl.indexes) {
+          destLookup.set(buildIndexLookupKey(idx), idx);
+        }
+      }
+
+      for (const [lookupKey, idx] of originLookup) {
+        if (!destLookup.has(lookupKey)) {
+          drops.push(new DropIndexCall(collName, idx.keys));
+        }
+      }
+
+      for (const [lookupKey, idx] of destLookup) {
+        if (!originLookup.has(lookupKey)) {
+          creates.push(
+            new CreateIndexCall(collName, idx.keys, schemaIndexToCreateIndexOptions(idx)),
+          );
+        }
+      }
+    }
+
+    if (conflicts.length > 0) {
+      return { kind: 'failure', conflicts };
+    }
+
+    const allCalls = [
+      ...collCreates,
+      ...drops,
+      ...creates,
+      ...validatorOps,
+      ...mutableOptionOps,
+      ...collDrops,
+    ];
+
+    for (const call of allCalls) {
+      if (!options.policy.allowedOperationClasses.includes(call.operationClass)) {
+        conflicts.push({
+          kind: 'policy-violation',
+          summary: `${call.operationClass} operation disallowed: ${call.label}`,
+          why: `Policy does not allow '${call.operationClass}' operations`,
+        });
+      }
+    }
+
+    if (conflicts.length > 0) {
+      return { kind: 'failure', conflicts };
+    }
+
+    return { kind: 'success', calls: allCalls };
+  }
+
+  plan(options: {
+    readonly contract: unknown;
+    readonly schema: unknown;
+    readonly policy: MigrationOperationPolicy;
+    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'mongo', 'mongo'>>;
+  }): MigrationPlannerResult {
+    const contract = options.contract as MongoContract;
+    const result = this.planCalls(options);
+    if (result.kind === 'failure') return result;
+    return {
+      kind: 'success',
+      plan: {
+        targetId: 'mongo',
+        destination: {
+          storageHash: contract.storage.storageHash,
+        },
+        operations: renderOps(result.calls),
+      },
+    };
+  }
+}
+
+function planValidatorDiffCall(
+  collName: string,
+  originValidator: MongoSchemaValidator | undefined,
+  destValidator: MongoSchemaValidator | undefined,
+): OpFactoryCall | undefined {
+  if (validatorsEqual(originValidator, destValidator)) return undefined;
+
+  if (destValidator) {
+    const operationClass: MigrationOperationClass = originValidator
+      ? classifyValidatorUpdate(originValidator, destValidator)
+      : 'destructive';
+    return new CollModCall(
+      collName,
+      {
+        validator: { $jsonSchema: destValidator.jsonSchema },
+        validationLevel: destValidator.validationLevel,
+        validationAction: destValidator.validationAction,
+      },
+      {
+        id: `validator.${collName}.${originValidator ? 'update' : 'add'}`,
+        label: `${originValidator ? 'Update' : 'Add'} validator on ${collName}`,
+        operationClass,
+      },
+    );
+  }
+
+  return new CollModCall(
+    collName,
+    {
+      validator: {},
+      validationLevel: 'strict',
+      validationAction: 'error',
+    },
+    {
+      id: `validator.${collName}.remove`,
+      label: `Remove validator on ${collName}`,
+      operationClass: 'widening',
+    },
+  );
+}
+
+function planMutableOptionsDiffCall(
+  collName: string,
+  origin: MongoSchemaCollectionOptions | undefined,
+  dest: MongoSchemaCollectionOptions | undefined,
+): OpFactoryCall | undefined {
+  const originCSPPI = origin?.changeStreamPreAndPostImages;
+  const destCSPPI = dest?.changeStreamPreAndPostImages;
+  if (deepEqual(originCSPPI, destCSPPI)) return undefined;
+
+  const desiredCSPPI = destCSPPI ?? { enabled: false };
+  return new CollModCall(
+    collName,
+    {
+      changeStreamPreAndPostImages: desiredCSPPI,
+    },
+    {
+      id: `options.${collName}.update`,
+      label: `Update mutable options on ${collName}`,
+      operationClass: desiredCSPPI.enabled ? 'widening' : 'destructive',
+    },
+  );
+}