app/lib/book-history.server.ts

Functions

Imports

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

Source

1// A book file's history: every version Carrel saved, every move that renamed it,
2// and every commit made to it outside Carrel, newest first. Carrel's own records come first (the
3// authorship rows and book_moves, no GitHub call); Git adds what Carrel did not do, path by path back
4// through the file's old names, since GitHub's history of a path stops where it was renamed. Any
5// version's text is read from Git at its commit. Read-only, and a Reader may read all of it.
6
7import { and, eq, inArray } from "drizzle-orm";
8import { drizzle } from "drizzle-orm/d1";
9
10import { authorship, people } from "~/db/schema";
11import { formerPaths, movesOf } from "~/lib/binder.server";
12import type { BookProject } from "~/lib/books.server";
13import type { NovelsRepo } from "~/lib/novels/repo.server";
14import { can } from "~/lib/roles";
15
16export type BookVersion = {
17  /** The commit that made this version. */
18  version: string;
19  /** The file's path in the book when this version was made. */
20  path: string;
21  at: string;
22  author: string;
23  message: string;
24  kind: "carrel" | "move" | "outside";
25};
26
27/** How many of the file's former paths are asked of Git, and how many commits for each. */
28const PATHS_ASKED = 5;
29const COMMITS_PER_PATH = 30;
30
31export async function bookVersions(db: D1Database, repo: NovelsRepo | null, project: BookProject, path: string): Promise<{ versions: BookVersion[]; gitError: string | null }> {
32  if (!can(project.role, "read")) throw new Response("Forbidden", { status: 403 });
33  const paths = await formerPaths(db, project.id, path);
34  const d = drizzle(db);
35  const saves = await d
36    .select({ commit: authorship.commitSha, path: authorship.path, at: authorship.createdAt, name: people.name, email: people.email, client: authorship.client, added: authorship.wordsAdded, removed: authorship.wordsRemoved })
37    .from(authorship)
38    .innerJoin(people, eq(people.id, authorship.personId))
39    .where(and(eq(authorship.projectId, project.id), inArray(authorship.path, paths)))
40    .all();
41  const moves = await movesOf(db, project.id, paths);
42  const movers = moves.length
43    ? new Map((await d.select({ id: people.id, name: people.name, email: people.email }).from(people).where(inArray(people.id, [...new Set(moves.map((m) => m.personId))])).all()).map((p) => [p.id, p.name || p.email]))
44    : new Map<number, string>();
45
46  const byCommit = new Map<string, BookVersion>();
47  for (const s of saves) {
48    const who = s.name || s.email;
49    byCommit.set(s.commit, {
50      version: s.commit,
51      path: s.path,
52      at: s.at,
53      author: s.client ? `${s.client} (AI, for ${who})` : who,
54      message: `Saved in Carrel: ${s.added} word${s.added === 1 ? "" : "s"} added, ${s.removed} removed`,
55      kind: "carrel",
56    });
57  }
58  for (const m of moves) {
59    if (!byCommit.has(m.commit)) byCommit.set(m.commit, { version: m.commit, path: m.to, at: m.at, author: movers.get(m.personId) ?? "", message: `Moved from ${m.from}`, kind: "move" });
60  }
61
62  let gitError: string | null = null;
63  if (repo) {
64    try {
65      for (const p of paths.slice(0, PATHS_ASKED)) {
66        for (const c of await repo.history(`${project.book}/${p}`, COMMITS_PER_PATH)) {
67          if (!byCommit.has(c.sha)) byCommit.set(c.sha, { version: c.sha, path: p, at: c.at, author: c.author, message: c.message.split("\n")[0] || "No message", kind: "outside" });
68        }
69      }
70    } catch (error) {
71      gitError = `Git did not answer (${error instanceof Error ? error.message : String(error)}), so only the versions Carrel recorded are listed.`;
72    }
73  }
74  const versions = [...byCommit.values()].sort((a, b) => (a.at < b.at ? 1 : a.at > b.at ? -1 : 0));
75  return { versions, gitError };
76}
77
78/** A version's text, read from Git at its commit; null when Git does not hold the file there. */
79export async function readVersion(repo: NovelsRepo, project: BookProject, version: BookVersion): Promise<string | null> {
80  if (!can(project.role, "read")) throw new Response("Forbidden", { status: 403 });
81  return (await repo.readAt(`${project.book}/${version.path}`, version.version))?.source ?? null;
82}