erudit 2.0.0-dev.7

package/server/plugin/db/setup.ts

@@ -0,0 +1,34 @@
+import { DataSource } from 'typeorm';
+
+import { PROJECT_DIR } from '#erudit/globalPaths';
+import { ERUDIT_SERVER } from '@server/global';
+
+// Database Entities
+import { DbContributor } from './entities/Contributor';
+import { DbBook } from './entities/Book';
+import { DbContent } from './entities/Content';
+import { DbContribution } from './entities/Contribution';
+import { DbGroup } from './entities/Group';
+import { DbHash } from './entities/Hash';
+import { DbTopic } from './entities/Topic';
+import { DbUnique } from './entities/Unique';
+
+export async function setupDatabase() {
+    ERUDIT_SERVER.DB = new DataSource({
+        type: 'sqlite',
+        database: PROJECT_DIR + '/.erudit/data.sqlite',
+        synchronize: true,
+        entities: [
+            DbBook,
+            DbContent,
+            DbContribution,
+            DbContributor,
+            DbGroup,
+            DbHash,
+            DbTopic,
+            DbUnique,
+        ],
+    });
+
+    await ERUDIT_SERVER.DB.initialize();
+}

package/server/plugin/global.ts

@@ -0,0 +1,18 @@
+import type { DataSource } from 'typeorm';
+import type { EruditConfig } from 'erudit-cog/schema';
+
+import type { EruditPhrases } from '@shared/types/language';
+import type { NavNode, RootNavNode } from '@server/nav/node';
+import type { EruditBitranConfig } from '@erudit/globals/bitran';
+
+interface EruditServer {
+    BUILD_PROMISE: Promise<void>;
+    CONFIG: Partial<EruditConfig>;
+    LANGUAGE: { phrases: EruditPhrases; functions: Record<string, Function> };
+    DB: DataSource;
+    NAV?: RootNavNode;
+    NAV_BOOKS?: Record<string, NavNode>;
+    BITRAN_CONFIG?: Partial<EruditBitranConfig>;
+}
+
+export const ERUDIT_SERVER: EruditServer = {} as any;

package/server/plugin/importer.ts

@@ -0,0 +1,12 @@
+import { createJiti } from 'jiti';
+import { ERUDIT_DIR } from '#erudit/globalPaths';
+
+const jiti = createJiti(ERUDIT_DIR, {
+    // Enable reimporting same files during process in development mode
+    fsCache: !import.meta.dev,
+    moduleCache: !import.meta.dev,
+});
+
+export async function IMPORT(...args: Parameters<typeof jiti.import>) {
+    return jiti.import(...args) as Promise<any>;
+}

package/server/plugin/index.ts

@@ -0,0 +1,9 @@
+import { ERUDIT_SERVER } from './global';
+import { build } from './build/process';
+import { close } from './build/close';
+
+export default defineNitroPlugin((_nitro) => {
+    ERUDIT_SERVER.BUILD_PROMISE = build();
+    _nitro.hooks.hook('request', async () => await ERUDIT_SERVER.BUILD_PROMISE);
+    _nitro.hooks.hook('close', close);
+});

package/server/plugin/logger.ts

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+import { createConsola } from 'consola';
+import { brandColorTitle } from 'erudit-cog/utils/brand';
+
+import eruditConfig from '#erudit/config';
+
+// TODO: Consola has buggy behaviour when called inside Nitro
+// @see https://github.com/nitrojs/nitro/issues/3079
+
+export const logger = createConsola({
+    defaults: {
+        //tag: brandColorTitle + ' Server',
+        message: chalk.gray(`[${brandColorTitle} Server]`),
+    },
+});
+
+export const debug = createConsola({
+    defaults: {
+        //tag: brandColorTitle + ' Server Debug',
+        message: chalk.gray(`[${brandColorTitle} Server Debug]`),
+        level: eruditConfig?.debug?.log ? 3 : -999,
+    },
+});

package/server/plugin/nav/node.ts

@@ -0,0 +1,26 @@
+import type { ContentType } from 'erudit-cog/schema';
+
+export interface NavNode {
+    type: ContentType;
+    path: string;
+    id: string;
+    fullId: string;
+    skip: boolean;
+    children?: NavNode[];
+    parent?: NavNode | RootNavNode;
+}
+
+export interface RootNavNode {
+    type: '#root';
+    children?: NavNode[];
+}
+
+export function isRootNode(node: NavNode | RootNavNode) {
+    return node?.type === '#root';
+}
+
+export function createRootNode(): RootNavNode {
+    return {
+        type: '#root',
+    };
+}

package/server/plugin/nav/utils.ts

@@ -0,0 +1,129 @@
+import { ERUDIT_SERVER } from '@server/global';
+import { isRootNode, type NavNode } from '@server/nav/node';
+
+export async function walkNav(
+    step: (node: NavNode) => Promise<void | false>,
+    from: NavNode | typeof ERUDIT_SERVER.NAV = ERUDIT_SERVER.NAV,
+) {
+    if (!from) return;
+
+    const stepResult = isRootNode(from) ? true : await step(from);
+
+    if (stepResult !== false)
+        if (from.children)
+            for (const child of from.children) await walkNav(step, child);
+}
+
+//
+//
+//
+
+export function getNavBookOf(target: string | NavNode): NavNode | undefined {
+    const id = typeof target === 'string' ? target : target.id;
+
+    if (!id || !ERUDIT_SERVER.NAV_BOOKS) return undefined;
+
+    const idParts = id.split('/');
+
+    while (idParts.length > 0) {
+        const book = ERUDIT_SERVER.NAV_BOOKS[idParts.join('/')];
+
+        if (book) return book;
+
+        idParts.pop();
+    }
+
+    return undefined;
+}
+
+export async function getPreviousNextNav(contentId: string) {
+    let previousNav: NavNode | undefined, nextNav: NavNode | undefined;
+    let book: NavNode | undefined;
+    let finish = false;
+
+    await walkNav(async (navNode) => {
+        if (navNode.id === contentId) {
+            book = getNavBookOf(navNode);
+            finish = true;
+            return;
+        }
+
+        if (finish && !nextNav) {
+            nextNav = navNode;
+            return false;
+        }
+
+        if (!finish) previousNav = navNode;
+    });
+
+    if (book) {
+        //
+        // Can't lead out of current book (if givent content item is inside the book)
+        //
+
+        if (previousNav)
+            if (getNavBookOf(previousNav)?.fullId !== book.fullId)
+                previousNav = undefined;
+
+        if (nextNav)
+            if (getNavBookOf(nextNav)?.fullId !== book.fullId)
+                nextNav = undefined;
+    } else {
+        //
+        // If not inside the book and tries to lead inside a book, then force lead to book's about page
+        //
+
+        if (previousNav) previousNav = getNavBookOf(previousNav) || previousNav;
+
+        if (nextNav) nextNav = getNavBookOf(nextNav) || nextNav;
+    }
+
+    return {
+        previousNav,
+        nextNav,
+    };
+}
+
+export async function getNavNode(
+    contentId: string,
+): Promise<NavNode | undefined> {
+    let navNode: NavNode | undefined;
+
+    await walkNav(async (_navNode) => {
+        if (_navNode.id === contentId) {
+            navNode = _navNode;
+            return false;
+        }
+    });
+
+    return navNode;
+}
+
+export async function getIdsUp(contentId: string): Promise<string[]> {
+    const startNavNode = await getNavNode(contentId);
+
+    if (!startNavNode) return [];
+
+    const ids: string[] = [];
+
+    let currentNavNode: any = startNavNode;
+    while (currentNavNode?.id) {
+        ids.push(currentNavNode.id);
+        currentNavNode = currentNavNode.parent;
+    }
+
+    return ids;
+}
+
+export async function isSkipId(contentId: string) {
+    let hidden = false;
+
+    await walkNav(async (navNode) => {
+        if (navNode.id === contentId) {
+            hidden = navNode.skip;
+            return false;
+        }
+    });
+
+    return hidden;
+}

package/server/plugin/repository/book.ts

@@ -0,0 +1,21 @@
+import { ERUDIT_SERVER } from '@server/global';
+import { getNavBookOf } from '@server/nav/utils';
+import { DbContent } from '@server/db/entities/Content';
+
+export async function getContentBookFor(contentId: string) {
+    const navBook = getNavBookOf(contentId);
+
+    if (!navBook) return undefined;
+
+    const bookId = navBook.id;
+
+    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+        select: ['title'],
+        where: { contentId: bookId },
+    });
+
+    return {
+        contentId: bookId,
+        title: dbContent?.title || bookId,
+    };
+}

package/server/plugin/repository/content.ts

@@ -0,0 +1,238 @@
+import type { ContentType } from 'erudit-cog/schema';
+import { Like } from 'typeorm';
+
+import { ERUDIT_SERVER } from '@server/global';
+import { DbContent } from '@server/db/entities/Content';
+import { DbContribution } from '@server/db/entities/Contribution';
+
+import { getContentContext } from '@server/content/context';
+import type { ContentGenericData } from '@shared/content/data/base';
+import { getIdsUp, getPreviousNextNav } from '../nav/utils';
+import { createContentLink, createTopicPartLink } from '@erudit/shared/link';
+import { getTopicPart } from './topic';
+import type { PreviousNextItem } from '@erudit/shared/content/previousNext';
+import type { NavNode } from '../nav/node';
+import { toAbsoluteContentId } from '../content/absoluteId';
+
+import type { ContentContributor } from '@erudit/shared/contributor';
+import { DbContributor } from '../db/entities/Contributor';
+
+export async function getContentGenericData(
+    contentId: string,
+): Promise<ContentGenericData> {
+    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+        where: { contentId },
+    });
+
+    if (!dbContent)
+        throw createError({
+            statusCode: 404,
+            message: `Content item "${contentId}" not found!`,
+        });
+
+    const previousNext = await getPreviousNext(contentId);
+    const decoration = await getContentDecoration(contentId);
+    const flags = await getContentFlags(contentId);
+
+    const contentPage: ContentGenericData = {
+        contentId,
+        type: dbContent.type,
+        title: dbContent.title || undefined,
+        description: dbContent.description || undefined,
+        flags,
+        previousNext,
+        decoration,
+        context: await getContentContext(contentId),
+        seo: dbContent.seo,
+        ogImage: dbContent.ogImage,
+        dependencies: dbContent.dependencies
+            ? await getContentDependencies(contentId, dbContent.dependencies)
+            : undefined,
+        references: dbContent.references,
+    };
+
+    return contentPage;
+}
+
+export async function getPreviousNext(contentId: string) {
+    const { previousNav, nextNav } = await getPreviousNextNav(contentId);
+
+    async function getItemData(navNode: NavNode): Promise<PreviousNextItem> {
+        const title = await getContentTitle(navNode.id);
+
+        const link = await (async () => {
+            if (navNode.type === 'topic')
+                return createTopicPartLink(
+                    await getTopicPart(navNode.id),
+                    navNode.id,
+                );
+
+            return createContentLink(navNode.type, navNode.id);
+        })();
+
+        return {
+            title,
+            link,
+        };
+    }
+
+    return {
+        previous: previousNav ? await getItemData(previousNav) : undefined,
+        next: nextNav ? await getItemData(nextNav) : undefined,
+    };
+}
+
+export async function getContentDecoration(contentId: string) {
+    const idsUp = await getIdsUp(contentId);
+
+    for (const id of idsUp) {
+        const decoration = (
+            await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+                select: ['decoration'],
+                where: { contentId: id },
+            })
+        )?.decoration;
+
+        if (decoration) return decoration;
+    }
+
+    return undefined;
+}
+
+export async function getContentFlags(contentId: string) {
+    const idsUp = await getIdsUp(contentId);
+    const flags: any = {};
+
+    for (const id of idsUp.reverse()) {
+        const dbFlags = (
+            await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+                select: ['flags'],
+                where: { contentId: id },
+            })
+        )?.flags;
+
+        if (dbFlags)
+            for (const [flagName, flagValue] of Object.entries(dbFlags))
+                flags[flagName] = flagValue;
+    }
+
+    for (const [flagName, flagValue] of Object.entries(flags))
+        if (flagValue === false) delete flags[flagName];
+
+    return flags;
+}
+
+export async function getContentDependencies(
+    contentId: string,
+    strDependencies: string[],
+) {
+    const dependencyIds = strDependencies.map((rawDependency) =>
+        toAbsoluteContentId(rawDependency, contentId),
+    );
+    const dependencies: Record<string, string> = {};
+
+    for (const dependencyId of dependencyIds)
+        dependencies[await getContentLink(dependencyId)] =
+            await getContentTitle(dependencyId);
+
+    return dependencies;
+}
+
+export async function getContentTitle(contentId: string) {
+    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+        select: ['title'],
+        where: { contentId },
+    });
+
+    return dbContent?.title || contentId.split('/').pop()!;
+}
+
+export async function getContentLink(contentId: string) {
+    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+        select: ['type'],
+        where: { contentId },
+    });
+
+    if (!dbContent)
+        throw createError({
+            statusCode: 404,
+            statusText: `Missing "${contentId}" content item!`,
+        });
+
+    if (dbContent.type !== 'topic')
+        return createContentLink(dbContent.type, contentId);
+
+    const topicPart = await getTopicPart(contentId);
+
+    return createTopicPartLink(topicPart, contentId);
+}
+
+export async function getFullContentId(contentId: string) {
+    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+        select: ['fullId'],
+        where: { contentId },
+    });
+
+    return dbContent?.fullId;
+}
+
+export async function getContentContributors(contentId: string) {
+    const contributorIds = await (async () => {
+        const idHash: Record<string, true> = {};
+
+        (
+            await ERUDIT_SERVER.DB.manager.find(DbContribution, {
+                select: ['contributorId'],
+                where: { contentId },
+            })
+        ).forEach(
+            (contribution) => (idHash[contribution.contributorId] = true),
+        );
+
+        const type: ContentType = (await ERUDIT_SERVER.DB.manager.findOne(
+            DbContent,
+            {
+                select: ['type'],
+                where: { contentId },
+            },
+        ))!.type;
+
+        if (type === 'book' || type === 'group') {
+            // Collecting contributors for all sub-content items
+            (
+                await ERUDIT_SERVER.DB.manager.find(DbContribution, {
+                    select: ['contributorId'],
+                    where: { contentId: Like(`${contentId}/%`) },
+                })
+            ).forEach(
+                (contribution) => (idHash[contribution.contributorId] = true),
+            );
+        }
+
+        return Object.keys(idHash);
+    })();
+
+    const contentContributors: ContentContributor[] = [];
+
+    for (const contributorId of contributorIds) {
+        const dbContributor = (await ERUDIT_SERVER.DB.manager.findOne(
+            DbContributor,
+            {
+                select: ['contributorId', 'displayName', 'avatar'],
+                where: { contributorId },
+            },
+        ))!;
+
+        const contentContributor: ContentContributor = { contributorId };
+
+        if (dbContributor.displayName)
+            contentContributor.displayName = dbContributor.displayName;
+
+        if (dbContributor.avatar)
+            contentContributor.avatar = dbContributor.avatar;
+
+        contentContributors.push(contentContributor);
+    }
+
+    return contentContributors.length ? contentContributors : undefined;
+}

package/server/plugin/repository/contributor.ts

@@ -0,0 +1,8 @@
+import { DbContributor } from '@server/db/entities/Contributor';
+import { ERUDIT_SERVER } from '@server/global';
+
+export async function contributorExists(contributorId: string) {
+    return await ERUDIT_SERVER.DB.manager.exists(DbContributor, {
+        where: { contributorId },
+    });
+}

package/server/plugin/repository/frontNav.ts

@@ -0,0 +1,148 @@
+import type {
+    FrontNav,
+    FrontNavBase,
+    FrontNavBook,
+    FrontNavFolder,
+    FrontNavItem,
+    FrontNavSeparator,
+    FrontNavTopic,
+} from '@erudit/shared/frontNav';
+
+import type { NavNode, RootNavNode } from '@server/nav/node';
+import { ERUDIT_SERVER } from '@server/global';
+import { DbContent } from '@server/db/entities/Content';
+import { DbGroup } from '@server/db/entities/Group';
+
+import { getTopicPart } from './topic';
+
+export async function createGlobalFrontNav(
+    from: RootNavNode | NavNode | undefined,
+): Promise<FrontNav | []> {
+    if (!from || !from.children) return [];
+
+    return await Promise.all(
+        from.children.map((node) =>
+            toFrontNavItem({ node, level: 0, includeBookNav: true }),
+        ),
+    );
+}
+
+export async function createBookFrontNav(from: NavNode): Promise<FrontNavBook> {
+    return await toFrontNavBook({ node: from, level: 0, includeBookNav: true });
+}
+
+type ToFuncArg = {
+    node: NavNode;
+    level: number;
+    includeBookNav?: boolean;
+};
+
+async function toFrontNavItem(arg: ToFuncArg): Promise<FrontNavItem> {
+    switch (arg.node.type) {
+        case 'book':
+            return await toFrontNavBook(arg);
+        case 'topic':
+            return await toFrontNavTopic(arg);
+        case 'group':
+            const dbGroup = await ERUDIT_SERVER.DB.manager.findOne(DbGroup, {
+                select: ['type'],
+                where: { contentId: arg.node.id },
+            });
+
+            if (!dbGroup)
+                throw new Error(
+                    `Missing group content item "${arg.node.id}" when creating front nav!`,
+                );
+
+            if (dbGroup.type === 'folder') return await toFrontNavFolder(arg);
+            else return await toFrontNavSeparator(arg);
+    }
+}
+
+async function toFrontNavBook({
+    node,
+    level,
+    includeBookNav,
+}: ToFuncArg): Promise<FrontNavBook> {
+    return {
+        type: 'book',
+        children: await toFrontNavChildren({
+            node,
+            level: 0,
+            includeBookNav,
+        }),
+        ...(await toFrontNavBase({ node, level })),
+    };
+}
+
+async function toFrontNavSeparator({
+    node,
+    level,
+    includeBookNav,
+}: ToFuncArg): Promise<FrontNavSeparator> {
+    return {
+        type: 'separator',
+        children: await toFrontNavChildren({ node, level, includeBookNav }),
+        ...(await toFrontNavBase({ node, level })),
+    };
+}
+
+async function toFrontNavFolder({
+    node,
+    level,
+    includeBookNav,
+}: ToFuncArg): Promise<FrontNavFolder> {
+    return {
+        type: 'folder',
+        children: await toFrontNavChildren({
+            node,
+            level: level + 1,
+            includeBookNav,
+        }),
+        ...(await toFrontNavBase({ node, level })),
+    };
+}
+
+async function toFrontNavTopic({
+    node,
+    level,
+}: ToFuncArg): Promise<FrontNavTopic> {
+    const topicPart = await getTopicPart(node.id);
+    return {
+        type: 'topic',
+        part: topicPart,
+        ...(await toFrontNavBase({ node, level })),
+    };
+}
+
+async function toFrontNavBase({
+    node,
+    level,
+}: ToFuncArg): Promise<Omit<FrontNavBase, 'type'>> {
+    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+        select: ['title', 'navTitle', 'flags'],
+        where: { contentId: node.id },
+    });
+
+    return {
+        id: node.id,
+        fullId: node.fullId,
+        level,
+        flags: dbContent?.flags,
+        label:
+            dbContent?.navTitle ||
+            dbContent?.title ||
+            node.id.split('/').pop()!,
+    };
+}
+
+async function toFrontNavChildren({ node, includeBookNav, level }: ToFuncArg) {
+    if (node.type === 'book' && !includeBookNav) return undefined;
+    if (!node.children) return undefined;
+
+    return Promise.all(
+        node.children!.map((child) =>
+            toFrontNavItem({ node: child, level, includeBookNav }),
+        ),
+    );
+}