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

package/server/api/content/data.ts

@@ -1,97 +0,0 @@
-import type { ContentGeneric } 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';
-import type { ContentGroupLike } from '@shared/content/data/groupLike';
-
-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 { getQuickLinks } from '@server/repository/quickLink';
-import { getContentToc } from '@server/repository/contentToc';
-import { getContentSourceUsageSet } from '@server/repository/reference';
-import { getReadLink } from '@server/repository/readLink';
-import { getElementStats } from '@server/repository/elementStats';
-import { countTopicsIn } from '@server/repository/topicCount';
-
-export default defineEventHandler(async (event) => {
-    let contentId = getQuery(event)?.contentId as string;
-    contentId = 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: ContentGeneric,
-): Promise<ContentTopicData> {
-    const contentBook = await getContentBookFor(generic.contentId);
-
-    return {
-        type: 'topic',
-        generic,
-        bookTitle: contentBook?.title,
-        topicPartLinks: await getTopicPartsLinks(generic.contentId),
-        quickLinks: await getQuickLinks(generic.contentId),
-    };
-}
-
-async function getGroupData(
-    generic: ContentGeneric,
-): Promise<ContentGroupData> {
-    const contentBook = await getContentBookFor(generic.contentId);
-
-    return {
-        type: 'group',
-        generic,
-        groupLike: await getGroupLikeData(generic.contentId),
-        bookTitle: contentBook?.title,
-    };
-}
-
-async function getBookData(generic: ContentGeneric): Promise<ContentBookData> {
-    return {
-        type: 'book',
-        generic,
-        groupLike: await getGroupLikeData(generic.contentId),
-    };
-}
-
-//
-//
-//
-
-async function getGroupLikeData(contentId: string): Promise<ContentGroupLike> {
-    return {
-        contentToc: await getContentToc(contentId),
-        readLink: await getReadLink(contentId),
-        topicCount: await countTopicsIn(contentId),
-        elementStats: await getElementStats(contentId),
-        sourceUsageSet: await getContentSourceUsageSet(contentId),
-    };
-}

package/server/api/contributor/count.ts

@@ -1,6 +0,0 @@
-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/fake/content.ts

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

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

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

package/server/api/index/data.ts

@@ -1,46 +0,0 @@
-import type { IndexData } from '@shared/indexData';
-
-import { getAllElementStats } from '@server/repository/elementStats';
-import { countAllTopics } from '@server/repository/topicCount';
-import { getFullContentToc } from '@server/repository/contentToc';
-import { ERUDIT_SERVER } from '@server/global';
-import { DbContributor } from '@server/db/entities/Contributor';
-import { getSponsorIds, readSponsorConfig } from '@server/sponsor/repository';
-
-export default defineEventHandler<Promise<IndexData>>(async () => {
-    return {
-        elementStats: await getAllElementStats(),
-        topicCount: await countAllTopics(),
-        contentToc: await getFullContentToc(),
-        contributors: await getIndexContributors(),
-        sponsors: await getIndexSponsors(),
-    };
-});
-
-async function getIndexContributors(): Promise<[string, string | undefined][]> {
-    const dbContributors = await ERUDIT_SERVER.DB.manager.find(DbContributor, {
-        select: ['contributorId', 'displayName', 'avatar'],
-    });
-
-    return dbContributors.map((contributor) => [
-        contributor.displayName || contributor.contributorId,
-        contributor.avatar ? '/contributors/' + contributor.avatar : undefined,
-    ]);
-}
-
-async function getIndexSponsors(): Promise<[string, string | undefined][]> {
-    const sponsorIds = getSponsorIds();
-    const indexSponsors: [string, string | undefined][] = [];
-
-    for (const sponsorId of sponsorIds) {
-        const config = await readSponsorConfig(sponsorId);
-        if (config) {
-            indexSponsors.push([
-                config.name || sponsorId,
-                ERUDIT_SERVER.SPONSORS?.avatars[sponsorId],
-            ]);
-        }
-    }
-
-    return indexSponsors;
-}

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

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

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

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

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

@@ -1,12 +0,0 @@
-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/preview/page/[...parts].ts

@@ -1,78 +0,0 @@
-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,
-            },
-        };
-    },
-);

package/server/api/preview/unique/[...location].ts

@@ -1,48 +0,0 @@
-import { stringifyBitranLocation } from '@erudit-js/cog/schema';
-
-import { getLocationContext } from '@server/content/context';
-import { ERUDIT_SERVER } from '@server/global';
-import { DbUnique } from '@server/db/entities/Unique';
-import { parseClientBitranLocation } from '@server/bitran/location';
-import { getBitranContent } from '@server/bitran/content';
-
-import type { Context } from '@shared/content/context';
-import type { RawBitranContent } from '@shared/bitran/content';
-
-interface ReturnType {
-    context: Context;
-    title?: string;
-    elementName: string;
-    rawBitranContent: RawBitranContent;
-}
-
-export default defineEventHandler<Promise<ReturnType>>(async (event) => {
-    setResponseHeader(event, 'Content-Type', 'application/json; charset=utf-8');
-
-    const location = await parseClientBitranLocation(
-        event.context.params!.location,
-    );
-
-    const context = await getLocationContext(location);
-
-    const dbUnique = await (async () => {
-        const dbUnique = ERUDIT_SERVER.DB.manager.findOne(DbUnique, {
-            select: ['title', 'productName'],
-            where: { location: stringifyBitranLocation(location) },
-        });
-
-        if (!dbUnique)
-            throw createError(
-                `Missing unique "${stringifyBitranLocation(location)}"!`,
-            );
-
-        return dbUnique as any as DbUnique;
-    })();
-
-    return <ReturnType>{
-        context,
-        title: dbUnique.title,
-        elementName: dbUnique.productName,
-        rawBitranContent: await getBitranContent(location),
-    };
-});

package/server/api/problem/generator/[...path].ts

@@ -1,26 +0,0 @@
-import { build } from 'esbuild';
-import { getGeneratorFilePath } from '@erudit-js/bitran-elements/problem/server';
-
-export default defineEventHandler(async (event) => {
-    const generatorContentPath = event.context.params!.path?.slice(0, -3);
-    const generatorFilePath = await getGeneratorFilePath(generatorContentPath);
-
-    const script = (
-        await build({
-            write: false,
-            bundle: true,
-            charset: 'utf8',
-            format: 'esm',
-            inject: ['@erudit-js/bitran-elements/problem/generator'],
-            entryPoints: [generatorFilePath],
-        })
-    ).outputFiles[0]!.text;
-
-    setResponseHeader(
-        event,
-        'Content-Type',
-        'application/javascript; charset=utf-8',
-    );
-
-    return script;
-});

package/server/api/sponsor/cameo/data/[sponsorId].ts

@@ -1,51 +0,0 @@
-import { type Cameo, type Sponsor } from '@erudit-js/cog/schema';
-
-import { retrieveSponsor } from '@server/sponsor/repository';
-import { ERUDIT_SERVER } from '@server/global';
-
-export default defineEventHandler<Promise<Cameo>>(async (event) => {
-    const sponsorId = event.context.params?.sponsorId;
-
-    if (typeof sponsorId !== 'string' || !sponsorId) {
-        throw createError({
-            statusCode: 400,
-            message: 'Sponsor ID is required and must be a string!',
-        });
-    }
-
-    let sponsor: Sponsor;
-    try {
-        sponsor = await retrieveSponsor(sponsorId);
-    } catch (error) {
-        throw createError({
-            statusCode: 500,
-            message: `Failed to retrieve sponsor with ID "${sponsorId}"! Error: ${error}`,
-        });
-    }
-
-    if (sponsor.tier !== 'tier2') {
-        throw createError({
-            statusCode: 404,
-            message: `Sponsor with ID "${sponsorId}" is not a Tier 2 sponsor!`,
-        });
-    }
-
-    const defaultMessages = ERUDIT_SERVER.CONFIG.sponsors?.defaultCameoMessages;
-
-    if (!defaultMessages) {
-        throw createError({
-            statusCode: 500,
-            message: 'Default sponsor cameo messages are not configured!',
-        });
-    }
-
-    return {
-        cameoId: sponsorId,
-        name: sponsor.name,
-        icon: sponsor.icon,
-        avatars: [sponsor.avatar],
-        color: sponsor.color,
-        link: sponsor.link,
-        messages: [...(sponsor.messages || []), ...defaultMessages],
-    } satisfies Cameo;
-});

package/server/api/sponsor/cameo/ids.ts

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

package/server/api/sponsor/count.ts

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

package/server/api/sponsor/list.ts

@@ -1,36 +0,0 @@
-import type { Tier1Sponsor, Tier2Sponsor } from '@erudit-js/cog/schema';
-
-import { getSponsorIds, retrieveSponsor } from '@server/sponsor/repository';
-
-const BATCH_SIZE = 10;
-
-export default defineEventHandler(async () => {
-    const sponsorIds = getSponsorIds();
-    const sponsors = await processSponsorsBatched(sponsorIds);
-    return categorizeSponsorsByTier(sponsors);
-});
-
-async function processSponsorsBatched(sponsorIds: string[]) {
-    const allSponsors = [];
-
-    for (let i = 0; i < sponsorIds.length; i += BATCH_SIZE) {
-        const batch = sponsorIds.slice(i, i + BATCH_SIZE);
-        const batchResults = await Promise.all(
-            batch.map((sponsorId) => retrieveSponsor(sponsorId!)),
-        );
-        allSponsors.push(...batchResults);
-    }
-
-    return allSponsors;
-}
-
-function categorizeSponsorsByTier(sponsors: (Tier1Sponsor | Tier2Sponsor)[]) {
-    return {
-        tier1: sponsors.filter(
-            (sponsor): sponsor is Tier1Sponsor => sponsor.tier === 'tier1',
-        ),
-        tier2: sponsors.filter(
-            (sponsor): sponsor is Tier2Sponsor => sponsor.tier === 'tier2',
-        ),
-    };
-}