app/lib/admin/posts-actions.server.ts

Functions

Imports

It imports app/db/index.ts, app/lib/admin/bulk-tag.ts, app/lib/content/slug.mjs, app/lib/editor/duplicate.mjs, app/lib/editor/frontmatter.ts, app/lib/editor/github.server.ts, app/lib/editor/publish-policy.mjs, app/lib/editor/publish.server.ts, app/lib/error-message.mjs, app/lib/search/ask-guard.server.ts, app/lib/search/ask.server.ts. Imported by app/routes/admin.posts._index.tsx.

Source

1import { redirect } from "react-router";
2
3import { listAllPostsForAdmin } from "~/db";
4import { applyBulkTag } from "~/lib/admin/bulk-tag";
5import { postPath } from "~/lib/content/slug.mjs";
6import { copySlugCandidates } from "~/lib/editor/duplicate.mjs";
7import { parsePost, parseTagInput, serializePost } from "~/lib/editor/frontmatter";
8import { readFile } from "~/lib/editor/github.server";
9import type { Actor } from "~/lib/editor/publish-policy.mjs";
10import { deletePost, regenerateAllFromRepo, savePost } from "~/lib/editor/publish.server";
11import { errorMessage } from "~/lib/error-message.mjs";
12import { askAvailable, pruneAskCorpus, syncAskCorpus } from "~/lib/search/ask.server";
13import { readAskBudget, resetAskBudget } from "~/lib/search/ask-guard.server";
14
15/*
16 * One handler per intent of the posts list's action. The route keeps the dispatch and, for its two
17 * destructive intents, the typed confirmation: check:destructive reads both off the route's own
18 * action, so a handler here runs only once the route has let it.
19 */
20
21/* `failed` picks the live region: a failure interrupts as an alert, a result waits as a status. */
22type Message = { message: string; failed?: true };
23
24/** Appended when a write landed but its cache purge did not: the public pages are stale until expiry. */
25function unpurgedNote(count: number) {
26  return count > 0
27    ? ` The cache purge failed for ${count} post(s), so public pages may show the old version until their cache expires.`
28    : "";
29}
30
31export async function regeneratePosts(env: Env): Promise<Message> {
32  try {
33    const { synced, removed, unpurged } = await regenerateAllFromRepo(env);
34    return {
35      message:
36        `Re-rendered ${synced} posts from the repository` +
37        (removed > 0 ? ` and removed ${removed} no longer in it` : "") +
38        "." +
39        unpurgedNote(unpurged),
40    };
41  } catch (error) {
42    return {
43      message: `Regenerate failed. ${errorMessage(error)}`,
44      failed: true,
45    };
46  }
47}
48
49/** The post count the sync confirmation shows: what the index will hold afterwards. */
50export async function askSyncConfirmCount(env: Env) {
51  const posts = await listAllPostsForAdmin(env);
52  return posts.length;
53}
54
55/** Runs the sync the route has confirmed: upload every record, then prune what this run did not upload. */
56export async function syncAskIndex(env: Env): Promise<Message> {
57  try {
58    const { uploaded, keys, failed, cacheDropped } = await syncAskCorpus(env);
59    const removed = await pruneAskCorpus(env, keys);
60    return {
61      message:
62        `Uploaded ${uploaded} search records to AI Search` +
63        (removed.length > 0 ? `, removed ${removed.length} stale item(s)` : "") +
64        `, dropped ${cacheDropped} cached answer(s).` +
65        // Named, so a transient that outlived its retries is not read as a finished sync.
66        (failed.length > 0
67          ? ` FAILED after retries: ${failed.map((f) => f.key).join(", ")}. Run the sync again.`
68          : ""),
69      ...(failed.length > 0 ? { failed: true as const } : {}),
70    };
71  } catch (error) {
72    return {
73      message: `Ask sync failed. ${errorMessage(error)}`,
74      failed: true,
75    };
76  }
77}
78
79/*
80 * Not a back door to a first publication: the copy is written with `draft: true`, and
81 * `forceFirstPublished` removes the key rather than carrying it across.
82 */
83export async function duplicatePost(env: Env, form: FormData, actor: Actor) {
84  const slug = String(form.get("slug") ?? "");
85  const file = await readFile(env, postPath(slug));
86  if (!file) {
87    return {
88      message: `No post file exists for "${slug}", so there is nothing to copy.`,
89      failed: true as const,
90    };
91  }
92  const fields = parsePost(file.content);
93
94  /* Probed against the repository, not D1: D1 is derived, and the file is what `savePost` refuses on. */
95  let target: string | null = null;
96  const candidates = copySlugCandidates(slug);
97  for (const candidate of candidates) {
98    if (!(await readFile(env, postPath(candidate)))) {
99      target = candidate;
100      break;
101    }
102  }
103  if (!target) {
104    return {
105      message:
106        `Could not find a free slug for a copy of "${slug}": the first ` +
107        `${candidates.length} candidates are all taken. Delete some copies first.`,
108      failed: true as const,
109    };
110  }
111
112  try {
113    await savePost(env, {
114      slug: target,
115      raw: serializePost({ ...fields, slug: target, draft: true, firstPublished: "" }),
116      isNew: true,
117      actor,
118    });
119    return redirect(`/admin/posts/${target}/edit`);
120  } catch (error) {
121    return {
122      message: `Duplicate failed. ${errorMessage(error)}`,
123      failed: true as const,
124    };
125  }
126}
127
128/*
129 * No republish here: `first_published` is frontmatter, not a D1 column, so this list cannot tell
130 * a never-published draft from a withdrawn one.
131 */
132export async function unpublishPost(env: Env, form: FormData, actor: Actor): Promise<Message> {
133  const slug = String(form.get("slug") ?? "");
134  const file = await readFile(env, postPath(slug));
135  if (!file) return { message: `No post file exists for "${slug}".`, failed: true };
136  const fields = parsePost(file.content);
137  // The committed file decides, not the rendered row: another tab may already have withdrawn it.
138  if (fields.draft) return { message: `"${slug}" is already a draft. Nothing changed.` };
139
140  try {
141    const { purged } = await savePost(env, {
142      slug,
143      raw: serializePost({ ...fields, draft: true }),
144      isNew: false,
145      actor,
146    });
147    return {
148      message:
149        `Unpublished "${slug}". It is a draft now, so it is off the public site, ` +
150        `the feeds and the sitemap. Republish it from its editor.` +
151        unpurgedNote(purged === false ? 1 : 0),
152    };
153  } catch (error) {
154    return {
155      message: `Unpublish failed. ${errorMessage(error)}`,
156      failed: true,
157    };
158  }
159}
160
161/** Deletes the selection the route has confirmed, one post at a time through the per-post writer. */
162export async function bulkDeletePosts(env: Env, slugs: string[], actor: Actor): Promise<Message> {
163  const failed: string[] = [];
164  let done = 0;
165  let unpurged = 0;
166  const askFailures: string[] = [];
167  for (const slug of slugs) {
168    try {
169      const { purged, askRemoval } = await deletePost(env, { slug, actor });
170      done += 1;
171      if (purged === false) unpurged += 1;
172      if (askRemoval && !askRemoval.ok) askFailures.push(`${slug}: ${askRemoval.message}`);
173    } catch (error) {
174      failed.push(`${slug}: ${errorMessage(error)}`);
175    }
176  }
177  return {
178    message:
179      `Deleted ${done} of ${slugs.length}.` +
180      (failed.length > 0 ? ` Failed on ${failed.join("; ")}` : "") +
181      (askFailures.length > 0 ? ` Ask removal failed on ${askFailures.join("; ")}` : "") +
182      unpurgedNote(unpurged),
183    ...(failed.length > 0 || askFailures.length > 0 ? { failed: true as const } : {}),
184  };
185}
186
187export async function bulkTagPosts(
188  env: Env,
189  form: FormData,
190  slugs: string[],
191  intent: "bulk-add-tag" | "bulk-remove-tag",
192  actor: Actor,
193): Promise<Message> {
194  const failed: string[] = [];
195  let unpurged = 0;
196
197  const wanted = parseTagInput(String(form.get("tag") ?? ""))[0];
198  if (!wanted) return { message: "Enter a tag first.", failed: true };
199  const adding = intent === "bulk-add-tag";
200
201  // A no-op post is skipped: writing it costs a commit and rewrites frontmatter whose key order is
202  // not yet canonical.
203  const tally = await applyBulkTag({
204    ids: slugs,
205    wanted,
206    adding,
207    missing: "no source file",
208    read: async (slug) => {
209      const file = await readFile(env, postPath(slug));
210      if (!file) return null;
211      const fields = parsePost(file.content);
212      return { item: fields, tags: fields.tags };
213    },
214    write: async (slug, fields, tags) => {
215      const { purged } = await savePost(env, {
216        slug,
217        raw: serializePost({ ...fields, tags }),
218        isNew: false,
219        actor,
220      });
221      if (purged === false) unpurged += 1;
222    },
223  });
224  const done = tally.done;
225  const skipped = tally.skipped;
226  failed.push(...tally.failed);
227
228  const verb = adding ? "Tagged" : "Untagged";
229  const why = adding ? "already tagged" : "not tagged";
230  return {
231    message:
232      `${verb} ${done} with "${wanted}"` +
233      (skipped > 0 ? `, skipped ${skipped} ${why}` : "") +
234      "." +
235      (failed.length > 0 ? ` Failed on ${failed.join("; ")}` : "") +
236      unpurgedNote(unpurged),
237    ...(failed.length > 0 ? { failed: true as const } : {}),
238  };
239}
240
241export async function resetAskBudgetAndReport(env: Env): Promise<Message> {
242  if (!askAvailable(env)) return { message: "Ask is not enabled.", failed: true };
243  await resetAskBudget(env);
244  const after = await readAskBudget(env);
245  return { message: `Ask budget reset. ${after.count} of ${after.limit} used today.` };
246}