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

package/server/api/quote/data/[quoteId].ts

@@ -0,0 +1,87 @@
+import { eq } from 'drizzle-orm';
+import {
+    parseQuoteId,
+    type CameoQuote,
+    type Quote,
+    type SponsorQuote,
+} from '@erudit-js/core/quote';
+
+export default defineEventHandler<Promise<Quote>>(async (event) => {
+    const quoteId = event.context.params?.quoteId;
+
+    if (!quoteId) {
+        throw createError({
+            statusCode: 400,
+            message: 'Quote ID is required!',
+        });
+    }
+
+    const { type, id } = parseQuoteId(quoteId);
+
+    if (type === 'cameo') {
+        const dbCameo = await ERUDIT.db.query.cameos.findFirst({
+            columns: { data: true },
+            where: eq(ERUDIT.db.schema.cameos.cameoId, id),
+        });
+
+        if (!dbCameo) {
+            throw createError({
+                statusCode: 404,
+                message: `Failed to find cameo with ID "${id}"!`,
+            });
+        }
+
+        const data = dbCameo.data;
+
+        const quote: CameoQuote = {
+            type: 'cameo',
+            name: data.name,
+            messages: data.messages,
+            icon: data.icon,
+            color: data.color,
+            link: data.link,
+            avatarUrl: `/file/cameos/${id}/avatar.${data.avatarExtension}`,
+        };
+
+        return quote;
+    } else if (type === 'sponsor') {
+        const dbSponsor = await ERUDIT.db.query.sponsors.findFirst({
+            columns: { data: true },
+            where: eq(ERUDIT.db.schema.sponsors.sponsorId, id),
+        });
+
+        if (!dbSponsor) {
+            throw createError({
+                statusCode: 404,
+                message: `Failed to find cameo with ID "${id}"!`,
+            });
+        }
+
+        const data = dbSponsor.data;
+
+        const quote: SponsorQuote = {
+            type: 'sponsor',
+            name: data.name ?? id,
+            color: data.color,
+            icon: data.icon,
+            link: data.link,
+            avatarUrl: ERUDIT.repository.sponsors.avatarUrl(
+                id,
+                data.avatarExtension,
+            ),
+        };
+
+        if (data.messages?.enabled === true) {
+            if (data.messages.list) {
+                quote.messages = data.messages.list;
+            }
+        }
+
+        return quote;
+    }
+
+    throw createError({
+        statusCode: 400,
+        message: `Unable to resolve quote ID "${quoteId}"!`,
+    });
+});

package/server/api/quote/ids.ts

@@ -0,0 +1,3 @@
+export default defineEventHandler(async () => {
+    return await ERUDIT.repository.quotes.ids();
+});

package/server/erudit/build.ts

@@ -0,0 +1,137 @@
+import chalk from 'chalk';
+import chokidar from 'chokidar';
+import { debounce } from 'perfect-debounce';
+import slash from 'slash';
+
+// Builders
+import { buildContributors } from './contributors/build';
+import { buildSponsors } from './sponsors/build';
+import { buildCameos } from './cameos/build';
+import { buildContentNav } from './content/nav/build';
+import { requestFullContentResolve, resolveContent } from './content/resolve';
+import { buildGlobalContent } from './content/global/build';
+import { buildNews } from './news/build';
+
+export type EruditServerChangedFiles = Set<string>;
+export type EruditServerBuildError = Error | undefined;
+
+export async function buildServerErudit() {
+    ERUDIT.buildPromise = (async () => {
+        ERUDIT.buildError = undefined;
+
+        try {
+            ERUDIT.log.start('Building...');
+            await buildContributors();
+            await buildSponsors();
+            await buildCameos();
+            await buildNews();
+            await buildContentNav();
+            await buildGlobalContent();
+            await resolveContent();
+            ERUDIT.log.success(chalk.green('Build Complete!'));
+        } catch (buildError) {
+            requestFullContentResolve();
+
+            if (buildError instanceof Error) {
+                ERUDIT.buildError = buildError;
+                if (buildError.stack) {
+                    ERUDIT.log.error(buildError.stack);
+                }
+            } else {
+                ERUDIT.buildError = createError({
+                    statusCode: 500,
+                    statusMessage: 'Unknown Erudit Build Error!',
+                    message:
+                        typeof buildError === 'string'
+                            ? buildError
+                            : 'An unknown error occurred!',
+                });
+                ERUDIT.log.error(ERUDIT.buildError.message);
+            }
+        }
+    })();
+
+    await ERUDIT.buildPromise;
+}
+
+//
+// Watcher
+//
+
+export async function tryServerWatchProject() {
+    if (
+        ERUDIT.config.public.mode !== 'write' &&
+        ERUDIT.config.public.mode !== 'dev'
+    ) {
+        return;
+    }
+
+    let pendingRebuild = false;
+    ERUDIT.changedFiles = new Set<string>();
+
+    const tryRebuildErudit = debounce(async () => {
+        pendingRebuild = true;
+        try {
+            await ERUDIT.buildPromise;
+            const files = Array.from(ERUDIT.changedFiles);
+            console.log();
+            ERUDIT.log.warn(
+                `${chalk.yellow('Rebuilding due to file change(s):')}\n\n` +
+                    files
+                        .map((p, i) => chalk.gray(`${i + 1} -`) + ` "${p}"`)
+                        .join('\n'),
+            );
+            console.log();
+            await buildServerErudit();
+            ERUDIT.changedFiles.clear();
+        } finally {
+            ERUDIT.changedFiles.clear();
+            pendingRebuild = false;
+        }
+    }, 300);
+
+    function isWatched(path: string) {
+        if (path.startsWith(ERUDIT.config.paths.project + '/content/')) {
+            return true;
+        }
+
+        if (path.startsWith(ERUDIT.config.paths.project + '/contributors/')) {
+            return true;
+        }
+
+        if (path.startsWith(ERUDIT.config.paths.project + '/cameos/')) {
+            return true;
+        }
+
+        if (path.startsWith(ERUDIT.config.paths.project + '/sponsors/')) {
+            return true;
+        }
+
+        if (path.startsWith(ERUDIT.config.paths.project + '/news/')) {
+            return true;
+        }
+    }
+
+    const watcher = chokidar.watch(ERUDIT.config.paths.project, {
+        ignoreInitial: true,
+    });
+
+    watcher.on('all', (_, path) => {
+        path = slash(path);
+
+        if (!isWatched(path)) {
+            return;
+        }
+
+        if (pendingRebuild) {
+            return;
+        }
+
+        if (path.trim()) {
+            ERUDIT.changedFiles.add(String(path));
+            tryRebuildErudit();
+        }
+    });
+
+    ERUDIT.log.success('Server project watcher is active 👀');
+}

package/server/erudit/cameos/build.ts

@@ -0,0 +1,161 @@
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { eq } from 'drizzle-orm';
+import type { Cameo, CameoConfig } from '@erudit-js/core/cameo';
+
+let initialBuild = true;
+
+const cameosRoot = () => `${ERUDIT.config.paths.project}/cameos`;
+
+export async function buildCameos() {
+    ERUDIT.log.debug.start('Building cameos...');
+
+    const isInitial = initialBuild;
+    initialBuild = false;
+
+    const cameoIds = collectCameoIds(isInitial);
+
+    if (!cameoIds.size) {
+        ERUDIT.log.info(
+            isInitial
+                ? 'Skipping cameos — no cameos found.'
+                : 'Skipping cameos — nothing changed.',
+        );
+        return;
+    }
+
+    for (const cameoId of cameoIds) {
+        await cleanupCameo(cameoId);
+    }
+
+    const existingIds = [...cameoIds].filter((id) =>
+        existsSync(`${cameosRoot()}/${id}`),
+    );
+
+    if (!existingIds.length) {
+        return;
+    }
+
+    for (const cameoId of existingIds) {
+        await buildCameo(cameoId);
+    }
+
+    ERUDIT.log.success(
+        isInitial
+            ? `Cameos build complete! (${ERUDIT.log.stress(cameoIds.size)})`
+            : `Cameos updated: ${ERUDIT.log.stress(existingIds.join(', '))}`,
+    );
+}
+
+//
+//
+//
+
+function collectCameoIds(initial: boolean): Set<string> {
+    if (initial) {
+        try {
+            return new Set(
+                readdirSync(cameosRoot(), { withFileTypes: true })
+                    .filter((entry) => entry.isDirectory())
+                    .map((entry) => entry.name),
+            );
+        } catch {
+            return new Set();
+        }
+    }
+
+    const ids = new Set<string>();
+
+    for (const file of ERUDIT.changedFiles.values()) {
+        if (!file.startsWith(`${cameosRoot()}/`)) continue;
+        const id = file.replace(`${cameosRoot()}/`, '').split('/')[0];
+        if (id) ids.add(id);
+    }
+
+    return ids;
+}
+
+async function cleanupCameo(cameoId: string) {
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.cameos)
+        .where(eq(ERUDIT.db.schema.cameos.cameoId, cameoId));
+
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.files)
+        .where(eq(ERUDIT.db.schema.files.role, 'cameo-avatar'));
+}
+
+async function buildCameo(cameoId: string) {
+    ERUDIT.log.debug.start(`Building cameo ${ERUDIT.log.stress(cameoId)}...`);
+
+    const dir = `${cameosRoot()}/${cameoId}`;
+    const files = readdirSync(dir);
+
+    const hasConfig = files.some(
+        (file) => file === 'cameo.ts' || file === 'cameo.js',
+    );
+
+    if (!hasConfig) {
+        ERUDIT.log.error(
+            `No config file found for cameo ${ERUDIT.log.stress(cameoId)}!`,
+        );
+        return;
+    }
+
+    let cameoConfig: CameoConfig;
+
+    try {
+        cameoConfig = (await ERUDIT.import(`${dir}/cameo`)) as CameoConfig;
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ERUDIT.log.error(
+            `Failed to load config for cameo ${ERUDIT.log.stress(cameoId)}: ${message}`,
+        );
+        return;
+    }
+
+    const avatarExtension = files
+        .find((file) => file.startsWith('avatar.'))
+        ?.split('.')
+        .pop();
+
+    if (!avatarExtension) {
+        ERUDIT.log.error(
+            `No avatar file found for cameo ${ERUDIT.log.stress(cameoId)}!`,
+        );
+        return;
+    }
+
+    await ERUDIT.repository.db.pushFile(
+        `${dir}/avatar.${avatarExtension}`,
+        'cameo-avatar',
+    );
+
+    const icon = (() => {
+        const iconFile = files.find((file) => file === 'icon.svg');
+        if (iconFile) {
+            return readFileSync(dir + '/' + iconFile, 'utf-8');
+        }
+    })();
+
+    if (!icon) {
+        ERUDIT.log.error(
+            `No icon file found for cameo ${ERUDIT.log.stress(cameoId)}!`,
+        );
+        return;
+    }
+
+    const cameo: Cameo = {
+        cameoId,
+        name: cameoConfig.name,
+        icon,
+        avatarExtension,
+        color: cameoConfig.color,
+        link: cameoConfig.link,
+        messages: cameoConfig.messages,
+    };
+
+    await ERUDIT.db.insert(ERUDIT.db.schema.cameos).values({
+        cameoId: cameoId,
+        data: cameo,
+    });
+}

package/server/erudit/config.ts

@@ -0,0 +1,13 @@
+export type EruditServerConfig = EruditRuntimeConfig & {
+    public: EruditPublicRuntimeConfig;
+};
+
+export async function setupServerRuntimeConfig() {
+    const runtimeConfig = useRuntimeConfig();
+    ERUDIT.config = {
+        ...runtimeConfig.erudit,
+        public: {
+            ...runtimeConfig.public.erudit,
+        },
+    } as EruditServerConfig;
+}

package/server/erudit/content/global/build.ts

@@ -0,0 +1,297 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { topicParts, type TopicPart } from '@erudit-js/core/content/topic';
+import { $CONTENT } from './singleton';
+
+// Call singleton to trigger initialization
+$CONTENT;
+
+let initialBuild = true;
+
+const contentRoot = () => `${ERUDIT.config.paths.project}/content`;
+
+export async function buildGlobalContent() {
+    ERUDIT.log.debug.start('Building global content...');
+
+    const isInitial = initialBuild;
+    initialBuild = false;
+
+    if (!isInitial && !hasContentChanges()) {
+        ERUDIT.log.info('Skipping global content — nothing changed.');
+        return;
+    }
+
+    const linkObject = await buildLinkObject();
+
+    const linkTypes = linkObjectToTypes(linkObject);
+    writeFileSync(
+        ERUDIT.config.paths.build + '/types/content.d.ts',
+        linkTypes,
+        'utf-8',
+    );
+
+    ERUDIT.log.success(
+        isInitial
+            ? 'Global content build complete!'
+            : 'Global content updated!',
+    );
+}
+
+function hasContentChanges() {
+    for (const file of (ERUDIT.changedFiles || new Set<string>()).values()) {
+        if (file.startsWith(`${contentRoot()}/`)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+function linkObjectToTypes(linkObject: any): string {
+    const indent = (level: number) => '    '.repeat(level);
+
+    function toCamelCase(str: string): string {
+        return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase());
+    }
+
+    function processObject(obj: any, level: number): string {
+        const lines: string[] = [];
+
+        for (const [key, value] of Object.entries(obj) as [string, any][]) {
+            if (key === '__jsdoc' || key === '__typeguard') continue;
+
+            const camelKey = toCamelCase(key);
+
+            // Add JSDoc comment if present
+            if (value && typeof value === 'object' && value.__jsdoc) {
+                const jsdocLines = value.__jsdoc.split('\n');
+                jsdocLines.forEach((line: string) => {
+                    lines.push(indent(level) + line);
+                });
+            }
+
+            // Determine if value has nested properties (excluding __jsdoc and __typeguard)
+            const hasNestedProps =
+                value &&
+                typeof value === 'object' &&
+                Object.keys(value).some(
+                    (k) => k !== '__jsdoc' && k !== '__typeguard',
+                );
+
+            // Get the typeguard from the object, default to GlobalContentItemTypeguard
+            const typeguard =
+                value?.__typeguard || 'GlobalContentItemTypeguard';
+
+            if (hasNestedProps) {
+                lines.push(indent(level) + `${camelKey}: ${typeguard} & {`);
+                lines.push(processObject(value, level + 1));
+                lines.push(indent(level) + `}`);
+            } else {
+                lines.push(indent(level) + `${camelKey}: ${typeguard} & {}`);
+            }
+        }
+
+        return lines.join('\n');
+    }
+
+    const body = processObject(linkObject, 2);
+
+    return `import type {
+    GlobalContentItemTypeguard,
+    GlobalContentTopicPartTypeguard,
+    GlobalContentUniqueTypeguard,
+} from '@erudit-js/core/content/global';
+
+export {};
+
+declare global {
+    const $CONTENT: {
+${body}
+    }
+}`;
+}
+
+/**
+ * Loop through the content navigation tree and build a nested object representing the link structure:
+ */
+async function buildLinkObject() {
+    const linkTree: any = {};
+
+    await ERUDIT.contentNav.walk((navItem) => {
+        // Navigate to the correct position in the tree based on the full path
+        let cursor = linkTree;
+        const pathParts = navItem.fullId.split('/');
+
+        // Navigate through parent parts
+        for (let i = 0; i < pathParts.length - 1; i++) {
+            cursor = cursor[pathParts[i]];
+        }
+
+        //
+        //
+        //
+
+        if (navItem.type === 'page') {
+            const pathToFile = `${ERUDIT.config.paths.project}/content/${navItem.contentRelPath}/${navItem.type}.tsx`;
+            const moduleContent = readFileSync(pathToFile, 'utf-8');
+            const title = tryGetTitle(moduleContent);
+
+            const jsdoc = jsdocLines([
+                title ? `Title: ${title}` : undefined,
+                `Type: ${navItem.type}`,
+                `Location: [${navItem.contentRelPath}](file:///${pathToFile})`,
+            ]);
+
+            cursor[navItem.idPart] = {
+                __typeguard: 'GlobalContentItemTypeguard',
+                __jsdoc: `
+/**
+${jsdoc}
+ */
+                `.trim(),
+                ...tryGetUniquesObject(
+                    moduleContent,
+                    pathToFile,
+                    navItem.contentRelPath,
+                ),
+            };
+        } else if (navItem.type === 'topic') {
+            const pathToTopicFile = `${ERUDIT.config.paths.project}/content/${navItem.contentRelPath}/topic.ts`;
+            const topicModuleContent = readFileSync(pathToTopicFile, 'utf-8');
+            const title = tryGetTitle(topicModuleContent);
+
+            const jsdoc = jsdocLines([
+                title ? `Title: ${title}` : undefined,
+                `Type: topic`,
+                `Location: [${navItem.contentRelPath}](file:///${pathToTopicFile})`,
+            ]);
+
+            cursor[navItem.idPart] = {
+                __typeguard: 'GlobalContentItemTypeguard',
+                __jsdoc: `
+/**
+${jsdoc}
+ */
+                `.trim(),
+            };
+
+            for (const part of topicParts) {
+                try {
+                    const pathToFile = `${ERUDIT.config.paths.project}/content/${navItem.contentRelPath}/${part}.tsx`;
+                    const partContent = readFileSync(pathToFile, 'utf-8');
+
+                    const jsdoc = jsdocLines([
+                        title ? `Title: ${title}` : undefined,
+                        `Type: topic`,
+                        `Part: ${part}`,
+                        `Location: [${navItem.contentRelPath}](file:///${pathToFile})`,
+                    ]);
+
+                    cursor[navItem.idPart][part as TopicPart] = {
+                        __typeguard: 'GlobalContentTopicPartTypeguard',
+                        __jsdoc: `
+/**
+${jsdoc}
+ */
+                        `.trim(),
+                        ...tryGetUniquesObject(
+                            partContent,
+                            pathToFile,
+                            navItem.contentRelPath,
+                        ),
+                    };
+                } catch {}
+            }
+        } else {
+            const pathToFile = `${ERUDIT.config.paths.project}/content/${navItem.contentRelPath}/${navItem.type}.ts`;
+            const moduleContent = readFileSync(pathToFile, 'utf-8');
+            const title = tryGetTitle(moduleContent);
+
+            const jsdoc = jsdocLines([
+                title ? `Title: ${title}` : undefined,
+                `Type: ${navItem.type}`,
+                `Location: [${navItem.contentRelPath}](file:///${pathToFile})`,
+            ]);
+
+            cursor[navItem.idPart] = {
+                __typeguard: 'GlobalContentItemTypeguard',
+                __jsdoc: `
+/**
+${jsdoc}
+ */
+                `.trim(),
+            };
+        }
+    });
+
+    return linkTree;
+}
+
+function tryGetTitle(moduleContent: string) {
+    const titleMatch = moduleContent.match(/title:\s*['"`](.*?)['"`]/);
+
+    if (titleMatch) {
+        return titleMatch[1].trim();
+    }
+}
+
+function jsdocLines(lines: any[]) {
+    return lines
+        .filter(Boolean)
+        .map((line) => ` * * ${line}`)
+        .join('\n');
+}
+
+function tryGetUniquesObject(
+    moduleContent: string,
+    pathToFile: string,
+    pathInContent: string,
+) {
+    // Match uniques: { ... } object (single or multiline)
+    const uniquesMatch = moduleContent.match(/uniques:\s*\{([^}]*)\}/s);
+
+    if (!uniquesMatch) {
+        return {};
+    }
+
+    const uniquesContent = uniquesMatch[1];
+
+    // Parse key-value pairs from uniques object
+    const lines = uniquesContent.split('\n');
+    const result: any = {};
+
+    for (const line of lines) {
+        // Skip commented out lines
+        if (line.trim().startsWith('//')) {
+            continue;
+        }
+
+        // Skip uniques starting with underscore
+        if (line.trim().startsWith('_')) {
+            continue;
+        }
+
+        const pairMatch = line.match(/(\w+):\s*(\w+)/);
+        if (!pairMatch) {
+            continue;
+        }
+
+        const [, uniqueName, tagName] = pairMatch;
+
+        const jsdoc = jsdocLines([
+            'Unique',
+            `Tag: \`<${tagName}>\``,
+            `Location: [${pathInContent}](file:///${pathToFile})`,
+        ]);
+
+        result[`$${uniqueName}`] = {
+            __typeguard: 'GlobalContentUniqueTypeguard',
+            __jsdoc: `
+/**
+${jsdoc}
+ */
+            `.trim(),
+        };
+    }
+
+    return result;
+}

package/server/erudit/content/global/singleton.ts

@@ -0,0 +1,5 @@
+import { createGlobalContentProxy } from '@erudit-js/core/content/global';
+
+export const $CONTENT = createGlobalContentProxy();
+
+(globalThis as any).$CONTENT = $CONTENT;