src/server/content.ts

Functions

Imports

It imports src/adapter.ts, src/contract.ts, src/server/http.ts. Imported by src/server.ts.

Source

1// The meta route, the content routes and the preview: what every site serves.
2
3import { createTwoFilesPatch } from "diff";
4import { capabilitiesOf, NotFoundError, type SiteAdapter } from "../adapter.js";
5import {
6  ContentDeleteQuery,
7  ContentDeleteResult,
8  ContentDoc,
9  ContentId,
10  ContentList,
11  ContentTagsInput,
12  Diff,
13  DiffQuery,
14  ListQuery,
15  Meta,
16  PACKAGE_VERSION,
17  PreviewInput,
18  PublishInput,
19  RevisionList,
20  RevisionSource,
21  SaveDraftInput,
22  ScheduleInput,
23  UnpublishInput,
24  Version,
25  WriteResult,
26  schemaHash,
27} from "../contract.js";
28import { BASE_HEADERS, ContractBreach, ID, checked, fail, json, pathParam, readBody, readQuery, type Route } from "./http.js";
29
30export function contentRoutes(adapter: SiteAdapter): Route[] {
31  const id = (m: RegExpMatchArray) => pathParam(m[1], ContentId, "content id");
32
33  const write = async (
34    m: RegExpMatchArray,
35    request: Request,
36    run: (contentId: string, request: Request) => Promise<unknown>,
37  ) => json(200, checked(WriteResult, await run(id(m), request), "write result"));
38
39  return [
40    {
41      method: "GET",
42      pattern: /^\/meta$/,
43      run: async () =>
44        json(200, checked(Meta, {
45          api: "carrel-site-api",
46          packageVersion: PACKAGE_VERSION,
47          schemaHash: await schemaHash(),
48          site: adapter.site,
49          capabilities: capabilitiesOf(adapter),
50        }, "meta")),
51    },
52    {
53      method: "GET",
54      pattern: /^\/content$/,
55      run: async (_m, url) => json(200, checked(ContentList, await adapter.content.list(readQuery(url, ListQuery)), "content list")),
56    },
57    {
58      method: "GET",
59      pattern: new RegExp(`^/content/${ID}$`),
60      run: async (m) => {
61        const doc = await adapter.content.get(id(m));
62        if (!doc) throw new NotFoundError();
63        return json(200, checked(ContentDoc, doc, "content"));
64      },
65    },
66    {
67      method: "PUT",
68      pattern: new RegExp(`^/content/${ID}/draft$`),
69      run: (m, _u, r) => write(m, r, async (i, req) => adapter.content.saveDraft(i, await readBody(req, SaveDraftInput))),
70    },
71    {
72      method: "POST",
73      pattern: new RegExp(`^/content/${ID}/publish$`),
74      run: (m, _u, r) => write(m, r, async (i, req) => adapter.content.publish(i, await readBody(req, PublishInput))),
75    },
76    {
77      method: "POST",
78      pattern: new RegExp(`^/content/${ID}/schedule$`),
79      run: (m, _u, r) => write(m, r, async (i, req) => adapter.content.schedule(i, await readBody(req, ScheduleInput))),
80    },
81    {
82      method: "POST",
83      pattern: new RegExp(`^/content/${ID}/unpublish$`),
84      run: (m, _u, r) => write(m, r, async (i, req) => adapter.content.unpublish(i, await readBody(req, UnpublishInput))),
85    },
86    {
87      method: "GET",
88      pattern: new RegExp(`^/content/${ID}/revisions$`),
89      run: async (m) => {
90        const items = await adapter.content.revisions(id(m));
91        if (!items) throw new NotFoundError();
92        return json(200, checked(RevisionList, { items }, "revisions"));
93      },
94    },
95    {
96      method: "GET",
97      pattern: new RegExp(`^/content/${ID}/revisions/${ID}$`),
98      run: async (m) => {
99        const contentId = id(m);
100        const version = pathParam(m[2], Version, "version");
101        const source = await adapter.content.revisionSource(contentId, version);
102        if (source === null) throw new NotFoundError("No such version.");
103        return json(200, checked(RevisionSource, { id: contentId, version, source }, "revision source"));
104      },
105    },
106    {
107      method: "DELETE",
108      pattern: new RegExp(`^/content/${ID}$`),
109      run: async (m, url) => {
110        const contentId = id(m);
111        // A site with no delete answers 501 whatever the query says.
112        if (!adapter.content.delete) return fail("not-implemented", "This site does not delete content through the API.");
113        const query = readQuery(url, ContentDeleteQuery);
114        await adapter.content.delete(contentId, query);
115        return json(200, checked(ContentDeleteResult, { id: contentId, deleted: true, changeId: query.changeId }, "content delete"));
116      },
117    },
118    {
119      method: "PUT",
120      pattern: new RegExp(`^/content/${ID}/tags$`),
121      run: async (m, _u, request) => {
122        const contentId = id(m);
123        if (!adapter.content.setTags) return fail("not-implemented", "This site does not keep tags on posts through the API.");
124        const input = await readBody(request, ContentTagsInput);
125        // One spelling per tag: the first one given wins, so "News" and "news" are one tag.
126        const seen = new Set<string>();
127        const tags = input.tags.filter((t) => !seen.has(t.toLowerCase()) && seen.add(t.toLowerCase()));
128        return json(200, checked(WriteResult, await adapter.content.setTags(contentId, { ...input, tags }), "content tags"));
129      },
130    },
131    {
132      method: "GET",
133      pattern: new RegExp(`^/content/${ID}/diff$`),
134      run: async (m, url) => {
135        const contentId = id(m);
136        const query = readQuery(url, DiffQuery);
137        const current = await adapter.content.get(contentId);
138        if (!current) throw new NotFoundError();
139        const to = query.to ?? current.version;
140        const [before, after] = await Promise.all([
141          adapter.content.revisionSource(contentId, query.from),
142          to === current.version ? current.source : adapter.content.revisionSource(contentId, to),
143        ]);
144        if (before === null || after === null) throw new NotFoundError("No such version.");
145        const patch = createTwoFilesPatch(`${contentId}@${query.from}`, `${contentId}@${to}`, before, after);
146        return json(200, checked(Diff, { id: contentId, from: query.from, to, patch }, "diff"));
147      },
148    },
149    {
150      method: "POST",
151      pattern: /^\/preview$/,
152      run: async (_m, _u, request) => {
153        const html = await adapter.preview.render(await readBody(request, PreviewInput));
154        if (typeof html !== "string") throw new ContractBreach("preview: not a string");
155        return new Response(html, {
156          status: 200,
157          headers: { ...BASE_HEADERS, "content-type": "text/html; charset=utf-8" },
158        });
159      },
160    },
161  ];
162}