erudit 4.0.0-dev.4 → 4.0.0-dev.5

package/server/erudit/content/search.ts

@@ -1,163 +1,146 @@
-import { eq } from 'drizzle-orm';
-import { contentTypes } from '@erudit-js/core/content/type';
-import { headingSchema } from '@erudit-js/prose/elements/heading/core';
-import type { TopicPart } from '@erudit-js/core/content/topic';
-
-export async function searchIndexContentTypes(): Promise<SearchEntriesList[]> {
-    const entryLists: SearchEntriesList[] = [];
-
-    for (const contentType of contentTypes) {
-        const dbContentItems = await ERUDIT.db.query.content.findMany({
-            columns: {
-                fullId: true,
-                title: true,
-                description: true,
-                type: true,
-            },
-            where: (fields) => eq(fields.type, contentType),
-        });
-
-        entryLists.push({
-            category: {
-                id: contentType,
-                priority: 200,
-            },
-            entries: await Promise.all(
-                dbContentItems.map(async (dbContentItem) => {
-                    const bookTitle: string | undefined = await (async () => {
-                        if (dbContentItem.type === 'book') {
-                            return undefined;
-                        }
-
-                        const itemBook = ERUDIT.contentNav.getBookFor(
-                            dbContentItem.fullId,
-                        );
-
-                        if (itemBook) {
-                            const bookId = itemBook.fullId;
-                            const dbBook =
-                                await ERUDIT.db.query.content.findFirst({
-                                    columns: { title: true },
-                                    where: eq(
-                                        ERUDIT.db.schema.content.fullId,
-                                        bookId,
-                                    ),
-                                });
-                            return dbBook?.title;
-                        }
-                    })();
-
-                    return {
-                        category: contentType,
-                        title: dbContentItem.title,
-                        description: dbContentItem.description || undefined,
-                        link: await ERUDIT.repository.content.link(
-                            dbContentItem.fullId,
-                        ),
-                        location: bookTitle,
-                    } satisfies SearchEntry;
-                }),
-            ),
-        });
-    }
-
-    return entryLists;
-}
-
-export async function searchIndexSnippets(): Promise<SearchEntriesList[]> {
-    const entryLists: Map<string, SearchEntriesList> = new Map();
-
-    const dbSnippets = await ERUDIT.db.query.contentSnippets.findMany({
-        where: eq(ERUDIT.db.schema.contentSnippets.search, true),
-    });
-
-    for (const dbSnippet of dbSnippets) {
-        if (!entryLists.has(dbSnippet.schemaName)) {
-            entryLists.set(dbSnippet.schemaName, {
-                category: {
-                    id: 'element:' + dbSnippet.schemaName,
-                    priority:
-                        dbSnippet.schemaName === headingSchema.name ? 325 : 350,
-                },
-                entries: [],
-            });
-        }
-
-        const navNode = ERUDIT.contentNav.getNodeOrThrow(
-            dbSnippet.contentFullId,
-        );
-        let link: string;
-
-        const locationTitle = await (async () => {
-            const dbContentItem = await ERUDIT.db.query.content.findFirst({
-                columns: { title: true },
-                where: eq(
-                    ERUDIT.db.schema.content.fullId,
-                    dbSnippet.contentFullId,
-                ),
-            });
-
-            return dbContentItem?.title;
-        })();
-
-        switch (navNode.type) {
-            case 'page':
-                link = PAGES[navNode.type](
-                    navNode.shortId,
-                    dbSnippet.elementId,
-                );
-                break;
-            case 'topic':
-                link = PAGES['topic'](
-                    dbSnippet.contentProseType as TopicPart,
-                    navNode.shortId,
-                    dbSnippet.elementId,
-                );
-                break;
-            default:
-                throw createError({
-                    statusCode: 500,
-                    statusMessage: `Cannot create search snippet link for content type "${navNode.type}"!`,
-                });
-        }
-
-        let searchTitle = dbSnippet.snippetData.title!;
-        let searchDescription = dbSnippet.snippetData.description;
-        if (
-            typeof dbSnippet.snippetData.search === 'object' &&
-            !Array.isArray(dbSnippet.snippetData.search)
-        ) {
-            if (dbSnippet.snippetData.search.title) {
-                searchTitle = dbSnippet.snippetData.search.title;
-            }
-
-            if (dbSnippet.snippetData.search.description) {
-                searchDescription = dbSnippet.snippetData.search.description;
-            }
-        }
-
-        let searchSynonyms: string[] | undefined = undefined;
-        if (Array.isArray(dbSnippet.snippetData.search)) {
-            searchSynonyms = dbSnippet.snippetData.search;
-        } else {
-            if (typeof dbSnippet.snippetData.search === 'object') {
-                searchSynonyms = dbSnippet.snippetData.search.synonyms;
-            }
-        }
-
-        entryLists.get(dbSnippet.schemaName)!.entries.push({
-            category: 'element:' + dbSnippet.schemaName,
-            title: searchTitle,
-            description: searchDescription,
-            link,
-            location: locationTitle,
-            synonyms: searchSynonyms
-                ? searchSynonyms.length > 0
-                    ? searchSynonyms
-                    : undefined
-                : undefined,
-        });
-    }
-
-    return Array.from(entryLists.values());
-}
+import { eq } from 'drizzle-orm';
+import { contentTypes } from '@erudit-js/core/content/type';
+import { headingSchema } from '@erudit-js/prose/elements/heading/core';
+import type { TopicPart } from '@erudit-js/core/content/topic';
+
+export async function searchIndexContentTypes(): Promise<SearchEntriesList[]> {
+  const entryLists: SearchEntriesList[] = [];
+
+  for (const contentType of contentTypes) {
+    const dbContentItems = await ERUDIT.db.query.content.findMany({
+      columns: {
+        fullId: true,
+        title: true,
+        description: true,
+        type: true,
+      },
+      where: (fields) => eq(fields.type, contentType),
+    });
+
+    entryLists.push({
+      category: {
+        id: contentType,
+        priority: 200,
+      },
+      entries: await Promise.all(
+        dbContentItems.map(async (dbContentItem) => {
+          const bookTitle: string | undefined = await (async () => {
+            if (dbContentItem.type === 'book') {
+              return undefined;
+            }
+
+            const itemBook = ERUDIT.contentNav.getBookFor(dbContentItem.fullId);
+
+            if (itemBook) {
+              const bookId = itemBook.fullId;
+              const dbBook = await ERUDIT.db.query.content.findFirst({
+                columns: { title: true },
+                where: eq(ERUDIT.db.schema.content.fullId, bookId),
+              });
+              return dbBook?.title;
+            }
+          })();
+
+          return {
+            category: contentType,
+            title: dbContentItem.title,
+            description: dbContentItem.description || undefined,
+            link: await ERUDIT.repository.content.link(dbContentItem.fullId),
+            location: bookTitle,
+          } satisfies SearchEntry;
+        }),
+      ),
+    });
+  }
+
+  return entryLists;
+}
+
+export async function searchIndexSnippets(): Promise<SearchEntriesList[]> {
+  const entryLists: Map<string, SearchEntriesList> = new Map();
+
+  const dbSnippets = await ERUDIT.db.query.contentSnippets.findMany({
+    where: eq(ERUDIT.db.schema.contentSnippets.search, true),
+  });
+
+  for (const dbSnippet of dbSnippets) {
+    if (!entryLists.has(dbSnippet.schemaName)) {
+      entryLists.set(dbSnippet.schemaName, {
+        category: {
+          id: 'element:' + dbSnippet.schemaName,
+          priority: dbSnippet.schemaName === headingSchema.name ? 325 : 350,
+        },
+        entries: [],
+      });
+    }
+
+    const navNode = ERUDIT.contentNav.getNodeOrThrow(dbSnippet.contentFullId);
+    let link: string;
+
+    const locationTitle = await (async () => {
+      const dbContentItem = await ERUDIT.db.query.content.findFirst({
+        columns: { title: true },
+        where: eq(ERUDIT.db.schema.content.fullId, dbSnippet.contentFullId),
+      });
+
+      return dbContentItem?.title;
+    })();
+
+    switch (navNode.type) {
+      case 'page':
+        link = PAGES[navNode.type](navNode.shortId, dbSnippet.elementId);
+        break;
+      case 'topic':
+        link = PAGES['topic'](
+          dbSnippet.contentProseType as TopicPart,
+          navNode.shortId,
+          dbSnippet.elementId,
+        );
+        break;
+      default:
+        throw createError({
+          statusCode: 500,
+          statusMessage: `Cannot create search snippet link for content type "${navNode.type}"!`,
+        });
+    }
+
+    let searchTitle = dbSnippet.snippetData.title!;
+    let searchDescription = dbSnippet.snippetData.description;
+    if (
+      typeof dbSnippet.snippetData.search === 'object' &&
+      !Array.isArray(dbSnippet.snippetData.search)
+    ) {
+      if (dbSnippet.snippetData.search.title) {
+        searchTitle = dbSnippet.snippetData.search.title;
+      }
+
+      if (dbSnippet.snippetData.search.description) {
+        searchDescription = dbSnippet.snippetData.search.description;
+      }
+    }
+
+    let searchSynonyms: string[] | undefined = undefined;
+    if (Array.isArray(dbSnippet.snippetData.search)) {
+      searchSynonyms = dbSnippet.snippetData.search;
+    } else {
+      if (typeof dbSnippet.snippetData.search === 'object') {
+        searchSynonyms = dbSnippet.snippetData.search.synonyms;
+      }
+    }
+
+    entryLists.get(dbSnippet.schemaName)!.entries.push({
+      category: 'element:' + dbSnippet.schemaName,
+      title: searchTitle,
+      description: searchDescription,
+      link,
+      location: locationTitle,
+      synonyms: searchSynonyms
+        ? searchSynonyms.length > 0
+          ? searchSynonyms
+          : undefined
+        : undefined,
+    });
+  }
+
+  return Array.from(entryLists.values());
+}

package/server/erudit/contributors/build.ts

@@ -1,166 +1,158 @@
-import { existsSync, readdirSync, writeFileSync } from 'node:fs';
-import { eq, like } from 'drizzle-orm';
-import { globSync } from 'glob';
-import { isRawElement, type AnySchema, type ProseElement } from '@jsprose/core';
-import {
-    contributorIdToPropertyName,
-    globalContributorsObject,
-    globalContributorsTypes,
-    type ContributorDefinition,
-} from '@erudit-js/core/contributor';
-
-$CONTRIBUTOR;
-
-let initialBuild = true;
-
-const contributorsRoot = () => `${ERUDIT.config.paths.project}/contributors`;
-
-const contributorsTypesPath = () =>
-    `${ERUDIT.config.paths.build}/types/contributors.d.ts`;
-
-export async function buildContributors() {
-    if (!ERUDIT.config.public.project.contributors?.enabled) return;
-
-    ERUDIT.log.debug.start('Building contributors...');
-
-    const isInitial = initialBuild;
-    initialBuild = false;
-
-    const contributorIds = collectContributorIds(isInitial);
-
-    if (!contributorIds.size) {
-        ERUDIT.log.info(
-            isInitial
-                ? 'Skipping contributors — no contributors found.'
-                : 'Skipping contributors — nothing changed.',
-        );
-        return;
-    }
-
-    for (const id of contributorIds) {
-        await cleanupContributor(id);
-    }
-
-    const existingIds = [...contributorIds].filter((id) =>
-        existsSync(`${contributorsRoot()}/${id}`),
-    );
-
-    syncContributorGlobals(existingIds);
-
-    if (!existingIds.length) {
-        return;
-    }
-
-    for (const id of existingIds) {
-        await buildContributor(id);
-    }
-
-    ERUDIT.log.success(
-        isInitial
-            ? `Contributors build complete! (${ERUDIT.log.stress(contributorIds.size)})`
-            : `Contributors updated: ${ERUDIT.log.stress(existingIds.join(', '))}`,
-    );
-}
-
-//
-//
-//
-
-function collectContributorIds(initial: boolean): Set<string> {
-    if (initial) {
-        return new Set(
-            globSync(`${contributorsRoot()}/*/`, { posix: true }).map(
-                (p) => p.split('/').at(-1)!,
-            ),
-        );
-    }
-
-    const ids = new Set<string>();
-
-    for (const file of ERUDIT.changedFiles.values()) {
-        if (!file.startsWith(`${contributorsRoot()}/`)) continue;
-        const id = file.replace(`${contributorsRoot()}/`, '').split('/')[0];
-        if (id) ids.add(id);
-    }
-
-    return ids;
-}
-
-async function cleanupContributor(contributorId: string) {
-    await ERUDIT.db
-        .delete(ERUDIT.db.schema.contributors)
-        .where(eq(ERUDIT.db.schema.contributors.contributorId, contributorId));
-
-    await ERUDIT.db
-        .delete(ERUDIT.db.schema.files)
-        .where(
-            like(ERUDIT.db.schema.files.role, `contributor:${contributorId}%`),
-        );
-
-    delete $CONTRIBUTOR[contributorIdToPropertyName(contributorId)];
-}
-
-function syncContributorGlobals(contributorIds: string[]) {
-    Object.assign($CONTRIBUTOR, globalContributorsObject(contributorIds));
-
-    writeFileSync(
-        contributorsTypesPath(),
-        globalContributorsTypes($CONTRIBUTOR),
-    );
-}
-
-async function buildContributor(contributorId: string) {
-    ERUDIT.log.debug.start(
-        `Building contributor ${ERUDIT.log.stress(contributorId)}...`,
-    );
-
-    const dir = `${contributorsRoot()}/${contributorId}`;
-    const files = readdirSync(dir);
-
-    const avatar = files.find((f) => f.startsWith('avatar.'));
-    if (avatar) {
-        await ERUDIT.repository.db.pushFile(
-            `${dir}/${avatar}`,
-            `contributor:${contributorId}`,
-        );
-    }
-
-    let def: ContributorDefinition | undefined;
-
-    try {
-        def = await ERUDIT.import(`${dir}/contributor`);
-    } catch (err) {
-        if (!String(err).includes('Cannot find module')) {
-            ERUDIT.log.error(`Failed to load contributor ${contributorId}:`);
-            console.error(err);
-        }
-    }
-
-    let description: ProseElement<AnySchema> | undefined;
-
-    if (isRawElement(def?.description)) {
-        const resolved = await ERUDIT.repository.prose.resolve(
-            def.description,
-            false,
-        );
-
-        for (const file of resolved.files) {
-            await ERUDIT.repository.db.pushFile(
-                file,
-                `contributor:${contributorId}`,
-            );
-        }
-
-        description = resolved.proseElement;
-    }
-
-    await ERUDIT.db.insert(ERUDIT.db.schema.contributors).values({
-        contributorId,
-        avatarExtension: avatar?.split('.').pop(),
-        displayName: def?.displayName,
-        short: def?.short,
-        links: def?.links,
-        editor: def?.editor,
-        description,
-    });
-}
+import { existsSync, readdirSync, writeFileSync } from 'node:fs';
+import { eq, like } from 'drizzle-orm';
+import { globSync } from 'glob';
+import { isRawElement, type AnySchema, type ProseElement } from '@jsprose/core';
+import {
+  contributorIdToPropertyName,
+  globalContributorsObject,
+  globalContributorsTypes,
+  type ContributorDefinition,
+} from '@erudit-js/core/contributor';
+
+$CONTRIBUTOR;
+
+let initialBuild = true;
+
+const contributorsRoot = () => ERUDIT.paths.project(`contributors`);
+
+const contributorsTypesPath = () =>
+  ERUDIT.paths.project(`.erudit/types/contributors.d.ts`);
+
+export async function buildContributors() {
+  if (!ERUDIT.config.public.contributors?.enabled) return;
+
+  ERUDIT.log.debug.start('Building contributors...');
+
+  const isInitial = initialBuild;
+  initialBuild = false;
+
+  const contributorIds = collectContributorIds(isInitial);
+
+  if (!contributorIds.size) {
+    ERUDIT.log.info(
+      isInitial
+        ? 'Skipping contributors — no contributors found.'
+        : 'Skipping contributors — nothing changed.',
+    );
+    return;
+  }
+
+  for (const id of contributorIds) {
+    await cleanupContributor(id);
+  }
+
+  const existingIds = [...contributorIds].filter((id) =>
+    existsSync(`${contributorsRoot()}/${id}`),
+  );
+
+  syncContributorGlobals(existingIds);
+
+  if (!existingIds.length) {
+    return;
+  }
+
+  for (const id of existingIds) {
+    await buildContributor(id);
+  }
+
+  ERUDIT.log.success(
+    isInitial
+      ? `Contributors build complete! (${ERUDIT.log.stress(contributorIds.size)})`
+      : `Contributors updated: ${ERUDIT.log.stress(existingIds.join(', '))}`,
+  );
+}
+
+//
+//
+//
+
+function collectContributorIds(initial: boolean): Set<string> {
+  if (initial) {
+    return new Set(
+      globSync(`${contributorsRoot()}/*/`, { posix: true }).map(
+        (p) => p.split('/').at(-1)!,
+      ),
+    );
+  }
+
+  const ids = new Set<string>();
+
+  for (const file of ERUDIT.changedFiles.values()) {
+    if (!file.startsWith(`${contributorsRoot()}/`)) continue;
+    const id = file.replace(`${contributorsRoot()}/`, '').split('/')[0];
+    if (id) ids.add(id);
+  }
+
+  return ids;
+}
+
+async function cleanupContributor(contributorId: string) {
+  await ERUDIT.db
+    .delete(ERUDIT.db.schema.contributors)
+    .where(eq(ERUDIT.db.schema.contributors.contributorId, contributorId));
+
+  await ERUDIT.db
+    .delete(ERUDIT.db.schema.files)
+    .where(like(ERUDIT.db.schema.files.role, `contributor:${contributorId}%`));
+
+  delete $CONTRIBUTOR[contributorIdToPropertyName(contributorId)];
+}
+
+function syncContributorGlobals(contributorIds: string[]) {
+  Object.assign($CONTRIBUTOR, globalContributorsObject(contributorIds));
+
+  writeFileSync(contributorsTypesPath(), globalContributorsTypes($CONTRIBUTOR));
+}
+
+async function buildContributor(contributorId: string) {
+  ERUDIT.log.debug.start(
+    `Building contributor ${ERUDIT.log.stress(contributorId)}...`,
+  );
+
+  const dir = `${contributorsRoot()}/${contributorId}`;
+  const files = readdirSync(dir);
+
+  const avatar = files.find((f) => f.startsWith('avatar.'));
+  if (avatar) {
+    await ERUDIT.repository.db.pushFile(
+      `${dir}/${avatar}`,
+      `contributor:${contributorId}`,
+    );
+  }
+
+  let def: ContributorDefinition | undefined;
+
+  try {
+    def = await ERUDIT.import(`${dir}/contributor`);
+  } catch (err) {
+    if (!String(err).includes('Cannot find module')) {
+      ERUDIT.log.error(`Failed to load contributor ${contributorId}:`);
+      console.error(err);
+    }
+  }
+
+  let description: ProseElement<AnySchema> | undefined;
+
+  if (isRawElement(def?.description)) {
+    const resolved = await ERUDIT.repository.prose.resolve(
+      def.description,
+      false,
+    );
+
+    for (const file of resolved.files) {
+      await ERUDIT.repository.db.pushFile(file, `contributor:${contributorId}`);
+    }
+
+    description = resolved.proseElement;
+  }
+
+  await ERUDIT.db.insert(ERUDIT.db.schema.contributors).values({
+    contributorId,
+    avatarExtension: avatar?.split('.').pop(),
+    displayName: def?.displayName,
+    short: def?.short,
+    links: def?.links,
+    editor: def?.editor,
+    description,
+  });
+}

package/server/erudit/contributors/global.ts

@@ -1,3 +1,3 @@
-export const $CONTRIBUTOR: Record<string, string> = {};
-
-(globalThis as any).$CONTRIBUTOR = $CONTRIBUTOR;
+export const $CONTRIBUTOR: Record<string, string> = {};
+
+(globalThis as any).$CONTRIBUTOR = $CONTRIBUTOR;