@cloud411716/fancy-webnovel 1.0.46 → 3.0.0

package/lib/projects.js

@@ -0,0 +1,400 @@
+/**
+ * Project registry, project directories, and project-scoped database users.
+ *
+ * The registry lives in one shared SurrealDB database
+ * (`fancy_registry`). A project's novel data lives in its own database
+ * (`proj_<uuid>`), and the project directory only stores connection metadata:
+ *
+ *   <workspace>/projects/<uuid>/.fancy-project.json
+ *
+ * The novel title is NOT duplicated on disk. Renaming a project updates the
+ * registry and the project's `story:main` record; the directory name (the
+ * UUID) never changes.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { Surreal, createRemoteEngines } from 'surrealdb';
+import {
+  WorkspaceError,
+  atomicWriteJson,
+  readJsonFile,
+  localIsoString,
+  readSecrets,
+  readWorkspace,
+  resolveWorkspace,
+  setActiveProject,
+  workspacePaths,
+  getActiveProject,
+} from './workspace.js';
+import { rpcUrl, startServer } from './surreal-server.js';
+
+export const PROJECT_SCHEMA_VERSION = 1;
+export const PROJECT_CONFIG_FILE = '.fancy-project.json';
+export const REGISTRY_TABLE = 'project';
+
+export class ProjectError extends Error {
+  constructor(code, message, detail) {
+    super(message);
+    this.name = 'ProjectError';
+    this.code = code;
+    this.detail = detail;
+  }
+}
+
+export function projectRecordId(projectId) {
+  return 'project:' + String(projectId).replace(/-/g, '_');
+}
+
+export function databaseName(projectId) {
+  return 'proj_' + String(projectId).replace(/-/g, '');
+}
+
+export function databaseUser(projectId) {
+  return 'u_' + String(projectId).replace(/-/g, '').slice(0, 16);
+}
+
+export function projectConfigPath(dir) {
+  return path.join(dir, PROJECT_CONFIG_FILE);
+}
+
+export function readProjectConfig(dir) {
+  const file = projectConfigPath(dir);
+  const data = readJsonFile(file);
+  if (!data || typeof data !== 'object' || Array.isArray(data) || !data.project_id) return null;
+  return data;
+}
+
+export function writeProjectConfig(dir, config) {
+  fs.mkdirSync(dir, { recursive: true });
+  return atomicWriteJson(projectConfigPath(dir), {
+    schema_version: PROJECT_SCHEMA_VERSION,
+    ...config,
+  }, { mode: 0o600 });
+}
+
+export function projectDir(root, projectId) {
+  return workspacePaths(root).project(projectId);
+}
+
+function normalizeProject(row) {
+  if (!row) return null;
+  const topic = row.topic && typeof row.topic === 'object' ? row.topic : {};
+  return {
+    ...row,
+    project_id: String(row.project_id || ''),
+    name: String(row.name || topic.book_name || row.project_id || ''),
+    db_name: String(row.db_name || ''),
+    db_user: String(row.db_user || ''),
+    dir: String(row.dir || ''),
+    status: String(row.status || 'active'),
+    topic,
+  };
+}
+
+async function connectAdmin(root) {
+  // startServer verifies the root credentials, and moves the workspace to a
+  // free port if another (possibly stale) SurrealDB is squatting on ours.
+  await startServer(root);
+  const workspace = readWorkspace(root);
+  const secrets = readSecrets(root);
+  const db = new Surreal({ engines: { ...createRemoteEngines() } });
+  await db.connect(rpcUrl(workspace));
+  await db.signin({
+    username: secrets.surreal?.username || 'root',
+    password: secrets.surreal?.password,
+  });
+  return { db, workspace, secrets };
+}
+
+const REGISTRY_DDL = [
+  `DEFINE TABLE IF NOT EXISTS ${REGISTRY_TABLE} SCHEMAFULL;`,
+  `DEFINE FIELD IF NOT EXISTS project_id ON ${REGISTRY_TABLE} TYPE string;`,
+  `DEFINE FIELD IF NOT EXISTS name ON ${REGISTRY_TABLE} TYPE string;`,
+  `DEFINE FIELD IF NOT EXISTS db_name ON ${REGISTRY_TABLE} TYPE string;`,
+  `DEFINE FIELD IF NOT EXISTS db_user ON ${REGISTRY_TABLE} TYPE string;`,
+  `DEFINE FIELD IF NOT EXISTS dir ON ${REGISTRY_TABLE} TYPE string;`,
+  `DEFINE FIELD IF NOT EXISTS status ON ${REGISTRY_TABLE} TYPE string DEFAULT 'active';`,
+  `DEFINE FIELD IF NOT EXISTS topic ON ${REGISTRY_TABLE} TYPE object FLEXIBLE;`,
+  `DEFINE FIELD IF NOT EXISTS created_at ON ${REGISTRY_TABLE} TYPE datetime VALUE time::now();`,
+  `DEFINE FIELD IF NOT EXISTS updated_at ON ${REGISTRY_TABLE} TYPE datetime VALUE time::now();`,
+  `DEFINE INDEX IF NOT EXISTS project_id_unique ON ${REGISTRY_TABLE} FIELDS project_id UNIQUE;`,
+  `DEFINE INDEX IF NOT EXISTS project_name_unique ON ${REGISTRY_TABLE} FIELDS name UNIQUE;`,
+];
+
+export async function withRegistry(root, fn) {
+  const { db, workspace } = await connectAdmin(root);
+  try {
+    await db.use({ namespace: workspace.surreal?.namespace || 'fancy', database: workspace.surreal?.registry_database || 'fancy_registry' });
+    for (const statement of REGISTRY_DDL) await db.query(statement);
+    return await fn(db, workspace);
+  } finally {
+    try { await db.close(); } catch { /* ignore */ }
+  }
+}
+
+export async function listProjects(root) {
+  return withRegistry(root, async (db) => {
+    const rows = await db.query(`SELECT * FROM ${REGISTRY_TABLE} WHERE status != 'deleted' ORDER BY name;`);
+    const list = Array.isArray(rows) && Array.isArray(rows[0]) ? rows[0] : [];
+    return list.map(normalizeProject);
+  });
+}
+
+export async function getProject(root, nameOrId) {
+  const key = String(nameOrId || '').trim();
+  if (!key) return null;
+  const projects = await listProjects(root);
+  const lower = key.toLowerCase();
+  return projects.find((row) => row.name === key
+    || row.project_id === key
+    || row.db_name === key
+    || row.dir === key
+    || path.basename(row.dir) === key
+    || row.name.toLowerCase() === lower)
+    || projects.find((row) => row.name.includes(key) || row.project_id.startsWith(key))
+    || null;
+}
+
+export async function findProjects(root, query) {
+  const key = String(query || '').trim();
+  const projects = await listProjects(root);
+  if (!key) return projects;
+  const lower = key.toLowerCase();
+  return projects.filter((row) => row.name.toLowerCase().includes(lower)
+    || row.project_id.startsWith(key)
+    || row.db_name === key
+    || path.basename(row.dir) === key);
+}
+
+async function assertNameAvailable(db, name, exceptId = null) {
+  const rows = await db.query(
+    `SELECT project_id, name FROM ${REGISTRY_TABLE} WHERE name = $name AND status != 'deleted';`,
+    { name },
+  );
+  const list = Array.isArray(rows) && Array.isArray(rows[0]) ? rows[0] : [];
+  const conflict = list.find((row) => row.project_id !== exceptId);
+  if (conflict) {
+    throw new ProjectError('PROJECT_NAME_EXISTS', '小说名已被占用：' + name + '（已有项目 UUID：' + conflict.project_id + '）。请更换小说名后重试。');
+  }
+}
+
+export async function createProject(root, opts = {}) {
+  const title = String(opts.title || opts.name || '').trim();
+  if (!title) throw new ProjectError('PROJECT_TITLE_REQUIRED', '创建项目时必须提供小说名。');
+  const projectId = opts.projectId || crypto.randomUUID();
+  const dbName = databaseName(projectId);
+  const dbUser = databaseUser(projectId);
+  const password = crypto.randomBytes(24).toString('base64url');
+  const dir = projectDir(root, projectId);
+  const topic = opts.topic && typeof opts.topic === 'object' ? opts.topic : {};
+
+  const result = await withRegistry(root, async (db, workspace) => {
+    await assertNameAvailable(db, title);
+    const namespace = workspace.surreal?.namespace || 'fancy';
+    await db.query(`DEFINE DATABASE IF NOT EXISTS ${dbName};`);
+    // DEFINE USER ... ON DATABASE is resolved against the connection's
+    // currently selected database. Switch to the project database before
+    // defining its user, then switch back to the registry.
+    await db.use({ namespace, database: dbName });
+    await db.query(`DEFINE USER IF NOT EXISTS ${dbUser} ON DATABASE PASSWORD '${password}' ROLES VIEWER;`);
+    await db.use({ namespace, database: workspace.surreal?.registry_database || 'fancy_registry' });
+    const created = await db.query(
+      `CREATE ${REGISTRY_TABLE} SET
+         project_id = $project_id,
+         name = $name,
+         db_name = $db_name,
+         db_user = $db_user,
+         dir = $dir,
+         status = 'active',
+         topic = $topic;`,
+      { project_id: projectId, name: title, db_name: dbName, db_user: dbUser, dir, topic },
+    );
+    const row = Array.isArray(created) && Array.isArray(created[0]) ? created[0][0] : null;
+    return { row: normalizeProject(row), namespace };
+  });
+
+  fs.mkdirSync(dir, { recursive: true });
+  fs.mkdirSync(path.join(dir, '导出'), { recursive: true });
+  fs.mkdirSync(path.join(dir, '设定'), { recursive: true });
+  writeProjectConfig(dir, {
+    project_id: projectId,
+    workspace: root,
+    database: dbName,
+    namespace: result.namespace,
+    db_user: dbUser,
+    created_at: localIsoString(),
+  });
+
+  const secrets = readSecrets(root);
+  secrets.projects = secrets.projects || {};
+  secrets.projects[projectId] = { username: dbUser, password };
+  atomicWriteJson(path.join(root, '.fancy', 'secrets.json'), secrets, { mode: 0o600 });
+
+  if (opts.makeActive !== false) setActiveProject(root, projectId);
+  return getProject(root, projectId);
+}
+
+export async function updateProjectTopic(root, nameOrId, topic) {
+  const project = await getProject(root, nameOrId);
+  if (!project) throw new ProjectError('PROJECT_NOT_FOUND', '未找到匹配的项目：' + nameOrId + '。可运行 /fancy-project list 查看当前工作区的项目。');
+  const value = topic && typeof topic === 'object' ? topic : {};
+  await withRegistry(root, async (db) => {
+    await db.query(
+      `UPDATE ${REGISTRY_TABLE} SET topic = $topic, updated_at = time::now() WHERE project_id = $id;`,
+      { topic: value, id: project.project_id },
+    );
+  });
+  try {
+    const { openStoryGraph } = await import('../plugins/fancy-story-builder/storydb/client.js');
+    const sdb = await openStoryGraph(project.dir, { project, admin: true });
+    try {
+      await sdb.query(
+        `UPDATE story:main SET payload.topic = $topic, title = $title, updated_at = time::now();`,
+        { topic: value, title: value.book_name || value.title || project.name },
+      );
+    } finally {
+      await sdb.close();
+    }
+  } catch { /* registry is authoritative for lookup */ }
+  return getProject(root, project.project_id);
+}
+
+export async function renameProject(root, nameOrId, newTitle) {
+  const title = String(newTitle || '').trim();
+  if (!title) throw new ProjectError('PROJECT_TITLE_REQUIRED', '新小说名不能为空。');
+  const project = await getProject(root, nameOrId);
+  if (!project) throw new ProjectError('PROJECT_NOT_FOUND', '未找到匹配的项目：' + nameOrId + '。可运行 /fancy-project list 查看当前工作区的项目。');
+  const topic = {
+    ...(project.topic || {}),
+    book_name: title,
+    title,
+  };
+  await withRegistry(root, async (db) => {
+    await assertNameAvailable(db, title, project.project_id);
+    await db.query(
+      `UPDATE ${REGISTRY_TABLE} SET name = $name, topic = $topic, updated_at = time::now()
+       WHERE project_id = $id;`,
+      { name: title, topic, id: project.project_id },
+    );
+  });
+  // Keep the story record in sync; if the project DB is unavailable, the
+  // registry rename still wins and the next open will repair it.
+  try {
+    const { openStoryGraph } = await import('../plugins/fancy-story-builder/storydb/client.js');
+    const sdb = await openStoryGraph(project.dir, { admin: true });
+    try {
+      await sdb.query('UPDATE story:main SET title = $title, updated_at = time::now();', { title });
+    } finally {
+      await sdb.close();
+    }
+  } catch { /* registry is authoritative for lookup */ }
+  return getProject(root, project.project_id);
+}
+
+export async function deleteProject(root, nameOrId, opts = {}) {
+  const project = await getProject(root, nameOrId);
+  if (!project) throw new ProjectError('PROJECT_NOT_FOUND', '未找到匹配的项目：' + nameOrId + '。可运行 /fancy-project list 查看当前工作区的项目。');
+  if (opts.confirm !== true) {
+    throw new ProjectError('CONFIRMATION_REQUIRED', '删除项目需要明确确认（confirm=true）。', { project });
+  }
+  await withRegistry(root, async (db) => {
+    await db.query(`REMOVE DATABASE ${project.db_name};`);
+    await db.query(`UPDATE ${REGISTRY_TABLE} SET status = 'deleted', updated_at = time::now() WHERE project_id = $id;`, { id: project.project_id });
+  });
+  const dir = path.resolve(project.dir || projectDir(root, project.project_id));
+  if (opts.purge === true) {
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+  } else if (fs.existsSync(dir)) {
+    const trash = path.join(workspacePaths(root).fancy, 'trash', `${project.project_id}-${Date.now()}`);
+    fs.mkdirSync(path.dirname(trash), { recursive: true });
+    try { fs.renameSync(dir, trash); } catch { /* ignore */ }
+  }
+  const active = getActiveProject(root);
+  if (active === project.project_id) setActiveProject(root, null);
+  return { project, removed: true, purged: opts.purge === true };
+}
+
+export async function setProjectActive(root, nameOrId) {
+  const project = await getProject(root, nameOrId);
+  if (!project) throw new ProjectError('PROJECT_NOT_FOUND', '未找到匹配的项目：' + nameOrId + '。可运行 /fancy-project list 查看当前工作区的项目。');
+  setActiveProject(root, project.project_id);
+  return project;
+}
+
+export function projectFromCwd(root, cwd) {
+  if (!cwd) return null;
+  let current = path.resolve(cwd);
+  const workspace = path.resolve(root);
+  for (;;) {
+    const config = readProjectConfig(current);
+    if (config) return { config, dir: current };
+    if (current === workspace) return null;
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+/**
+ * Resolve a project without requiring the registry when the cwd already points
+ * at a project directory. If only the workspace is known, use the active
+ * project or, when there is exactly one, that project.
+ */
+export async function resolveProject(opts = {}) {
+  const root = opts.workspace || resolveWorkspace({ cwd: opts.cwd, explicit: opts.explicitWorkspace, required: true });
+  const fromCwd = projectFromCwd(root, opts.cwd || process.cwd());
+  if (fromCwd) {
+    let record = null;
+    try { record = await getProject(root, fromCwd.config.project_id); } catch { /* registry may be down */ }
+    return {
+      ...(record || {}),
+      project_id: fromCwd.config.project_id,
+      name: (record && record.name) || fromCwd.config.project_id,
+      db_name: fromCwd.config.database,
+      db_user: fromCwd.config.db_user,
+      dir: fromCwd.dir,
+      config: fromCwd.config,
+      workspace: root,
+    };
+  }
+
+  if (opts.project) {
+    const project = await getProject(root, opts.project);
+    if (!project) throw new ProjectError('PROJECT_NOT_FOUND', '未找到匹配的项目：' + opts.project + '。可运行 /fancy-project list 查看当前工作区的项目。');
+    return { ...project, config: readProjectConfig(project.dir), workspace: root };
+  }
+
+  const active = getActiveProject(root);
+  if (active) {
+    const project = await getProject(root, active);
+    if (project) return { ...project, config: readProjectConfig(project.dir), workspace: root };
+  }
+
+  const projects = await listProjects(root);
+  if (projects.length === 1) {
+    return { ...projects[0], config: readProjectConfig(projects[0].dir), workspace: root };
+  }
+  if (!projects.length) {
+    throw new ProjectError('PROJECT_NOT_FOUND', '当前工作区尚未创建任何项目。请先运行 /fancy-topic setup 创建项目。');
+  }
+  throw new ProjectError(
+    'PROJECT_AMBIGUOUS',
+    '当前工作区存在多个项目，无法自动选择。请使用 --project <小说名|UUID> 指定项目，或先运行 /fancy-project use <小说名|UUID> 设置当前项目。',
+    { projects: projects.map((p) => ({ id: p.project_id, name: p.name })) },
+  );
+}
+
+export async function ensureProjectSchemaReady(project, opts = {}) {
+  const { openStoryGraph } = await import('../plugins/fancy-story-builder/storydb/client.js');
+  const sdb = await openStoryGraph(project.dir, { admin: true, ...opts });
+  try {
+    return sdb;
+  } catch (err) {
+    await sdb.close();
+    throw err;
+  }
+}
+
+export { WorkspaceError };