erudit 3.0.0-dev.23 → 3.0.0-dev.25

package/server/plugin/repository/frontNav.ts

@@ -1,145 +0,0 @@
-import type {
-    FrontNav,
-    FrontNavBase,
-    FrontNavBook,
-    FrontNavFolder,
-    FrontNavItem,
-    FrontNavSeparator,
-    FrontNavTopic,
-} from '@erudit/shared/frontNav';
-
-import type { NavNode, RootNavNode } from '@server/nav/node';
-import { ERUDIT_SERVER } from '@server/global';
-import { DbContent } from '@server/db/entities/Content';
-import { DbGroup } from '@server/db/entities/Group';
-
-import { getTopicPart } from './topic';
-
-export async function createGlobalFrontNav(
-    from: RootNavNode | NavNode | undefined,
-): Promise<FrontNav | []> {
-    if (!from || !from.children) return [];
-
-    return await Promise.all(
-        from.children.map((node) =>
-            toFrontNavItem({ node, level: 0, includeBookNav: true }),
-        ),
-    );
-}
-
-export async function createBookFrontNav(from: NavNode): Promise<FrontNavBook> {
-    return await toFrontNavBook({ node: from, level: 0, includeBookNav: true });
-}
-
-type ToFuncArg = {
-    node: NavNode;
-    level: number;
-    includeBookNav?: boolean;
-};
-
-async function toFrontNavItem(arg: ToFuncArg): Promise<FrontNavItem> {
-    switch (arg.node.type) {
-        case 'book':
-            return await toFrontNavBook(arg);
-        case 'topic':
-            return await toFrontNavTopic(arg);
-        case 'group':
-            const dbGroup = await ERUDIT_SERVER.DB.manager.findOne(DbGroup, {
-                select: ['type'],
-                where: { contentId: arg.node.fullId },
-            });
-
-            if (!dbGroup)
-                throw new Error(
-                    `Missing group content item "${arg.node.fullId}" when creating front nav!`,
-                );
-
-            if (dbGroup.type === 'folder') return await toFrontNavFolder(arg);
-            else return await toFrontNavSeparator(arg);
-    }
-}
-
-async function toFrontNavBook({
-    node,
-    level,
-    includeBookNav,
-}: ToFuncArg): Promise<FrontNavBook> {
-    return {
-        type: 'book',
-        children: await toFrontNavChildren({
-            node,
-            level: 0,
-            includeBookNav,
-        }),
-        ...(await toFrontNavBase({ node, level })),
-    };
-}
-
-async function toFrontNavSeparator({
-    node,
-    level,
-    includeBookNav,
-}: ToFuncArg): Promise<FrontNavSeparator> {
-    return {
-        type: 'separator',
-        children: await toFrontNavChildren({ node, level, includeBookNav }),
-        ...(await toFrontNavBase({ node, level })),
-    };
-}
-
-async function toFrontNavFolder({
-    node,
-    level,
-    includeBookNav,
-}: ToFuncArg): Promise<FrontNavFolder> {
-    return {
-        type: 'folder',
-        children: await toFrontNavChildren({
-            node,
-            level: level + 1,
-            includeBookNav,
-        }),
-        ...(await toFrontNavBase({ node, level })),
-    };
-}
-
-async function toFrontNavTopic({
-    node,
-    level,
-}: ToFuncArg): Promise<FrontNavTopic> {
-    const topicPart = await getTopicPart(node.fullId);
-    return {
-        type: 'topic',
-        part: topicPart,
-        ...(await toFrontNavBase({ node, level })),
-    };
-}
-
-async function toFrontNavBase({
-    node,
-    level,
-}: ToFuncArg): Promise<Omit<FrontNavBase, 'type'>> {
-    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
-        select: ['title', 'navTitle', 'flags'],
-        where: { contentId: node.fullId },
-    });
-
-    return {
-        id: node.shortId,
-        fullId: node.fullId,
-        level,
-        flags: dbContent?.flags,
-        label: dbContent?.navTitle || dbContent?.title || node.idPart,
-    };
-}
-
-async function toFrontNavChildren({ node, includeBookNav, level }: ToFuncArg) {
-    if (node.type === 'book' && !includeBookNav) return undefined;
-    if (!node.children) return undefined;
-
-    return Promise.all(
-        node.children!.map((child) =>
-            toFrontNavItem({ node: child, level, includeBookNav }),
-        ),
-    );
-}

package/server/plugin/repository/link.ts

@@ -1,20 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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/topic.ts

@@ -1,35 +0,0 @@
-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';
-
-export async function getTopicParts(contentId: string) {
-    const dbTopic = await ERUDIT_SERVER.DB.manager.findOne(DbTopic, {
-        select: ['parts'],
-        where: { contentId },
-    });
-
-    if (!dbTopic) throw new Error(`Missing topic "${contentId}".`);
-
-    return dbTopic.parts;
-}
-
-export async function getTopicPart(contentId: string): Promise<TopicPart> {
-    const topicParts = await getTopicParts(contentId);
-    return topicParts.shift()!;
-}
-
-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, shortTopicId);
-
-    return links;
-}

package/server/plugin/repository/topicCount.ts

@@ -1,19 +0,0 @@
-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/server/plugin/sponsor/build.ts

@@ -1,82 +0,0 @@
-import chalk from 'chalk';
-import { glob } from 'glob';
-import type { Sponsor, SponsorConfig } from '@erudit-js/cog/schema';
-
-import { PROJECT_DIR } from '#erudit/globalPaths';
-import { ERUDIT_SERVER } from '@server/global';
-import { debug, logger } from '@server/logger';
-
-import { getSponsorCount, readSponsorConfig } from './repository';
-
-export async function buildSponsors() {
-    if (!ERUDIT_SERVER.CONFIG.sponsors) {
-        return;
-    }
-
-    debug.start('Building sponsors...');
-
-    const sponsorIds = await searchSponsorIds();
-
-    if (sponsorIds.length === 0) {
-        logger.warn('No sponsors found!');
-        return;
-    }
-
-    ERUDIT_SERVER.SPONSORS = {
-        tier1Ids: [],
-        tier2Ids: [],
-        avatars: {},
-    };
-
-    for (const sponsorId of sponsorIds) {
-        const sponsorAvatar = await searchSponsorAvatar(sponsorId);
-
-        let config: SponsorConfig<Sponsor>;
-        try {
-            config = await readSponsorConfig(sponsorId);
-        } catch (error) {
-            logger.error(
-                `Failed to read sponsor config for: ${sponsorId}! ${error}`,
-            );
-            continue;
-        }
-
-        if (config.tier === 'tier1') {
-            ERUDIT_SERVER.SPONSORS.tier1Ids.push(sponsorId);
-        } else if (config.tier === 'tier2') {
-            ERUDIT_SERVER.SPONSORS.tier2Ids.push(sponsorId);
-        } else {
-            logger.warn(
-                `Sponsor ${sponsorId} has an unknown tier: ${config.tier}!`,
-            );
-            continue;
-        }
-
-        ERUDIT_SERVER.SPONSORS.avatars[sponsorId] = sponsorAvatar;
-    }
-
-    logger.success(
-        `Sponsors built successfully!`,
-        chalk.dim(`(${getSponsorCount()})`),
-    );
-}
-
-async function searchSponsorIds() {
-    const dirs = await glob(PROJECT_DIR + '/sponsors/*/sponsor.{ts,js}', {
-        posix: true,
-    });
-
-    return dirs.map((dir) => dir.split('/').slice(-2, -1)[0]!);
-}
-
-export async function searchSponsorAvatar(
-    sponsorId: string,
-): Promise<string | undefined> {
-    const pattern = `sponsors/${sponsorId}/avatar.*`;
-    const avatars = await glob(pattern, {
-        cwd: PROJECT_DIR,
-        posix: true,
-    });
-
-    return avatars.pop();
-}

package/server/plugin/sponsor/index.ts

@@ -1,5 +0,0 @@
-export interface ServerSponsors {
-    tier1Ids: string[];
-    tier2Ids: string[];
-    avatars: Record<string, string | undefined>;
-}

package/server/plugin/sponsor/repository.ts

@@ -1,56 +0,0 @@
-import type { SponsorConfig, Sponsor } from '@erudit-js/cog/schema';
-
-import { PROJECT_DIR } from '#erudit/globalPaths';
-import { ERUDIT_SERVER } from '@server/global';
-import { IMPORT } from '@server/importer';
-
-export function getSponsorIds() {
-    const sponsors = ERUDIT_SERVER?.SPONSORS;
-
-    if (!sponsors) {
-        return [];
-    }
-
-    const tier1Ids = sponsors.tier1Ids || [];
-    const tier2Ids = sponsors.tier2Ids || [];
-
-    return [...tier1Ids, ...tier2Ids];
-}
-
-export function getSponsorCount() {
-    return getSponsorIds().length;
-}
-
-export async function readSponsorConfig(sponsorId: string) {
-    const config = (await IMPORT(
-        `${PROJECT_DIR}/sponsors/${sponsorId}/sponsor`,
-        { default: true },
-    )) as SponsorConfig<Sponsor>;
-
-    return config;
-}
-
-export async function retrieveSponsor(sponsorId: string): Promise<Sponsor> {
-    const config = await readSponsorConfig(sponsorId);
-    const avatar = ERUDIT_SERVER.SPONSORS?.avatars[sponsorId];
-
-    if (!config) {
-        throw new Error(`Sponsor config not found for ID: ${sponsorId}`);
-    }
-
-    return {
-        ...config,
-        sponsorId,
-        avatar,
-    };
-}
-
-export function getTier2SponsorIds() {
-    const sponsors = ERUDIT_SERVER?.SPONSORS;
-
-    if (!sponsors) {
-        return [];
-    }
-
-    return sponsors.tier2Ids || [];
-}

package/server/routes/asset/[...assetPath].ts

@@ -1,34 +0,0 @@
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-
-import { PROJECT_DIR } from '#erudit/globalPaths';
-
-export default defineEventHandler(async (event) => {
-    setHeader(event, 'Content-Type', 'application/octet-stream');
-    const assetPath = event.context.params?.assetPath?.trim();
-
-    if (typeof assetPath !== 'string' || !assetPath) {
-        throw createError({
-            statusCode: 400,
-            message: 'Invalid asset path!',
-        });
-    }
-
-    const fsPath = PROJECT_DIR + '/' + assetPath;
-
-    if (!existsSync(fsPath)) {
-        throw createError({
-            statusCode: 404,
-            message: `Asset not found: ${assetPath}`,
-        });
-    }
-
-    const fileContent = await readFile(fsPath).catch((err) => {
-        throw createError({
-            statusCode: 500,
-            message: `Failed to read asset "${assetPath}"! Error: ${err.message}`,
-        });
-    });
-
-    return fileContent;
-});

package/server/tsconfig.json

@@ -1,9 +0,0 @@
-{
-    "extends": "../../../playground/.erudit/nuxt/.nuxt/tsconfig.server.json",
-    "compilerOptions": {
-        "verbatimModuleSyntax": true,
-        "experimentalDecorators": true,
-        "emitDecoratorMetadata": true
-    },
-    "exclude": ["../module/**/*", "../globalPath.ts"]
-}

package/shared/aside/minor.ts

@@ -1,55 +0,0 @@
-import type { ContentType, TopicPart } from '@erudit-js/cog/schema';
-
-import type { Toc } from '@shared/bitran/toc';
-import type { PreviousNext } from '@shared/content/previousNext';
-import type { ContentContributor, Contribution } from '@shared/contributor';
-
-export type AsideMinorType = ContentType | 'contributor' | 'news';
-
-interface AsideMinorBase {
-    type: AsideMinorType;
-}
-
-export interface AsideMinorContentBase extends AsideMinorBase {
-    type: ContentType;
-    fullContentId: string;
-    shortContentId: string;
-    fsContentDirectory: string;
-    previousNext: PreviousNext;
-    contributors?: ContentContributor[];
-}
-
-export interface AsideMinorBook extends AsideMinorContentBase {
-    type: 'book';
-}
-
-export interface AsideMinorGroup extends AsideMinorContentBase {
-    type: 'group';
-}
-
-export interface AsideMinorTopic extends AsideMinorContentBase {
-    type: 'topic';
-    toc: Toc;
-    part: TopicPart;
-    partLinks: Partial<{
-        article: string;
-        summary: string;
-        practice: string;
-    }>;
-}
-
-export interface AsideMinorContributor extends AsideMinorBase {
-    type: 'contributor';
-    contributions: Contribution[];
-}
-
-export interface AsideMinorNews extends AsideMinorBase {
-    type: 'news';
-}
-
-export type AsideMinorData =
-    | AsideMinorBook
-    | AsideMinorGroup
-    | AsideMinorTopic
-    | AsideMinorContributor
-    | AsideMinorNews;

package/shared/asset.ts

@@ -1,17 +0,0 @@
-import {
-    PUBLIC_CONTENT_ASSET,
-    PUBLIC_ERUDIT_ASSET,
-    PUBLIC_USER_ASSET,
-} from '@erudit/const';
-
-export function eruditAsset(path: string) {
-    return PUBLIC_ERUDIT_ASSET + path;
-}
-
-export function contentAsset(path: string) {
-    return PUBLIC_CONTENT_ASSET + path;
-}
-
-export function publicAsset(path: string) {
-    return PUBLIC_USER_ASSET + path;
-}

package/shared/bitran/content.ts

@@ -1,9 +0,0 @@
-import type { RenderDataStorage } from '@bitran-js/core';
-import type { BitranContext } from '@erudit-js/cog/schema';
-
-export interface RawBitranContent {
-    biCode: string;
-    storage: RenderDataStorage;
-    routes: string[];
-    context: BitranContext;
-}

package/shared/bitran/contentId.ts

@@ -1,56 +0,0 @@
-import { detectContentBookId } from '../content/bookId';
-
-export function toAbsoluteContentPath(
-    contentPath: string,
-    contextPath: string,
-    bookIds?: string[],
-) {
-    const unresolvedPath = (() => {
-        if (contentPath.startsWith('/')) {
-            return contentPath;
-        }
-
-        if (contentPath.startsWith('~/')) {
-            const restPath = contentPath.substring(2);
-            const bookId = detectContentBookId(contextPath, bookIds ?? []);
-
-            if (bookId) {
-                return bookId + '/' + restPath;
-            }
-
-            // Not in any book, convert to absolute path
-            return '/' + restPath;
-        }
-
-        return contextPath + '/' + contentPath;
-    })();
-
-    return resolveContentPath(unresolvedPath);
-}
-
-export function resolveContentPath(toResolvePath: string) {
-    const reverseParts = toResolvePath.split('/').reverse();
-    const resolvedParts: string[] = [];
-
-    let skipCounter = 0;
-
-    for (let i = 0; i < reverseParts.length; i++) {
-        const part = reverseParts[i];
-
-        if (part === '..') {
-            skipCounter++;
-            continue;
-        }
-
-        if (skipCounter) {
-            skipCounter--;
-            continue;
-        }
-
-        if (part && part !== '.') {
-            resolvedParts.unshift(part);
-        }
-    }
-
-    return resolvedParts.join('/');
-}