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

package/server/plugin/bitran/location.ts

@@ -1,25 +0,0 @@
-import {
-    decodeBitranLocation,
-    parseBitranLocation,
-} from '@erudit-js/cog/schema';
-
-export function parseUrlLocation(urlLocation: string) {
-    urlLocation = decodeURIComponent(urlLocation);
-    urlLocation = decodeBitranLocation(urlLocation);
-
-    if (!urlLocation)
-        throw createError({
-            statusCode: 500,
-            statusText: 'Empty content location router parameter!',
-        });
-
-    try {
-        return parseBitranLocation(urlLocation);
-    } catch (error: any) {
-        throw createError({
-            statusCode: 404,
-            statusText:
-                error?.message || `Can't parse location "${urlLocation}"!`,
-        });
-    }
-}

package/server/plugin/bitran/products/include.ts

@@ -1,228 +0,0 @@
-import { BlockNode, type ElementNode } from '@bitran-js/core';
-import type { BitranTranspiler } from '@bitran-js/transpiler';
-
-import {
-    parseBitranLocation,
-    parsePartialBitranLocation,
-    stringifyBitranLocation,
-    tryReplaceAlias,
-    type BitranAliases,
-    type BitranContext,
-} from '@erudit-js/cog/schema';
-import { IncludeNode } from '@erudit-js/bitran-elements/include/shared';
-import { AliasesNode } from '@erudit-js/bitran-elements/aliases/shared';
-import { LinkNode } from '@erudit-js/bitran-elements/link/shared';
-import { createLinkTarget } from '@erudit-js/bitran-elements/link/target';
-
-import { createBitranTranspiler } from '@server/bitran/transpiler';
-import { ERUDIT_SERVER } from '@server/global';
-import { DbUnique } from '@server/db/entities/Unique';
-import {
-    toAbsoluteContentId,
-    toAbsoluteContentLocation,
-} from '@server/content/absoluteId';
-
-export type TraverseEnterFn = (payload: {
-    _location: string;
-    _bitranTranspiler: BitranTranspiler;
-    _biCode: string;
-}) => Promise<any>;
-
-export type TraverseStepFn = (payload: {
-    _location: string;
-    _bitranTranspiler: BitranTranspiler;
-    _node: ElementNode;
-}) => Promise<any>;
-
-export type TraverseLeaveFn = (payload: { _location: string }) => Promise<any>;
-
-/**
- * This operation is heavy as fuck.
- * It consumes a lot of memory and is slow.
- * Use as rarely as possible!
- */
-export async function traverseInclude(
-    includeNode: IncludeNode,
-    context: BitranContext,
-    listeners: {
-        enter?: TraverseEnterFn;
-        step?: TraverseStepFn;
-        leave?: TraverseLeaveFn;
-    },
-) {
-    const entryLocation = stringifyBitranLocation(
-        parsePartialBitranLocation(includeNode.id, context.location),
-    );
-
-    const travelMap: Record<string, string | null> = {
-        // Not displayed when error, but needed for checking infinite loops
-        [entryLocation]: null,
-    };
-
-    try {
-        await _traverseStep(
-            includeNode,
-            entryLocation,
-            context.aliases,
-            listeners,
-            travelMap,
-        );
-    } catch (message) {
-        let finalMessage = `Include Traversal Error!\n\n${message}\n\n`;
-
-        for (const [location, includeTarget] of Object.entries(
-            travelMap,
-        ).reverse()) {
-            if (includeTarget === null) continue;
-
-            finalMessage += `at "${printIncludeTarget(includeTarget)}" in "${location}"\n`;
-        }
-
-        throw new Error(finalMessage);
-    }
-}
-
-async function _traverseStep(
-    includeNode: IncludeNode,
-    location: string,
-    aliases: BitranAliases,
-    listeners: {
-        enter?: TraverseEnterFn;
-        step?: TraverseStepFn;
-        leave?: TraverseLeaveFn;
-    },
-    travelMap: Record<string, string | null>,
-) {
-    let includeTargetLocation: string;
-
-    try {
-        const parsedLocation = parseBitranLocation(location);
-
-        includeTargetLocation = stringifyBitranLocation(
-            parsePartialBitranLocation(
-                tryReplaceAlias(includeNode.parseData.location, aliases),
-                parsedLocation,
-            ),
-        );
-
-        includeTargetLocation = toAbsoluteContentLocation(
-            includeTargetLocation,
-            parsedLocation.path!,
-        );
-    } catch (error) {
-        travelMap[location] = includeNode.parseData.location;
-        throw error;
-    }
-
-    if (includeTargetLocation in travelMap)
-        throw `Include "${printIncludeTarget(includeNode.parseData.location)}" targets "${includeTargetLocation}" which creates infinite loop!`;
-
-    travelMap[location] = includeNode.parseData.location;
-
-    //
-    // Loading Unique this Include is referencing to.
-    //
-
-    const dbUnique = await ERUDIT_SERVER.DB.manager.findOne(DbUnique, {
-        where: { location: includeTargetLocation },
-    });
-
-    if (!dbUnique)
-        throw `Include "${printIncludeTarget(includeNode.parseData.location)}" is targeting to non-existing unique "${includeTargetLocation}"!`;
-
-    //
-    // Creating Bitran core within loaded unique's location context.
-    //
-
-    const context: BitranContext = {
-        location: parseBitranLocation(includeTargetLocation),
-        aliases: dbUnique.context.aliases,
-    };
-
-    const bitranTranspiler = await createBitranTranspiler();
-
-    listeners.enter &&
-        (await listeners.enter({
-            _biCode: dbUnique.content,
-            _location: includeTargetLocation,
-            _bitranTranspiler: bitranTranspiler,
-        }));
-
-    //
-    // Parsing unique content and sub-traversing all includes if any.
-    //
-
-    let stepErrorMessage: string | undefined;
-
-    await bitranTranspiler.parser.parse(dbUnique.content, {
-        step: async (node) => {
-            if (stepErrorMessage) return;
-
-            // Skip Alias nodes to prevent them being injected into calling document context and possibly conflicting with other aliases, includes and links...
-            if (node instanceof AliasesNode) return;
-
-            // Replacing block ids with absolute ones to make possible to link to them
-            if (node instanceof BlockNode)
-                node.meta.id = Object.keys(travelMap)
-                    .concat([location])
-                    .join('__');
-
-            if (node instanceof LinkNode) {
-                const linkTarget = createLinkTarget(node.parseData.target, {
-                    location: context.location,
-                    aliases: context.aliases ?? {},
-                });
-
-                switch (linkTarget.type) {
-                    case 'unique':
-                        node.parseData.target = toAbsoluteContentLocation(
-                            linkTarget.strlocation,
-                            context.location?.path!,
-                        );
-                        break;
-                    case 'page':
-                        node.parseData.target = `page|${linkTarget.pageType as any}|${toAbsoluteContentId(linkTarget.path!, context.location?.path!)}`;
-                        break;
-                }
-            }
-
-            if (!(node instanceof IncludeNode)) {
-                listeners.step &&
-                    (await listeners.step({
-                        _location: includeTargetLocation,
-                        _node: node,
-                        _bitranTranspiler: bitranTranspiler,
-                    }));
-
-                return;
-            }
-
-            try {
-                await _traverseStep(
-                    node,
-                    includeTargetLocation,
-                    context.aliases,
-                    listeners,
-                    travelMap,
-                );
-            } catch (message: any) {
-                stepErrorMessage = message;
-            }
-        },
-    });
-
-    if (stepErrorMessage) throw stepErrorMessage;
-
-    //
-    // Leaving from current Include
-    //
-
-    listeners.leave &&
-        (await listeners.leave({
-            _location: includeTargetLocation,
-        }));
-}
-
-function printIncludeTarget(target: string) {
-    return `<~ ${target}`;
-}

package/server/plugin/bitran/products/link.ts

@@ -1,116 +0,0 @@
-import {
-    isTopicPart,
-    parseBitranLocation,
-    stringifyBitranLocation,
-    type BitranContext,
-} from '@erudit-js/cog/schema';
-import type { LinkParseData } from '@erudit-js/bitran-elements/link/shared';
-import {
-    createLinkTarget,
-    type LinkTarget,
-} from '@erudit-js/bitran-elements/link/target';
-
-import { DbUnique } from '@server/db/entities/Unique';
-import { ERUDIT_SERVER } from '@server/global';
-import { DbContent } from '@server/db/entities/Content';
-import { DbContributor } from '@server/db/entities/Contributor';
-import {
-    toAbsoluteContentId,
-    toAbsoluteContentLocation,
-} from '@server/content/absoluteId';
-
-import {
-    createBitranLocationLink,
-    createContentLink,
-    createContributorLink,
-    createTopicPartLink,
-} from '@erudit/shared/link';
-
-export async function resolveLinkTarget(
-    linkData: LinkParseData,
-    context: BitranContext,
-): Promise<LinkTarget> {
-    const linkTarget = createLinkTarget(linkData.target, context);
-
-    if (linkTarget.type === 'unique') {
-        const absoluteLocation = toAbsoluteContentLocation(
-            linkTarget.strlocation,
-            context.location?.path!,
-        );
-
-        const dbUnique = await ERUDIT_SERVER.DB.manager.findOne(DbUnique, {
-            select: ['location', 'productName'],
-            where: { location: absoluteLocation },
-        });
-
-        if (!dbUnique)
-            throw new Error(
-                `Unique "${linkTarget.strlocation}" does not exist!`,
-            );
-
-        const targetLocation = parseBitranLocation(dbUnique.location);
-
-        linkTarget._productName = dbUnique.productName;
-        linkTarget._href = createBitranLocationLink(targetLocation);
-        linkTarget._absoluteStrLocation =
-            stringifyBitranLocation(targetLocation);
-    } else if (linkTarget.type === 'page') {
-        const absoluteContentId = toAbsoluteContentId(
-            linkTarget.path!,
-            context.location?.path,
-        );
-
-        switch (linkTarget.pageType) {
-            case 'article':
-            case 'summary':
-            case 'practice':
-            case 'group':
-            case 'book':
-                {
-                    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(
-                        DbContent,
-                        {
-                            where: { contentId: absoluteContentId },
-                        },
-                    );
-
-                    if (!dbContent)
-                        throw new Error(
-                            `Page "${linkTarget.pageType}|${absoluteContentId}" does not exist!`,
-                        );
-
-                    linkTarget._href = isTopicPart(linkTarget.pageType)
-                        ? createTopicPartLink(
-                              linkTarget.pageType,
-                              absoluteContentId,
-                          )
-                        : createContentLink(
-                              linkTarget.pageType,
-                              absoluteContentId,
-                          );
-                }
-                break;
-
-            case 'contributor':
-                {
-                    const dbContributor =
-                        await ERUDIT_SERVER.DB.manager.findOne(DbContributor, {
-                            select: ['contributorId'],
-                            where: { contributorId: absoluteContentId },
-                        });
-
-                    if (!dbContributor)
-                        throw new Error(
-                            `Contributor "${absoluteContentId}" does not exist!`,
-                        );
-
-                    linkTarget._href = createContributorLink(
-                        dbContributor.contributorId,
-                    );
-                }
-                break;
-        }
-    }
-
-    return linkTarget;
-}

package/server/plugin/bitran/setup.ts

@@ -1,11 +0,0 @@
-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.config')
-        ).default;
-    } catch {}
-}

package/server/plugin/bitran/toc.ts

@@ -1,75 +0,0 @@
-import { type ElementNode } from '@bitran-js/core';
-import type { BitranLocation } from '@erudit-js/cog/schema';
-import {
-    headingName,
-    HeadingNode,
-} from '@erudit-js/bitran-elements/heading/shared';
-
-import type { Toc } from '@erudit/shared/bitran/toc';
-import { ERUDIT_SERVER } from '@server/global';
-import { getBitranContent } from './content';
-import { createBitranTranspiler } from './transpiler';
-
-export async function getBitranToc(location: BitranLocation) {
-    const content = await getBitranContent(location, false);
-    const bitranCore = await createBitranTranspiler();
-
-    const toc: Toc = [];
-
-    await bitranCore.parser.parse(content.biCode, {
-        async step(node) {
-            tryAddToToc(node as ElementNode);
-        },
-    });
-
-    return toc;
-
-    function tryAddToToc(node: ElementNode) {
-        const tocItemBase = {
-            id: node.id,
-            productName: node.name,
-        };
-
-        // Check if node is manually excluded from TOC
-        if (typeof node.meta?.toc === 'boolean' && !node.meta?.toc) return;
-
-        if (node instanceof HeadingNode) {
-            toc.push({
-                ...tocItemBase,
-                level: node.parseData.level - 1,
-                title: node.parseData.title,
-            });
-            return;
-        }
-
-        const notHeadingLevel = () => {
-            // If TOC is empty, we're at the root level
-            if (toc.length === 0) return 0;
-
-            // Find the most recent heading to determine parent level
-            for (let i = toc.length - 1; i >= 0; i--) {
-                if (toc[i].productName === headingName) {
-                    // Found a heading, return its level + 1
-                    return toc[i].level + 1;
-                }
-            }
-
-            // No heading found in TOC, place at root level
-            return 0;
-        };
-
-        if (
-            ERUDIT_SERVER.BITRAN_CONFIG?.toc?.includes(node.name) ||
-            node.meta?.toc
-        ) {
-            // Erudit Bitran config says to add these products to TOC
-            // Or show in TOC any product with truthy `toc` meta property
-            toc.push({
-                ...tocItemBase,
-                level: notHeadingLevel(),
-                title: node.meta?.title || node.parseData?.title,
-            });
-            return;
-        }
-    }
-}

package/server/plugin/bitran/transpiler.ts

@@ -1,30 +0,0 @@
-import {
-    defineBitranTranspiler,
-    type ElementTranspilers,
-} from '@bitran-js/transpiler';
-import { eruditDefaultTranspilers } from '@erudit-js/bitran-elements/defaultTranspilers';
-
-import { ERUDIT_SERVER } from '@server/global';
-
-export async function createBitranTranspiler() {
-    const projectTranspilers = await getProjectTranspilers();
-
-    const bitranTranspiler = defineBitranTranspiler({
-        ...projectTranspilers,
-        ...eruditDefaultTranspilers,
-    });
-
-    return bitranTranspiler;
-}
-
-async function getProjectTranspilers(): Promise<ElementTranspilers> {
-    const bitranElements = ERUDIT_SERVER?.BITRAN_CONFIG?.elements;
-
-    if (!bitranElements) return {};
-
-    const projectTranspilers: ElementTranspilers = {};
-    for (const [name, bitranElement] of Object.entries(bitranElements))
-        projectTranspilers[name] = await bitranElement.transpiler();
-
-    return projectTranspilers;
-}

package/server/plugin/build/close.ts

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

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

@@ -1,176 +0,0 @@
-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-js/cog/schema';
-import { resolvePaths } from '@erudit-js/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;
-}