erudit 3.0.0-dev.9 → 4.0.0-dev.1

package/server/erudit/content/nav/repository/previousNext.ts

@@ -0,0 +1,35 @@
+import type { ContentNavNode } from '../types';
+
+export function getPreviousNext(node: ContentNavNode) {
+    const currentFullId = node.fullId;
+
+    let previous: ContentNavNode | undefined;
+    let next: ContentNavNode | undefined;
+    let currentFound = false;
+
+    for (const navNode of ERUDIT.contentNav.id2Node.values()) {
+        if (currentFound) {
+            next = navNode;
+            break;
+        }
+
+        if (navNode.fullId === currentFullId) {
+            currentFound = true;
+        } else {
+            previous = navNode;
+        }
+    }
+
+    // If current inside book then next can't point outside of book
+    if (next) {
+        const currentBook = ERUDIT.contentNav.getBookFor(node);
+        if (currentBook) {
+            const nextBook = ERUDIT.contentNav.getBookFor(next);
+            if (!nextBook || nextBook.fullId !== currentBook.fullId) {
+                next = undefined;
+            }
+        }
+    }
+
+    return { previous, next };
+}

package/server/erudit/content/nav/repository/walk.ts

@@ -0,0 +1,127 @@
+import type { ContentNavNode } from '../types';
+
+export enum WalkStop {
+    NoDeeper,
+    Exit,
+}
+
+type WalkStepReturnSync = void | WalkStop;
+type WalkStepReturn = WalkStepReturnSync | Promise<WalkStepReturnSync>;
+
+function shouldExit(result: WalkStepReturnSync): boolean {
+    return result === WalkStop.Exit;
+}
+
+function shouldSkipChildren(result: WalkStepReturnSync): boolean {
+    return result === WalkStop.NoDeeper;
+}
+
+function getRoots() {
+    return ERUDIT.contentNav.id2Root.values();
+}
+
+function hasChildren(node: ContentNavNode): boolean {
+    return ERUDIT.contentNav.hasChildren(node);
+}
+
+export function walkSync(
+    step: (node: ContentNavNode) => WalkStepReturnSync,
+    from?: ContentNavNode,
+) {
+    function _walk(node: ContentNavNode): boolean {
+        const stepResult = step(node);
+
+        if (shouldExit(stepResult)) {
+            return true;
+        }
+
+        if (!shouldSkipChildren(stepResult) && hasChildren(node)) {
+            for (const child of node.children!) {
+                if (_walk(child)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    if (!from) {
+        for (const root of getRoots()) {
+            if (_walk(root)) {
+                break;
+            }
+        }
+        return;
+    }
+
+    _walk(from);
+}
+
+export async function walk(
+    step: (node: ContentNavNode) => WalkStepReturn,
+    from?: ContentNavNode,
+) {
+    async function _walk(node: ContentNavNode): Promise<boolean> {
+        const stepResult = await step(node);
+
+        if (shouldExit(stepResult)) {
+            return true;
+        }
+
+        if (!shouldSkipChildren(stepResult) && hasChildren(node)) {
+            for (const child of node.children!) {
+                if (await _walk(child)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    if (!from) {
+        for (const root of getRoots()) {
+            if (await _walk(root)) {
+                break;
+            }
+        }
+        return;
+    }
+
+    await _walk(from);
+}
+
+export function walkUpSync(
+    step: (node: ContentNavNode) => void | false,
+    from: ContentNavNode,
+) {
+    let cursor: ContentNavNode | undefined = from;
+
+    while (cursor) {
+        const result = step(cursor);
+
+        if (result === false) {
+            return;
+        }
+
+        cursor = cursor.parent;
+    }
+}
+
+export async function walkUp(
+    step: (node: ContentNavNode) => Promise<void | false> | void | false,
+    from: ContentNavNode,
+) {
+    let cursor: ContentNavNode | undefined = from;
+
+    while (cursor) {
+        const result = await step(cursor);
+
+        if (result === false) {
+            return;
+        }
+
+        cursor = cursor.parent;
+    }
+}

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

@@ -0,0 +1,13 @@
+import * as repository from './repository';
+
+export async function setupServerContentNav() {
+    ERUDIT.contentNav = {
+        id2Node: new Map(),
+        id2Books: new Map(),
+        id2Root: new Map(),
+        short2Full: new Map(),
+        ...repository,
+    };
+
+    ERUDIT.log.success('Content navigation setup complete!');
+}

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

@@ -0,0 +1,24 @@
+import type { ContentType } from '@erudit-js/core/content/type';
+import * as repository from './repository';
+
+export type ContentNavMap = Map<string, ContentNavNode>;
+export type Id2Id = Map<string, string>;
+
+export type EruditServerContentNav = {
+    id2Node: ContentNavMap;
+    id2Root: ContentNavMap;
+    id2Books: ContentNavMap;
+    short2Full: Id2Id;
+} & typeof repository;
+
+export interface ContentNavNode {
+    idPart: string;
+    fullId: string;
+    shortId: string;
+    contentRelPath: string;
+    position: number;
+    skip: boolean;
+    type: ContentType;
+    parent?: ContentNavNode;
+    children?: ContentNavNode[];
+}

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

@@ -0,0 +1,24 @@
+import { eq } from 'drizzle-orm';
+
+export async function getContentBreadcrumbs(fullId: string) {
+    const breadcrumbs: Breadcrumbs = [];
+
+    const navNode = ERUDIT.contentNav.getNodeOrThrow(fullId);
+    await ERUDIT.contentNav.walkUp(async (stepNode) => {
+        const dbContent = (await ERUDIT.db.query.content.findFirst({
+            columns: {
+                title: true,
+                navTitle: true,
+            },
+            where: eq(ERUDIT.db.schema.content.fullId, stepNode.fullId),
+        }))!;
+
+        breadcrumbs.push({
+            icon: ICONS[stepNode.type],
+            title: dbContent.navTitle ?? dbContent.title,
+            link: await ERUDIT.repository.content.link(stepNode.fullId),
+        });
+    }, navNode);
+
+    return breadcrumbs.slice(1).reverse();
+}

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

@@ -0,0 +1,47 @@
+import { getContentDescription } from './description';
+
+export async function getContentChildren(
+    fullContentId?: string,
+): Promise<MainContentChildrenItem[]> {
+    const navNode = fullContentId
+        ? ERUDIT.contentNav.getNodeOrThrow(fullContentId)
+        : { children: Array.from(ERUDIT.contentNav.id2Root.values()) };
+    const children: MainContentChildrenItem[] = [];
+
+    for (const childNode of navNode.children ?? []) {
+        const type = childNode.type;
+        const link = await ERUDIT.repository.content.link(childNode.fullId);
+        const title = await ERUDIT.repository.content.title(
+            childNode.fullId,
+            'nav',
+        );
+        const description = await getContentDescription(childNode.fullId);
+        const elementSnippets = await ERUDIT.repository.content.elementSnippets(
+            childNode.fullId,
+        );
+        const quickLinks = elementSnippets?.filter((snippet) => snippet.quick);
+        const stats = await ERUDIT.repository.content.stats(childNode.fullId);
+
+        const child: MainContentChildrenItem = {
+            type,
+            link,
+            title,
+        };
+
+        if (description) {
+            child.description = description;
+        }
+
+        if (quickLinks && quickLinks.length > 0) {
+            child.quickLinks = quickLinks;
+        }
+
+        if (stats) {
+            child.stats = stats;
+        }
+
+        children.push(child);
+    }
+
+    return children;
+}

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

@@ -0,0 +1,35 @@
+import { getContentDependencies, getContentDependents } from './deps';
+import { getContentExternals } from './externals';
+
+export async function getContentConnections(
+    fullId: string,
+): Promise<ContentConnections | undefined> {
+    const { hardDependencies, autoDependencies } =
+        await getContentDependencies(fullId);
+    const dependents = await getContentDependents(fullId);
+    const externals = await getContentExternals(fullId);
+
+    const connections: ContentConnections = {};
+
+    if (hardDependencies.length > 0) {
+        connections.hardDependencies = hardDependencies;
+    }
+
+    if (autoDependencies.length > 0) {
+        connections.autoDependencies = autoDependencies;
+    }
+
+    if (dependents.length > 0) {
+        connections.dependents = dependents;
+    }
+
+    if (externals.length > 0) {
+        connections.externals = externals;
+    }
+
+    if (Object.keys(connections).length === 0) {
+        return undefined;
+    }
+
+    return connections;
+}

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

@@ -0,0 +1,16 @@
+import { getDefaultTopicPart, getTopicParts } from './topicParts';
+
+export async function getContentLink(fullId: string): Promise<string> {
+    const navNode = ERUDIT.contentNav.getNodeOrThrow(fullId);
+
+    switch (navNode.type) {
+        case 'book':
+        case 'group':
+        case 'page':
+            return PAGES[navNode.type](navNode.shortId);
+    }
+
+    const defaultTopicPart = await getDefaultTopicPart(fullId);
+
+    return PAGES.topic(defaultTopicPart, navNode.shortId);
+}

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

@@ -0,0 +1,23 @@
+import { eq } from 'drizzle-orm';
+
+export async function getContentDecoration(fullId: string) {
+    const parts = fullId.split('/');
+    for (let i = parts.length; i > 0; i--) {
+        const trimmedId = parts.slice(0, i).join('/');
+
+        const dbContent = await ERUDIT.db.query.content.findFirst({
+            columns: { decorationExtension: true },
+            where: eq(ERUDIT.db.schema.content.fullId, trimmedId),
+        });
+
+        if (dbContent?.decorationExtension) {
+            const navNode = ERUDIT.contentNav.getNodeOrThrow(trimmedId);
+            return (
+                'content/' +
+                navNode.contentRelPath +
+                '/decoration.' +
+                dbContent.decorationExtension
+            );
+        }
+    }
+}

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

@@ -0,0 +1,84 @@
+import { eq, like, or } from 'drizzle-orm';
+
+export async function getContentDependencies(fullId: string): Promise<{
+    hardDependencies: ContentHardDep[];
+    autoDependencies: ContentAutoDep[];
+}> {
+    const hardDependencies: ContentHardDep[] = [];
+    const autoDependencies: ContentAutoDep[] = [];
+
+    const dbContents = await ERUDIT.db.query.contentDeps.findMany({
+        columns: { fromFullId: true, toFullId: true, hard: true, reason: true },
+        where: or(
+            eq(ERUDIT.db.schema.contentDeps.toFullId, fullId),
+            like(ERUDIT.db.schema.contentDeps.toFullId, `${fullId}/%`),
+        ),
+    });
+
+    for (const dbContent of dbContents) {
+        // Skip child-only self-references
+        const isToChild = dbContent.toFullId.startsWith(`${fullId}/`);
+        const isFromChild = dbContent.fromFullId.startsWith(`${fullId}/`);
+        if (isToChild && isFromChild) {
+            continue;
+        }
+
+        const dep = await getContentAutoDep(dbContent.fromFullId);
+
+        if (dbContent.hard && fullId === dbContent.toFullId) {
+            hardDependencies.push({
+                ...dep,
+                type: 'hard',
+                reason: dbContent.reason!,
+            });
+        } else {
+            autoDependencies.push(dep);
+        }
+    }
+
+    return { hardDependencies, autoDependencies };
+}
+
+export async function getContentDependents(
+    fullId: string,
+): Promise<ContentAutoDep[]> {
+    const dependents: ContentAutoDep[] = [];
+
+    const dbContents = await ERUDIT.db.query.contentDeps.findMany({
+        columns: { fromFullId: true, toFullId: true },
+        where: or(
+            eq(ERUDIT.db.schema.contentDeps.fromFullId, fullId),
+            like(ERUDIT.db.schema.contentDeps.fromFullId, `${fullId}/%`),
+        ),
+    });
+
+    for (const dbContent of dbContents) {
+        // Skip child-only self-references
+        const isFromChild = dbContent.fromFullId.startsWith(`${fullId}/`);
+        const isToChild = dbContent.toFullId.startsWith(`${fullId}/`);
+        if (isFromChild && isToChild) {
+            continue;
+        }
+
+        const dep = await getContentAutoDep(dbContent.toFullId);
+        dependents.push(dep);
+    }
+
+    return dependents;
+}
+
+export async function getContentAutoDep(
+    fullId: string,
+): Promise<ContentAutoDep> {
+    const navNode = ERUDIT.contentNav.getNodeOrThrow(fullId);
+    const contentType = navNode.type;
+    const title = await ERUDIT.repository.content.title(fullId);
+    const link = await ERUDIT.repository.content.link(fullId);
+
+    return {
+        type: 'auto',
+        contentType,
+        title,
+        link,
+    };
+}

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

@@ -0,0 +1,11 @@
+import { eq } from 'drizzle-orm';
+
+export async function getContentDescription(
+    fullContentId: string,
+): Promise<string | undefined> {
+    const dbContentItem = (await ERUDIT.db.query.content.findFirst({
+        where: eq(ERUDIT.db.schema.content.fullId, fullContentId),
+    }))!;
+
+    return dbContentItem.description || undefined;
+}

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

@@ -0,0 +1,65 @@
+import { and, asc, eq, or } from 'drizzle-orm';
+
+export async function getContentElementSnippets(
+    fullId: string,
+): Promise<ElementSnippet[] | undefined> {
+    const snippets: ElementSnippet[] = [];
+
+    const dbSnippets = await ERUDIT.db.query.contentSnippets.findMany({
+        columns: {
+            contentProseType: true,
+            schemaName: true,
+            elementId: true,
+            title: true,
+            description: true,
+            quick: true,
+            seo: true,
+        },
+        where: and(
+            eq(ERUDIT.db.schema.contentSnippets.contentFullId, fullId),
+            or(
+                eq(ERUDIT.db.schema.contentSnippets.quick, true),
+                eq(ERUDIT.db.schema.contentSnippets.seo, true),
+            ),
+        ),
+        orderBy: (snippets) => asc(snippets.snippetId),
+    });
+
+    const navNode = ERUDIT.contentNav.getNodeOrThrow(fullId);
+
+    for (const dbSnippet of dbSnippets) {
+        const link = (() => {
+            if (dbSnippet.contentProseType === 'page') {
+                return PAGES.page(navNode.shortId, dbSnippet.elementId);
+            }
+
+            return PAGES.topic(
+                dbSnippet.contentProseType,
+                navNode.shortId,
+                dbSnippet.elementId,
+            );
+        })();
+
+        const snippet: ElementSnippet = {
+            link,
+            schemaName: dbSnippet.schemaName,
+            title: dbSnippet.title,
+        };
+
+        if (dbSnippet.quick) {
+            snippet.quick = true;
+        }
+
+        if (dbSnippet.seo) {
+            snippet.seo = true;
+        }
+
+        if (dbSnippet.description) {
+            snippet.description = dbSnippet.description;
+        }
+
+        snippets.push(snippet);
+    }
+
+    return snippets.length > 0 ? snippets : undefined;
+}

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

@@ -0,0 +1,21 @@
+import type { ContentExternal } from '@erudit-js/core/content/externals';
+import { eq } from 'drizzle-orm';
+
+export async function getContentExternals(
+    fullId: string,
+): Promise<ContentExternal[]> {
+    const externals: ContentExternal[] = [];
+
+    const dbContentItems = await ERUDIT.db.query.content.findMany({
+        columns: { fullId: true, type: true, externals: true },
+        where: eq(ERUDIT.db.schema.content.fullId, fullId),
+    });
+
+    for (const dbContentItem of dbContentItems) {
+        if (dbContentItem?.externals) {
+            externals.push(...dbContentItem.externals);
+        }
+    }
+
+    return externals;
+}

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

@@ -0,0 +1,33 @@
+import { eq } from 'drizzle-orm';
+import type { ContentFlags } from '@erudit-js/core/content/flags';
+
+export async function getContentFlags(
+    fullId: string,
+): Promise<ContentFlags | undefined> {
+    const flags: ContentFlags = {};
+
+    const parts = fullId.split('/');
+    for (let i = 1; i <= parts.length; i++) {
+        const trimmedId = parts.slice(0, i).join('/');
+
+        const dbContent = await ERUDIT.db.query.content.findFirst({
+            columns: { flags: true },
+            where: eq(ERUDIT.db.schema.content.fullId, trimmedId),
+        });
+
+        const dbFlags = dbContent?.flags || {};
+
+        for (const [key, value] of Object.entries(dbFlags) as [
+            keyof ContentFlags,
+            boolean,
+        ][]) {
+            if (value === false) {
+                delete flags[key];
+            } else {
+                flags[key] = value;
+            }
+        }
+    }
+
+    return Object.keys(flags).length > 0 ? flags : undefined;
+}

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

@@ -0,0 +1,12 @@
+import { eq } from 'drizzle-orm';
+
+export async function getContentSeo(fullContentId: string) {
+    const dbContentItem = await ERUDIT.db.query.content.findFirst({
+        columns: {
+            seo: true,
+        },
+        where: eq(ERUDIT.db.schema.content.fullId, fullContentId),
+    });
+
+    return dbContentItem?.seo || undefined;
+}

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

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