erudit 3.0.0-dev.2 → 3.0.0-dev.21

package/server/plugin/bitran/content.ts

@@ -1,187 +1,252 @@
-import { isTopicPart, type TopicPart } from 'erudit-cog/schema';
-import { createPreRenderData, type PreRenderData } from '@bitran-js/transpiler';
-import { BlockNode, BlocksNode } from '@bitran-js/core';
-import { type BitranContent } from '@bitran-js/renderer-vue';
-import {
-    AliasesNode,
-    mergeAliases,
-    NO_ALIASES,
-} from '@erudit-js/bitran-elements/aliases/shared';
-import { IncludeNode } from '@erudit-js/bitran-elements/include/shared';
-
-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 { resolveLinkTarget } from '@server/bitran/products/link';
-import { traverseInclude } from '@server/bitran/products/include';
-import { createBitranTranspiler } from '@server/bitran/transpiler';
-
-import type { BitranContext } from '@erudit/shared/bitran/context';
-import {
-    stringifyBitranLocation,
-    type BitranLocation,
-} from '@erudit/shared/bitran/location';
-import { LinkNode } from '@erudit/shared/bitran/link/shared';
-
-interface RawBitranContent {
-    context: BitranContext;
-    biCode: string;
-}
-
-export async function getBitranContent(
-    location: BitranLocation,
-): Promise<BitranContent> {
-    const rawContent = await getRawBitranContent(location);
-    const bitranContent = await createBitranContent(
-        rawContent.context,
-        rawContent.biCode,
-    );
-    return bitranContent;
-}
-
-export async function getRawBitranContent(
-    location: BitranLocation,
-): Promise<RawBitranContent> {
-    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 === 'group') {
-        const dbGroup = await ERUDIT_SERVER.DB.manager.findOne(DbGroup, {
-            select: ['contentId', 'content'],
-            where: { contentId: location.path },
-        });
-
-        if (!dbGroup) throwNotFound();
-
-        return {
-            biCode: dbGroup!.content!,
-            context: { location, aliases: NO_ALIASES() },
-        };
-    }
-
-    return throwNotFound();
-}
-
-async function createBitranContent(
-    context: BitranContext,
-    biCode: string,
-): Promise<BitranContent> {
-    const bitranTranspiler = await createBitranTranspiler();
-
-    const root = await bitranTranspiler.parser.parse(biCode, {
-        async step(node) {
-            if (node instanceof AliasesNode) {
-                mergeAliases(context.aliases, node.parseData);
-                return;
-            }
-
-            if (node instanceof IncludeNode) {
-                await resolveInclude(node, context);
-                return;
-            }
-        },
-    });
-
-    const finalContent = await bitranTranspiler.stringifier.stringify(root);
-
-    // Building render data
-    const preRenderDataMap: Record<string, PreRenderData> = {};
-    await bitranTranspiler.parser.parse(finalContent, {
-        step: async (node) => {
-            const id = node.id;
-            const elementTranspiler = bitranTranspiler.transpilers[node.name]!;
-
-            if (node instanceof LinkNode) {
-                try {
-                    preRenderDataMap[id] = {
-                        type: 'success',
-                        data: await resolveLinkTarget(node.parseData, {
-                            location: context.location,
-                            aliases: context.aliases ?? {},
-                        }),
-                    };
-                } catch (error: any) {
-                    preRenderDataMap[id] = {
-                        type: 'error',
-                        message: error?.message || String(error),
-                    };
-                }
-                return;
-            }
-
-            if (id) {
-                const preRenderData = await createPreRenderData(
-                    node,
-                    elementTranspiler,
-                );
-                if (preRenderData) preRenderDataMap[id] = preRenderData;
-            }
-        },
-    });
-
-    return {
-        biCode: finalContent,
-        preRenderData: preRenderDataMap,
-    };
-}
-
-async function resolveInclude(
-    includeNode: IncludeNode,
-    context: BitranContext,
-): Promise<IncludeNode> {
-    let _blocks;
-
-    try {
-        const blocks: BlockNode[] = [];
-
-        await traverseInclude(includeNode, context, {
-            step: async ({ _node }) => {
-                if (_node instanceof BlockNode) blocks.push(_node);
-            },
-        });
-
-        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;
-}
+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 === 'group') {
+        const dbGroup = await ERUDIT_SERVER.DB.manager.findOne(DbGroup, {
+            select: ['contentId', 'content'],
+            where: { contentId: location.path },
+        });
+
+        if (!dbGroup) throwNotFound();
+
+        return {
+            biCode: dbGroup!.content!,
+            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}`);
+}