some work

Author: aster-void

src/lib/data/private/migration.remote.ts

@@ -5,7 +5,7 @@ import {
   startDeleteAll,
   startImageCleanup,
 } from "$lib/server/services/migration/index.server";
-import { getMigrationState, resetMigration } from "$lib/server/services/migration/state.server";
+import { migrationActor } from "$lib/server/services/migration/state.server";
 import type { MigrationState } from "$lib/shared/types/migration";
 
 export const start = command(async (): Promise<{ started: boolean; message: string }> => {
@@ -16,12 +16,12 @@ export const start = command(async (): Promise<{ started: boolean; message: stri
 // Use command instead of query to bypass caching for real-time polling
 export const getStatus = command(async (): Promise<MigrationState> => {
   await requireUtCodeMember();
-  return getMigrationState();
+  return migrationActor.getState();
 });
 
 export const reset = command(async (): Promise<void> => {
   await requireUtCodeMember();
-  resetMigration();
+  migrationActor.reset();
 });
 
 export const cleanup = command(async (): Promise<{ started: boolean; message: string }> => {

src/lib/server/services/migration/index.server.ts

@@ -1,15 +1,17 @@
 /**
  * Migration orchestrator
  *
- * Coordinates the migration process: cloning repo, running workers,
- * and managing state. Uses workers from migration-workers.server.ts.
+ * Sends events to the migration actor and executes effects.
+ * The actor handles all state transitions synchronously,
+ * making race conditions impossible.
  */
 
 import { spawn } from "node:child_process";
 import { rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { completeMigration, failMigration, isRunning, log, startMigration } from "./state.server";
+import type { MigrationOperation } from "$lib/shared/types/migration";
+import { type MigrationEffect, migrationActor } from "./state.server";
 import {
   cleanupInvalidImageUrls,
   deleteAllMigratedData,
@@ -21,7 +23,7 @@ import {
 
 const REPO_URL = "https://github.com/ut-code/utcode.net.git";
 
-async function runCommand(cmd: string, args: string[], cwd?: string): Promise<void> {
+function runCommand(cmd: string, args: string[], cwd?: string): Promise<void> {
   return new Promise((resolve, reject) => {
     const child = spawn(cmd, args, { cwd, stdio: "pipe" });
     let stderr = "";
@@ -38,112 +40,124 @@ async function runCommand(cmd: string, args: string[], cwd?: string): Promise<vo
 
 async function cloneRepo(): Promise<string> {
   const tempDir = join(tmpdir(), `utcode-migration-${Date.now()}`);
-  log(`Cloning ${REPO_URL}...`);
+  migrationActor.log(`Cloning ${REPO_URL}...`);
   await runCommand("git", ["clone", "--depth", "1", REPO_URL, tempDir]);
-  log("Repository cloned successfully");
+  migrationActor.log("Repository cloned successfully");
   return tempDir;
 }
 
-export function startDataMigration(): { started: boolean; message: string } {
-  if (isRunning()) {
-    return { started: false, message: "Migration already in progress" };
-  }
+// ============================================================================
+// Effect executors - async work triggered by actor
+// ============================================================================
 
-  startMigration();
-  log("=== Data Migration Started ===");
+async function executeMigration(): Promise<void> {
+  let repoPath: string | null = null;
 
-  // Run migration in background (fire and forget with proper error handling)
-  runMigrationAsync().catch(console.error);
+  try {
+    repoPath = await cloneRepo();
 
-  return { started: true, message: "Migration started" };
-}
+    const log = (msg: string) => migrationActor.log(msg);
+    const members = await migrateMembers(repoPath, log);
+    const articles = await migrateArticles(repoPath, log);
+    const projects = await migrateProjects(repoPath, log);
+    const images = await migrateImages(repoPath, log);
 
-export function startImageCleanup(): { started: boolean; message: string } {
-  if (isRunning()) {
-    return { started: false, message: "Migration already in progress" };
+    migrationActor.complete({ members, articles, projects, images });
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : String(e);
+    migrationActor.fail(errorMessage);
+  } finally {
+    if (repoPath) {
+      migrationActor.log("Cleaning up temporary files...");
+      await rm(repoPath, { recursive: true, force: true }).catch(() => {});
+    }
   }
-
-  startMigration();
-  log("=== Image URL Cleanup Started ===");
-
-  runCleanupAsync().catch(console.error);
-
-  return { started: true, message: "Cleanup started" };
 }
 
-async function runCleanupAsync(): Promise<void> {
+async function executeCleanup(): Promise<void> {
   try {
+    const log = (msg: string) => migrationActor.log(msg);
     const result = await cleanupInvalidImageUrls(log);
 
-    log("=== Cleanup Complete ===");
-    completeMigration({
+    migrationActor.complete({
       members: { created: result.members.cleaned, skipped: result.members.skipped, errors: 0 },
       articles: { created: result.articles.cleaned, skipped: result.articles.skipped, errors: 0 },
       projects: { created: result.projects.cleaned, skipped: result.projects.skipped, errors: 0 },
       images: { created: 0, skipped: 0, errors: 0 },
     });
   } catch (e) {
     const errorMessage = e instanceof Error ? e.message : String(e);
-    log(`=== Cleanup Failed: ${errorMessage} ===`);
-    failMigration(errorMessage);
+    migrationActor.fail(errorMessage);
   }
 }
 
-export function startDeleteAll(): { started: boolean; message: string } {
-  if (isRunning()) {
-    return { started: false, message: "Migration already in progress" };
-  }
-
-  startMigration();
-  log("=== Delete All Data Started ===");
-
-  runDeleteAllAsync().catch(console.error);
-
-  return { started: true, message: "Delete started" };
-}
-
-async function runDeleteAllAsync(): Promise<void> {
+async function executeDelete(): Promise<void> {
   try {
+    const log = (msg: string) => migrationActor.log(msg);
     const result = await deleteAllMigratedData(log);
 
-    log("=== Delete Complete ===");
-    completeMigration({
+    migrationActor.complete({
       members: { created: result.members.deleted, skipped: 0, errors: 0 },
       articles: { created: result.articles.deleted, skipped: 0, errors: 0 },
       projects: { created: result.projects.deleted, skipped: 0, errors: 0 },
       images: { created: 0, skipped: 0, errors: 0 },
     });
   } catch (e) {
     const errorMessage = e instanceof Error ? e.message : String(e);
-    log(`=== Delete Failed: ${errorMessage} ===`);
-    failMigration(errorMessage);
+    migrationActor.fail(errorMessage);
   }
 }
 
-async function runMigrationAsync(): Promise<void> {
-  let repoPath: string | null = null;
+/**
+ * Execute an effect returned by the actor
+ */
+function executeEffect(effect: MigrationEffect): void {
+  if (!effect) return;
+
+  switch (effect.type) {
+    case "RUN_MIGRATION":
+      executeMigration().catch(console.error);
+      break;
+    case "RUN_CLEANUP":
+      executeCleanup().catch(console.error);
+      break;
+    case "RUN_DELETE":
+      executeDelete().catch(console.error);
+      break;
+  }
+}
 
-  try {
-    // Clone repo
-    repoPath = await cloneRepo();
+// ============================================================================
+// Public API - sends events to actor and executes effects
+// ============================================================================
 
-    // Run migrations in order (members first, then articles/projects, then images)
-    const members = await migrateMembers(repoPath, log);
-    const articles = await migrateArticles(repoPath, log);
-    const projects = await migrateProjects(repoPath, log);
-    const images = await migrateImages(repoPath, log);
+/**
+ * Start an operation by sending START event to actor
+ * Returns immediately - async work runs in background
+ */
+export function startOperation(operation: MigrationOperation): {
+  started: boolean;
+  message: string;
+} {
+  const { effect, started } = migrationActor.send({ type: "START", operation });
 
-    log("=== Migration Complete ===");
-    completeMigration({ members, articles, projects, images });
-  } catch (e) {
-    const errorMessage = e instanceof Error ? e.message : String(e);
-    log(`=== Migration Failed: ${errorMessage} ===`);
-    failMigration(errorMessage);
-  } finally {
-    // Cleanup
-    if (repoPath) {
-      log("Cleaning up temporary files...");
-      await rm(repoPath, { recursive: true, force: true }).catch(() => {});
-    }
+  if (!started) {
+    return { started: false, message: "Migration already in progress" };
   }
+
+  // Execute the effect (async work) in background
+  executeEffect(effect);
+
+  const labels: Record<MigrationOperation, string> = {
+    migrate: "Migration",
+    cleanup: "Cleanup",
+    delete: "Delete",
+  };
+
+  return { started: true, message: `${labels[operation]} started` };
 }
+
+// Convenience exports for backward compatibility
+export const startDataMigration = () => startOperation("migrate");
+export const startImageCleanup = () => startOperation("cleanup");
+export const startDeleteAll = () => startOperation("delete");