app/lib/legal.server.ts

Functions

Imports

It imports app/db/schema.ts, app/lib/legal.ts, app/lib/people.server.ts, app/lib/projects.server.ts, app/lib/roles.ts, app/lib/sites.server.ts. Imported by app/lib/content.server.ts, app/routes/editor.tsx, app/routes/legal.tsx.

Source

1// The shared sections of legal pages, and what a write to a legal page needs from them. The
2// sections live here and are the Owner's to change; a page picks them up when it is next published.
3
4import { asc, eq } from "drizzle-orm";
5import { drizzle } from "drizzle-orm/d1";
6
7import { legalSections } from "~/db/schema";
8import type { ContentDoc } from "@dustinedwards/site-api";
9import { expandShared, legalTypeOf, pathOf, prepareLegalWrite, SECTION_KEY, valuesOf, type SharedSection } from "~/lib/legal";
10import { splitSource } from "@dustinedwards/site-api/frontmatter";
11import type { Viewer } from "~/lib/people.server";
12import type { SiteProject } from "~/lib/projects.server";
13import { can } from "~/lib/roles";
14import { siteEntry } from "~/lib/sites.server";
15
16export type StoredSection = SharedSection & { updatedAt: string };
17
18export async function listSections(db: D1Database): Promise<StoredSection[]> {
19  return drizzle(db)
20    .select({ key: legalSections.key, title: legalSections.title, body: legalSections.body, updatedAt: legalSections.updatedAt })
21    .from(legalSections)
22    .orderBy(asc(legalSections.key))
23    .all();
24}
25
26export type SectionOutcome = { ok: true } | { ok: false; message: string };
27
28/** Shared text reaches every site's public page, so only the Owner changes it. */
29export async function saveSection(db: D1Database, project: { role: SiteProject["role"] }, viewer: Viewer, input: { key: string; title: string; body: string }): Promise<SectionOutcome> {
30  if (!can(project.role, "manage")) throw new Response("Forbidden", { status: 403 });
31  const key = input.key.trim();
32  const title = input.title.trim();
33  const body = input.body.replace(/\r\n/g, "\n").trim();
34  if (!SECTION_KEY.test(key)) return { ok: false, message: "A section's name is lowercase words joined by hyphens, like cloudflare-hosting." };
35  if (!title || !body) return { ok: false, message: "A section needs a title and its text." };
36  const dash = /[–—]/.exec(body + title);
37  if (dash) return { ok: false, message: `The text has a wide dash (${dash[0]}); the site's pages refuse it. Use a comma, period or colon.` };
38  await drizzle(db)
39    .insert(legalSections)
40    .values({ key, title, body, updatedBy: viewer.id })
41    .onConflictDoUpdate({ target: legalSections.key, set: { title, body, updatedBy: viewer.id, updatedAt: new Date().toISOString() } });
42  return { ok: true };
43}
44
45export async function deleteSection(db: D1Database, project: { role: SiteProject["role"] }, key: string): Promise<void> {
46  if (!can(project.role, "manage")) throw new Response("Forbidden", { status: 403 });
47  await drizzle(db).delete(legalSections).where(eq(legalSections.key, key));
48}
49
50export type LegalCheck = { ok: true; source: string } | { ok: false; message: string };
51
52/**
53 * What Carrel does to a write before the site sees it, for a legal page or an item the site keeps
54 * public: refuse to take a kept-public page down or move it, then expand shared sections and stamp
55 * `last_updated`. Any other item passes through unchanged.
56 */
57export async function checkLegalWrite(
58  db: D1Database,
59  project: SiteProject,
60  itemId: string,
61  request: { action: "save" | "publish" | "schedule" | "unpublish"; source?: string },
62  current: ContentDoc | null,
63  now: Date,
64): Promise<LegalCheck> {
65  const keptPublic = siteEntry(project.site).keepPublic.includes(itemId);
66  if (keptPublic && request.action === "unpublish") {
67    return { ok: false, message: "This page is the license named by the site's data. Carrel keeps it public; change its wording instead." };
68  }
69  const source = request.source;
70  if (source === undefined) return { ok: true, source: "" };
71  const legal = keptPublic || legalTypeOf(source) !== null || (current !== null && legalTypeOf(current.source) !== null);
72  if (!legal) return { ok: true, source };
73  if (current && pathOf(current.source) !== pathOf(source)) {
74    return { ok: false, message: `A legal page's path is fixed in Carrel (${pathOf(current.source) ?? "none"}): the site's code and its data name it.` };
75  }
76  if (request.action === "schedule") return { ok: true, source };
77  const live = request.action === "publish" || (request.action === "save" && current !== null && current.status !== "draft");
78  const prepared = prepareLegalWrite({
79    source,
80    stored: current?.source ?? null,
81    storedPublic: current !== null && current.status !== "draft",
82    sections: await listSections(db),
83    public: live,
84    today: now.toISOString().slice(0, 10),
85  });
86  return prepared.ok ? { ok: true, source: prepared.source } : prepared;
87}
88
89/** Whether a page's body still matches what its shared sections now say, for the Legal tab. */
90export async function sectionsCurrent(db: D1Database, source: string): Promise<boolean> {
91  const body = splitSource(source).body;
92  return expandShared(body, await listSections(db), valuesOf(source)).text === body;
93}