erudit 3.0.0-dev.2 → 3.0.0-dev.21

package/server/plugin/repository/file.ts

@@ -0,0 +1,10 @@
+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,148 +1,145 @@
-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.id },
-            });
-
-            if (!dbGroup)
-                throw new Error(
-                    `Missing group content item "${arg.node.id}" 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.id);
-    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.id },
-    });
-
-    return {
-        id: node.id,
-        fullId: node.fullId,
-        level,
-        flags: dbContent?.flags,
-        label:
-            dbContent?.navTitle ||
-            dbContent?.title ||
-            node.id.split('/').pop()!,
-    };
-}
-
-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 }),
-        ),
-    );
-}
+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,32 +1,35 @@
-import type { TopicPart } from 'erudit-cog/schema';
-
-import { ERUDIT_SERVER } from '@server/global';
-import { DbTopic } from '@server/db/entities/Topic';
-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 links: TopicPartLinks = {};
-
-    for (const topicPart of existingTopicParts)
-        links[topicPart] = createTopicPartLink(topicPart, topicId);
-
-    return links;
-}
+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

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

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

package/server/plugin/sponsor/repository.ts

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

@@ -0,0 +1,34 @@
+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/routes/robots.txt.ts

@@ -0,0 +1,9 @@
+export default defineEventHandler((event) => {
+    setHeader(event, 'Content-Type', 'text/plain');
+    const robots = `
+User-agent: *
+Allow: /
+    `.trim();
+
+    return robots;
+});

package/server/routes/sitemap.xml.ts

@@ -0,0 +1,103 @@
+import { Not } from 'typeorm';
+import type { ContentType } 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 { DbContent } from '@server/db/entities/Content';
+import { DbContributor } from '@server/db/entities/Contributor';
+
+import {
+    createContentLink,
+    createContributorLink,
+    createTopicPartLink,
+} from '@shared/link';
+import { trailingSlash } from '@erudit/utils/url';
+
+export default defineEventHandler(async (event) => {
+    setHeader(event, 'Content-Type', 'application/xml');
+
+    const routes = [
+        ...staticRoutes(),
+        ...(await topicRoutes()),
+        ...(await contentRoutes()),
+        ...(await contributorsRoutes()),
+    ];
+
+    const buildUrl = ERUDIT_SERVER.CONFIG.site?.buildUrl || '';
+    const baseUrl = ERUDIT_SERVER.CONFIG.site?.baseUrl || '/';
+
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${routes
+    .map(
+        (route) =>
+            `    <url>
+        <loc>${trailingSlash(buildUrl + baseUrl, false) + route}</loc>
+        <lastmod>${new Date().toISOString().slice(0, 10)}</lastmod>
+    </url>`,
+    )
+    .join('\n')}
+</urlset>`;
+});
+
+function staticRoutes() {
+    const routes = ['/', '/contributors/'];
+
+    if (ERUDIT_SERVER.CONFIG.sponsors) {
+        routes.push('/sponsors/');
+    }
+
+    return routes;
+}
+
+async function topicRoutes() {
+    const dbTopics = await ERUDIT_SERVER.DB.manager.find(DbTopic, {
+        select: ['contentId', 'parts'],
+    });
+
+    const topicRoutes: string[] = [];
+
+    for (const dbTopic of dbTopics) {
+        const shortId = getShortContentId(dbTopic.contentId);
+        for (const part of dbTopic.parts) {
+            topicRoutes.push(createTopicPartLink(part, shortId));
+        }
+    }
+
+    return topicRoutes;
+}
+
+async function contentRoutes() {
+    const dbContentItems = await ERUDIT_SERVER.DB.manager.find(DbContent, {
+        select: ['contentId', 'type'],
+        where: {
+            type: Not('topic' as ContentType),
+        },
+    });
+
+    const contentRoutes: string[] = [];
+
+    for (const dbContent of dbContentItems) {
+        const shortId = getShortContentId(dbContent.contentId);
+        contentRoutes.push(createContentLink(dbContent.type, shortId));
+    }
+
+    return contentRoutes;
+}
+
+async function contributorsRoutes() {
+    const dbContributors = await ERUDIT_SERVER.DB.manager.find(DbContributor, {
+        select: ['contributorId'],
+    });
+
+    const contributorRoutes: string[] = [];
+
+    for (const dbContributor of dbContributors) {
+        contributorRoutes.push(
+            createContributorLink(dbContributor.contributorId),
+        );
+    }
+
+    return contributorRoutes;
+}