erudit 4.1.1 → 4.2.0

package/server/erudit/content/global/build.ts

@@ -9,6 +9,13 @@ let initialBuild = true;
 
 const contentRoot = () => ERUDIT.paths.project('content');
 
+export let builtLinkObject: Record<string, any> | null = null;
+
+/** All valid fully-qualified $CONTENT paths — content items, topic parts,
+ *  public uniques, and internal (underscore) uniques.
+ *  Used for server-side prose link validation. */
+export let builtValidPaths: Set<string> | null = null;
+
 export async function buildGlobalContent() {
   ERUDIT.log.debug.start('Building global content...');
 
@@ -20,7 +27,9 @@ export async function buildGlobalContent() {
     return;
   }
 
-  const linkObject = await buildLinkObject();
+  const { linkObject, validPaths } = await buildLinkObject();
+  builtLinkObject = linkObject;
+  builtValidPaths = validPaths;
 
   const linkTypes = linkObjectToTypes(linkObject);
   writeFileSync(
@@ -51,6 +60,10 @@ function linkObjectToTypes(linkObject: any): string {
     return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase());
   }
 
+  function isValidIdentifier(key: string): boolean {
+    return /^[$_a-zA-Z][$_a-zA-Z0-9]*$/.test(key);
+  }
+
   function processObject(obj: any, level: number): string {
     const lines: string[] = [];
 
@@ -58,6 +71,9 @@ function linkObjectToTypes(linkObject: any): string {
       if (key === '__jsdoc' || key === '__typeguard') continue;
 
       const camelKey = toCamelCase(key);
+      const outputKey = isValidIdentifier(camelKey)
+        ? camelKey
+        : `'${camelKey}'`;
 
       // Add JSDoc comment if present
       if (value && typeof value === 'object' && value.__jsdoc) {
@@ -77,11 +93,11 @@ function linkObjectToTypes(linkObject: any): string {
       const typeguard = value?.__typeguard || 'GlobalContentItemTypeguard';
 
       if (hasNestedProps) {
-        lines.push(indent(level) + `${camelKey}: ${typeguard} & {`);
+        lines.push(indent(level) + `${outputKey}: ${typeguard} & {`);
         lines.push(processObject(value, level + 1));
         lines.push(indent(level) + `}`);
       } else {
-        lines.push(indent(level) + `${camelKey}: ${typeguard} & {}`);
+        lines.push(indent(level) + `${outputKey}: ${typeguard} & {}`);
       }
     }
 
@@ -110,6 +126,7 @@ ${body}
  */
 async function buildLinkObject() {
   const linkTree: any = {};
+  const validPaths = new Set<string>();
 
   await ERUDIT.contentNav.walk((navItem) => {
     // Navigate to the correct position in the tree based on the full path
@@ -118,7 +135,7 @@ async function buildLinkObject() {
 
     // Navigate through parent parts
     for (let i = 0; i < pathParts.length - 1; i++) {
-      cursor = cursor[pathParts[i]];
+      cursor = cursor[pathParts[i]!];
     }
 
     //
@@ -151,6 +168,11 @@ ${jsdoc}
           navItem.contentRelPath,
         ),
       };
+
+      validPaths.add(navItem.fullId);
+      for (const name of getAllUniqueNames(moduleContent)) {
+        validPaths.add(`${navItem.fullId}/$${name}`);
+      }
     } else if (navItem.type === 'topic') {
       const pathToTopicFile = ERUDIT.paths.project(
         `content/${navItem.contentRelPath}/topic.ts`,
@@ -173,6 +195,8 @@ ${jsdoc}
                 `.trim(),
       };
 
+      validPaths.add(navItem.fullId);
+
       for (const part of topicParts) {
         try {
           const pathToFile = ERUDIT.paths.project(
@@ -200,6 +224,11 @@ ${jsdoc}
               navItem.contentRelPath,
             ),
           };
+
+          validPaths.add(`${navItem.fullId}/${part}`);
+          for (const name of getAllUniqueNames(partContent)) {
+            validPaths.add(`${navItem.fullId}/${part}/$${name}`);
+          }
         } catch {}
       }
     } else {
@@ -223,17 +252,19 @@ ${jsdoc}
  */
                 `.trim(),
       };
+
+      validPaths.add(navItem.fullId);
     }
   });
 
-  return linkTree;
+  return { linkObject: linkTree, validPaths };
 }
 
 function tryGetTitle(moduleContent: string) {
-  const titleMatch = moduleContent.match(/title:\s*['"`](.*?)['"`]/);
+  const titleMatch = moduleContent.match(/title:\s*(['"`])(.*?)\1/);
 
   if (titleMatch) {
-    return titleMatch[1].trim();
+    return titleMatch[2]!.trim();
   }
 }
 
@@ -244,6 +275,25 @@ function jsdocLines(lines: any[]) {
     .join('\n');
 }
 
+/** Returns ALL unique names from a module — both public and internal. Used to
+ *  populate builtValidPaths for server-side prose link validation. */
+function getAllUniqueNames(moduleContent: string): string[] {
+  const uniquesMatch = moduleContent.match(/uniques:\s*\{([^}]*)\}/s);
+  if (!uniquesMatch) return [];
+
+  const names: string[] = [];
+  for (const line of uniquesMatch[1]!.split('\n')) {
+    if (line.trim().startsWith('//')) continue;
+
+    const pairMatch =
+      line.match(/\[['"](.*?)['"]\]:\s*(\w+)/) ||
+      line.match(/['"](.*?)['"]:\s*(\w+)/) ||
+      line.match(/(\w+):\s*(\w+)/);
+    if (pairMatch) names.push(pairMatch[1]!);
+  }
+  return names;
+}
+
 function tryGetUniquesObject(
   moduleContent: string,
   pathToFile: string,
@@ -259,7 +309,7 @@ function tryGetUniquesObject(
   const uniquesContent = uniquesMatch[1];
 
   // Parse key-value pairs from uniques object
-  const lines = uniquesContent.split('\n');
+  const lines = uniquesContent!.split('\n');
   const result: any = {};
 
   for (const line of lines) {
@@ -268,12 +318,16 @@ function tryGetUniquesObject(
       continue;
     }
 
-    // Skip uniques starting with underscore
+    // Skip uniques starting with underscore (internal — excluded from $CONTENT types)
     if (line.trim().startsWith('_')) {
       continue;
     }
 
-    const pairMatch = line.match(/(\w+):\s*(\w+)/);
+    // Support bracket notation ['any string'], quoted keys "any string" / 'any string', and plain identifiers
+    const pairMatch =
+      line.match(/\[['"](.*?)['"]\]:\s*(\w+)/) ||
+      line.match(/['"](.*?)['"]:\s*(\w+)/) ||
+      line.match(/(\w+):\s*(\w+)/);
     if (!pairMatch) {
       continue;
     }

package/server/erudit/content/nav/build.ts

@@ -216,16 +216,16 @@ function parseContentPath(relPath: string):
 
   for (let i = 0; i < parts.length; i++) {
     const part = parts[i];
-    const typeDelimiterPos = part.search(/[+-]/);
+    const typeDelimiterPos = part!.search(/[+-]/);
     if (typeDelimiterPos <= 0) return;
 
-    const posStr = part.slice(0, typeDelimiterPos);
+    const posStr = part!.slice(0, typeDelimiterPos);
     if (!/^\d+$/.test(posStr)) return;
     const posNum = Number(posStr);
 
-    const typeDelimiter = part.charAt(typeDelimiterPos);
+    const typeDelimiter = part!.charAt(typeDelimiterPos);
     skip = typeDelimiter === '+';
-    idPart = part.slice(typeDelimiterPos + 1);
+    idPart = part!.slice(typeDelimiterPos + 1);
     if (!idPart) return;
 
     fullId += `/${idPart}`;

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

@@ -24,7 +24,7 @@ export async function getContentChildren(
     const elementSnippets = await ERUDIT.repository.content.elementSnippets(
       childNode.fullId,
     );
-    const quickLinks = elementSnippets?.filter((snippet) => snippet.quick);
+    const keyLinks = elementSnippets?.filter((snippet) => snippet.key);
     const stats = await ERUDIT.repository.content.stats(childNode.fullId);
 
     const child: MainContentChildrenItem = {
@@ -37,8 +37,8 @@ export async function getContentChildren(
       child.description = description;
     }
 
-    if (quickLinks && quickLinks.length > 0) {
-      child.quickLinks = quickLinks;
+    if (keyLinks && keyLinks.length > 0) {
+      child.keyLinks = keyLinks;
     }
 
     if (stats) {

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,69 @@ 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, contentProseType: true },
+        where: and(
+          eq(ERUDIT.db.schema.contentUniques.contentFullId, contentFullId),
+          eq(ERUDIT.db.schema.contentUniques.uniqueName, uniqueName),
+        ),
+      });
+
+      if (!dbUnique) return null;
+
+      const navNode = ERUDIT.contentNav.getNodeOrThrow(contentFullId);
+      const schemaName = dbUnique.prose.schema.name;
+
+      if (!schemaName) return null;
+
+      const link =
+        navNode.type === 'topic'
+          ? PAGES.topic(
+              dbUnique.contentProseType as any,
+              navNode.shortId,
+              dbUnique.prose.id,
+            )
+          : PAGES.page(navNode.shortId, dbUnique.prose.id);
+
+      return {
+        name: uniqueName,
+        title: dbUnique.title ?? undefined,
+        link,
+        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;
 }