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

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!',
+            });
+        }
+    }
+}

package/server/erudit/language/list/en.ts

@@ -0,0 +1,211 @@
+const en: LanguagePhrases = {
+    language_code: 'en',
+    language_name: 'English',
+    erudit: 'Erudit',
+    content_nav: 'Content navigation',
+    pages: 'Pages',
+    search: 'Search',
+    languages: 'Languages',
+    settings: 'Settings',
+    theme: 'Theme',
+    theme_light: 'Light',
+    theme_dark: 'Dark',
+    theme_system: 'System',
+    built: 'Built',
+    content: 'Content',
+    add_translation: 'Add translation',
+    main_page: 'Main page',
+    contributors: 'Contributors',
+    sponsors: 'Sponsors',
+    search_the_site: 'Search the site...',
+    searching_more: 'Searching more...',
+    no_results: 'No results found',
+    no_more_results: 'No more results',
+    no_content: 'No content.',
+    to_index: 'To index',
+    about_textbook: 'About textbook',
+    flag_title_dev: 'Development',
+    flag_hint_dev:
+        'This material is not complete, may contain error and will change in the future! Use with caution!',
+    flag_title_advanced: 'Advanced',
+    flag_hint_advanced:
+        'This material is for learners with a high level of knowledge. It contains information that is not suitable for beginners!',
+    flag_title_secondary: 'Additional',
+    flag_hint_secondary:
+        'This is an optional material is for learners who want to dive deeper and gain additional knowledge and context.',
+    ads_replacer:
+        'We help you. Help us back.<br><strong style="color: inherit;">Disable your ads blocker!</strong>',
+    direct_link: 'Direct link',
+    direct_link_explain: 'You are about to open a direct link:',
+    book: 'Textbook',
+    group: 'Category',
+    topic: 'Topic',
+    article: 'Article',
+    summary: 'Summary',
+    practice: 'Practice',
+    page: 'Page',
+    preview_content_page_description: 'You are about to open a content page:',
+    begin_learning: 'Begin Learning!',
+    flag_dev: 'Development',
+    flag_dev_description:
+        'This material is in development! It may change in the future and even contain errors!',
+    flag_advanced: 'Advanced',
+    flag_advanced_description:
+        'This material is for learners with a high level of knowledge. It contains information that is not suitable for beginners!',
+    flag_secondary: 'Additional',
+    flag_secondary_description:
+        'This is an optional material is for learners who want to dive deeper and gain additional knowledge and context.',
+    key_elements: 'Key elements',
+    stats: 'Statistics',
+    connections: 'Connections',
+    need_to_know: 'Need to know',
+    depends_on: 'Depends on',
+    used_by: 'Used by',
+    externals: 'Externals',
+    add_quote: 'Add your own message!',
+    next_quote: 'Next quote',
+    sponsors_description:
+        'List of people and organizations that support the project financially. Thanks to them, the project can exist and develop. If you want to help the project, you can become a sponsor and get on this page too!',
+    become_sponsor: 'Become a sponsor',
+    no_sponsors: 'There are no sponsors yet. You can be the first one!',
+    contributors_description:
+        'List of people who contributed to the project materials: suggested valuable ideas, made corrections to existing material or wrote their own!',
+    contributors_invite:
+        'You can also help the project, make a contribution and get on this page!',
+    contributor_page_description: (name: string) =>
+        `Personal page of contributor "${name}" with information about their contributions to the project.`,
+    become_contributor: 'Become a contributor',
+    no_contributors: 'There are no contributors yet. You can be the first one!',
+    contribution: 'Contribution',
+    no_contribution: 'No contributions yet.',
+    editor: 'Editor',
+    materials: 'Materials',
+    x_sponsors: (count: number) => m(count, 'Sponsor', 'Sponsors'),
+    x_contributors: (count: number) => m(count, 'Contributor', 'Contributors'),
+    news: 'News',
+    no_news: 'No news.',
+    show_more: 'Show more',
+    make_contribution: 'Make a contribution',
+    improve_material: 'Improve material',
+    how_to_improve: 'How to improve?',
+    report_issue: 'Report an issue',
+    edit_page: 'Edit page',
+    no_toc: 'TOC is empty.',
+    article_seo_description: (contentTitle: string) =>
+        `Clear and interesting explanation of the topic "${contentTitle}". Clear examples, important terms and statements, interesting facts, life applications.`,
+    summary_seo_description: (contentTitle: string) =>
+        `Summary of the topic "${contentTitle}": key definitions, theorems, properties and examples of their use. All the most important things in a concise form!`,
+    practice_seo_description: (contentTitle: string) =>
+        `Various problems with hints and answers on the topic "${contentTitle}". Interesting conditions, hints and detailed solutions. Turn knowledge into a skill!`,
+    externals_own: 'Own',
+    externals_from: 'From',
+
+    default_index_title: 'Erudit',
+    default_index_short: 'Modern digital textbooks!',
+    default_site_info_short: 'Modern textbook',
+
+    // _language_title: 'English',
+    // _language_code: 'en',
+    // site_info_title: 'Erudit',
+    // site_info_slogan: 'Modern textbook',
+    // seo_index_title: 'Erudit - CMS for eductional sites',
+    // seo_index_description:
+    //     'Erudit is a CMS for creating and managing perfect educational sites, maintained by the community.',
+    // seo_article_description: (contentTitle) =>
+    //     `Clear and interesting explanation of the topic "${contentTitle}". Illustrative examples, important properties, interesting facts, life applications, clear proofs. Here you will definitely understand the topic!`,
+    // seo_summary_description: (contentTitle) =>
+    //     `Summary of the topic "${contentTitle}": key definitions, theorems, properties and examples of their use. All the most important things in a concise form!`,
+    // seo_practice_description: (contentTitle) =>
+    //     `Various problems with hints and answers on the topic "${contentTitle}". Interesting conditions, hints and detailed solutions. Turn knowledge into a skill!`,
+    // index: 'Index',
+    // pages: 'Pages',
+    // search: 'Search',
+    // language: 'Language',
+    // other: 'Other',
+    // ads_replacer:
+    //     'Help us develop the project.<br><strong>Disable your ads blocker!</strong>',
+    // theme: 'Theme',
+    // theme_system: 'System',
+    // theme_light: 'Light',
+    // theme_dark: 'Dark',
+    // content: 'Content',
+    // main_page: 'Main page',
+    // contributors: 'Contributors',
+    // contributors_page_description:
+    //     'List of people who contributed to the project materials: suggested valuable ideas, made corrections to existing material or wrote their own!',
+    // contributors_page_invite:
+    //     'You can also help the project, make a contribution and get on this page!',
+    // become_contributor: 'Become a contributor',
+    // contributor: 'Contributor',
+    // contribution: 'Contribution',
+    // contributions_explain: (count) =>
+    //     `Contributed to ${m(count, 'material', 'materials')}`,
+    // contributor_description: (name) =>
+    //     `Page with information about the contributor "${name}" and his contribution to the project.`,
+    // editor: 'Editor',
+    // add_translation: 'Add translation',
+    // empty_nav: 'Empty navigation',
+
+    // popover_dependencies: 'Dependencies',
+    // popover_dependencies_description:
+    //     'There is no royal way into this topic! You can only figure it out if you know the following topics:',
+    // to_index: 'To index',
+    // about_book: 'About book',
+    // close: 'Close',
+    // back: 'Back',
+    // goto: 'Go to',
+    // error: 'Error!',
+    // external_link: 'External link',
+    // external_link_warn: 'You are going to visit external resource!',
+    // internal_link: 'Internal link',
+    // internal_link_warn: 'You are going to visit internal site page!',
+    // book: 'Textbook',
+    // group: 'Group',
+    // topic: 'Topic',
+    // topics: 'Topics',
+    // article: 'Article',
+    // summary: 'Summary',
+    // practice: 'Practice',
+    // element_id: 'Element ID',
+    // preview_missing_title: 'Element not found!',
+    // preview_missing_explain: `Can't find the element with specified ID in this page!<br>Perhaps the element ID is specified incorrectly or the element has been changed/deleted.`,
+    // preview_missing_explain_mismatch: `Can't find the element with specified ID in this page!<br>The version of the linked page is different from the current version of the page!<br>This is most likely the cause of the error.`,
+    // preview_hash_mismatch_title: 'Page version mismatch!',
+    // preview_hash_mismatch_explain:
+    //     'The version of the page you see now is different from the version of the page the original link led to!<br>The content may be different from what you expected to see.',
+    // current_page_hash: 'Current hash',
+    // expected_page_hash: 'Expected hash',
+    // empty_toc: 'Empty table of contents...',
+    // no_contributors: 'No contributors...',
+    // make_contribution: 'Make a contribution',
+    // material_improvement: 'Material improvement',
+    // how_to_improve: 'How to improve?',
+    // edit_page: 'Edit page',
+    // report_problem: 'Report a problem',
+    // references: 'References',
+    // reference_source_featured: 'Featured source',
+    // references_description:
+    //     'A list of external sources that were used to write this material. If there is an asterisk next to the title, it is a featured source and is worth reading if you want to delve deeper into the material.',
+    // sponsors: 'Sponsors',
+    // sponsors_description:
+    //     'People and organizations that support the project financially. Thanks to them, we can continue to develop the project and improve the quality of materials. If you want to support the project, you can become a sponsor too!',
+    // become_sponsor: 'Become a sponsor',
+    // toc: 'Table of contents',
+    // mentions: (count) => m(count, 'mention', 'mentions'),
+    // start_learning: 'Start learning!',
+    // x_contributors: (count) => m(count, 'Contributor', 'Contributors'),
+    // x_sponsors: (count) => m(count, 'Sponsor', 'Sponsors'),
+    // show_all: 'Show all',
+};
+
+export default en;
+
+export function m(
+    number: number,
+    one: string,
+    few: string,
+    includeNumber = true,
+) {
+    const text = number === 1 ? one : few;
+    return includeNumber ? `${number} ${text}` : text;
+}