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

package/server/erudit/db/schema/contentContributions.ts

@@ -0,0 +1,15 @@
+import { primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+
+export const contentContributions = sqliteTable(
+    'contentContributions',
+    {
+        contentFullId: text().notNull(),
+        contributorId: text().notNull(),
+        description: text(),
+    },
+    (table) => [
+        primaryKey({
+            columns: [table.contentFullId, table.contributorId],
+        }),
+    ],
+);

package/server/erudit/db/schema/contentDeps.ts

@@ -0,0 +1,21 @@
+import {
+    integer,
+    primaryKey,
+    sqliteTable,
+    text,
+} from 'drizzle-orm/sqlite-core';
+
+export const contentDeps = sqliteTable(
+    'contentDeps',
+    {
+        fromFullId: text().notNull(),
+        toFullId: text().notNull(),
+        hard: integer({ mode: 'boolean' }).notNull(),
+        reason: text(),
+    },
+    (table) => [
+        primaryKey({
+            columns: [table.fromFullId, table.toFullId],
+        }),
+    ],
+);

package/server/erudit/db/schema/contentElementStats.ts

@@ -0,0 +1,20 @@
+import {
+    integer,
+    sqliteTable,
+    text,
+    primaryKey,
+} from 'drizzle-orm/sqlite-core';
+
+export const contentElementStats = sqliteTable(
+    'contentElementStats',
+    {
+        fullId: text().notNull(),
+        schemaName: text().notNull(),
+        count: integer().notNull(),
+    },
+    (table) => [
+        primaryKey({
+            columns: [table.fullId, table.schemaName],
+        }),
+    ],
+);

package/server/erudit/db/schema/contentProseLinks.ts

@@ -0,0 +1,23 @@
+import { sqliteTable, primaryKey, text } from 'drizzle-orm/sqlite-core';
+import { type ProseLink } from '@erudit-js/core/prose/link';
+import { type ContentProseType } from '@erudit-js/core/content/prose';
+
+export const contentProseLinks = sqliteTable(
+    'contentProseLinks',
+    {
+        fromContentId: text().notNull(),
+        fromContentProseType: text().notNull().$type<ContentProseType>(),
+        proseLink: text({ mode: 'json' }).notNull().$type<ProseLink>(),
+        toContentId: text(),
+        toContentProseType: text().$type<ContentProseType>(),
+    },
+    (table) => [
+        primaryKey({
+            columns: [
+                table.fromContentId,
+                table.fromContentProseType,
+                table.proseLink,
+            ],
+        }),
+    ],
+);

package/server/erudit/db/schema/contentSnippets.ts

@@ -0,0 +1,32 @@
+import {
+    integer,
+    primaryKey,
+    sqliteTable,
+    text,
+} from 'drizzle-orm/sqlite-core';
+import type { ContentProseType } from '@erudit-js/core/content/prose';
+
+export const contentSnippets = sqliteTable(
+    'contentSnippets',
+    {
+        contentFullId: text().notNull(),
+        contentProseType: text().notNull().$type<ContentProseType>(),
+        title: text().notNull(),
+        description: text(),
+        elementId: text().notNull(),
+        schemaName: text().notNull(),
+        search: integer({ mode: 'boolean' }).notNull(),
+        searchSynonyms: text({ mode: 'json' }).$type<string[]>(),
+        quick: integer({ mode: 'boolean' }).notNull(),
+        seo: integer({ mode: 'boolean' }).notNull(),
+    },
+    (table) => [
+        primaryKey({
+            columns: [
+                table.contentFullId,
+                table.contentProseType,
+                table.elementId,
+            ],
+        }),
+    ],
+);

package/server/erudit/db/schema/contentToc.ts

@@ -0,0 +1,16 @@
+import { primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { ResolvedTocItem } from '@erudit-js/prose';
+
+export const contentToc = sqliteTable(
+    'contentToc',
+    {
+        fullId: text().notNull(),
+        topicPart: text(),
+        toc: text({ mode: 'json' }).notNull().$type<ResolvedTocItem[]>(),
+    },
+    (table) => [
+        primaryKey({
+            columns: [table.fullId, table.topicPart],
+        }),
+    ],
+);

package/server/erudit/db/schema/contentUniques.ts

@@ -0,0 +1,25 @@
+import { primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { AnySchema, ProseElement } from '@jsprose/core';
+import type { ContentProseType } from '@erudit-js/core/content/prose';
+
+export const contentUniques = sqliteTable(
+    'contentUniques',
+    {
+        contentFullId: text().notNull(),
+        contentProseType: text().notNull().$type<ContentProseType>(),
+        uniqueName: text().notNull(),
+        title: text(),
+        prose: text({ mode: 'json' })
+            .$type<ProseElement<AnySchema>>()
+            .notNull(),
+    },
+    (table) => [
+        primaryKey({
+            columns: [
+                table.contentFullId,
+                table.uniqueName,
+                table.contentProseType,
+            ],
+        }),
+    ],
+);

package/server/erudit/db/schema/contributors.ts

@@ -0,0 +1,12 @@
+import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { AnySchema, ProseElement } from '@jsprose/core';
+
+export const contributors = sqliteTable('contributors', {
+    contributorId: text().primaryKey(),
+    displayName: text(),
+    short: text(),
+    avatarExtension: text(),
+    editor: integer({ mode: 'boolean' }),
+    links: text({ mode: 'json' }).$type<Record<string, string>>(),
+    description: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
+});

package/server/erudit/db/schema/files.ts

@@ -0,0 +1,11 @@
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { primaryKey } from 'drizzle-orm/sqlite-core';
+
+export const files = sqliteTable(
+    'files',
+    {
+        path: text(),
+        role: text(),
+    },
+    (table) => [primaryKey({ columns: [table.path, table.role] })],
+);

package/server/erudit/db/schema/groups.ts

@@ -0,0 +1,6 @@
+import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+
+export const groups = sqliteTable('groups', {
+    fullId: text().primaryKey(),
+    separator: integer({ mode: 'boolean' }).notNull(),
+});

package/server/erudit/db/schema/index.ts

@@ -0,0 +1,17 @@
+export { content } from './content';
+export { contributors } from './contributors';
+export { topics } from './topics';
+export { contentUniques } from './contentUniques';
+export { pages } from './pages';
+export { groups } from './groups';
+export { contentSnippets } from './contentSnippets';
+export { files } from './files';
+export { contentProseLinks } from './contentProseLinks';
+export { problemScripts } from './problemScripts';
+export { contentElementStats } from './contentElementStats';
+export { contentDeps } from './contentDeps';
+export { contentContributions } from './contentContributions';
+export { contentToc } from './contentToc';
+export { cameos } from './cameos';
+export { sponsors } from './sponsors';
+export { news } from './news';

package/server/erudit/db/schema/news.ts

@@ -0,0 +1,7 @@
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { AnySchema, ProseElement } from '@jsprose/core';
+
+export const news = sqliteTable('news', {
+    date: text().primaryKey(),
+    prose: text({ mode: 'json' }).$type<ProseElement<AnySchema>>().notNull(),
+});

package/server/erudit/db/schema/pages.ts

@@ -0,0 +1,7 @@
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { AnySchema, ProseElement } from '@jsprose/core';
+
+export const pages = sqliteTable('pages', {
+    fullId: text().primaryKey(),
+    prose: text({ mode: 'json' }).$type<ProseElement<AnySchema>>().notNull(),
+});

package/server/erudit/db/schema/problemScripts.ts

@@ -0,0 +1,14 @@
+import { primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+
+export const problemScripts = sqliteTable(
+    'problemScripts',
+    {
+        problemScriptSrc: text(),
+        contentFullId: text(),
+    },
+    (table) => [
+        primaryKey({
+            columns: [table.problemScriptSrc, table.contentFullId],
+        }),
+    ],
+);

package/server/erudit/db/schema/sponsors.ts

@@ -0,0 +1,9 @@
+import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { Sponsor } from '@erudit-js/core/sponsor';
+
+export const sponsors = sqliteTable('sponsors', {
+    sponsorId: text().primaryKey(),
+    hasMessages: integer({ mode: 'boolean' }).notNull(),
+    avatarExtension: text(),
+    data: text({ mode: 'json' }).notNull().$type<Sponsor>(),
+});

package/server/erudit/db/schema/topics.ts

@@ -0,0 +1,9 @@
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { AnySchema, ProseElement } from '@jsprose/core';
+
+export const topics = sqliteTable('topics', {
+    fullId: text().primaryKey(),
+    article: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
+    summary: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
+    practice: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
+});

package/server/erudit/db/setup.ts

@@ -0,0 +1,62 @@
+import { createRequire } from 'node:module';
+import { readdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import Database from 'better-sqlite3';
+
+import * as schema from './schema';
+
+export async function setupServerDatabase() {
+    const buildDir = ERUDIT.config.paths.build;
+    const nowTs = Date.now();
+    const dbFilename = `erudit-${nowTs}.db`;
+    const dbPath = join(buildDir, dbFilename);
+
+    try {
+        for (const f of readdirSync(buildDir)) {
+            const m = f.match(/^erudit-(\d+)\.db$/);
+            if (m && Number(m[1]) < nowTs) {
+                try {
+                    unlinkSync(join(buildDir, f));
+                } catch {}
+            }
+        }
+    } catch {}
+
+    const connection = new Database(dbPath);
+
+    const db = drizzle(connection, { schema });
+
+    ERUDIT.db = new Proxy(db, {
+        get(target, prop, receiver) {
+            if (prop === 'connection') {
+                return connection;
+            }
+
+            if (prop === 'schema') {
+                return schema;
+            }
+
+            if (prop === 'path') {
+                return dbPath;
+            }
+
+            return Reflect.get(target, prop, receiver);
+        },
+    }) as any;
+
+    const require = createRequire(import.meta.url);
+    const { generateSQLiteMigration, generateSQLiteDrizzleJson } =
+        require('drizzle-kit/api') as typeof import('drizzle-kit/api');
+
+    const migration = await generateSQLiteMigration(
+        await generateSQLiteDrizzleJson({}),
+        await generateSQLiteDrizzleJson(schema, undefined, 'camelCase'),
+    );
+
+    for (const query of migration) {
+        await ERUDIT.db.run(query);
+    }
+
+    ERUDIT.log.success('Database connection setup complete!');
+}

package/server/erudit/db/types.ts

@@ -0,0 +1,10 @@
+import { LibSQLDatabase } from 'drizzle-orm/libsql';
+import type { Database } from 'better-sqlite3';
+
+import type * as schema from './schema';
+
+export type EruditServerDatabase = LibSQLDatabase<typeof schema> & {
+    path: string;
+    connection: Database;
+    schema: typeof schema;
+};

package/server/erudit/global.ts

@@ -0,0 +1,33 @@
+import type { EruditServerBuildError, EruditServerChangedFiles } from './build';
+import type { EruditServerConfig } from './config';
+import type { EruditServerContentNav } from './content/nav/types';
+import type { EruditServerDatabase } from './db/types';
+import type { EruditServerImporter } from './importer';
+import type { EruditServerLanguage } from './language/types';
+import type { EruditServerLogger } from './logger';
+import type { EruditServerRepository } from './repository';
+
+export const ERUDIT: {
+    buildError: EruditServerBuildError;
+    buildPromise: Promise<void>;
+    changedFiles: EruditServerChangedFiles;
+    config: EruditServerConfig;
+    log: EruditServerLogger;
+    language: EruditServerLanguage;
+    db: EruditServerDatabase;
+    repository: EruditServerRepository;
+    contentNav: EruditServerContentNav;
+    import: EruditServerImporter;
+} = {} as any;
+
+Object.assign(globalThis, {
+    defineContributor,
+    defineSponsor,
+    defineCameo,
+    defineBook,
+    defineTopic,
+    definePage,
+    defineGroup,
+    defineProse,
+    Include,
+});

package/server/erudit/importer.ts

@@ -0,0 +1,97 @@
+import { createJiti, type Jiti, type JitiOptions } from 'jiti';
+import slash from 'slash';
+import { insertDocumentId } from '@jsprose/core';
+import {
+    pathToDocumentId,
+    stringifyDocumentId,
+} from '@erudit-js/core/prose/documentId';
+import { insertProblemScriptId } from '@erudit-js/prose/elements/problem/problemScript';
+
+import {
+    EXTENSIONS,
+    STATIC_ASSET_EXTENSIONS,
+} from './prose/transform/extensions';
+
+export type EruditServerImporter = Jiti['import'];
+
+export let jiti: Jiti;
+
+export async function setupServerImporter() {
+    const jitiId = ERUDIT.config.paths.project;
+    const defaultJiti = createJiti(jitiId, createBaseJitiOptions());
+    const getDefaultCode = defaultJiti.transform.bind(defaultJiti);
+
+    jiti = createJiti(ERUDIT.config.paths.project, {
+        ...createBaseJitiOptions(),
+        extensions: EXTENSIONS.map((ext) => '.' + ext),
+        transform: (opts) => {
+            if (!opts.filename) {
+                return { code: getDefaultCode(opts) };
+            }
+
+            const filename = slash(opts.filename).replace('file://', '');
+
+            const staticAssetModule = tryStaticAssetModule(filename);
+            if (staticAssetModule) {
+                return staticAssetModule;
+            }
+
+            let code = getDefaultCode(opts);
+
+            //
+            // Insert IDs in `defineDocument(...)` calls
+            //
+
+            const documentId = pathToDocumentId(
+                filename,
+                ERUDIT.config.paths.project,
+            );
+
+            if (documentId) {
+                code = insertDocumentId({
+                    code,
+                    documentId: stringifyDocumentId(documentId),
+                    aliasName: 'defineProse',
+                });
+            }
+
+            //
+            // Problem Scripts
+            //
+
+            code = insertProblemScriptId(filename, code);
+
+            return { code };
+        },
+    });
+
+    ERUDIT.import = jiti.import;
+
+    ERUDIT.log.success('Importer setup complete!');
+}
+
+function createBaseJitiOptions(): JitiOptions {
+    return {
+        fsCache: false,
+        moduleCache: false,
+        alias: {
+            '#project/': ERUDIT.config.paths.project + '/',
+            '#content/': ERUDIT.config.paths.project + '/content/',
+        },
+        jsx: {
+            runtime: 'automatic',
+            importSource: '@jsprose/core',
+        },
+    };
+}
+
+function tryStaticAssetModule(filename: unknown) {
+    if (
+        typeof filename === 'string' &&
+        STATIC_ASSET_EXTENSIONS.some((ext) => filename.endsWith('.' + ext))
+    ) {
+        return {
+            code: `exports.default = "${filename}";`,
+        };
+    }
+}

package/server/erudit/index.ts

@@ -0,0 +1,90 @@
+import chalk from 'chalk';
+
+import { setupServerLogger } from './logger';
+import { setupServerRuntimeConfig } from './config';
+import { setupServerLanguage } from './language/setup';
+import { setupServerDatabase } from './db/setup';
+import { setupServerImporter } from './importer';
+import { setupServerRepository } from './repository';
+import { setupServerContentNav } from './content/nav/setup';
+import { buildServerErudit, tryServerWatchProject } from './build';
+
+let serverSetupPromise: Promise<void>;
+
+export default defineNitroPlugin((nitro) => {
+    serverSetupPromise = setupServer();
+
+    nitro.hooks.hook('request', async (event) => {
+        await serverSetupPromise;
+        await ERUDIT.buildPromise;
+
+        if (ERUDIT.buildError) {
+            const accept = getHeader(event, 'accept') || '';
+            if (accept.includes('text/html')) {
+                function escapeHtml(str: string) {
+                    return str
+                        .replace(/&/g, '&amp;')
+                        .replace(/</g, '&lt;')
+                        .replace(/>/g, '&gt;')
+                        .replace(/"/g, '&quot;')
+                        .replace(/'/g, '&#39;');
+                }
+
+                event.node.res.end(`
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="UTF-8">
+        <title>Erudit Build Error</title>
+        <style>
+        :root {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen;
+        }
+        </style>
+    </head>
+    <body>
+    <h1>Erudit Build Error</h1>
+    <pre style="padding: 1em; border-radius: 4px; overflow-x: auto;">
+${escapeHtml(ERUDIT.buildError.stack || '')}
+    </pre>
+    </body>
+</html>
+  `);
+            }
+        }
+    });
+
+    nitro.hooks.hook('close', async () => {});
+});
+
+async function setupServer() {
+    try {
+        const { registerProseGlobals } = await import('#erudit/prose/global');
+        registerProseGlobals();
+
+        await setupServerRuntimeConfig();
+        await setupServerLogger();
+        await setupServerImporter();
+        await setupServerLanguage();
+        await setupServerDatabase();
+        await setupServerRepository();
+        await setupServerContentNav();
+        ERUDIT.log.success(chalk.green('Setup Complete!'));
+
+        await tryServerWatchProject();
+        await buildServerErudit();
+    } catch (buildError) {
+        if (buildError instanceof Error) {
+            ERUDIT.buildError = buildError;
+        } else {
+            ERUDIT.buildError = createError({
+                statusCode: 500,
+                statusMessage: 'Unknown Erudit Server Error',
+                message:
+                    typeof buildError === 'string'
+                        ? buildError
+                        : 'An unknown error occurred!',
+            });
+        }
+    }
+}