app/lib/writing.server.ts

Functions

Imports

It imports app/db/schema.ts, app/lib/books.server.ts, app/lib/people.server.ts, app/lib/roles.ts, app/lib/writing/progress.ts, app/lib/writing/status.ts. Imported by app/lib/books.server.ts, app/routes/book.corkboard.tsx, app/routes/book.file.tsx, app/routes/book.outliner.tsx, app/routes/book.tsx.

Source

1// The writing desk's own records in D1: each project's status list, each person's
2// writing goal, the running count of words that reached a file without being typed, and the saves a
3// day's progress is counted from. Git holds the text and the headers; none of this is in Git.
4
5import { and, eq, gte, isNotNull, isNull, sql } from "drizzle-orm";
6import { drizzle } from "drizzle-orm/d1";
7
8import { authorship, statusLabels, untypedWords, writingGoals } from "~/db/schema";
9import type { BookProject } from "~/lib/books.server";
10import type { Viewer } from "~/lib/people.server";
11import { can } from "~/lib/roles";
12import { DEFAULT_GOAL, parseWritingDays, STREAK_HORIZON_DAYS, type Goal, type SaveEntry } from "~/lib/writing/progress";
13import { cleanLabels, STARTING_STATUSES, type StatusLabel } from "~/lib/writing/status";
14
15function forbid(): never {
16  throw new Response("Forbidden", { status: 403 });
17}
18
19// ---------- status lists
20
21/** The project's list, or the starting list for books while it has none of its own. */
22export async function statusList(db: D1Database, project: BookProject): Promise<{ labels: StatusLabel[]; edited: boolean }> {
23  if (!can(project.role, "read")) forbid();
24  const rows = await drizzle(db)
25    .select({ label: statusLabels.label, color: statusLabels.color })
26    .from(statusLabels)
27    .where(eq(statusLabels.projectId, project.id))
28    .orderBy(statusLabels.position)
29    .all();
30  if (rows.length === 0) return { labels: STARTING_STATUSES.book, edited: false };
31  return { labels: rows, edited: true };
32}
33
34/** Replaces the whole list. Files keep whatever `status:` they carry; a label taken away shows as written. */
35export async function saveStatusList(db: D1Database, project: BookProject, rows: { label: string; color: string | number }[]) {
36  if (!can(project.role, "edit")) forbid();
37  const clean = cleanLabels(rows);
38  if (!clean.ok) return clean;
39  await db.batch([
40    db.prepare("DELETE FROM status_labels WHERE project_id = ?").bind(project.id),
41    ...clean.labels.map((l, i) => db.prepare("INSERT INTO status_labels (project_id, position, label, color) VALUES (?, ?, ?, ?)").bind(project.id, i, l.label, l.color)),
42  ]);
43  return clean;
44}
45
46// ---------- goals
47
48export async function readGoal(db: D1Database, project: BookProject, viewer: Viewer): Promise<Goal> {
49  if (!can(project.role, "read")) forbid();
50  const row = await drizzle(db)
51    .select()
52    .from(writingGoals)
53    .where(and(eq(writingGoals.projectId, project.id), eq(writingGoals.personId, viewer.id)))
54    .get();
55  if (!row) return DEFAULT_GOAL;
56  return { mode: row.mode, dailyTarget: row.dailyTarget, writingDays: parseWritingDays(row.writingDays), allowNegative: row.allowNegative };
57}
58
59const MAX_DAILY_TARGET = 100_000;
60
61/** A person's own goal: anyone who may write in the project sets theirs, and no one else's. */
62export async function saveGoal(db: D1Database, project: BookProject, viewer: Viewer, input: { mode: string; dailyTarget: string; writingDays: string[]; allowNegative: boolean }) {
63  if (!can(project.role, "edit")) forbid();
64  const mode = input.mode === "deadline" ? "deadline" : "daily";
65  const raw = input.dailyTarget.replace(/[,_\s]/g, "");
66  const dailyTarget = raw === "" ? null : Number(raw);
67  if (dailyTarget !== null && (!Number.isInteger(dailyTarget) || dailyTarget < 1 || dailyTarget > MAX_DAILY_TARGET)) {
68    return { ok: false as const, error: `Give the daily target as a whole number of words from 1 to ${MAX_DAILY_TARGET.toLocaleString("en-US")}, or leave it empty.` };
69  }
70  const days = parseWritingDays(input.writingDays.join(""));
71  if (days.length === 0) return { ok: false as const, error: "Choose at least one writing day." };
72  const values = { mode, dailyTarget, writingDays: days.join(""), allowNegative: input.allowNegative } as const;
73  await drizzle(db)
74    .insert(writingGoals)
75    .values({ projectId: project.id, personId: viewer.id, ...values })
76    .onConflictDoUpdate({ target: [writingGoals.projectId, writingGoals.personId], set: values });
77  return { ok: true as const };
78}
79
80// ---------- words that were not typed
81
82/** Adds words that reached a file without being typed: a paste, a drop, an AI draft taken as the working draft. */
83export async function addUntyped(db: D1Database, projectId: number, personId: number, path: string, words: number) {
84  const n = Math.floor(words);
85  if (!Number.isFinite(n) || n <= 0) return;
86  await drizzle(db)
87    .insert(untypedWords)
88    .values({ projectId, personId, path, words: n })
89    .onConflictDoUpdate({ target: [untypedWords.projectId, untypedWords.personId, untypedWords.path], set: { words: sql`${untypedWords.words} + ${n}` } });
90}
91
92/** The count since the last save, cleared: a save takes it. */
93export async function takeUntyped(db: D1Database, projectId: number, personId: number, path: string): Promise<number> {
94  const where = and(eq(untypedWords.projectId, projectId), eq(untypedWords.personId, personId), eq(untypedWords.path, path));
95  const rows = await drizzle(db).delete(untypedWords).where(where).returning({ words: untypedWords.words });
96  return rows.reduce((n, r) => n + r.words, 0);
97}
98
99export async function clearUntyped(db: D1Database, projectId: number, personId: number, path: string) {
100  await takeUntyped(db, projectId, personId, path);
101}
102
103/** The words a field posted as not typed: a whole number from 0, anything else read as 0. */
104export function untypedField(value: FormDataEntryValue | null): number {
105  const n = Number(value ?? 0);
106  return Number.isInteger(n) && n > 0 && n < 10_000_000 ? n : 0;
107}
108
109// ---------- the saves a day is counted from
110
111/**
112 * This person's own saves in the project over the streak horizon, as typed and removed words. An AI
113 * client's saves and saves from before typed words were recorded are left out: they were not typed.
114 */
115export async function progressEntries(db: D1Database, project: BookProject, viewer: Viewer, now = new Date()): Promise<SaveEntry[]> {
116  if (!can(project.role, "read")) forbid();
117  // A day more than the horizon, so the oldest local day is whole in any zone.
118  const since = new Date(now.getTime() - (STREAK_HORIZON_DAYS + 1) * 86_400_000).toISOString();
119  const rows = await drizzle(db)
120    .select({ at: authorship.createdAt, typed: authorship.wordsTyped, removed: authorship.wordsRemoved })
121    .from(authorship)
122    .where(
123      and(
124        eq(authorship.projectId, project.id),
125        eq(authorship.personId, viewer.id),
126        isNull(authorship.client),
127        isNotNull(authorship.wordsTyped),
128        gte(authorship.createdAt, since),
129      ),
130    )
131    .orderBy(authorship.createdAt)
132    .all();
133  return rows.map((r) => ({ at: r.at, typed: r.typed ?? 0, removed: r.removed }));
134}