create-interview-cockpit 0.1.0 → 0.2.0

package/template/server/src/storage.ts

@@ -4,14 +4,38 @@ import { fileURLToPath } from "url";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const DATA_DIR = path.join(__dirname, "../../data");
-const TOPICS_FILE = path.join(DATA_DIR, "topics.json");
-const QUESTIONS_DIR = path.join(DATA_DIR, "questions");
-const CONTEXT_FILES_DIR = path.join(DATA_DIR, "context-files");
+const WORKSPACES_DIR = path.join(DATA_DIR, "workspaces");
+const WORKSPACES_FILE = path.join(DATA_DIR, "workspaces.json");
 
-async function ensureDirs() {
-  await fs.mkdir(DATA_DIR, { recursive: true });
-  await fs.mkdir(QUESTIONS_DIR, { recursive: true });
-  await fs.mkdir(CONTEXT_FILES_DIR, { recursive: true });
+// ── Active workspace ──────────────────────────────────────────
+let _activeWorkspaceId = "default";
+
+export function getActiveWorkspaceId(): string {
+  return _activeWorkspaceId;
+}
+
+/** Directly set the active workspace without side effects (no disk write, no dir creation). */
+export function setActiveWorkspaceId(id: string): void {
+  _activeWorkspaceId = id;
+}
+
+// ── Workspace-scoped path helpers ─────────────────────────────
+function workspaceDir(id = _activeWorkspaceId) {
+  return path.join(WORKSPACES_DIR, id);
+}
+function topicsFilePath(id = _activeWorkspaceId) {
+  return path.join(workspaceDir(id), "topics.json");
+}
+function questionsDirPath(id = _activeWorkspaceId) {
+  return path.join(workspaceDir(id), "questions");
+}
+function contextFilesDirPath(id = _activeWorkspaceId) {
+  return path.join(workspaceDir(id), "context-files");
+}
+async function ensureWorkspaceDirs(id = _activeWorkspaceId) {
+  await fs.mkdir(workspaceDir(id), { recursive: true });
+  await fs.mkdir(questionsDirPath(id), { recursive: true });
+  await fs.mkdir(contextFilesDirPath(id), { recursive: true });
 }
 
 export interface Topic {
@@ -25,6 +49,7 @@ export interface ContextFile {
   id: string;
   name: string;
   originalName: string;
+  driveFileId?: string;
   createdAt: string;
 }
 
@@ -71,12 +96,226 @@ export interface Question {
   createdAt: string;
 }
 
+// ── Workspace registry types ──────────────────────────────────────────
+export interface DriveConfig {
+  folderId: string;
+  folderName: string;
+  lastSyncedAt?: string;
+  subFolderId?: string;
+  subFolderName?: string;
+}
+
+export interface WorkspaceMeta {
+  id: string;
+  name: string;
+  type: "local" | "google_drive";
+  driveConfig?: DriveConfig;
+  createdAt: string;
+}
+
+interface WorkspacesRegistry {
+  activeWorkspaceId: string;
+  workspaces: WorkspaceMeta[];
+}
+
+// ── Migration: flat data/ → data/workspaces/default/ ────────────────────
+// Call once on server startup. No-op if already migrated.
+export async function migrateToWorkspaces(): Promise<void> {
+  try {
+    await fs.access(WORKSPACES_FILE);
+    // Already migrated — load the persisted active workspace ID
+    const data = await fs.readFile(WORKSPACES_FILE, "utf-8");
+    const registry: WorkspacesRegistry = JSON.parse(data);
+    _activeWorkspaceId = registry.activeWorkspaceId || "default";
+    return;
+  } catch {
+    // No registry yet — perform first-time migration
+  }
+
+  const defaultId = "default";
+  await ensureWorkspaceDirs(defaultId);
+
+  // Copy existing flat topics.json
+  try {
+    await fs.copyFile(
+      path.join(DATA_DIR, "topics.json"),
+      topicsFilePath(defaultId),
+    );
+  } catch {
+    await fs.writeFile(topicsFilePath(defaultId), JSON.stringify([], null, 2));
+  }
+
+  // Copy existing questions/*.json
+  try {
+    const files = await fs.readdir(path.join(DATA_DIR, "questions"));
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      await fs.copyFile(
+        path.join(DATA_DIR, "questions", file),
+        path.join(questionsDirPath(defaultId), file),
+      );
+    }
+  } catch {
+    /* ok if not present */
+  }
+
+  // Copy existing context-files/*
+  try {
+    const files = await fs.readdir(path.join(DATA_DIR, "context-files"));
+    for (const file of files) {
+      await fs.copyFile(
+        path.join(DATA_DIR, "context-files", file),
+        path.join(contextFilesDirPath(defaultId), file),
+      );
+    }
+  } catch {
+    /* ok if not present */
+  }
+
+  const registry: WorkspacesRegistry = {
+    activeWorkspaceId: defaultId,
+    workspaces: [
+      {
+        id: defaultId,
+        name: "Local",
+        type: "local",
+        createdAt: new Date().toISOString(),
+      },
+    ],
+  };
+  await fs.writeFile(WORKSPACES_FILE, JSON.stringify(registry, null, 2));
+  _activeWorkspaceId = defaultId;
+}
+
+// ── Workspace CRUD ───────────────────────────────────────────────
+export async function getWorkspaces(): Promise<WorkspacesRegistry> {
+  try {
+    const data = await fs.readFile(WORKSPACES_FILE, "utf-8");
+    const registry = JSON.parse(data) as WorkspacesRegistry;
+    // Keep the in-memory active ID in sync with what's persisted
+    if (registry.activeWorkspaceId) {
+      _activeWorkspaceId = registry.activeWorkspaceId;
+    }
+    return registry;
+  } catch {
+    return { activeWorkspaceId: _activeWorkspaceId, workspaces: [] };
+  }
+}
+
+export async function saveWorkspace(ws: WorkspaceMeta): Promise<WorkspaceMeta> {
+  const registry = await getWorkspaces();
+  const idx = registry.workspaces.findIndex((w) => w.id === ws.id);
+  if (idx !== -1) {
+    registry.workspaces[idx] = ws;
+  } else {
+    registry.workspaces.push(ws);
+    await ensureWorkspaceDirs(ws.id);
+  }
+  await fs.writeFile(WORKSPACES_FILE, JSON.stringify(registry, null, 2));
+  return ws;
+}
+
+export async function updateWorkspace(
+  id: string,
+  patch: Partial<WorkspaceMeta>,
+): Promise<WorkspaceMeta | null> {
+  const registry = await getWorkspaces();
+  const idx = registry.workspaces.findIndex((w) => w.id === id);
+  if (idx === -1) return null;
+  // Deep-merge driveConfig if provided
+  if (patch.driveConfig && registry.workspaces[idx].driveConfig) {
+    patch.driveConfig = {
+      ...registry.workspaces[idx].driveConfig,
+      ...patch.driveConfig,
+    };
+  }
+  Object.assign(registry.workspaces[idx], patch);
+  await fs.writeFile(WORKSPACES_FILE, JSON.stringify(registry, null, 2));
+  return registry.workspaces[idx];
+}
+
+export async function deleteWorkspace(id: string): Promise<void> {
+  const registry = await getWorkspaces();
+  if (registry.workspaces.length <= 1) {
+    throw new Error("Cannot delete the last workspace");
+  }
+  registry.workspaces = registry.workspaces.filter((w) => w.id !== id);
+  if (registry.activeWorkspaceId === id) {
+    registry.activeWorkspaceId = registry.workspaces[0].id;
+    _activeWorkspaceId = registry.activeWorkspaceId;
+  }
+  await fs.writeFile(WORKSPACES_FILE, JSON.stringify(registry, null, 2));
+  try {
+    await fs.rm(workspaceDir(id), { recursive: true });
+  } catch {
+    /* ok */
+  }
+}
+
+export async function activateWorkspace(
+  id: string,
+): Promise<WorkspacesRegistry> {
+  const registry = await getWorkspaces();
+  const ws = registry.workspaces.find((w) => w.id === id);
+  if (!ws) throw new Error(`Workspace "${id}" not found`);
+  registry.activeWorkspaceId = id;
+  _activeWorkspaceId = id;
+  await ensureWorkspaceDirs(id);
+  await fs.writeFile(WORKSPACES_FILE, JSON.stringify(registry, null, 2));
+  return registry;
+}
+
+// Workspace-scoped read helpers used by the Drive export path
+// (avoids mutating the module-level active workspace)
+export async function getTopicsForWorkspace(
+  workspaceId: string,
+): Promise<Topic[]> {
+  await ensureWorkspaceDirs(workspaceId);
+  try {
+    const data = await fs.readFile(topicsFilePath(workspaceId), "utf-8");
+    const topics: Topic[] = JSON.parse(data);
+    for (const t of topics) {
+      if (!t.contextFiles) t.contextFiles = [];
+    }
+    return topics;
+  } catch {
+    return [];
+  }
+}
+
+export async function getQuestionsByTopicForWorkspace(
+  workspaceId: string,
+  topicId: string,
+): Promise<Question[]> {
+  await ensureWorkspaceDirs(workspaceId);
+  try {
+    const files = await fs.readdir(questionsDirPath(workspaceId));
+    const questions: Question[] = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      const data = await fs.readFile(
+        path.join(questionsDirPath(workspaceId), file),
+        "utf-8",
+      );
+      const q: Question = JSON.parse(data);
+      if (q.topicId === topicId) questions.push(q);
+    }
+    return questions.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  } catch {
+    return [];
+  }
+}
+
+export function getContextFilesDirForWorkspace(workspaceId: string): string {
+  return contextFilesDirPath(workspaceId);
+}
+
 // --- Topics ---
 
 export async function getTopics(): Promise<Topic[]> {
-  await ensureDirs();
+  await ensureWorkspaceDirs();
   try {
-    const data = await fs.readFile(TOPICS_FILE, "utf-8");
+    const data = await fs.readFile(topicsFilePath(), "utf-8");
     const topics: Topic[] = JSON.parse(data);
     // Backfill missing fields from older data
     for (const t of topics) {
@@ -96,7 +335,7 @@ export async function saveTopic(topic: Topic): Promise<Topic> {
   } else {
     topics.push(topic);
   }
-  await fs.writeFile(TOPICS_FILE, JSON.stringify(topics, null, 2));
+  await fs.writeFile(topicsFilePath(), JSON.stringify(topics, null, 2));
   return topic;
 }
 
@@ -107,14 +346,14 @@ export async function deleteTopic(id: string): Promise<void> {
   if (topic?.contextFiles) {
     for (const cf of topic.contextFiles) {
       try {
-        await fs.unlink(path.join(CONTEXT_FILES_DIR, cf.id));
+        await fs.unlink(path.join(contextFilesDirPath(), cf.id));
       } catch {
         /* already gone */
       }
     }
   }
   const remaining = topics.filter((t) => t.id !== id);
-  await fs.writeFile(TOPICS_FILE, JSON.stringify(remaining, null, 2));
+  await fs.writeFile(topicsFilePath(), JSON.stringify(remaining, null, 2));
   const questions = await getQuestionsByTopic(id);
   for (const q of questions) {
     await deleteQuestion(q.id);
@@ -129,14 +368,54 @@ export async function updateTopic(
   const idx = topics.findIndex((t) => t.id === id);
   if (idx === -1) return null;
   Object.assign(topics[idx], patch);
-  await fs.writeFile(TOPICS_FILE, JSON.stringify(topics, null, 2));
+  await fs.writeFile(topicsFilePath(), JSON.stringify(topics, null, 2));
   return topics[idx];
 }
 
+/**
+ * Replace the entire topic list in one write (used by sync to avoid N read+write cycles).
+ */
+export async function replaceAllTopics(topics: Topic[]): Promise<void> {
+  await ensureWorkspaceDirs();
+  await fs.writeFile(topicsFilePath(), JSON.stringify(topics, null, 2));
+}
+
+/**
+ * Wipe all topics, questions, and context-file blobs for a workspace in parallel.
+ * Much faster than calling deleteTopic() in a loop.
+ */
+export async function clearWorkspaceData(workspaceId: string): Promise<void> {
+  await ensureWorkspaceDirs(workspaceId);
+  const wid = workspaceId;
+  await fs.writeFile(topicsFilePath(wid), JSON.stringify([], null, 2));
+  await Promise.all([
+    fs
+      .readdir(questionsDirPath(wid))
+      .then((files) =>
+        Promise.all(
+          files.map((f) =>
+            fs.unlink(path.join(questionsDirPath(wid), f)).catch(() => {}),
+          ),
+        ),
+      )
+      .catch(() => {}),
+    fs
+      .readdir(contextFilesDirPath(wid))
+      .then((files) =>
+        Promise.all(
+          files.map((f) =>
+            fs.unlink(path.join(contextFilesDirPath(wid), f)).catch(() => {}),
+          ),
+        ),
+      )
+      .catch(() => {}),
+  ]);
+}
+
 // --- Context Files ---
 
 export function getContextFilesDir(): string {
-  return CONTEXT_FILES_DIR;
+  return contextFilesDirPath();
 }
 
 export async function saveContextFile(
@@ -144,13 +423,15 @@ export async function saveContextFile(
   fileId: string,
   originalName: string,
   buffer: Buffer,
+  driveFileId?: string,
 ): Promise<ContextFile> {
-  await ensureDirs();
-  await fs.writeFile(path.join(CONTEXT_FILES_DIR, fileId), buffer);
+  await ensureWorkspaceDirs();
+  await fs.writeFile(path.join(contextFilesDirPath(), fileId), buffer);
   const cf: ContextFile = {
     id: fileId,
     name: originalName,
     originalName,
+    ...(driveFileId ? { driveFileId } : {}),
     createdAt: new Date().toISOString(),
   };
   const topics = await getTopics();
@@ -158,17 +439,33 @@ export async function saveContextFile(
   if (topic) {
     if (!topic.contextFiles) topic.contextFiles = [];
     topic.contextFiles.push(cf);
-    await fs.writeFile(TOPICS_FILE, JSON.stringify(topics, null, 2));
+    await fs.writeFile(topicsFilePath(), JSON.stringify(topics, null, 2));
   }
   return cf;
 }
 
+/**
+ * Write only the binary blob for a context file — does NOT update topics.json.
+ * Use this when you want to batch-update topics.json separately (e.g. during sync).
+ */
+export async function writeContextFileBlob(
+  workspaceId: string,
+  fileId: string,
+  buffer: Buffer,
+): Promise<void> {
+  await ensureWorkspaceDirs(workspaceId);
+  await fs.writeFile(
+    path.join(contextFilesDirPath(workspaceId), fileId),
+    buffer,
+  );
+}
+
 export async function deleteContextFile(
   topicId: string,
   fileId: string,
 ): Promise<void> {
   try {
-    await fs.unlink(path.join(CONTEXT_FILES_DIR, fileId));
+    await fs.unlink(path.join(contextFilesDirPath(), fileId));
   } catch {
     /* already gone */
   }
@@ -178,21 +475,21 @@ export async function deleteContextFile(
     topic.contextFiles = (topic.contextFiles || []).filter(
       (f) => f.id !== fileId,
     );
-    await fs.writeFile(TOPICS_FILE, JSON.stringify(topics, null, 2));
+    await fs.writeFile(topicsFilePath(), JSON.stringify(topics, null, 2));
   }
 }
 
 export async function readContextFileContent(fileId: string): Promise<string> {
-  return fs.readFile(path.join(CONTEXT_FILES_DIR, fileId), "utf-8");
+  return fs.readFile(path.join(contextFilesDirPath(), fileId), "utf-8");
 }
 
 // --- Questions ---
 
 export async function getQuestion(id: string): Promise<Question | null> {
-  await ensureDirs();
+  await ensureWorkspaceDirs();
   try {
     const data = await fs.readFile(
-      path.join(QUESTIONS_DIR, `${id}.json`),
+      path.join(questionsDirPath(), `${id}.json`),
       "utf-8",
     );
     const q: Question = JSON.parse(data);
@@ -207,13 +504,16 @@ export async function getQuestion(id: string): Promise<Question | null> {
 export async function getQuestionsByTopic(
   topicId: string,
 ): Promise<Question[]> {
-  await ensureDirs();
+  await ensureWorkspaceDirs();
   try {
-    const files = await fs.readdir(QUESTIONS_DIR);
+    const files = await fs.readdir(questionsDirPath());
     const questions: Question[] = [];
     for (const file of files) {
       if (!file.endsWith(".json")) continue;
-      const data = await fs.readFile(path.join(QUESTIONS_DIR, file), "utf-8");
+      const data = await fs.readFile(
+        path.join(questionsDirPath(), file),
+        "utf-8",
+      );
       const q: Question = JSON.parse(data);
       if (q.topicId === topicId) {
         questions.push(q);
@@ -226,9 +526,9 @@ export async function getQuestionsByTopic(
 }
 
 export async function saveQuestion(question: Question): Promise<Question> {
-  await ensureDirs();
+  await ensureWorkspaceDirs();
   await fs.writeFile(
-    path.join(QUESTIONS_DIR, `${question.id}.json`),
+    path.join(questionsDirPath(), `${question.id}.json`),
     JSON.stringify(question, null, 2),
   );
   return question;
@@ -240,14 +540,14 @@ export async function deleteQuestion(id: string): Promise<void> {
   if (q?.contextFiles) {
     for (const cf of q.contextFiles) {
       try {
-        await fs.unlink(path.join(CONTEXT_FILES_DIR, cf.id));
+        await fs.unlink(path.join(contextFilesDirPath(), cf.id));
       } catch {
         /* ok */
       }
     }
   }
   try {
-    await fs.unlink(path.join(QUESTIONS_DIR, `${id}.json`));
+    await fs.unlink(path.join(questionsDirPath(), `${id}.json`));
   } catch {
     // ignore if already deleted
   }
@@ -259,8 +559,8 @@ export async function saveQuestionContextFile(
   originalName: string,
   buffer: Buffer,
 ): Promise<ContextFile> {
-  await ensureDirs();
-  await fs.writeFile(path.join(CONTEXT_FILES_DIR, fileId), buffer);
+  await ensureWorkspaceDirs();
+  await fs.writeFile(path.join(contextFilesDirPath(), fileId), buffer);
   const cf: ContextFile = {
     id: fileId,
     name: originalName,
@@ -281,7 +581,7 @@ export async function deleteQuestionContextFile(
   fileId: string,
 ): Promise<void> {
   try {
-    await fs.unlink(path.join(CONTEXT_FILES_DIR, fileId));
+    await fs.unlink(path.join(contextFilesDirPath(), fileId));
   } catch {
     /* ok */
   }