erudit 4.1.1 → 4.2.0-dev.1

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

@@ -27,7 +27,7 @@ export async function getContentDependencies(fullId: string) {
 
   for (const toFullId of hardToFullIds) {
     const reason = fullId2Reason.get(toFullId)!;
-    const hardDep = await createContentDep('hard', toFullId, reason);
+    const hardDep = await createContentDep('hard', toFullId, undefined, reason);
     if (hardDep) {
       hardDependencies.push(hardDep);
     }
@@ -40,7 +40,7 @@ export async function getContentDependencies(fullId: string) {
   const autoDependencies: ContentAutoDep[] = [];
 
   const dbAutoDependencies = await ERUDIT.db.query.contentDeps.findMany({
-    columns: { toFullId: true, hard: true },
+    columns: { toFullId: true, hard: true, uniqueNames: true },
     where: and(
       or(
         eq(ERUDIT.db.schema.contentDeps.fromFullId, fullId),
@@ -50,13 +50,30 @@ export async function getContentDependencies(fullId: string) {
     ),
   });
 
+  // Merge unique names across rows that share the same toFullId
+  // (can happen when a topic and its children both dep on the same target).
+  const autoUniqueMap = new Map<string, Set<string>>();
+  for (const row of dbAutoDependencies) {
+    if (!autoUniqueMap.has(row.toFullId)) {
+      autoUniqueMap.set(row.toFullId, new Set());
+    }
+    if (row.uniqueNames) {
+      for (const name of row.uniqueNames.split(',')) {
+        autoUniqueMap.get(row.toFullId)!.add(name);
+      }
+    }
+  }
+
   // Skip auto-dependency if a hard dependency from the same source exists
   const autoToFullIds = ERUDIT.contentNav
     .orderIds(externalToFullIds(dbAutoDependencies))
     .filter((toFullId) => !fullId2Reason.has(toFullId));
 
   for (const toFullId of autoToFullIds) {
-    const autoDep = await createContentDep('auto', toFullId);
+    const uniquePairs = Array.from(autoUniqueMap.get(toFullId) ?? []).map(
+      (uniqueName) => ({ contentFullId: toFullId, uniqueName }),
+    );
+    const autoDep = await createContentDep('auto', toFullId, uniquePairs);
     if (autoDep) {
       autoDependencies.push(autoDep);
     }
@@ -92,32 +109,50 @@ export async function getContentDependents(
   fullId: string,
 ): Promise<ContentAutoDep[]> {
   const dbDependents = await ERUDIT.db.query.contentDeps.findMany({
-    columns: { fromFullId: true, toFullId: true },
+    columns: { fromFullId: true, toFullId: true, uniqueNames: true },
     where: or(
       eq(ERUDIT.db.schema.contentDeps.toFullId, fullId),
       like(ERUDIT.db.schema.contentDeps.toFullId, `${fullId}/%`),
     ),
   });
 
-  // Skip dependent if it originates from current content item or its child
-  const externalFromFullIds = dbDependents.reduce((ids, dbDependent) => {
-    const fromFullId = dbDependent.fromFullId;
+  // Group rows by fromFullId, collecting {contentFullId, uniqueName} pairs
+  // (toFullId can vary when a dependent references different child pages).
+  const fromUniquePairsMap = new Map<
+    string,
+    { contentFullId: string; uniqueName: string }[]
+  >();
+  const externalFromFullIds: string[] = [];
+
+  for (const row of dbDependents) {
+    const fromFullId = row.fromFullId;
     const isFromSelf = fromFullId === fullId;
     const isFromChild = fromFullId.startsWith(`${fullId}/`);
 
-    if (isFromSelf || isFromChild) {
-      return ids;
+    if (isFromSelf || isFromChild) continue;
+
+    if (!fromUniquePairsMap.has(fromFullId)) {
+      fromUniquePairsMap.set(fromFullId, []);
+      externalFromFullIds.push(fromFullId);
     }
 
-    ids.push(fromFullId);
-    return ids;
-  }, [] as string[]);
+    if (row.uniqueNames) {
+      for (const name of row.uniqueNames.split(',')) {
+        fromUniquePairsMap
+          .get(fromFullId)!
+          .push({ contentFullId: row.toFullId, uniqueName: name });
+      }
+    }
+  }
 
   // Order sources according to nav structure
   const fromFullIds = ERUDIT.contentNav.orderIds(externalFromFullIds);
 
   const dependents = await Promise.all(
-    fromFullIds.map((fromFullId) => createContentDep('auto', fromFullId)),
+    fromFullIds.map((fromFullId) => {
+      const uniquePairs = fromUniquePairsMap.get(fromFullId) ?? [];
+      return createContentDep('auto', fromFullId, uniquePairs);
+    }),
   );
 
   return dependents.filter((dep): dep is ContentAutoDep => dep !== undefined);
@@ -126,15 +161,18 @@ export async function getContentDependents(
 async function createContentDep(
   type: 'auto',
   fullId: string,
+  uniquePairs: { contentFullId: string; uniqueName: string }[],
 ): Promise<ContentAutoDep | undefined>;
 async function createContentDep(
   type: 'hard',
   fullId: string,
+  uniquePairs: undefined,
   reason: string,
 ): Promise<ContentHardDep | undefined>;
 async function createContentDep(
   type: 'auto' | 'hard',
   fullId: string,
+  uniquePairs?: { contentFullId: string; uniqueName: string }[],
   reason?: string,
 ): Promise<ContentDep | undefined> {
   const navNode = ERUDIT.contentNav.getNodeOrThrow(fullId);
@@ -160,10 +198,60 @@ async function createContentDep(
     };
   }
 
+  const uniques =
+    uniquePairs && uniquePairs.length > 0
+      ? await resolveUniqueEntries(uniquePairs)
+      : undefined;
+
   return {
     type: 'auto',
     contentType,
     title,
     link,
+    ...(uniques && uniques.length > 0 ? { uniques } : {}),
   };
 }
+
+async function resolveUniqueEntries(
+  pairs: { contentFullId: string; uniqueName: string }[],
+): Promise<ContentDepUnique[]> {
+  // Deduplicate by "contentFullId/uniqueName" to avoid showing the same
+  // element twice when multiple prose types reference it.
+  const seen = new Set<string>();
+  const unique: typeof pairs = [];
+  for (const pair of pairs) {
+    const key = `${pair.contentFullId}/${pair.uniqueName}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      unique.push(pair);
+    }
+  }
+
+  const results = await Promise.all(
+    unique.map(async ({ contentFullId, uniqueName }) => {
+      const dbUnique = await ERUDIT.db.query.contentUniques.findFirst({
+        columns: { title: true, prose: true },
+        where: and(
+          eq(ERUDIT.db.schema.contentUniques.contentFullId, contentFullId),
+          eq(ERUDIT.db.schema.contentUniques.uniqueName, uniqueName),
+        ),
+      });
+
+      if (!dbUnique) return null;
+
+      const pageLink = await ERUDIT.repository.content.link(contentFullId);
+      const schemaName = dbUnique.prose.schema.name;
+
+      if (!schemaName) return null;
+
+      return {
+        name: uniqueName,
+        title: dbUnique.title ?? undefined,
+        link: `${pageLink}?element=${dbUnique.prose.id}`,
+        schemaName,
+      } satisfies ContentDepUnique;
+    }),
+  );
+
+  return results.filter((r): r is ContentDepUnique => r !== null);
+}

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

@@ -15,7 +15,7 @@ export async function getContentElementSnippets(
     where: and(
       eq(ERUDIT.db.schema.contentSnippets.contentFullId, fullId),
       or(
-        eq(ERUDIT.db.schema.contentSnippets.quick, true),
+        eq(ERUDIT.db.schema.contentSnippets.key, true),
         eq(ERUDIT.db.schema.contentSnippets.seo, true),
       ),
     ),
@@ -45,27 +45,27 @@ export async function getContentElementSnippets(
       title: snippetData.title!,
     };
 
-    if (snippetData.quick) {
-      snippet.quick = {};
-      let quickTitle: string | undefined;
-      let quickDescription: string | undefined;
+    if (snippetData.key) {
+      snippet.key = {};
+      let keyTitle: string | undefined;
+      let keyDescription: string | undefined;
 
-      if (typeof snippetData.quick === 'string') {
-        quickTitle = snippetData.quick;
-      } else if (typeof snippetData.quick === 'object') {
-        if (snippetData.quick.title) {
-          quickTitle = snippetData.quick.title;
+      if (typeof snippetData.key === 'string') {
+        keyTitle = snippetData.key;
+      } else if (typeof snippetData.key === 'object') {
+        if (snippetData.key.title) {
+          keyTitle = snippetData.key.title;
         }
-        if (snippetData.quick.description) {
-          quickDescription = snippetData.quick.description;
+        if (snippetData.key.description) {
+          keyDescription = snippetData.key.description;
         }
       }
 
-      if (quickTitle) {
-        snippet.quick.title = quickTitle;
+      if (keyTitle) {
+        snippet.key.title = keyTitle;
       }
-      if (quickDescription) {
-        snippet.quick.description = quickDescription;
+      if (keyDescription) {
+        snippet.key.description = keyDescription;
       }
     }
 

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

@@ -1,30 +1,38 @@
 import { and, eq, sql } from 'drizzle-orm';
 
-export async function addContentElementCount(
+export async function updateContentSchemaCounts(
   fullId: string,
-  schemaName: string,
-  amount: number,
+  schemaCounts: Record<string, number>,
+  // schemaName: string,
+  // amount: number,
 ): Promise<void> {
-  await ERUDIT.db
-    .insert(ERUDIT.db.schema.contentElementStats)
-    .values({
-      fullId,
-      schemaName,
-      count: 0,
-    })
-    .onConflictDoNothing();
+  const schemasFilter = ERUDIT.config.countElements.flat();
+  const filteredSchemaCounts = Object.entries(schemaCounts).filter(
+    ([schemaName]) => schemasFilter.includes(schemaName),
+  );
 
-  await ERUDIT.db
-    .update(ERUDIT.db.schema.contentElementStats)
-    .set({
-      count: sql`${ERUDIT.db.schema.contentElementStats.count} + ${amount}`,
-    })
-    .where(
-      and(
-        eq(ERUDIT.db.schema.contentElementStats.fullId, fullId),
-        eq(ERUDIT.db.schema.contentElementStats.schemaName, schemaName),
-      ),
-    );
+  for (const [schemaName, amount] of filteredSchemaCounts) {
+    await ERUDIT.db
+      .insert(ERUDIT.db.schema.contentElementStats)
+      .values({
+        fullId,
+        schemaName,
+        count: 0,
+      })
+      .onConflictDoNothing();
+
+    await ERUDIT.db
+      .update(ERUDIT.db.schema.contentElementStats)
+      .set({
+        count: sql`${ERUDIT.db.schema.contentElementStats.count} + ${amount}`,
+      })
+      .where(
+        and(
+          eq(ERUDIT.db.schema.contentElementStats.fullId, fullId),
+          eq(ERUDIT.db.schema.contentElementStats.schemaName, schemaName),
+        ),
+      );
+  }
 }
 
 export async function getContentStats(

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

@@ -35,5 +35,5 @@ export async function getTopicParts(fullId: string): Promise<TopicPart[]> {
 
 export async function getDefaultTopicPart(fullId: string): Promise<TopicPart> {
   const parts = await getTopicParts(fullId);
-  return parts[0];
+  return parts[0]!;
 }

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

@@ -1,12 +1,13 @@
 import { and, eq } from 'drizzle-orm';
 import {
+  isProseElement,
+  makeProseElement,
   mixSchema,
-  walkElements,
   WalkNoDeeper,
+  walkPreSync,
   WalkStop,
-  type AnySchema,
   type ProseElement,
-} from '@jsprose/core';
+} from 'tsprose';
 import type { ContentProseType } from '@erudit-js/core/content/prose';
 import { headingSchema } from '@erudit-js/prose/elements/heading/core';
 
@@ -36,21 +37,18 @@ export async function getContentUnique(
 export async function getContentHeadingUnique(
   fullId: string,
   proseType: ContentProseType,
-  uniqueName: string,
+  uniqueId: string,
 ) {
   const contentProse = await ERUDIT.repository.prose.getContent(
     proseType,
     fullId,
   );
 
-  const afterHeadingElements: ProseElement<AnySchema>[] = [];
+  const afterHeadingElements: ProseElement[] = [];
   let adding = false;
 
-  await walkElements(contentProse, async (element) => {
-    if (
-      element.schemaName === headingSchema.name &&
-      element.uniqueName === uniqueName
-    ) {
+  walkPreSync(contentProse, (element) => {
+    if (isProseElement(element, headingSchema) && element.id === uniqueId) {
       adding = true;
     }
 
@@ -66,11 +64,12 @@ export async function getContentHeadingUnique(
     }
   });
 
-  const mix: ProseElement<typeof mixSchema> = {
-    __JSPROSE_element: true,
-    schemaName: mixSchema.name,
-    children: afterHeadingElements,
-  } as ProseElement<typeof mixSchema>;
+  const mix = makeProseElement({
+    schema: mixSchema,
+    elementHandler: (proseElement) => {
+      proseElement.children = afterHeadingElements;
+    },
+  });
 
   return mix;
 }

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

@@ -1,12 +1,10 @@
-import { isDocument, type AnyDocument } from '@jsprose/core';
+import { isDocument, type Document } from 'tsprose';
 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) {
@@ -16,7 +14,7 @@ export async function resolvePage(pageNode: ContentNavNode) {
 
   try {
     const pageModule = await ERUDIT.import<{
-      content: AnyDocument;
+      content: Document;
       page: PageContentItem;
     }>(ERUDIT.paths.project(`content/${pageNode.contentRelPath}/page`));
 
@@ -30,49 +28,31 @@ export async function resolvePage(pageNode: ContentNavNode) {
 
     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.countElements.flat().includes(rawElement.schemaName)
-        ) {
-          elementsCount[rawElement.schemaName] =
-            (elementsCount[rawElement.schemaName] || 0) + 1;
-        }
-      },
-    );
+    const result = await ERUDIT.repository.prose.fromRaw({
+      rawProse: proseDocument.rawProse,
+      toc: { enabled: true },
+      snippets: { enabled: true },
+    });
 
-    if (resolveResult.tocItems?.length) {
+    if (result.toc?.length) {
       await ERUDIT.db.insert(ERUDIT.db.schema.contentToc).values({
         fullId: pageNode.fullId,
-        toc: resolveResult.tocItems,
+        toc: result.toc,
       });
     }
 
-    for (const [schemaName, count] of Object.entries(elementsCount)) {
-      await ERUDIT.repository.content.addElementCount(
-        pageNode.fullId,
-        schemaName,
-        count,
-      );
-    }
+    await ERUDIT.repository.content.updateSchemaCounts(
+      pageNode.fullId,
+      result.schemaCounts,
+    );
 
     await ERUDIT.db.insert(ERUDIT.db.schema.pages).values({
       fullId: pageNode.fullId,
-      prose: resolveResult.proseElement,
+      prose: result.prose,
     });
 
-    await insertContentResolved(pageNode.fullId, 'page', resolveResult);
+    await insertContentResolved(pageNode.fullId, 'page', result);
   } catch (error) {
     logContentError(pageNode);
     throw error;