erudit 3.0.0-dev.22 → 3.0.0-dev.25

package/server/erudit/build.ts

@@ -0,0 +1,135 @@
+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 === 'generate') {
+        // Generate is single pass so no watching
+        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,111 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { eq } from 'drizzle-orm';
+import type { Cameo, CameoConfig } from '@erudit-js/core/cameo';
+
+export async function buildCameos() {
+    ERUDIT.log.debug.start('Building cameos...');
+
+    await ERUDIT.db.delete(ERUDIT.db.schema.cameos);
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.files)
+        .where(eq(ERUDIT.db.schema.files.role, 'cameo-avatar'));
+
+    let cameoIds: string[] = [];
+
+    try {
+        cameoIds = readdirSync(ERUDIT.config.paths.project + '/cameos', {
+            withFileTypes: true,
+        })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    } catch {}
+
+    let cameoCount = 0;
+
+    for (const cameoId of cameoIds) {
+        await buildCameo(cameoId);
+        cameoCount++;
+    }
+
+    ERUDIT.log.success(
+        `Cameos build complete! (${ERUDIT.log.stress(cameoCount)})`,
+    );
+}
+
+async function buildCameo(cameoId: string) {
+    ERUDIT.log.debug.start(`Building cameo ${ERUDIT.log.stress(cameoId)}...`);
+
+    const cameoDirectory = ERUDIT.config.paths.project + '/cameos/' + cameoId;
+    const cameoFiles = readdirSync(cameoDirectory);
+
+    const hasConfig = cameoFiles.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(
+            `${cameoDirectory}/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 = cameoFiles
+        .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(
+        `${cameoDirectory}/avatar.${avatarExtension}`,
+        'cameo-avatar',
+    );
+
+    const icon = (() => {
+        const iconFile = cameoFiles.find((file) => file === 'icon.svg');
+        if (iconFile) {
+            return readFileSync(cameoDirectory + '/' + 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,11 @@
+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,271 @@
+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;
+
+export async function buildGlobalContent() {
+    ERUDIT.log.debug.start('Building global content...');
+
+    const linkObject = await buildLinkObject();
+
+    const linkTypes = linkObjectToTypes(linkObject);
+    writeFileSync(
+        ERUDIT.config.paths.build + '/types/content.d.ts',
+        linkTypes,
+        'utf-8',
+    );
+
+    ERUDIT.log.success('Global content built successfully!');
+}
+
+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;