erudit 3.0.0-dev.9 → 4.0.0-dev.2

package/server/api/main/content/[...contentTypePath].ts

@@ -0,0 +1,153 @@
+import { and, eq } from 'drizzle-orm';
+
+export default defineEventHandler<Promise<MainContent>>(async (event) => {
+    const strContentTypePath = event.context.params?.contentTypePath;
+    const contentTypePath = parseContentTypePath(strContentTypePath!);
+    const navNode = ERUDIT.contentNav.getNodeOrThrow(contentTypePath.contentId);
+    const fullId = navNode.fullId;
+    const shortId = navNode.shortId;
+    const contentRelativePath = navNode.contentRelPath;
+    const title = await ERUDIT.repository.content.title(fullId);
+    const description = await ERUDIT.repository.content.description(fullId);
+    const decoration = await ERUDIT.repository.content.decoration(fullId);
+    const elementSnippets =
+        await ERUDIT.repository.content.elementSnippets(fullId);
+    const flags = await ERUDIT.repository.content.flags(fullId);
+    const stats = await ERUDIT.repository.content.stats(fullId);
+    const connections = await ERUDIT.repository.content.connections(fullId);
+    const contributions = await ERUDIT.repository.content.contentContributions(
+        fullId,
+        ['topic', 'page'].includes(contentTypePath.type),
+    );
+    const seo = await ERUDIT.repository.content.seo(fullId);
+
+    const bookNode = ERUDIT.contentNav.getBookFor(fullId);
+    const bookTitle = bookNode
+        ? await ERUDIT.repository.content.title(bookNode.fullId)
+        : undefined;
+
+    //
+    // Base
+    //
+    const mainContentBase: Omit<MainContentBase, 'type'> = {
+        fullId,
+        shortId,
+        contentRelativePath,
+        title,
+        bookTitle,
+        breadcrumbs: await ERUDIT.repository.content.breadcrumbs(fullId),
+        seo,
+    };
+
+    if (description) {
+        mainContentBase.description = description;
+    }
+
+    if (decoration) {
+        mainContentBase.decoration = decoration;
+    }
+
+    if (flags) {
+        mainContentBase.flags = flags;
+    }
+
+    if (stats) {
+        mainContentBase.stats = stats;
+    }
+
+    if (connections) {
+        mainContentBase.connections = connections;
+    }
+
+    if (contributions) {
+        mainContentBase.contributions = contributions;
+    }
+
+    if (contentTypePath.type === 'page' || contentTypePath.type === 'topic') {
+        const proseElement = await ERUDIT.repository.prose.getContent(
+            contentTypePath.type === 'topic'
+                ? contentTypePath.topicPart
+                : contentTypePath.type,
+            fullId,
+        );
+
+        const topicParts = await ERUDIT.repository.content.topicParts(fullId);
+        const { storage } =
+            await ERUDIT.repository.prose.finalize(proseElement);
+
+        const where = (() => {
+            if (contentTypePath.type === 'topic') {
+                return and(
+                    eq(ERUDIT.db.schema.contentToc.fullId, fullId),
+                    eq(
+                        ERUDIT.db.schema.contentToc.topicPart,
+                        contentTypePath.topicPart,
+                    ),
+                );
+            }
+
+            return eq(ERUDIT.db.schema.contentToc.fullId, fullId);
+        })();
+
+        const tocItems = (
+            await ERUDIT.db.query.contentToc.findFirst({
+                columns: { toc: true },
+                where,
+            })
+        )?.toc;
+
+        //
+        // Topic
+        //
+        if (contentTypePath.type === 'topic') {
+            const mainContentTopicPart: MainContentTopicPart = {
+                ...mainContentBase,
+                type: 'topic',
+                part: contentTypePath.topicPart,
+                parts: topicParts,
+                proseElement,
+                storage,
+            };
+
+            if (elementSnippets) {
+                mainContentTopicPart.snippets = elementSnippets;
+            }
+
+            if (tocItems) {
+                mainContentTopicPart.toc = tocItems;
+            }
+
+            return mainContentTopicPart;
+        }
+
+        //
+        // Page
+        //
+
+        const mainContentPage: MainContentPage = {
+            ...mainContentBase,
+            type: 'page',
+            proseElement,
+            storage,
+        };
+
+        if (elementSnippets) {
+            mainContentPage.snippets = elementSnippets;
+        }
+
+        if (tocItems) {
+            mainContentPage.toc = tocItems;
+        }
+
+        return mainContentPage;
+    }
+
+    //
+    // Rest content types
+    //
+    return {
+        ...mainContentBase,
+        type: contentTypePath.type,
+        children: await ERUDIT.repository.content.children(fullId),
+    } satisfies MainContentGroup | MainContentBook;
+});

package/server/api/news/batch/[batchIndex].ts

@@ -0,0 +1,5 @@
+export default defineEventHandler(async (event) => {
+    const { batchIndex } = event.context.params as { batchIndex: string };
+    const batch = await ERUDIT.repository.news.batch(parseInt(batchIndex, 10));
+    return batch;
+});

package/server/api/pageSponsors.ts

@@ -0,0 +1,58 @@
+import type { PageSponsor } from '@erudit-js/core/sponsor';
+
+export default defineEventHandler<Promise<PageSponsor[]>>(async (event) => {
+    const pageSponsors: PageSponsor[] = [];
+    const dbSponsors = await ERUDIT.db.query.sponsors.findMany();
+
+    for (const dbSponsor of dbSponsors) {
+        const pageSponsor: PageSponsor = {
+            name: dbSponsor.data.name ?? dbSponsor.sponsorId,
+        };
+
+        // Try get info
+        if (dbSponsor.data.info) {
+            pageSponsor.info = dbSponsor.data.info;
+        }
+
+        // If has messages, treat random message as info
+        if (dbSponsor.data.messages?.enabled) {
+            if (dbSponsor.data.messages.list) {
+                pageSponsor.info =
+                    dbSponsor.data.messages.list[
+                        Math.floor(
+                            Math.random() * dbSponsor.data.messages.list.length,
+                        )
+                    ];
+            }
+        }
+
+        if (dbSponsor.data.link) {
+            pageSponsor.link = dbSponsor.data.link;
+        }
+
+        if (dbSponsor.data.icon) {
+            pageSponsor.icon = dbSponsor.data.icon;
+        }
+
+        if (dbSponsor.data.avatarExtension) {
+            pageSponsor.avatarUrl = ERUDIT.repository.sponsors.avatarUrl(
+                dbSponsor.sponsorId,
+                dbSponsor.data.avatarExtension,
+            );
+        }
+
+        if (dbSponsor.data.color) {
+            pageSponsor.color = dbSponsor.data.color;
+        }
+
+        if (dbSponsor.data.group) {
+            pageSponsor.group = dbSponsor.data.group;
+        }
+
+        pageSponsors.push(pageSponsor);
+    }
+
+    pageSponsors.sort((a, b) => a.name.localeCompare(b.name));
+
+    return pageSponsors;
+});

package/server/api/prerender/content.ts

@@ -0,0 +1,82 @@
+export default defineEventHandler(async () => {
+    const routes: string[] = [];
+
+    routes.push(...(await pages()));
+    routes.push(...(await contentUniques()));
+    routes.push(...(await problemScripts()));
+
+    return routes;
+});
+
+export async function pages() {
+    const routes: string[] = [];
+
+    for (const navNode of ERUDIT.contentNav.id2Node.values()) {
+        if (navNode.type === 'topic') {
+            const topicParts = await ERUDIT.repository.content.topicParts(
+                navNode.fullId,
+            );
+
+            for (const part of topicParts) {
+                routes.push(PAGES.topic(part, navNode.shortId));
+                routes.push(
+                    `/api/preview/contentPage/${stringifyContentTypePath(part, navNode.fullId)}.json`,
+                );
+            }
+        } else {
+            routes.push(PAGES[navNode.type](navNode.shortId));
+            routes.push(
+                `/api/preview/contentPage/${stringifyContentTypePath(
+                    navNode.type,
+                    navNode.fullId,
+                )}.json`,
+            );
+        }
+    }
+    return routes;
+}
+
+export async function contentUniques() {
+    const routes: string[] = [];
+
+    const dbUniques = await ERUDIT.db.query.contentUniques.findMany({
+        columns: {
+            contentFullId: true,
+            contentProseType: true,
+            uniqueName: true,
+        },
+    });
+
+    for (const dbUnique of dbUniques) {
+        routes.push(
+            `/api/preview/contentUnique/${stringifyContentTypePath(dbUnique.contentProseType, dbUnique.contentFullId)}/${dbUnique.uniqueName}.json`,
+        );
+    }
+
+    return routes;
+}
+
+export async function problemScripts() {
+    const routes: string[] = [];
+
+    const dbProblemScripts = await ERUDIT.db
+        .selectDistinct({
+            problemScript: ERUDIT.db.schema.problemScripts.problemScriptSrc,
+        })
+        .from(ERUDIT.db.schema.problemScripts);
+
+    for (const dbProblemScript of dbProblemScripts) {
+        routes.push(
+            `/api/problemScript/` +
+                dbProblemScript
+                    .problemScript!.replace(
+                        ERUDIT.config.paths.project + '/',
+                        '',
+                    )
+                    .replace('.tsx', '') +
+                '.js',
+        );
+    }
+
+    return routes;
+}

package/server/api/prerender/default.ts

@@ -0,0 +1,35 @@
+export default defineEventHandler(async () => {
+    const routes: string[] = [];
+
+    //
+    // Index
+    //
+
+    routes.push(PAGES.index);
+
+    //
+    // Contributors
+    //
+
+    if (ERUDIT.config.public.project.contributors?.enabled) {
+        routes.push(PAGES.contributors);
+
+        const dbContributors = await ERUDIT.db.query.contributors.findMany({
+            columns: { contributorId: true },
+        });
+
+        for (const dbContributor of dbContributors) {
+            routes.push(PAGES.contributor(dbContributor.contributorId));
+        }
+    }
+
+    //
+    // Sponsors
+    //
+
+    if (ERUDIT.config.public.project.sponsors?.enabled) {
+        routes.push(PAGES.sponsors);
+    }
+
+    return routes;
+});

package/server/api/prerender/files.ts

@@ -0,0 +1,10 @@
+export default defineEventHandler(async () => {
+    const dbFiles = await ERUDIT.db.query.files.findMany();
+    const routes = new Set<string>();
+
+    for (const dbFile of dbFiles) {
+        routes.add(`/file/${dbFile.path}`);
+    }
+
+    return Array.from(routes);
+});

package/server/api/prerender/frontNav.ts

@@ -0,0 +1,13 @@
+export default defineEventHandler(async () => {
+    const bookShortIds = Array.from(ERUDIT.contentNav.id2Books.values()).map(
+        (bookNode) => bookNode.shortId,
+    );
+
+    const routes: string[] = [];
+
+    for (const bookShortId of bookShortIds) {
+        routes.push(`/api/aside/major/frontNav/book/${bookShortId}`);
+    }
+
+    return routes;
+});

package/server/api/prerender/language.ts

@@ -0,0 +1,7 @@
+export default defineEventHandler(async () => {
+    const phraseRoutes = Object.keys(ERUDIT.language.phrases).map(
+        (phraseKey) => `/api/language/phrase/${phraseKey}`,
+    );
+
+    return ['/api/language/functions', ...phraseRoutes];
+});

package/server/api/prerender/news.ts

@@ -0,0 +1,8 @@
+export default defineEventHandler(async () => {
+    const routes = new Set<string>(['/api/news/batch/0']);
+    const batchesNumber = await ERUDIT.repository.news.countBatches();
+    for (let batch = 0; batch < batchesNumber; batch++) {
+        routes.add(`/api/news/batch/${batch}`);
+    }
+    return Array.from(routes);
+});

package/server/api/prerender/quotes.ts

@@ -0,0 +1,15 @@
+export default defineEventHandler(async () => {
+    const routes: string[] = ['/api/quote/ids'];
+
+    const { cameo, sponsor } = await ERUDIT.repository.quotes.ids();
+
+    for (const cameoId of cameo ?? []) {
+        routes.push(`/api/quote/data/${cameoId}`);
+    }
+
+    for (const sponsorId of sponsor ?? []) {
+        routes.push(`/api/quote/data/${sponsorId}`);
+    }
+
+    return routes;
+});

package/server/api/preview/contentPage/[...contentTypePath].ts

@@ -0,0 +1,63 @@
+import { eq } from 'drizzle-orm';
+
+export default defineEventHandler<Promise<PreviewContentPage>>(
+    async (event) => {
+        // <typeOrPart>/<fullOrShortId>.json
+        const strContentTypePath = event.context.params!.contentTypePath.slice(
+            0,
+            -5,
+        );
+
+        const contentTypePath = parseContentTypePath(strContentTypePath);
+        const fullId = contentTypePath.contentId;
+        const navNode = ERUDIT.contentNav.getNodeOrThrow(fullId);
+        const shortId = navNode.shortId;
+
+        const dbContent = (await ERUDIT.db.query.content.findFirst({
+            columns: {
+                title: true,
+                description: true,
+                // TODO: decoration svg!
+            },
+            where: eq(ERUDIT.db.schema.content.fullId, fullId),
+        }))!;
+
+        const bookNavNode = ERUDIT.contentNav.getBookFor(fullId);
+        let bookTitle: string | undefined;
+
+        if (bookNavNode) {
+            const dbBook = (await ERUDIT.db.query.content.findFirst({
+                columns: {
+                    title: true,
+                },
+                where: eq(ERUDIT.db.schema.content.fullId, bookNavNode.fullId),
+            }))!;
+
+            bookTitle = dbBook.title;
+        }
+
+        const link = (() => {
+            if (contentTypePath.type === 'topic') {
+                return PAGES.topic(contentTypePath.topicPart, shortId);
+            }
+
+            return PAGES[contentTypePath.type](shortId);
+        })();
+
+        const previewContentPage: PreviewContentPage = {
+            content:
+                contentTypePath.type === 'topic'
+                    ? {
+                          type: 'topic',
+                          topicPart: contentTypePath.topicPart,
+                      }
+                    : { type: contentTypePath.type },
+            link,
+            title: dbContent.title,
+            description: dbContent.description ?? undefined,
+            bookTitle,
+        };
+
+        return previewContentPage;
+    },
+);

package/server/api/preview/contentUnique/[...contentTypePathUnique].ts

@@ -0,0 +1,81 @@
+import { mixSchema, uniqueName2Id, type ProseElement } from '@jsprose/core';
+import { headingSchema } from '@erudit-js/prose/elements/heading/core';
+import { detailsSchema } from '@erudit-js/prose/elements/details/core';
+
+export default defineEventHandler<Promise<PreviewContentUnique>>(
+    async (event) => {
+        // <typeOrPart>/<fullContentId>/<uniqueName>.json
+        const strContentTypePathUnique =
+            event.context.params!.contentTypePathUnique.slice(0, -5);
+        const parts = strContentTypePathUnique.split('/');
+
+        const strContentTypePath = parts.slice(0, -1).join('/');
+        const uniqueName = parts.at(-1)!;
+
+        const contentTypePath = parseContentTypePath(strContentTypePath);
+        const fullId = contentTypePath.contentId;
+        const navNode = ERUDIT.contentNav.getNodeOrThrow(fullId);
+        const shortId = navNode.shortId;
+
+        const contentTitle = await ERUDIT.repository.content.title(fullId);
+
+        const unique = await ERUDIT.repository.content.unique(
+            fullId,
+            contentTypePath.type === 'topic'
+                ? contentTypePath.topicPart
+                : 'page',
+            uniqueName,
+        );
+
+        const uniqueProse = await (async () => {
+            if (unique.prose.schemaName === headingSchema.name) {
+                return await ERUDIT.repository.content.uniqueHeading(
+                    fullId,
+                    contentTypePath.type === 'topic'
+                        ? contentTypePath.topicPart
+                        : 'page',
+                    uniqueName,
+                );
+            } else if (unique.prose.schemaName === detailsSchema.name) {
+                const mix: ProseElement<typeof mixSchema> = {
+                    __JSPROSE_element: true,
+                    schemaName: mixSchema.name,
+                    children: unique.prose.children!,
+                } as ProseElement<typeof mixSchema>;
+
+                return mix;
+            } else {
+                return unique.prose;
+            }
+        })();
+
+        const finalizedProse =
+            await ERUDIT.repository.prose.finalize(uniqueProse);
+
+        const link = (() => {
+            if (contentTypePath.type === 'topic') {
+                return PAGES.topic(
+                    contentTypePath.topicPart,
+                    shortId,
+                    uniqueName2Id(uniqueName),
+                );
+            }
+
+            return PAGES[contentTypePath.type](
+                shortId,
+                uniqueName2Id(uniqueName),
+            );
+        })();
+
+        const previewContentUnique: PreviewContentUnique = {
+            schemaName: unique.prose.schemaName,
+            elementTitle: unique.title || undefined,
+            fadeOverlay: unique.prose.schemaName === headingSchema.name,
+            contentTitle,
+            link,
+            ...finalizedProse,
+        };
+
+        return previewContentUnique;
+    },
+);

package/server/api/problemScript/[...problemScriptPath].ts

@@ -0,0 +1,92 @@
+import { resolve } from 'node:path';
+import { build, type Plugin } from 'esbuild';
+
+import { STATIC_ASSET_EXTENSIONS } from '@erudit/server/prose/transform/extensions';
+import { createGlobalContent } from '@erudit-js/core/content/global';
+
+export default defineEventHandler<Promise<string>>(async (event) => {
+    // <filepathToScriptFile>.js
+    const problemScriptPath = event.context.params!.problemScriptPath.slice(
+        0,
+        -3,
+    ); // remove .js
+
+    const buildResult = await build({
+        entryPoints: [
+            ERUDIT.config.paths.project + '/' + problemScriptPath + '.tsx',
+        ],
+        charset: 'utf8',
+        bundle: true,
+        treeShaking: true,
+        platform: 'neutral',
+        format: 'esm',
+        write: false,
+        define: {
+            $CONTRIBUTOR: '{}',
+        },
+        jsx: 'automatic',
+        plugins: [jsxRuntimePlugin, staticFilesPlugin],
+        alias: {
+            '#project': ERUDIT.config.paths.project + '/',
+            '#content': ERUDIT.config.paths.project + '/content/',
+        },
+    });
+
+    let code = buildResult.outputFiles[0].text;
+
+    // Transform $CONTENT patterns to link objects
+    code = code.replace(/\$CONTENT(\.[a-zA-Z_$][\w$]*)+/g, (match) => {
+        const path = match
+            .slice(8) // Remove '$CONTENT.'
+            .split('.')
+            .join('/');
+
+        return JSON.stringify(createGlobalContent(path));
+    });
+
+    // Insert script ID
+    code = code.replace(
+        'defineProblemScript(',
+        `defineProblemScript('__auto_generated__',`,
+    );
+
+    setHeader(event, 'Content-Type', 'text/javascript; charset=utf-8');
+    return code;
+});
+
+const jsxRuntimePlugin: Plugin = {
+    name: 'jsx-runtime',
+    setup(build) {
+        build.onResolve({ filter: /^react\/jsx-runtime$/ }, () => ({
+            path: 'jsx-runtime-shim',
+            namespace: 'jsx-runtime-shim',
+        }));
+
+        build.onLoad({ filter: /.*/, namespace: 'jsx-runtime-shim' }, () => ({
+            contents: `
+                export const jsx = globalThis.jsx;
+                export const jsxs = globalThis.jsxs;
+                export const Fragment = globalThis.Fragment;
+            `,
+            loader: 'js',
+        }));
+    },
+};
+
+const staticFilesPlugin: Plugin = {
+    name: 'static-files',
+    setup(build) {
+        build.onLoad(
+            {
+                filter: new RegExp(
+                    `\\.(${STATIC_ASSET_EXTENSIONS.join('|')})$`,
+                ),
+            },
+            async (args) => {
+                const absPath = resolve(args.path).replace(/\\/g, '/');
+                const contents = `export default ${JSON.stringify(absPath)};`;
+                return { contents, loader: 'js' };
+            },
+        );
+    },
+};