app/lib/bulk.server.ts

Functions

Imports

It imports app/lib/content.server.ts, app/lib/frontmatter.ts, app/lib/people.server.ts, app/lib/projects.server.ts, app/lib/roles.ts, app/lib/sites.server.ts. Imported by app/routes/project.bulk.ts.

Source

1// Bulk actions on a site's posts: add or remove a tag, duplicate, delete. Each post is its own
2// write, in order, through the same functions a single save uses, so every role rule, every version
3// check and every authorship record is the one the editor has. One post failing (stale, refused, not
4// there) never stops the rest, and every post gets an outcome in plain words.
5
6import { ContentId } from "@dustinedwards/site-api";
7import { SiteApiError } from "@dustinedwards/site-api/client";
8
9import { deleteFromSite, readDoc, readDraft, writeToSite } from "~/lib/content.server";
10import { joinSource, setRawKey, setTags, splitSource, tagsOf } from "@dustinedwards/site-api/frontmatter";
11import { readFields, setField } from "~/lib/frontmatter";
12import type { Viewer } from "~/lib/people.server";
13import type { SiteProject } from "~/lib/projects.server";
14import { can } from "~/lib/roles";
15import { siteClient, SiteNotConnected } from "~/lib/sites.server";
16
17export const MAX_BULK = 100;
18
19export type BulkRequest = { op: "tag-add"; tag: string } | { op: "tag-remove"; tag: string } | { op: "duplicate" } | { op: "delete" };
20
21/** One post's outcome. `ok` false means this post was left as it was; the message says why. */
22export type ItemResult = { id: string; title: string; ok: boolean; message: string; copyId?: string };
23
24/** A tag as a post's frontmatter list can hold it: one short piece of text with nothing that would break the list. */
25export function cleanTag(raw: string): string | null {
26  const tag = raw.trim();
27  if (tag.length === 0 || tag.length > 40) return null;
28  if (/[,\[\]"'#:\r\n\\]/.test(tag)) return null;
29  return tag;
30}
31
32const same = (a: string, b: string) => a.toLowerCase() === b.toLowerCase();
33
34/** The ids to act on: unique, each one an id a site could hold. An id that could not be one is reported, not sent. */
35function parseIds(raw: readonly string[]): { ids: string[]; invalid: string[] } {
36  const ids: string[] = [];
37  const invalid: string[] = [];
38  for (const id of new Set(raw)) (ContentId.safeParse(id).success ? ids : invalid).push(id);
39  return { ids, invalid };
40}
41
42function requireCan(project: { role: SiteProject["role"] }, action: Parameters<typeof can>[1]) {
43  if (!can(project.role, action)) throw new Response("Forbidden", { status: 403 });
44}
45
46/**
47 * Applies one action to each post. The role is checked once before any post is read (a Reader or an
48 * Editor who asks to delete is refused outright, and the site is not asked); a post whose own state
49 * needs a higher role, such as a live post for an Editor, is refused alone and the rest go on.
50 */
51export async function bulkApply(
52  env: Env,
53  project: SiteProject,
54  viewer: Viewer,
55  request: BulkRequest,
56  rawIds: readonly string[],
57  fetcher?: typeof fetch,
58): Promise<ItemResult[]> {
59  requireCan(project, request.op === "delete" ? "delete_content" : "edit");
60  if (rawIds.length === 0) throw new Response("Choose at least one post.", { status: 400 });
61  if (rawIds.length > MAX_BULK) throw new Response(`At most ${MAX_BULK} posts at a time.`, { status: 400 });
62  const tag = request.op === "tag-add" || request.op === "tag-remove" ? cleanTag(request.tag) : null;
63  if ((request.op === "tag-add" || request.op === "tag-remove") && tag === null) {
64    throw new Response("A tag is one short piece of text, with no commas, brackets, quotes or colons.", { status: 400 });
65  }
66
67  const { ids, invalid } = parseIds(rawIds);
68  const results: ItemResult[] = invalid.map((id) => ({ id, title: id, ok: false, message: "That is not a post id, so it was not sent to the site." }));
69  for (const id of ids) {
70    try {
71      switch (request.op) {
72        case "tag-add":
73        case "tag-remove":
74          results.push(await tagOne(env, project, viewer, id, request.op, tag!, fetcher));
75          break;
76        case "duplicate":
77          results.push(await duplicateOne(env, project, viewer, id, fetcher));
78          break;
79        case "delete":
80          results.push(await deleteOne(env, project, viewer, id, fetcher));
81          break;
82      }
83    } catch (error) {
84      results.push(failure(id, error));
85    }
86  }
87  return results;
88}
89
90/** What went wrong for one post, said plainly. Anything unexpected is logged and reported, never dropped. */
91function failure(id: string, error: unknown): ItemResult {
92  if (error instanceof Response && error.status === 403) {
93    return { id, title: id, ok: false, message: "Changing a live post is the Owner's step, so this one was left as it was." };
94  }
95  if (error instanceof SiteNotConnected) return { id, title: id, ok: false, message: error.detail };
96  console.error(JSON.stringify({ bulk: "item-failed", id, error: error instanceof Response ? `response ${error.status}` : String(error) }));
97  if (error instanceof SiteApiError) return { id, title: id, ok: false, message: "The site did not answer for this post. It was left as it was." };
98  return { id, title: id, ok: false, message: "Something went wrong with this post. It was left as it was." };
99}
100
101async function tagOne(env: Env, project: SiteProject, viewer: Viewer, id: string, op: "tag-add" | "tag-remove", tag: string, fetcher?: typeof fetch): Promise<ItemResult> {
102  const doc = await readDoc(env, project, id, fetcher);
103  if (!doc) return { id, title: id, ok: false, message: "The site does not have this post." };
104  const title = doc.title || id;
105  // Saving to the site clears the person's working copy, which would lose unsaved edits.
106  if (await readDraft(env.DB, project, viewer, id)) {
107    return { id, title, ok: false, message: "You have a working draft of this post in Carrel. Open it and change the tags there, so the draft is not lost." };
108  }
109  const parts = splitSource(doc.source);
110  if (parts.front === null) return { id, title, ok: false, message: "This post has no frontmatter, so it has no tags to change." };
111  const tags = tagsOf(parts.front);
112  const has = tags.some((t) => same(t, tag));
113  if (op === "tag-add" && has) return { id, title, ok: true, message: `Already tagged "${tag}". Not changed.` };
114  if (op === "tag-remove" && !has) return { id, title, ok: true, message: `Did not have the tag "${tag}". Not changed.` };
115  const next = op === "tag-add" ? [...tags, tag] : tags.filter((t) => !same(t, tag));
116  const source = joinSource({ ...parts, front: setTags(parts.front, next) });
117  let outcome;
118  try {
119    outcome = await writeToSite(env, project, viewer, id, { action: "save", source, expectedVersion: doc.version }, fetcher);
120  } catch (error) {
121    return { ...failure(id, error), title };
122  }
123  if (!outcome.ok) return { id, title, ok: false, message: outcome.reason === "conflict" ? "The post changed on the site while this ran. Nothing was changed." : outcome.message };
124  return { id, title, ok: true, message: op === "tag-add" ? `Added the tag "${tag}".` : `Removed the tag "${tag}".` };
125}
126
127const COPY_TRIES = 50;
128
129/** The first of id-copy, id-copy-2, ... that no post, working draft, AI draft or indexed row already uses. */
130async function freeCopyId(env: Env, project: SiteProject, id: string, fetcher?: typeof fetch): Promise<{ id: string; n: number } | null> {
131  const client = siteClient(env, project.site, fetcher);
132  for (let n = 1; n <= COPY_TRIES; n++) {
133    const candidate = n === 1 ? `${id}-copy` : `${id}-copy-${n}`;
134    if (!ContentId.safeParse(candidate).success) return null;
135    const local = await env.DB.prepare(
136      `SELECT 1 AS used FROM drafts WHERE project_id = ?1 AND item_id = ?2
137       UNION ALL SELECT 1 FROM ai_drafts WHERE project_id = ?1 AND item_id = ?2
138       UNION ALL SELECT 1 FROM site_items WHERE project_id = ?1 AND item_id = ?2 LIMIT 1`,
139    )
140      .bind(project.id, candidate)
141      .first();
142    if (local) continue;
143    try {
144      await client.get(candidate);
145    } catch (error) {
146      if (error instanceof SiteApiError && error.status === 404) return { id: candidate, n };
147      throw error;
148    }
149  }
150  return null;
151}
152
153async function duplicateOne(env: Env, project: SiteProject, viewer: Viewer, id: string, fetcher?: typeof fetch): Promise<ItemResult> {
154  const doc = await readDoc(env, project, id, fetcher);
155  if (!doc) return { id, title: id, ok: false, message: "The site does not have this post." };
156  const title = doc.title || id;
157  const parts = splitSource(doc.source);
158  if (parts.front === null) return { id, title, ok: false, message: "This post has no frontmatter, so it cannot be copied as a draft." };
159  const copy = await freeCopyId(env, project, id, fetcher);
160  if (!copy) return { id, title, ok: false, message: "No unused id was found for the copy. Rename an earlier copy and try again." };
161
162  let front = setField(parts.front, "title", `${readFields(parts.front).title || id} (copy${copy.n > 1 ? ` ${copy.n}` : ""})`);
163  // The site's own copy of the id sits in the file as well; a copy that kept the old one would clash with the original.
164  if (/^slug:/m.test(front)) front = setRawKey(front, "slug", copy.id);
165  front = setRawKey(front, "draft", "true");
166  const source = joinSource({ ...parts, front });
167  let outcome;
168  try {
169    outcome = await writeToSite(env, project, viewer, copy.id, { action: "save", source, expectedVersion: null }, fetcher);
170  } catch (error) {
171    return { ...failure(id, error), title };
172  }
173  if (!outcome.ok) return { id, title, ok: false, message: outcome.reason === "conflict" ? "The id chosen for the copy was taken while this ran. Nothing was copied." : outcome.message };
174  return { id, title, ok: true, message: `Copied as a draft with the id "${copy.id}".`, copyId: copy.id };
175}
176
177async function deleteOne(env: Env, project: SiteProject, viewer: Viewer, id: string, fetcher?: typeof fetch): Promise<ItemResult> {
178  const outcome = await deleteFromSite(env, project, viewer, id, fetcher);
179  if (!outcome.ok) return { id, title: id, ok: false, message: outcome.message };
180  return {
181    id,
182    title: outcome.title || id,
183    ok: true,
184    message: outcome.recorded ? "Deleted from the site." : "Deleted from the site. Carrel could not save the record of it; tell the Owner.",
185  };
186}