app/lib/editor/action.server.ts

Functions

Imports

It imports app/lib/editor/frontmatter.ts, app/lib/editor/intent.mjs, app/lib/editor/publish-policy.mjs, app/lib/editor/publish.server.ts, app/lib/error-message.mjs. Imported by app/routes/admin.posts.$slug.edit.tsx, app/routes/admin.posts.new.tsx.

Source

1import {
2  EditorError,
3  FirstPublishConfirmationRequired,
4  GitHubError,
5  currentHead,
6  savePost,
7  validateAndRender,
8} from "./publish.server";
9import { FrontmatterError, fieldsFromForm, serializePost, type PostFields } from "./frontmatter";
10import type { Actor, SaveOutcome } from "./publish-policy.mjs";
11import { readIntent } from "./intent.mjs";
12import { DRAFT_BY_INTENT, PUBLISH_CONFIRMED_INTENT } from "capsomer/publish-transition";
13import { errorMessage } from "~/lib/error-message.mjs";
14
15type EditorActionResult =
16  | { kind: "preview"; fields: PostFields; previewHtml: string; headSha: string }
17  | { kind: "problem"; fields: PostFields; problem: { message: string; field?: string; line?: number; conflict?: boolean }; headSha: string }
18  /** Carries the fields back so the author's unsaved body survives the confirmation round trip. */
19  | { kind: "confirm-publish"; fields: PostFields; headSha: string }
20  | {
21      kind: "saved";
22      slug: string;
23      outcome: SaveOutcome;
24      commitSha: string;
25      firstPublished: string | null;
26    };
27
28export async function handleEditorAction(
29  env: Env & { GITHUB_TOKEN?: string },
30  request: Request,
31  actor: Actor,
32): Promise<EditorActionResult> {
33  const form = await request.formData();
34  const fields = fieldsFromForm(form);
35  // An absent or unknown intent is refused, never defaulted: a default here would be a write.
36  const rawIntent = readIntent(form);
37  const isNew = form.get("isNew") === "1";
38  const submittedHead = String(form.get("headSha") ?? "");
39
40  const fail = async (message: string, extra: { field?: string; line?: number; conflict?: boolean } = {}) => {
41    // Re-read head so a retry after a conflict is against current state. A failed re-read keeps the
42    // submitted head and says so, because a retry against it may then report a conflict.
43    let headSha = submittedHead;
44    let note = "";
45    try {
46      headSha = await currentHead(env);
47    } catch (error) {
48      console.error(JSON.stringify({ alert: "editor-head-reread-failed", detail: errorMessage(error) }));
49      note =
50        ` (The repository head could not be re-read: ` +
51        `${errorMessage(error)}. A retry may report a conflict.)`;
52    }
53    return { kind: "problem" as const, fields, problem: { message: message + note, ...extra }, headSha };
54  };
55
56  if (rawIntent === null) {
57    return fail(
58      "This form submitted no intent, so nothing was saved. Every control names " +
59        "what it does; a request without one is malformed and is refused rather " +
60        "than assumed to be a save.",
61    );
62  }
63  const intent = rawIntent;
64
65  if (intent !== "preview" && !(intent in DRAFT_BY_INTENT)) {
66    return fail(
67      `This form submitted an intent this editor does not recognize ("${intent}"), ` +
68        "so nothing was saved. The intent names the transition, including whether " +
69        "the post ends up public, and a request naming one that does not exist is " +
70        "refused rather than run with a guess.",
71    );
72  }
73
74  try {
75    // Inside the try: a field that would reshape the frontmatter is refused as a problem on that field.
76    const raw = serializePost(fields);
77    if (intent === "preview") {
78      const record = await validateAndRender(env, fields.slug, raw);
79      return { kind: "preview", fields, previewHtml: record.html, headSha: submittedHead };
80    }
81
82    const saved = await savePost(env, {
83      slug: fields.slug,
84      raw,
85      expectedHeadSha: submittedHead || null,
86      isNew,
87      actor,
88      // Only the confirmed intent answers yes, so a plain publish lands on the confirmation step.
89      firstPublishConfirmed: intent === PUBLISH_CONFIRMED_INTENT,
90    });
91    return {
92      kind: "saved",
93      slug: fields.slug,
94      outcome: saved.outcome,
95      commitSha: saved.commitSha,
96      firstPublished: saved.firstPublished,
97    };
98  } catch (error) {
99    // submittedHead, not a re-read head: a commit that landed underneath is then reported as a
100    // conflict instead of being silently rebased by the act of confirming.
101    if (error instanceof FirstPublishConfirmationRequired) {
102      return { kind: "confirm-publish", fields, headSha: submittedHead };
103    }
104    if (error instanceof EditorError) {
105      return fail(error.message, { field: error.field, line: error.line });
106    }
107    if (error instanceof FrontmatterError) {
108      return fail(error.message, { field: error.field });
109    }
110    if (error instanceof GitHubError) {
111      return fail(error.message, { conflict: error.conflict });
112    }
113    // Not a recognized failure: logged with its stack, since the editor shows only the message.
114    console.error(JSON.stringify({ alert: "editor-action-unrecognized-error", detail: errorMessage(error) }));
115    return fail(errorMessage(error));
116  }
117}