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

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

@@ -1,19 +1,48 @@
-import type { ContentExternal } from '@erudit-js/core/content/externals';
-import { eq } from 'drizzle-orm';
+import { eq, like } from 'drizzle-orm';
+import type { ContentExternals } from '@erudit-js/core/content/externals';
 
 export async function getContentExternals(
     fullId: string,
-): Promise<ContentExternal[]> {
-    const externals: ContentExternal[] = [];
+): Promise<ContentExternals> {
+    const externals: ContentExternals = [];
 
-    const dbContentItems = await ERUDIT.db.query.content.findMany({
-        columns: { fullId: true, type: true, externals: true },
+    const dbOwnContentItem = await ERUDIT.db.query.content.findFirst({
+        columns: { externals: true },
         where: eq(ERUDIT.db.schema.content.fullId, fullId),
     });
 
-    for (const dbContentItem of dbContentItems) {
-        if (dbContentItem?.externals) {
-            externals.push(...dbContentItem.externals);
+    if (dbOwnContentItem?.externals) {
+        externals.push({
+            type: 'own',
+            items: dbOwnContentItem.externals,
+        });
+    }
+    const parts = fullId.split('/');
+    const dbParentContentItems = [];
+
+    for (let i = parts.length - 1; i > 0; i--) {
+        const parentId = parts.slice(0, i).join('/');
+        const dbParentContentItem = await ERUDIT.db.query.content.findFirst({
+            columns: {
+                fullId: true,
+                externals: true,
+                title: true,
+            },
+            where: eq(ERUDIT.db.schema.content.fullId, parentId),
+        });
+
+        if (dbParentContentItem) {
+            dbParentContentItems.push(dbParentContentItem);
+        }
+    }
+
+    for (const dbParentContentItem of dbParentContentItems) {
+        if (dbParentContentItem?.externals) {
+            externals.push({
+                type: 'parent',
+                title: dbParentContentItem.title,
+                items: dbParentContentItem.externals,
+            });
         }
     }
 

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

@@ -1,3 +1,4 @@
+import chalk from 'chalk';
 import { inArray, or } from 'drizzle-orm';
 import { contentPathToId } from '@erudit-js/core/content/path';
 
@@ -8,35 +9,38 @@ import { resolveTopic } from './topic';
 
 let initialResolve = true;
 
+const contentRoot = () => `${ERUDIT.config.paths.project}/content`;
+
 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);
-            }
-        }
+    const isInitial = initialResolve;
+    initialResolve = false;
+
+    const toResolveContentIds = collectContentIdsToResolve(isInitial);
+
+    if (!toResolveContentIds.size) {
+        ERUDIT.log.info(
+            isInitial
+                ? 'Skipping content — no content found.'
+                : 'Skipping content — nothing changed.',
+        );
+        return;
+    }
+
+    if (!isInitial) {
+        ERUDIT.log.info(renderChangedContentTree(toResolveContentIds));
     }
 
     await clearOldContentData(Array.from(toResolveContentIds));
 
     for (const contentId of toResolveContentIds) {
-        const navNode = ERUDIT.contentNav.getNodeOrThrow(contentId);
+        const navNode = ERUDIT.contentNav.getNode(contentId);
+
+        if (!navNode) {
+            continue;
+        }
+
         switch (navNode.type) {
             case 'book':
                 await resolveBook(navNode);
@@ -52,6 +56,153 @@ export async function resolveContent() {
                 break;
         }
     }
+
+    ERUDIT.log.success(
+        isInitial
+            ? `Content resolved! (${ERUDIT.log.stress(toResolveContentIds.size)})`
+            : `Content updated! (${ERUDIT.log.stress(
+                  toResolveContentIds.size,
+              )})`,
+    );
+}
+
+function collectContentIdsToResolve(isInitial: boolean): Set<string> {
+    if (isInitial) {
+        return new Set(ERUDIT.contentNav.id2Node.keys());
+    }
+
+    if (!hasContentChanges()) {
+        return new Set();
+    }
+
+    const ids = new Set<string>();
+    const changedFiles = ERUDIT.changedFiles || new Set<string>();
+
+    for (const changedFile of changedFiles.values()) {
+        if (!changedFile.startsWith(`${contentRoot()}/`)) continue;
+
+        const contentId =
+            contentPathToId(changedFile, ERUDIT.config.paths.project, 'full') ||
+            deriveContentIdFromPath(changedFile);
+
+        if (!contentId) continue;
+
+        const navNode = ERUDIT.contentNav.getNode(contentId);
+
+        if (navNode) {
+            ERUDIT.contentNav.walkSync((node) => {
+                ids.add(node.fullId);
+            }, navNode);
+
+            ERUDIT.contentNav.walkUpSync((node) => {
+                ids.add(node.fullId);
+            }, navNode);
+            continue;
+        }
+
+        addAncestorIds(ids, contentId);
+    }
+
+    return ids;
+}
+
+function hasContentChanges() {
+    for (const file of (ERUDIT.changedFiles || new Set<string>()).values()) {
+        if (file.startsWith(`${contentRoot()}/`)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+function addAncestorIds(target: Set<string>, contentId: string) {
+    const parts = contentId.split('/').filter(Boolean);
+
+    for (let i = 1; i <= parts.length; i++) {
+        target.add(parts.slice(0, i).join('/'));
+    }
+}
+
+function deriveContentIdFromPath(path: string): string | undefined {
+    if (!path.startsWith(`${contentRoot()}/`)) return;
+
+    const rel = path.slice(contentRoot().length + 1);
+    const segments = rel.split('/');
+
+    // Drop filename if present
+    if (segments.length && segments[segments.length - 1].includes('.')) {
+        segments.pop();
+    }
+
+    if (!segments.length) return;
+
+    const idParts: string[] = [];
+
+    for (const seg of segments) {
+        const match = seg.match(/^(\d+)[+-](.+)$/);
+        if (!match) return;
+        const [, , idPart] = match;
+        if (!idPart) return;
+        idParts.push(idPart);
+    }
+
+    return idParts.join('/');
+}
+
+function renderChangedContentTree(ids: Set<string>): string {
+    const sorted = Array.from(ids).sort((a, b) => {
+        const al = a.split('/').length;
+        const bl = b.split('/').length;
+        if (al !== bl) return al - bl;
+        return a.localeCompare(b);
+    });
+
+    type Node = { name: string; children: Map<string, Node> };
+    const root: Node = { name: '', children: new Map() };
+
+    const ensureNode = (parent: Node, part: string): Node => {
+        let next = parent.children.get(part);
+        if (!next) {
+            next = { name: part, children: new Map() };
+            parent.children.set(part, next);
+        }
+        return next;
+    };
+
+    for (const id of sorted) {
+        let cursor = root;
+        for (const part of id.split('/')) {
+            cursor = ensureNode(cursor, part);
+        }
+    }
+
+    const lines: string[] = [];
+
+    const walkTree = (node: Node, depth: number) => {
+        if (node.name) {
+            const indent = '  '.repeat(Math.max(0, depth - 1));
+            lines.push(`${indent}- ${chalk.cyan(node.name)}`);
+        }
+
+        const children = Array.from(node.children.values()).sort((a, b) =>
+            a.name.localeCompare(b.name),
+        );
+
+        children.forEach((child) => {
+            walkTree(child, depth + 1);
+        });
+    };
+
+    const roots = Array.from(root.children.values()).sort((a, b) =>
+        a.name.localeCompare(b.name),
+    );
+    roots.forEach((child) => {
+        walkTree(child, 1);
+    });
+
+    const header = chalk.gray('Changed content:');
+    return [header, ...lines].join('\n');
 }
 
 export async function clearOldContentData(contentIds: string[]) {

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

@@ -1,13 +1,10 @@
 import { eq } from 'drizzle-orm';
 import {
     isDocument,
-    isProseElement,
     isRawElement,
     walkElements,
     type AnyDocument,
     type AnySchema,
-    type ProseElement,
-    type RawElement,
 } from '@jsprose/core';
 import {
     topicParts,
@@ -118,41 +115,105 @@ export async function resolveTopic(topicNode: ContentNavNode) {
                     },
                 );
 
+                let finalTocItems = resolvedTopicPart.tocItems;
+
                 if (
-                    resolvedTopicPart.tocItems?.length ||
-                    (topicPart === 'practice' &&
-                        practiceProblemsTocItems.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;
+                    // Map elementId -> TocItem for both headings and problems
+                    const itemMap = new Map<string, ResolvedTocItem>();
+
+                    // Collect all existing TOC items (headings) recursively
+                    const collectItems = (items: ResolvedTocItem[]) => {
+                        for (const item of items) {
+                            if (item.elementId) {
+                                itemMap.set(item.elementId, item);
+                            }
+                            if (
+                                item.type === 'heading' &&
+                                item.children?.length
+                            ) {
+                                collectItems(item.children);
                             }
-                            return true;
-                        });
-                    }
-
-                    await ERUDIT.db.insert(ERUDIT.db.schema.contentToc).values({
-                        fullId: topicNode.fullId,
-                        topicPart,
-                        toc: tocItems,
+                        }
+                    };
+                    collectItems(resolvedTopicPart.tocItems || []);
+
+                    // Add practice problems to the map
+                    practiceProblemsTocItems.forEach((p) => {
+                        if (p.elementId) {
+                            itemMap.set(p.elementId, p);
+                        }
                     });
+
+                    // Rebuild TOC in document order using walkElements
+                    const result: ResolvedTocItem[] = [];
+                    const stack: ResolvedTocItem[] = [];
+
+                    await walkElements(
+                        resolvedTopicPart.proseElement,
+                        (element) => {
+                            if (element.id && itemMap.has(element.id)) {
+                                const item = itemMap.get(element.id)!;
+
+                                if (item.type === 'heading') {
+                                    // Pop headings at same or deeper level
+                                    while (stack.length > 0) {
+                                        const last = stack[stack.length - 1];
+                                        if (
+                                            last.type === 'heading' &&
+                                            last.level >= item.level
+                                        ) {
+                                            stack.pop();
+                                        } else {
+                                            break;
+                                        }
+                                    }
+
+                                    // Create new heading with empty children array
+                                    const newItem: ResolvedTocItem = {
+                                        ...item,
+                                        children: [],
+                                    };
+
+                                    // Add to parent heading or root
+                                    if (stack.length > 0) {
+                                        const parent = stack[stack.length - 1];
+                                        if (parent.type === 'heading') {
+                                            parent.children.push(newItem);
+                                        }
+                                    } else {
+                                        result.push(newItem);
+                                    }
+
+                                    stack.push(newItem);
+                                } else {
+                                    // Non-heading item (problems, etc.)
+                                    if (stack.length > 0) {
+                                        const parent = stack[stack.length - 1];
+                                        if (parent.type === 'heading') {
+                                            parent.children.push(item);
+                                        } else {
+                                            result.push(item);
+                                        }
+                                    } else {
+                                        result.push(item);
+                                    }
+                                }
+                            }
+                        },
+                    );
+
+                    finalTocItems = result;
                 }
 
+                await ERUDIT.db.insert(ERUDIT.db.schema.contentToc).values({
+                    fullId: topicNode.fullId,
+                    topicPart,
+                    toc: finalTocItems,
+                });
+
                 await ERUDIT.db
                     .update(ERUDIT.db.schema.topics)
                     .set({

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

@@ -1,6 +1,7 @@
 import { type ResolvedRawElement } from '@jsprose/core';
 import type { ContentProseType } from '@erudit-js/core/content/prose';
 import type { ResolvedEruditRawElement } from '@erudit-js/prose';
+import { sql } from 'drizzle-orm';
 
 export async function insertContentResolved(
     contentFullId: string,
@@ -30,18 +31,22 @@ export async function insertContentResolved(
             contentProseType,
             elementId: snippet.elementId,
             schemaName: snippet.schemaName,
-            title: snippet.title!,
-            description: snippet.description,
-            search: Boolean(snippet.search),
-            searchSynonyms:
-                typeof snippet.search === 'object'
-                    ? snippet.search.synonyms
-                    : undefined,
-            quick: Boolean(snippet.quick),
-            seo: Boolean(snippet.seo),
+            snippetData: snippet.snippetData,
+            search: !!snippet.snippetData.search,
+            quick: !!snippet.snippetData.quick,
+            seo: !!snippet.snippetData.seo,
         });
     }
 
+    // Deduplicate search flags for topic snippets
+    if (
+        contentProseType === 'article' ||
+        contentProseType === 'summary' ||
+        contentProseType === 'practice'
+    ) {
+        await deduplicateTopicSnippetsSearch(contentFullId);
+    }
+
     for (const problemScript of resolveResult.problemScripts) {
         await ERUDIT.repository.db.pushProblemScript(
             problemScript,
@@ -91,3 +96,37 @@ function globalContentToNavNode(globalContentPath: string) {
 
     return navNode;
 }
+
+async function deduplicateTopicSnippetsSearch(contentFullId: string) {
+    // Disable search flag for duplicate snippets,
+    // keeping the highest-priority one per (title, schemaName)
+    await ERUDIT.db.run(sql`
+    UPDATE contentSnippets
+    SET search = 0
+    WHERE snippetId IN (
+      SELECT snippetId
+      FROM (
+        SELECT
+          snippetId,
+          ROW_NUMBER() OVER (
+            PARTITION BY
+              LOWER(TRIM(json_extract(snippetData, '$.title'))),
+              schemaName
+            ORDER BY
+              CASE contentProseType
+                WHEN 'article' THEN 0
+                WHEN 'summary' THEN 1
+                WHEN 'practice' THEN 2
+                ELSE 99
+              END
+          ) AS rn
+        FROM contentSnippets
+        WHERE
+          contentFullId = ${contentFullId}
+          AND json_extract(snippetData, '$.title') IS NOT NULL
+          AND search = 1
+      )
+      WHERE rn > 1
+    );
+  `);
+}

package/server/erudit/content/search.ts

@@ -121,13 +121,41 @@ export async function searchIndexSnippets(): Promise<SearchEntriesList[]> {
                 });
         }
 
+        let searchTitle = dbSnippet.snippetData.title!;
+        let searchDescription = dbSnippet.snippetData.description;
+        if (
+            typeof dbSnippet.snippetData.search === 'object' &&
+            !Array.isArray(dbSnippet.snippetData.search)
+        ) {
+            if (dbSnippet.snippetData.search.title) {
+                searchTitle = dbSnippet.snippetData.search.title;
+            }
+
+            if (dbSnippet.snippetData.search.description) {
+                searchDescription = dbSnippet.snippetData.search.description;
+            }
+        }
+
+        let searchSynonyms: string[] | undefined = undefined;
+        if (Array.isArray(dbSnippet.snippetData.search)) {
+            searchSynonyms = dbSnippet.snippetData.search;
+        } else {
+            if (typeof dbSnippet.snippetData.search === 'object') {
+                searchSynonyms = dbSnippet.snippetData.search.synonyms;
+            }
+        }
+
         entryLists.get(dbSnippet.schemaName)!.entries.push({
             category: 'element:' + dbSnippet.schemaName,
-            title: dbSnippet.title,
-            description: dbSnippet.description || undefined,
+            title: searchTitle,
+            description: searchDescription,
             link,
             location: locationTitle,
-            synonyms: dbSnippet.searchSynonyms || undefined,
+            synonyms: searchSynonyms
+                ? searchSynonyms.length > 0
+                    ? searchSynonyms
+                    : undefined
+                : undefined,
         });
     }