@prisma-next/migration-tools 0.11.0-dev.59 → 0.11.0-dev.60

package/src/enumerate-migration-spaces.ts

@@ -1,127 +0,0 @@
-import { readMigrationsDir } from './io';
-import type { MigrationListEntry, MigrationSpaceListEntry } from './migration-list-types';
-import { readRefs } from './refs';
-import {
-  APP_SPACE_ID,
-  isValidSpaceId,
-  RESERVED_SPACE_SUBDIR_NAMES,
-  spaceMigrationDirectory,
-  spaceRefsDirectory,
-} from './space-layout';
-import { listContractSpaceDirectories } from './verify-contract-spaces';
-
-/**
- * Index `migrations/<space>/refs/*.json` by the contract hash each ref
- * points at, so callers can attach `(ref names)` decorations to every
- * row whose destination contract hash matches.
- *
- * Each bucket is sorted lex-asc to keep rendered output deterministic
- * (adjacent rows pointing at the same hash render their ref decorations
- * in the same order).
- *
- * Refs whose hash matches no migration on disk are still indexed; the
- * caller decides whether to surface them. Migration rows only carry
- * `(refs)` decorations when a matching destination contract hash exists
- * on disk — orphan refs are not rendered on any row.
- *
- * Returns an empty map when the refs directory does not exist
- * ({@link readRefs} treats `ENOENT` as "no refs").
- */
-export async function resolveRefsByContractHash(
-  refsDir: string,
-): Promise<ReadonlyMap<string, readonly string[]>> {
-  const refs = await readRefs(refsDir);
-  const byHash = new Map<string, string[]>();
-  for (const [name, entry] of Object.entries(refs)) {
-    const bucket = byHash.get(entry.hash);
-    if (bucket) bucket.push(name);
-    else byHash.set(entry.hash, [name]);
-  }
-  for (const bucket of byHash.values()) {
-    bucket.sort();
-  }
-  return byHash;
-}
-
-/**
- * Compare two contract-space IDs for the inter-space ordering rule:
- * {@link APP_SPACE_ID} first if present, then lex-asc on the rest.
- */
-function compareSpaceIds(a: string, b: string): number {
-  if (a === APP_SPACE_ID) return b === APP_SPACE_ID ? 0 : -1;
-  if (b === APP_SPACE_ID) return 1;
-  if (a < b) return -1;
-  if (a > b) return 1;
-  return 0;
-}
-
-/**
- * Sort `dirName` descending so the rendered output reads latest-first,
- * matching the `git log` latest-first convention.
- */
-function compareDirNamesDescending(a: MigrationListEntry, b: MigrationListEntry): number {
-  if (a.dirName < b.dirName) return 1;
-  if (a.dirName > b.dirName) return -1;
-  return 0;
-}
-
-/**
- * Enumerate every contract space's on-disk migrations under
- * `<projectMigrationsDir>/`. For each valid space directory:
- *
- * - Loads on-disk packages via {@link readMigrationsDir}.
- * - Attaches ref decorations: each migration's `refs[]` lists every ref
- *   name from `migrations/<spaceId>/refs/*.json` whose hash equals the
- *   migration's destination contract hash.
- * - Sorts migrations within the space by `dirName` descending
- *   (reverse-filename, latest first).
- *
- * Contract spaces are returned with {@link APP_SPACE_ID} first when
- * present, then the remaining ids lex-asc. A contract-space directory
- * that contains no migrations becomes `{ spaceId, migrations: [] }` so
- * the renderer's empty-state path can surface it.
- *
- * Directory entries that are not valid {@link isValidSpaceId} names are
- * skipped (a stray non-space directory under `migrations/` does not
- * spawn a phantom space entry). Entries whose name appears in
- * {@link RESERVED_SPACE_SUBDIR_NAMES} are also skipped — the per-space
- * `refs/` subdirectory name shape would otherwise satisfy
- * {@link isValidSpaceId} and surface as a phantom contract space.
- *
- * Returns `[]` when `<projectMigrationsDir>` does not exist — a fresh
- * project that has not authored any migration yet.
- */
-export async function enumerateMigrationSpaces(args: {
-  readonly projectMigrationsDir: string;
-}): Promise<readonly MigrationSpaceListEntry[]> {
-  const { projectMigrationsDir } = args;
-  const candidateDirs = await listContractSpaceDirectories(projectMigrationsDir);
-  const spaceIds = candidateDirs
-    .filter((name) => !RESERVED_SPACE_SUBDIR_NAMES.has(name))
-    .filter(isValidSpaceId)
-    .sort(compareSpaceIds);
-
-  const spaces: MigrationSpaceListEntry[] = [];
-  for (const spaceId of spaceIds) {
-    const spaceDir = spaceMigrationDirectory(projectMigrationsDir, spaceId);
-    const { packages } = await readMigrationsDir(spaceDir);
-    const refsByHash = await resolveRefsByContractHash(spaceRefsDirectory(spaceDir));
-
-    const migrations: MigrationListEntry[] = packages
-      .map((pkg) => ({
-        dirName: pkg.dirName,
-        from: pkg.metadata.from,
-        to: pkg.metadata.to,
-        migrationHash: pkg.metadata.migrationHash,
-        operationCount: pkg.ops.length,
-        createdAt: pkg.metadata.createdAt,
-        refs: refsByHash.get(pkg.metadata.to) ?? [],
-        providedInvariants: pkg.metadata.providedInvariants,
-      }))
-      .sort(compareDirNamesDescending);
-
-    spaces.push({ spaceId, migrations });
-  }
-
-  return spaces;
-}

package/src/exports/enumerate-migration-spaces.ts

@@ -1,4 +0,0 @@
-export {
-  enumerateMigrationSpaces,
-  resolveRefsByContractHash,
-} from '../enumerate-migration-spaces';

package/src/exports/migration-list-graph-topology.ts

@@ -1,5 +0,0 @@
-export type {
-  MigrationEdgeKind,
-  MigrationListGraphTopology,
-} from '../migration-list-graph-topology';
-export { classifyMigrationListGraphTopology } from '../migration-list-graph-topology';

package/src/exports/migration-list-types.ts

@@ -1,5 +0,0 @@
-export type {
-  MigrationListEntry,
-  MigrationListResult,
-  MigrationSpaceListEntry,
-} from '../migration-list-types';

package/src/migration-list-graph-topology.ts

@@ -1,158 +0,0 @@
-import { EMPTY_CONTRACT_HASH } from './constants';
-import type { MigrationListEntry } from './migration-list-types';
-
-export type MigrationEdgeKind = 'forward' | 'rollback' | 'self';
-
-export interface MigrationListGraphTopology {
-  readonly kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>;
-  readonly forwardInDegree: ReadonlyMap<string, number>;
-  readonly forwardOutDegree: ReadonlyMap<string, number>;
-}
-
-interface NonSelfEdge {
-  readonly entry: MigrationListEntry;
-  readonly from: string;
-  readonly to: string;
-}
-
-function canonicalFrom(from: string | null): string {
-  return from ?? EMPTY_CONTRACT_HASH;
-}
-
-function compareDirNameDesc(a: MigrationListEntry, b: MigrationListEntry): number {
-  return b.dirName.localeCompare(a.dirName);
-}
-
-function bumpDegree(map: Map<string, number>, key: string): void {
-  map.set(key, (map.get(key) ?? 0) + 1);
-}
-
-export function classifyMigrationListGraphTopology(
-  entries: readonly MigrationListEntry[],
-): MigrationListGraphTopology {
-  const nodes = new Set<string>();
-  const kindByMigrationHash = new Map<string, MigrationEdgeKind>();
-  const outgoingByFrom = new Map<string, NonSelfEdge[]>();
-
-  for (const entry of entries) {
-    const from = canonicalFrom(entry.from);
-    const to = entry.to;
-    nodes.add(from);
-    nodes.add(to);
-
-    if (from === to) {
-      kindByMigrationHash.set(entry.migrationHash, 'self');
-      continue;
-    }
-
-    const bucket = outgoingByFrom.get(from);
-    const edge: NonSelfEdge = { entry, from, to };
-    if (bucket) bucket.push(edge);
-    else outgoingByFrom.set(from, [edge]);
-  }
-
-  for (const bucket of outgoingByFrom.values()) {
-    bucket.sort((a, b) => compareDirNameDesc(a.entry, b.entry));
-  }
-
-  const nonSelfInDegree = new Map<string, number>();
-  for (const node of nodes) {
-    nonSelfInDegree.set(node, 0);
-  }
-  for (const bucket of outgoingByFrom.values()) {
-    for (const edge of bucket) {
-      bumpDegree(nonSelfInDegree, edge.to);
-    }
-  }
-
-  const dfsRoots: string[] = [];
-  for (const node of nodes) {
-    if ((nonSelfInDegree.get(node) ?? 0) === 0) {
-      dfsRoots.push(node);
-    }
-  }
-  dfsRoots.sort((a, b) => {
-    if (a === EMPTY_CONTRACT_HASH) return -1;
-    if (b === EMPTY_CONTRACT_HASH) return 1;
-    return a.localeCompare(b);
-  });
-  if (dfsRoots.length === 0) {
-    dfsRoots.push(...[...nodes].sort((a, b) => a.localeCompare(b)));
-  }
-
-  const WHITE = 0;
-  const GRAY = 1;
-  const BLACK = 2;
-  const color = new Map<string, number>();
-  for (const node of nodes) {
-    color.set(node, WHITE);
-  }
-
-  interface Frame {
-    node: string;
-    outgoing: readonly NonSelfEdge[];
-    index: number;
-  }
-  const stack: Frame[] = [];
-
-  function pushFrame(node: string): void {
-    color.set(node, GRAY);
-    stack.push({ node, outgoing: outgoingByFrom.get(node) ?? [], index: 0 });
-  }
-
-  function runDfsFrom(root: string): void {
-    if (color.get(root) !== WHITE) return;
-    pushFrame(root);
-
-    while (stack.length > 0) {
-      const frame = stack[stack.length - 1];
-      if (frame === undefined) break;
-      if (frame.index >= frame.outgoing.length) {
-        color.set(frame.node, BLACK);
-        stack.pop();
-        continue;
-      }
-
-      const edge = frame.outgoing[frame.index];
-      frame.index += 1;
-      if (edge === undefined) continue;
-
-      const v = edge.to;
-      const vColor = color.get(v);
-      if (vColor === GRAY) {
-        kindByMigrationHash.set(edge.entry.migrationHash, 'rollback');
-      } else {
-        kindByMigrationHash.set(edge.entry.migrationHash, 'forward');
-        if (vColor === WHITE) {
-          pushFrame(v);
-        }
-      }
-    }
-  }
-
-  for (const root of dfsRoots) {
-    runDfsFrom(root);
-  }
-  const remainingWhite = [...nodes].filter((node) => color.get(node) === WHITE);
-  remainingWhite.sort((a, b) => a.localeCompare(b));
-  for (const root of remainingWhite) {
-    runDfsFrom(root);
-  }
-
-  const forwardInDegree = new Map<string, number>();
-  const forwardOutDegree = new Map<string, number>();
-
-  for (const entry of entries) {
-    if (kindByMigrationHash.get(entry.migrationHash) !== 'forward') continue;
-    const from = canonicalFrom(entry.from);
-    const to = entry.to;
-    bumpDegree(forwardOutDegree, from);
-    bumpDegree(forwardInDegree, to);
-  }
-
-  return {
-    kindByMigrationHash,
-    forwardInDegree,
-    forwardOutDegree,
-  };
-}

package/src/migration-list-types.ts

@@ -1,21 +0,0 @@
-export interface MigrationListEntry {
-  readonly dirName: string;
-  readonly from: string | null;
-  readonly to: string;
-  readonly migrationHash: string;
-  readonly operationCount: number;
-  readonly createdAt: string;
-  readonly refs: readonly string[];
-  readonly providedInvariants: readonly string[];
-}
-
-export interface MigrationSpaceListEntry {
-  readonly spaceId: string;
-  readonly migrations: readonly MigrationListEntry[];
-}
-
-export interface MigrationListResult {
-  readonly ok: true;
-  readonly spaces: readonly MigrationSpaceListEntry[];
-  readonly summary: string;
-}