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

package/server/plugin/build/jobs/content/generic.ts

@@ -1,176 +1,176 @@
-import { existsSync } from 'node:fs';
-import { globSync } from 'glob';
-import chalk from 'chalk';
-import sizeOf from 'image-size';
-import {
-    contentTypes,
-    type ContentConfig,
-    type ContentReferences,
-    type ContentType,
-} from 'erudit-cog/schema';
-import { resolvePaths } from 'erudit-cog/kit';
-
-import { PROJECT_DIR } from '#erudit/globalPaths';
-import { stress } from '@erudit/utils/stress';
-
-import { debug, logger } from '@server/logger';
-import { ERUDIT_SERVER } from '@server/global';
-import { walkNav } from '@server/nav/utils';
-import { isRootNode, type NavNode } from '@server/nav/node';
-import { DbContent } from '@server/db/entities/Content';
-import { IMPORT } from '@server/importer';
-import { contributorExists } from '@server/repository/contributor';
-import { DbContribution } from '@server/db/entities/Contribution';
-
-import { contentAsset } from '@erudit/shared/asset';
-import type { ImageData } from '@erudit/shared/image';
-
-import type { BuilderFunctionArgs } from './builderArgs';
-import { contentItemPath } from './path';
-import { buildBook } from './type/book';
-import { buildGroup } from './type/group';
-import { buildTopic } from './type/topic';
-
-const typeBuilders: Record<ContentType, Function> = {
-    book: buildBook,
-    group: buildGroup,
-    topic: buildTopic,
-};
-
-export async function buildContent() {
-    if (!ERUDIT_SERVER.NAV) return;
-
-    debug.start('Building content...');
-
-    const counters: Record<ContentType, number> = Object.fromEntries(
-        contentTypes.map((contentType) => [contentType, 0]),
-    ) as any;
-
-    await walkNav(async (node) => {
-        if (isRootNode(node)) return;
-        counters[node.type]++;
-        await addContentItem(node);
-    });
-
-    logger.success(
-        'Content built successfully!',
-        chalk.dim(
-            '(' +
-                Object.entries(counters)
-                    .map(([k, v]) => `${k.at(0)!.toUpperCase()}: ${v}`)
-                    .join(', ') +
-                ')',
-        ),
-    );
-}
-
-async function addContentItem(navNode: NavNode) {
-    debug.start(
-        `Adding ${stress(navNode.type)} content item ${stress(navNode.id)}...`,
-    );
-
-    const dbContent = new DbContent();
-    dbContent.contentId = navNode.id;
-    dbContent.fullId = navNode.fullId;
-    dbContent.type = navNode.type;
-    dbContent.decoration = getDecoration(navNode);
-    dbContent.ogImage = getOgImageData(navNode);
-    dbContent.references = await getContentReferences(navNode);
-
-    let config: Partial<ContentConfig> | undefined;
-
-    try {
-        config = (await IMPORT(contentItemPath(navNode, navNode.type), {
-            default: true,
-        })) as Partial<ContentConfig>;
-
-        dbContent.title = config.title;
-        dbContent.navTitle = config.navTitle;
-        dbContent.description = config.description;
-        dbContent.flags = config.flags;
-        dbContent.dependencies = config.dependencies;
-
-        if (config.seo) {
-            dbContent.seo = {
-                title: config.seo?.title,
-                description: config.seo?.description,
-            };
-        }
-
-        await addContributions(navNode, config.contributors);
-    } catch {}
-
-    await ERUDIT_SERVER.DB.manager.save(dbContent);
-
-    await typeBuilders[navNode.type](<BuilderFunctionArgs>{
-        navNode,
-        dbContent,
-        config,
-    });
-}
-
-function getDecoration(navNode: NavNode) {
-    if (existsSync(contentItemPath(navNode, 'decoration.svg')))
-        return `/${navNode.path}/decoration.svg`;
-
-    return undefined;
-}
-
-async function addContributions(navNode: NavNode, contributors?: string[]) {
-    if (!contributors || !contributors.length) {
-        if (navNode.type !== 'book' && navNode.type !== 'group')
-            logger.warn(
-                `${navNode.type.at(0)!.toUpperCase() + navNode.type.slice(1)} ${stress(navNode.id)} has no contributors!`,
-            );
-
-        return;
-    }
-
-    for (const contributorId of contributors) {
-        if (!(await contributorExists(contributorId))) {
-            logger.warn(
-                `Skipping unknown contributor ${stress(contributorId)} when adding ${navNode.type} ${stress(navNode.id)}!`,
-            );
-            continue;
-        }
-
-        const dbContribution = new DbContribution();
-        dbContribution.contentId = navNode.id;
-        dbContribution.contributorId = contributorId;
-        await ERUDIT_SERVER.DB.manager.save(dbContribution);
-    }
-}
-
-function getOgImageData(navNode: NavNode): ImageData | undefined {
-    const ogImagePath = globSync(
-        contentItemPath(navNode, 'og-image.{svg,webp,jpg,png}'),
-    ).pop();
-
-    if (ogImagePath) {
-        const size = sizeOf(ogImagePath);
-        return {
-            src: contentAsset(
-                resolvePaths(ogImagePath).replace(
-                    PROJECT_DIR + '/content/',
-                    '',
-                ),
-            ),
-            width: size.width!,
-            height: size.height!,
-        };
-    }
-
-    return undefined;
-}
-
-async function getContentReferences(navNode: NavNode) {
-    try {
-        const references = await IMPORT(
-            contentItemPath(navNode, `references`),
-            { default: true },
-        );
-        return references as ContentReferences;
-    } catch (error) {}
-
-    return undefined;
-}
+import { existsSync } from 'node:fs';
+import { globSync } from 'glob';
+import chalk from 'chalk';
+import sizeOf from 'image-size';
+import {
+    contentTypes,
+    type ContentConfig,
+    type ContentReferences,
+    type ContentType,
+} from 'erudit-cog/schema';
+import { resolvePaths } from 'erudit-cog/kit';
+
+import { PROJECT_DIR } from '#erudit/globalPaths';
+import { stress } from '@erudit/utils/stress';
+
+import { debug, logger } from '@server/logger';
+import { ERUDIT_SERVER } from '@server/global';
+import { walkNav } from '@server/nav/utils';
+import { isRootNode, type NavNode } from '@server/nav/node';
+import { DbContent } from '@server/db/entities/Content';
+import { IMPORT } from '@server/importer';
+import { contributorExists } from '@server/repository/contributor';
+import { DbContribution } from '@server/db/entities/Contribution';
+
+import { contentAsset } from '@erudit/shared/asset';
+import type { ImageData } from '@erudit/shared/image';
+
+import type { BuilderFunctionArgs } from './builderArgs';
+import { contentItemPath } from './path';
+import { buildBook } from './type/book';
+import { buildGroup } from './type/group';
+import { buildTopic } from './type/topic';
+
+const typeBuilders: Record<ContentType, Function> = {
+    book: buildBook,
+    group: buildGroup,
+    topic: buildTopic,
+};
+
+export async function buildContent() {
+    if (!ERUDIT_SERVER.NAV) return;
+
+    debug.start('Building content...');
+
+    const counters: Record<ContentType, number> = Object.fromEntries(
+        contentTypes.map((contentType) => [contentType, 0]),
+    ) as any;
+
+    await walkNav(async (node) => {
+        if (isRootNode(node)) return;
+        counters[node.type]++;
+        await addContentItem(node);
+    });
+
+    logger.success(
+        'Content built successfully!',
+        chalk.dim(
+            '(' +
+                Object.entries(counters)
+                    .map(([k, v]) => `${k.at(0)!.toUpperCase()}: ${v}`)
+                    .join(', ') +
+                ')',
+        ),
+    );
+}
+
+async function addContentItem(navNode: NavNode) {
+    debug.start(
+        `Adding ${stress(navNode.type)} content item ${stress(navNode.id)}...`,
+    );
+
+    const dbContent = new DbContent();
+    dbContent.contentId = navNode.id;
+    dbContent.fullId = navNode.fullId;
+    dbContent.type = navNode.type;
+    dbContent.decoration = getDecoration(navNode);
+    dbContent.ogImage = getOgImageData(navNode);
+    dbContent.references = await getContentReferences(navNode);
+
+    let config: Partial<ContentConfig> | undefined;
+
+    try {
+        config = (await IMPORT(contentItemPath(navNode, navNode.type), {
+            default: true,
+        })) as Partial<ContentConfig>;
+
+        dbContent.title = config.title;
+        dbContent.navTitle = config.navTitle;
+        dbContent.description = config.description;
+        dbContent.flags = config.flags;
+        dbContent.dependencies = config.dependencies;
+
+        if (config.seo) {
+            dbContent.seo = {
+                title: config.seo?.title,
+                description: config.seo?.description,
+            };
+        }
+
+        await addContributions(navNode, config.contributors);
+    } catch {}
+
+    await ERUDIT_SERVER.DB.manager.save(dbContent);
+
+    await typeBuilders[navNode.type](<BuilderFunctionArgs>{
+        navNode,
+        dbContent,
+        config,
+    });
+}
+
+function getDecoration(navNode: NavNode) {
+    if (existsSync(contentItemPath(navNode, 'decoration.svg')))
+        return `/${navNode.path}/decoration.svg`;
+
+    return undefined;
+}
+
+async function addContributions(navNode: NavNode, contributors?: string[]) {
+    if (!contributors || !contributors.length) {
+        if (navNode.type !== 'book' && navNode.type !== 'group')
+            logger.warn(
+                `${navNode.type.at(0)!.toUpperCase() + navNode.type.slice(1)} ${stress(navNode.id)} has no contributors!`,
+            );
+
+        return;
+    }
+
+    for (const contributorId of contributors) {
+        if (!(await contributorExists(contributorId))) {
+            logger.warn(
+                `Skipping unknown contributor ${stress(contributorId)} when adding ${navNode.type} ${stress(navNode.id)}!`,
+            );
+            continue;
+        }
+
+        const dbContribution = new DbContribution();
+        dbContribution.contentId = navNode.id;
+        dbContribution.contributorId = contributorId;
+        await ERUDIT_SERVER.DB.manager.save(dbContribution);
+    }
+}
+
+function getOgImageData(navNode: NavNode): ImageData | undefined {
+    const ogImagePath = globSync(
+        contentItemPath(navNode, 'og-image.{svg,webp,jpg,png}'),
+    ).pop();
+
+    if (ogImagePath) {
+        const size = sizeOf(ogImagePath);
+        return {
+            src: contentAsset(
+                resolvePaths(ogImagePath).replace(
+                    PROJECT_DIR + '/content/',
+                    '',
+                ),
+            ),
+            width: size.width!,
+            height: size.height!,
+        };
+    }
+
+    return undefined;
+}
+
+async function getContentReferences(navNode: NavNode) {
+    try {
+        const references = await IMPORT(
+            contentItemPath(navNode, `references`),
+            { default: true },
+        );
+        return references as ContentReferences;
+    } catch (error) {}
+
+    return undefined;
+}

package/server/plugin/build/jobs/content/parse.ts

@@ -1,100 +1,100 @@
-import { ElementNode, walkForward } from '@bitran-js/core';
-import { type BitranTranspiler } from '@bitran-js/transpiler';
-import {
-    AliasesNode,
-    mergeAliases,
-    NO_ALIASES,
-} from '@erudit-js/bitran-elements/aliases/shared';
-import { HeadingNode } from '@erudit-js/bitran-elements/heading/shared';
-
-import { createBitranTranspiler } from '@server/bitran/transpiler';
-import { ERUDIT_SERVER } from '@server/global';
-import { DbUnique } from '@server/db/entities/Unique';
-
-import type { BitranContext } from '@shared/bitran/context';
-import {
-    stringifyBitranLocation,
-    type BitranLocation,
-} from '@shared/bitran/location';
-
-let context: BitranContext = {} as any;
-let bitranTranspiler: BitranTranspiler;
-
-const blocksAfterHeading = 2;
-
-export async function parseBitranContent(
-    location: BitranLocation,
-    biCode: string,
-) {
-    // Reset Bitran context in order not to create core each time
-    context.location = location;
-    context.aliases = NO_ALIASES();
-
-    bitranTranspiler ||= await createBitranTranspiler();
-
-    // Tracking heading nodes to deal with them later
-    const headings: HeadingNode[] = [];
-
-    await bitranTranspiler.parser.parse(biCode, {
-        async step(node) {
-            const meta = node.meta;
-            const uniqueId = meta?.id;
-
-            if (node instanceof AliasesNode) {
-                mergeAliases(context.aliases, node.parseData);
-            }
-
-            if (uniqueId) {
-                if (node instanceof HeadingNode) {
-                    headings.push(node);
-                    return;
-                }
-
-                await addUnique(node);
-            }
-        },
-    });
-
-    for (const heading of headings) {
-        let blocksAfter = 0;
-        let content = await bitranTranspiler.stringifier.stringify(heading);
-
-        await walkForward(heading, async (node) => {
-            if (blocksAfter >= blocksAfterHeading) return false;
-
-            if (node instanceof AliasesNode) return;
-            // Spoiler
-            // Todo
-
-            content +=
-                '\n\n' + (await bitranTranspiler.stringifier.stringify(node));
-
-            blocksAfter++;
-        });
-
-        await addUnique(heading, content);
-    }
-
-    //
-    //
-    //
-
-    function createUniqueLocation(node: ElementNode) {
-        return stringifyBitranLocation({
-            ...location,
-            ...{ unique: node.meta.id! },
-        });
-    }
-
-    async function addUnique(node: ElementNode, content?: string) {
-        const dbUnique = new DbUnique();
-        dbUnique.location = createUniqueLocation(node);
-        dbUnique.content =
-            content || (await bitranTranspiler.stringifier.stringify(node));
-        dbUnique.title = node.parseData?.title || node.meta?.title;
-        dbUnique.productName = node.name;
-        dbUnique.context = context;
-
-        await ERUDIT_SERVER.DB.manager.save(dbUnique);
-    }
-}
+import { ElementNode, walkForward } from '@bitran-js/core';
+import { type BitranTranspiler } from '@bitran-js/transpiler';
+import {
+    AliasesNode,
+    mergeAliases,
+    NO_ALIASES,
+} from '@erudit-js/bitran-elements/aliases/shared';
+import { HeadingNode } from '@erudit-js/bitran-elements/heading/shared';
+
+import { createBitranTranspiler } from '@server/bitran/transpiler';
+import { ERUDIT_SERVER } from '@server/global';
+import { DbUnique } from '@server/db/entities/Unique';
+
+import type { BitranContext } from '@shared/bitran/context';
+import {
+    stringifyBitranLocation,
+    type BitranLocation,
+} from '@shared/bitran/location';
+
+let context: BitranContext = {} as any;
+let bitranTranspiler: BitranTranspiler;
+
+const blocksAfterHeading = 2;
+
+export async function parseBitranContent(
+    location: BitranLocation,
+    biCode: string,
+) {
+    // Reset Bitran context in order not to create core each time
+    context.location = location;
+    context.aliases = NO_ALIASES();
+
+    bitranTranspiler ||= await createBitranTranspiler();
+
+    // Tracking heading nodes to deal with them later
+    const headings: HeadingNode[] = [];
+
+    await bitranTranspiler.parser.parse(biCode, {
+        async step(node) {
+            const meta = node.meta;
+            const uniqueId = meta?.id;
+
+            if (node instanceof AliasesNode) {
+                mergeAliases(context.aliases, node.parseData);
+            }
+
+            if (uniqueId) {
+                if (node instanceof HeadingNode) {
+                    headings.push(node);
+                    return;
+                }
+
+                await addUnique(node);
+            }
+        },
+    });
+
+    for (const heading of headings) {
+        let blocksAfter = 0;
+        let content = await bitranTranspiler.stringifier.stringify(heading);
+
+        await walkForward(heading, async (node) => {
+            if (blocksAfter >= blocksAfterHeading) return false;
+
+            if (node instanceof AliasesNode) return;
+            // Spoiler
+            // Todo
+
+            content +=
+                '\n\n' + (await bitranTranspiler.stringifier.stringify(node));
+
+            blocksAfter++;
+        });
+
+        await addUnique(heading, content);
+    }
+
+    //
+    //
+    //
+
+    function createUniqueLocation(node: ElementNode) {
+        return stringifyBitranLocation({
+            ...location,
+            ...{ unique: node.meta.id! },
+        });
+    }
+
+    async function addUnique(node: ElementNode, content?: string) {
+        const dbUnique = new DbUnique();
+        dbUnique.location = createUniqueLocation(node);
+        dbUnique.content =
+            content || (await bitranTranspiler.stringifier.stringify(node));
+        dbUnique.title = node.parseData?.title || node.meta?.title;
+        dbUnique.productName = node.name;
+        dbUnique.context = context;
+
+        await ERUDIT_SERVER.DB.manager.save(dbUnique);
+    }
+}

package/server/plugin/build/jobs/content/path.ts

@@ -1,6 +1,6 @@
-import { PROJECT_DIR } from '#erudit/globalPaths';
-import type { NavNode } from '@server/nav/node';
-
-export function contentItemPath(navNode: NavNode, path?: string) {
-    return PROJECT_DIR + `/content/${navNode.path}${path ? '/' + path : ''}`;
-}
+import { PROJECT_DIR } from '#erudit/globalPaths';
+import type { NavNode } from '@server/nav/node';
+
+export function contentItemPath(navNode: NavNode, path?: string) {
+    return PROJECT_DIR + `/content/${navNode.path}${path ? '/' + path : ''}`;
+}

package/server/plugin/build/jobs/content/type/book.ts

@@ -1,9 +1,9 @@
-import { DbBook } from '@server/db/entities/Book';
-import { ERUDIT_SERVER } from '@server/global';
-import type { BuilderFunctionArgs } from '../builderArgs';
-
-export async function buildBook({ dbContent }: BuilderFunctionArgs) {
-    const dbBook = new DbBook();
-    dbBook.contentId = dbContent.contentId;
-    await ERUDIT_SERVER.DB.manager.save(dbBook);
-}
+import { DbBook } from '@server/db/entities/Book';
+import { ERUDIT_SERVER } from '@server/global';
+import type { BuilderFunctionArgs } from '../builderArgs';
+
+export async function buildBook({ dbContent }: BuilderFunctionArgs) {
+    const dbBook = new DbBook();
+    dbBook.contentId = dbContent.contentId;
+    await ERUDIT_SERVER.DB.manager.save(dbBook);
+}

package/server/plugin/build/jobs/content/type/group.ts

@@ -1,37 +1,37 @@
-import { readFileSync } from 'node:fs';
-import type { GroupConfig } from 'erudit-cog/schema';
-
-import { DbGroup } from '@server/db/entities/Group';
-import { ERUDIT_SERVER } from '@erudit/server/plugin/global';
-import type { BuilderFunctionArgs } from '../builderArgs';
-import { contentItemPath } from '../path';
-import { parseBitranContent } from '../parse';
-
-export async function buildGroup({
-    navNode,
-    config,
-}: BuilderFunctionArgs<GroupConfig>) {
-    const dbGroup = new DbGroup();
-    dbGroup.contentId = navNode.id;
-    dbGroup.type = config?.type || 'folder';
-
-    try {
-        const strContent = readFileSync(
-            contentItemPath(navNode, 'content.bi'),
-            'utf-8',
-        );
-
-        if (strContent) {
-            dbGroup.content = strContent;
-            await parseBitranContent(
-                {
-                    type: 'group',
-                    path: navNode.id,
-                },
-                strContent,
-            );
-        }
-    } catch {}
-
-    await ERUDIT_SERVER.DB.manager.save(dbGroup);
-}
+import { readFileSync } from 'node:fs';
+import type { GroupConfig } from 'erudit-cog/schema';
+
+import { DbGroup } from '@server/db/entities/Group';
+import { ERUDIT_SERVER } from '@erudit/server/plugin/global';
+import type { BuilderFunctionArgs } from '../builderArgs';
+import { contentItemPath } from '../path';
+import { parseBitranContent } from '../parse';
+
+export async function buildGroup({
+    navNode,
+    config,
+}: BuilderFunctionArgs<GroupConfig>) {
+    const dbGroup = new DbGroup();
+    dbGroup.contentId = navNode.id;
+    dbGroup.type = config?.type || 'folder';
+
+    try {
+        const strContent = readFileSync(
+            contentItemPath(navNode, 'content.bi'),
+            'utf-8',
+        );
+
+        if (strContent) {
+            dbGroup.content = strContent;
+            await parseBitranContent(
+                {
+                    type: 'group',
+                    path: navNode.id,
+                },
+                strContent,
+            );
+        }
+    } catch {}
+
+    await ERUDIT_SERVER.DB.manager.save(dbGroup);
+}