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

package/server/erudit/contributors/repository/avatarUrl.ts

@@ -1,10 +1,10 @@
-export function getContributorAvatarUrl(
-    contributorId: string,
-    avatarExtension: string | undefined,
-): string | undefined {
-    if (!avatarExtension) {
-        return undefined;
-    }
-
-    return '/file/contributors/' + contributorId + '/avatar.' + avatarExtension;
-}
+export function getContributorAvatarUrl(
+  contributorId: string,
+  avatarExtension: string | undefined,
+): string | undefined {
+  if (!avatarExtension) {
+    return undefined;
+  }
+
+  return '/file/contributors/' + contributorId + '/avatar.' + avatarExtension;
+}

package/server/erudit/contributors/repository/contributions.ts

@@ -1,178 +1,171 @@
-import { eq, count } from 'drizzle-orm';
-import type {
-    ContentContribution,
-    ContributorContribution,
-} from '@erudit-js/core/content/contributions';
-
-export async function countContributions(
-    contributorId: string,
-): Promise<number> {
-    const result = await ERUDIT.db
-        .select({ count: count() })
-        .from(ERUDIT.db.schema.contentContributions)
-        .where(
-            eq(
-                ERUDIT.db.schema.contentContributions.contributorId,
-                contributorId,
-            ),
-        );
-
-    return result[0].count;
-}
-
-export async function getContributorContributions(
-    contributorId: string,
-): Promise<ContributorContribution[] | undefined> {
-    const contributions: ContributorContribution[] = [];
-
-    const dbContributions = await ERUDIT.db.query.contentContributions.findMany(
-        {
-            columns: { contentFullId: true },
-            where: eq(
-                ERUDIT.db.schema.contentContributions.contributorId,
-                contributorId,
-            ),
-        },
-    );
-
-    const contentFullIds = ERUDIT.contentNav.orderIds(
-        dbContributions.map((c) => c.contentFullId),
-    );
-
-    const seenBookTitles = new Set<string>();
-    let currentBookId: string | undefined;
-
-    for (const contentFullId of contentFullIds) {
-        const currentNode = ERUDIT.contentNav.getNodeOrThrow(contentFullId);
-        const title = await ERUDIT.repository.content.title(
-            contentFullId,
-            'normal',
-        );
-        const link = await ERUDIT.repository.content.link(contentFullId);
-        const book = ERUDIT.contentNav.getBookFor(contentFullId);
-
-        const contributionItem = {
-            type: currentNode.type as 'topic' | 'page',
-            title,
-            link,
-        };
-
-        if (book && book.fullId === currentBookId) {
-            // Add to existing book group
-            const lastContribution = contributions.at(-1);
-            if (lastContribution && lastContribution.type === 'book') {
-                lastContribution.items.push(contributionItem);
-            }
-        } else if (book) {
-            // Start a new book group
-
-            currentBookId = book.fullId;
-            const bookNode = ERUDIT.contentNav.getNodeOrThrow(book.fullId);
-
-            const baseBookTitle = await ERUDIT.repository.content.title(
-                book.fullId,
-                'normal',
-            );
-
-            let bookTitle = baseBookTitle;
-
-            // Only include parent title if we've already seen a book with this title
-            if (seenBookTitles.has(baseBookTitle) && bookNode.parent) {
-                const parentTitle = await ERUDIT.repository.content.title(
-                    bookNode.parent.fullId,
-                    'normal',
-                );
-                bookTitle = `${parentTitle} / ${baseBookTitle}`;
-            }
-
-            // Track this title for future duplicates
-            seenBookTitles.add(baseBookTitle);
-
-            contributions.push({
-                type: 'book',
-                title: bookTitle,
-                items: [contributionItem],
-            });
-        } else {
-            // Standalone contribution (not part of a book)
-            currentBookId = undefined;
-            contributions.push(contributionItem);
-        }
-    }
-
-    return contributions.length > 0 ? contributions : undefined;
-}
-
-export async function getContentContributions(
-    contentFullId: string,
-    withDescription: boolean,
-): Promise<ContentContribution[] | undefined> {
-    const contributions: ContentContribution[] = [];
-    const seenContributors = new Set<string>();
-
-    const dbContributions = await ERUDIT.db.query.contentContributions.findMany(
-        {
-            columns: {
-                contributorId: true,
-                description: true,
-                contentFullId: true,
-            },
-        },
-    );
-
-    const relevantContributions = dbContributions.filter(
-        (dbContribution) =>
-            dbContribution.contentFullId === contentFullId ||
-            dbContribution.contentFullId.startsWith(`${contentFullId}/`),
-    );
-
-    for (const dbContribution of relevantContributions) {
-        if (seenContributors.has(dbContribution.contributorId)) {
-            continue;
-        }
-
-        seenContributors.add(dbContribution.contributorId);
-
-        const dbContributor = await ERUDIT.db.query.contributors.findFirst({
-            columns: {
-                displayName: true,
-                avatarExtension: true,
-            },
-            where: eq(
-                ERUDIT.db.schema.contributors.contributorId,
-                dbContribution.contributorId,
-            ),
-        });
-
-        const name = dbContributor?.displayName || dbContribution.contributorId;
-
-        const avatarUrl = ERUDIT.repository.contributors.avatarUrl(
-            dbContribution.contributorId,
-            dbContributor?.avatarExtension || undefined,
-        );
-
-        const description = withDescription
-            ? dbContribution.description || undefined
-            : undefined;
-
-        const contribution: ContentContribution = {
-            contributorId: dbContribution.contributorId,
-        };
-
-        if (name) {
-            contribution.name = name;
-        }
-
-        if (avatarUrl) {
-            contribution.avatarUrl = avatarUrl;
-        }
-
-        if (description) {
-            contribution.description = description;
-        }
-
-        contributions.push(contribution);
-    }
-
-    return contributions.length > 0 ? contributions : undefined;
-}
+import { eq, count } from 'drizzle-orm';
+import type {
+  ContentContribution,
+  ContributorContribution,
+} from '@erudit-js/core/content/contributions';
+
+export async function countContributions(
+  contributorId: string,
+): Promise<number> {
+  const result = await ERUDIT.db
+    .select({ count: count() })
+    .from(ERUDIT.db.schema.contentContributions)
+    .where(
+      eq(ERUDIT.db.schema.contentContributions.contributorId, contributorId),
+    );
+
+  return result[0].count;
+}
+
+export async function getContributorContributions(
+  contributorId: string,
+): Promise<ContributorContribution[] | undefined> {
+  const contributions: ContributorContribution[] = [];
+
+  const dbContributions = await ERUDIT.db.query.contentContributions.findMany({
+    columns: { contentFullId: true },
+    where: eq(
+      ERUDIT.db.schema.contentContributions.contributorId,
+      contributorId,
+    ),
+  });
+
+  const contentFullIds = ERUDIT.contentNav.orderIds(
+    dbContributions.map((c) => c.contentFullId),
+  );
+
+  const seenBookTitles = new Set<string>();
+  let currentBookId: string | undefined;
+
+  for (const contentFullId of contentFullIds) {
+    const currentNode = ERUDIT.contentNav.getNodeOrThrow(contentFullId);
+    const title = await ERUDIT.repository.content.title(
+      contentFullId,
+      'normal',
+    );
+    const link = await ERUDIT.repository.content.link(contentFullId);
+    const book = ERUDIT.contentNav.getBookFor(contentFullId);
+
+    const contributionItem = {
+      type: currentNode.type as 'topic' | 'page',
+      title,
+      link,
+    };
+
+    if (book && book.fullId === currentBookId) {
+      // Add to existing book group
+      const lastContribution = contributions.at(-1);
+      if (lastContribution && lastContribution.type === 'book') {
+        lastContribution.items.push(contributionItem);
+      }
+    } else if (book) {
+      // Start a new book group
+
+      currentBookId = book.fullId;
+      const bookNode = ERUDIT.contentNav.getNodeOrThrow(book.fullId);
+
+      const baseBookTitle = await ERUDIT.repository.content.title(
+        book.fullId,
+        'normal',
+      );
+
+      let bookTitle = baseBookTitle;
+
+      // Only include parent title if we've already seen a book with this title
+      if (seenBookTitles.has(baseBookTitle) && bookNode.parent) {
+        const parentTitle = await ERUDIT.repository.content.title(
+          bookNode.parent.fullId,
+          'normal',
+        );
+        bookTitle = `${parentTitle} / ${baseBookTitle}`;
+      }
+
+      // Track this title for future duplicates
+      seenBookTitles.add(baseBookTitle);
+
+      contributions.push({
+        type: 'book',
+        title: bookTitle,
+        items: [contributionItem],
+      });
+    } else {
+      // Standalone contribution (not part of a book)
+      currentBookId = undefined;
+      contributions.push(contributionItem);
+    }
+  }
+
+  return contributions.length > 0 ? contributions : undefined;
+}
+
+export async function getContentContributions(
+  contentFullId: string,
+  withDescription: boolean,
+): Promise<ContentContribution[] | undefined> {
+  const contributions: ContentContribution[] = [];
+  const seenContributors = new Set<string>();
+
+  const dbContributions = await ERUDIT.db.query.contentContributions.findMany({
+    columns: {
+      contributorId: true,
+      description: true,
+      contentFullId: true,
+    },
+  });
+
+  const relevantContributions = dbContributions.filter(
+    (dbContribution) =>
+      dbContribution.contentFullId === contentFullId ||
+      dbContribution.contentFullId.startsWith(`${contentFullId}/`),
+  );
+
+  for (const dbContribution of relevantContributions) {
+    if (seenContributors.has(dbContribution.contributorId)) {
+      continue;
+    }
+
+    seenContributors.add(dbContribution.contributorId);
+
+    const dbContributor = await ERUDIT.db.query.contributors.findFirst({
+      columns: {
+        displayName: true,
+        avatarExtension: true,
+      },
+      where: eq(
+        ERUDIT.db.schema.contributors.contributorId,
+        dbContribution.contributorId,
+      ),
+    });
+
+    const name = dbContributor?.displayName || dbContribution.contributorId;
+
+    const avatarUrl = ERUDIT.repository.contributors.avatarUrl(
+      dbContribution.contributorId,
+      dbContributor?.avatarExtension || undefined,
+    );
+
+    const description = withDescription
+      ? dbContribution.description || undefined
+      : undefined;
+
+    const contribution: ContentContribution = {
+      contributorId: dbContribution.contributorId,
+    };
+
+    if (name) {
+      contribution.name = name;
+    }
+
+    if (avatarUrl) {
+      contribution.avatarUrl = avatarUrl;
+    }
+
+    if (description) {
+      contribution.description = description;
+    }
+
+    contributions.push(contribution);
+  }
+
+  return contributions.length > 0 ? contributions : undefined;
+}

package/server/erudit/contributors/repository/count.ts

@@ -1,3 +1,3 @@
-export function countContributors(): number {
-    return Object.values($CONTRIBUTOR).length;
-}
+export function countContributors(): number {
+  return Object.values($CONTRIBUTOR).length;
+}

package/server/erudit/contributors/search.ts

@@ -1,34 +1,34 @@
-export const searchCategoryContributors: SearchEntryCategory = {
-    id: 'contributors',
-    priority: 100,
-};
-
-export async function searchIndexContributors(): Promise<SearchEntriesList> {
-    const dbContributors = await ERUDIT.db.query.contributors.findMany({
-        columns: {
-            contributorId: true,
-            displayName: true,
-        },
-    });
-
-    return {
-        category: searchCategoryContributors,
-        entries: dbContributors.map((dbContributor) => {
-            const entry: SearchEntry = {
-                category: searchCategoryContributors.id,
-                title: dbContributor.displayName || dbContributor.contributorId,
-                link: PAGES.contributor(dbContributor.contributorId),
-            };
-
-            const hasDisplayName = !!dbContributor.displayName;
-            const displaySameAsId =
-                dbContributor.displayName === dbContributor.contributorId;
-
-            if (hasDisplayName && !displaySameAsId) {
-                entry.synonyms = [dbContributor.contributorId];
-            }
-
-            return entry;
-        }),
-    };
-}
+export const searchCategoryContributors: SearchEntryCategory = {
+  id: 'contributors',
+  priority: 100,
+};
+
+export async function searchIndexContributors(): Promise<SearchEntriesList> {
+  const dbContributors = await ERUDIT.db.query.contributors.findMany({
+    columns: {
+      contributorId: true,
+      displayName: true,
+    },
+  });
+
+  return {
+    category: searchCategoryContributors,
+    entries: dbContributors.map((dbContributor) => {
+      const entry: SearchEntry = {
+        category: searchCategoryContributors.id,
+        title: dbContributor.displayName || dbContributor.contributorId,
+        link: PAGES.contributor(dbContributor.contributorId),
+      };
+
+      const hasDisplayName = !!dbContributor.displayName;
+      const displaySameAsId =
+        dbContributor.displayName === dbContributor.contributorId;
+
+      if (hasDisplayName && !displaySameAsId) {
+        entry.synonyms = [dbContributor.contributorId];
+      }
+
+      return entry;
+    }),
+  };
+}

package/server/erudit/db/repository/pushFile.ts

@@ -1,26 +1,23 @@
-import slash from 'slash';
-
-export async function pushFile(filepath: string, role: string): Promise<void> {
-    filepath = slash(filepath);
-
-    if (!filepath.startsWith(ERUDIT.config.paths.project)) {
-        throw createError({
-            statusCode: 400,
-            statusMessage: 'File is outside of project directory!',
-            message: `Can not add ${filepath} as it is outside of the project directory!`,
-        });
-    }
-
-    const relativePath = filepath.replace(
-        ERUDIT.config.paths.project + '/',
-        '',
-    );
-
-    await ERUDIT.db
-        .insert(ERUDIT.db.schema.files)
-        .values({
-            path: relativePath,
-            role,
-        })
-        .onConflictDoNothing();
-}
+import { sn } from 'unslash';
+
+export async function pushFile(filepath: string, role: string): Promise<void> {
+  filepath = sn(filepath);
+
+  if (!filepath.startsWith(ERUDIT.paths.project())) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: 'File is outside of project directory!',
+      message: `Can not add ${filepath} as it is outside of the project directory!`,
+    });
+  }
+
+  const relativePath = filepath.replace(ERUDIT.paths.project() + '/', '');
+
+  await ERUDIT.db
+    .insert(ERUDIT.db.schema.files)
+    .values({
+      path: relativePath,
+      role,
+    })
+    .onConflictDoNothing();
+}

package/server/erudit/db/repository/pushProblemScript.ts

@@ -1,19 +1,19 @@
-export async function pushProblemScript(
-    problemScriptSrc: string,
-    contentFullId: string,
-): Promise<void> {
-    const parsedId = problemScriptSrc;
-
-    if (!problemScriptSrc.startsWith(ERUDIT.config.paths.project)) {
-        throw createError({
-            statusCode: 400,
-            statusMessage: 'Problem script is outside of project directory!',
-            message: `Can not add problem script from ${problemScriptSrc} as it is outside of the project directory!`,
-        });
-    }
-
-    await ERUDIT.db.insert(ERUDIT.db.schema.problemScripts).values({
-        problemScriptSrc,
-        contentFullId,
-    });
-}
+export async function pushProblemScript(
+  problemScriptSrc: string,
+  contentFullId: string,
+): Promise<void> {
+  const parsedId = problemScriptSrc;
+
+  if (!problemScriptSrc.startsWith(ERUDIT.paths.project())) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: 'Problem script is outside of project directory!',
+      message: `Can not add problem script from ${problemScriptSrc} as it is outside of the project directory!`,
+    });
+  }
+
+  await ERUDIT.db.insert(ERUDIT.db.schema.problemScripts).values({
+    problemScriptSrc,
+    contentFullId,
+  });
+}

package/server/erudit/db/repository/pushProseLink.ts

@@ -1,40 +1,40 @@
-import {
-    isContentProseType,
-    type ContentProseType,
-} from '@erudit-js/core/content/prose';
-import type { ProseLink } from '@erudit-js/core/prose/link';
-
-export async function pushProseLink(
-    contentFullId: string,
-    contentProseType: ContentProseType,
-    proseLink: ProseLink,
-): Promise<void> {
-    let toContentId: string | undefined;
-    let toContentProseType: ContentProseType | undefined;
-
-    switch (proseLink.type) {
-        case 'contentItem':
-            toContentId = proseLink.itemId.contentId;
-            isContentProseType(proseLink.itemId.type) &&
-                (toContentProseType = proseLink.itemId.type);
-            break;
-        case 'document':
-        case 'unique':
-            if (proseLink.documentId.type === 'contentPage') {
-                toContentId = proseLink.documentId.contentId;
-                toContentProseType = 'page';
-            } else if (proseLink.documentId.type === 'contentTopic') {
-                toContentId = proseLink.documentId.contentId;
-                toContentProseType = proseLink.documentId.topicPart;
-            }
-            break;
-    }
-
-    await ERUDIT.db.insert(ERUDIT.db.schema.contentProseLinks).values({
-        fromContentId: contentFullId,
-        fromContentProseType: contentProseType,
-        toContentId,
-        toContentProseType,
-        proseLink,
-    });
-}
+import {
+  isContentProseType,
+  type ContentProseType,
+} from '@erudit-js/core/content/prose';
+import type { ProseLink } from '@erudit-js/core/prose/link';
+
+export async function pushProseLink(
+  contentFullId: string,
+  contentProseType: ContentProseType,
+  proseLink: ProseLink,
+): Promise<void> {
+  let toContentId: string | undefined;
+  let toContentProseType: ContentProseType | undefined;
+
+  switch (proseLink.type) {
+    case 'contentItem':
+      toContentId = proseLink.itemId.contentId;
+      isContentProseType(proseLink.itemId.type) &&
+        (toContentProseType = proseLink.itemId.type);
+      break;
+    case 'document':
+    case 'unique':
+      if (proseLink.documentId.type === 'contentPage') {
+        toContentId = proseLink.documentId.contentId;
+        toContentProseType = 'page';
+      } else if (proseLink.documentId.type === 'contentTopic') {
+        toContentId = proseLink.documentId.contentId;
+        toContentProseType = proseLink.documentId.topicPart;
+      }
+      break;
+  }
+
+  await ERUDIT.db.insert(ERUDIT.db.schema.contentProseLinks).values({
+    fromContentId: contentFullId,
+    fromContentProseType: contentProseType,
+    toContentId,
+    toContentProseType,
+    proseLink,
+  });
+}

package/server/erudit/db/schema/cameos.ts

@@ -1,7 +1,7 @@
-import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import type { Cameo } from '@erudit-js/core/cameo';
-
-export const cameos = sqliteTable('cameos', {
-    cameoId: text().primaryKey(),
-    data: text({ mode: 'json' }).notNull().$type<Cameo>(),
-});
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { Cameo } from '@erudit-js/core/cameo';
+
+export const cameos = sqliteTable('cameos', {
+  cameoId: text().primaryKey(),
+  data: text({ mode: 'json' }).notNull().$type<Cameo>(),
+});