erudit 2.0.0-dev.7

package/server/plugin/bitran/setup.ts

@@ -0,0 +1,10 @@
+import { PROJECT_DIR } from '#erudit/globalPaths';
+import { IMPORT } from '@server/importer';
+import { ERUDIT_SERVER } from '@server/global';
+
+export async function setupBitranConfig() {
+    try {
+        ERUDIT_SERVER.BITRAN_CONFIG = await IMPORT(PROJECT_DIR + '/bitran.ts');
+        console.log(ERUDIT_SERVER.BITRAN_CONFIG);
+    } catch {}
+}

package/server/plugin/bitran/toc.ts

@@ -0,0 +1,82 @@
+import type { ProductNode } from 'bitran/dom';
+
+import { getRawBitranContent } from './content';
+import { createBitranCore } from './core';
+import type { BitranLocation } from '@erudit/shared/bitran/location';
+import type { Toc } from '@erudit/shared/bitran/toc';
+import { IncludeNode } from '@erudit/shared/bitran/products/include/core';
+import { traverseInclude } from './products/include';
+import { HeadingNode } from '@erudit/shared/bitran/products/heading/core';
+import { headingName } from '@erudit/shared/bitran/products/heading/shared';
+import { ERUDIT_SERVER } from '../global';
+
+export async function getBitranToc(location: BitranLocation) {
+    const rawContent = await getRawBitranContent(location);
+    const bitranCore = await createBitranCore(rawContent.context);
+
+    const toc: Toc = [];
+
+    await bitranCore.parser.parse(rawContent.biCode, {
+        step: async (productNode) => {
+            if (productNode instanceof IncludeNode) {
+                await traverseInclude(productNode, rawContent.context, {
+                    step: async ({ _node }) => tryAddToToc(_node),
+                });
+            } else tryAddToToc(productNode);
+        },
+    });
+
+    return toc;
+
+    function tryAddToToc(product: ProductNode) {
+        const tocItemBase = {
+            id: product.getId(),
+            productName: product.name,
+        };
+
+        // Check if node is manually excluded from TOC
+        if (typeof product.meta?.toc === 'boolean' && !product.meta?.toc)
+            return;
+
+        if (product instanceof HeadingNode) {
+            toc.push({
+                ...tocItemBase,
+                level: product.parseData.level,
+                title: product.parseData.title,
+            });
+            return;
+        }
+
+        const notHeadingLevel = () => {
+            // Toc items without heading are at top level
+            if (toc.length === 0) return 0;
+
+            const lastTocItem = toc.at(-1)!;
+
+            // Going one level deep if previous item was a heading and copy deep level if not
+            return lastTocItem.productName === headingName
+                ? lastTocItem.level + 1
+                : lastTocItem.level;
+        };
+
+        if (ERUDIT_SERVER.BITRAN_CONFIG?.toc?.includes(product.name)) {
+            // Erudit Config says to add these products to TOC
+            toc.push({
+                ...tocItemBase,
+                level: notHeadingLevel(),
+                title: product.meta?.title || product.parseData?.title,
+            });
+            return;
+        }
+
+        if (product.meta?.toc) {
+            // Show in Toc any product with truthy `toc` meta property
+            toc.push({
+                ...tocItemBase,
+                level: notHeadingLevel(),
+                title: product.meta?.title || product.parseData?.title,
+            });
+            return;
+        }
+    }
+}

package/server/plugin/build/close.ts

@@ -0,0 +1,10 @@
+import { debug, logger } from '@server/logger';
+import { ERUDIT_SERVER } from '@server/global';
+
+export async function close() {
+    debug.start('Shutting down server...');
+
+    await ERUDIT_SERVER.DB?.destroy();
+
+    logger.success('Server shut down gracefully!');
+}

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

@@ -0,0 +1,8 @@
+import type { DbContent } from '@server/db/entities/Content';
+import type { NavNode } from '@server/nav/node';
+
+export interface BuilderFunctionArgs<T = any> {
+    navNode: NavNode;
+    dbContent: DbContent;
+    config?: Partial<T>;
+}

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

@@ -0,0 +1,176 @@
+import { existsSync } from 'node:fs';
+import { globSync } from 'glob';
+import chalk from 'chalk';
+import sizeOf from 'image-size';
+import {
+    contentTypes,
+    type ContentConfig,
+    type ContentReferences,
+    type ContentType,
+} from 'erudit-cog/schema';
+import { resolvePaths } from 'erudit-cog/kit';
+
+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 { 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 { 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...');
+
+    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 addContentItem(navNode: NavNode) {
+    debug.start(
+        `Adding ${stress(navNode.type)} content item ${stress(navNode.id)}...`,
+    );
+
+    const dbContent = new DbContent();
+    dbContent.contentId = navNode.id;
+    dbContent.fullId = navNode.fullId;
+    dbContent.type = navNode.type;
+    dbContent.decoration = getDecoration(navNode);
+    dbContent.ogImage = 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.path}/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.id)} 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.id)}!`,
+            );
+            continue;
+        }
+
+        const dbContribution = new DbContribution();
+        dbContribution.contentId = navNode.id;
+        dbContribution.contributorId = contributorId;
+        await ERUDIT_SERVER.DB.manager.save(dbContribution);
+    }
+}
+
+function getOgImageData(navNode: NavNode): ImageData | undefined {
+    const ogImagePath = globSync(
+        contentItemPath(navNode, 'og-image.{svg,webp,jpg,png}'),
+    ).pop();
+
+    if (ogImagePath) {
+        const size = sizeOf(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

@@ -0,0 +1,90 @@
+import type { BitranCore } from 'bitran/core';
+import { assumeGroupItem, type ProductNode } from 'bitran/dom';
+
+import { createBitranCore } from '@server/bitran/core';
+import { DbUnique } from '@server/db/entities/Unique';
+import { ERUDIT_SERVER } from '@server/global';
+
+import { NO_ALIASES } from '@shared/bitran/alias';
+import type { BitranContext } from '@shared/bitran/context';
+import {
+    stringifyBitranLocation,
+    type BitranLocation,
+} from '@shared/bitran/location';
+import { AliasNode } from '@shared/bitran/products/alias/core';
+import { HeadingNode } from '@shared/bitran/products/heading/core';
+
+let context: BitranContext = {} as any;
+let bitranCore: BitranCore;
+
+const blocksAfterHeading = 2;
+
+export async function parseBitranContent(
+    location: BitranLocation,
+    biCode: string,
+) {
+    // Reset Bitran context in order not to create core each time
+    context.location = location;
+    context.aliases = NO_ALIASES();
+
+    bitranCore ||= await createBitranCore(context);
+
+    // Tracking heading nodes to deal with them later
+    let headings: HeadingNode[] = [];
+
+    await bitranCore.parser.parse(biCode, {
+        async step(product) {
+            const meta = product.meta;
+            const uniqueId = meta?.id;
+
+            if (uniqueId) {
+                if (product instanceof HeadingNode) {
+                    headings.push(product);
+                    return;
+                }
+
+                await addUnique(product);
+            }
+        },
+    });
+
+    for (const heading of headings) {
+        let blocksAfter = 0;
+        let content = bitranCore.stringifier.stringify(heading);
+
+        assumeGroupItem(heading).walkForward((product) => {
+            if (blocksAfter >= blocksAfterHeading) return false;
+
+            if (product instanceof AliasNode) return;
+            // Spoiler
+            // Todo
+
+            content += '\n\n' + bitranCore.stringifier.stringify(product);
+            blocksAfter++;
+        });
+
+        await addUnique(heading, content);
+    }
+
+    //
+    //
+    //
+
+    function createUniqueLocation(product: ProductNode) {
+        return stringifyBitranLocation({
+            ...location,
+            ...{ unique: product.meta.id! },
+        });
+    }
+
+    async function addUnique(product: ProductNode, content?: string) {
+        const dbUnique = new DbUnique();
+        dbUnique.location = createUniqueLocation(product);
+        dbUnique.content = content || bitranCore.stringifier.stringify(product);
+        dbUnique.title = product.parseData?.title || product.meta?.title;
+        dbUnique.productName = product.name;
+        dbUnique.context = context;
+
+        await ERUDIT_SERVER.DB.manager.save(dbUnique);
+    }
+}

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

@@ -0,0 +1,6 @@
+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.path}${path ? '/' + path : ''}`;
+}

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

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

@@ -0,0 +1,37 @@
+import { readFileSync } from 'node:fs';
+import type { GroupConfig } from 'erudit-cog/schema';
+
+import { DbGroup } from '@server/db/entities/Group';
+import { ERUDIT_SERVER } from '@erudit/server/plugin/global';
+import type { BuilderFunctionArgs } from '../builderArgs';
+import { contentItemPath } from '../path';
+import { parseBitranContent } from '../parse';
+
+export async function buildGroup({
+    navNode,
+    config,
+}: BuilderFunctionArgs<GroupConfig>) {
+    const dbGroup = new DbGroup();
+    dbGroup.contentId = navNode.id;
+    dbGroup.type = config?.type || 'folder';
+
+    try {
+        const strContent = readFileSync(
+            contentItemPath(navNode, 'content.bi'),
+            'utf-8',
+        );
+
+        if (strContent) {
+            dbGroup.content = strContent;
+            await parseBitranContent(
+                {
+                    type: 'group',
+                    path: navNode.id,
+                },
+                strContent,
+            );
+        }
+    } catch {}
+
+    await ERUDIT_SERVER.DB.manager.save(dbGroup);
+}

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

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { topicParts, type TopicPart } from 'erudit-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.id;
+    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: navNode.id,
+            },
+            strContent,
+        );
+    }
+
+    dbTopic.parts = existingTopicParts;
+    await ERUDIT_SERVER.DB.manager.save(dbTopic);
+}

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

@@ -0,0 +1,66 @@
+import { readFileSync } from 'node:fs';
+import { globSync } from 'glob';
+import path from 'node:path';
+import chalk from 'chalk';
+import { resolvePaths } from 'erudit-cog/kit';
+import type { ContributorConfig } from 'erudit-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.description = description;
+
+    await ERUDIT_SERVER.DB.manager.save(dbContributor);
+}

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

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