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

package/server/plugin/build/jobs/content/type/group.ts

@@ -12,7 +12,7 @@ export async function buildGroup({
     config,
 }: BuilderFunctionArgs<GroupConfig>) {
     const dbGroup = new DbGroup();
-    dbGroup.contentId = navNode.id;
+    dbGroup.contentId = navNode.fullId;
     dbGroup.type = config?.type || 'folder';
 
     try {
@@ -26,7 +26,7 @@ export async function buildGroup({
             await parseBitranContent(
                 {
                     type: 'group',
-                    path: navNode.id,
+                    path: dbGroup.contentId,
                 },
                 strContent,
             );

package/server/plugin/build/jobs/content/type/topic.ts

@@ -9,7 +9,7 @@ import { parseBitranContent } from '../parse';
 
 export async function buildTopic({ navNode }: BuilderFunctionArgs) {
     const dbTopic = new DbTopic();
-    dbTopic.contentId = navNode.id;
+    dbTopic.contentId = navNode.fullId;
     const existingTopicParts: TopicPart[] = [];
 
     for (const topicPart of topicParts) {
@@ -25,7 +25,7 @@ export async function buildTopic({ navNode }: BuilderFunctionArgs) {
         await parseBitranContent(
             {
                 type: topicPart,
-                path: navNode.id,
+                path: dbTopic.contentId,
             },
             strContent,
         );

package/server/plugin/build/jobs/nav.ts

@@ -1,6 +1,5 @@
 import { globSync } from 'glob';
 import chalk from 'chalk';
-import { resolvePaths } from '@erudit-js/cog/kit';
 import {
     contentTypes,
     topicParts,
@@ -54,13 +53,15 @@ async function scanChildNodes(
     parent: NavNode | RootNavNode,
     insideBook: boolean,
 ): Promise<{ children: NavNode[] | undefined; newIds: Ids }> {
-    const currentFsPath = isRootNode(parent) ? '' : parent.path;
+    const currentFsPath = isRootNode(parent) ? '' : parent.path + '/';
 
     const nodeFsPaths = globSync(
-        `${PROJECT_DIR}/content/${currentFsPath}/*/{${contentTypes.join(',')}}.{ts,js}`,
-    )
-        .sort()
-        .map((path) => resolvePaths(path));
+        `${currentFsPath}*/{${contentTypes.join(',')}}.{ts,js}`,
+        {
+            cwd: PROJECT_DIR + '/content',
+            posix: true,
+        },
+    ).sort();
 
     let newIds: Ids = {};
     const children: NavNode[] = [];
@@ -77,11 +78,7 @@ async function scanChildNodes(
 
         if (!pathParts) continue; // Wrong path pattern
 
-        const nodePath = nodeFsPath
-            .replace(PROJECT_DIR + '/content/', '')
-            .split('/')
-            .slice(0, -1)
-            .join('/');
+        const nodePath = nodeFsPath.split('/').slice(0, -1).join('/');
 
         if (pathParts.type === 'book' && insideBook) {
             logger.warn(
@@ -96,8 +93,8 @@ async function scanChildNodes(
         const parentId = isRootNode(parent)
             ? ''
             : parent.skip
-              ? parent.id.split('/').slice(0, -1).join('/')
-              : parent.id;
+              ? parent.fullId.split('/').slice(0, -1).join('/')
+              : parent.fullId;
 
         // Regular id might not include parent id part if it is skipped
         const id = parentId ? `${parentId}/${pathParts.id}` : pathParts.id;
@@ -117,14 +114,30 @@ async function scanChildNodes(
             ? pathParts.id
             : `${parent.fullId}/${pathParts.id}`;
 
+        // Short id skips parent ids for nodes with skip=true, except current node
+        const shortId = isRootNode(parent)
+            ? pathParts.id
+            : (() => {
+                  // Traverse up, skipping parent ids where skip=true
+                  let ids: string[] = [];
+                  let p: NavNode | RootNavNode | undefined = parent;
+                  while (p && !isRootNode(p)) {
+                      if (!p.skip) ids.unshift(p.idPart);
+                      p = p.parent;
+                  }
+                  ids.push(pathParts.id);
+                  return ids.join('/');
+              })();
+
         const skip = pathParts.sep === '+';
 
         const childNode: NavNode = {
             parent,
             type: pathParts.type,
             path: nodePath,
-            id,
+            idPart: pathParts.id,
             fullId,
+            shortId,
             skip,
         };
 
@@ -203,7 +216,7 @@ function debugPrintNav(node: RootNavNode) {
         console.log(
             isRootNode(node)
                 ? chalk.dim('#root')
-                : `${'  '.repeat(indent)}${node.id.split('/').pop()} ${chalk.dim(`[${node.type}${node.skip ? ', ' + chalk.yellow('skip') : ''}]`)}`,
+                : `${'  '.repeat(indent)}${node.idPart} ${chalk.dim(`[${node.type}${node.skip ? ', ' + chalk.yellow('skip') : ''}]`)}`,
         );
 
         if (node.children)

package/server/plugin/content/context.ts

@@ -9,6 +9,7 @@ import { ERUDIT_SERVER } from '@server/global';
 import { getIdsUp, isSkipId } from '@server/nav/utils';
 import { DbContent } from '@server/db/entities/Content';
 import { DbContributor } from '@server/db/entities/Contributor';
+import { getFullContentId } from '@server/repository/contentId';
 
 import type { Context } from '@shared/content/context';
 import {
@@ -19,9 +20,11 @@ import {
 import { CONTENT_TYPE_ICON, ICON, TOPIC_PART_ICON } from '@erudit/shared/icons';
 
 export async function getContentContext(contentId: string): Promise<Context> {
+    contentId = getFullContentId(contentId);
+
     const context: Context = [];
 
-    for (const _contentId of (await getIdsUp(contentId)).reverse()) {
+    for (const _contentId of getIdsUp(contentId).reverse()) {
         const dbContent = await getDbContent(_contentId);
 
         context.push({
@@ -106,7 +109,7 @@ export async function getLocationContext(
 
 async function getDbContent(contentId: string): Promise<DbContent> {
     const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
-        select: ['type', 'title', 'fullId', 'contentId'],
+        select: ['type', 'title', 'contentId'],
         where: { contentId },
     });
 

package/server/plugin/db/entities/Content.ts

@@ -13,10 +13,6 @@ export class DbContent {
     @PrimaryColumn('varchar')
     contentId!: string;
 
-    @Column('varchar')
-    @Index({ unique: true })
-    fullId!: string;
-
     @Column('varchar')
     type!: ContentType;
 

package/server/plugin/db/setup.ts

@@ -3,6 +3,7 @@ import { DataSource } from 'typeorm';
 
 import { PROJECT_DIR } from '#erudit/globalPaths';
 import { ERUDIT_SERVER } from '@server/global';
+import { logger } from '../logger';
 
 // Database Entities
 import { DbContributor } from './entities/Contributor';
@@ -14,7 +15,6 @@ import { DbHash } from './entities/Hash';
 import { DbTopic } from './entities/Topic';
 import { DbUnique } from './entities/Unique';
 import { DbFile } from './entities/File';
-import { logger } from '../logger';
 
 export async function setupDatabase() {
     rmSync(PROJECT_DIR + '/.erudit/data.sqlite', { force: true });

package/server/plugin/importer.ts

@@ -1,10 +1,14 @@
 import { createJiti } from 'jiti';
-import { ERUDIT_DIR } from '#erudit/globalPaths';
+import { ERUDIT_DIR, PROJECT_DIR } from '#erudit/globalPaths';
 
 const jiti = createJiti(ERUDIT_DIR, {
     // Enable reimporting same files during process in development mode
     fsCache: !import.meta.dev,
     moduleCache: !import.meta.dev,
+    alias: {
+        '#project': PROJECT_DIR,
+        '#content': PROJECT_DIR + '/content',
+    },
 });
 
 export async function IMPORT(...args: Parameters<typeof jiti.import>) {

package/server/plugin/nav/node.ts

@@ -3,7 +3,8 @@ import type { ContentType } from '@erudit-js/cog/schema';
 export interface NavNode {
     type: ContentType;
     path: string;
-    id: string;
+    idPart: string;
+    shortId: string;
     fullId: string;
     skip: boolean;
     children?: NavNode[];

package/server/plugin/nav/utils.ts

@@ -1,5 +1,5 @@
 import { ERUDIT_SERVER } from '@server/global';
-import { isRootNode, type NavNode } from '@server/nav/node';
+import { isRootNode, type NavNode, type RootNavNode } from '@server/nav/node';
 
 export async function walkNav(
     step: (node: NavNode) => Promise<void | false>,
@@ -18,12 +18,22 @@ export async function walkNav(
 //
 //
 
-export function getNavBookIds() {
-    return Object.keys(ERUDIT_SERVER.NAV_BOOKS || {});
+export function getNavBookIds(mode: 'full' | 'short'): string[] {
+    const bookIds: string[] = [];
+
+    if (!ERUDIT_SERVER.NAV_BOOKS) {
+        return bookIds;
+    }
+
+    for (const navBook of Object.values(ERUDIT_SERVER.NAV_BOOKS)) {
+        bookIds.push(mode === 'full' ? navBook.fullId : navBook.shortId);
+    }
+
+    return bookIds;
 }
 
 export function getNavBookOf(target: string | NavNode): NavNode | undefined {
-    const id = typeof target === 'string' ? target : target.id;
+    const id = typeof target === 'string' ? target : target.fullId;
 
     if (!id || !ERUDIT_SERVER.NAV_BOOKS) return undefined;
 
@@ -46,7 +56,7 @@ export async function getPreviousNextNav(contentId: string) {
     let finish = false;
 
     await walkNav(async (navNode) => {
-        if (navNode.id === contentId) {
+        if (navNode.fullId === contentId) {
             book = getNavBookOf(navNode);
             finish = true;
             return;
@@ -88,32 +98,64 @@ export async function getPreviousNextNav(contentId: string) {
     };
 }
 
-export async function getNavNode(
-    contentId: string,
-): Promise<NavNode | undefined> {
-    let navNode: NavNode | undefined;
+/**
+ * Find navigation node by mixed content ID.
+ * It can be full ID, short ID or any combination of present and missing skipped parts.
+ */
+export function getNavNode(mixedContentId: string): NavNode {
+    const parts = mixedContentId.split('/');
+    let foundNode: NavNode | undefined;
+
+    function search(node: NavNode, partIdx: number): NavNode | undefined {
+        const targetIdPart = parts[partIdx];
+        const nodeIdPart = node.idPart;
+
+        if (nodeIdPart === targetIdPart) {
+            if (partIdx === parts.length - 1) {
+                return node;
+            }
+
+            for (const child of node.children || []) {
+                const deepResult = search(child, partIdx + 1);
+                if (deepResult) return deepResult;
+            }
+        }
 
-    await walkNav(async (_navNode) => {
-        if (_navNode.id === contentId) {
-            navNode = _navNode;
-            return false;
+        if (node.skip) {
+            for (const child of node.children || []) {
+                const deepResult = search(child, partIdx);
+                if (deepResult) return deepResult;
+            }
         }
-    });
 
-    return navNode;
-}
+        return undefined;
+    }
+
+    for (const child of ERUDIT_SERVER.NAV?.children || []) {
+        foundNode = search(child, 0);
+        if (foundNode) break;
+    }
 
-export async function getIdsUp(contentId: string): Promise<string[]> {
-    const startNavNode = await getNavNode(contentId);
+    if (!foundNode) {
+        throw new Error(
+            `Failed to find navigation content node for ID: ${mixedContentId}`,
+        );
+    }
 
-    if (!startNavNode) return [];
+    return foundNode;
+}
 
+export function getIdsUp(contentId: string): string[] {
     const ids: string[] = [];
+    const startNavNode = getNavNode(contentId);
+
+    if (!startNavNode) return ids;
+
+    let currentNavNode: NavNode = startNavNode;
 
-    let currentNavNode: any = startNavNode;
-    while (currentNavNode?.id) {
-        ids.push(currentNavNode.id);
-        currentNavNode = currentNavNode.parent;
+    while (currentNavNode?.idPart) {
+        ids.push(currentNavNode.fullId);
+        currentNavNode = currentNavNode.parent as NavNode;
     }
 
     return ids;
@@ -123,7 +165,7 @@ export async function isSkipId(contentId: string) {
     let hidden = false;
 
     await walkNav(async (navNode) => {
-        if (navNode.id === contentId) {
+        if (navNode.fullId === contentId) {
             hidden = navNode.skip;
             return false;
         }

package/server/plugin/repository/content.ts

@@ -6,7 +6,11 @@ import { DbContent } from '@server/db/entities/Content';
 import { DbContribution } from '@server/db/entities/Contribution';
 import { getContentContext } from '@server/content/context';
 import { DbContributor } from '@server/db/entities/Contributor';
-import { getIdsUp, getNavBookIds, getPreviousNextNav } from '@server/nav/utils';
+import { getIdsUp, getPreviousNextNav } from '@server/nav/utils';
+import {
+    getShortContentId,
+    resolveClientContentId,
+} from '@server/repository/contentId';
 import { getTopicPart } from './topic';
 import type { NavNode } from '../nav/node';
 
@@ -14,7 +18,6 @@ import { createContentLink, createTopicPartLink } from '@erudit/shared/link';
 import type { PreviousNextItem } from '@erudit/shared/content/previousNext';
 import type { ContentContributor } from '@erudit/shared/contributor';
 import type { ContentGenericData } from '@shared/content/data/base';
-import { toAbsoluteContentId } from '@erudit/shared/bitran/contentId';
 
 export async function getContentGenericData(
     contentId: string,
@@ -23,11 +26,12 @@ export async function getContentGenericData(
         where: { contentId },
     });
 
-    if (!dbContent)
+    if (!dbContent) {
         throw createError({
             statusCode: 404,
             message: `Content item "${contentId}" not found!`,
         });
+    }
 
     const previousNext = await getPreviousNext(contentId);
     const decoration = await getContentDecoration(contentId);
@@ -57,16 +61,16 @@ export async function getPreviousNext(contentId: string) {
     const { previousNav, nextNav } = await getPreviousNextNav(contentId);
 
     async function getItemData(navNode: NavNode): Promise<PreviousNextItem> {
-        const title = await getContentTitle(navNode.id);
+        const title = await getContentTitle(navNode.fullId);
 
         const link = await (async () => {
             if (navNode.type === 'topic')
                 return createTopicPartLink(
-                    await getTopicPart(navNode.id),
-                    navNode.id,
+                    await getTopicPart(navNode.fullId),
+                    navNode.shortId,
                 );
 
-            return createContentLink(navNode.type, navNode.id);
+            return createContentLink(navNode.type, navNode.shortId);
         })();
 
         return {
@@ -125,9 +129,13 @@ export async function getContentDependencies(
     contentId: string,
     strDependencies: string[],
 ) {
-    const dependencyIds = strDependencies.map((rawDependency) =>
-        toAbsoluteContentId(rawDependency, contentId, getNavBookIds()),
-    );
+    const dependencyIds: string[] = [];
+    for (const rawDependency of strDependencies) {
+        dependencyIds.push(
+            resolveClientContentId(rawDependency, contentId, 'full'),
+        );
+    }
+
     const dependencies: Record<string, string> = {};
 
     for (const dependencyId of dependencyIds)
@@ -152,27 +160,22 @@ export async function getContentLink(contentId: string) {
         where: { contentId },
     });
 
-    if (!dbContent)
+    if (!dbContent) {
         throw createError({
             statusCode: 404,
             statusText: `Missing "${contentId}" content item!`,
         });
+    }
 
-    if (dbContent.type !== 'topic')
-        return createContentLink(dbContent.type, contentId);
-
-    const topicPart = await getTopicPart(contentId);
+    const shortContentId = getShortContentId(contentId);
 
-    return createTopicPartLink(topicPart, contentId);
-}
+    if (dbContent.type !== 'topic') {
+        return createContentLink(dbContent.type, shortContentId);
+    }
 
-export async function getFullContentId(contentId: string) {
-    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
-        select: ['fullId'],
-        where: { contentId },
-    });
+    const topicPart = await getTopicPart(contentId);
 
-    return dbContent?.fullId;
+    return createTopicPartLink(topicPart, shortContentId);
 }
 
 export async function getContentContributors(contentId: string) {

package/server/plugin/repository/contentId.ts

@@ -0,0 +1,40 @@
+import { getNavBookIds, getNavNode } from '@server/nav/utils';
+import { toAbsoluteContentPath } from '@shared/bitran/contentId';
+
+export function getFullContentId(mixedContentId: string): string {
+    const navNode = getNavNode(mixedContentId);
+    return navNode.fullId;
+}
+
+export function getShortContentId(mixedContentId: string): string {
+    const navNode = getNavNode(mixedContentId);
+    return navNode.shortId;
+}
+
+export function serverAbsolutizeContentPath(
+    relativePath: string,
+    contextPath: string,
+) {
+    const absolutePath = toAbsoluteContentPath(
+        relativePath,
+        contextPath,
+        getNavBookIds('full'),
+    );
+
+    return absolutePath;
+}
+
+export function resolveClientContentId(
+    clientContentId: string,
+    contextContentId: string,
+    mode: 'full' | 'short',
+): string {
+    const absoluteContentId = serverAbsolutizeContentPath(
+        clientContentId,
+        contextContentId,
+    );
+
+    return mode === 'full'
+        ? getFullContentId(absoluteContentId)
+        : getShortContentId(absoluteContentId);
+}

package/server/plugin/repository/frontNav.ts

@@ -46,12 +46,12 @@ async function toFrontNavItem(arg: ToFuncArg): Promise<FrontNavItem> {
         case 'group':
             const dbGroup = await ERUDIT_SERVER.DB.manager.findOne(DbGroup, {
                 select: ['type'],
-                where: { contentId: arg.node.id },
+                where: { contentId: arg.node.fullId },
             });
 
             if (!dbGroup)
                 throw new Error(
-                    `Missing group content item "${arg.node.id}" when creating front nav!`,
+                    `Missing group content item "${arg.node.fullId}" when creating front nav!`,
                 );
 
             if (dbGroup.type === 'folder') return await toFrontNavFolder(arg);
@@ -107,7 +107,7 @@ async function toFrontNavTopic({
     node,
     level,
 }: ToFuncArg): Promise<FrontNavTopic> {
-    const topicPart = await getTopicPart(node.id);
+    const topicPart = await getTopicPart(node.fullId);
     return {
         type: 'topic',
         part: topicPart,
@@ -121,18 +121,15 @@ async function toFrontNavBase({
 }: ToFuncArg): Promise<Omit<FrontNavBase, 'type'>> {
     const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
         select: ['title', 'navTitle', 'flags'],
-        where: { contentId: node.id },
+        where: { contentId: node.fullId },
     });
 
     return {
-        id: node.id,
+        id: node.shortId,
         fullId: node.fullId,
         level,
         flags: dbContent?.flags,
-        label:
-            dbContent?.navTitle ||
-            dbContent?.title ||
-            node.id.split('/').pop()!,
+        label: dbContent?.navTitle || dbContent?.title || node.idPart,
     };
 }
 

package/server/plugin/repository/topic.ts

@@ -2,6 +2,8 @@ import type { TopicPart } from '@erudit-js/cog/schema';
 
 import { ERUDIT_SERVER } from '@server/global';
 import { DbTopic } from '@server/db/entities/Topic';
+import { getShortContentId } from '@server/repository/contentId';
+
 import type { TopicPartLinks } from '@shared/content/data/type/topic';
 import { createTopicPartLink } from '@shared/link';
 
@@ -23,10 +25,11 @@ export async function getTopicPart(contentId: string): Promise<TopicPart> {
 
 export async function getTopicPartsLinks(topicId: string) {
     const existingTopicParts = await getTopicParts(topicId);
+    const shortTopicId = await getShortContentId(topicId);
     const links: TopicPartLinks = {};
 
     for (const topicPart of existingTopicParts)
-        links[topicPart] = createTopicPartLink(topicPart, topicId);
+        links[topicPart] = createTopicPartLink(topicPart, shortTopicId);
 
     return links;
 }

package/shared/aside/minor.ts

@@ -17,7 +17,7 @@ export type AsideMinorType =
 
 export interface AsideMinorTopic extends AsideMinorBase {
     type: 'topic';
-    fullContentId: string;
+    topicId: string;
     location: BitranLocation;
     nav: Partial<{
         previous: PreviousNextItem;
@@ -33,7 +33,7 @@ export interface AsideMinorTopic extends AsideMinorBase {
 
 export interface AsideMinorContent extends AsideMinorBase {
     type: 'group' | 'book';
-    fullContentId: string;
+    contentId: string;
     nav: Partial<{
         previous: PreviousNextItem;
         next: PreviousNextItem;

package/shared/bitran/contentId.ts

@@ -1,60 +1,28 @@
-import {
-    isContentType,
-    parseBitranLocation,
-    stringifyBitranLocation,
-    type BitranLocation,
-} from '@erudit-js/cog/schema';
+import { detectContentBookId } from '../content/bookId';
 
-export function toAbsoluteLocation<T extends string | BitranLocation>(
-    location: T,
-    contextId: string,
-    bookIds?: string[],
-) {
-    const isStringLocation = typeof location === 'string';
-    const parsedLocation = isStringLocation
-        ? parseBitranLocation(location)
-        : (location as BitranLocation);
-
-    if (isContentType(parsedLocation.type)) {
-        parsedLocation.path = toAbsoluteContentId(
-            parsedLocation.path!,
-            contextId,
-            bookIds,
-        );
-        return (
-            isStringLocation
-                ? stringifyBitranLocation(parsedLocation)
-                : parsedLocation
-        ) as T;
-    }
-
-    return location;
-}
-
-export function toAbsoluteContentId(
-    contentId: string,
-    contextId: string,
+export function toAbsoluteContentPath(
+    contentPath: string,
+    contextPath: string,
     bookIds?: string[],
 ) {
     const unresolvedPath = (() => {
-        if (contentId.startsWith('/')) {
-            return contentId;
+        if (contentPath.startsWith('/')) {
+            return contentPath;
         }
 
-        if (contentId.startsWith('~/')) {
-            const restPath = contentId.substring(2);
+        if (contentPath.startsWith('~/')) {
+            const restPath = contentPath.substring(2);
+            const bookId = detectContentBookId(contextPath, bookIds ?? []);
 
-            for (const bookId of bookIds ?? []) {
-                if (contextId.startsWith(bookId)) {
-                    return bookId + '/' + restPath;
-                }
+            if (bookId) {
+                return bookId + '/' + restPath;
             }
 
             // Not in any book, convert to absolute path
             return '/' + restPath;
         }
 
-        return contextId + '/' + contentId;
+        return contextPath + '/' + contentPath;
     })();
 
     return resolveContentPath(unresolvedPath);

package/shared/content/bookId.ts

@@ -0,0 +1,12 @@
+export function detectContentBookId(contentId: string, bookIds: string[]) {
+    let bestMatch: string | undefined = undefined;
+    for (const bookId of bookIds) {
+        if (contentId.startsWith(bookId)) {
+            if (!bestMatch || bookId.length > bestMatch.length) {
+                bestMatch = bookId;
+            }
+        }
+    }
+
+    return bestMatch;
+}