erudit 4.0.0-dev.1 → 4.0.0-dev.2

package/server/erudit/contributors/build.ts

@@ -1,50 +1,111 @@
-import { readdirSync, writeFileSync } from 'node:fs';
-import { like } from 'drizzle-orm';
+import { existsSync, readdirSync, writeFileSync } from 'node:fs';
+import { eq, like } from 'drizzle-orm';
 import { globSync } from 'glob';
 import { isRawElement, type AnySchema, type ProseElement } from '@jsprose/core';
 import {
+    contributorIdToPropertyName,
     globalContributorsObject,
     globalContributorsTypes,
     type ContributorDefinition,
 } from '@erudit-js/core/contributor';
 
-// Trigger globalThis update
 $CONTRIBUTOR;
 
+let initialBuild = true;
+
+const contributorsRoot = () => `${ERUDIT.config.paths.project}/contributors`;
+
+const contributorsTypesPath = () =>
+    `${ERUDIT.config.paths.build}/types/contributors.d.ts`;
+
 export async function buildContributors() {
-    if (!ERUDIT.config.public.project.contributors?.enabled) {
-        return;
-    }
+    if (!ERUDIT.config.public.project.contributors?.enabled) return;
 
     ERUDIT.log.debug.start('Building contributors...');
 
-    await ERUDIT.db.delete(ERUDIT.db.schema.contributors);
-    await ERUDIT.db
-        .delete(ERUDIT.db.schema.files)
-        .where(like(ERUDIT.db.schema.files.role, 'contributor:%'));
+    const isInitial = initialBuild;
+    initialBuild = false;
 
-    const contributorIds = globSync(
-        `${ERUDIT.config.paths.project}/contributors/*/`,
-        { posix: true },
-    ).map((dirPath) => dirPath.split('/').pop() as string);
+    const contributorIds = collectContributorIds(isInitial);
 
-    for (const key in $CONTRIBUTOR) {
-        delete $CONTRIBUTOR[key];
+    if (!contributorIds.size) {
+        ERUDIT.log.info(
+            isInitial
+                ? 'Skipping contributors — no contributors found.'
+                : 'Skipping contributors — nothing changed.',
+        );
+        return;
     }
 
-    Object.assign($CONTRIBUTOR, globalContributorsObject(contributorIds));
+    for (const id of contributorIds) {
+        await cleanupContributor(id);
+    }
 
-    writeFileSync(
-        `${ERUDIT.config.paths.build}/types/contributors.d.ts`,
-        globalContributorsTypes($CONTRIBUTOR),
+    const existingIds = [...contributorIds].filter((id) =>
+        existsSync(`${contributorsRoot()}/${id}`),
     );
 
-    for (const contributorId of contributorIds) {
-        await buildContributor(contributorId);
+    syncContributorGlobals(existingIds);
+
+    if (!existingIds.length) {
+        return;
+    }
+
+    for (const id of existingIds) {
+        await buildContributor(id);
     }
 
     ERUDIT.log.success(
-        `Contributors build complete! (${ERUDIT.log.stress(contributorIds.length)})`,
+        isInitial
+            ? `Contributors build complete! (${ERUDIT.log.stress(contributorIds.size)})`
+            : `Contributors updated: ${ERUDIT.log.stress(existingIds.join(', '))}`,
+    );
+}
+
+//
+//
+//
+
+function collectContributorIds(initial: boolean): Set<string> {
+    if (initial) {
+        return new Set(
+            globSync(`${contributorsRoot()}/*/`, { posix: true }).map(
+                (p) => p.split('/').at(-1)!,
+            ),
+        );
+    }
+
+    const ids = new Set<string>();
+
+    for (const file of ERUDIT.changedFiles.values()) {
+        if (!file.startsWith(`${contributorsRoot()}/`)) continue;
+        const id = file.replace(`${contributorsRoot()}/`, '').split('/')[0];
+        if (id) ids.add(id);
+    }
+
+    return ids;
+}
+
+async function cleanupContributor(contributorId: string) {
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.contributors)
+        .where(eq(ERUDIT.db.schema.contributors.contributorId, contributorId));
+
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.files)
+        .where(
+            like(ERUDIT.db.schema.files.role, `contributor:${contributorId}%`),
+        );
+
+    delete $CONTRIBUTOR[contributorIdToPropertyName(contributorId)];
+}
+
+function syncContributorGlobals(contributorIds: string[]) {
+    Object.assign($CONTRIBUTOR, globalContributorsObject(contributorIds));
+
+    writeFileSync(
+        contributorsTypesPath(),
+        globalContributorsTypes($CONTRIBUTOR),
     );
 }
 
@@ -53,59 +114,53 @@ async function buildContributor(contributorId: string) {
         `Building contributor ${ERUDIT.log.stress(contributorId)}...`,
     );
 
-    const directory = `${ERUDIT.config.paths.project}/contributors/${contributorId}`;
-    const files = readdirSync(directory);
+    const dir = `${contributorsRoot()}/${contributorId}`;
+    const files = readdirSync(dir);
 
-    const avatarExtension = files
-        .find((file) => file.startsWith('avatar.'))
-        ?.split('.')
-        .pop();
-
-    if (avatarExtension) {
+    const avatar = files.find((f) => f.startsWith('avatar.'));
+    if (avatar) {
         await ERUDIT.repository.db.pushFile(
-            `${directory}/avatar.${avatarExtension}`,
+            `${dir}/${avatar}`,
             `contributor:${contributorId}`,
         );
     }
 
-    let moduleDefault: ContributorDefinition | undefined;
+    let def: ContributorDefinition | undefined;
 
     try {
-        moduleDefault = await ERUDIT.import(`${directory}/contributor`);
-    } catch (error) {
-        if (!String(error).includes('Cannot find module')) {
-            ERUDIT.log.error(
-                `Failed to load contributor ${ERUDIT.log.stress(contributorId)} module:\n`,
-            );
-            console.log(error);
+        def = await ERUDIT.import(`${dir}/contributor`);
+    } catch (err) {
+        if (!String(err).includes('Cannot find module')) {
+            ERUDIT.log.error(`Failed to load contributor ${contributorId}:`);
+            console.error(err);
         }
     }
 
     let description: ProseElement<AnySchema> | undefined;
 
-    if (isRawElement(moduleDefault?.description)) {
-        const resolveResult = await ERUDIT.repository.prose.resolve(
-            moduleDefault.description,
+    if (isRawElement(def?.description)) {
+        const resolved = await ERUDIT.repository.prose.resolve(
+            def.description,
             false,
         );
 
-        for (const file of resolveResult.files) {
+        for (const file of resolved.files) {
             await ERUDIT.repository.db.pushFile(
                 file,
                 `contributor:${contributorId}`,
             );
         }
 
-        description = resolveResult.proseElement;
+        description = resolved.proseElement;
     }
 
     await ERUDIT.db.insert(ERUDIT.db.schema.contributors).values({
         contributorId,
-        avatarExtension,
-        displayName: moduleDefault?.displayName,
-        short: moduleDefault?.short,
-        links: moduleDefault?.links,
-        editor: moduleDefault?.editor,
-        description: description,
+        avatarExtension: avatar?.split('.').pop(),
+        displayName: def?.displayName,
+        short: def?.short,
+        links: def?.links,
+        editor: def?.editor,
+        description,
     });
 }

package/server/erudit/db/repository/pushFile.ts

@@ -16,8 +16,11 @@ export async function pushFile(filepath: string, role: string): Promise<void> {
         '',
     );
 
-    await ERUDIT.db.insert(ERUDIT.db.schema.files).values({
-        path: relativePath,
-        role,
-    });
+    await ERUDIT.db
+        .insert(ERUDIT.db.schema.files)
+        .values({
+            path: relativePath,
+            role,
+        })
+        .onConflictDoNothing();
 }

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

@@ -1,7 +1,7 @@
 import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
 import type { ContentFlags } from '@erudit-js/core/content/flags';
 import type { ContentType } from '@erudit-js/core/content/type';
-import type { ContentExternal } from '@erudit-js/core/content/externals';
+import type { ContentExternalItem } from '@erudit-js/core/content/externals';
 import type { ContentSeo } from '@erudit-js/core/content/seo';
 
 export const content = sqliteTable('content', {
@@ -13,6 +13,6 @@ export const content = sqliteTable('content', {
     hidden: integer({ mode: 'boolean' }).notNull(),
     flags: text({ mode: 'json' }).$type<ContentFlags>(),
     decorationExtension: text(),
-    externals: text({ mode: 'json' }).$type<ContentExternal[]>(),
+    externals: text({ mode: 'json' }).$type<ContentExternalItem[]>(),
     seo: text({ mode: 'json' }).$type<ContentSeo>(),
 });

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

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

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

@@ -97,6 +97,8 @@ const en: LanguagePhrases = {
         `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!',

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

@@ -98,6 +98,8 @@ const ru: LanguagePhrases = {
         `Конспект темы «${contentTitle}»: ключевые определения, теоремы, свойства и примеры их использвания. Все самое важное и в кратком виде!`,
     practice_seo_description: (contentTitle: string) =>
         `Разнообразные задачи с подсказками и ответами по теме «${contentTitle}». Интересные условия, подсказки и подробные решения. Превратите знания в навык!`,
+    externals_own: 'Собственные',
+    externals_from: 'Из',
 
     default_index_title: 'Erudit',
     default_index_short: 'Современные цифровые учебники!',

package/server/erudit/news/build.ts

@@ -1,3 +1,4 @@
+import { existsSync } from 'node:fs';
 import { inArray } from 'drizzle-orm';
 import { globSync } from 'glob';
 import type { AnySchema, RawElement } from '@jsprose/core';
@@ -6,72 +7,108 @@ import { resolveEruditProse } from '../prose/repository/resolve';
 
 let initialBuild = true;
 
+const newsRoot = () => `${ERUDIT.config.paths.project}/news`;
+
 export async function buildNews() {
     ERUDIT.log.debug.start('Building news...');
 
-    const newsFilenames = new Set<string>();
-
-    if (initialBuild) {
-        initialBuild = false;
-        globSync(`[0-9][0-9][0-9][0-9].[0-9][0-9].[0-9][0-9].tsx`, {
-            posix: true,
-            cwd: ERUDIT.config.paths.project + '/news',
-        }).forEach((filePath) => newsFilenames.add(filePath));
-    } else {
-        for (const changedFile of ERUDIT.changedFiles.values()) {
-            if (
-                changedFile.startsWith(ERUDIT.config.paths.project + '/news/')
-            ) {
-                const relativePath = changedFile.replace(
-                    ERUDIT.config.paths.project + '/news/',
-                    '',
-                );
-
-                if (relativePath.match(/^[0-9]{4}\.[0-9]{2}\.[0-9]{2}\.tsx$/)) {
-                    newsFilenames.add(relativePath);
-                }
-            }
-        }
+    const isInitial = initialBuild;
+    initialBuild = false;
+
+    const newsFilenames = collectNewsFilenames(isInitial);
 
-        await ERUDIT.db.delete(ERUDIT.db.schema.news).where(
-            inArray(
-                ERUDIT.db.schema.news.date,
-                Array.from(newsFilenames).map((filename) =>
-                    filename.replace('.tsx', ''),
-                ),
-            ),
+    if (!newsFilenames.size) {
+        ERUDIT.log.info(
+            isInitial
+                ? 'Skipping news — no news found.'
+                : 'Skipping news — nothing changed.',
         );
+        return;
     }
 
     for (const filename of newsFilenames) {
+        await cleanupNews(filename);
+    }
+
+    const existingFilenames = [...newsFilenames].filter((filename) =>
+        existsSync(`${newsRoot()}/${filename}`),
+    );
+
+    if (!existingFilenames.length) {
+        return;
+    }
+
+    for (const filename of existingFilenames) {
         await buildNewsItem(filename);
     }
+
+    ERUDIT.log.success(
+        isInitial
+            ? `News build complete! (${ERUDIT.log.stress(newsFilenames.size)})`
+            : `News updated: ${ERUDIT.log.stress(existingFilenames.join(', '))}`,
+    );
 }
 
-export async function buildNewsItem(filename: string) {
+//
+//
+//
+
+function collectNewsFilenames(initial: boolean): Set<string> {
+    if (initial) {
+        return new Set(
+            globSync(`[0-9][0-9][0-9][0-9].[0-9][0-9].[0-9][0-9].tsx`, {
+                posix: true,
+                cwd: newsRoot(),
+            }),
+        );
+    }
+
+    const filenames = new Set<string>();
+
+    for (const file of ERUDIT.changedFiles.values()) {
+        if (!file.startsWith(`${newsRoot()}/`)) continue;
+        const relativePath = file.replace(`${newsRoot()}/`, '');
+
+        if (relativePath.match(/^[0-9]{4}\.[0-9]{2}\.[0-9]{2}\.tsx$/)) {
+            filenames.add(relativePath);
+        }
+    }
+
+    return filenames;
+}
+
+async function cleanupNews(filename: string) {
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.news)
+        .where(
+            inArray(ERUDIT.db.schema.news.date, [filename.replace('.tsx', '')]),
+        );
+}
+
+async function buildNewsItem(filename: string) {
     ERUDIT.log.debug.start(
         `Building news item ${ERUDIT.log.stress(filename)}...`,
     );
 
-    try {
-        const newsModule = await ERUDIT.import<{
-            default: RawElement<AnySchema>;
-        }>(`${ERUDIT.config.paths.project}/news/${filename}`);
+    let newsModule: { default: RawElement<AnySchema> } | undefined;
 
-        const resolvedProse = await resolveEruditProse(
-            newsModule.default,
-            false,
-        );
+    try {
+        newsModule = await ERUDIT.import(`${newsRoot()}/${filename}`);
+    } catch (err) {
+        ERUDIT.log.error(`Failed to load news item ${filename}:`);
+        console.error(err);
+        return;
+    }
 
-        await ERUDIT.db.insert(ERUDIT.db.schema.news).values({
-            date: filename.replace('.tsx', ''),
-            prose: resolvedProse.proseElement,
-        });
-    } catch (error) {
-        ERUDIT.log.error(
-            `Failed to build news item ${ERUDIT.log.stress(filename)}!\n` +
-                String(error),
-        );
+    if (!newsModule?.default) {
+        ERUDIT.log.error(`No default export in news item ${filename}`);
         return;
     }
+
+    const resolvedProse = await resolveEruditProse(newsModule.default, false);
+
+    await ERUDIT.db.insert(ERUDIT.db.schema.news).values({
+        date: filename.replace('.tsx', ''),
+        prose: resolvedProse.proseElement,
+    });
 }

package/server/erudit/sponsors/build.ts

@@ -1,7 +1,11 @@
-import { readdirSync, readFileSync } from 'node:fs';
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
 import { eq } from 'drizzle-orm';
 import type { Sponsor, SponsorConfig } from '@erudit-js/core/sponsor';
 
+let initialBuild = true;
+
+const sponsorsRoot = () => `${ERUDIT.config.paths.project}/sponsors`;
+
 export async function buildSponsors() {
     if (!ERUDIT.config.public.project.sponsors?.enabled) {
         return;
@@ -9,43 +13,90 @@ export async function buildSponsors() {
 
     ERUDIT.log.debug.start('Building sponsors...');
 
-    await ERUDIT.db.delete(ERUDIT.db.schema.sponsors);
-    await ERUDIT.db
-        .delete(ERUDIT.db.schema.files)
-        .where(eq(ERUDIT.db.schema.files.role, 'sponsor-avatar'));
-
-    let sponsorIds: string[] = [];
+    const isInitial = initialBuild;
+    initialBuild = false;
 
-    try {
-        sponsorIds = readdirSync(ERUDIT.config.paths.project + '/sponsors', {
-            withFileTypes: true,
-        })
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => entry.name);
-    } catch {}
+    const sponsorIds = collectSponsorIds(isInitial);
 
-    let sponsorCount = 0;
+    if (!sponsorIds.size) {
+        ERUDIT.log.info(
+            isInitial
+                ? 'Skipping sponsors — no sponsors found.'
+                : 'Skipping sponsors — nothing changed.',
+        );
+        return;
+    }
 
     for (const sponsorId of sponsorIds) {
+        await cleanupSponsor(sponsorId);
+    }
+
+    const existingIds = [...sponsorIds].filter((id) =>
+        existsSync(`${sponsorsRoot()}/${id}`),
+    );
+
+    if (!existingIds.length) {
+        return;
+    }
+
+    for (const sponsorId of existingIds) {
         await buildSponsor(sponsorId);
-        sponsorCount++;
     }
 
     ERUDIT.log.success(
-        `Sponsors build complete! (${ERUDIT.log.stress(sponsorCount)})`,
+        isInitial
+            ? `Sponsors build complete! (${ERUDIT.log.stress(sponsorIds.size)})`
+            : `Sponsors updated: ${ERUDIT.log.stress(existingIds.join(', '))}`,
     );
 }
 
+//
+//
+//
+
+function collectSponsorIds(initial: boolean): Set<string> {
+    if (initial) {
+        try {
+            return new Set(
+                readdirSync(sponsorsRoot(), { 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(`${sponsorsRoot()}/`)) continue;
+        const id = file.replace(`${sponsorsRoot()}/`, '').split('/')[0];
+        if (id) ids.add(id);
+    }
+
+    return ids;
+}
+
+async function cleanupSponsor(sponsorId: string) {
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.sponsors)
+        .where(eq(ERUDIT.db.schema.sponsors.sponsorId, sponsorId));
+
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.files)
+        .where(eq(ERUDIT.db.schema.files.role, 'sponsor-avatar'));
+}
+
 async function buildSponsor(sponsorId: string) {
     ERUDIT.log.debug.start(
         `Building sponsor ${ERUDIT.log.stress(sponsorId)}...`,
     );
 
-    const sponsorDirectory =
-        ERUDIT.config.paths.project + '/sponsors/' + sponsorId;
-    const sponsorFiles = readdirSync(sponsorDirectory);
+    const dir = `${sponsorsRoot()}/${sponsorId}`;
+    const files = readdirSync(dir);
 
-    const hasConfig = sponsorFiles.some(
+    const hasConfig = files.some(
         (file) => file === 'sponsor.ts' || file === 'sponsor.js',
     );
 
@@ -60,7 +111,7 @@ async function buildSponsor(sponsorId: string) {
 
     try {
         sponsorConfig = (await ERUDIT.import(
-            `${sponsorDirectory}/sponsor`,
+            `${dir}/sponsor`,
         )) as SponsorConfig;
     } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -70,14 +121,14 @@ async function buildSponsor(sponsorId: string) {
         return;
     }
 
-    const avatarExtension = sponsorFiles
+    const avatarExtension = files
         .find((file) => file.startsWith('avatar.'))
         ?.split('.')
         .pop();
 
     if (avatarExtension) {
         await ERUDIT.repository.db.pushFile(
-            `${sponsorDirectory}/avatar.${avatarExtension}`,
+            `${dir}/avatar.${avatarExtension}`,
             'sponsor-avatar',
         );
     }
@@ -87,9 +138,9 @@ async function buildSponsor(sponsorId: string) {
             return sponsorConfig.icon;
         }
 
-        const iconFile = sponsorFiles.find((file) => file === 'icon.svg');
+        const iconFile = files.find((file) => file === 'icon.svg');
         if (iconFile) {
-            return readFileSync(sponsorDirectory + '/' + iconFile, 'utf-8');
+            return readFileSync(dir + '/' + iconFile, 'utf-8');
         }
     })();
 

package/shared/types/contentConnections.ts

@@ -1,4 +1,4 @@
-import type { ContentExternal } from '@erudit-js/core/content/externals';
+import type { ContentExternals } from '@erudit-js/core/content/externals';
 import type { ContentType } from '@erudit-js/core/content/type';
 
 interface BaseContentDep {
@@ -23,5 +23,5 @@ export interface ContentConnections {
     hardDependencies?: ContentHardDep[];
     autoDependencies?: ContentAutoDep[];
     dependents?: ContentAutoDep[];
-    externals?: ContentExternal[];
+    externals?: ContentExternals;
 }

package/shared/types/elementSnippet.ts

@@ -1,8 +1,14 @@
 export interface ElementSnippet {
     schemaName: string;
-    title: string;
     link: string;
-    quick?: boolean;
-    seo?: boolean;
+    title: string;
     description?: string;
+    quick?: {
+        title?: string;
+        description?: string;
+    };
+    seo?: {
+        title?: string;
+        description?: string;
+    };
 }

package/shared/types/language.ts

@@ -93,6 +93,8 @@ export type LanguagePhrases = Phrases<{
     article_seo_description: (contentTitle: string) => string;
     summary_seo_description: (contentTitle: string) => string;
     practice_seo_description: (contentTitle: string) => string;
+    externals_own: string;
+    externals_from: string;
 
     default_index_title: string;
     default_index_short: string;