erudit 3.0.0-dev.11 → 3.0.0-dev.13

package/server/api/aside/minor/path.ts

@@ -1,22 +1,26 @@
 import { isTopicPart, locationFromPath } from '@erudit-js/cog/schema';
 
 import type { AsideMinorContent, AsideMinorTopic } from '@shared/aside/minor';
-import { getBitranToc } from '@erudit/server/plugin/bitran/toc';
+import { getBitranToc } from '@server/bitran/toc';
 import {
     getContentContributors,
-    getFullContentId,
     getPreviousNext,
-} from '@erudit/server/plugin/repository/content';
-import { getTopicPartsLinks } from '@erudit/server/plugin/repository/topic';
+} from '@server/repository/content';
+import { getTopicPartsLinks } from '@server/repository/topic';
+import {
+    getFullContentId,
+    getShortContentId,
+} from '@server/repository/contentId';
 
 export default defineEventHandler(async (event) => {
     const query = getQuery<{ path: string }>(event);
 
-    if (!query.path)
+    if (!query.path) {
         throw createError({
             statusCode: 400,
             statusText: 'Missing "path" query parameter!',
         });
+    }
 
     const path = query.path.substring(1);
     const pathStart = path.split('/')[0];
@@ -32,14 +36,18 @@ export default defineEventHandler(async (event) => {
 async function createTopicData(path: string): Promise<AsideMinorTopic> {
     const location = locationFromPath(path);
 
-    if (!location)
+    if (!location) {
         throw createError({
             statusCode: 400,
             statusText: `Provided path "${path}" is not a valid topic location!`,
         });
+    }
+
+    if (location.path) {
+        location.path = await getFullContentId(location.path);
+    }
 
     const contentId = location.path;
-    const fullContentId = (await getFullContentId(contentId))!;
 
     const toc = await getBitranToc(location);
     const previousNext = await getPreviousNext(contentId);
@@ -48,7 +56,7 @@ async function createTopicData(path: string): Promise<AsideMinorTopic> {
 
     return {
         type: 'topic',
-        fullContentId,
+        topicId: contentId,
         location,
         toc,
         nav: {
@@ -63,14 +71,14 @@ async function createContentData(
     type: string,
     path: string,
 ): Promise<AsideMinorContent> {
-    const contentId = path.split('/').slice(1).join('/');
-    const fullContentId = (await getFullContentId(contentId))!;
+    const rawContentId = path.split('/').slice(1).join('/');
+    const contentId = (await getFullContentId(rawContentId))!;
     const previousNext = await getPreviousNext(contentId);
     const contributors = await getContentContributors(contentId);
 
     return {
         type: type as any,
-        fullContentId,
+        contentId,
         nav: previousNext,
         contributors,
     };

package/server/api/bitran/content/[...location].ts

@@ -1,8 +1,10 @@
-import { parseUrlLocation } from '@server/bitran/location';
+import { parseClientBitranLocation } from '@server/bitran/location';
 import { getBitranContent } from '@server/bitran/content';
 
 export default defineEventHandler(async (event) => {
     setResponseHeader(event, 'Content-Type', 'application/json; charset=utf-8');
-    const location = parseUrlLocation(event.context.params!.location || '');
+    const location = await parseClientBitranLocation(
+        event.context.params!.location,
+    );
     return await getBitranContent(location);
 });

package/server/api/bitran/toc/[...location].ts

@@ -1,7 +1,9 @@
-import { parseUrlLocation } from '@server/bitran/location';
+import { parseClientBitranLocation } from '@server/bitran/location';
 import { getBitranToc } from '@server/bitran/toc';
 
 export default defineEventHandler(async (event) => {
-    const location = parseUrlLocation(event.context.params!.location || '');
+    const location = await parseClientBitranLocation(
+        event.context.params!.location,
+    );
     return await getBitranToc(location);
 });

package/server/api/content/data.ts

@@ -1,6 +1,7 @@
 import { getTopicPartsLinks } from '@server/repository/topic';
 import { getContentBookFor } from '@server/repository/book';
 import { getContentGenericData } from '@server/repository/content';
+import { getFullContentId } from '@server/repository/contentId';
 
 import type { ContentGenericData } from '@shared/content/data/base';
 import type { ContentTopicData } from '@shared/content/data/type/topic';
@@ -8,13 +9,15 @@ import type { ContentGroupData } from '@shared/content/data/type/group';
 import type { ContentBookData } from '@shared/content/data/type/book';
 
 export default defineEventHandler(async (event) => {
-    const contentId = getQuery(event)?.contentId as string;
+    let contentId = getQuery(event)?.contentId as string;
+    contentId = await getFullContentId(contentId);
 
-    if (!contentId)
+    if (!contentId) {
         throw createError({
             statusCode: 400,
             statusText: 'Missing content ID!',
         });
+    }
 
     const generic = await getContentGenericData(contentId);
 

package/server/api/prerender.ts

@@ -0,0 +1,120 @@
+import {
+    encodeBitranLocation,
+    parseBitranLocation,
+    stringifyBitranLocation,
+} from '@erudit-js/cog/schema';
+
+import { DbUnique } from '@server/db/entities/Unique';
+import { ERUDIT_SERVER } from '@server/global';
+import { DbBook } from '@server/db/entities/Book';
+import { DbTopic } from '@server/db/entities/Topic';
+import { DbGroup } from '@server/db/entities/Group';
+import { DbContributor } from '@server/db/entities/Contributor';
+import { getShortContentId } from '@server/repository/contentId';
+
+export default defineEventHandler(async () => {
+    const routes: string[] = [];
+    routes.push(...language());
+    routes.push(...(await previewUniques()));
+    routes.push(...(await previewPages()));
+
+    return routes;
+});
+
+//
+//
+//
+
+function language() {
+    const phraseRoutes = Object.keys(ERUDIT_SERVER.LANGUAGE?.phrases || []).map(
+        (phraseId) => `/api/language/phrase/${phraseId}`,
+    );
+    return ['/api/language/functions', ...phraseRoutes];
+}
+
+async function previewUniques() {
+    const dbUniques = await ERUDIT_SERVER.DB.manager.find(DbUnique, {
+        select: ['location'],
+    });
+
+    if (!dbUniques) {
+        return [];
+    }
+
+    const routes: string[] = [];
+    for (const dbUnique of dbUniques) {
+        const location = parseBitranLocation(dbUnique.location);
+
+        if (location.path) {
+            location.path = await getShortContentId(location.path);
+        }
+
+        routes.push(
+            `/api/preview/unique/${encodeBitranLocation(stringifyBitranLocation(location))}`,
+        );
+    }
+    return routes;
+}
+
+async function previewPages() {
+    const pageRoutes: string[] = [];
+
+    // Books
+
+    const dbBooks = await ERUDIT_SERVER.DB.manager.find(DbBook, {
+        select: ['contentId'],
+    });
+
+    if (dbBooks) {
+        for (const dbBook of dbBooks) {
+            const bookId = await getShortContentId(dbBook.contentId);
+            pageRoutes.push(`/api/preview/page/book/${bookId}`);
+        }
+    }
+
+    // Topics
+
+    const dbTopics = await ERUDIT_SERVER.DB.manager.find(DbTopic, {
+        select: ['contentId', 'parts'],
+    });
+
+    if (dbTopics) {
+        for (const dbTopic of dbTopics) {
+            const topicId = await getShortContentId(dbTopic.contentId);
+            for (const part of dbTopic.parts) {
+                pageRoutes.push(`/api/preview/page/${part}/${topicId}`);
+            }
+        }
+    }
+
+    // Groups
+
+    const dbGroups = await ERUDIT_SERVER.DB.manager.find(DbGroup, {
+        select: ['contentId'],
+    });
+
+    if (dbGroups) {
+        for (const dbGroup of dbGroups) {
+            const groupId = await getShortContentId(dbGroup.contentId);
+            pageRoutes.push(`/api/preview/page/group/${groupId}`);
+        }
+    }
+
+    // Contributors
+
+    const dbContributors = await ERUDIT_SERVER.DB.manager.find(DbContributor, {
+        select: ['contributorId'],
+    });
+
+    if (dbContributors) {
+        for (const dbContributor of dbContributors) {
+            pageRoutes.push(
+                `/api/preview/page/contributor/${dbContributor.contributorId}`,
+            );
+        }
+    }
+
+    // // //
+
+    return pageRoutes;
+}

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

@@ -1,13 +1,17 @@
+import type { LinkTargetPageType } from '@erudit-js/bitran-elements/link/target';
+import { isContentType } from '@erudit-js/cog/schema';
+
 import {
     getContentContext,
     getTopicPartContext,
     getContributorContext,
-} from '@erudit/server/plugin/content/context';
-
-import type { LinkTargetPageType } from '@erudit-js/bitran-elements/link/target';
+} from '@server/content/context';
+import { getFullContentId } from '@server/repository/contentId';
+import { ERUDIT_SERVER } from '@server/global';
+import { DbContent } from '@server/db/entities/Content';
 
-import type { PreviewDataPageLink } from '@app/scripts/preview/data/pageLink';
 import type { Context, ContextItem } from '@erudit/shared/content/context';
+import type { PreviewDataPageLink } from '@app/scripts/preview/data/pageLink';
 
 export default defineEventHandler<Promise<PreviewDataPageLink>>(
     async (event) => {
@@ -37,8 +41,30 @@ export default defineEventHandler<Promise<PreviewDataPageLink>>(
             .map((c) => c.title)
             .join(' / ');
 
+        const description = await (async () => {
+            if (!isContentType(pageType)) {
+                return;
+            }
+
+            const fullContentId = await getFullContentId(contentId);
+            const dbContent = await ERUDIT_SERVER.DB.manager.findOne(
+                DbContent,
+                {
+                    select: ['description'],
+                    where: { contentId: fullContentId },
+                },
+            );
+
+            if (!dbContent) {
+                return;
+            }
+
+            return dbContent.description?.trim();
+        })();
+
         return <PreviewDataPageLink>{
             type: 'page-link',
+            description,
             footer: {
                 secondary:
                     (contextStr ? contextStr + ' • ' : '') +

package/server/api/preview/unique/{[location].ts → [...location].ts}

@@ -2,13 +2,12 @@ import {
     stringifyBitranLocation,
     type BitranContext,
 } from '@erudit-js/cog/schema';
-import type { BitranContent } from '@bitran-js/renderer-vue';
 
-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 { parseClientBitranLocation } from '@server/bitran/location';
 
 import type { Context } from '@shared/content/context';
 import type { StringBitranContent } from '@erudit/shared/bitran/stringContent';
@@ -26,7 +25,9 @@ interface ReturnType {
 export default defineEventHandler<Promise<ReturnType>>(async (event) => {
     setResponseHeader(event, 'Content-Type', 'application/json; charset=utf-8');
 
-    const location = parseUrlLocation(getRouterParam(event, 'location') || '');
+    const location = await parseClientBitranLocation(
+        event.context.params!.location,
+    );
 
     const context = await getLocationContext(location);
 

package/server/plugin/bitran/content.ts

@@ -1,6 +1,5 @@
 import {
     BlockErrorNode,
-    BlockNode,
     BlocksNode,
     createRenderData,
     ElementNode,
@@ -12,7 +11,6 @@ import {
     isTopicPart,
     mergeAliases,
     NO_ALIASES,
-    setEruditBitranRuntime,
     stringifyBitranLocation,
     type BitranContext,
     type BitranLocation,
@@ -111,17 +109,13 @@ async function createBitranContent(
     biCode: string,
     generatePrerenderData: boolean = true,
 ): Promise<StringBitranContent> {
-    const bitranTranspiler = await createBitranTranspiler();
-
     const runtime: EruditBitranRuntime = {
         eruditConfig: ERUDIT_SERVER.CONFIG,
-        context,
         insideInclude: false,
+        context,
     };
 
-    [bitranTranspiler.parser, bitranTranspiler.stringifier].forEach((item) =>
-        setEruditBitranRuntime(item, runtime),
-    );
+    const bitranTranspiler = await createBitranTranspiler(runtime);
 
     const renderDataStorage: RenderDataStorage = {};
 
@@ -183,14 +177,7 @@ async function resolveInclude(
     let _blocks;
 
     try {
-        const blocks: BlockNode[] = [];
-
-        await traverseInclude(includeNode, context, {
-            step: async ({ _node }) => {
-                if (_node instanceof BlockNode) blocks.push(_node);
-            },
-        });
-
+        const blocks = await traverseInclude(includeNode, context, {});
         const blocksNode = new BlocksNode(includeNode);
         blocksNode.setNodes(blocks);
         _blocks = blocksNode;

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

@@ -3,7 +3,6 @@ import type { BitranTranspiler } from '@bitran-js/transpiler';
 import {
     parseBitranLocation,
     parsePartialBitranLocation,
-    setEruditBitranRuntime,
     stringifyBitranLocation,
     tryReplaceAlias,
     type BitranAliases,
@@ -15,9 +14,10 @@ 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 { getNavBookIds } from '@server/nav/utils';
-
-import { toAbsoluteLocation } from '@shared/bitran/contentId';
+import {
+    resolveClientContentId,
+    serverAbsolutizeContentPath,
+} from '@server/repository/contentId';
 
 export type TraverseEnterFn = (payload: {
     _location: string;
@@ -41,24 +41,27 @@ export async function traverseInclude(
         step?: TraverseStepFn;
         leave?: TraverseLeaveFn;
     },
-) {
-    const entryLocation = stringifyBitranLocation(
-        parsePartialBitranLocation(includeNode.id, context.location),
+): Promise<BlockNode[]> {
+    const rawLocation = parsePartialBitranLocation(
+        includeNode.id,
+        context.location,
     );
 
-    // Always use absolute locations as keys for travelMap to avoid infinite loop bugs
-    const absEntryLocation = toAbsoluteLocation(
-        entryLocation,
-        context.location.path!,
-        getNavBookIds(),
-    );
+    if (rawLocation.path) {
+        rawLocation.path = serverAbsolutizeContentPath(
+            rawLocation.path,
+            context.location.path!,
+        );
+    }
+
+    const absEntryLocation = stringifyBitranLocation(rawLocation);
 
     const travelMap: Record<string, string | null> = {
         [absEntryLocation]: null,
     };
 
     try {
-        await _traverseStep(
+        return await _traverseInclude(
             includeNode,
             absEntryLocation,
             context.aliases,
@@ -79,7 +82,7 @@ export async function traverseInclude(
     }
 }
 
-async function _traverseStep(
+async function _traverseInclude(
     includeNode: IncludeNode,
     location: string,
     aliases: BitranAliases,
@@ -89,24 +92,27 @@ async function _traverseStep(
         leave?: TraverseLeaveFn;
     },
     travelMap: Record<string, string | null>,
-) {
+): Promise<BlockNode[]> {
     let includeTargetLocation: string;
 
     try {
         const parsedLocation = parseBitranLocation(location);
 
-        includeTargetLocation = stringifyBitranLocation(
-            parsePartialBitranLocation(
+        includeTargetLocation = (() => {
+            const _location = parsePartialBitranLocation(
                 tryReplaceAlias(includeNode.parseData.location, aliases),
                 parsedLocation,
-            ),
-        );
+            );
 
-        includeTargetLocation = toAbsoluteLocation(
-            includeTargetLocation,
-            parsedLocation.path!,
-            getNavBookIds(),
-        );
+            if (_location.path) {
+                _location.path = serverAbsolutizeContentPath(
+                    _location.path,
+                    parsedLocation.path!,
+                );
+            }
+
+            return stringifyBitranLocation(_location);
+        })();
     } catch (error) {
         travelMap[location] = includeNode.parseData.location;
         throw new Error(
@@ -144,15 +150,11 @@ async function _traverseStep(
         aliases: dbUnique.context.aliases,
     };
 
-    const bitranTranspiler = await createBitranTranspiler();
-
-    [bitranTranspiler.parser, bitranTranspiler.stringifier].forEach((item) =>
-        setEruditBitranRuntime(item, {
-            eruditConfig: ERUDIT_SERVER.CONFIG,
-            context: structuredClone(context),
-            insideInclude: true,
-        }),
-    );
+    const bitranTranspiler = await createBitranTranspiler({
+        eruditConfig: ERUDIT_SERVER.CONFIG,
+        context: structuredClone(context),
+        insideInclude: true,
+    });
 
     if (listeners.enter) {
         await listeners.enter({
@@ -168,7 +170,7 @@ async function _traverseStep(
 
     let stepErrorMessage: string | Error | undefined;
 
-    await bitranTranspiler.parser.parse(dbUnique.content, {
+    const rootNode = await bitranTranspiler.parser.parse(dbUnique.content, {
         step: async (node) => {
             if (stepErrorMessage) return;
 
@@ -193,7 +195,7 @@ async function _traverseStep(
             }
 
             try {
-                await _traverseStep(
+                await _traverseInclude(
                     node,
                     includeTargetLocation,
                     context.aliases,
@@ -218,6 +220,8 @@ async function _traverseStep(
             _location: includeTargetLocation,
         });
     }
+
+    return (rootNode.children as BlockNode[]) ?? [];
 }
 
 function printIncludeTarget(target: string) {

package/server/plugin/bitran/location.ts

@@ -3,23 +3,37 @@ import {
     parseBitranLocation,
 } from '@erudit-js/cog/schema';
 
-export function parseUrlLocation(urlLocation: string) {
-    urlLocation = decodeURIComponent(urlLocation);
-    urlLocation = decodeBitranLocation(urlLocation);
+import { getFullContentId } from '@server/repository/contentId';
 
-    if (!urlLocation)
+export async function parseClientBitranLocation(clientLocation: string) {
+    clientLocation = decodeURIComponent(clientLocation);
+    clientLocation = decodeBitranLocation(clientLocation);
+
+    if (!clientLocation) {
         throw createError({
-            statusCode: 500,
+            statusCode: 400,
             statusText: 'Empty content location router parameter!',
         });
+    }
 
     try {
-        return parseBitranLocation(urlLocation);
-    } catch (error: any) {
+        const location = parseBitranLocation(clientLocation);
+
+        if (location.path) {
+            location.path = await getFullContentId(location.path);
+        }
+
+        return location;
+    } catch (_error) {
+        let error = `Failed to parse client location "${clientLocation}"!`;
+
+        if (_error) {
+            error += '\n\n' + _error;
+        }
+
         throw createError({
-            statusCode: 404,
-            statusText:
-                error?.message || `Can't parse location "${urlLocation}"!`,
+            statusCode: 400,
+            statusText: error,
         });
     }
 }

package/server/plugin/bitran/toc.ts

@@ -1,5 +1,5 @@
 import { type ElementNode } from '@bitran-js/core';
-import type { BitranLocation } from '@erudit-js/cog/schema';
+import { NO_ALIASES, type BitranLocation } from '@erudit-js/cog/schema';
 import {
     headingName,
     HeadingNode,
@@ -16,7 +16,12 @@ import { createBitranTranspiler } from './transpiler';
 
 export async function getBitranToc(location: BitranLocation) {
     const content = await getBitranContent(location, false);
-    const bitranCore = await createBitranTranspiler();
+
+    const bitranCore = await createBitranTranspiler({
+        eruditConfig: ERUDIT_SERVER.CONFIG,
+        insideInclude: false,
+        context: { aliases: NO_ALIASES(), location },
+    });
 
     const toc: Toc = [];
 

package/server/plugin/bitran/transpiler.ts

@@ -1,9 +1,18 @@
 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() {
+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/jobs/content/generic.ts

@@ -80,12 +80,11 @@ async function scanContentFiles() {
 
 async function addContentItem(navNode: NavNode) {
     debug.start(
-        `Adding ${stress(navNode.type)} content item ${stress(navNode.id)}...`,
+        `Adding ${stress(navNode.type)} content item ${stress(navNode.shortId)}...`,
     );
 
     const dbContent = new DbContent();
-    dbContent.contentId = navNode.id;
-    dbContent.fullId = navNode.fullId;
+    dbContent.contentId = navNode.fullId;
     dbContent.type = navNode.type;
     dbContent.decoration = getDecoration(navNode);
     dbContent.ogImage = await getOgImageData(navNode);
@@ -134,7 +133,7 @@ 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!`,
+                `${navNode.type.at(0)!.toUpperCase() + navNode.type.slice(1)} ${stress(navNode.fullId)} has no contributors!`,
             );
 
         return;
@@ -143,13 +142,13 @@ async function addContributions(navNode: NavNode, contributors?: string[]) {
     for (const contributorId of contributors) {
         if (!(await contributorExists(contributorId))) {
             logger.warn(
-                `Skipping unknown contributor ${stress(contributorId)} when adding ${navNode.type} ${stress(navNode.id)}!`,
+                `Skipping unknown contributor ${stress(contributorId)} when adding ${navNode.type} ${stress(navNode.fullId)}!`,
             );
             continue;
         }
 
         const dbContribution = new DbContribution();
-        dbContribution.contentId = navNode.id;
+        dbContribution.contentId = navNode.fullId;
         dbContribution.contributorId = contributorId;
         await ERUDIT_SERVER.DB.manager.save(dbContribution);
     }

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

@@ -29,7 +29,11 @@ export async function parseBitranContent(
     context.location = location;
     context.aliases = NO_ALIASES();
 
-    bitranTranspiler ||= await createBitranTranspiler();
+    bitranTranspiler ||= await createBitranTranspiler({
+        context,
+        eruditConfig: ERUDIT_SERVER.CONFIG,
+        insideInclude: false,
+    });
 
     // Tracking heading nodes to deal with them later
     const headings: HeadingNode[] = [];