erudit 3.0.0-dev.2 → 3.0.0-dev.20

package/server/plugin/repository/content.ts

@@ -1,238 +1,240 @@
-import type { ContentType } from 'erudit-cog/schema';
-import { Like } from 'typeorm';
-
-import { ERUDIT_SERVER } from '@server/global';
-import { DbContent } from '@server/db/entities/Content';
-import { DbContribution } from '@server/db/entities/Contribution';
-
-import { getContentContext } from '@server/content/context';
-import type { ContentGenericData } from '@shared/content/data/base';
-import { getIdsUp, getPreviousNextNav } from '../nav/utils';
-import { createContentLink, createTopicPartLink } from '@erudit/shared/link';
-import { getTopicPart } from './topic';
-import type { PreviousNextItem } from '@erudit/shared/content/previousNext';
-import type { NavNode } from '../nav/node';
-import { toAbsoluteContentId } from '../content/absoluteId';
-
-import type { ContentContributor } from '@erudit/shared/contributor';
-import { DbContributor } from '../db/entities/Contributor';
-
-export async function getContentGenericData(
-    contentId: string,
-): Promise<ContentGenericData> {
-    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
-        where: { contentId },
-    });
-
-    if (!dbContent)
-        throw createError({
-            statusCode: 404,
-            message: `Content item "${contentId}" not found!`,
-        });
-
-    const previousNext = await getPreviousNext(contentId);
-    const decoration = await getContentDecoration(contentId);
-    const flags = await getContentFlags(contentId);
-
-    const contentPage: ContentGenericData = {
-        contentId,
-        type: dbContent.type,
-        title: dbContent.title || undefined,
-        description: dbContent.description || undefined,
-        flags,
-        previousNext,
-        decoration,
-        context: await getContentContext(contentId),
-        seo: dbContent.seo,
-        ogImage: dbContent.ogImage,
-        dependencies: dbContent.dependencies
-            ? await getContentDependencies(contentId, dbContent.dependencies)
-            : undefined,
-        references: dbContent.references,
-    };
-
-    return contentPage;
-}
-
-export async function getPreviousNext(contentId: string) {
-    const { previousNav, nextNav } = await getPreviousNextNav(contentId);
-
-    async function getItemData(navNode: NavNode): Promise<PreviousNextItem> {
-        const title = await getContentTitle(navNode.id);
-
-        const link = await (async () => {
-            if (navNode.type === 'topic')
-                return createTopicPartLink(
-                    await getTopicPart(navNode.id),
-                    navNode.id,
-                );
-
-            return createContentLink(navNode.type, navNode.id);
-        })();
-
-        return {
-            title,
-            link,
-        };
-    }
-
-    return {
-        previous: previousNav ? await getItemData(previousNav) : undefined,
-        next: nextNav ? await getItemData(nextNav) : undefined,
-    };
-}
-
-export async function getContentDecoration(contentId: string) {
-    const idsUp = await getIdsUp(contentId);
-
-    for (const id of idsUp) {
-        const decoration = (
-            await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
-                select: ['decoration'],
-                where: { contentId: id },
-            })
-        )?.decoration;
-
-        if (decoration) return decoration;
-    }
-
-    return undefined;
-}
-
-export async function getContentFlags(contentId: string) {
-    const idsUp = await getIdsUp(contentId);
-    const flags: any = {};
-
-    for (const id of idsUp.reverse()) {
-        const dbFlags = (
-            await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
-                select: ['flags'],
-                where: { contentId: id },
-            })
-        )?.flags;
-
-        if (dbFlags)
-            for (const [flagName, flagValue] of Object.entries(dbFlags))
-                flags[flagName] = flagValue;
-    }
-
-    for (const [flagName, flagValue] of Object.entries(flags))
-        if (flagValue === false) delete flags[flagName];
-
-    return flags;
-}
-
-export async function getContentDependencies(
-    contentId: string,
-    strDependencies: string[],
-) {
-    const dependencyIds = strDependencies.map((rawDependency) =>
-        toAbsoluteContentId(rawDependency, contentId),
-    );
-    const dependencies: Record<string, string> = {};
-
-    for (const dependencyId of dependencyIds)
-        dependencies[await getContentLink(dependencyId)] =
-            await getContentTitle(dependencyId);
-
-    return dependencies;
-}
-
-export async function getContentTitle(contentId: string) {
-    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
-        select: ['title'],
-        where: { contentId },
-    });
-
-    return dbContent?.title || contentId.split('/').pop()!;
-}
-
-export async function getContentLink(contentId: string) {
-    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
-        select: ['type'],
-        where: { contentId },
-    });
-
-    if (!dbContent)
-        throw createError({
-            statusCode: 404,
-            statusText: `Missing "${contentId}" content item!`,
-        });
-
-    if (dbContent.type !== 'topic')
-        return createContentLink(dbContent.type, contentId);
-
-    const topicPart = await getTopicPart(contentId);
-
-    return createTopicPartLink(topicPart, contentId);
-}
-
-export async function getFullContentId(contentId: string) {
-    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
-        select: ['fullId'],
-        where: { contentId },
-    });
-
-    return dbContent?.fullId;
-}
-
-export async function getContentContributors(contentId: string) {
-    const contributorIds = await (async () => {
-        const idHash: Record<string, true> = {};
-
-        (
-            await ERUDIT_SERVER.DB.manager.find(DbContribution, {
-                select: ['contributorId'],
-                where: { contentId },
-            })
-        ).forEach(
-            (contribution) => (idHash[contribution.contributorId] = true),
-        );
-
-        const type: ContentType = (await ERUDIT_SERVER.DB.manager.findOne(
-            DbContent,
-            {
-                select: ['type'],
-                where: { contentId },
-            },
-        ))!.type;
-
-        if (type === 'book' || type === 'group') {
-            // Collecting contributors for all sub-content items
-            (
-                await ERUDIT_SERVER.DB.manager.find(DbContribution, {
-                    select: ['contributorId'],
-                    where: { contentId: Like(`${contentId}/%`) },
-                })
-            ).forEach(
-                (contribution) => (idHash[contribution.contributorId] = true),
-            );
-        }
-
-        return Object.keys(idHash);
-    })();
-
-    const contentContributors: ContentContributor[] = [];
-
-    for (const contributorId of contributorIds) {
-        const dbContributor = (await ERUDIT_SERVER.DB.manager.findOne(
-            DbContributor,
-            {
-                select: ['contributorId', 'displayName', 'avatar'],
-                where: { contributorId },
-            },
-        ))!;
-
-        const contentContributor: ContentContributor = { contributorId };
-
-        if (dbContributor.displayName)
-            contentContributor.displayName = dbContributor.displayName;
-
-        if (dbContributor.avatar)
-            contentContributor.avatar = dbContributor.avatar;
-
-        contentContributors.push(contentContributor);
-    }
-
-    return contentContributors.length ? contentContributors : undefined;
-}
+import type { ContentType } from '@erudit-js/cog/schema';
+import { Like } from 'typeorm';
+
+import { ERUDIT_SERVER } from '@server/global';
+import { DbContent } from '@server/db/entities/Content';
+import { DbContribution } from '@server/db/entities/Contribution';
+import { getContentContext } from '@server/content/context';
+import { DbContributor } from '@server/db/entities/Contributor';
+import { getIdsUp, getPreviousNextNav } from '@server/nav/utils';
+import {
+    getShortContentId,
+    resolveClientContentId,
+} from '@server/repository/contentId';
+import { getTopicPart } from './topic';
+import type { NavNode } from '../nav/node';
+
+import { createContentLink, createTopicPartLink } from '@erudit/shared/link';
+import type { PreviousNextItem } from '@erudit/shared/content/previousNext';
+import type { ContentContributor } from '@erudit/shared/contributor';
+import type { ContentGenericData } from '@shared/content/data/base';
+
+export async function getContentGenericData(
+    contentId: string,
+): Promise<ContentGenericData> {
+    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+        where: { contentId },
+    });
+
+    if (!dbContent) {
+        throw createError({
+            statusCode: 404,
+            message: `Content item "${contentId}" not found!`,
+        });
+    }
+
+    const previousNext = await getPreviousNext(contentId);
+    const decoration = await getContentDecoration(contentId);
+    const flags = await getContentFlags(contentId);
+
+    const contentPage: ContentGenericData = {
+        contentId,
+        type: dbContent.type,
+        title: dbContent.title || undefined,
+        description: dbContent.description || undefined,
+        flags,
+        previousNext,
+        decoration,
+        context: await getContentContext(contentId),
+        seo: dbContent.seo,
+        ogImage: dbContent.ogImage,
+        dependencies: dbContent.dependencies
+            ? await getContentDependencies(contentId, dbContent.dependencies)
+            : undefined,
+        references: dbContent.references,
+    };
+
+    return contentPage;
+}
+
+export async function getPreviousNext(contentId: string) {
+    const { previousNav, nextNav } = await getPreviousNextNav(contentId);
+
+    async function getItemData(navNode: NavNode): Promise<PreviousNextItem> {
+        const title = await getContentTitle(navNode.fullId);
+
+        const link = await (async () => {
+            if (navNode.type === 'topic')
+                return createTopicPartLink(
+                    await getTopicPart(navNode.fullId),
+                    navNode.shortId,
+                );
+
+            return createContentLink(navNode.type, navNode.shortId);
+        })();
+
+        return {
+            title,
+            link,
+        };
+    }
+
+    return {
+        previous: previousNav ? await getItemData(previousNav) : undefined,
+        next: nextNav ? await getItemData(nextNav) : undefined,
+    };
+}
+
+export async function getContentDecoration(contentId: string) {
+    const idsUp = await getIdsUp(contentId);
+
+    for (const id of idsUp) {
+        const decoration = (
+            await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+                select: ['decoration'],
+                where: { contentId: id },
+            })
+        )?.decoration;
+
+        if (decoration) return decoration;
+    }
+
+    return undefined;
+}
+
+export async function getContentFlags(contentId: string) {
+    const idsUp = await getIdsUp(contentId);
+    const flags: any = {};
+
+    for (const id of idsUp.reverse()) {
+        const dbFlags = (
+            await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+                select: ['flags'],
+                where: { contentId: id },
+            })
+        )?.flags;
+
+        if (dbFlags)
+            for (const [flagName, flagValue] of Object.entries(dbFlags))
+                flags[flagName] = flagValue;
+    }
+
+    for (const [flagName, flagValue] of Object.entries(flags))
+        if (flagValue === false) delete flags[flagName];
+
+    return flags;
+}
+
+export async function getContentDependencies(
+    contentId: string,
+    strDependencies: string[],
+) {
+    const dependencyIds: string[] = [];
+    for (const rawDependency of strDependencies) {
+        dependencyIds.push(
+            resolveClientContentId(rawDependency, contentId, 'full'),
+        );
+    }
+
+    const dependencies: Record<string, string> = {};
+
+    for (const dependencyId of dependencyIds)
+        dependencies[await getContentLink(dependencyId)] =
+            await getContentTitle(dependencyId);
+
+    return dependencies;
+}
+
+export async function getContentTitle(contentId: string) {
+    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+        select: ['title'],
+        where: { contentId },
+    });
+
+    return dbContent?.title || contentId.split('/').pop()!;
+}
+
+export async function getContentLink(contentId: string) {
+    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+        select: ['type'],
+        where: { contentId },
+    });
+
+    if (!dbContent) {
+        throw createError({
+            statusCode: 404,
+            statusText: `Missing "${contentId}" content item!`,
+        });
+    }
+
+    const shortContentId = getShortContentId(contentId);
+
+    if (dbContent.type !== 'topic') {
+        return createContentLink(dbContent.type, shortContentId);
+    }
+
+    const topicPart = await getTopicPart(contentId);
+
+    return createTopicPartLink(topicPart, shortContentId);
+}
+
+export async function getContentContributors(contentId: string) {
+    const contributorIds = await (async () => {
+        const idHash: Record<string, true> = {};
+
+        (
+            await ERUDIT_SERVER.DB.manager.find(DbContribution, {
+                select: ['contributorId'],
+                where: { contentId },
+            })
+        ).forEach(
+            (contribution) => (idHash[contribution.contributorId] = true),
+        );
+
+        const type: ContentType = (await ERUDIT_SERVER.DB.manager.findOne(
+            DbContent,
+            {
+                select: ['type'],
+                where: { contentId },
+            },
+        ))!.type;
+
+        if (type === 'book' || type === 'group') {
+            // Collecting contributors for all sub-content items
+            (
+                await ERUDIT_SERVER.DB.manager.find(DbContribution, {
+                    select: ['contributorId'],
+                    where: { contentId: Like(`${contentId}/%`) },
+                })
+            ).forEach(
+                (contribution) => (idHash[contribution.contributorId] = true),
+            );
+        }
+
+        return Object.keys(idHash);
+    })();
+
+    const contentContributors: ContentContributor[] = [];
+
+    for (const contributorId of contributorIds) {
+        const dbContributor = (await ERUDIT_SERVER.DB.manager.findOne(
+            DbContributor,
+            {
+                select: ['contributorId', 'displayName', 'avatar'],
+                where: { contributorId },
+            },
+        ))!;
+
+        const contentContributor: ContentContributor = { contributorId };
+
+        if (dbContributor.displayName)
+            contentContributor.displayName = dbContributor.displayName;
+
+        if (dbContributor.avatar)
+            contentContributor.avatar = dbContributor.avatar;
+
+        contentContributors.push(contentContributor);
+    }
+
+    return contentContributors.length ? contentContributors : undefined;
+}

package/server/plugin/repository/contentId.ts

@@ -0,0 +1,40 @@
+import { getNavBookIds, getNavNode } from '@server/nav/utils';
+import { toAbsoluteContentPath } from '@shared/bitran/contentId';
+
+export function getFullContentId(mixedContentId: string): string {
+    const navNode = getNavNode(mixedContentId);
+    return navNode.fullId;
+}
+
+export function getShortContentId(mixedContentId: string): string {
+    const navNode = getNavNode(mixedContentId);
+    return navNode.shortId;
+}
+
+export function serverAbsolutizeContentPath(
+    relativePath: string,
+    contextPath: string,
+) {
+    const absolutePath = toAbsoluteContentPath(
+        relativePath,
+        contextPath,
+        getNavBookIds('full'),
+    );
+
+    return absolutePath;
+}
+
+export function resolveClientContentId(
+    clientContentId: string,
+    contextContentId: string,
+    mode: 'full' | 'short',
+): string {
+    const absoluteContentId = serverAbsolutizeContentPath(
+        clientContentId,
+        contextContentId,
+    );
+
+    return mode === 'full'
+        ? getFullContentId(absoluteContentId)
+        : getShortContentId(absoluteContentId);
+}

package/server/plugin/repository/contributor.ts

@@ -1,8 +1,98 @@
-import { DbContributor } from '@server/db/entities/Contributor';
-import { ERUDIT_SERVER } from '@server/global';
-
-export async function contributorExists(contributorId: string) {
-    return await ERUDIT_SERVER.DB.manager.exists(DbContributor, {
-        where: { contributorId },
-    });
-}
+import { DbContributor } from '@server/db/entities/Contributor';
+import { DbContribution } from '@server/db/entities/Contribution';
+import { ERUDIT_SERVER } from '@server/global';
+import { getNavBookOf, getNavNode } from '@server/nav/utils';
+import { getBookTitleFor } from '@server/repository/book';
+import { getContentLink, getContentTitle } from '@server/repository/content';
+
+import type { Contribution, PageContributor } from '@shared/contributor';
+
+export async function contributorExists(contributorId: string) {
+    return await ERUDIT_SERVER.DB.manager.exists(DbContributor, {
+        where: { contributorId },
+    });
+}
+
+export async function getContributorPageData(
+    contributorId: string,
+): Promise<PageContributor> {
+    if (!(await contributorExists(contributorId))) {
+        throw createError({
+            statusCode: 404,
+            message: `Contributor ${contributorId} not found!`,
+        });
+    }
+
+    const dbContributor = (await ERUDIT_SERVER.DB.manager.findOne(
+        DbContributor,
+        {
+            select: [
+                'displayName',
+                'slogan',
+                'links',
+                'avatar',
+                'isEditor',
+                'description',
+            ],
+            where: { contributorId },
+        },
+    ))!;
+
+    return {
+        contributorId,
+        displayName: dbContributor.displayName,
+        slogan: dbContributor.slogan,
+        links: dbContributor.links,
+        avatar: dbContributor.avatar,
+        isEditor: dbContributor.isEditor,
+        hasDescription: !!dbContributor.description,
+        contributions: await getContributions(contributorId),
+    };
+}
+
+export async function getContributions(
+    contributorId: string,
+): Promise<Contribution[]> {
+    const dbContributions = await ERUDIT_SERVER.DB.manager.find(
+        DbContribution,
+        {
+            select: ['contentId'],
+            where: { contributorId },
+        },
+    );
+
+    const contributions: Contribution[] = [];
+
+    for (const dbContribution of dbContributions) {
+        const contentId = dbContribution.contentId;
+        const contentNavNode = getNavNode(contentId);
+
+        const bookTitle = await (async () => {
+            const bookId = getNavBookOf(contentId)?.fullId;
+
+            if (!bookId) {
+                return undefined;
+            }
+
+            if (bookId === contentId) {
+                return undefined;
+            }
+
+            return await getBookTitleFor(bookId);
+        })();
+
+        const contentTitle = await getContentTitle(contentId);
+        const contentLink = await getContentLink(contentId);
+
+        const contribution: Contribution = {
+            bookTitle: bookTitle,
+            contentType: contentNavNode.type,
+            contentTitle,
+            contentLink,
+        };
+
+        contributions.push(contribution);
+    }
+
+    return contributions;
+}

package/server/plugin/repository/file.ts

@@ -0,0 +1,10 @@
+import { ERUDIT_SERVER } from '@server/global';
+import { DbFile } from '@server/db/entities/File';
+
+export async function getFileFullPath(path: string) {
+    const dbFile = await ERUDIT_SERVER.DB.manager.findOne(DbFile, {
+        where: { path },
+    });
+
+    return dbFile?.fullPath;
+}