erudit 3.0.0-dev.22 → 3.0.0-dev.25

package/server/plugin/repository/content.ts

@@ -1,240 +0,0 @@
-import type { ContentType } from '@erudit-js/cog/schema';
-import { Like } from 'typeorm';
-
-import { ERUDIT_SERVER } from '@server/global';
-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, getPreviousNextNav } from '@server/nav/utils';
-import {
-    getShortContentId,
-    resolveClientContentId,
-} from '@server/repository/contentId';
-import { getTopicPart } from './topic';
-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';
-
-export async function getContentGenericData(
-    contentId: string,
-): Promise<ContentGenericData> {
-    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
-        where: { contentId },
-    });
-
-    if (!dbContent) {
-        throw createError({
-            statusCode: 404,
-            message: `Content item "${contentId}" not found!`,
-        });
-    }
-
-    const previousNext = await getPreviousNext(contentId);
-    const decoration = await getContentDecoration(contentId);
-    const flags = await getContentFlags(contentId);
-
-    const contentPage: ContentGenericData = {
-        contentId,
-        type: dbContent.type,
-        title: dbContent.title || undefined,
-        description: dbContent.description || undefined,
-        flags,
-        previousNext,
-        decoration,
-        context: await getContentContext(contentId),
-        seo: dbContent.seo,
-        ogImage: dbContent.ogImage,
-        dependencies: dbContent.dependencies
-            ? await getContentDependencies(contentId, dbContent.dependencies)
-            : undefined,
-        references: dbContent.references,
-    };
-
-    return contentPage;
-}
-
-export async function getPreviousNext(contentId: string) {
-    const { previousNav, nextNav } = await getPreviousNextNav(contentId);
-
-    async function getItemData(navNode: NavNode): Promise<PreviousNextItem> {
-        const title = await getContentTitle(navNode.fullId);
-
-        const link = await (async () => {
-            if (navNode.type === 'topic')
-                return createTopicPartLink(
-                    await getTopicPart(navNode.fullId),
-                    navNode.shortId,
-                );
-
-            return createContentLink(navNode.type, navNode.shortId);
-        })();
-
-        return {
-            title,
-            link,
-        };
-    }
-
-    return {
-        previous: previousNav ? await getItemData(previousNav) : undefined,
-        next: nextNav ? await getItemData(nextNav) : undefined,
-    };
-}
-
-export async function getContentDecoration(contentId: string) {
-    const idsUp = await getIdsUp(contentId);
-
-    for (const id of idsUp) {
-        const decoration = (
-            await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
-                select: ['decoration'],
-                where: { contentId: id },
-            })
-        )?.decoration;
-
-        if (decoration) return decoration;
-    }
-
-    return undefined;
-}
-
-export async function getContentFlags(contentId: string) {
-    const idsUp = await getIdsUp(contentId);
-    const flags: any = {};
-
-    for (const id of idsUp.reverse()) {
-        const dbFlags = (
-            await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
-                select: ['flags'],
-                where: { contentId: id },
-            })
-        )?.flags;
-
-        if (dbFlags)
-            for (const [flagName, flagValue] of Object.entries(dbFlags))
-                flags[flagName] = flagValue;
-    }
-
-    for (const [flagName, flagValue] of Object.entries(flags))
-        if (flagValue === false) delete flags[flagName];
-
-    return flags;
-}
-
-export async function getContentDependencies(
-    contentId: string,
-    strDependencies: string[],
-) {
-    const dependencyIds: string[] = [];
-    for (const rawDependency of strDependencies) {
-        dependencyIds.push(
-            resolveClientContentId(rawDependency, contentId, 'full'),
-        );
-    }
-
-    const dependencies: Record<string, string> = {};
-
-    for (const dependencyId of dependencyIds)
-        dependencies[await getContentLink(dependencyId)] =
-            await getContentTitle(dependencyId);
-
-    return dependencies;
-}
-
-export async function getContentTitle(contentId: string) {
-    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
-        select: ['title'],
-        where: { contentId },
-    });
-
-    return dbContent?.title || contentId.split('/').pop()!;
-}
-
-export async function getContentLink(contentId: string) {
-    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
-        select: ['type'],
-        where: { contentId },
-    });
-
-    if (!dbContent) {
-        throw createError({
-            statusCode: 404,
-            statusText: `Missing "${contentId}" content item!`,
-        });
-    }
-
-    const shortContentId = getShortContentId(contentId);
-
-    if (dbContent.type !== 'topic') {
-        return createContentLink(dbContent.type, shortContentId);
-    }
-
-    const topicPart = await getTopicPart(contentId);
-
-    return createTopicPartLink(topicPart, shortContentId);
-}
-
-export async function getContentContributors(contentId: string) {
-    const contributorIds = await (async () => {
-        const idHash: Record<string, true> = {};
-
-        (
-            await ERUDIT_SERVER.DB.manager.find(DbContribution, {
-                select: ['contributorId'],
-                where: { contentId },
-            })
-        ).forEach(
-            (contribution) => (idHash[contribution.contributorId] = true),
-        );
-
-        const type: ContentType = (await ERUDIT_SERVER.DB.manager.findOne(
-            DbContent,
-            {
-                select: ['type'],
-                where: { contentId },
-            },
-        ))!.type;
-
-        if (type === 'book' || type === 'group') {
-            // Collecting contributors for all sub-content items
-            (
-                await ERUDIT_SERVER.DB.manager.find(DbContribution, {
-                    select: ['contributorId'],
-                    where: { contentId: Like(`${contentId}/%`) },
-                })
-            ).forEach(
-                (contribution) => (idHash[contribution.contributorId] = true),
-            );
-        }
-
-        return Object.keys(idHash);
-    })();
-
-    const contentContributors: ContentContributor[] = [];
-
-    for (const contributorId of contributorIds) {
-        const dbContributor = (await ERUDIT_SERVER.DB.manager.findOne(
-            DbContributor,
-            {
-                select: ['contributorId', 'displayName', 'avatar'],
-                where: { contributorId },
-            },
-        ))!;
-
-        const contentContributor: ContentContributor = { contributorId };
-
-        if (dbContributor.displayName)
-            contentContributor.displayName = dbContributor.displayName;
-
-        if (dbContributor.avatar)
-            contentContributor.avatar = dbContributor.avatar;
-
-        contentContributors.push(contentContributor);
-    }
-
-    return contentContributors.length ? contentContributors : undefined;
-}

package/server/plugin/repository/contentId.ts

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

@@ -1,129 +0,0 @@
-import { DbContributor } from '@server/db/entities/Contributor';
-import { DbContribution } from '@server/db/entities/Contribution';
-import { ERUDIT_SERVER } from '@server/global';
-import { getNavBookOf, getNavNode } from '@server/nav/utils';
-import { getBookTitleFor } from '@server/repository/book';
-import { getContentLink, getContentTitle } from '@server/repository/content';
-
-import type { Contribution, PageContributor } from '@shared/contributor';
-
-export async function contributorExists(contributorId: string) {
-    return await ERUDIT_SERVER.DB.manager.exists(DbContributor, {
-        where: { contributorId },
-    });
-}
-
-export async function getContributorPageData(
-    contributorId: string,
-): Promise<PageContributor> {
-    if (!(await contributorExists(contributorId))) {
-        throw createError({
-            statusCode: 404,
-            message: `Contributor ${contributorId} not found!`,
-        });
-    }
-
-    const dbContributor = (await ERUDIT_SERVER.DB.manager.findOne(
-        DbContributor,
-        {
-            select: [
-                'displayName',
-                'slogan',
-                'links',
-                'avatar',
-                'isEditor',
-                'description',
-            ],
-            where: { contributorId },
-        },
-    ))!;
-
-    return {
-        contributorId,
-        displayName: dbContributor.displayName,
-        slogan: dbContributor.slogan,
-        links: dbContributor.links,
-        avatar: dbContributor.avatar,
-        isEditor: dbContributor.isEditor,
-        hasDescription: !!dbContributor.description,
-        contributions: await getContributions(contributorId),
-    };
-}
-
-export async function getContributions(
-    contributorId: string,
-): Promise<Contribution[]> {
-    const dbContributions = await ERUDIT_SERVER.DB.manager.find(
-        DbContribution,
-        {
-            select: ['contentId'],
-            where: { contributorId },
-        },
-    );
-
-    const contributions: Contribution[] = [];
-    const existingBookTitles = new Set<string>();
-
-    for (const dbContribution of dbContributions) {
-        const contentId = dbContribution.contentId;
-        const contentNavNode = getNavNode(contentId);
-
-        const bookData = await (async () => {
-            const bookNavNode = getNavBookOf(contentId);
-
-            if (!bookNavNode) {
-                return undefined;
-            }
-
-            const bookId = bookNavNode.fullId;
-
-            if (!bookId) {
-                return undefined;
-            }
-
-            if (bookId === contentId) {
-                return undefined;
-            }
-
-            let bookTitle = await getBookTitleFor(bookId);
-
-            let cursor = bookNavNode;
-            while (cursor) {
-                if (cursor.type === 'group') {
-                    const groupTitle = await getContentTitle(cursor.fullId);
-                    const newBookTitle = groupTitle + ' / ' + bookTitle;
-
-                    if (bookTitle && existingBookTitles.has(bookTitle)) {
-                        bookTitle = newBookTitle;
-                    }
-                }
-
-                cursor = cursor.parent as any;
-            }
-
-            if (bookTitle) {
-                existingBookTitles.add(bookTitle);
-            }
-
-            return {
-                bookId,
-                bookTitle,
-            };
-        })();
-
-        const contentTitle = await getContentTitle(contentId);
-        const contentLink = await getContentLink(contentId);
-
-        const contribution: Contribution = {
-            bookId: bookData?.bookId,
-            bookTitle: bookData?.bookTitle,
-            contentType: contentNavNode.type,
-            contentTitle,
-            contentLink,
-        };
-
-        contributions.push(contribution);
-    }
-
-    return contributions;
-}

package/server/plugin/repository/file.ts

@@ -1,10 +0,0 @@
-import { ERUDIT_SERVER } from '@server/global';
-import { DbFile } from '@server/db/entities/File';
-
-export async function getFileFullPath(path: string) {
-    const dbFile = await ERUDIT_SERVER.DB.manager.findOne(DbFile, {
-        where: { path },
-    });
-
-    return dbFile?.fullPath;
-}

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/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/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>;
-}