@prisma-next/target-mongo 0.4.0-dev.9 → 0.4.2

package/src/core/render-typescript.ts

@@ -1,13 +1,6 @@
 import { detectScaffoldRuntime, shebangLineFor } from '@prisma-next/migration-tools/migration-ts';
-import type {
-  CollModCall,
-  CreateCollectionCall,
-  CreateIndexCall,
-  DropCollectionCall,
-  DropIndexCall,
-  OpFactoryCall,
-  OpFactoryCallVisitor,
-} from './op-factory-call';
+import { type ImportRequirement, jsonToTsSource, renderImports } from '@prisma-next/ts-render';
+import type { OpFactoryCall } from './op-factory-call';
 
 export interface RenderMigrationMeta {
   readonly from: string;
@@ -17,21 +10,49 @@ export interface RenderMigrationMeta {
 }
 
 /**
- * Render a list of Mongo `OpFactoryCall`s as a class-flow `migration.ts`
+ * Always-present base imports for the rendered scaffold:
+ *
+ * - `Migration` from `@prisma-next/family-mongo/migration` — the
+ *   user-facing Mongo `Migration` base; subclasses don't need to
+ *   redeclare `targetId` or thread family/target generics.
+ * - `MigrationCLI` from `@prisma-next/cli/migration-cli` — the
+ *   migration-file CLI entrypoint that loads `prisma-next.config.ts`,
+ *   assembles a `ControlStack`, and instantiates the migration class.
+ *   The migration file owns this dependency directly: pulling CLI
+ *   machinery in at script run time is acceptable because the script's
+ *   whole purpose is to be invoked from the project that owns the
+ *   config. (Mirrors the postgres facade pattern; pulling `MigrationCLI`
+ *   into `@prisma-next/family-mongo/migration` so a Mongo migration only
+ *   needs one import is tracked separately as a follow-up.)
+ */
+const BASE_IMPORTS: readonly ImportRequirement[] = [
+  { moduleSpecifier: '@prisma-next/family-mongo/migration', symbol: 'Migration' },
+  { moduleSpecifier: '@prisma-next/cli/migration-cli', symbol: 'MigrationCLI' },
+];
+
+/**
+ * Render a list of Mongo `OpFactoryCall`s as a `migration.ts`
  * source string. The result is shebanged, extends the user-facing
  * `Migration` (i.e. `MongoMigration`) from `@prisma-next/family-mongo`, and
  * implements the abstract `operations` and `describe` members. `meta` is
  * always rendered — `describe()` is part of the `Migration` contract, so
  * even an empty stub must satisfy it; callers pass empty strings for a
  * migration-new scaffold.
+ *
+ * The walk is polymorphic: each call node contributes its own
+ * `renderTypeScript()` expression and declares its own
+ * `importRequirements()`. The top-level renderer aggregates imports
+ * across all nodes and emits one `import { … } from "…"` line per module.
+ * The `Migration` and `MigrationCLI` imports are always emitted — they're
+ * structural to the rendered scaffold (extends `Migration`, calls
+ * `MigrationCLI.run`), not driven by any node.
  */
 export function renderCallsToTypeScript(
   calls: ReadonlyArray<OpFactoryCall>,
   meta: RenderMigrationMeta,
 ): string {
-  const factoryNames = collectFactoryNames(calls);
-  const imports = buildImports(factoryNames);
-  const operationsBody = calls.map((c) => c.accept(renderCallVisitor)).join(',\n');
+  const imports = buildImports(calls);
+  const operationsBody = calls.map((c) => c.renderTypeScript()).join(',\n');
 
   return [
     shebangLineFor(detectScaffoldRuntime()),
@@ -47,25 +68,19 @@ export function renderCallsToTypeScript(
     '}',
     '',
     'export default M;',
-    'Migration.run(import.meta.url, M);',
+    'MigrationCLI.run(import.meta.url, M);',
     '',
   ].join('\n');
 }
 
-function collectFactoryNames(calls: ReadonlyArray<OpFactoryCall>): string[] {
-  const names = new Set<string>();
+function buildImports(calls: ReadonlyArray<OpFactoryCall>): string {
+  const requirements: ImportRequirement[] = [...BASE_IMPORTS];
   for (const call of calls) {
-    names.add(call.factory);
+    for (const req of call.importRequirements()) {
+      requirements.push(req);
+    }
   }
-  return [...names].sort();
-}
-
-function buildImports(factoryNames: string[]): string {
-  const lines = ["import { Migration } from '@prisma-next/family-mongo/migration';"];
-  if (factoryNames.length > 0) {
-    lines.push(`import { ${factoryNames.join(', ')} } from '@prisma-next/target-mongo/migration';`);
-  }
-  return lines.join('\n');
+  return renderImports(requirements);
 }
 
 function buildDescribeMethod(meta: RenderMigrationMeta): string {
@@ -78,7 +93,7 @@ function buildDescribeMethod(meta: RenderMigrationMeta): string {
     lines.push(`      kind: ${JSON.stringify(meta.kind)},`);
   }
   if (meta.labels && meta.labels.length > 0) {
-    lines.push(`      labels: ${renderLiteral(meta.labels)},`);
+    lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);
   }
   lines.push('    };');
   lines.push('  }');
@@ -86,58 +101,6 @@ function buildDescribeMethod(meta: RenderMigrationMeta): string {
   return lines.join('\n');
 }
 
-const renderCallVisitor: OpFactoryCallVisitor<string> = {
-  createIndex(call: CreateIndexCall) {
-    return call.options
-      ? `createIndex(${renderLiteral(call.collection)}, ${renderLiteral(call.keys)}, ${renderLiteral(call.options)})`
-      : `createIndex(${renderLiteral(call.collection)}, ${renderLiteral(call.keys)})`;
-  },
-  dropIndex(call: DropIndexCall) {
-    return `dropIndex(${renderLiteral(call.collection)}, ${renderLiteral(call.keys)})`;
-  },
-  createCollection(call: CreateCollectionCall) {
-    return call.options
-      ? `createCollection(${renderLiteral(call.collection)}, ${renderLiteral(call.options)})`
-      : `createCollection(${renderLiteral(call.collection)})`;
-  },
-  dropCollection(call: DropCollectionCall) {
-    return `dropCollection(${renderLiteral(call.collection)})`;
-  },
-  collMod(call: CollModCall) {
-    return call.meta
-      ? `collMod(${renderLiteral(call.collection)}, ${renderLiteral(call.options)}, ${renderLiteral(call.meta)})`
-      : `collMod(${renderLiteral(call.collection)}, ${renderLiteral(call.options)})`;
-  },
-};
-
-function renderLiteral(value: unknown): string {
-  if (value === undefined) return 'undefined';
-  if (value === null) return 'null';
-  if (typeof value === 'string') return JSON.stringify(value);
-  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
-  if (Array.isArray(value)) {
-    if (value.length === 0) return '[]';
-    const items = value.map((v) => renderLiteral(v));
-    const singleLine = `[${items.join(', ')}]`;
-    if (singleLine.length <= 80) return singleLine;
-    return `[\n${items.map((i) => `  ${i}`).join(',\n')},\n]`;
-  }
-  if (typeof value === 'object') {
-    const entries = Object.entries(value).filter(([, v]) => v !== undefined);
-    if (entries.length === 0) return '{}';
-    const items = entries.map(([k, v]) => `${renderKey(k)}: ${renderLiteral(v)}`);
-    const singleLine = `{ ${items.join(', ')} }`;
-    if (singleLine.length <= 80) return singleLine;
-    return `{\n${items.map((i) => `  ${i}`).join(',\n')},\n}`;
-  }
-  return String(value);
-}
-
-function renderKey(key: string): string {
-  if (key === '__proto__') return JSON.stringify(key);
-  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
-}
-
 function indent(text: string, spaces: number): string {
   const pad = ' '.repeat(spaces);
   return text

package/src/core/schema-diff.ts

@@ -0,0 +1,402 @@
+import type {
+  SchemaIssue,
+  SchemaVerificationNode,
+} from '@prisma-next/framework-components/control';
+import type {
+  MongoSchemaCollection,
+  MongoSchemaIndex,
+  MongoSchemaIR,
+} from '@prisma-next/mongo-schema-ir';
+import { canonicalize, deepEqual } from '@prisma-next/mongo-schema-ir';
+
+export function diffMongoSchemas(
+  live: MongoSchemaIR,
+  expected: MongoSchemaIR,
+  strict: boolean,
+): {
+  root: SchemaVerificationNode;
+  issues: SchemaIssue[];
+  counts: { pass: number; warn: number; fail: number; totalNodes: number };
+} {
+  const issues: SchemaIssue[] = [];
+  const collectionChildren: SchemaVerificationNode[] = [];
+  let pass = 0;
+  let warn = 0;
+  let fail = 0;
+
+  const allNames = new Set([...live.collectionNames, ...expected.collectionNames]);
+
+  for (const name of [...allNames].sort()) {
+    const liveColl = live.collection(name);
+    const expectedColl = expected.collection(name);
+
+    if (!liveColl && expectedColl) {
+      issues.push({
+        kind: 'missing_table',
+        table: name,
+        message: `Collection "${name}" is missing from the database`,
+      });
+      collectionChildren.push({
+        status: 'fail',
+        kind: 'collection',
+        name,
+        contractPath: `storage.collections.${name}`,
+        code: 'MISSING_COLLECTION',
+        message: `Collection "${name}" is missing`,
+        expected: name,
+        actual: null,
+        children: [],
+      });
+      fail++;
+      continue;
+    }
+
+    if (liveColl && !expectedColl) {
+      const status = strict ? 'fail' : 'warn';
+      issues.push({
+        kind: 'extra_table',
+        table: name,
+        message: `Extra collection "${name}" exists in the database but not in the contract`,
+      });
+      collectionChildren.push({
+        status,
+        kind: 'collection',
+        name,
+        contractPath: `storage.collections.${name}`,
+        code: 'EXTRA_COLLECTION',
+        message: `Extra collection "${name}" found`,
+        expected: null,
+        actual: name,
+        children: [],
+      });
+      if (status === 'fail') fail++;
+      else warn++;
+      continue;
+    }
+
+    const lc = liveColl as MongoSchemaCollection;
+    const ec = expectedColl as MongoSchemaCollection;
+    const indexChildren = diffIndexes(name, lc, ec, strict, issues);
+    const validatorChildren = diffValidator(name, lc, ec, strict, issues);
+    const optionsChildren = diffOptions(name, lc, ec, strict, issues);
+    const children = [...indexChildren, ...validatorChildren, ...optionsChildren];
+
+    const worstStatus = children.reduce<'pass' | 'warn' | 'fail'>(
+      (s, c) => (c.status === 'fail' ? 'fail' : c.status === 'warn' && s !== 'fail' ? 'warn' : s),
+      'pass',
+    );
+
+    for (const c of children) {
+      if (c.status === 'pass') pass++;
+      else if (c.status === 'warn') warn++;
+      else fail++;
+    }
+
+    if (children.length === 0) {
+      pass++;
+    }
+
+    collectionChildren.push({
+      status: worstStatus,
+      kind: 'collection',
+      name,
+      contractPath: `storage.collections.${name}`,
+      code: worstStatus === 'pass' ? 'MATCH' : 'DRIFT',
+      message:
+        worstStatus === 'pass' ? `Collection "${name}" matches` : `Collection "${name}" has drift`,
+      expected: name,
+      actual: name,
+      children,
+    });
+  }
+
+  const rootStatus = fail > 0 ? 'fail' : warn > 0 ? 'warn' : 'pass';
+  const totalNodes = pass + warn + fail + collectionChildren.length;
+
+  const root: SchemaVerificationNode = {
+    status: rootStatus,
+    kind: 'root',
+    name: 'mongo-schema',
+    contractPath: 'storage',
+    code: rootStatus === 'pass' ? 'MATCH' : 'DRIFT',
+    message: rootStatus === 'pass' ? 'Schema matches' : 'Schema has drift',
+    expected: null,
+    actual: null,
+    children: collectionChildren,
+  };
+
+  return { root, issues, counts: { pass, warn, fail, totalNodes } };
+}
+
+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 formatIndexName(index: MongoSchemaIndex): string {
+  return index.keys.map((k) => `${k.field}:${k.direction}`).join(', ');
+}
+
+function diffIndexes(
+  collName: string,
+  live: MongoSchemaCollection,
+  expected: MongoSchemaCollection,
+  strict: boolean,
+  issues: SchemaIssue[],
+): SchemaVerificationNode[] {
+  const nodes: SchemaVerificationNode[] = [];
+  const liveLookup = new Map<string, MongoSchemaIndex>();
+  for (const idx of live.indexes) liveLookup.set(buildIndexLookupKey(idx), idx);
+
+  const expectedLookup = new Map<string, MongoSchemaIndex>();
+  for (const idx of expected.indexes) expectedLookup.set(buildIndexLookupKey(idx), idx);
+
+  for (const [key, idx] of expectedLookup) {
+    if (liveLookup.has(key)) {
+      nodes.push({
+        status: 'pass',
+        kind: 'index',
+        name: formatIndexName(idx),
+        contractPath: `storage.collections.${collName}.indexes`,
+        code: 'MATCH',
+        message: `Index ${formatIndexName(idx)} matches`,
+        expected: key,
+        actual: key,
+        children: [],
+      });
+    } else {
+      issues.push({
+        kind: 'index_mismatch',
+        table: collName,
+        indexOrConstraint: formatIndexName(idx),
+        message: `Index ${formatIndexName(idx)} missing on collection "${collName}"`,
+      });
+      nodes.push({
+        status: 'fail',
+        kind: 'index',
+        name: formatIndexName(idx),
+        contractPath: `storage.collections.${collName}.indexes`,
+        code: 'MISSING_INDEX',
+        message: `Index ${formatIndexName(idx)} missing`,
+        expected: key,
+        actual: null,
+        children: [],
+      });
+    }
+  }
+
+  for (const [key, idx] of liveLookup) {
+    if (!expectedLookup.has(key)) {
+      const status = strict ? 'fail' : 'warn';
+      issues.push({
+        kind: 'extra_index',
+        table: collName,
+        indexOrConstraint: formatIndexName(idx),
+        message: `Extra index ${formatIndexName(idx)} on collection "${collName}"`,
+      });
+      nodes.push({
+        status,
+        kind: 'index',
+        name: formatIndexName(idx),
+        contractPath: `storage.collections.${collName}.indexes`,
+        code: 'EXTRA_INDEX',
+        message: `Extra index ${formatIndexName(idx)}`,
+        expected: null,
+        actual: key,
+        children: [],
+      });
+    }
+  }
+
+  return nodes;
+}
+
+function diffValidator(
+  collName: string,
+  live: MongoSchemaCollection,
+  expected: MongoSchemaCollection,
+  strict: boolean,
+  issues: SchemaIssue[],
+): SchemaVerificationNode[] {
+  if (!live.validator && !expected.validator) return [];
+
+  if (expected.validator && !live.validator) {
+    issues.push({
+      kind: 'type_missing',
+      table: collName,
+      message: `Validator missing on collection "${collName}"`,
+    });
+    return [
+      {
+        status: 'fail',
+        kind: 'validator',
+        name: 'validator',
+        contractPath: `storage.collections.${collName}.validator`,
+        code: 'MISSING_VALIDATOR',
+        message: 'Validator missing',
+        expected: canonicalize(expected.validator.jsonSchema),
+        actual: null,
+        children: [],
+      },
+    ];
+  }
+
+  if (!expected.validator && live.validator) {
+    const status = strict ? 'fail' : 'warn';
+    issues.push({
+      kind: 'extra_validator',
+      table: collName,
+      message: `Extra validator on collection "${collName}"`,
+    });
+    return [
+      {
+        status,
+        kind: 'validator',
+        name: 'validator',
+        contractPath: `storage.collections.${collName}.validator`,
+        code: 'EXTRA_VALIDATOR',
+        message: 'Extra validator found',
+        expected: null,
+        actual: canonicalize(live.validator.jsonSchema),
+        children: [],
+      },
+    ];
+  }
+
+  const liveVal = live.validator as NonNullable<typeof live.validator>;
+  const expectedVal = expected.validator as NonNullable<typeof expected.validator>;
+  const liveSchema = canonicalize(liveVal.jsonSchema);
+  const expectedSchema = canonicalize(expectedVal.jsonSchema);
+
+  if (
+    liveSchema !== expectedSchema ||
+    liveVal.validationLevel !== expectedVal.validationLevel ||
+    liveVal.validationAction !== expectedVal.validationAction
+  ) {
+    issues.push({
+      kind: 'type_mismatch',
+      table: collName,
+      expected: expectedSchema,
+      actual: liveSchema,
+      message: `Validator mismatch on collection "${collName}"`,
+    });
+    return [
+      {
+        status: 'fail',
+        kind: 'validator',
+        name: 'validator',
+        contractPath: `storage.collections.${collName}.validator`,
+        code: 'VALIDATOR_MISMATCH',
+        message: 'Validator mismatch',
+        expected: {
+          jsonSchema: expectedVal.jsonSchema,
+          validationLevel: expectedVal.validationLevel,
+          validationAction: expectedVal.validationAction,
+        },
+        actual: {
+          jsonSchema: liveVal.jsonSchema,
+          validationLevel: liveVal.validationLevel,
+          validationAction: liveVal.validationAction,
+        },
+        children: [],
+      },
+    ];
+  }
+
+  return [
+    {
+      status: 'pass',
+      kind: 'validator',
+      name: 'validator',
+      contractPath: `storage.collections.${collName}.validator`,
+      code: 'MATCH',
+      message: 'Validator matches',
+      expected: expectedSchema,
+      actual: liveSchema,
+      children: [],
+    },
+  ];
+}
+
+function diffOptions(
+  collName: string,
+  live: MongoSchemaCollection,
+  expected: MongoSchemaCollection,
+  strict: boolean,
+  issues: SchemaIssue[],
+): SchemaVerificationNode[] {
+  if (!live.options && !expected.options) return [];
+
+  if (!expected.options && live.options) {
+    const status = strict ? 'fail' : 'warn';
+    issues.push({
+      kind: 'type_mismatch',
+      table: collName,
+      actual: canonicalize(live.options),
+      message: `Extra collection options on "${collName}"`,
+    });
+    return [
+      {
+        status,
+        kind: 'options',
+        name: 'options',
+        contractPath: `storage.collections.${collName}.options`,
+        code: 'EXTRA_OPTIONS',
+        message: 'Extra collection options found',
+        expected: null,
+        actual: live.options,
+        children: [],
+      },
+    ];
+  }
+
+  if (deepEqual(live.options, expected.options)) {
+    return [
+      {
+        status: 'pass',
+        kind: 'options',
+        name: 'options',
+        contractPath: `storage.collections.${collName}.options`,
+        code: 'MATCH',
+        message: 'Collection options match',
+        expected: canonicalize(expected.options),
+        actual: canonicalize(live.options),
+        children: [],
+      },
+    ];
+  }
+
+  issues.push({
+    kind: 'type_mismatch',
+    table: collName,
+    expected: canonicalize(expected.options),
+    actual: canonicalize(live.options),
+    message: `Collection options mismatch on "${collName}"`,
+  });
+  return [
+    {
+      status: 'fail',
+      kind: 'options',
+      name: 'options',
+      contractPath: `storage.collections.${collName}.options`,
+      code: 'OPTIONS_MISMATCH',
+      message: 'Collection options mismatch',
+      expected: expected.options,
+      actual: live.options,
+      children: [],
+    },
+  ];
+}