Merge pull request #4376 from Northeastern-Electric-Racing/#4375-migration-deletion

#4375 Migration And Deletion

Author: wavehassman

package.json

@@ -20,7 +20,6 @@
     "prisma:reset:force": "yarn workspace shared build; cd src/backend; npx prisma migrate reset --force",
     "prisma:reset": "yarn workspace shared build; cd src/backend; npx prisma migrate reset",
     "prisma:reset:no-seed": "yarn workspace shared build; cd src/backend; npx prisma migrate reset --skip-seed",
-    "prisma:dev-seed": "yarn workspace shared build && cd src/backend && npx prisma migrate reset --force --skip-seed && npx tsx --import dotenv/config ./src/prisma/dev-seed.ts",
     "docker:prisma:reset": "cd devContainerization && docker compose -f docker-compose.dev.yml exec -T backend sh -c \"cd /src/backend && npx prisma migrate reset --force\"",
     "prisma:migrate": "yarn prisma:migrate:dev",
     "docker:prisma:migrate": "cd devContainerization && docker compose -f docker-compose.dev.yml exec -it -w /src/backend backend npx prisma migrate dev",

src/backend/package.json

@@ -7,9 +7,7 @@
     "test": "vitest",
     "build": "NODE_OPTIONS='--max-old-space-size=8192' tsc --noEmit false",
     "start": "node -r dotenv/config dist/backend/index.js",
-    "prisma:manual": "tsx --import dotenv/config ./src/prisma/manual.ts",
-    "prisma:dev-seed": "tsx --import dotenv/config ./src/prisma/dev-seed.ts",
-    "prisma:dev-setup": "docker compose up -d --no-recreate database && yarn prisma:reset:no-seed --force && yarn workspace backend prisma:dev-seed"
+    "prisma:manual": "tsx --import dotenv/config ./src/prisma/manual.ts"
   },
   "dependencies": {
     "@prisma/client": "^6.2.1",
@@ -39,9 +37,9 @@
     "multer": "^1.4.5-lts.1",
     "node-ical": "^0.26.1",
     "nodemailer": "^6.9.1",
-    "ora": "^9.4.1",
     "prisma": "^6.2.1",
-    "shared": "1.0.0"
+    "shared": "1.0.0",
+    "twisters": "^1.1.0"
   },
   "devDependencies": {
     "@types/express-jwt": "^6.0.4",

src/backend/src/prisma/dev-seed.ts

@@ -6,14 +6,18 @@ export type SeedProcessConstructor<TInput, TOutput> = new (...args: any[]) => Se
 export const GLOBAL_SEED = 1;
 
 export abstract class SeedProcess<TInput, TOutput> {
-  protected faker: Faker;
+  public faker: Faker;
   public prisma!: PrismaClient;
 
   constructor() {
     this.faker = new Faker({ locale: [en, base] });
     this.faker.seed(GLOBAL_SEED);
   }
 
+  reseed(seed: number) {
+    this.faker.seed(seed);
+  }
+
   abstract dependencies(): SeedProcessConstructor<any, any>[];
   abstract run(deps: TInput): Promise<TOutput>;
 }

src/backend/src/prisma/processes/seed-process.ts

@@ -1,28 +1,73 @@
 import { PrismaClient } from '@prisma/client';
-import { SeedProcess } from './seed-process.js';
-import ora from 'ora';
+import { SeedProcess, GLOBAL_SEED } from './seed-process.js';
+import { Twisters } from 'twisters';
+
+type AnyProcess = SeedProcess<any, any>;
+
+const DEFAULT_MAX_CONCURRENCY = 4;
+
+const deriveSeed = (baseSeed: number, processName: string): number => {
+  let hash = baseSeed >>> 0;
+  for (let i = 0; i < processName.length; i++) {
+    hash = (Math.imul(hash, 31) + processName.charCodeAt(i)) >>> 0;
+  }
+  return hash;
+};
 
 export class SeedRunner {
-  private instances: SeedProcess<any, any>[] = [];
+  private instances: AnyProcess[] = [];
   private prisma!: PrismaClient;
+  private baseSeed = GLOBAL_SEED;
+  private maxConcurrency = DEFAULT_MAX_CONCURRENCY;
 
   withPrisma(prisma: PrismaClient) {
     this.prisma = prisma;
     return this;
   }
 
-  register(...processes: SeedProcess<any, any>[]) {
+  withSeed(seed: number) {
+    this.baseSeed = seed;
+    return this;
+  }
+
+  withMaxConcurrency(max: number) {
+    this.maxConcurrency = Math.max(1, max);
+    return this;
+  }
+
+  register(...processes: AnyProcess[]) {
     this.instances.push(...processes);
     return this;
   }
 
   async run() {
     if (!this.prisma) throw new Error('SeedRunner requires a PrismaClient. Call withPrisma() before run().');
 
-    const outputs = new Map<string, any>();
-    const context: Record<string, any> = {};
     const total = this.instances.length;
+    const byName = new Map<string, AnyProcess>();
+    for (const instance of this.instances) {
+      const { name } = instance.constructor;
+      if (byName.has(name)) throw new Error(`Duplicate process registered: ${name}`);
+      byName.set(name, instance);
+    }
+
+    const dependencyNames = new Map<string, string[]>();
+    for (const instance of this.instances) {
+      const { name } = instance.constructor;
+      const deps = instance.dependencies().map((depClass) => depClass.name);
+      for (const dep of deps) {
+        if (!byName.has(dep)) {
+          throw new Error(`Process ${name} depends on ${dep}, which was not registered.`);
+        }
+      }
+      dependencyNames.set(name, deps);
+    }
+
+    this.assertNoCycles(dependencyNames);
+
     const maxNameLength = Math.max(...this.instances.map((i) => i.constructor.name.length));
+    const outputs = new Map<string, any>();
+    const context: Record<string, any> = {};
 
     const mergeOutputs = (target: Record<string, any>, source: Record<string, any>, sourceName: string) => {
       const duplicateKeys = Object.keys(source).filter((key) => key in target);
@@ -32,53 +77,123 @@ export class SeedRunner {
       return Object.assign(target, source);
     };
 
-    const totalStart = Date.now();
+    const remaining = new Set(byName.keys());
+    const inFlight = new Map<string, Promise<void>>();
+    const completed = new Set<string>();
+    const startTimes = new Map<string, number>();
+    let launchedCount = 0;
+    let failed: unknown = null;
 
+    const totalStart = Date.now();
+    const twisters = new Twisters();
     console.log();
-    console.log(`  🌱 Starting seed — ${total} processes\n`);
+    console.log(`  🌱 Starting seed — ${total} processes (max ${this.maxConcurrency} concurrent)\n`);
+
+    const depsSatisfied = (name: string) => (dependencyNames.get(name) ?? []).every((dep) => completed.has(dep));
+
+    const launch = (name: string) => {
+      const instance = byName.get(name)!;
+      remaining.delete(name);
+      launchedCount += 1;
+      const index = `[${String(launchedCount).padStart(String(total).length)}/${total}]`;
+      const label = instance.constructor.name.padEnd(maxNameLength);
+
+      twisters.put(name, { text: `  ${index} ${label}` });
+      startTimes.set(name, Date.now());
 
-    for (let i = 0; i < this.instances.length; i++) {
-      const instance = this.instances[i];
       instance.prisma = this.prisma;
-      const start = Date.now();
-      const index = `[${String(i + 1).padStart(String(total).length)}/${total}]`;
-      const name = instance.constructor.name.padEnd(maxNameLength);
-
-      const spinner = ora({
-        text: `${index} ${name}`,
-        color: 'cyan'
-      }).start();
-
-      try {
-        const depOutputs = instance.dependencies().reduce<Record<string, any>>((acc, depClass) => {
-          const output = outputs.get(depClass.name);
-          if (!output) throw new Error(`Missing output for dependency: ${depClass.name}`);
-          return mergeOutputs(acc, output, depClass.name);
-        }, {});
+      instance.reseed(deriveSeed(this.baseSeed, name));
 
+      const depOutputs = (dependencyNames.get(name) ?? []).reduce<Record<string, any>>((acc, depName) => {
+        const output = outputs.get(depName);
+        if (!output) throw new Error(`Missing output for dependency: ${depName}`);
+        return mergeOutputs(acc, output, depName);
+      }, {});
+
+      const task = (async () => {
         const output = await instance.run(depOutputs);
+        outputs.set(name, output);
+        mergeOutputs(context, output, name);
+      })()
+        .then(() => {
+          const elapsed = `${((Date.now() - startTimes.get(name)!) / 1000).toFixed(2)}s`;
+          twisters.put(name, { active: false, text: `  ✔ ${index} ${label} ${elapsed}` });
+          completed.add(name);
+        })
+        .catch((e) => {
+          const elapsed = `${((Date.now() - startTimes.get(name)!) / 1000).toFixed(2)}s`;
+          twisters.put(name, { active: false, text: `  ✖ ${index} ${label} ${elapsed}` });
+          if (!failed) failed = e;
+        })
+        .finally(() => {
+          inFlight.delete(name);
+        });
+
+      inFlight.set(name, task);
+    };
+
+    while ((remaining.size > 0 || inFlight.size > 0) && !failed) {
+      const ready = [...remaining].filter(depsSatisfied);
 
-        outputs.set(instance.constructor.name, output);
-        mergeOutputs(context, output, instance.constructor.name);
-
-        const elapsed = `${((Date.now() - start) / 1000).toFixed(2)}s`;
-        spinner.succeed(`${index} ${name}   ${elapsed}`);
-      } catch (e) {
-        const elapsed = `${((Date.now() - start) / 1000).toFixed(2)}s`;
-        spinner.fail(`${index} ${name}   ${elapsed}`);
-        const totalElapsed = `${((Date.now() - totalStart) / 1000).toFixed(2)}s`;
-        console.log();
-        console.log(`  ❌ Seed failed on ${instance.constructor.name.trim()} failure(s) in ${totalElapsed}`);
-        console.log();
-        throw e;
+      while (ready.length > 0 && inFlight.size < this.maxConcurrency) {
+        launch(ready.shift()!);
+      }
+
+      if (inFlight.size === 0 && remaining.size > 0) {
+        break;
+      }
+
+      if (inFlight.size > 0) {
+        await Promise.race(inFlight.values());
       }
     }
 
+    await Promise.allSettled(inFlight.values());
+
+    twisters.forEachMessage((_message, messageName) => twisters.remove(messageName));
+    twisters.flush();
+
+    if (failed) {
+      const totalElapsed = `${((Date.now() - totalStart) / 1000).toFixed(2)}s`;
+      console.log();
+      console.log(`  ❌ Seed failed in ${totalElapsed}`);
+      console.log();
+      throw failed;
+    }
+
+    if (completed.size < total) {
+      const stuck = [...byName.keys()].filter((name) => !completed.has(name));
+      throw new Error(`Seed could not complete. Unreachable processes (dependency issue): ${stuck.join(', ')}`);
+    }
+
     const totalElapsed = `${((Date.now() - totalStart) / 1000).toFixed(2)}s`;
     console.log();
     console.log(`  ✅ Seed complete — ${total} processes finished in ${totalElapsed}`);
     console.log();
 
     return context;
   }
+
+  private assertNoCycles(dependencyNames: Map<string, string[]>) {
+    const visiting = new Set<string>();
+    const visited = new Set<string>();
+    const stack: string[] = [];
+
+    const visit = (name: string) => {
+      if (visited.has(name)) return;
+      if (visiting.has(name)) {
+        const cycleStart = stack.indexOf(name);
+        const cycle = [...stack.slice(cycleStart), name].join(' → ');
+        throw new Error(`Dependency cycle detected: ${cycle}`);
+      }
+      visiting.add(name);
+      stack.push(name);
+      for (const dep of dependencyNames.get(name) ?? []) visit(dep);
+      stack.pop();
+      visiting.delete(name);
+      visited.add(name);
+    };
+
+    for (const name of dependencyNames.keys()) visit(name);
+  }
 }