erudit 3.0.0-dev.23 → 3.0.0-dev.26

package/server/plugin/build/jobs/content/generic.ts

@@ -1,191 +0,0 @@
-import { existsSync } from 'node:fs';
-import { globSync } from 'glob';
-import chalk from 'chalk';
-import { imageSizeFromFile } from 'image-size/fromFile';
-import {
-    contentTypes,
-    type ContentConfig,
-    type ContentReferences,
-    type ContentType,
-} from '@erudit-js/cog/schema';
-import { resolvePaths } from '@erudit-js/cog/kit';
-
-import { PROJECT_DIR } from '#erudit/globalPaths';
-import { scanContentPaths } from '@erudit/utils/contentPath';
-import { stress } from '@erudit/utils/stress';
-
-import { debug, logger } from '@server/logger';
-import { ERUDIT_SERVER } from '@server/global';
-import { walkNav } from '@server/nav/utils';
-import { isRootNode, type NavNode } from '@server/nav/node';
-import { DbContent } from '@server/db/entities/Content';
-import { IMPORT } from '@server/importer';
-import { contributorExists } from '@server/repository/contributor';
-import { DbContribution } from '@server/db/entities/Contribution';
-import { DbFile } from '@server/db/entities/File';
-
-import { contentAsset } from '@erudit/shared/asset';
-import type { ImageData } from '@erudit/shared/image';
-
-import type { BuilderFunctionArgs } from './builderArgs';
-import { contentItemPath } from './path';
-import { buildBook } from './type/book';
-import { buildGroup } from './type/group';
-import { buildTopic } from './type/topic';
-
-const typeBuilders: Record<ContentType, Function> = {
-    book: buildBook,
-    group: buildGroup,
-    topic: buildTopic,
-};
-
-export async function buildContent() {
-    if (!ERUDIT_SERVER.NAV) return;
-
-    debug.start('Building content...');
-
-    await scanContentFiles();
-
-    const counters: Record<ContentType, number> = Object.fromEntries(
-        contentTypes.map((contentType) => [contentType, 0]),
-    ) as any;
-
-    await walkNav(async (node) => {
-        if (isRootNode(node)) return;
-        counters[node.type]++;
-        await addContentItem(node);
-    });
-
-    logger.success(
-        'Content built successfully!',
-        chalk.dim(
-            '(' +
-                Object.entries(counters)
-                    .map(([k, v]) => `${k.at(0)!.toUpperCase()}: ${v}`)
-                    .join(', ') +
-                ')',
-        ),
-    );
-}
-
-async function scanContentFiles() {
-    const contentFiles = scanContentPaths(PROJECT_DIR + '/content');
-    for (const [path, fullPath] of Object.entries(contentFiles)) {
-        const dbFile = new DbFile();
-        dbFile.path = path;
-        dbFile.fullPath = fullPath;
-        await ERUDIT_SERVER.DB.manager.save(dbFile);
-    }
-}
-
-async function addContentItem(navNode: NavNode) {
-    debug.start(
-        `Adding ${stress(navNode.type)} content item ${stress(navNode.shortId)}...`,
-    );
-
-    const dbContent = new DbContent();
-    dbContent.contentId = navNode.fullId;
-    dbContent.type = navNode.type;
-    dbContent.decoration = getDecoration(navNode);
-    dbContent.ogImage = await getOgImageData(navNode);
-    dbContent.references = await getContentReferences(navNode);
-
-    let config: Partial<ContentConfig> | undefined;
-
-    try {
-        config = (await IMPORT(contentItemPath(navNode, navNode.type), {
-            default: true,
-        })) as Partial<ContentConfig>;
-
-        dbContent.title = config.title;
-        dbContent.navTitle = config.navTitle;
-        dbContent.description = config.description;
-        dbContent.flags = config.flags;
-        dbContent.dependencies = config.dependencies;
-
-        if (config.seo) {
-            dbContent.seo = {
-                title: config.seo?.title,
-                description: config.seo?.description,
-            };
-        }
-
-        await addContributions(navNode, config.contributors);
-    } catch {}
-
-    await ERUDIT_SERVER.DB.manager.save(dbContent);
-
-    await typeBuilders[navNode.type](<BuilderFunctionArgs>{
-        navNode,
-        dbContent,
-        config,
-    });
-}
-
-function getDecoration(navNode: NavNode) {
-    if (existsSync(contentItemPath(navNode, 'decoration.svg')))
-        return `/${navNode.fsPath}/decoration.svg`;
-
-    return undefined;
-}
-
-async function addContributions(navNode: NavNode, contributors?: string[]) {
-    if (!contributors || !contributors.length) {
-        if (navNode.type !== 'book' && navNode.type !== 'group')
-            logger.warn(
-                `${navNode.type.at(0)!.toUpperCase() + navNode.type.slice(1)} ${stress(navNode.fullId)} has no contributors!`,
-            );
-
-        return;
-    }
-
-    for (const contributorId of contributors) {
-        if (!(await contributorExists(contributorId))) {
-            logger.warn(
-                `Skipping unknown contributor ${stress(contributorId)} when adding ${navNode.type} ${stress(navNode.fullId)}!`,
-            );
-            continue;
-        }
-
-        const dbContribution = new DbContribution();
-        dbContribution.contentId = navNode.fullId;
-        dbContribution.contributorId = contributorId;
-        await ERUDIT_SERVER.DB.manager.save(dbContribution);
-    }
-}
-
-async function getOgImageData(
-    navNode: NavNode,
-): Promise<ImageData | undefined> {
-    const ogImagePath = globSync(
-        contentItemPath(navNode, 'og-image.{svg,webp,jpg,png}'),
-    ).pop();
-
-    if (ogImagePath) {
-        const size = await imageSizeFromFile(ogImagePath);
-        return {
-            src: contentAsset(
-                resolvePaths(ogImagePath).replace(
-                    PROJECT_DIR + '/content/',
-                    '',
-                ),
-            ),
-            width: size.width,
-            height: size.height,
-        };
-    }
-
-    return undefined;
-}
-
-async function getContentReferences(navNode: NavNode) {
-    try {
-        const references = await IMPORT(
-            contentItemPath(navNode, `references`),
-            { default: true },
-        );
-        return references as ContentReferences;
-    } catch (error) {}
-
-    return undefined;
-}

package/server/plugin/build/jobs/content/parse.ts

@@ -1,207 +0,0 @@
-import { ElementNode, walkForward } from '@bitran-js/core';
-import { type BitranTranspiler } from '@bitran-js/transpiler';
-
-import {
-    mergeAliases,
-    NO_ALIASES,
-    stringifyBitranLocation,
-    type BitranContext,
-    type BitranLocation,
-} from '@erudit-js/cog/schema';
-import { AliasesNode } from '@erudit-js/bitran-elements/aliases/shared';
-import { DetailsNode } from '@erudit-js/bitran-elements/details/shared';
-import { HeadingNode } from '@erudit-js/bitran-elements/heading/shared';
-import {
-    problemName,
-    ProblemNode,
-    problemsName,
-    ProblemsNode,
-    type ProblemParseData,
-    type ProblemsParseData,
-} from '@erudit-js/bitran-elements/problem/shared';
-
-import { createBitranTranspiler } from '@server/bitran/transpiler';
-import { ERUDIT_SERVER } from '@server/global';
-import { DbUnique } from '@server/db/entities/Unique';
-import { DbQuickLink } from '@erudit/server/plugin/db/entities/QuickLink';
-import { logger } from '@server/logger';
-import { DbStat } from '@erudit/server/plugin/db/entities/Stat';
-
-let context: BitranContext = {} as any;
-let bitranTranspiler: BitranTranspiler;
-let stats: Record<string, number> = {};
-
-const blocksAfterHeading = 2;
-
-export async function parseBitranContent(
-    location: BitranLocation,
-    biCode: string,
-) {
-    // Reset
-    context.location = location;
-    context.aliases = NO_ALIASES();
-    stats = {};
-
-    bitranTranspiler ||= await createBitranTranspiler({
-        context,
-        eruditConfig: ERUDIT_SERVER.CONFIG,
-        insideInclude: false,
-    });
-
-    // Tracking heading nodes to deal with them later
-    const headings: HeadingNode[] = [];
-
-    await bitranTranspiler.parser.parse(biCode, {
-        async step(node) {
-            const meta = node.meta;
-            const uniqueId = meta?.id;
-
-            tryUpdateStats(node.name);
-            await tryAddQuickLink(node);
-
-            if (node instanceof AliasesNode) {
-                mergeAliases(context.aliases, node.parseData);
-            }
-
-            if (uniqueId) {
-                if (node instanceof HeadingNode) {
-                    headings.push(node);
-                    return;
-                }
-
-                if (node instanceof DetailsNode) {
-                    await addUnique(
-                        node,
-                        await bitranTranspiler.stringifier.stringify(
-                            node.parseData,
-                        ),
-                    );
-                    return;
-                }
-
-                await addUnique(node);
-            }
-        },
-    });
-
-    await saveStats();
-
-    for (const heading of headings) {
-        let blocksAfter = 0;
-        let content = await bitranTranspiler.stringifier.stringify(heading);
-
-        await walkForward(heading, async (node) => {
-            if (blocksAfter >= blocksAfterHeading) return false;
-
-            if (node instanceof AliasesNode) return;
-            if (node instanceof DetailsNode) return;
-            // Todo
-
-            content +=
-                '\n\n' + (await bitranTranspiler.stringifier.stringify(node));
-
-            blocksAfter++;
-        });
-
-        await addUnique(heading, content);
-    }
-
-    //
-    //
-    //
-
-    function createUniqueLocation(node: ElementNode) {
-        return stringifyBitranLocation({
-            ...location,
-            ...{ unique: node.meta.id! },
-        });
-    }
-
-    async function addUnique(node: ElementNode, content?: string) {
-        const dbUnique = new DbUnique();
-        dbUnique.location = createUniqueLocation(node);
-        dbUnique.content =
-            content || (await bitranTranspiler.stringifier.stringify(node));
-
-        dbUnique.title = node.parseData?.title || node.meta?.title || null;
-
-        if (node instanceof ProblemNode || node instanceof ProblemsNode) {
-            dbUnique.title = node.parseData.info.title;
-        }
-
-        dbUnique.productName = node.name;
-        dbUnique.context = context;
-
-        await ERUDIT_SERVER.DB.manager.save(dbUnique);
-    }
-}
-
-function tryUpdateStats(elementName: string) {
-    const trackedNames = (ERUDIT_SERVER.CONFIG?.bitran?.stat ?? []).flat();
-    if (trackedNames.includes(elementName)) {
-        stats[elementName] = (stats[elementName] || 0) + 1;
-    }
-}
-
-async function saveStats() {
-    for (const [elementName, count] of Object.entries(stats)) {
-        const dbStat = new DbStat();
-        dbStat.contentId = context.location.path!;
-        dbStat.elementName = elementName;
-        dbStat.count = count;
-        await ERUDIT_SERVER.DB.manager.save(dbStat);
-    }
-}
-
-async function tryAddQuickLink(element: ElementNode) {
-    const linkProperty = element.meta?.link;
-    if (linkProperty === undefined) return;
-
-    let linkLabel: string | undefined;
-
-    const linkCandidates = [
-        linkProperty,
-        element.parseData?.title,
-        element.meta?.title,
-    ];
-
-    if (element.name === problemName || element.name === problemsName) {
-        const problemParseData = element.parseData as
-            | ProblemParseData
-            | ProblemsParseData;
-        linkCandidates.unshift(problemParseData.info.title);
-    }
-
-    for (const linkCandidate of linkCandidates) {
-        if (typeof linkCandidate === 'string') {
-            const _label = linkCandidate.trim();
-            if (_label) {
-                linkLabel = _label;
-                break;
-            }
-        }
-    }
-
-    if (!linkLabel) {
-        logger.warn(
-            `Missing quick link label for element "${element.id}" at "${context.location.path!}"!`,
-        );
-        return;
-    }
-
-    const dbQuickLink = new DbQuickLink();
-    dbQuickLink.label = linkLabel;
-    dbQuickLink.elementName = element.name;
-    dbQuickLink.elementId = element.id;
-    dbQuickLink.contentId = context.location.path!;
-    dbQuickLink.contentType = context.location.type;
-
-    try {
-        await ERUDIT_SERVER.DB.manager.insert(DbQuickLink, dbQuickLink);
-    } catch (error) {
-        logger.warn(
-            `Failed to insert quick link "${linkLabel}" for element "${element.id}" at "${context.location.path!}"!`,
-            'This is probably because the is already a quick link with same label!',
-        );
-    }
-}

package/server/plugin/build/jobs/content/path.ts

@@ -1,6 +0,0 @@
-import { PROJECT_DIR } from '#erudit/globalPaths';
-import type { NavNode } from '@server/nav/node';
-
-export function contentItemPath(navNode: NavNode, path?: string) {
-    return PROJECT_DIR + `/content/${navNode.fsPath}${path ? '/' + path : ''}`;
-}

package/server/plugin/build/jobs/content/type/book.ts

@@ -1,9 +0,0 @@
-import { DbBook } from '@server/db/entities/Book';
-import { ERUDIT_SERVER } from '@server/global';
-import type { BuilderFunctionArgs } from '../builderArgs';
-
-export async function buildBook({ dbContent }: BuilderFunctionArgs) {
-    const dbBook = new DbBook();
-    dbBook.contentId = dbContent.contentId;
-    await ERUDIT_SERVER.DB.manager.save(dbBook);
-}

package/server/plugin/build/jobs/content/type/group.ts

@@ -1,16 +0,0 @@
-import type { GroupConfig } from '@erudit-js/cog/schema';
-
-import { DbGroup } from '@server/db/entities/Group';
-import { ERUDIT_SERVER } from '@erudit/server/plugin/global';
-import type { BuilderFunctionArgs } from '../builderArgs';
-
-export async function buildGroup({
-    navNode,
-    config,
-}: BuilderFunctionArgs<GroupConfig>) {
-    const dbGroup = new DbGroup();
-    dbGroup.contentId = navNode.fullId;
-    dbGroup.type = config?.type || 'folder';
-
-    await ERUDIT_SERVER.DB.manager.save(dbGroup);
-}

package/server/plugin/build/jobs/content/type/topic.ts

@@ -1,36 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { topicParts, type TopicPart } from '@erudit-js/cog/schema';
-
-import { ERUDIT_SERVER } from '@server/global';
-import { DbTopic } from '@server/db/entities/Topic';
-import type { BuilderFunctionArgs } from '../builderArgs';
-import { contentItemPath } from '../path';
-import { parseBitranContent } from '../parse';
-
-export async function buildTopic({ navNode }: BuilderFunctionArgs) {
-    const dbTopic = new DbTopic();
-    dbTopic.contentId = navNode.fullId;
-    const existingTopicParts: TopicPart[] = [];
-
-    for (const topicPart of topicParts) {
-        const partPath = contentItemPath(navNode, `${topicPart}.bi`);
-        const strContent =
-            existsSync(partPath) && readFileSync(partPath, 'utf-8');
-
-        if (strContent === false) continue;
-
-        existingTopicParts.push(topicPart);
-        dbTopic[topicPart] = strContent;
-
-        await parseBitranContent(
-            {
-                type: topicPart,
-                path: dbTopic.contentId,
-            },
-            strContent,
-        );
-    }
-
-    dbTopic.parts = existingTopicParts;
-    await ERUDIT_SERVER.DB.manager.save(dbTopic);
-}

package/server/plugin/build/jobs/contributors.ts

@@ -1,69 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { globSync } from 'glob';
-import path from 'node:path';
-import chalk from 'chalk';
-import { resolvePaths } from '@erudit-js/cog/kit';
-import type { ContributorConfig } from '@erudit-js/cog/schema';
-
-import { PROJECT_DIR } from '#erudit/globalPaths';
-import { stress } from '@erudit/utils/stress';
-import { debug, logger } from '@server/logger';
-import { ERUDIT_SERVER } from '@server/global';
-import { IMPORT } from '@server/importer';
-import { DbContributor } from '@server/db/entities/Contributor';
-
-export async function buildContributors() {
-    debug.start('Building contributors...');
-
-    const contributorPaths = globSync(PROJECT_DIR + '/contributors/*/');
-    for (const contributorPath of contributorPaths)
-        await addContributor(resolvePaths(contributorPath));
-
-    logger.success(
-        `Contributors built successfully!`,
-        chalk.dim(`(${contributorPaths.length})`),
-    );
-}
-
-async function addContributor(contributorPath: string) {
-    const contributorId = contributorPath.split('/').pop() as string;
-
-    debug.start(`Adding contributor ${stress(contributorId)}...`);
-
-    const avatarFilename = (() => {
-        const avatarPaths = globSync(`${contributorPath}/avatar.*`);
-        if (avatarPaths[0])
-            return avatarPaths[0].split(path.sep).slice(-2).join('/');
-
-        return undefined;
-    })();
-
-    const config: Partial<ContributorConfig> = await (async () => {
-        try {
-            return await IMPORT(`${contributorPath}/contributor`, {
-                default: true,
-            });
-        } catch {
-            return {};
-        }
-    })();
-
-    const description = (() => {
-        try {
-            return readFileSync(`${contributorPath}/description.bi`, 'utf-8');
-        } catch {
-            return undefined;
-        }
-    })();
-
-    const dbContributor = new DbContributor();
-    dbContributor.contributorId = contributorId;
-    dbContributor.avatar = avatarFilename;
-    dbContributor.displayName = config.displayName;
-    dbContributor.isEditor = Boolean(config.editor);
-    dbContributor.slogan = config.slogan;
-    dbContributor.links = config.links;
-    dbContributor.description = description;
-
-    await ERUDIT_SERVER.DB.manager.save(dbContributor);
-}

package/server/plugin/build/jobs/language.ts

@@ -1,36 +0,0 @@
-import { existsSync } from 'node:fs';
-
-import { ERUDIT_DIR } from '#erudit/globalPaths';
-import { stress } from '@erudit/utils/stress';
-import { ERUDIT_SERVER } from '@server/global';
-import { IMPORT } from '@server/importer';
-
-export async function setupLanguage() {
-    const languageCode = ERUDIT_SERVER.CONFIG?.language || 'en';
-    const languageFilePath = ERUDIT_DIR + `/languages/${languageCode}.ts`;
-
-    if (!existsSync(languageFilePath))
-        throw new Error(`Language file for ${stress(languageCode)} not found!`);
-
-    try {
-        const languageModule = await IMPORT(languageFilePath);
-
-        if (!languageModule.default)
-            throw new Error(
-                `Language file for ${stress(languageCode)} is missing default export with phrases!`,
-            );
-
-        const { default: phrases, ...context } = { ...languageModule };
-
-        ERUDIT_SERVER.LANGUAGE = {
-            phrases,
-            functions: Object.entries(context)
-                .filter(([, value]) => typeof value === 'function')
-                .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {}),
-        };
-    } catch (error) {
-        throw new Error(
-            `Error while loading language ${stress(languageCode)}!\n\n${error}`,
-        );
-    }
-}