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

package/server/api/preview/unique/{[location].ts → [...location].ts}

@@ -1,55 +1,48 @@
-import type { BitranContent } from 'bitran';
-
-import { parseUrlLocation } from '@server/bitran/location';
-import { getLocationContext } from '@server/content/context';
-import { ERUDIT_SERVER } from '@server/global';
-import { DbUnique } from '@server/db/entities/Unique';
-import { getBitranContent } from '@server/bitran/content';
-
-import type { Context } from '@shared/content/context';
-import type { BitranContext } from '@shared/bitran/context';
-import { stringifyBitranLocation } from '@shared/bitran/location';
-
-interface ReturnType {
-    context: Context;
-    productTitle?: string;
-    bitran: {
-        productName: string;
-        context: BitranContext;
-        content: BitranContent;
-    };
-}
-
-export default defineEventHandler<Promise<ReturnType>>(async (event) => {
-    const location = parseUrlLocation(getRouterParam(event, 'location') || '');
-
-    const context = await getLocationContext(location);
-
-    const dbUnique = await (async () => {
-        const dbUnique = ERUDIT_SERVER.DB.manager.findOne(DbUnique, {
-            select: ['productName', 'title', 'context'],
-            where: { location: stringifyBitranLocation(location) },
-        });
-
-        if (!dbUnique)
-            throw createError(
-                `Missing unique "${stringifyBitranLocation(location)}"!`,
-            );
-
-        return dbUnique as any as DbUnique;
-    })();
-
-    const bitran = await (async () => {
-        return {
-            content: await getBitranContent(location),
-            context: dbUnique.context,
-            productName: dbUnique.productName,
-        };
-    })();
-
-    return <ReturnType>{
-        context,
-        productTitle: dbUnique.title,
-        bitran,
-    };
-});
+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

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

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

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

package/server/api/sponsor/count.ts

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

package/server/api/sponsor/list.ts

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