app/lib/carrel/publication-handler.server.ts

Functions

Imports

It imports app/db/publications.ts, app/lib/carrel/content-kinds.server.ts, app/lib/carrel/errors.server.ts, app/lib/carrel/front-matter-lines.ts, app/lib/editor/github.server.ts, app/lib/publications/parse.mjs, app/lib/publications/paths.mjs, app/lib/publications/save.server.ts, app/lib/publications/types.ts. Imported by app/lib/carrel/site-adapter.server.ts.

Source

1// The publication kind of Carrel's /content group (docs/PUBLICATIONS.md): ids are `publication.<slug>` (the
2// registry encodes them), and a write goes through savePublication, the one path a publication reaches the
3// repository by. Nothing here writes around it, and there is no editor in the site's admin for this kind.
4
5import { VersionConflictError } from "@dustinedwards/site-api";
6import type { ContentStatus, ContentSummary, WriteResult } from "@dustinedwards/site-api";
7
8import { listPublicationIdentities } from "~/db/publications";
9import type { ContentKindHandler } from "~/lib/carrel/content-kinds.server";
10import { asSiteApiError } from "~/lib/carrel/errors.server";
11import { withPublication } from "~/lib/carrel/front-matter-lines";
12import { fileRevisions, fileRevisionSource, readFile } from "~/lib/editor/github.server";
13import { parsePublication, publicationPath } from "~/lib/publications/parse.mjs";
14import { paperPath } from "~/lib/publications/paths.mjs";
15import { fileIsDraft, savePublication } from "~/lib/publications/save.server";
16import type { Publication } from "~/lib/publications/types";
17
18type PublicationEnv = Env & { GITHUB_TOKEN?: string };
19
20/** A revision's version is a commit sha; an item's own version is the blob sha of its file. */
21
22/** The deposited date at its own precision, as the timestamp the contract wants (a partial date reads as its first day). */
23function timestampOf(date: string | null): string | null {
24  if (!date) return null;
25  const full = date.length === 4 ? `${date}-01-01` : date.length === 7 ? `${date}-01` : date;
26  const at = Date.parse(`${full}T00:00:00.000Z`);
27  return Number.isNaN(at) ? null : new Date(at).toISOString();
28}
29
30export function publicationHandler(env: PublicationEnv): ContentKindHandler {
31  /** One write through savePublication as the Carrel actor, answered in the package's terms. */
32  async function write(slug: string, changeId: string, raw: string, expectedVersion: string | null): Promise<WriteResult> {
33    try {
34      const saved = await savePublication(env, {
35        slug,
36        raw,
37        expectedBlobSha: expectedVersion ?? undefined,
38        isNew: expectedVersion === null,
39        actor: { kind: "carrel", changeId },
40      });
41      return { id: slug, version: saved.sourceBlobSha, status: saved.draft ? "draft" : "published", changeId };
42    } catch (error) {
43      return asSiteApiError(env, error, publicationPath(slug));
44    }
45  }
46
47  /** The stored file for a write that names a version; a version for a missing id is a conflict. */
48  async function existing(slug: string): Promise<string> {
49    const file = await readFile(env, publicationPath(slug));
50    if (!file) throw new VersionConflictError(null);
51    return file.content;
52  }
53
54  return {
55    kind: "publication",
56
57    async list(query) {
58      const needle = query.q?.toLowerCase();
59      const rows = await listPublicationIdentities(env);
60      const summaries: ContentSummary[] = rows.map((row) => {
61        const record = JSON.parse(row.record) as Publication;
62        const status: ContentStatus = row.status === "draft" ? "draft" : "published";
63        return {
64          id: row.slug,
65          kind: "publication",
66          title: row.title,
67          status,
68          path: status === "draft" ? null : paperPath(row.slug),
69          publishAt: null,
70          publishedAt: status === "published" ? timestampOf(record.publishedDate) : null,
71          updatedAt: row.syncedAt ? row.syncedAt.toISOString() : null,
72        };
73      });
74      return summaries
75        .filter((s) => !query.status || s.status === query.status)
76        .filter((s) => !needle || s.title.toLowerCase().includes(needle) || s.id.includes(needle));
77    },
78
79    async get(slug) {
80      const file = await readFile(env, publicationPath(slug));
81      if (!file) return null;
82      const rows = await listPublicationIdentities(env);
83      const { data } = parsePublication({ file: publicationPath(slug), raw: file.content });
84      const draft = data.draft === true;
85      const stored = rows.find((row) => row.slug === slug);
86      return {
87        id: slug,
88        kind: "publication",
89        title: typeof data.title === "string" ? data.title : slug,
90        status: draft ? "draft" : "published",
91        path: draft ? null : paperPath(slug),
92        publishAt: null,
93        publishedAt: draft ? null : timestampOf(typeof data.publishedDate === "string" ? data.publishedDate : null),
94        updatedAt: stored?.syncedAt ? stored.syncedAt.toISOString() : null,
95        format: "markdown",
96        source: file.content,
97        version: file.sha,
98      };
99    },
100
101    // Keeps the stored status, as a post does: a save to a live paper edits it live, and a new record
102    // starts as a draft. First publication is a separate call, which Carrel's key may make.
103    async saveDraft(slug, input) {
104      const file = await readFile(env, publicationPath(slug));
105      if (input.expectedVersion === null && file) throw new VersionConflictError(file.sha);
106      if (input.expectedVersion !== null && !file) throw new VersionConflictError(null);
107      const raw = withPublication(input.source, { draft: file ? fileIsDraft(file.content) : true });
108      return write(slug, input.changeId, raw, input.expectedVersion);
109    },
110
111    async publish(slug, input) {
112      // Read even when source is sent: a version for an id that does not exist is a conflict.
113      const stored = await existing(slug);
114      return write(slug, input.changeId, withPublication(input.source ?? stored, { draft: false }), input.expectedVersion);
115    },
116
117    async unpublish(slug, input) {
118      const source = await existing(slug);
119      return write(slug, input.changeId, withPublication(source, { draft: true }), input.expectedVersion);
120    },
121
122    revisions(slug) {
123      return fileRevisions(env, publicationPath(slug));
124    },
125
126    revisionSource(slug, version) {
127      return fileRevisionSource(env, publicationPath(slug), version);
128    },
129  };
130}