erudit 3.0.0-dev.8 → 4.0.0-dev.1

package/server/erudit/content/resolve/utils/insertContentItem.ts

@@ -0,0 +1,122 @@
+import { globSync } from 'glob';
+import { isContentItem, type ContentItem } from '@erudit-js/core/content/item';
+import {
+    getGlobalContentPath,
+    type GlobalContentItem,
+} from '@erudit-js/core/content/global';
+
+import type { ContentNavNode } from '../../nav/types';
+import type { TopicContentItem } from '@erudit-js/core/content/topic';
+import type { PageContentItem } from '@erudit-js/core/content/page';
+
+export async function insertContentItem(
+    navNode: ContentNavNode,
+    contentItem: ContentItem,
+) {
+    if (
+        isContentItem<TopicContentItem>(contentItem, 'topic') ||
+        isContentItem<PageContentItem>(contentItem, 'page')
+    ) {
+        await resolveContributions(navNode.fullId, contentItem);
+    }
+
+    const decorationExtension = await resolveDecorationExtension(navNode);
+    await resolveHardDependencies(navNode.fullId, contentItem);
+
+    await ERUDIT.db.insert(ERUDIT.db.schema.content).values({
+        fullId: navNode.fullId,
+        type: navNode.type,
+        title: contentItem.title || navNode.fullId.split('/').pop()!,
+        navTitle: contentItem.navTitle,
+        description: contentItem.description,
+        hidden: Boolean(contentItem.hidden) || false,
+        flags: contentItem.flags,
+        decorationExtension,
+        externals: contentItem.externals,
+        seo: contentItem.seo,
+    });
+}
+
+async function resolveContributions(
+    fullId: string,
+    contentItem: TopicContentItem | PageContentItem,
+) {
+    if (contentItem.contributions) {
+        const seenContributors = new Set<string>();
+
+        for (const contribution of contentItem.contributions as any) {
+            const contributorId: string =
+                typeof contribution === 'string'
+                    ? contribution
+                    : contribution.contributor;
+
+            const description: string | undefined =
+                typeof contribution === 'string'
+                    ? undefined
+                    : contribution.description;
+
+            if (seenContributors.has(contributorId)) {
+                ERUDIT.log.warn(
+                    `Duplicate contributor "${contributorId}" in content item "${fullId}"!`,
+                );
+                continue;
+            }
+
+            seenContributors.add(contributorId);
+
+            await ERUDIT.db
+                .insert(ERUDIT.db.schema.contentContributions)
+                .values({
+                    contentFullId: fullId,
+                    contributorId,
+                    description,
+                });
+        }
+    }
+}
+
+async function resolveHardDependencies(
+    fullId: string,
+    contentItem: ContentItem,
+) {
+    if (contentItem.dependencies) {
+        for (const dependency of contentItem.dependencies) {
+            await ERUDIT.db.insert(ERUDIT.db.schema.contentDeps).values({
+                fromFullId: getGlobalContentPath(
+                    dependency.dependency as any as GlobalContentItem,
+                ),
+                toFullId: fullId,
+                hard: true,
+                reason: dependency.reason,
+            });
+        }
+    }
+}
+
+async function resolveDecorationExtension(navNode: ContentNavNode) {
+    const decorationExtension = globSync(
+        ERUDIT.config.paths.project +
+            '/content/' +
+            navNode.contentRelPath +
+            '/decoration.*',
+        {
+            posix: true,
+        },
+    )
+        .shift()
+        ?.split('.')
+        ?.pop();
+
+    if (decorationExtension) {
+        await ERUDIT.repository.db.pushFile(
+            ERUDIT.config.paths.project +
+                '/content/' +
+                navNode.contentRelPath +
+                '/decoration.' +
+                decorationExtension,
+            'content-decoration:' + navNode.fullId,
+        );
+    }
+
+    return decorationExtension;
+}

package/server/erudit/content/resolve/utils/insertContentResolved.ts

@@ -0,0 +1,93 @@
+import { type ResolvedRawElement } from '@jsprose/core';
+import type { ContentProseType } from '@erudit-js/core/content/prose';
+import type { ResolvedEruditRawElement } from '@erudit-js/prose';
+
+export async function insertContentResolved(
+    contentFullId: string,
+    contentProseType: ContentProseType,
+    resolveResult: ResolvedRawElement & ResolvedEruditRawElement,
+) {
+    for (const file of resolveResult.files) {
+        await ERUDIT.repository.db.pushFile(
+            file,
+            `content-item:${contentFullId}`,
+        );
+    }
+
+    for (const [uniqueName, unique] of Object.entries(resolveResult.uniques)) {
+        await ERUDIT.db.insert(ERUDIT.db.schema.contentUniques).values({
+            contentFullId,
+            contentProseType,
+            uniqueName,
+            title: resolveResult.uniqueTitles[uniqueName],
+            prose: unique,
+        });
+    }
+
+    for (const snippet of resolveResult.snippets) {
+        await ERUDIT.db.insert(ERUDIT.db.schema.contentSnippets).values({
+            contentFullId,
+            contentProseType,
+            elementId: snippet.elementId,
+            schemaName: snippet.schemaName,
+            title: snippet.title!,
+            description: snippet.description,
+            search: Boolean(snippet.search),
+            searchSynonyms:
+                typeof snippet.search === 'object'
+                    ? snippet.search.synonyms
+                    : undefined,
+            quick: Boolean(snippet.quick),
+            seo: Boolean(snippet.seo),
+        });
+    }
+
+    for (const problemScript of resolveResult.problemScripts) {
+        await ERUDIT.repository.db.pushProblemScript(
+            problemScript,
+            contentFullId,
+        );
+    }
+
+    const fromFullIds = new Set(
+        Array.from(resolveResult.dependencies)
+            .map((dependency) => {
+                if (dependency.startsWith('<link:')) {
+                    const navNode = globalContentToNavNode(
+                        dependency.replace(/^<link:.+>\//, ''),
+                    );
+                    return navNode.fullId;
+                }
+            })
+            .filter((id): id is string => id !== undefined),
+    );
+
+    const contentDeps = Array.from(fromFullIds)
+        .filter((fromFullId) => fromFullId !== contentFullId)
+        .map((fromFullId) => ({
+            fromFullId,
+            toFullId: contentFullId,
+            hard: false,
+        }));
+
+    if (contentDeps.length > 0) {
+        await ERUDIT.db
+            .insert(ERUDIT.db.schema.contentDeps)
+            .values(contentDeps)
+            .onConflictDoNothing();
+    }
+}
+
+function globalContentToNavNode(globalContentPath: string) {
+    const parts = globalContentPath.split('/');
+
+    if (parts.at(-1)?.startsWith('$')) {
+        parts.pop();
+    }
+
+    const navNode =
+        ERUDIT.contentNav.getNode(parts.join('/')) ??
+        ERUDIT.contentNav.getNodeOrThrow(parts.slice(0, -1).join('/'));
+
+    return navNode;
+}

package/server/erudit/content/search.ts

@@ -0,0 +1,135 @@
+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}"!`,
+                });
+        }
+
+        entryLists.get(dbSnippet.schemaName)!.entries.push({
+            category: 'element:' + dbSnippet.schemaName,
+            title: dbSnippet.title,
+            description: dbSnippet.description || undefined,
+            link,
+            location: locationTitle,
+            synonyms: dbSnippet.searchSynonyms || undefined,
+        });
+    }
+
+    return Array.from(entryLists.values());
+}

package/server/erudit/contributors/build.ts

@@ -0,0 +1,111 @@
+import { readdirSync, writeFileSync } from 'node:fs';
+import { like } from 'drizzle-orm';
+import { globSync } from 'glob';
+import { isRawElement, type AnySchema, type ProseElement } from '@jsprose/core';
+import {
+    globalContributorsObject,
+    globalContributorsTypes,
+    type ContributorDefinition,
+} from '@erudit-js/core/contributor';
+
+// Trigger globalThis update
+$CONTRIBUTOR;
+
+export async function buildContributors() {
+    if (!ERUDIT.config.public.project.contributors?.enabled) {
+        return;
+    }
+
+    ERUDIT.log.debug.start('Building contributors...');
+
+    await ERUDIT.db.delete(ERUDIT.db.schema.contributors);
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.files)
+        .where(like(ERUDIT.db.schema.files.role, 'contributor:%'));
+
+    const contributorIds = globSync(
+        `${ERUDIT.config.paths.project}/contributors/*/`,
+        { posix: true },
+    ).map((dirPath) => dirPath.split('/').pop() as string);
+
+    for (const key in $CONTRIBUTOR) {
+        delete $CONTRIBUTOR[key];
+    }
+
+    Object.assign($CONTRIBUTOR, globalContributorsObject(contributorIds));
+
+    writeFileSync(
+        `${ERUDIT.config.paths.build}/types/contributors.d.ts`,
+        globalContributorsTypes($CONTRIBUTOR),
+    );
+
+    for (const contributorId of contributorIds) {
+        await buildContributor(contributorId);
+    }
+
+    ERUDIT.log.success(
+        `Contributors build complete! (${ERUDIT.log.stress(contributorIds.length)})`,
+    );
+}
+
+async function buildContributor(contributorId: string) {
+    ERUDIT.log.debug.start(
+        `Building contributor ${ERUDIT.log.stress(contributorId)}...`,
+    );
+
+    const directory = `${ERUDIT.config.paths.project}/contributors/${contributorId}`;
+    const files = readdirSync(directory);
+
+    const avatarExtension = files
+        .find((file) => file.startsWith('avatar.'))
+        ?.split('.')
+        .pop();
+
+    if (avatarExtension) {
+        await ERUDIT.repository.db.pushFile(
+            `${directory}/avatar.${avatarExtension}`,
+            `contributor:${contributorId}`,
+        );
+    }
+
+    let moduleDefault: ContributorDefinition | undefined;
+
+    try {
+        moduleDefault = await ERUDIT.import(`${directory}/contributor`);
+    } catch (error) {
+        if (!String(error).includes('Cannot find module')) {
+            ERUDIT.log.error(
+                `Failed to load contributor ${ERUDIT.log.stress(contributorId)} module:\n`,
+            );
+            console.log(error);
+        }
+    }
+
+    let description: ProseElement<AnySchema> | undefined;
+
+    if (isRawElement(moduleDefault?.description)) {
+        const resolveResult = await ERUDIT.repository.prose.resolve(
+            moduleDefault.description,
+            false,
+        );
+
+        for (const file of resolveResult.files) {
+            await ERUDIT.repository.db.pushFile(
+                file,
+                `contributor:${contributorId}`,
+            );
+        }
+
+        description = resolveResult.proseElement;
+    }
+
+    await ERUDIT.db.insert(ERUDIT.db.schema.contributors).values({
+        contributorId,
+        avatarExtension,
+        displayName: moduleDefault?.displayName,
+        short: moduleDefault?.short,
+        links: moduleDefault?.links,
+        editor: moduleDefault?.editor,
+        description: description,
+    });
+}

package/server/erudit/contributors/global.ts

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

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,178 @@
+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

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

package/server/erudit/contributors/search.ts

@@ -0,0 +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;
+        }),
+    };
+}