app/lib/binder.server.ts

Functions

Imports

It imports app/db/schema.ts, app/lib/books.server.ts, app/lib/novels/repo.server.ts, app/lib/people.server.ts, app/lib/roles.ts, app/lib/writing/binder.ts. Imported by app/lib/book-history.server.ts, app/routes/book.corkboard.tsx, app/routes/book.tsx.

Source

1// Reordering a book from the binder or the corkboard. The new order becomes
2// renames of the numbered files, all in ONE commit with the version of each file Carrel indexed, so a
3// move never splits across commits and never overwrites a change made elsewhere. After the commit,
4// Carrel's own records that name a path follow the file: the index, the flags, the AI drafts beside
5// it and the untyped-word count. The authorship record keeps the paths it was written with; a move is
6// recorded in book_moves, which a file's history follows back.
7
8import { and, eq, inArray } from "drizzle-orm";
9import { drizzle } from "drizzle-orm/d1";
10
11import { bookFiles, bookMoves, drafts } from "~/db/schema";
12import { listFiles, recheck, type BookProject } from "~/lib/books.server";
13import { GitConflict, type NovelsRepo } from "~/lib/novels/repo.server";
14import type { Viewer } from "~/lib/people.server";
15import { can } from "~/lib/roles";
16import { planRenames, type ChapterOrder, type Rename } from "~/lib/writing/binder";
17
18export type ReorderResult =
19  | { ok: true; renames: Rename[]; commit: string | null }
20  | { ok: false; reason: "stale" | "draft" | "conflict" | "failed"; message: string };
21
22/** The tables that name a book file by its path, and the column that holds it. */
23const PATH_COLUMNS = [
24  ["book_files", "path"],
25  ["findings", "path"],
26  ["ai_drafts", "item_id"],
27  ["untyped_words", "path"],
28] as const;
29
30export async function reorderBook(db: D1Database, repo: NovelsRepo, project: BookProject, viewer: Viewer, desired: ChapterOrder[]): Promise<ReorderResult> {
31  if (!can(project.role, "edit")) throw new Response("Forbidden", { status: 403 });
32  const files = await listFiles(db, project);
33  const plan = planRenames(
34    files.map((f) => f.path),
35    desired,
36  );
37  if (!plan.ok) return { ok: false, reason: "stale", message: plan.error };
38  if (plan.renames.length === 0) return { ok: true, renames: [], commit: null };
39
40  // A working draft is tied to its path and to the version it started from: moving the file under it
41  // would strand the draft, so the move waits until it is saved or discarded.
42  const froms = plan.renames.map((r) => r.from);
43  const held = await drizzle(db)
44    .select({ path: drafts.itemId })
45    .from(drafts)
46    .where(and(eq(drafts.projectId, project.id), inArray(drafts.itemId, froms)))
47    .all();
48  if (held.length > 0) {
49    const paths = [...new Set(held.map((h) => h.path))].sort();
50    return {
51      ok: false,
52      reason: "draft",
53      message: `${paths.join(", ")} ${paths.length === 1 ? "has" : "have"} a working draft in Carrel. Save it to Git or discard it, then move again.`,
54    };
55  }
56
57  const sha = new Map(files.map((f) => [f.path, f.sha]));
58  const changeId = crypto.randomUUID();
59  let commit: string;
60  try {
61    ({ commit } = await repo.commitMany({
62      renames: plan.renames.map((r) => ({ from: `${project.book}/${r.from}`, to: `${project.book}/${r.to}`, sha: sha.get(r.from)! })),
63      message: `Reorder ${project.book}: ${plan.renames.length} file${plan.renames.length === 1 ? "" : "s"} renumbered\n\nCarrel-Change: ${changeId}`,
64      author: { name: viewer.name || viewer.email, email: viewer.email },
65    }));
66  } catch (error) {
67    if (error instanceof GitConflict) {
68      return { ok: false, reason: "conflict", message: "The book changed in Git since Carrel last read it, so nothing was moved. Refresh the book from Git, then move again." };
69    }
70    console.error(JSON.stringify({ book: "reorder-failed", error: String(error) }));
71    return { ok: false, reason: "failed", message: "Git did not accept the move, so nothing was moved." };
72  }
73
74  // Two steps through a placeholder, so a file moving onto a path another file is leaving never
75  // meets it in the table.
76  const temp = (i: number) => `\u0000moving/${changeId}/${i}`;
77  const statements: D1PreparedStatement[] = [];
78  for (const [table, column] of PATH_COLUMNS) {
79    plan.renames.forEach((r, i) => statements.push(db.prepare(`UPDATE ${table} SET ${column} = ? WHERE project_id = ? AND ${column} = ?`).bind(temp(i), project.id, r.from)));
80    plan.renames.forEach((r, i) => statements.push(db.prepare(`UPDATE ${table} SET ${column} = ? WHERE project_id = ? AND ${column} = ?`).bind(r.to, project.id, temp(i))));
81  }
82  statements.push(
83    ...plan.renames.map((r) =>
84      db
85        .prepare("INSERT INTO book_moves (project_id, change_id, from_path, to_path, commit_sha, person_id) VALUES (?, ?, ?, ?, ?, ?)")
86        .bind(project.id, changeId, r.from, r.to, commit, viewer.id),
87    ),
88  );
89  await db.batch(statements);
90
91  // The reading order changed, so the timeline check reads every scene again.
92  await recheck(db, project.id, "all");
93  return { ok: true, renames: plan.renames, commit };
94}
95
96/** Every path this file has had, newest first, following the moves back from `path`. */
97export async function formerPaths(db: D1Database, projectId: number, path: string): Promise<string[]> {
98  const rows = await drizzle(db)
99    .select({ from: bookMoves.fromPath, to: bookMoves.toPath, id: bookMoves.id })
100    .from(bookMoves)
101    .where(eq(bookMoves.projectId, projectId))
102    .all();
103  const paths = [path];
104  // Newest move first; a path is followed back through each move that landed on it before.
105  const sorted = [...rows].sort((a, b) => b.id - a.id);
106  let current = path;
107  let before = Infinity;
108  for (;;) {
109    const move = sorted.find((m) => m.to === current && m.id < before);
110    if (!move || paths.includes(move.from) || paths.length > 50) break;
111    paths.push(move.from);
112    current = move.from;
113    before = move.id;
114  }
115  return paths;
116}
117
118/** The moves of this file, for its history: when it was renamed, by whom, from where, in which commit. */
119export async function movesOf(db: D1Database, projectId: number, paths: string[]) {
120  if (paths.length === 0) return [];
121  return drizzle(db)
122    .select({ from: bookMoves.fromPath, to: bookMoves.toPath, commit: bookMoves.commitSha, personId: bookMoves.personId, at: bookMoves.createdAt })
123    .from(bookMoves)
124    .where(and(eq(bookMoves.projectId, projectId), inArray(bookMoves.toPath, paths)))
125    .all();
126}
127
128/** The index rows the corkboard needs for one chapter. */
129export async function chapterSources(db: D1Database, projectId: number, paths: string[]) {
130  if (paths.length === 0) return new Map<string, string>();
131  const rows = await drizzle(db)
132    .select({ path: bookFiles.path, source: bookFiles.source })
133    .from(bookFiles)
134    .where(and(eq(bookFiles.projectId, projectId), inArray(bookFiles.path, paths)))
135    .all();
136  return new Map(rows.map((r) => [r.path, r.source]));
137}