app/lib/cv/compile.mjs

Functions

Imports

It imports app/lib/content/hashes.mjs, app/lib/cv/entries.mjs, app/lib/cv/markdown.mjs, app/lib/cv/parse.mjs, app/lib/cv/validate.mjs, app/lib/identity.mjs, app/lib/pages/compile.mjs. Imported by app/db/cv.ts, app/lib/cv/save.server.ts.

Source

1// One door from the CV's files to everything derived from them: parse and validate a file, assemble the files
2// into one CV, join it to the publications, and compile the page a search record is made from. build:content,
3// sync:content, the CV save and the sync_cv tool all call these, so a file CI passes is the file a save accepts
4// and the CV draws (docs/CV.md).
5
6import { gitBlobSha } from "../content/hashes.mjs";
7import { compilePage } from "../pages/compile.mjs";
8import { buildCv } from "./entries.mjs";
9import { cvMarkdownDocument } from "./markdown.mjs";
10import { deriveIdentity } from "../identity.mjs";
11import { CV_DIR, CV_FILES, cvFileFor, cvSourcePath } from "./parse.mjs";
12import { orderErrors, paperRefErrors, parseCvFile } from "./validate.mjs";
13
14/** @typedef {import("./types.ts").CvFileRecord} CvFileRecord */
15/** @typedef {import("../publications/types.ts").Publication} Publication */
16
17/**
18 * The published records by lower-cased DOI, the join key the CV's paper references use.
19 *
20 * @param {Publication[]} publications
21 * @returns {Map<string, Publication>}
22 */
23function publicationsByDoi(publications) {
24  return new Map(publications.flatMap((p) => (p.doi ? [[p.doi.toLowerCase(), p]] : [])));
25}
26
27/**
28 * One file, judged on its own: its shape, its privacy and style rules and, for the publications file, that
29 * each paper it cites is a published record that lists the owner.
30 *
31 * @param {{ slug: string, raw: string, publications: Publication[] }} input
32 * @returns {Promise<
33 *   | { ok: false, errors: string[] }
34 *   | { ok: true, errors: [], record: CvFileRecord, sourcePath: string, sourceBlobSha: string }
35 * >}
36 */
37export async function compileCvFile({ slug, raw, publications }) {
38  const file = cvFileFor(slug);
39  if (!file) {
40    return {
41      ok: false,
42      errors: [
43        `"${slug}" is not a CV file. The files are ${CV_FILES.map((f) => f.slug).join(", ")} (CV_FILES, ` +
44          "app/lib/cv/parse.mjs); a save cannot create a new one, because the set of files is structure.",
45      ],
46    };
47  }
48  const parsed = parseCvFile(file, raw);
49  if (!parsed.ok) return parsed;
50  const { record } = parsed;
51  if (record.type === "publication") {
52    const errors = paperRefErrors(record.entries, publicationsByDoi(publications));
53    if (errors.length > 0) return { ok: false, errors };
54  }
55  return { ok: true, errors: [], record, sourcePath: cvSourcePath(slug), sourceBlobSha: await gitBlobSha(raw) };
56}
57
58/**
59 * The files' records as one source, in CV_FILES order. Every file must be present, and none twice.
60 *
61 * @param {CvFileRecord[]} records
62 * @returns {{ ok: false, errors: string[] } | { ok: true, source: import("./types.ts").CvSource }}
63 */
64export function assembleCvSource(records) {
65  /** @type {string[]} */
66  const errors = [];
67  const bySlug = new Map();
68  for (const record of records) {
69    if (bySlug.has(record.slug)) errors.push(`${record.slug} is present twice`);
70    bySlug.set(record.slug, record);
71  }
72  for (const { slug } of CV_FILES) {
73    if (!bySlug.has(slug)) errors.push(`${cvSourcePath(slug)} has no record`);
74  }
75  for (const slug of bySlug.keys()) {
76    if (!cvFileFor(slug)) errors.push(`${slug} is not a CV file`);
77  }
78  if (errors.length > 0) return { ok: false, errors };
79  const profile = bySlug.get("profile");
80  if (!profile || profile.type !== "profile") return { ok: false, errors: ["the profile record is not a profile"] };
81  const entries = CV_FILES.flatMap(({ slug }) => {
82    const record = bySlug.get(slug);
83    return record && record.type !== "profile" ? record.entries : [];
84  });
85  // The site's role, job title and headship are derived from the profile and the appointments (app/lib/identity.mjs),
86  // so a CV that could not give them is refused here, where it is edited, and not at the next build.
87  const identity = deriveIdentity(profile.person, entries);
88  if (!identity.ok) return { ok: false, errors: identity.errors };
89  return {
90    ok: true,
91    source: {
92      edition: profile.edition,
93      person: profile.person,
94      presentations: profile.presentations,
95      entries,
96    },
97  };
98}
99
100/**
101 * The whole CV, the rules that need every file at once: assembled, every paper joined, every section in
102 * order. A save runs this over D1's other files with its own in place, so a change that breaks the whole is
103 * refused even when its own file is sound.
104 *
105 * @param {{ records: CvFileRecord[], publications: Publication[] }} input
106 * @returns {{ ok: false, errors: string[] } | { ok: true, errors: [], cv: import("./entries.mjs").Cv }}
107 */
108export function compileCv({ records, publications }) {
109  const assembled = assembleCvSource(records);
110  if (!assembled.ok) return assembled;
111  const errors = paperRefErrors(assembled.source.entries, publicationsByDoi(publications));
112  if (errors.length > 0) return { ok: false, errors };
113  let cv;
114  try {
115    cv = buildCv(assembled.source, publications);
116  } catch (error) {
117    return { ok: false, errors: [error instanceof Error ? error.message : String(error)] };
118  }
119  const ordering = orderErrors(cv.entries);
120  if (ordering.length > 0) return { ok: false, errors: ordering };
121  return { ok: true, errors: [], cv };
122}
123
124/**
125 * The CV's page as the pipeline compiles it, for the search records and the link check: the same compile
126 * every other page goes through (app/lib/pages/compile.mjs), over the markdown the twin is made of. A paper's
127 * title may carry another author's punctuation, so the dash rule is not applied to what a record supplies.
128 *
129 * @param {{ cv: import("./entries.mjs").Cv, pipeline: Parameters<typeof compilePage>[0]["pipeline"] }} input
130 */
131export function compileCvPage({ cv, pipeline }) {
132  return compilePage({
133    slug: "cv",
134    raw: cvMarkdownDocument(cv),
135    pipeline,
136    sourcePath: CV_DIR,
137    generated: true,
138  });
139}