erudit 3.0.0-dev.21 → 3.0.0-dev.23

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

@@ -1,11 +1,8 @@
-import { readFileSync } from 'node:fs';
 import type { GroupConfig } from '@erudit-js/cog/schema';
 
 import { DbGroup } from '@server/db/entities/Group';
 import { ERUDIT_SERVER } from '@erudit/server/plugin/global';
 import type { BuilderFunctionArgs } from '../builderArgs';
-import { contentItemPath } from '../path';
-import { parseBitranContent } from '../parse';
 
 export async function buildGroup({
     navNode,
@@ -15,23 +12,5 @@ export async function buildGroup({
     dbGroup.contentId = navNode.fullId;
     dbGroup.type = config?.type || 'folder';
 
-    try {
-        const strContent = readFileSync(
-            contentItemPath(navNode, 'content.bi'),
-            'utf-8',
-        );
-
-        if (strContent) {
-            dbGroup.content = strContent;
-            await parseBitranContent(
-                {
-                    type: 'group',
-                    path: dbGroup.contentId,
-                },
-                strContent,
-            );
-        }
-    } catch {}
-
     await ERUDIT_SERVER.DB.manager.save(dbGroup);
 }

package/server/plugin/content/context.ts

@@ -12,11 +12,8 @@ import { DbContributor } from '@server/db/entities/Contributor';
 import { getFullContentId } from '@server/repository/contentId';
 
 import type { Context } from '@shared/content/context';
-import {
-    createContentLink,
-    createContributorLink,
-    createTopicPartLink,
-} from '@shared/link';
+import { createContributorLink, createTopicPartLink } from '@shared/link';
+import { createContentLink } from '@server/repository/link';
 import { CONTENT_TYPE_ICON, ICON, TOPIC_PART_ICON } from '@erudit/shared/icons';
 
 export async function getContentContext(contentId: string): Promise<Context> {
@@ -35,7 +32,7 @@ export async function getContentContext(contentId: string): Promise<Context> {
                   ? CONTENT_TYPE_ICON[dbContent.type]
                   : '',
             title: dbContent.title || dbContent.contentId,
-            href: createContentLink(dbContent.type, dbContent.contentId),
+            href: await createContentLink(dbContent.contentId),
             hidden: await isSkipId(dbContent.contentId),
         });
     }

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

@@ -8,7 +8,4 @@ export class DbGroup {
 
     @Column('varchar')
     type!: GroupType;
-
-    @Column('text', { nullable: true })
-    content?: string;
 }

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

@@ -0,0 +1,19 @@
+import { Column, Entity, PrimaryColumn } from 'typeorm';
+
+@Entity('quickLink')
+export class DbQuickLink {
+    @PrimaryColumn('varchar')
+    label!: string;
+
+    @PrimaryColumn('varchar')
+    contentId!: string;
+
+    @Column('varchar')
+    contentType!: string;
+
+    @Column('varchar')
+    elementId!: string;
+
+    @Column('varchar')
+    elementName!: string;
+}

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

@@ -0,0 +1,13 @@
+import { Column, Entity, PrimaryColumn } from 'typeorm';
+
+@Entity('stat')
+export class DbStat {
+    @PrimaryColumn('varchar')
+    contentId!: string;
+
+    @PrimaryColumn('varchar')
+    elementName!: string;
+
+    @Column('int')
+    count!: number;
+}

package/server/plugin/db/setup.ts

@@ -15,6 +15,8 @@ import { DbHash } from './entities/Hash';
 import { DbTopic } from './entities/Topic';
 import { DbUnique } from './entities/Unique';
 import { DbFile } from './entities/File';
+import { DbQuickLink } from './entities/QuickLink';
+import { DbStat } from './entities/Stat';
 
 export async function setupDatabase() {
     rmSync(PROJECT_DIR + '/.erudit/data.sqlite', { force: true });
@@ -35,6 +37,8 @@ export async function setupDatabase() {
             DbTopic,
             DbUnique,
             DbFile,
+            DbQuickLink,
+            DbStat,
         ],
     });
 

package/server/plugin/repository/content.ts

@@ -17,11 +17,11 @@ import type { NavNode } from '../nav/node';
 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 type { ContentGeneric } from '@shared/content/data/base';
 
 export async function getContentGenericData(
     contentId: string,
-): Promise<ContentGenericData> {
+): Promise<ContentGeneric> {
     const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
         where: { contentId },
     });
@@ -37,7 +37,7 @@ export async function getContentGenericData(
     const decoration = await getContentDecoration(contentId);
     const flags = await getContentFlags(contentId);
 
-    const contentPage: ContentGenericData = {
+    const contentPage: ContentGeneric = {
         contentId,
         type: dbContent.type,
         title: dbContent.title || undefined,

package/server/plugin/repository/contentToc.ts

@@ -0,0 +1,90 @@
+import type { ContentToc } from '@shared/content/toc';
+
+import { DbContent } from '@server/db/entities/Content';
+import { ERUDIT_SERVER } from '@server/global';
+import { getNavNode } from '@server/nav/utils';
+import { createContentLink } from '@server/repository/link';
+import { getElementStats } from '@erudit/server/plugin/repository/elementStats';
+import { getQuickLinks } from '@server/repository/quickLink';
+import { countTopicsIn } from '@server/repository/topicCount';
+
+async function processChildContent(childId: string): Promise<any> {
+    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+        select: ['title', 'description', 'type'],
+        where: {
+            contentId: childId,
+        },
+    });
+
+    if (!dbContent) {
+        throw createError({
+            statusCode: 404,
+            statusMessage: `Failed to create content TOC!\nContent with ID "${childId}" not found!`,
+        });
+    }
+
+    const title = dbContent.title ?? childId;
+    const link = await createContentLink(childId);
+    const description = dbContent.description;
+
+    switch (dbContent.type) {
+        case 'book':
+        case 'group':
+            const stats = await getElementStats(childId);
+            const topicCount = await countTopicsIn(childId);
+            return {
+                type: dbContent.type,
+                link,
+                title,
+                description,
+                topicCount,
+                stats: stats || [],
+            };
+        case 'topic':
+            const quickLinks = await getQuickLinks(childId);
+            return {
+                type: 'topic',
+                link,
+                title,
+                description,
+                quickLinks,
+            };
+    }
+}
+
+export async function getContentToc(
+    mixedContentId: string,
+): Promise<ContentToc> {
+    const navNode = getNavNode(mixedContentId);
+    const childIds = navNode.children?.map((child) => child.fullId) || [];
+    const toc: ContentToc = [];
+
+    for (const childId of childIds) {
+        const tocItem = await processChildContent(childId);
+        if (tocItem) {
+            toc.push(tocItem);
+        }
+    }
+
+    return toc;
+}
+
+export async function getFullContentToc(): Promise<ContentToc | undefined> {
+    const rootNode = ERUDIT_SERVER.NAV;
+
+    if (!rootNode) {
+        return undefined;
+    }
+
+    const childIds = rootNode.children?.map((child) => child.fullId) || [];
+    const toc: ContentToc = [];
+
+    for (const childId of childIds) {
+        const tocItem = await processChildContent(childId);
+        if (tocItem) {
+            toc.push(tocItem);
+        }
+    }
+
+    return toc;
+}

package/server/plugin/repository/elementStats.ts

@@ -0,0 +1,80 @@
+import { Like } from 'typeorm';
+
+import type { ElementStats } from '@shared/stat';
+
+import { DbStat } from '@server/db/entities/Stat';
+import { ERUDIT_SERVER } from '@server/global';
+import { getFullContentId } from '@server/repository/contentId';
+
+function buildGroupMappings() {
+    const statNames = ERUDIT_SERVER.CONFIG.bitran?.stat || [];
+    const orderedGroups: string[] = [];
+    const elementToGroup = new Map<string, string>();
+
+    statNames.forEach((item) => {
+        if (typeof item === 'string') {
+            orderedGroups.push(item);
+            elementToGroup.set(item, item);
+        } else if (Array.isArray(item) && item.length > 0) {
+            const groupName = item[0];
+            orderedGroups.push(groupName);
+            item.forEach((elementName) => {
+                elementToGroup.set(elementName, groupName);
+            });
+        }
+    });
+
+    return { orderedGroups, elementToGroup };
+}
+
+function processStats(
+    dbStats: DbStat[],
+    orderedGroups: string[],
+    elementToGroup: Map<string, string>,
+): ElementStats {
+    const groupCounts = dbStats.reduce((counts, stat) => {
+        const groupName =
+            elementToGroup.get(stat.elementName) || stat.elementName;
+        counts.set(groupName, (counts.get(groupName) || 0) + stat.count);
+        return counts;
+    }, new Map<string, number>());
+
+    return orderedGroups
+        .map((groupName) => ({
+            elementName: groupName,
+            count: groupCounts.get(groupName) || 0,
+            type: 'element' as const,
+        }))
+        .filter((stat) => stat.count > 0);
+}
+
+export async function getElementStats(
+    mixedContentId: string,
+): Promise<ElementStats | undefined> {
+    const contentId = getFullContentId(mixedContentId);
+    const { orderedGroups, elementToGroup } = buildGroupMappings();
+
+    const dbStats = await ERUDIT_SERVER.DB.manager.find(DbStat, {
+        where: {
+            contentId: Like(`${contentId}/%`),
+        },
+    });
+
+    if (!dbStats.length) {
+        return undefined;
+    }
+
+    return processStats(dbStats, orderedGroups, elementToGroup);
+}
+
+export async function getAllElementStats(): Promise<ElementStats> {
+    const { orderedGroups, elementToGroup } = buildGroupMappings();
+
+    const dbStats = await ERUDIT_SERVER.DB.manager.find(DbStat);
+
+    if (!dbStats.length) {
+        return [];
+    }
+
+    return processStats(dbStats, orderedGroups, elementToGroup);
+}

package/server/plugin/repository/link.ts

@@ -0,0 +1,20 @@
+import { getNavNode } from '@server/nav/utils';
+import {
+    createContentLink as _createContentLink,
+    createTopicPartLink,
+} from '@shared/link';
+import { getTopicParts } from './topic';
+
+export async function createContentLink(
+    mixedContentId: string,
+): Promise<string> {
+    const navNode = getNavNode(mixedContentId);
+
+    if (navNode.type === 'topic') {
+        const parts = await getTopicParts(navNode.fullId);
+        const part = parts.shift()!;
+        return createTopicPartLink(part, navNode.shortId);
+    }
+
+    return _createContentLink(navNode.type, navNode.shortId);
+}

package/server/plugin/repository/quickLink.ts

@@ -0,0 +1,36 @@
+import { trailingSlash } from '@erudit/utils/url';
+
+import type { QuickLinks } from '@shared/quickLink';
+import { createContentLink } from '@shared/link';
+
+import { ERUDIT_SERVER } from '@server/global';
+import { DbQuickLink } from '@server/db/entities/QuickLink';
+import { getNavNode } from '@server/nav/utils';
+import { getFullContentId } from '@server/repository/contentId';
+
+export async function getQuickLinks(
+    mixedContentId: string,
+): Promise<QuickLinks> {
+    const fullContentId = getFullContentId(mixedContentId);
+    const dbTags = await ERUDIT_SERVER.DB.manager.find(DbQuickLink, {
+        where: { contentId: fullContentId },
+    });
+
+    return dbTags.map((dbTag) => {
+        const navNode = getNavNode(dbTag.contentId);
+
+        const link =
+            trailingSlash(
+                createContentLink(dbTag.contentType as any, navNode.shortId),
+                false,
+            ) +
+            '#' +
+            dbTag.elementId;
+
+        return {
+            label: dbTag.label,
+            elementName: dbTag.elementName,
+            link,
+        };
+    });
+}

package/server/plugin/repository/readLink.ts

@@ -0,0 +1,17 @@
+import { getNavNode } from '@server/nav/utils';
+import { createContentLink } from '@server/repository/link';
+
+export async function getReadLink(mixedContentId: string): Promise<string> {
+    const navNode = getNavNode(mixedContentId);
+
+    if (!navNode.children || navNode.children.length === 0) {
+        throw createError({
+            statusCode: 404,
+            statusText: `Missing children to create read link for content ID "${mixedContentId}"!`,
+        });
+    }
+
+    const targetId = navNode.children[0]!.fullId;
+
+    return await createContentLink(targetId);
+}

package/server/plugin/repository/reference.ts

@@ -0,0 +1,78 @@
+import { Like } from 'typeorm';
+import { createHash } from 'crypto';
+
+import type {
+    ContentSourceUsage,
+    ContentSourceUsageSet,
+    ContentSourceUsageSetItem,
+} from '@shared/content/reference';
+import { ERUDIT_SERVER } from '@server/global';
+import { DbContent } from '@server/db/entities/Content';
+import { createContentLink } from '@server/repository/link';
+import { getFullContentId } from '@server/repository/contentId';
+
+export async function getContentSourceUsageSet(
+    mixedContentId: string,
+): Promise<ContentSourceUsageSet> {
+    const contentFullId = getFullContentId(mixedContentId);
+    const dbContentItems = await ERUDIT_SERVER.DB.manager.find(DbContent, {
+        select: ['contentId'],
+        where: { contentId: Like(`${contentFullId}/%`), type: 'topic' },
+    });
+
+    const usageSetObj: Record<string, ContentSourceUsageSetItem> = {};
+
+    for (const childId of dbContentItems.map((item) => item.contentId)) {
+        const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+            select: ['title', 'type', 'references'],
+            where: { contentId: childId },
+        });
+
+        if (!dbContent || !dbContent.references) {
+            continue;
+        }
+
+        const referenceGroups = dbContent.references;
+        for (const referenceGroup of referenceGroups) {
+            const source = referenceGroup.source;
+            const sourceId = getObjectUuid(source);
+
+            if (!(sourceId in usageSetObj)) {
+                usageSetObj[sourceId] = {
+                    source,
+                    usages: [],
+                };
+            }
+
+            const usageSet = usageSetObj[sourceId];
+
+            usageSet.usages.push({
+                type: dbContent.type,
+                title: dbContent.title || childId,
+                count: referenceGroup.references.length,
+                link: await createContentLink(childId),
+            });
+        }
+    }
+
+    const sortedEntries = Object.entries(usageSetObj).sort(([, a], [, b]) => {
+        const aFeatured = !!a.source.featured;
+        const bFeatured = !!b.source.featured;
+
+        if (aFeatured !== bFeatured) {
+            return bFeatured ? 1 : -1;
+        }
+
+        const aSum = a.usages.reduce((sum, usage) => sum + usage.count, 0);
+        const bSum = b.usages.reduce((sum, usage) => sum + usage.count, 0);
+
+        return bSum - aSum;
+    });
+
+    return sortedEntries.map(([, value]) => value);
+}
+
+export function getObjectUuid(obj: any): string {
+    const serialized = JSON.stringify(obj, Object.keys(obj).sort());
+    return createHash('sha256').update(serialized).digest('hex').slice(0, 8);
+}

package/server/plugin/repository/topicCount.ts

@@ -0,0 +1,19 @@
+import { Like } from 'typeorm';
+
+import { DbTopic } from '@server/db/entities/Topic';
+import { ERUDIT_SERVER } from '@server/global';
+import { getFullContentId } from '@server/repository/contentId';
+
+export async function countTopicsIn(mixedContentId: string) {
+    const fullContentId = getFullContentId(mixedContentId);
+    return await ERUDIT_SERVER.DB.manager.count(DbTopic, {
+        where: [
+            { contentId: fullContentId },
+            { contentId: Like(`${fullContentId}/%`) },
+        ],
+    });
+}
+
+export async function countAllTopics() {
+    return await ERUDIT_SERVER.DB.manager.count(DbTopic);
+}

package/shared/content/data/base.ts

@@ -10,7 +10,7 @@ import type { Context } from '@shared/content/context';
 import type { PreviousNext } from '@shared/content/previousNext';
 import type { ImageData } from '@shared/image';
 
-export interface ContentGenericData {
+export interface ContentGeneric {
     contentId: string;
     title?: string;
     description?: string;
@@ -28,5 +28,5 @@ export interface ContentGenericData {
 
 export interface ContentBaseData {
     type: ContentType;
-    generic: ContentGenericData;
+    generic: ContentGeneric;
 }

package/shared/content/data/groupLike.ts

@@ -0,0 +1,11 @@
+import type { ElementStat } from '@shared/stat';
+import type { ContentToc } from '@shared/content/toc';
+import type { ContentSourceUsageSet } from '@shared/content/reference';
+
+export interface ContentGroupLike {
+    contentToc: ContentToc;
+    readLink: string;
+    topicCount: number;
+    elementStats?: ElementStat[];
+    sourceUsageSet?: ContentSourceUsageSet;
+}

package/shared/content/data/type/book.ts

@@ -1,5 +1,7 @@
-import type { ContentBaseData } from '../base';
+import type { ContentBaseData } from '@shared/content/data/base';
+import type { ContentGroupLike } from '@shared/content/data/groupLike';
 
 export interface ContentBookData extends ContentBaseData {
     type: 'book';
+    groupLike: ContentGroupLike;
 }

package/shared/content/data/type/group.ts

@@ -1,6 +1,8 @@
-import type { ContentBaseData } from '../base';
+import type { ContentBaseData } from '@shared/content/data/base';
+import type { ContentGroupLike } from '@shared/content/data/groupLike';
 
 export interface ContentGroupData extends ContentBaseData {
     type: 'group';
+    groupLike: ContentGroupLike;
     bookTitle?: string;
 }

package/shared/content/data/type/topic.ts

@@ -1,6 +1,7 @@
 import type { TopicPart } from '@erudit-js/cog/schema';
+import type { QuickLinks } from '@erudit/shared/quickLink';
 
-import type { ContentBaseData } from '../base';
+import type { ContentBaseData } from '@shared/content/data/base';
 
 export type TopicPartLinks = Partial<Record<TopicPart, string>>;
 
@@ -8,4 +9,5 @@ export interface ContentTopicData extends ContentBaseData {
     type: 'topic';
     topicPartLinks: TopicPartLinks;
     bookTitle?: string;
+    quickLinks: QuickLinks;
 }

package/shared/content/reference.ts

@@ -0,0 +1,18 @@
+import type {
+    ContentReferenceSource,
+    ContentType,
+} from '@erudit-js/cog/schema';
+
+export interface ContentSourceUsage {
+    type: ContentType;
+    title: string;
+    link: string;
+    count: number;
+}
+
+export interface ContentSourceUsageSetItem {
+    source: ContentReferenceSource;
+    usages: ContentSourceUsage[];
+}
+
+export type ContentSourceUsageSet = ContentSourceUsageSetItem[];

package/shared/content/toc.ts

@@ -0,0 +1,35 @@
+import type { ContentType } from '@erudit-js/cog/schema';
+
+import type { ElementStats } from '../stat';
+import type { QuickLinks } from '../quickLink';
+
+interface ContentTocBaseItem {
+    type: ContentType;
+    link: string;
+    title: string;
+    description?: string;
+}
+
+export interface ContentTocBookItem extends ContentTocBaseItem {
+    type: 'book';
+    topicCount: number;
+    stats: ElementStats;
+}
+
+export interface ContentTocGroupItem extends ContentTocBaseItem {
+    type: 'group';
+    topicCount: number;
+    stats: ElementStats;
+}
+
+export interface ContentTocTopicItem extends ContentTocBaseItem {
+    type: 'topic';
+    quickLinks: QuickLinks;
+}
+
+export type ContentTocItem =
+    | ContentTocBookItem
+    | ContentTocGroupItem
+    | ContentTocTopicItem;
+
+export type ContentToc = ContentTocItem[];

package/shared/indexData.ts

@@ -0,0 +1,10 @@
+import type { ContentToc } from './content/toc';
+import type { ElementStats } from './stat';
+
+export interface IndexData {
+    elementStats: ElementStats;
+    topicCount: number;
+    contributors: [string, string | undefined][];
+    sponsors: [string, string | undefined][];
+    contentToc?: ContentToc;
+}

package/shared/link.ts

@@ -13,8 +13,9 @@ export function createBitranLocationLink(location: BitranLocation) {
 }
 
 export function createContentLink(contentType: ContentType, contentId: string) {
-    // if (contentType === 'topic')
-    //     throw Error(`Use 'createTopicPartLink' to create links to topics!`);
+    if (contentType === 'topic') {
+        throw Error(`Use 'createTopicPartLink' to create links to topics!`);
+    }
 
     return `/${contentType}/${contentId}/`;
 }

package/shared/quickLink.ts

@@ -0,0 +1,7 @@
+export interface QuickLink {
+    label: string;
+    link: string;
+    elementName: string;
+}
+
+export type QuickLinks = QuickLink[];

package/shared/stat.ts

@@ -0,0 +1,23 @@
+import type { MyIconName } from '#my-icons';
+
+export type StatType = 'custom' | 'element';
+
+interface StatBase {
+    type: StatType;
+    count: number;
+}
+
+export interface CustomStat extends StatBase {
+    type: 'custom';
+    icon: MyIconName | (string & {});
+    label: string;
+}
+
+export interface ElementStat extends StatBase {
+    type: 'element';
+    elementName: string;
+}
+
+export type Stat = ElementStat | CustomStat;
+export type ElementStats = ElementStat[];
+export type Stats = Stat[];