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

package/server/api/bitran/toc/[...location].ts

@@ -0,0 +1,9 @@
+import { parseClientBitranLocation } from '@server/bitran/location';
+import { getBitranToc } from '@server/bitran/toc';
+
+export default defineEventHandler(async (event) => {
+    const location = await parseClientBitranLocation(
+        event.context.params!.location,
+    );
+    return await getBitranToc(location);
+});

package/server/api/cameo/data/[cameoId].ts

@@ -0,0 +1,42 @@
+import { glob } from 'glob';
+import { type Cameo } from '@erudit-js/cog/schema';
+
+import { PROJECT_DIR } from '@erudit/globalPath';
+import { IMPORT } from '@server/importer';
+
+export default defineEventHandler<Promise<Cameo>>(async (event) => {
+    const cameoId = event.context.params?.cameoId;
+
+    if (typeof cameoId !== 'string' || !cameoId) {
+        throw createError({
+            statusCode: 400,
+            message: 'Cameo ID is required and must be a string!',
+        });
+    }
+
+    const avatarPaths = await glob(`cameos/${cameoId}/avatars/*`, {
+        cwd: PROJECT_DIR,
+        absolute: false,
+        posix: true,
+    });
+
+    const avatarRoutes = avatarPaths.map((path) => `/asset/${path}`);
+
+    let cameoConfig;
+    try {
+        cameoConfig = await IMPORT(`${PROJECT_DIR}/cameos/${cameoId}/cameo`, {
+            default: true,
+        });
+    } catch (error) {
+        throw createError({
+            statusCode: 500,
+            message: `Failed to import config for ID "${cameoId}"! Error: ${error}`,
+        });
+    }
+
+    return {
+        ...cameoConfig,
+        cameoId,
+        avatars: avatarRoutes,
+    } satisfies Cameo;
+});

package/server/api/cameo/ids.ts

@@ -0,0 +1,5 @@
+import { getCameoIds } from '@server/repository/cameo';
+
+export default defineEventHandler(async () => {
+    return await getCameoIds();
+});

package/server/api/content/data.ts

@@ -1,72 +1,75 @@
-import { getTopicPartsLinks } from '@server/repository/topic';
-import { getContentBookFor } from '@server/repository/book';
-import { getContentGenericData } from '@server/repository/content';
-
-import type { ContentGenericData } from '@shared/content/data/base';
-import type { ContentTopicData } from '@shared/content/data/type/topic';
-import type { ContentGroupData } from '@shared/content/data/type/group';
-import type { ContentBookData } from '@shared/content/data/type/book';
-
-export default defineEventHandler(async (event) => {
-    const contentId = getQuery(event)?.contentId as string;
-
-    if (!contentId)
-        throw createError({
-            statusCode: 400,
-            statusText: 'Missing content ID!',
-        });
-
-    const generic = await getContentGenericData(contentId);
-
-    switch (generic.type) {
-        case 'topic':
-            return await getTopicData(generic);
-        case 'group':
-            return await getGroupData(generic);
-        case 'book':
-            return await getBookData(generic);
-    }
-
-    throw createError({
-        statusCode: 400,
-        statusText: `Unknown content data type "${generic.type}"!`,
-    });
-});
-
-//
-//
-//
-
-async function getTopicData(
-    generic: ContentGenericData,
-): Promise<ContentTopicData> {
-    const contentBook = await getContentBookFor(generic.contentId);
-
-    return {
-        type: 'topic',
-        generic,
-        bookTitle: contentBook?.title,
-        topicPartLinks: await getTopicPartsLinks(generic.contentId),
-    };
-}
-
-async function getGroupData(
-    generic: ContentGenericData,
-): Promise<ContentGroupData> {
-    const contentBook = await getContentBookFor(generic.contentId);
-
-    return {
-        type: 'group',
-        generic,
-        bookTitle: contentBook?.title,
-    };
-}
-
-async function getBookData(
-    generic: ContentGenericData,
-): Promise<ContentBookData> {
-    return {
-        type: 'book',
-        generic,
-    };
-}
+import { getTopicPartsLinks } from '@server/repository/topic';
+import { getContentBookFor } from '@server/repository/book';
+import { getContentGenericData } from '@server/repository/content';
+import { getFullContentId } from '@server/repository/contentId';
+
+import type { ContentGenericData } from '@shared/content/data/base';
+import type { ContentTopicData } from '@shared/content/data/type/topic';
+import type { ContentGroupData } from '@shared/content/data/type/group';
+import type { ContentBookData } from '@shared/content/data/type/book';
+
+export default defineEventHandler(async (event) => {
+    let contentId = getQuery(event)?.contentId as string;
+    contentId = await getFullContentId(contentId);
+
+    if (!contentId) {
+        throw createError({
+            statusCode: 400,
+            statusText: 'Missing content ID!',
+        });
+    }
+
+    const generic = await getContentGenericData(contentId);
+
+    switch (generic.type) {
+        case 'topic':
+            return await getTopicData(generic);
+        case 'group':
+            return await getGroupData(generic);
+        case 'book':
+            return await getBookData(generic);
+    }
+
+    throw createError({
+        statusCode: 400,
+        statusText: `Unknown content data type "${generic.type}"!`,
+    });
+});
+
+//
+//
+//
+
+async function getTopicData(
+    generic: ContentGenericData,
+): Promise<ContentTopicData> {
+    const contentBook = await getContentBookFor(generic.contentId);
+
+    return {
+        type: 'topic',
+        generic,
+        bookTitle: contentBook?.title,
+        topicPartLinks: await getTopicPartsLinks(generic.contentId),
+    };
+}
+
+async function getGroupData(
+    generic: ContentGenericData,
+): Promise<ContentGroupData> {
+    const contentBook = await getContentBookFor(generic.contentId);
+
+    return {
+        type: 'group',
+        generic,
+        bookTitle: contentBook?.title,
+    };
+}
+
+async function getBookData(
+    generic: ContentGenericData,
+): Promise<ContentBookData> {
+    return {
+        type: 'book',
+        generic,
+    };
+}

package/server/api/contributor/count.ts

@@ -1,6 +1,6 @@
-import { DbContributor } from '@server/db/entities/Contributor';
-import { ERUDIT_SERVER } from '@server/global';
-
-export default defineEventHandler(async () => {
-    return await ERUDIT_SERVER.DB.manager.count(DbContributor);
-});
+import { DbContributor } from '@server/db/entities/Contributor';
+import { ERUDIT_SERVER } from '@server/global';
+
+export default defineEventHandler(async () => {
+    return await ERUDIT_SERVER.DB.manager.count(DbContributor);
+});

package/server/api/contributor/list.ts

@@ -0,0 +1,44 @@
+import { DbContribution } from '@server/db/entities/Contribution';
+import { DbContributor } from '@server/db/entities/Contributor';
+import { ERUDIT_SERVER } from '@server/global';
+
+import { type ContributorListItem } from '@shared/contributor';
+
+export default defineEventHandler<Promise<ContributorListItem[]>>(async () => {
+    const dbContributors = await ERUDIT_SERVER.DB.manager.find(DbContributor, {
+        select: ['contributorId', 'displayName', 'isEditor', 'avatar'],
+    });
+
+    if (dbContributors.length === 0) {
+        return [];
+    }
+
+    const contributors: ContributorListItem[] = await Promise.all(
+        dbContributors.map(async (dbContributor) => {
+            const contributions = await ERUDIT_SERVER.DB.manager.count(
+                DbContribution,
+                {
+                    where: { contributorId: dbContributor.contributorId },
+                },
+            );
+
+            return {
+                contributorId: dbContributor.contributorId,
+                displayName: dbContributor.displayName,
+                isEditor: dbContributor.isEditor,
+                avatar: dbContributor.avatar,
+                contributions,
+            };
+        }),
+    );
+
+    contributors.sort((a, b) => {
+        if (a.isEditor !== b.isEditor) {
+            return a.isEditor ? -1 : 1;
+        }
+
+        return b.contributions - a.contributions;
+    });
+
+    return contributors;
+});

package/server/api/contributor/page/[contributorId].ts

@@ -0,0 +1,14 @@
+import { getContributorPageData } from '@server/repository/contributor';
+
+export default defineEventHandler(async (event) => {
+    const contributorId = event.context.params?.contributorId;
+
+    if (!contributorId) {
+        throw createError({
+            statusCode: 400,
+            message: 'Missing contributor ID!',
+        });
+    }
+
+    return await getContributorPageData(contributorId);
+});

package/server/api/fake/content.ts

@@ -1,11 +1,11 @@
-export default defineEventHandler(() => {
-    return {
-        commit: {
-            commit: {
-                author: {
-                    date: '2019-08-30T14:57:06.000Z',
-                },
-            },
-        },
-    };
-});
+export default defineEventHandler(() => {
+    return {
+        commit: {
+            commit: {
+                author: {
+                    date: '2019-08-30T14:57:06.000Z',
+                },
+            },
+        },
+    };
+});

package/server/api/fake/shared/languages.ts

@@ -1,12 +1,12 @@
-export default defineEventHandler(() => {
-    return {
-        en: {
-            name: 'English',
-            link: 'https://en.omath.net',
-        },
-        ru: {
-            name: 'Русский',
-            link: 'https://omath.ru',
-        },
-    };
-});
+export default defineEventHandler(() => {
+    return {
+        en: {
+            name: 'English',
+            link: 'https://en.omath.net',
+        },
+        ru: {
+            name: 'Русский',
+            link: 'https://omath.ru',
+        },
+    };
+});

package/server/api/language/functions.ts

@@ -1,12 +1,12 @@
-import { ERUDIT_SERVER } from '@server/global';
-
-export default defineEventHandler(() => {
-    const strFunctions: Record<string, string> = {};
-
-    for (const [key, func] of Object.entries(
-        ERUDIT_SERVER.LANGUAGE?.functions || {},
-    ))
-        strFunctions[key] = 'return ' + func.toString();
-
-    return strFunctions;
-});
+import { ERUDIT_SERVER } from '@server/global';
+
+export default defineEventHandler(() => {
+    const strFunctions: Record<string, string> = {};
+
+    for (const [key, func] of Object.entries(
+        ERUDIT_SERVER.LANGUAGE?.functions || {},
+    ))
+        strFunctions[key] = 'return ' + func.toString();
+
+    return strFunctions;
+});

package/server/api/language/phrase/[phraseId].ts

@@ -1,19 +1,19 @@
-import type { EruditPhraseId } from '@shared/types/language';
-import { ERUDIT_SERVER } from '@server/global';
-
-export default defineEventHandler((event) => {
-    const phraseId = getRouterParam(event, 'phraseId');
-    const phrase =
-        ERUDIT_SERVER.LANGUAGE?.phrases?.[phraseId as EruditPhraseId];
-
-    setResponseHeader(event, 'content-type', 'text/plain');
-
-    if (typeof phrase === 'string') return phrase;
-    else if (typeof phrase === 'function')
-        return '~!~FUNC~!~' + 'return ' + phrase.toString();
-
-    throw createError({
-        statusCode: 400,
-        statusText: `Unknown phrase id "${phraseId}"!`,
-    });
-});
+import type { EruditPhraseId } from '@shared/types/language';
+import { ERUDIT_SERVER } from '@server/global';
+
+export default defineEventHandler((event) => {
+    setResponseHeader(event, 'Content-Type', 'text/plain; charset=utf-8');
+
+    const phraseId = getRouterParam(event, 'phraseId');
+    const phrase =
+        ERUDIT_SERVER.LANGUAGE?.phrases?.[phraseId as EruditPhraseId];
+
+    if (typeof phrase === 'string') return phrase;
+    else if (typeof phrase === 'function')
+        return '~!~FUNC~!~' + 'return ' + phrase.toString();
+
+    throw createError({
+        statusCode: 400,
+        statusText: `Unknown phrase id "${phraseId}"!`,
+    });
+});

package/server/api/language/phraseIds.ts

@@ -1,8 +1,8 @@
-import { ERUDIT_SERVER } from '@server/global';
-import type { EruditPhraseId } from '@shared/types/language';
-
-export default defineEventHandler(() => {
-    return Object.keys(
-        ERUDIT_SERVER.LANGUAGE?.phrases || [],
-    ) as EruditPhraseId[];
-});
+import { ERUDIT_SERVER } from '@server/global';
+import type { EruditPhraseId } from '@shared/types/language';
+
+export default defineEventHandler(() => {
+    return Object.keys(
+        ERUDIT_SERVER.LANGUAGE?.phrases || [],
+    ) as EruditPhraseId[];
+});

package/server/api/prerender/assets/cameo.ts

@@ -0,0 +1,14 @@
+import { PROJECT_DIR } from '#erudit/globalPaths';
+import { glob } from 'glob';
+
+const includePatterns = [`cameos/*/avatars/*`];
+
+export default defineEventHandler(async () => {
+    const files = await glob(includePatterns, {
+        cwd: PROJECT_DIR,
+        absolute: false,
+        posix: true,
+    });
+
+    return files.map((file) => '/asset/' + file);
+});

package/server/api/prerender/assets/contributor.ts

@@ -0,0 +1,12 @@
+import { glob } from 'glob';
+import { PROJECT_DIR } from '#erudit/globalPaths';
+
+export default defineEventHandler(async () => {
+    const avatars = await glob('contributors/*/avatar.*', {
+        cwd: PROJECT_DIR,
+        absolute: false,
+        posix: true,
+    });
+
+    return avatars.map((avatar) => '/asset/' + avatar);
+});

package/server/api/prerender/assets/sponsor.ts

@@ -0,0 +1,13 @@
+import { ERUDIT_SERVER } from '@server/global';
+
+export default defineEventHandler(async () => {
+    const serverSponsors = ERUDIT_SERVER.SPONSORS;
+
+    if (!serverSponsors) {
+        return [];
+    }
+
+    return Object.values(serverSponsors.avatars)
+        .filter(Boolean)
+        .map((avatar) => '/asset/' + avatar);
+});

package/server/api/prerender/cameos.ts

@@ -0,0 +1,12 @@
+import { getCameoIds } from '@server/repository/cameo';
+import { getTier2SponsorIds } from '@server/sponsor/repository';
+
+export default defineEventHandler(async () => {
+    const cameoIds = await getCameoIds();
+    return [
+        '/api/cameo/ids',
+        '/api/sponsor/cameo/ids',
+        ...cameoIds.map((id) => `/api/cameo/data/${id}`),
+        ...getTier2SponsorIds().map((id) => `/api/sponsor/cameo/data/${id}`),
+    ];
+});

package/server/api/prerender/language.ts

@@ -0,0 +1,9 @@
+import { ERUDIT_SERVER } from '@server/global';
+
+export default defineEventHandler(() => {
+    const phraseRoutes = Object.keys(ERUDIT_SERVER.LANGUAGE?.phrases || []).map(
+        (phraseId) => `/api/language/phrase/${phraseId}`,
+    );
+
+    return ['/api/language/functions', ...phraseRoutes];
+});

package/server/api/preview/page/[...parts].ts

@@ -1,51 +1,78 @@
-import {
-    getContentContext,
-    getTopicPartContext,
-    getContributorContext,
-} from '@erudit/server/plugin/content/context';
-
-import type { PreviewDataPageLink } from '@app/scripts/preview/data/pageLink';
-import type { LinkTargetPageType } from '@erudit/shared/bitran/link/target';
-import type { Context, ContextItem } from '@erudit/shared/content/context';
-
-export default defineEventHandler<Promise<PreviewDataPageLink>>(
-    async (event) => {
-        const urlParts = (event.context.params?.parts || '').split('/');
-        const pageType: LinkTargetPageType = urlParts.shift() as any;
-        const contentId: string = urlParts.join('/');
-
-        const context: Context = await (async () => {
-            switch (pageType) {
-                case 'book':
-                case 'group':
-                    return await getContentContext(contentId);
-                case 'article':
-                case 'summary':
-                case 'practice':
-                    return await getTopicPartContext(pageType, contentId);
-                case 'contributor':
-                    return await getContributorContext(contentId);
-            }
-
-            throw createError(`Can't handle "${pageType}" page type!`);
-        })();
-
-        const lastContextItem = context.pop() as ContextItem;
-        const contextStr = context
-            .filter((c) => !c.hidden)
-            .map((c) => c.title)
-            .join(' / ');
-
-        return <PreviewDataPageLink>{
-            type: 'page-link',
-            footer: {
-                secondary:
-                    (contextStr ? contextStr + ' • ' : '') +
-                    lastContextItem.type,
-                primary: lastContextItem.title,
-                href: lastContextItem.href,
-                iconName: lastContextItem.icon,
-            },
-        };
-    },
-);
+import type { LinkTargetPageType } from '@erudit-js/bitran-elements/link/target';
+import { isContentType } from '@erudit-js/cog/schema';
+
+import {
+    getContentContext,
+    getTopicPartContext,
+    getContributorContext,
+} from '@server/content/context';
+import { getFullContentId } from '@server/repository/contentId';
+import { ERUDIT_SERVER } from '@server/global';
+import { DbContent } from '@server/db/entities/Content';
+
+import type { Context, ContextItem } from '@erudit/shared/content/context';
+import type { PreviewDataPageLink } from '@app/scripts/preview/data/pageLink';
+
+export default defineEventHandler<Promise<PreviewDataPageLink>>(
+    async (event) => {
+        const urlParts = (event.context.params?.parts || '').split('/');
+        const pageType: LinkTargetPageType = urlParts.shift() as any;
+        const contentId: string = urlParts.join('/');
+
+        const context: Context = await (async () => {
+            switch (pageType) {
+                case 'book':
+                case 'group':
+                    return await getContentContext(contentId);
+                case 'article':
+                case 'summary':
+                case 'practice':
+                    return await getTopicPartContext(pageType, contentId);
+                case 'contributor':
+                    return await getContributorContext(contentId);
+            }
+
+            throw createError(`Can't handle "${pageType as any}" page type!`);
+        })();
+
+        const lastContextItem = context.pop() as ContextItem;
+        const contextStr = context
+            .filter((c) => !c.hidden)
+            .map((c) => c.title)
+            .join(' / ');
+
+        const description = await (async () => {
+            if (!isContentType(pageType)) {
+                return;
+            }
+
+            const fullContentId = await getFullContentId(contentId);
+            const dbContent = await ERUDIT_SERVER.DB.manager.findOne(
+                DbContent,
+                {
+                    select: ['description'],
+                    where: { contentId: fullContentId },
+                },
+            );
+
+            if (!dbContent) {
+                return;
+            }
+
+            return dbContent.description?.trim();
+        })();
+
+        return <PreviewDataPageLink>{
+            type: 'page-link',
+            description,
+            footer: {
+                secondary:
+                    (contextStr ? contextStr + ' • ' : '') +
+                    lastContextItem.type,
+                primary: lastContextItem.title,
+                href: lastContextItem.href,
+                iconName: lastContextItem.icon,
+            },
+        };
+    },
+);