erudit 2.0.0-dev.7

package/server/api/preview/page/[...parts].ts

@@ -0,0 +1,51 @@
+import {
+    getContentContext,
+    getTopicPartContext,
+    getContributorContext,
+} from '@erudit/server/plugin/content/context';
+
+import type { PreviewDataPageLink } from '@app/scripts/preview/data/pageLink';
+import type { LinkTargetPageType } from '@erudit/shared/bitran/products/link/target';
+import type { Context, ContextItem } from '@erudit/shared/content/context';
+
+export default defineEventHandler<Promise<PreviewDataPageLink>>(
+    async (event) => {
+        const urlParts = (event.context.params?.parts || '').split('/');
+        const pageType: LinkTargetPageType = urlParts.shift() as any;
+        const contentId: string = urlParts.join('/');
+
+        const context: Context = await (async () => {
+            switch (pageType) {
+                case 'book':
+                case 'group':
+                    return await getContentContext(contentId);
+                case 'article':
+                case 'summary':
+                case 'practice':
+                    return await getTopicPartContext(pageType, contentId);
+                case 'contributor':
+                    return await getContributorContext(contentId);
+            }
+
+            throw createError(`Can't handle "${pageType}" page type!`);
+        })();
+
+        const lastContextItem = context.pop() as ContextItem;
+        const contextStr = context
+            .filter((c) => !c.hidden)
+            .map((c) => c.title)
+            .join(' / ');
+
+        return <PreviewDataPageLink>{
+            type: 'page-link',
+            footer: {
+                secondary:
+                    (contextStr ? contextStr + ' • ' : '') +
+                    lastContextItem.type,
+                primary: lastContextItem.title,
+                href: lastContextItem.href,
+                iconName: lastContextItem.icon,
+            },
+        };
+    },
+);

package/server/api/preview/unique/[location].ts

@@ -0,0 +1,55 @@
+import type { BitranContent } from 'bitran';
+
+import { parseUrlLocation } from '@server/bitran/location';
+import { getLocationContext } from '@server/content/context';
+import { ERUDIT_SERVER } from '@server/global';
+import { DbUnique } from '@server/db/entities/Unique';
+import { getBitranContent } from '@server/bitran/content';
+
+import type { Context } from '@shared/content/context';
+import type { BitranContext } from '@shared/bitran/context';
+import { stringifyBitranLocation } from '@shared/bitran/location';
+
+interface ReturnType {
+    context: Context;
+    productTitle?: string;
+    bitran: {
+        productName: string;
+        context: BitranContext;
+        content: BitranContent;
+    };
+}
+
+export default defineEventHandler<Promise<ReturnType>>(async (event) => {
+    const location = parseUrlLocation(getRouterParam(event, 'location') || '');
+
+    const context = await getLocationContext(location);
+
+    const dbUnique = await (async () => {
+        const dbUnique = ERUDIT_SERVER.DB.manager.findOne(DbUnique, {
+            select: ['productName', 'title', 'context'],
+            where: { location: stringifyBitranLocation(location) },
+        });
+
+        if (!dbUnique)
+            throw createError(
+                `Missing unique "${stringifyBitranLocation(location)}"!`,
+            );
+
+        return dbUnique as any as DbUnique;
+    })();
+
+    const bitran = await (async () => {
+        return {
+            content: await getBitranContent(location),
+            context: dbUnique.context,
+            productName: dbUnique.productName,
+        };
+    })();
+
+    return <ReturnType>{
+        context,
+        productTitle: dbUnique.title,
+        bitran,
+    };
+});

package/server/plugin/bitran/content.ts

@@ -0,0 +1,176 @@
+import type { BitranContent, BitranPreRenderData } from 'bitran';
+import { createRenderData } from 'bitran/core';
+import { BlockNode } from 'bitran/dom';
+import { BlocksNode, ErrorNode } from 'bitran/default';
+import type { BitranContext } from '@erudit/shared/bitran/context';
+import {
+    stringifyBitranLocation,
+    type BitranLocation,
+} from '@erudit/shared/bitran/location';
+import { ERUDIT_SERVER } from '../global';
+import { DbUnique } from '../db/entities/Unique';
+import { isTopicPart, type TopicPart } from 'erudit-cog/schema';
+import { DbTopic } from '../db/entities/Topic';
+import { DbGroup } from '../db/entities/Group';
+import { NO_ALIASES } from '@erudit/shared/bitran/alias';
+import { createBitranCore } from './core';
+import { IncludeNode } from '@erudit/shared/bitran/products/include/core';
+import { LinkNode } from '@erudit/shared/bitran/products/link/core';
+import { resolveLinkTarget } from './products/link';
+import { traverseInclude } from './products/include';
+
+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,
+    // @ts-ignore
+): 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() },
+        };
+    }
+
+    throwNotFound();
+}
+
+async function createBitranContent(
+    context: BitranContext,
+    biCode: string,
+): Promise<BitranContent> {
+    const bitranCore = await createBitranCore(context);
+
+    const root = await bitranCore.parser.parse(biCode, {
+        step: async (productNode) => {
+            if (productNode instanceof IncludeNode)
+                await resolveInclude(productNode, context);
+        },
+    });
+
+    const finalContent = bitranCore.stringifier.stringify(root);
+
+    // Building render data
+    const renderData: BitranPreRenderData = {};
+    await bitranCore.parser.parse(finalContent, {
+        step: async (productNode) => {
+            const id = productNode.getId();
+            const productCore = bitranCore.products[productNode.name]!;
+
+            if (productNode instanceof LinkNode) {
+                try {
+                    renderData[id] = {
+                        status: 'success',
+                        data: await resolveLinkTarget(productNode.parseData, {
+                            location: context.location,
+                            aliases: context.aliases ?? {},
+                        }),
+                    };
+                } catch (error: any) {
+                    renderData[id] = {
+                        status: 'error',
+                        errorMessage: error?.message || error,
+                    };
+                }
+                return;
+            }
+
+            if (id)
+                renderData[id] = await createRenderData(
+                    'pre',
+                    productNode,
+                    productCore,
+                );
+        },
+    });
+
+    return {
+        biCode: finalContent,
+        renderData,
+    };
+}
+
+async function resolveInclude(
+    includeNode: IncludeNode,
+    context: BitranContext,
+): Promise<IncludeNode | ErrorNode> {
+    let _blocks;
+
+    try {
+        const blocks: BlockNode[] = [];
+
+        await traverseInclude(includeNode, context, {
+            step: async ({ _location, _node, _bitranCore }) => {
+                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;
+}

package/server/plugin/bitran/core.ts

@@ -0,0 +1,51 @@
+import {
+    createBitranCore as _createBitranCore,
+    type GenericProductCore,
+} from 'bitran/core';
+
+import { ERUDIT_SERVER } from '@server/global';
+import type { BitranContext } from '@erudit/shared/bitran/context';
+
+// Erudit Products
+import { headingName } from '@erudit/shared/bitran/products/heading/shared';
+import { heading } from '@erudit/shared/bitran/products/heading/core';
+import { aliasName } from '@erudit/shared/bitran/products/alias/shared';
+import { defineAlias } from '@erudit/shared/bitran/products/alias/core';
+import { includeName } from '@erudit/shared/bitran/products/include/shared';
+import { include } from '@erudit/shared/bitran/products/include/core';
+import { linkName } from '@erudit/shared/bitran/products/link/shared';
+import { link } from '@erudit/shared/bitran/products/link/core';
+
+type Products = Record<string, GenericProductCore>;
+
+export async function createBitranCore(context: BitranContext) {
+    const projectProducts = await getProjectProducts();
+
+    const eruditProducts: Products = {
+        [aliasName]: defineAlias(context), // Exec aliases logic on server and pass resolved aliases as RenderData -> no actions on client at all
+        [includeName]: include,
+        [headingName]: heading,
+        [linkName]: link,
+    };
+
+    const bitranCore = _createBitranCore({
+        products: {
+            ...projectProducts,
+            ...eruditProducts,
+        },
+    });
+
+    return bitranCore;
+}
+
+async function getProjectProducts(): Promise<Products> {
+    const productDefinitions = ERUDIT_SERVER?.BITRAN_CONFIG?.products;
+
+    if (!productDefinitions) return {};
+
+    const projectProducts: Products = {};
+    for (const [name, definition] of Object.entries(productDefinitions))
+        projectProducts[name] = await definition.core();
+
+    return projectProducts;
+}

package/server/plugin/bitran/location.ts

@@ -0,0 +1,25 @@
+import {
+    decodeBitranLocation,
+    parseBitranLocation,
+} from '@erudit/shared/bitran/location';
+
+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

@@ -0,0 +1,229 @@
+import type { BitranCore } from 'bitran/core';
+import { BlockNode, type ProductNode } from 'bitran/dom';
+
+import type { BitranContext } from '@erudit/shared/bitran/context';
+import { IncludeNode } from '@erudit/shared/bitran/products/include/core';
+import {
+    parseBitranLocation,
+    parsePartialBitranLocation,
+    stringifyBitranLocation,
+} from '@erudit/shared/bitran/location';
+import {
+    tryReplaceAlias,
+    type BitranAliases,
+} from '@erudit/shared/bitran/alias';
+import {
+    toAbsoluteContentId,
+    toAbsoluteContentLocation,
+} from '../../content/absoluteId';
+import { ERUDIT_SERVER } from '../../global';
+import { DbUnique } from '../../db/entities/Unique';
+import { createBitranCore } from '../core';
+import { AliasNode } from '@erudit/shared/bitran/products/alias/core';
+import { LinkNode } from '@erudit/shared/bitran/products/link/core';
+import { createLinkTarget } from '@erudit/shared/bitran/products/link/target';
+
+export type TraverseEnterFn = (payload: {
+    _location: string;
+    _bitranCore: BitranCore;
+    _biCode: string;
+}) => Promise<any>;
+
+export type TraverseStepFn = (payload: {
+    _location: string;
+    _bitranCore: BitranCore;
+    _node: ProductNode;
+}) => 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.getId(), 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 bitranCore = await createBitranCore(context);
+
+    listeners.enter &&
+        (await listeners.enter({
+            _biCode: dbUnique.content,
+            _location: includeTargetLocation,
+            _bitranCore: bitranCore,
+        }));
+
+    //
+    // Parsing unique content and sub-traversing all includes if any.
+    //
+
+    let stepErrorMessage: string | undefined;
+
+    await bitranCore.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 AliasNode) 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}|${toAbsoluteContentId(linkTarget.path!, context.location?.path!)}`;
+                        break;
+                }
+            }
+
+            if (!(node instanceof IncludeNode)) {
+                listeners.step &&
+                    (await listeners.step({
+                        _location: includeTargetLocation,
+                        _node: node,
+                        _bitranCore: bitranCore,
+                    }));
+
+                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

@@ -0,0 +1,114 @@
+import {
+    createLinkTarget,
+    type LinkTarget,
+} from '@erudit/shared/bitran/products/link/target';
+import {
+    toAbsoluteContentId,
+    toAbsoluteContentLocation,
+} from '../../content/absoluteId';
+import type { BitranContext } from '@erudit/shared/bitran/context';
+import type { LinkData } from '@erudit/shared/bitran/products/link/shared';
+import { DbUnique } from '../../db/entities/Unique';
+import { ERUDIT_SERVER } from '../../global';
+import {
+    parseBitranLocation,
+    stringifyBitranLocation,
+} from '@erudit/shared/bitran/location';
+import {
+    createBitranLocationLink,
+    createContentLink,
+    createContributorLink,
+    createTopicPartLink,
+} from '@erudit/shared/link';
+import { DbContent } from '../../db/entities/Content';
+import { isTopicPart } from 'erudit-cog/schema';
+import { DbContributor } from '../../db/entities/Contributor';
+
+export async function resolveLinkTarget(
+    linkData: LinkData,
+    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;
+}