@prisma-next/target-mongo 0.5.0-dev.4 → 0.5.0-dev.40

package/src/core/schema-verify/canonicalize-introspection.ts

@@ -0,0 +1,389 @@
+/**
+ * Canonicalizes a live (introspected) `MongoSchemaIR` against the expected
+ * (contract-built) IR before diffing. MongoDB applies server-side defaults
+ * to several option/index families that are absent from authored contracts,
+ * which would otherwise cause `verifyMongoSchema` to report false-positive
+ * drift on a fresh `migration apply`.
+ *
+ * The normalization is contract-aware where it has to be: server defaults
+ * are stripped from the live IR for fields the contract did not specify, so
+ * a contract that *does* specify a value still gets compared faithfully.
+ *
+ * Symmetric defaults — like `changeStreamPreAndPostImages: { enabled: false }`,
+ * which is equivalent to "absent" on both sides — are stripped from both IRs
+ * so either authoring style verifies.
+ */
+
+import type {
+  MongoSchemaCollection,
+  MongoSchemaCollectionOptions,
+  MongoSchemaIndex,
+  MongoSchemaIR,
+} from '@prisma-next/mongo-schema-ir';
+import {
+  MongoSchemaCollection as MongoSchemaCollectionCtor,
+  MongoSchemaCollectionOptions as MongoSchemaCollectionOptionsCtor,
+  MongoSchemaIndex as MongoSchemaIndexCtor,
+  MongoSchemaIR as MongoSchemaIRCtor,
+} from '@prisma-next/mongo-schema-ir';
+import { ifDefined } from '@prisma-next/utils/defined';
+
+export interface CanonicalizedSchemas {
+  readonly live: MongoSchemaIR;
+  readonly expected: MongoSchemaIR;
+}
+
+export function canonicalizeSchemasForVerification(
+  live: MongoSchemaIR,
+  expected: MongoSchemaIR,
+): CanonicalizedSchemas {
+  const expectedByName = new Map<string, MongoSchemaCollection>();
+  for (const c of expected.collections) expectedByName.set(c.name, c);
+
+  const liveByName = new Map<string, MongoSchemaCollection>();
+  for (const c of live.collections) liveByName.set(c.name, c);
+
+  const canonicalLive = live.collections.map((c) =>
+    canonicalizeLiveCollection(c, expectedByName.get(c.name)),
+  );
+  const canonicalExpected = expected.collections.map((c) =>
+    canonicalizeExpectedCollection(c, liveByName.get(c.name)),
+  );
+
+  return {
+    live: new MongoSchemaIRCtor(canonicalLive),
+    expected: new MongoSchemaIRCtor(canonicalExpected),
+  };
+}
+
+function canonicalizeLiveCollection(
+  liveColl: MongoSchemaCollection,
+  expectedColl: MongoSchemaCollection | undefined,
+): MongoSchemaCollection {
+  const expectedIndexes = expectedColl?.indexes ?? [];
+  const indexes = liveColl.indexes.map((idx) =>
+    canonicalizeLiveIndex(idx, findExpectedIndexCounterpart(idx, expectedIndexes)),
+  );
+
+  const options = liveColl.options
+    ? canonicalizeLiveOptions(liveColl.options, expectedColl?.options)
+    : undefined;
+
+  return new MongoSchemaCollectionCtor({
+    name: liveColl.name,
+    indexes,
+    ...ifDefined('validator', liveColl.validator),
+    ...ifDefined('options', options),
+  });
+}
+
+function canonicalizeExpectedCollection(
+  expectedColl: MongoSchemaCollection,
+  liveColl: MongoSchemaCollection | undefined,
+): MongoSchemaCollection {
+  // Symmetric text-index key ordering: a contract-shaped text index preserves
+  // the user-authored field order, but the introspected counterpart comes
+  // back from MongoDB with `weights` keys in alphabetical order, so we
+  // canonicalize both sides to alphabetical text-key order. The order of
+  // text fields within the text block is semantically irrelevant — relevance
+  // is governed by `weights`, not key order.
+  const indexes = expectedColl.indexes.map(canonicalizeTextIndexKeyOrder);
+
+  const options = expectedColl.options
+    ? canonicalizeExpectedOptions(expectedColl.options, liveColl?.options)
+    : undefined;
+
+  return new MongoSchemaCollectionCtor({
+    name: expectedColl.name,
+    indexes,
+    ...ifDefined('validator', expectedColl.validator),
+    ...ifDefined('options', options),
+  });
+}
+
+function canonicalizeTextIndexKeyOrder(index: MongoSchemaIndex): MongoSchemaIndex {
+  const hasTextKey = index.keys.some((k) => k.direction === 'text');
+  if (!hasTextKey) return index;
+  return new MongoSchemaIndexCtor({
+    keys: sortTextKeys(index.keys),
+    unique: index.unique,
+    ...ifDefined('sparse', index.sparse),
+    ...ifDefined('expireAfterSeconds', index.expireAfterSeconds),
+    ...ifDefined('partialFilterExpression', index.partialFilterExpression),
+    ...ifDefined('wildcardProjection', index.wildcardProjection),
+    ...ifDefined('collation', index.collation),
+    ...ifDefined('weights', index.weights),
+    ...ifDefined('default_language', index.default_language),
+    ...ifDefined('language_override', index.language_override),
+  });
+}
+
+/**
+ * Returns a copy of `keys` with text-direction entries sorted alphabetically
+ * while preserving the relative position of non-text entries. Compound text
+ * indexes (`{a: 1, _fts: 'text', _ftsx: 1, b: 1}`) keep their scalar
+ * prefix/suffix layout; only the contiguous text block is reordered.
+ */
+function sortTextKeys(
+  keys: ReadonlyArray<{
+    readonly field: string;
+    readonly direction: 'text' | 1 | -1 | '2dsphere' | '2d' | 'hashed';
+  }>,
+): ReadonlyArray<{
+  readonly field: string;
+  readonly direction: 'text' | 1 | -1 | '2dsphere' | '2d' | 'hashed';
+}> {
+  const textEntries = keys.filter((k) => k.direction === 'text');
+  if (textEntries.length <= 1) return keys;
+  const sortedText = [...textEntries].sort((a, b) => a.field.localeCompare(b.field));
+  let textIdx = 0;
+  return keys.map((k) => {
+    if (k.direction !== 'text') return k;
+    const next = sortedText[textIdx++];
+    /* v8 ignore next 3 -- @preserve invariant guard: textIdx is always < sortedText.length here because we only consume sortedText for text-direction entries and sortedText is built from the same filter. */
+    if (next === undefined) {
+      throw new Error('sortTextKeys: text-key counts mismatched');
+    }
+    return next;
+  });
+}
+
+function canonicalizeLiveIndex(
+  liveIndex: MongoSchemaIndex,
+  expectedIndex: MongoSchemaIndex | undefined,
+): MongoSchemaIndex {
+  const projectedKeys = sortTextKeys(projectTextIndexKeys(liveIndex));
+  const collation = liveIndex.collation
+    ? stripUnspecifiedFields(liveIndex.collation, expectedIndex?.collation)
+    : liveIndex.collation;
+
+  // Text-index server defaults: when the contract did not set
+  // `weights`/`default_language`/`language_override`, MongoDB applies
+  // `weights = {<field>: 1, ...}` (uniform), `'english'`, and `'language'`
+  // respectively. Strip them from live *only* when the live value matches
+  // those defaults — preserving non-default live values lets the verifier
+  // surface drift when the live index is tampered (e.g. weights tuned
+  // out-of-band, custom `default_language`/`language_override`) even though
+  // the contract authored neither.
+  const weights =
+    expectedIndex?.weights === undefined && hasDefaultTextWeights(projectedKeys, liveIndex.weights)
+      ? undefined
+      : liveIndex.weights;
+  const default_language =
+    expectedIndex?.default_language === undefined && liveIndex.default_language === 'english'
+      ? undefined
+      : liveIndex.default_language;
+  const language_override =
+    expectedIndex?.language_override === undefined && liveIndex.language_override === 'language'
+      ? undefined
+      : liveIndex.language_override;
+
+  return new MongoSchemaIndexCtor({
+    keys: projectedKeys,
+    unique: liveIndex.unique,
+    ...ifDefined('sparse', liveIndex.sparse),
+    ...ifDefined('expireAfterSeconds', liveIndex.expireAfterSeconds),
+    ...ifDefined('partialFilterExpression', liveIndex.partialFilterExpression),
+    ...ifDefined('wildcardProjection', liveIndex.wildcardProjection),
+    ...ifDefined('collation', collation),
+    ...ifDefined('weights', weights),
+    ...ifDefined('default_language', default_language),
+    ...ifDefined('language_override', language_override),
+  });
+}
+
+/**
+ * Locate the contract-side index that corresponds to a live index for the
+ * purpose of contract-aware normalization. We deliberately match by the
+ * *projected* (contract-shaped) key list — so a live `_fts/_ftsx` index
+ * resolves to a contract `{title: 'text', body: 'text'}` index — and pick
+ * the first match. Contracts very rarely contain duplicate-key indexes; if
+ * we have no counterpart we fall back to no normalization for that index.
+ */
+function findExpectedIndexCounterpart(
+  liveIndex: MongoSchemaIndex,
+  expectedIndexes: ReadonlyArray<MongoSchemaIndex>,
+): MongoSchemaIndex | undefined {
+  const projectedLiveKeys = sortTextKeys(projectTextIndexKeys(liveIndex));
+  const liveKeySig = projectedLiveKeys.map((k) => `${k.field}:${k.direction}`).join(',');
+  for (const expected of expectedIndexes) {
+    const expectedKeySig = sortTextKeys(expected.keys)
+      .map((k) => `${k.field}:${k.direction}`)
+      .join(',');
+    if (expectedKeySig === liveKeySig) return expected;
+  }
+  return undefined;
+}
+
+/**
+ * MongoDB expands a contract-shaped text index like
+ * `[{title: 'text'}, {body: 'text'}]` into its internal weighted vector
+ * representation `[{_fts: 'text'}, {_ftsx: 1}]`. We project back to
+ * contract-shaped keys via `weights`, iterating in whatever order MongoDB
+ * returns them (alphabetical, in practice). `sortTextKeys` is applied
+ * downstream to canonicalize the order on both sides, so this projection
+ * does not depend on a specific iteration order.
+ */
+function projectTextIndexKeys(liveIndex: MongoSchemaIndex): ReadonlyArray<{
+  readonly field: string;
+  readonly direction: 'text' | 1 | -1 | '2dsphere' | '2d' | 'hashed';
+}> {
+  const isTextIndex =
+    liveIndex.keys.length >= 1 &&
+    liveIndex.keys.some((k) => k.field === '_fts' && k.direction === 'text');
+
+  if (!isTextIndex || !liveIndex.weights) return liveIndex.keys;
+
+  const textKeys = Object.keys(liveIndex.weights).map((field) => ({
+    field,
+    direction: 'text' as const,
+  }));
+
+  // Splice the projected text fields into the original `_fts/_ftsx` slot so
+  // compound text indexes that mix scalar prefixes *and* suffixes — e.g.
+  // `[prefix, _fts, _ftsx, suffix]` — keep their original layout. Flattening
+  // scalars first would yield `[prefix, suffix, ...text]`, which `sortTextKeys`
+  // (downstream) cannot recover because it only reorders text-direction
+  // entries within their existing positions. MongoDB always emits exactly one
+  // `_fts`/`_ftsx` pair per index, so we don't need to guard against
+  // duplicates.
+  type IndexKey = (typeof liveIndex.keys)[number];
+  const projectedKeys: IndexKey[] = [];
+  for (const key of liveIndex.keys) {
+    if (key.field === '_ftsx') continue;
+    if (key.field === '_fts') {
+      projectedKeys.push(...textKeys);
+      continue;
+    }
+    projectedKeys.push(key);
+  }
+  return projectedKeys;
+}
+
+/**
+ * MongoDB's server-default `weights` for an authored-without-weights text
+ * index assigns `1` to every text-direction field. Returns `true` only when
+ * `liveWeights` is exactly that uniform shape (every projected text-direction
+ * key weighted at `1`) so the canonicalizer leaves non-default weights —
+ * including out-of-band relevance tweaks — visible to the verifier.
+ *
+ * `projectTextIndexKeys` derives text-direction keys from the live weights
+ * map, so the count is guaranteed to match; we only have to check the value
+ * shape.
+ */
+function hasDefaultTextWeights(
+  projectedKeys: ReadonlyArray<{
+    readonly field: string;
+    readonly direction: 'text' | 1 | -1 | '2dsphere' | '2d' | 'hashed';
+  }>,
+  liveWeights: MongoSchemaIndex['weights'],
+): boolean {
+  if (liveWeights === undefined) return false;
+  const textFields = projectedKeys.filter((k) => k.direction === 'text').map((k) => k.field);
+  return textFields.every((field) => liveWeights[field] === 1);
+}
+
+function canonicalizeLiveOptions(
+  liveOptions: MongoSchemaCollectionOptions,
+  expectedOptions: MongoSchemaCollectionOptions | undefined,
+): MongoSchemaCollectionOptions | undefined {
+  const collation = liveOptions.collation
+    ? stripUnspecifiedFields(liveOptions.collation, expectedOptions?.collation)
+    : undefined;
+
+  // Timeseries: drop `bucketMaxSpanSeconds` (and any other server-applied
+  // extras) when the contract did not specify them.
+  const timeseries = liveOptions.timeseries
+    ? (stripUnspecifiedFields(
+        liveOptions.timeseries as Record<string, unknown>,
+        expectedOptions?.timeseries as Record<string, unknown> | undefined,
+      ) as MongoSchemaCollectionOptions['timeseries'])
+    : undefined;
+
+  // ClusteredIndex: drop `key`, `unique`, `v` and any other server-applied
+  // extras when the contract did not specify them.
+  const clusteredIndex = liveOptions.clusteredIndex
+    ? (stripUnspecifiedFields(
+        liveOptions.clusteredIndex as Record<string, unknown>,
+        expectedOptions?.clusteredIndex as Record<string, unknown> | undefined,
+      ) as MongoSchemaCollectionOptions['clusteredIndex'])
+    : undefined;
+
+  // changeStreamPreAndPostImages: `{enabled: false}` is equivalent to
+  // "absent". Strip it from live so it round-trips with a contract that
+  // omits the field, and is symmetric with the expected-side stripping.
+  const changeStreamPreAndPostImages = isDisabledChangeStream(
+    liveOptions.changeStreamPreAndPostImages,
+  )
+    ? undefined
+    : liveOptions.changeStreamPreAndPostImages;
+
+  const hasMeaningful =
+    liveOptions.capped || timeseries || collation || changeStreamPreAndPostImages || clusteredIndex;
+  if (!hasMeaningful) return undefined;
+
+  return new MongoSchemaCollectionOptionsCtor({
+    ...ifDefined('capped', liveOptions.capped),
+    ...ifDefined('timeseries', timeseries),
+    ...ifDefined('collation', collation),
+    ...ifDefined('changeStreamPreAndPostImages', changeStreamPreAndPostImages),
+    ...ifDefined('clusteredIndex', clusteredIndex),
+  });
+}
+
+function canonicalizeExpectedOptions(
+  expectedOptions: MongoSchemaCollectionOptions,
+  _liveOptions: MongoSchemaCollectionOptions | undefined,
+): MongoSchemaCollectionOptions | undefined {
+  // Symmetric: a contract `{enabled: false}` is equivalent to absent.
+  const changeStreamPreAndPostImages = isDisabledChangeStream(
+    expectedOptions.changeStreamPreAndPostImages,
+  )
+    ? undefined
+    : expectedOptions.changeStreamPreAndPostImages;
+
+  const hasMeaningful =
+    expectedOptions.capped ||
+    expectedOptions.timeseries ||
+    expectedOptions.collation ||
+    changeStreamPreAndPostImages ||
+    expectedOptions.clusteredIndex;
+  if (!hasMeaningful) return undefined;
+
+  return new MongoSchemaCollectionOptionsCtor({
+    ...ifDefined('capped', expectedOptions.capped),
+    ...ifDefined('timeseries', expectedOptions.timeseries),
+    ...ifDefined('collation', expectedOptions.collation),
+    ...ifDefined('changeStreamPreAndPostImages', changeStreamPreAndPostImages),
+    ...ifDefined('clusteredIndex', expectedOptions.clusteredIndex),
+  });
+}
+
+function isDisabledChangeStream(value: { enabled: boolean } | undefined): boolean {
+  return value !== undefined && value.enabled === false;
+}
+
+/**
+ * Returns a copy of `live` containing only the keys that `expected` defines.
+ * Used for option families whose individual sub-fields are server-extended
+ * with platform defaults (collation, timeseries, clusteredIndex), so the
+ * verifier should compare only what the contract actually authored.
+ *
+ * When `expected` is `undefined` — i.e. the contract authored nothing for
+ * this whole option family but the live IR has it — we return `live`
+ * unchanged so the verifier still sees the entire live block and can
+ * surface it as drift. (Returning `undefined` here would silently strip a
+ * server-attached collation/timeseries/clusteredIndex that the contract
+ * never asked for, hiding real drift.)
+ */
+function stripUnspecifiedFields(
+  live: Record<string, unknown>,
+  expected: Record<string, unknown> | undefined,
+): Record<string, unknown> {
+  if (expected === undefined) return live;
+  const out: Record<string, unknown> = {};
+  for (const key of Object.keys(expected)) {
+    if (Object.hasOwn(live, key)) out[key] = live[key];
+  }
+  return out;
+}

package/src/core/schema-verify/verify-mongo-schema.ts

@@ -0,0 +1,60 @@
+import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
+import type {
+  OperationContext,
+  VerifyDatabaseSchemaResult,
+} from '@prisma-next/framework-components/control';
+import { VERIFY_CODE_SCHEMA_FAILURE } from '@prisma-next/framework-components/control';
+import type { MongoContract } from '@prisma-next/mongo-contract';
+import type { MongoSchemaIR } from '@prisma-next/mongo-schema-ir';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { contractToMongoSchemaIR } from '../contract-to-schema';
+import { diffMongoSchemas } from '../schema-diff';
+import { canonicalizeSchemasForVerification } from './canonicalize-introspection';
+
+export interface VerifyMongoSchemaOptions {
+  readonly contract: MongoContract;
+  readonly schema: MongoSchemaIR;
+  readonly strict: boolean;
+  readonly context?: OperationContext;
+  /**
+   * Active framework components participating in this composition. Mongo
+   * verification does not currently consult them, but the parameter exists
+   * for parity with `verifySqlSchema` so callers can pass the same envelope.
+   */
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'mongo', string>>;
+}
+
+export function verifyMongoSchema(options: VerifyMongoSchemaOptions): VerifyDatabaseSchemaResult {
+  const { contract, schema, strict, context } = options;
+  const startTime = Date.now();
+
+  const expectedIR = contractToMongoSchemaIR(contract);
+  // Strip server-applied defaults (and authored equivalents) before diffing so
+  // the verifier compares like-with-like — see `canonicalize-introspection.ts`.
+  const { live: canonicalLive, expected: canonicalExpected } = canonicalizeSchemasForVerification(
+    schema,
+    expectedIR,
+  );
+  const { root, issues, counts } = diffMongoSchemas(canonicalLive, canonicalExpected, strict);
+
+  const ok = counts.fail === 0;
+  const profileHash = typeof contract.profileHash === 'string' ? contract.profileHash : '';
+
+  return {
+    ok,
+    ...ifDefined('code', ok ? undefined : VERIFY_CODE_SCHEMA_FAILURE),
+    summary: ok ? 'Schema matches contract' : `Schema verification found ${counts.fail} issue(s)`,
+    contract: {
+      storageHash: contract.storage.storageHash,
+      ...(profileHash ? { profileHash } : {}),
+    },
+    target: { expected: contract.target },
+    schema: { issues, root, counts },
+    meta: {
+      strict,
+      ...ifDefined('contractPath', context?.contractPath),
+      ...ifDefined('configPath', context?.configPath),
+    },
+    timings: { total: Date.now() - startTime },
+  };
+}

package/src/exports/runtime.ts

@@ -0,0 +1,38 @@
+import type {
+  RuntimeTargetDescriptor,
+  RuntimeTargetInstance,
+} from '@prisma-next/framework-components/execution';
+import { createMongoCodecRegistry, type MongoCodecRegistry } from '@prisma-next/mongo-codec';
+import { mongoTargetDescriptorMeta } from '../core/descriptor-meta';
+
+export interface MongoRuntimeTargetInstance extends RuntimeTargetInstance<'mongo', 'mongo'> {}
+
+/**
+ * Target-mongo deliberately does NOT import `MongoRuntimeTargetDescriptor`
+ * from `@prisma-next/mongo-runtime`. The target package is a control-plane
+ * residence and must not pull the Mongo execution-plane package into its
+ * dependency closure. The runtime descriptor here is shaped to satisfy the
+ * framework's `RuntimeTargetDescriptor` plus the structural
+ * `MongoStaticContributions` (`codecs`) that `@prisma-next/mongo-runtime`
+ * consumers narrow to at composition time.
+ */
+const mongoRuntimeTargetDescriptor: RuntimeTargetDescriptor<
+  'mongo',
+  'mongo',
+  MongoRuntimeTargetInstance
+> & {
+  readonly codecs: () => MongoCodecRegistry;
+} = {
+  ...mongoTargetDescriptorMeta,
+  // The target descriptor itself contributes no codecs — the standard set
+  // lives on the adapter descriptor (see `@prisma-next/adapter-mongo/runtime`).
+  codecs: () => createMongoCodecRegistry(),
+  create(): MongoRuntimeTargetInstance {
+    return {
+      familyId: 'mongo',
+      targetId: 'mongo',
+    };
+  },
+};
+
+export default mongoRuntimeTargetDescriptor;

package/src/exports/schema-verify.ts

@@ -0,0 +1,2 @@
+export type { VerifyMongoSchemaOptions } from '../core/schema-verify/verify-mongo-schema';
+export { verifyMongoSchema } from '../core/schema-verify/verify-mongo-schema';

package/dist/migration-factories-gwi81C8u.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"migration-factories-gwi81C8u.mjs","names":["MATCH_ALL_FILTER: MongoFilterExpr","precheck: readonly MongoDataTransformCheck[]","postcheck: readonly MongoDataTransformCheck[]","postcheckExpect: 'exists' | 'notExists'","run: MongoQueryPlan[]"],"sources":["../src/core/migration-factories.ts"],"sourcesContent":["import type {\n  MongoDataTransformCheck,\n  MongoDataTransformOperation,\n  MongoFilterExpr,\n  MongoIndexKey,\n} from '@prisma-next/mongo-query-ast/control';\nimport {\n  buildIndexOpId,\n  CollModCommand,\n  type CollModOptions,\n  CreateCollectionCommand,\n  type CreateCollectionOptions,\n  CreateIndexCommand,\n  type CreateIndexOptions,\n  DropCollectionCommand,\n  DropIndexCommand,\n  defaultMongoIndexName,\n  keysToKeySpec,\n  ListCollectionsCommand,\n  ListIndexesCommand,\n  MongoAndExpr,\n  MongoExistsExpr,\n  MongoFieldFilter,\n  type MongoMigrationPlanOperation,\n} from '@prisma-next/mongo-query-ast/control';\nimport type { MongoQueryPlan } from '@prisma-next/mongo-query-ast/execution';\nimport type { CollModMeta } from './op-factory-call';\n\ninterface Buildable {\n  build(): MongoQueryPlan;\n}\n\nfunction isBuildable(value: unknown): value is Buildable {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'build' in value &&\n    typeof (value as { build: unknown }).build === 'function'\n  );\n}\n\nfunction resolveQuery(value: MongoQueryPlan | Buildable): MongoQueryPlan {\n  return isBuildable(value) ? value.build() : value;\n}\n\n// Every MongoDB document carries `_id`, so `exists('_id')` is equivalent to\n// \"match all\". The filter AST has no identity/always-true expression.\nconst MATCH_ALL_FILTER: MongoFilterExpr = MongoExistsExpr.exists('_id');\n\nexport function dataTransform(\n  name: string,\n  options: {\n    check?: {\n      source: () => MongoQueryPlan | Buildable;\n      filter?: MongoFilterExpr;\n      expect?: 'exists' | 'notExists';\n      description?: string;\n    };\n    run: () => MongoQueryPlan | Buildable;\n  },\n): MongoDataTransformOperation {\n  let precheck: readonly MongoDataTransformCheck[] = [];\n  let postcheck: readonly MongoDataTransformCheck[] = [];\n\n  if (options.check) {\n    const source = resolveQuery(options.check.source());\n    const filter = options.check.filter ?? MATCH_ALL_FILTER;\n    const description = options.check.description ?? `Check for data transform: ${name}`;\n    const precheckExpect = options.check.expect ?? 'exists';\n    const postcheckExpect: 'exists' | 'notExists' =\n      precheckExpect === 'exists' ? 'notExists' : 'exists';\n\n    precheck = [{ description, source, filter, expect: precheckExpect }];\n    postcheck = [{ description, source, filter, expect: postcheckExpect }];\n  }\n\n  const run: MongoQueryPlan[] = [resolveQuery(options.run())];\n\n  return {\n    id: `data_transform.${name}`,\n    label: `Data transform: ${name}`,\n    operationClass: 'data',\n    name,\n    precheck,\n    run,\n    postcheck,\n  };\n}\n\nfunction formatKeys(keys: ReadonlyArray<MongoIndexKey>): string {\n  return keys.map((k) => `${k.field}:${k.direction}`).join(', ');\n}\n\nfunction isTextIndex(keys: ReadonlyArray<MongoIndexKey>): boolean {\n  return keys.some((k) => k.direction === 'text');\n}\n\nfunction keyFilter(keys: ReadonlyArray<MongoIndexKey>) {\n  return isTextIndex(keys)\n    ? MongoFieldFilter.eq('key._fts', 'text')\n    : MongoFieldFilter.eq('key', keysToKeySpec(keys));\n}\n\nexport function createIndex(\n  collection: string,\n  keys: ReadonlyArray<MongoIndexKey>,\n  options?: CreateIndexOptions,\n): MongoMigrationPlanOperation {\n  const name = defaultMongoIndexName(keys);\n  const filter = keyFilter(keys);\n  const fullFilter = options?.unique\n    ? MongoAndExpr.of([filter, MongoFieldFilter.eq('unique', true)])\n    : filter;\n\n  return {\n    id: buildIndexOpId('create', collection, keys),\n    label: `Create index on ${collection} (${formatKeys(keys)})`,\n    operationClass: 'additive',\n    precheck: [\n      {\n        description: `index does not already exist on ${collection}`,\n        source: new ListIndexesCommand(collection),\n        filter,\n        expect: 'notExists',\n      },\n    ],\n    execute: [\n      {\n        description: `create index on ${collection}`,\n        command: new CreateIndexCommand(collection, keys, {\n          ...options,\n          unique: options?.unique ?? undefined,\n          name,\n        }),\n      },\n    ],\n    postcheck: [\n      {\n        description: `index exists on ${collection}`,\n        source: new ListIndexesCommand(collection),\n        filter: fullFilter,\n        expect: 'exists',\n      },\n    ],\n  };\n}\n\nexport function dropIndex(\n  collection: string,\n  keys: ReadonlyArray<MongoIndexKey>,\n): MongoMigrationPlanOperation {\n  const indexName = defaultMongoIndexName(keys);\n  const filter = keyFilter(keys);\n\n  return {\n    id: buildIndexOpId('drop', collection, keys),\n    label: `Drop index on ${collection} (${formatKeys(keys)})`,\n    operationClass: 'destructive',\n    precheck: [\n      {\n        description: `index exists on ${collection}`,\n        source: new ListIndexesCommand(collection),\n        filter,\n        expect: 'exists',\n      },\n    ],\n    execute: [\n      {\n        description: `drop index on ${collection}`,\n        command: new DropIndexCommand(collection, indexName),\n      },\n    ],\n    postcheck: [\n      {\n        description: `index no longer exists on ${collection}`,\n        source: new ListIndexesCommand(collection),\n        filter,\n        expect: 'notExists',\n      },\n    ],\n  };\n}\n\nexport function createCollection(\n  collection: string,\n  options?: CreateCollectionOptions,\n): MongoMigrationPlanOperation {\n  return {\n    id: `collection.${collection}.create`,\n    label: `Create collection ${collection}`,\n    operationClass: 'additive',\n    precheck: [\n      {\n        description: `collection ${collection} does not exist`,\n        source: new ListCollectionsCommand(),\n        filter: MongoFieldFilter.eq('name', collection),\n        expect: 'notExists',\n      },\n    ],\n    execute: [\n      {\n        description: `create collection ${collection}`,\n        command: new CreateCollectionCommand(collection, options),\n      },\n    ],\n    postcheck: [],\n  };\n}\n\nexport function dropCollection(collection: string): MongoMigrationPlanOperation {\n  return {\n    id: `collection.${collection}.drop`,\n    label: `Drop collection ${collection}`,\n    operationClass: 'destructive',\n    precheck: [],\n    execute: [\n      {\n        description: `drop collection ${collection}`,\n        command: new DropCollectionCommand(collection),\n      },\n    ],\n    postcheck: [],\n  };\n}\n\nexport function setValidation(\n  collection: string,\n  schema: Record<string, unknown>,\n  options?: { validationLevel?: 'strict' | 'moderate'; validationAction?: 'error' | 'warn' },\n): MongoMigrationPlanOperation {\n  return {\n    id: `collection.${collection}.setValidation`,\n    label: `Set validation on ${collection}`,\n    operationClass: 'destructive',\n    precheck: [],\n    execute: [\n      {\n        description: `set validation on ${collection}`,\n        command: new CollModCommand(collection, {\n          validator: { $jsonSchema: schema },\n          validationLevel: options?.validationLevel,\n          validationAction: options?.validationAction,\n        }),\n      },\n    ],\n    postcheck: [],\n  };\n}\n\nexport function collMod(\n  collection: string,\n  options: CollModOptions,\n  meta?: CollModMeta,\n): MongoMigrationPlanOperation {\n  const hasValidator = options.validator != null && Object.keys(options.validator).length > 0;\n\n  return {\n    id: meta?.id ?? `collection.${collection}.collMod`,\n    label: meta?.label ?? `Modify collection ${collection}`,\n    operationClass: meta?.operationClass ?? 'destructive',\n    precheck:\n      options.validator != null\n        ? [\n            {\n              description: `collection ${collection} exists`,\n              source: new ListCollectionsCommand(),\n              filter: MongoFieldFilter.eq('name', collection),\n              expect: 'exists' as const,\n            },\n          ]\n        : [],\n    execute: [\n      {\n        description: `modify ${collection}`,\n        command: new CollModCommand(collection, options),\n      },\n    ],\n    postcheck: hasValidator\n      ? [\n          {\n            description: `validator applied on ${collection}`,\n            source: new ListCollectionsCommand(),\n            filter: MongoAndExpr.of([\n              MongoFieldFilter.eq('name', collection),\n              ...(options.validationLevel\n                ? [MongoFieldFilter.eq('options.validationLevel', options.validationLevel)]\n                : []),\n              ...(options.validationAction\n                ? [MongoFieldFilter.eq('options.validationAction', options.validationAction)]\n                : []),\n            ]),\n            expect: 'exists' as const,\n          },\n        ]\n      : [],\n  };\n}\n\nexport function validatedCollection(\n  name: string,\n  schema: Record<string, unknown>,\n  indexes: ReadonlyArray<{ keys: MongoIndexKey[]; unique?: boolean }>,\n): MongoMigrationPlanOperation[] {\n  return [\n    createCollection(name, {\n      validator: { $jsonSchema: schema },\n      validationLevel: 'strict',\n      validationAction: 'error',\n    }),\n    ...indexes.map((idx) => createIndex(name, idx.keys, { unique: idx.unique })),\n  ];\n}\n"],"mappings":"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"}