erudit 4.0.0-dev.4 → 4.0.0

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

@@ -1,97 +1,97 @@
-import { and, eq, sql } from 'drizzle-orm';
-
-export async function addContentElementCount(
-    fullId: string,
-    schemaName: string,
-    amount: number,
-): Promise<void> {
-    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(
-    fullContentId?: string,
-): Promise<ContentStats | undefined> {
-    const stats: ContentStats = {};
-
-    const rootNavNode = fullContentId
-        ? ERUDIT.contentNav.getNodeOrThrow(fullContentId)
-        : ({
-              type: '_root',
-              children: Array.from(ERUDIT.contentNav.id2Root.values()),
-          } as const);
-
-    if (rootNavNode.type !== 'topic' && rootNavNode.type !== 'page') {
-        // Container node, so look for materials inside it
-        let materialCount = 0;
-        await ERUDIT.contentNav.walk((navNode) => {
-            if (navNode.type === 'topic' || navNode.type === 'page') {
-                materialCount++;
-            }
-        }, rootNavNode as any);
-
-        if (materialCount > 0) {
-            stats.materials = materialCount;
-        }
-    }
-
-    const schema2Count: Record<string, number> = {};
-
-    const rows = await ERUDIT.db.query.contentElementStats.findMany({
-        where: fullContentId
-            ? sql`${ERUDIT.db.schema.contentElementStats.fullId} = ${fullContentId} OR ${ERUDIT.db.schema.contentElementStats.fullId} LIKE ${fullContentId + '/%'}`
-            : sql`1=1`,
-    });
-
-    for (const row of rows) {
-        if (row.count > 0) {
-            schema2Count[row.schemaName] =
-                (schema2Count[row.schemaName] || 0) + row.count;
-        }
-    }
-
-    // Possible merge arrays of schema names into single stats entry
-    const actualElementStats = ERUDIT.config.project.countElements.reduce<
-        Record<string, number>
-    >((acc, current) => {
-        if (Array.isArray(current)) {
-            const firstKey = current[0]!;
-            const sum = current.reduce((sum, name) => {
-                return sum + (schema2Count[name] || 0);
-            }, 0);
-            if (sum > 0) {
-                acc[firstKey] = sum;
-            }
-        } else {
-            const count = schema2Count[current] || 0;
-            if (count > 0) {
-                acc[current] = count;
-            }
-        }
-        return acc;
-    }, {});
-
-    if (Object.keys(actualElementStats).length > 0) {
-        stats.elements = actualElementStats;
-    }
-
-    return Object.keys(stats).length > 0 ? stats : undefined;
-}
+import { and, eq, sql } from 'drizzle-orm';
+
+export async function addContentElementCount(
+  fullId: string,
+  schemaName: string,
+  amount: number,
+): Promise<void> {
+  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(
+  fullContentId?: string,
+): Promise<ContentStats | undefined> {
+  const stats: ContentStats = {};
+
+  const rootNavNode = fullContentId
+    ? ERUDIT.contentNav.getNodeOrThrow(fullContentId)
+    : ({
+        type: '_root',
+        children: Array.from(ERUDIT.contentNav.id2Root.values()),
+      } as const);
+
+  if (rootNavNode.type !== 'topic' && rootNavNode.type !== 'page') {
+    // Container node, so look for materials inside it
+    let materialCount = 0;
+    await ERUDIT.contentNav.walk((navNode) => {
+      if (navNode.type === 'topic' || navNode.type === 'page') {
+        materialCount++;
+      }
+    }, rootNavNode as any);
+
+    if (materialCount > 0) {
+      stats.materials = materialCount;
+    }
+  }
+
+  const schema2Count: Record<string, number> = {};
+
+  const rows = await ERUDIT.db.query.contentElementStats.findMany({
+    where: fullContentId
+      ? sql`${ERUDIT.db.schema.contentElementStats.fullId} = ${fullContentId} OR ${ERUDIT.db.schema.contentElementStats.fullId} LIKE ${fullContentId + '/%'}`
+      : sql`1=1`,
+  });
+
+  for (const row of rows) {
+    if (row.count > 0) {
+      schema2Count[row.schemaName] =
+        (schema2Count[row.schemaName] || 0) + row.count;
+    }
+  }
+
+  // Possible merge arrays of schema names into single stats entry
+  const actualElementStats = ERUDIT.config.countElements.reduce<
+    Record<string, number>
+  >((acc, current) => {
+    if (Array.isArray(current)) {
+      const firstKey = current[0]!;
+      const sum = current.reduce((sum, name) => {
+        return sum + (schema2Count[name] || 0);
+      }, 0);
+      if (sum > 0) {
+        acc[firstKey] = sum;
+      }
+    } else {
+      const count = schema2Count[current] || 0;
+      if (count > 0) {
+        acc[current] = count;
+      }
+    }
+    return acc;
+  }, {});
+
+  if (Object.keys(actualElementStats).length > 0) {
+    stats.elements = actualElementStats;
+  }
+
+  return Object.keys(stats).length > 0 ? stats : undefined;
+}

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

@@ -1,27 +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()!;
-}
+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

@@ -1,39 +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];
-}
+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

@@ -1,76 +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;
-}
+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

@@ -1,32 +1,29 @@
-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;
-    }
-}
+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.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

@@ -1,39 +1,34 @@
-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;
-    }
-}
+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.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;
+  }
+}