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

package/server/plugin/bitran/content.ts

@@ -1,238 +0,0 @@
-import {
-    BlockErrorNode,
-    BlocksNode,
-    createRenderData,
-    ElementNode,
-    InlinerErrorNode,
-    walkDown,
-    type RenderDataStorage,
-} from '@bitran-js/core';
-import {
-    isTopicPart,
-    mergeAliases,
-    NO_ALIASES,
-    stringifyBitranLocation,
-    type BitranContext,
-    type BitranLocation,
-    type EruditBitranRuntime,
-    type TopicPart,
-} from '@erudit-js/cog/schema';
-import { AliasesNode } from '@erudit-js/bitran-elements/aliases/shared';
-import { IncludeNode } from '@erudit-js/bitran-elements/include/shared';
-import {
-    ProblemNode,
-    ProblemsNode,
-} from '@erudit-js/bitran-elements/problem/shared';
-import {
-    prerenderProblem,
-    prerenderProblems,
-} from '@erudit-js/bitran-elements/problem/prerender';
-import { LinkNode } from '@erudit-js/bitran-elements/link/shared';
-import { prerenderLink } from '@erudit-js/bitran-elements/link/prerender';
-
-import { ERUDIT_SERVER } from '@server/global';
-import { DbUnique } from '@server/db/entities/Unique';
-import { DbTopic } from '@server/db/entities/Topic';
-import { DbGroup } from '@server/db/entities/Group';
-import { DbContributor } from '@server/db/entities/Contributor';
-import { traverseInclude } from '@server/bitran/elements/include';
-import { createBitranTranspiler } from '@server/bitran/transpiler';
-import { logger } from '@server/logger';
-
-import { type RawBitranContent } from '@erudit/shared/bitran/content';
-
-export async function getBitranContent(
-    location: BitranLocation,
-    generatePrerenderData: boolean = true,
-): Promise<RawBitranContent> {
-    const { biCode, context } = await retrieveContentFrom(location);
-    const bitranContent = await createBitranContent(
-        context,
-        biCode,
-        generatePrerenderData,
-    );
-    return bitranContent;
-}
-
-//
-// Local
-//
-
-async function retrieveContentFrom(location: BitranLocation) {
-    const throwNotFound = () => {
-        throw createError({
-            statusCode: 404,
-            statusText: `Can't find content for location "${stringifyBitranLocation(location)}"!`,
-        });
-    };
-
-    if (location.unique) {
-        const dbUnique = await ERUDIT_SERVER.DB.manager.findOne(DbUnique, {
-            where: { location: stringifyBitranLocation(location) },
-        });
-
-        if (!dbUnique) throwNotFound();
-
-        return {
-            biCode: dbUnique!.content,
-            context: dbUnique!.context,
-        };
-    }
-
-    if (isTopicPart(location.type)) {
-        const topicPart = location.type as TopicPart;
-
-        const dbTopic = await ERUDIT_SERVER.DB.manager.findOne(DbTopic, {
-            select: ['contentId', topicPart],
-            where: { contentId: location.path },
-        });
-
-        if (!dbTopic) throwNotFound();
-
-        return {
-            biCode: dbTopic![topicPart]!,
-            context: { location, aliases: NO_ALIASES() },
-        };
-    }
-
-    if (location.type === 'contributor') {
-        const dbContributor = await ERUDIT_SERVER.DB.manager.findOne(
-            DbContributor,
-            {
-                select: ['description'],
-                where: { contributorId: location.path },
-            },
-        );
-
-        if (!dbContributor) throwNotFound();
-
-        return {
-            biCode: dbContributor!.description!,
-            context: { location, aliases: NO_ALIASES() },
-        };
-    }
-
-    return throwNotFound();
-}
-
-async function createBitranContent(
-    context: BitranContext,
-    biCode: string,
-    generatePrerenderData: boolean = true,
-): Promise<RawBitranContent> {
-    const runtime: EruditBitranRuntime = {
-        eruditConfig: ERUDIT_SERVER.CONFIG,
-        insideInclude: false,
-        context,
-    };
-
-    const bitranTranspiler = await createBitranTranspiler(runtime);
-
-    const renderDataStorage: RenderDataStorage = {};
-
-    const routes: string[] = [];
-    const addRoute = (
-        newRoutes: string | undefined | (string | undefined)[],
-    ) => {
-        if (Array.isArray(newRoutes)) {
-            routes.push(...(newRoutes.filter(Boolean) as string[]));
-        } else if (newRoutes) {
-            routes.push(newRoutes);
-        }
-    };
-
-    async function setNodeRenderData(node: ElementNode) {
-        if (generatePrerenderData === false) {
-            return;
-        }
-
-        const transpiler = bitranTranspiler.transpilers[node.name];
-
-        const renderDataResult = await createRenderData({
-            storage: renderDataStorage,
-            node,
-            extra: runtime,
-            generator: transpiler?.renderDataGenerator,
-        });
-
-        if (renderDataResult?.type === 'success') {
-            node.renderData = renderDataResult.data;
-        }
-    }
-
-    async function addNodePrerenderRoute(node: ElementNode) {
-        switch (true) {
-            case node instanceof ProblemNode:
-                addRoute(prerenderProblem(node));
-                break;
-            case node instanceof ProblemsNode:
-                addRoute(await prerenderProblems(node, runtime));
-                break;
-            case node instanceof LinkNode:
-                addRoute(prerenderLink(node, runtime));
-                break;
-        }
-    }
-
-    const root = await bitranTranspiler.parser.parse(biCode, {
-        async step(node) {
-            switch (true) {
-                case node instanceof BlockErrorNode:
-                case node instanceof InlinerErrorNode:
-                    logParseError(node.name, node.error);
-                    return;
-                case node instanceof AliasesNode:
-                    mergeAliases(context.aliases, node.parseData);
-                    break;
-                case node instanceof IncludeNode:
-                    const includeNode = await resolveInclude(node, context);
-                    await walkDown(includeNode, async (child) => {
-                        if (child instanceof ElementNode) {
-                            await setNodeRenderData(child);
-                            await addNodePrerenderRoute(child);
-                        }
-                    });
-                    break;
-            }
-
-            await setNodeRenderData(node);
-            await addNodePrerenderRoute(node);
-        },
-    });
-
-    const finalContent = await bitranTranspiler.stringifier.stringify(root);
-
-    return {
-        biCode: finalContent,
-        storage: renderDataStorage,
-        routes,
-        context: {
-            location: context.location,
-            aliases: context.aliases,
-        },
-    };
-}
-
-async function resolveInclude(
-    includeNode: IncludeNode,
-    context: BitranContext,
-): Promise<IncludeNode> {
-    let _blocks;
-
-    try {
-        const blocks = await traverseInclude(includeNode, context, {});
-        const blocksNode = new BlocksNode(includeNode);
-        blocksNode.setNodes(blocks);
-        _blocks = blocksNode;
-        includeNode.parseData.blocks = _blocks;
-    } catch (error: any) {
-        includeNode.parseData.error = error?.message || error;
-    }
-
-    includeNode.parseData.resolved = true;
-    return includeNode;
-}
-
-function logParseError(nodeName: string, error: string) {
-    logger.warn(`Error parsing "${nodeName}" element!\n\n${error}`);
-}

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

@@ -1,229 +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 { createBitranTranspiler } from '@server/bitran/transpiler';
-import { ERUDIT_SERVER } from '@server/global';
-import { DbUnique } from '@server/db/entities/Unique';
-import {
-    resolveClientContentId,
-    serverAbsolutizeContentPath,
-} from '@server/repository/contentId';
-
-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>;
-
-export async function traverseInclude(
-    includeNode: IncludeNode,
-    context: BitranContext,
-    listeners: {
-        enter?: TraverseEnterFn;
-        step?: TraverseStepFn;
-        leave?: TraverseLeaveFn;
-    },
-): Promise<BlockNode[]> {
-    const rawLocation = parsePartialBitranLocation(
-        includeNode.id,
-        context.location,
-    );
-
-    if (rawLocation.path) {
-        rawLocation.path = serverAbsolutizeContentPath(
-            rawLocation.path,
-            context.location.path!,
-        );
-    }
-
-    const absEntryLocation = stringifyBitranLocation(rawLocation);
-
-    const travelMap: Record<string, string | null> = {
-        [absEntryLocation]: null,
-    };
-
-    try {
-        return await _traverseInclude(
-            includeNode,
-            absEntryLocation,
-            context.aliases,
-            listeners,
-            travelMap,
-        );
-    } catch (message) {
-        let finalMessage = `Include Traversal Error!\n\n${message instanceof Error ? message.message : message}\n\n`;
-
-        // Print the traversal path in the order of traversal
-        for (const location of Object.keys(travelMap)) {
-            const includeTarget = travelMap[location];
-            if (includeTarget === null) continue;
-            finalMessage += `at "${printIncludeTarget(includeTarget)}" in "${location}"\n`;
-        }
-
-        throw new Error(finalMessage);
-    }
-}
-
-async function _traverseInclude(
-    includeNode: IncludeNode,
-    location: string,
-    aliases: BitranAliases,
-    listeners: {
-        enter?: TraverseEnterFn;
-        step?: TraverseStepFn;
-        leave?: TraverseLeaveFn;
-    },
-    travelMap: Record<string, string | null>,
-): Promise<BlockNode[]> {
-    let includeTargetLocation: string;
-
-    try {
-        const parsedLocation = parseBitranLocation(location);
-
-        includeTargetLocation = (() => {
-            const _location = parsePartialBitranLocation(
-                tryReplaceAlias(includeNode.parseData.location, aliases),
-                parsedLocation,
-            );
-
-            if (_location.path) {
-                _location.path = serverAbsolutizeContentPath(
-                    _location.path,
-                    parsedLocation.path!,
-                );
-            }
-
-            return stringifyBitranLocation(_location);
-        })();
-    } catch (error) {
-        travelMap[location] = includeNode.parseData.location;
-        throw new Error(
-            `Failed to resolve include target location "${includeNode.parseData.location}" from "${location}": ${error instanceof Error ? error.message : error}`,
-        );
-    }
-
-    // Use only absolute locations as keys for infinite loop detection
-    if (includeTargetLocation in travelMap)
-        throw new Error(
-            `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 new Error(
-            `Include "${printIncludeTarget(includeNode.parseData.location)}" is targeting 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({
-        eruditConfig: ERUDIT_SERVER.CONFIG,
-        context: structuredClone(context),
-        insideInclude: true,
-    });
-
-    if (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 | Error | undefined;
-
-    const rootNode = 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 IncludeNode)) {
-                if (listeners.step) {
-                    await listeners.step({
-                        _location: includeTargetLocation,
-                        _node: node,
-                        _bitranTranspiler: bitranTranspiler,
-                    });
-                }
-                return;
-            }
-
-            try {
-                await _traverseInclude(
-                    node,
-                    includeTargetLocation,
-                    context.aliases,
-                    listeners,
-                    travelMap,
-                );
-            } catch (err: any) {
-                stepErrorMessage =
-                    err instanceof Error ? err : new Error(String(err));
-            }
-        },
-    });
-
-    if (stepErrorMessage) throw stepErrorMessage;
-
-    //
-    // Leaving from current Include
-    //
-
-    if (listeners.leave) {
-        await listeners.leave({
-            _location: includeTargetLocation,
-        });
-    }
-
-    return (rootNode.children as BlockNode[]) ?? [];
-}
-
-function printIncludeTarget(target: string) {
-    return `<~ ${target}`;
-}

package/server/plugin/bitran/location.ts

@@ -1,40 +0,0 @@
-import {
-    decodeBitranLocation,
-    isContentType,
-    parseBitranLocation,
-} from '@erudit-js/cog/schema';
-
-import { getFullContentId } from '@server/repository/contentId';
-
-export async function parseClientBitranLocation(clientLocation: string) {
-    clientLocation = decodeURIComponent(clientLocation);
-    clientLocation = decodeBitranLocation(clientLocation);
-
-    if (!clientLocation) {
-        throw createError({
-            statusCode: 400,
-            statusText: 'Empty content location router parameter!',
-        });
-    }
-
-    try {
-        const location = parseBitranLocation(clientLocation);
-
-        if (isContentType(location.type)) {
-            location.path = getFullContentId(location.path!);
-        }
-
-        return location;
-    } catch (_error) {
-        let error = `Failed to parse client location "${clientLocation}"!`;
-
-        if (_error) {
-            error += '\n\n' + _error;
-        }
-
-        throw createError({
-            statusCode: 400,
-            statusText: error,
-        });
-    }
-}

package/server/plugin/bitran/toc.ts

@@ -1,94 +0,0 @@
-import { type ElementNode } from '@bitran-js/core';
-import { NO_ALIASES, type BitranLocation } from '@erudit-js/cog/schema';
-import {
-    headingName,
-    HeadingNode,
-} from '@erudit-js/bitran-elements/heading/shared';
-import {
-    ProblemNode,
-    ProblemsNode,
-} from '@erudit-js/bitran-elements/problem/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({
-        eruditConfig: ERUDIT_SERVER.CONFIG,
-        insideInclude: false,
-        context: { aliases: NO_ALIASES(), location },
-    });
-
-    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;
-        };
-
-        // Problems by default are in TOC
-        if (node instanceof ProblemsNode || node instanceof ProblemNode) {
-            toc.push({
-                ...tocItemBase,
-                level: notHeadingLevel(),
-                title: node.meta?.title || node.parseData.info.title,
-            });
-            return;
-        }
-
-        if (
-            ERUDIT_SERVER.CONFIG.bitran?.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,18 +0,0 @@
-import { defineBitranTranspiler } from '@bitran-js/transpiler';
-import {
-    setEruditBitranRuntime,
-    type EruditBitranRuntime,
-} from '@erudit-js/cog/schema';
-
-import getServerTranspilers from '#erudit/bitran/server';
-
-export async function createBitranTranspiler(runtime: EruditBitranRuntime) {
-    const serverTranspiler = await getServerTranspilers();
-    const bitranTranspiler = defineBitranTranspiler(serverTranspiler);
-
-    [bitranTranspiler.parser, bitranTranspiler.stringifier].forEach((item) => {
-        setEruditBitranRuntime(item, runtime);
-    });
-
-    return bitranTranspiler;
-}

package/server/plugin/build/close.ts

@@ -1,12 +0,0 @@
-import { debug, logger } from '@server/logger';
-import { ERUDIT_SERVER } from '@server/global';
-
-export async function close() {
-    debug.start('Shutting down server...');
-
-    if (ERUDIT_SERVER.DB && ERUDIT_SERVER.DB.isInitialized) {
-        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>;
-}