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

package/src/core/mongo-emit.ts

@@ -1,135 +0,0 @@
-/**
- * Mongo's in-process implementation of the `emit` capability on
- * `TargetMigrationsCapability`. Invoked by the framework's class-flow emit
- * dispatcher in `@prisma-next/cli/lib/migration-emit` — see that module's
- * preamble for the cross-cutting story (when the CLI dispatches here, who
- * attests `migration.json`, why both flows produce byte-identical artifacts,
- * and the relationship to the self-emitting `Migration.run` shebang path).
- *
- * Mongo-specific responsibilities of this helper:
- *
- *  - Accept two authoring shapes for `migration.ts`'s default export, both
- *    adhering to the `MigrationPlan` interface:
- *
- *      1. Class subclass (canonical, scaffolded form):
- *           class M extends Migration {
- *             override get operations() { return [...]; }
- *             override describe() { return { from, to }; }
- *           }
- *           export default M;
- *           Migration.run(import.meta.url, M);
- *
- *      2. Factory function returning a MigrationPlan-shaped object:
- *           export default () => ({
- *             targetId: 'mongo',
- *             destination: { storageHash: '...' },
- *             operations: [createCollection("users")],
- *           });
- *
- *    Only the class form is scaffolded; the factory form is supported for
- *    authors who prefer it.
- *  - Dynamic-import the file so structured errors thrown during evaluation
- *    (notably `placeholder(...)`) surface to the CLI as real exceptions.
- *  - Dispatch on the default export's shape and validate the factory return
- *    is `MigrationPlan`-shaped.
- *  - Persist `ops.json` via the framework I/O helper and return the
- *    operations to the caller (which performs attestation).
- */
-
-import { stat } from 'node:fs/promises';
-import { pathToFileURL } from 'node:url';
-import {
-  errorMigrationFileMissing,
-  errorMigrationInvalidDefaultExport,
-  errorMigrationPlanNotArray,
-} from '@prisma-next/errors/migration';
-import type {
-  MigrationPlan,
-  MigrationPlanOperation,
-  TargetMigrationsCapability,
-} from '@prisma-next/framework-components/control';
-import { writeMigrationOps } from '@prisma-next/migration-tools/io';
-import { Migration } from '@prisma-next/migration-tools/migration';
-import { join } from 'pathe';
-
-const MIGRATION_TS_FILE = 'migration.ts';
-
-type EmitOptions = Parameters<NonNullable<TargetMigrationsCapability['emit']>>[0];
-
-/**
- * Implementation of `TargetMigrationsCapability.emit` for Mongo.
- *
- * Loads `<dir>/migration.ts` and dispatches on the default export's shape:
- * if it is a `Migration` subclass, instantiates it; otherwise invokes it as a
- * factory function (sync or async) and validates the returned value is
- * `MigrationPlan`-shaped. In both cases reads `.operations` to produce the
- * operations list, writes `ops.json`, and returns the operations for the
- * framework helper to render. Attestation of `migration.json` is the
- * caller's responsibility: the framework's `emitMigration` helper calls
- * `attestMigration` after this function returns. This capability MUST NOT
- * call `attestMigration` itself, to avoid double-attestation when the helper
- * drives emit.
- */
-export async function mongoEmit(options: EmitOptions): Promise<readonly MigrationPlanOperation[]> {
-  const filePath = join(options.dir, MIGRATION_TS_FILE);
-
-  try {
-    await stat(filePath);
-  } catch {
-    throw errorMigrationFileMissing(options.dir);
-  }
-
-  const fileUrl = pathToFileURL(filePath).href;
-  const mod = (await import(fileUrl)) as { default?: unknown };
-
-  const MigrationExport = mod.default;
-  if (typeof MigrationExport !== 'function') {
-    throw errorMigrationInvalidDefaultExport(
-      options.dir,
-      `default export of type ${typeof MigrationExport}`,
-    );
-  }
-
-  let plan: MigrationPlan;
-  if (MigrationExport.prototype instanceof Migration) {
-    plan = new (MigrationExport as new () => Migration)();
-  } else {
-    let factoryResult: unknown;
-    try {
-      factoryResult = await (MigrationExport as () => unknown | Promise<unknown>)();
-    } catch (error) {
-      if (error instanceof TypeError && /cannot be invoked without 'new'/i.test(error.message)) {
-        throw errorMigrationInvalidDefaultExport(
-          options.dir,
-          'a default export that does not extend Migration (from @prisma-next/migration-tools/migration)',
-        );
-      }
-      throw error;
-    }
-    if (
-      typeof factoryResult !== 'object' ||
-      factoryResult === null ||
-      !('operations' in factoryResult)
-    ) {
-      throw errorMigrationInvalidDefaultExport(
-        options.dir,
-        `factory must return a MigrationPlan-shaped object; got ${describeValue(factoryResult)}`,
-      );
-    }
-    plan = factoryResult as MigrationPlan;
-  }
-
-  const operations: unknown = plan.operations;
-  if (!Array.isArray(operations)) {
-    throw errorMigrationPlanNotArray(options.dir, describeValue(operations));
-  }
-
-  await writeMigrationOps(options.dir, operations);
-
-  return operations;
-}
-
-function describeValue(value: unknown): string {
-  if (value === null) return 'null';
-  return `a value of type ${typeof value}`;
-}

package/src/core/schema-diff.ts

@@ -1,402 +0,0 @@
-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: [],
-    },
-  ];
-}