erudit 4.0.0-dev.3 → 4.0.0-dev.5

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

@@ -1,10 +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)}`,
-    );
-}
+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.paths.project(`content/${contentNode.contentRelPath}`))}`,
+  );
+}

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

@@ -1,122 +1,113 @@
-import { globSync } from 'glob';
-import { isContentItem, type ContentItem } from '@erudit-js/core/content/item';
-import {
-    getGlobalContentPath,
-    type GlobalContentItem,
-} from '@erudit-js/core/content/global';
-
-import type { ContentNavNode } from '../../nav/types';
-import type { TopicContentItem } from '@erudit-js/core/content/topic';
-import type { PageContentItem } from '@erudit-js/core/content/page';
-
-export async function insertContentItem(
-    navNode: ContentNavNode,
-    contentItem: ContentItem,
-) {
-    if (
-        isContentItem<TopicContentItem>(contentItem, 'topic') ||
-        isContentItem<PageContentItem>(contentItem, 'page')
-    ) {
-        await resolveContributions(navNode.fullId, contentItem);
-    }
-
-    const decorationExtension = await resolveDecorationExtension(navNode);
-    await resolveHardDependencies(navNode.fullId, contentItem);
-
-    await ERUDIT.db.insert(ERUDIT.db.schema.content).values({
-        fullId: navNode.fullId,
-        type: navNode.type,
-        title: contentItem.title || navNode.fullId.split('/').pop()!,
-        navTitle: contentItem.navTitle,
-        description: contentItem.description,
-        hidden: Boolean(contentItem.hidden) || false,
-        flags: contentItem.flags,
-        decorationExtension,
-        externals: contentItem.externals,
-        seo: contentItem.seo,
-    });
-}
-
-async function resolveContributions(
-    fullId: string,
-    contentItem: TopicContentItem | PageContentItem,
-) {
-    if (contentItem.contributions) {
-        const seenContributors = new Set<string>();
-
-        for (const contribution of contentItem.contributions as any) {
-            const contributorId: string =
-                typeof contribution === 'string'
-                    ? contribution
-                    : contribution.contributor;
-
-            const description: string | undefined =
-                typeof contribution === 'string'
-                    ? undefined
-                    : contribution.description;
-
-            if (seenContributors.has(contributorId)) {
-                ERUDIT.log.warn(
-                    `Duplicate contributor "${contributorId}" in content item "${fullId}"!`,
-                );
-                continue;
-            }
-
-            seenContributors.add(contributorId);
-
-            await ERUDIT.db
-                .insert(ERUDIT.db.schema.contentContributions)
-                .values({
-                    contentFullId: fullId,
-                    contributorId,
-                    description,
-                });
-        }
-    }
-}
-
-async function resolveHardDependencies(
-    fullId: string,
-    contentItem: ContentItem,
-) {
-    if (contentItem.dependencies) {
-        for (const dependency of contentItem.dependencies) {
-            await ERUDIT.db.insert(ERUDIT.db.schema.contentDeps).values({
-                fromFullId: getGlobalContentPath(
-                    dependency.dependency as any as GlobalContentItem,
-                ),
-                toFullId: fullId,
-                hard: true,
-                reason: dependency.reason,
-            });
-        }
-    }
-}
-
-async function resolveDecorationExtension(navNode: ContentNavNode) {
-    const decorationExtension = globSync(
-        ERUDIT.config.paths.project +
-            '/content/' +
-            navNode.contentRelPath +
-            '/decoration.*',
-        {
-            posix: true,
-        },
-    )
-        .shift()
-        ?.split('.')
-        ?.pop();
-
-    if (decorationExtension) {
-        await ERUDIT.repository.db.pushFile(
-            ERUDIT.config.paths.project +
-                '/content/' +
-                navNode.contentRelPath +
-                '/decoration.' +
-                decorationExtension,
-            'content-decoration:' + navNode.fullId,
-        );
-    }
-
-    return decorationExtension;
-}
+import { globSync } from 'glob';
+import { isContentItem, type ContentItem } from '@erudit-js/core/content/item';
+import {
+  getGlobalContentPath,
+  type GlobalContentItem,
+} from '@erudit-js/core/content/global';
+
+import type { ContentNavNode } from '../../nav/types';
+import type { TopicContentItem } from '@erudit-js/core/content/topic';
+import type { PageContentItem } from '@erudit-js/core/content/page';
+
+export async function insertContentItem(
+  navNode: ContentNavNode,
+  contentItem: ContentItem,
+) {
+  if (
+    isContentItem<TopicContentItem>(contentItem, 'topic') ||
+    isContentItem<PageContentItem>(contentItem, 'page')
+  ) {
+    await resolveContributions(navNode.fullId, contentItem);
+  }
+
+  const decorationExtension = await resolveDecorationExtension(navNode);
+  await resolveHardDependencies(navNode.fullId, contentItem);
+
+  await ERUDIT.db.insert(ERUDIT.db.schema.content).values({
+    fullId: navNode.fullId,
+    type: navNode.type,
+    title: contentItem.title || navNode.fullId.split('/').pop()!,
+    navTitle: contentItem.navTitle,
+    description: contentItem.description,
+    hidden: Boolean(contentItem.hidden) || false,
+    flags: contentItem.flags,
+    decorationExtension,
+    externals: contentItem.externals,
+    seo: contentItem.seo,
+  });
+}
+
+async function resolveContributions(
+  fullId: string,
+  contentItem: TopicContentItem | PageContentItem,
+) {
+  if (contentItem.contributions) {
+    const seenContributors = new Set<string>();
+
+    for (const contribution of contentItem.contributions as any) {
+      const contributorId: string =
+        typeof contribution === 'string'
+          ? contribution
+          : contribution.contributor;
+
+      const description: string | undefined =
+        typeof contribution === 'string' ? undefined : contribution.description;
+
+      if (seenContributors.has(contributorId)) {
+        ERUDIT.log.warn(
+          `Duplicate contributor "${contributorId}" in content item "${fullId}"!`,
+        );
+        continue;
+      }
+
+      seenContributors.add(contributorId);
+
+      await ERUDIT.db.insert(ERUDIT.db.schema.contentContributions).values({
+        contentFullId: fullId,
+        contributorId,
+        description,
+      });
+    }
+  }
+}
+
+async function resolveHardDependencies(
+  fullId: string,
+  contentItem: ContentItem,
+) {
+  if (contentItem.dependencies) {
+    for (const dependency of contentItem.dependencies) {
+      await ERUDIT.db.insert(ERUDIT.db.schema.contentDeps).values({
+        fromFullId: getGlobalContentPath(
+          dependency.dependency as any as GlobalContentItem,
+        ),
+        toFullId: fullId,
+        hard: true,
+        reason: dependency.reason,
+      });
+    }
+  }
+}
+
+async function resolveDecorationExtension(navNode: ContentNavNode) {
+  const decorationExtension = globSync(
+    ERUDIT.paths.project(`content/${navNode.contentRelPath}/decoration.*`),
+    {
+      posix: true,
+    },
+  )
+    .shift()
+    ?.split('.')
+    ?.pop();
+
+  if (decorationExtension) {
+    await ERUDIT.repository.db.pushFile(
+      ERUDIT.paths.project(
+        `content/${navNode.contentRelPath}/decoration.${decorationExtension}`,
+      ),
+      'content-decoration:' + navNode.fullId,
+    );
+  }
+
+  return decorationExtension;
+}

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

@@ -1,132 +1,126 @@
-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,
-    contentProseType: ContentProseType,
-    resolveResult: ResolvedRawElement & ResolvedEruditRawElement,
-) {
-    for (const file of resolveResult.files) {
-        await ERUDIT.repository.db.pushFile(
-            file,
-            `content-item:${contentFullId}`,
-        );
-    }
-
-    for (const [uniqueName, unique] of Object.entries(resolveResult.uniques)) {
-        await ERUDIT.db.insert(ERUDIT.db.schema.contentUniques).values({
-            contentFullId,
-            contentProseType,
-            uniqueName,
-            title: resolveResult.uniqueTitles[uniqueName],
-            prose: unique,
-        });
-    }
-
-    for (const snippet of resolveResult.snippets) {
-        await ERUDIT.db.insert(ERUDIT.db.schema.contentSnippets).values({
-            contentFullId,
-            contentProseType,
-            elementId: snippet.elementId,
-            schemaName: snippet.schemaName,
-            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,
-            contentFullId,
-        );
-    }
-
-    const fromFullIds = new Set(
-        Array.from(resolveResult.dependencies)
-            .map((dependency) => {
-                if (dependency.startsWith('<link:')) {
-                    const navNode = globalContentToNavNode(
-                        dependency.replace(/^<link:.+>\//, ''),
-                    );
-                    return navNode.fullId;
-                }
-            })
-            .filter((id): id is string => id !== undefined),
-    );
-
-    const contentDeps = Array.from(fromFullIds)
-        .filter((fromFullId) => fromFullId !== contentFullId)
-        .map((fromFullId) => ({
-            fromFullId,
-            toFullId: contentFullId,
-            hard: false,
-        }));
-
-    if (contentDeps.length > 0) {
-        await ERUDIT.db
-            .insert(ERUDIT.db.schema.contentDeps)
-            .values(contentDeps)
-            .onConflictDoNothing();
-    }
-}
-
-function globalContentToNavNode(globalContentPath: string) {
-    const parts = globalContentPath.split('/');
-
-    if (parts.at(-1)?.startsWith('$')) {
-        parts.pop();
-    }
-
-    const navNode =
-        ERUDIT.contentNav.getNode(parts.join('/')) ??
-        ERUDIT.contentNav.getNodeOrThrow(parts.slice(0, -1).join('/'));
-
-    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
-    );
-  `);
-}
+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,
+  contentProseType: ContentProseType,
+  resolveResult: ResolvedRawElement & ResolvedEruditRawElement,
+) {
+  for (const file of resolveResult.files) {
+    await ERUDIT.repository.db.pushFile(file, `content-item:${contentFullId}`);
+  }
+
+  for (const [uniqueName, unique] of Object.entries(resolveResult.uniques)) {
+    await ERUDIT.db.insert(ERUDIT.db.schema.contentUniques).values({
+      contentFullId,
+      contentProseType,
+      uniqueName,
+      title: resolveResult.uniqueTitles[uniqueName],
+      prose: unique,
+    });
+  }
+
+  for (const snippet of resolveResult.snippets) {
+    await ERUDIT.db.insert(ERUDIT.db.schema.contentSnippets).values({
+      contentFullId,
+      contentProseType,
+      elementId: snippet.elementId,
+      schemaName: snippet.schemaName,
+      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, contentFullId);
+  }
+
+  const fromFullIds = new Set(
+    Array.from(resolveResult.dependencies)
+      .map((dependency) => {
+        if (dependency.startsWith('<link:')) {
+          const navNode = globalContentToNavNode(
+            dependency.replace(/^<link:.+>\//, ''),
+          );
+          return navNode.fullId;
+        }
+      })
+      .filter((id): id is string => id !== undefined),
+  );
+
+  const contentDeps = Array.from(fromFullIds)
+    .filter((fromFullId) => fromFullId !== contentFullId)
+    .map((fromFullId) => ({
+      fromFullId,
+      toFullId: contentFullId,
+      hard: false,
+    }));
+
+  if (contentDeps.length > 0) {
+    await ERUDIT.db
+      .insert(ERUDIT.db.schema.contentDeps)
+      .values(contentDeps)
+      .onConflictDoNothing();
+  }
+}
+
+function globalContentToNavNode(globalContentPath: string) {
+  const parts = globalContentPath.split('/');
+
+  if (parts.at(-1)?.startsWith('$')) {
+    parts.pop();
+  }
+
+  const navNode =
+    ERUDIT.contentNav.getNode(parts.join('/')) ??
+    ERUDIT.contentNav.getNodeOrThrow(parts.slice(0, -1).join('/'));
+
+  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
+    );
+  `);
+}