erudit 3.0.0-dev.8 → 4.0.0-dev.1

package/server/erudit/content/repository/title.ts

@@ -0,0 +1,27 @@
+import { eq } from 'drizzle-orm';
+
+export async function getContentTitle(
+    fullContentId: string,
+    type: 'normal' | 'nav' = 'normal',
+) {
+    const dbContentItem = await ERUDIT.db.query.content.findFirst({
+        columns: {
+            title: true,
+            navTitle: true,
+        },
+        where: eq(ERUDIT.db.schema.content.fullId, fullContentId),
+    });
+
+    if (!dbContentItem) {
+        throw createError({
+            statusCode: 404,
+            message: `Content with id "${fullContentId}" not found!`,
+        });
+    }
+
+    if (type === 'nav' && dbContentItem.navTitle) {
+        return dbContentItem.navTitle;
+    }
+
+    return dbContentItem.title || fullContentId.split('/').pop()!;
+}

package/server/erudit/content/repository/topicParts.ts

@@ -0,0 +1,39 @@
+import { eq, sql } from 'drizzle-orm';
+import type { TopicPart } from '@erudit-js/core/content/topic';
+
+export async function getTopicParts(fullId: string): Promise<TopicPart[]> {
+    const dbResult = await ERUDIT.db
+        .select({
+            hasArticle: sql<boolean>`(${ERUDIT.db.schema.topics.article} IS NOT NULL)`,
+            hasSummary: sql<boolean>`(${ERUDIT.db.schema.topics.summary} IS NOT NULL)`,
+            hasPractice: sql<boolean>`(${ERUDIT.db.schema.topics.practice} IS NOT NULL)`,
+        })
+        .from(ERUDIT.db.schema.topics)
+        .where(eq(ERUDIT.db.schema.topics.fullId, fullId));
+
+    const topic = dbResult?.[0];
+    if (!topic) {
+        return [];
+    }
+
+    const parts: TopicPart[] = [];
+
+    if (topic.hasArticle) {
+        parts.push('article');
+    }
+
+    if (topic.hasSummary) {
+        parts.push('summary');
+    }
+
+    if (topic.hasPractice) {
+        parts.push('practice');
+    }
+
+    return parts;
+}
+
+export async function getDefaultTopicPart(fullId: string): Promise<TopicPart> {
+    const parts = await getTopicParts(fullId);
+    return parts[0];
+}

package/server/erudit/content/repository/unique.ts

@@ -0,0 +1,76 @@
+import { and, eq } from 'drizzle-orm';
+import {
+    mixSchema,
+    walkElements,
+    WalkNoDeeper,
+    WalkStop,
+    type AnySchema,
+    type ProseElement,
+} from '@jsprose/core';
+import type { ContentProseType } from '@erudit-js/core/content/prose';
+import { headingSchema } from '@erudit-js/prose/elements/heading/core';
+
+export async function getContentUnique(
+    fullId: string,
+    proseType: ContentProseType,
+    uniqueName: string,
+) {
+    const dbContentUnique = await ERUDIT.db.query.contentUniques.findFirst({
+        where: and(
+            eq(ERUDIT.db.schema.contentUniques.contentFullId, fullId),
+            eq(ERUDIT.db.schema.contentUniques.contentProseType, proseType),
+            eq(ERUDIT.db.schema.contentUniques.uniqueName, uniqueName),
+        ),
+    });
+
+    if (!dbContentUnique) {
+        throw createError({
+            statusCode: 404,
+            message: `Content unique with name "${uniqueName}" for content "${fullId}" and prose type "${proseType}" not found!`,
+        });
+    }
+
+    return dbContentUnique;
+}
+
+export async function getContentHeadingUnique(
+    fullId: string,
+    proseType: ContentProseType,
+    uniqueName: string,
+) {
+    const contentProse = await ERUDIT.repository.prose.getContent(
+        proseType,
+        fullId,
+    );
+
+    const afterHeadingElements: ProseElement<AnySchema>[] = [];
+    let adding = false;
+
+    await walkElements(contentProse, async (element) => {
+        if (
+            element.schemaName === headingSchema.name &&
+            element.uniqueName === uniqueName
+        ) {
+            adding = true;
+        }
+
+        if (adding) {
+            afterHeadingElements.push(element);
+
+            if (afterHeadingElements.length === 4) {
+                adding = false;
+                return WalkStop;
+            }
+
+            return WalkNoDeeper;
+        }
+    });
+
+    const mix: ProseElement<typeof mixSchema> = {
+        __JSPROSE_element: true,
+        schemaName: mixSchema.name,
+        children: afterHeadingElements,
+    } as ProseElement<typeof mixSchema>;
+
+    return mix;
+}

package/server/erudit/content/resolve/book.ts

@@ -0,0 +1,32 @@
+import type { BookContentItem } from '@erudit-js/core/content/book';
+import { isContentItem } from '@erudit-js/core/content/item';
+
+import type { ContentNavNode } from '../nav/types';
+import { logContentError } from './utils/contentError';
+import { insertContentItem } from './utils/insertContentItem';
+
+export async function resolveBook(bookNode: ContentNavNode) {
+    ERUDIT.log.debug.start(
+        `Resolving book ${ERUDIT.log.stress(bookNode.fullId)}...`,
+    );
+
+    try {
+        const bookModule = await ERUDIT.import<{ default: BookContentItem }>(
+            ERUDIT.config.paths.project +
+                '/content/' +
+                bookNode.contentRelPath +
+                '/book',
+        );
+
+        if (!isContentItem<BookContentItem>(bookModule?.default, 'book')) {
+            throw new Error('Book default export must be a book content item!');
+        }
+
+        const bookContentItem = bookModule.default;
+
+        await insertContentItem(bookNode, bookContentItem);
+    } catch (error) {
+        logContentError(bookNode);
+        throw error;
+    }
+}

package/server/erudit/content/resolve/group.ts

@@ -0,0 +1,39 @@
+import type { GroupContentItem } from '@erudit-js/core/content/group';
+import { isContentItem } from '@erudit-js/core/content/item';
+
+import type { ContentNavNode } from '../nav/types';
+import { logContentError } from './utils/contentError';
+import { insertContentItem } from './utils/insertContentItem';
+
+export async function resolveGroup(groupNode: ContentNavNode) {
+    ERUDIT.log.debug.start(
+        `Resolving group ${ERUDIT.log.stress(groupNode.fullId)}...`,
+    );
+
+    try {
+        const groupModule = await ERUDIT.import<{ default: GroupContentItem }>(
+            ERUDIT.config.paths.project +
+                '/content/' +
+                groupNode.contentRelPath +
+                '/group',
+        );
+
+        if (!isContentItem<GroupContentItem>(groupModule?.default, 'group')) {
+            throw new Error(
+                'Group default export must be a group content item!',
+            );
+        }
+
+        const groupContentItem = groupModule.default;
+
+        await insertContentItem(groupNode, groupContentItem);
+
+        await ERUDIT.db.insert(ERUDIT.db.schema.groups).values({
+            fullId: groupNode.fullId,
+            separator: groupContentItem.separator ?? false,
+        });
+    } catch (error) {
+        logContentError(groupNode);
+        throw error;
+    }
+}

package/server/erudit/content/resolve/index.ts

@@ -0,0 +1,139 @@
+import { inArray, or } from 'drizzle-orm';
+import { contentPathToId } from '@erudit-js/core/content/path';
+
+import { resolveGroup } from './group';
+import { resolveBook } from './book';
+import { resolvePage } from './page';
+import { resolveTopic } from './topic';
+
+let initialResolve = true;
+
+export async function resolveContent() {
+    ERUDIT.log.debug.start('Resolving content...');
+
+    let toResolveContentIds = new Set<string>();
+    if (initialResolve) {
+        initialResolve = false;
+        toResolveContentIds = new Set(ERUDIT.contentNav.id2Node.keys());
+    } else {
+        for (const changedFile of ERUDIT.changedFiles.values()) {
+            const contentId = contentPathToId(
+                changedFile,
+                ERUDIT.config.paths.project,
+                'full',
+            );
+
+            const navNode = ERUDIT.contentNav.getNode(contentId || '');
+
+            if (navNode) {
+                await ERUDIT.contentNav.walk((node) => {
+                    toResolveContentIds.add(node.fullId);
+                }, navNode);
+            }
+        }
+    }
+
+    await clearOldContentData(Array.from(toResolveContentIds));
+
+    for (const contentId of toResolveContentIds) {
+        const navNode = ERUDIT.contentNav.getNodeOrThrow(contentId);
+        switch (navNode.type) {
+            case 'book':
+                await resolveBook(navNode);
+                break;
+            case 'group':
+                await resolveGroup(navNode);
+                break;
+            case 'page':
+                await resolvePage(navNode);
+                break;
+            case 'topic':
+                await resolveTopic(navNode);
+                break;
+        }
+    }
+}
+
+export async function clearOldContentData(contentIds: string[]) {
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.content)
+        .where(inArray(ERUDIT.db.schema.content.fullId, contentIds));
+
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.groups)
+        .where(inArray(ERUDIT.db.schema.groups.fullId, contentIds));
+
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.pages)
+        .where(inArray(ERUDIT.db.schema.pages.fullId, contentIds));
+
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.topics)
+        .where(inArray(ERUDIT.db.schema.topics.fullId, contentIds));
+
+    await ERUDIT.db.delete(ERUDIT.db.schema.files).where(
+        inArray(
+            ERUDIT.db.schema.files.role,
+            contentIds.flatMap((id) => [
+                `content-item:${id}`,
+                `content-decoration:${id}`,
+            ]),
+        ),
+    );
+
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.contentDeps)
+        .where(inArray(ERUDIT.db.schema.contentDeps.toFullId, contentIds));
+
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.contentElementStats)
+        .where(
+            inArray(ERUDIT.db.schema.contentElementStats.fullId, contentIds),
+        );
+
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.contentProseLinks)
+        .where(
+            or(
+                inArray(
+                    ERUDIT.db.schema.contentProseLinks.fromContentId,
+                    contentIds,
+                ),
+            ),
+        );
+
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.contentContributions)
+        .where(
+            inArray(
+                ERUDIT.db.schema.contentContributions.contentFullId,
+                contentIds,
+            ),
+        );
+
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.contentUniques)
+        .where(
+            inArray(ERUDIT.db.schema.contentUniques.contentFullId, contentIds),
+        );
+
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.contentSnippets)
+        .where(
+            inArray(ERUDIT.db.schema.contentSnippets.contentFullId, contentIds),
+        );
+
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.problemScripts)
+        .where(
+            inArray(ERUDIT.db.schema.problemScripts.contentFullId, contentIds),
+        );
+
+    await ERUDIT.db
+        .delete(ERUDIT.db.schema.contentToc)
+        .where(inArray(ERUDIT.db.schema.contentToc.fullId, contentIds));
+}
+
+export function requestFullContentResolve() {
+    initialResolve = true;
+}

package/server/erudit/content/resolve/page.ts

@@ -0,0 +1,87 @@
+import { isDocument, type AnyDocument } from '@jsprose/core';
+import { isContentItem } from '@erudit-js/core/content/item';
+import type { PageContentItem } from '@erudit-js/core/content/page';
+import { isIncludedRawElement } from '@erudit-js/prose';
+
+import type { ContentNavNode } from '../nav/types';
+import { logContentError } from './utils/contentError';
+import { insertContentItem } from './utils/insertContentItem';
+import { resolveEruditProse } from '../../prose/repository/resolve';
+import { insertContentResolved } from './utils/insertContentResolved';
+
+export async function resolvePage(pageNode: ContentNavNode) {
+    ERUDIT.log.debug.start(
+        `Resolving page ${ERUDIT.log.stress(pageNode.fullId)}...`,
+    );
+
+    try {
+        const pageModule = await ERUDIT.import<{
+            content: AnyDocument;
+            page: PageContentItem;
+        }>(
+            ERUDIT.config.paths.project +
+                '/content/' +
+                pageNode.contentRelPath +
+                '/page',
+        );
+
+        if (!isContentItem<PageContentItem>(pageModule?.page, 'page')) {
+            throw new Error('Page `page` export must be a page content item!');
+        }
+
+        if (!isDocument(pageModule?.content)) {
+            throw new Error('Page `content` export must be a Document!');
+        }
+
+        await insertContentItem(pageNode, pageModule.page);
+
+        const elementsCount: Record<string, number> = {};
+
+        const proseDocument = pageModule.content;
+        const resolveResult = await resolveEruditProse(
+            proseDocument.content,
+            true,
+            async ({ rawElement }) => {
+                // Counting elements for statistics
+
+                if (isIncludedRawElement(rawElement)) {
+                    return;
+                }
+
+                if (
+                    ERUDIT.config.project.countElements
+                        .flat()
+                        .includes(rawElement.schemaName)
+                ) {
+                    elementsCount[rawElement.schemaName] =
+                        (elementsCount[rawElement.schemaName] || 0) + 1;
+                }
+            },
+        );
+
+        if (resolveResult.tocItems?.length) {
+            await ERUDIT.db.insert(ERUDIT.db.schema.contentToc).values({
+                fullId: pageNode.fullId,
+                toc: resolveResult.tocItems,
+            });
+        }
+
+        for (const [schemaName, count] of Object.entries(elementsCount)) {
+            await ERUDIT.repository.content.addElementCount(
+                pageNode.fullId,
+                schemaName,
+                count,
+            );
+        }
+
+        await ERUDIT.db.insert(ERUDIT.db.schema.pages).values({
+            fullId: pageNode.fullId,
+            prose: resolveResult.proseElement,
+        });
+
+        await insertContentResolved(pageNode.fullId, 'page', resolveResult);
+    } catch (error) {
+        logContentError(pageNode);
+        throw error;
+    }
+}

package/server/erudit/content/resolve/topic.ts

@@ -0,0 +1,185 @@
+import { eq } from 'drizzle-orm';
+import {
+    isDocument,
+    isProseElement,
+    isRawElement,
+    walkElements,
+    type AnyDocument,
+    type AnySchema,
+    type ProseElement,
+    type RawElement,
+} from '@jsprose/core';
+import {
+    topicParts,
+    type TopicContentItem,
+} from '@erudit-js/core/content/topic';
+import { isContentItem } from '@erudit-js/core/content/item';
+import {
+    isIncludedRawElement,
+    type EruditRawElement,
+    type ResolvedTocItem,
+} from '@erudit-js/prose';
+import { problemSchema } from '@erudit-js/prose/elements/problem/problem';
+import { problemsSchema } from '@erudit-js/prose/elements/problem/problems';
+
+import type { ContentNavNode } from '../nav/types';
+import { logContentError } from './utils/contentError';
+import { insertContentItem } from './utils/insertContentItem';
+import { resolveEruditProse } from '../../prose/repository/resolve';
+import { insertContentResolved } from './utils/insertContentResolved';
+
+export async function resolveTopic(topicNode: ContentNavNode) {
+    ERUDIT.log.debug.start(
+        `Resolving topic ${ERUDIT.log.stress(topicNode.fullId)}...`,
+    );
+
+    try {
+        const topicModule = await ERUDIT.import<{ default: TopicContentItem }>(
+            ERUDIT.config.paths.project +
+                '/content/' +
+                topicNode.contentRelPath +
+                '/topic',
+        );
+
+        if (!isContentItem<TopicContentItem>(topicModule?.default, 'topic')) {
+            throw new Error(
+                'Topic default export must be a topic content item!',
+            );
+        }
+
+        await insertContentItem(topicNode, topicModule.default);
+        await ERUDIT.db.insert(ERUDIT.db.schema.topics).values({
+            fullId: topicNode.fullId,
+        });
+
+        const elementsCount: Record<string, number> = {};
+
+        for (const topicPart of topicParts) {
+            const topicPartDocument = await ERUDIT.import<{
+                default: AnyDocument;
+            }>(
+                ERUDIT.config.paths.project +
+                    '/content/' +
+                    topicNode.contentRelPath +
+                    '/' +
+                    topicPart,
+                { try: true },
+            );
+
+            if (isDocument(topicPartDocument?.default)) {
+                const practiceProblemsTocItems: ResolvedTocItem[] = [];
+
+                const resolvedTopicPart = await resolveEruditProse(
+                    topicPartDocument.default.content,
+                    true,
+                    async ({ rawElement, proseElement }) => {
+                        //
+                        // Auto-adding problems to TOC if in practice topic part
+                        //
+
+                        if (topicPart === 'practice') {
+                            if (
+                                (rawElement as EruditRawElement<AnySchema>)
+                                    .title &&
+                                proseElement.id
+                            ) {
+                                if (
+                                    isRawElement(rawElement, problemSchema) ||
+                                    isRawElement(rawElement, problemsSchema)
+                                ) {
+                                    practiceProblemsTocItems.push({
+                                        type: 'element',
+                                        elementId: proseElement.id,
+                                        schemaName: rawElement.schemaName,
+                                        title: (
+                                            rawElement as EruditRawElement<AnySchema>
+                                        ).title!,
+                                    });
+                                }
+                            }
+                        }
+
+                        //
+                        // Counting elements for statistics
+                        //
+
+                        if (isIncludedRawElement(rawElement)) {
+                            return;
+                        }
+
+                        if (
+                            ERUDIT.config.project.countElements
+                                .flat()
+                                .includes(rawElement.schemaName)
+                        ) {
+                            elementsCount[rawElement.schemaName] =
+                                (elementsCount[rawElement.schemaName] || 0) + 1;
+                        }
+                    },
+                );
+
+                if (
+                    resolvedTopicPart.tocItems?.length ||
+                    (topicPart === 'practice' &&
+                        practiceProblemsTocItems.length)
+                ) {
+                    let tocItems = resolvedTopicPart.tocItems || [];
+
+                    if (topicPart === 'practice') {
+                        // Combine regular toc items with practice problems
+                        const combined = [
+                            ...tocItems,
+                            ...practiceProblemsTocItems,
+                        ];
+
+                        // Deduplicate based on elementId
+                        const seen = new Set<string>();
+                        tocItems = combined.filter((item) => {
+                            if (item.type === 'element' && item.elementId) {
+                                if (seen.has(item.elementId)) {
+                                    return false;
+                                }
+                                seen.add(item.elementId);
+                                return true;
+                            }
+                            return true;
+                        });
+                    }
+
+                    await ERUDIT.db.insert(ERUDIT.db.schema.contentToc).values({
+                        fullId: topicNode.fullId,
+                        topicPart,
+                        toc: tocItems,
+                    });
+                }
+
+                await ERUDIT.db
+                    .update(ERUDIT.db.schema.topics)
+                    .set({
+                        [topicPart]: resolvedTopicPart.proseElement,
+                    })
+                    .where(
+                        eq(ERUDIT.db.schema.topics.fullId, topicNode.fullId),
+                    );
+
+                await insertContentResolved(
+                    topicNode.fullId,
+                    topicPart,
+                    resolvedTopicPart,
+                );
+            }
+        }
+
+        for (const [schemaName, count] of Object.entries(elementsCount)) {
+            await ERUDIT.repository.content.addElementCount(
+                topicNode.fullId,
+                schemaName,
+                count,
+            );
+        }
+    } catch (error) {
+        logContentError(topicNode);
+        //console.log(error);
+        throw error;
+    }
+}

package/server/erudit/content/resolve/utils/contentError.ts

@@ -0,0 +1,10 @@
+import chalk from 'chalk';
+import type { ContentNavNode } from '../../nav/types';
+
+export function logContentError(contentNode: ContentNavNode) {
+    ERUDIT.log.error(
+        `Error parsing ${contentNode.type} ${ERUDIT.log.stress(
+            contentNode.fullId,
+        )}!\nLocation: ${chalk.red(ERUDIT.config.paths.project + '/content/' + contentNode.contentRelPath)}`,
+    );
+}