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

package/server/erudit/news/repository/batch.ts

@@ -0,0 +1,61 @@
+import { count } from 'drizzle-orm';
+
+const newsNumberPerBatch = 20;
+
+export async function countNewsBatches(): Promise<number> {
+    const newsTotal = await ERUDIT.db
+        .select({ count: count() })
+        .from(ERUDIT.db.schema.news)
+        .then((result) => result[0].count);
+
+    return Math.ceil(newsTotal / newsNumberPerBatch);
+}
+
+export async function getNewsNextBatch(index: number): Promise<NewsBatch> {
+    const newsTotal = await ERUDIT.db
+        .select({ count: count() })
+        .from(ERUDIT.db.schema.news)
+        .then((result) => result[0].count);
+
+    const dbNews = await ERUDIT.db.query.news.findMany({
+        columns: {
+            date: true,
+            prose: true,
+        },
+        orderBy: (news, { desc }) => [desc(news.date)],
+        limit: newsNumberPerBatch,
+        offset: index * newsNumberPerBatch,
+    });
+
+    const items: NewsItem[] = [];
+
+    for (const dbNewsItem of dbNews) {
+        const date = dbNewsItem.date;
+        const finalizedProse = await ERUDIT.repository.prose.finalize(
+            dbNewsItem.prose,
+        );
+
+        const item: NewsItem = {
+            date,
+            content: finalizedProse,
+        };
+
+        items.push(item);
+    }
+
+    const hasNext = (index + 1) * newsNumberPerBatch < newsTotal;
+
+    const batch: NewsBatch = {
+        items,
+    };
+
+    if (hasNext) {
+        batch.nextIndex = index + 1;
+    }
+
+    if (index === 0) {
+        batch.total = newsTotal;
+    }
+
+    return batch;
+}

package/server/erudit/prose/repository/finalize.ts

@@ -0,0 +1,68 @@
+import {
+    fillStorage,
+    isProseElement,
+    PROSE_REGISTRY,
+    type AnySchema,
+    type FinalizedProse,
+    type GenericStorage,
+    type ProseElement,
+} from '@jsprose/core';
+import { imageSchema } from '@erudit-js/prose/elements/image/core';
+import { videoSchema } from '@erudit-js/prose/elements/video/core';
+import { calloutSchema } from '@erudit-js/prose/elements/callout/core';
+import {
+    referenceSchema,
+    refSchema,
+} from '@erudit-js/prose/elements/link/reference/core';
+import {
+    dependencySchema,
+    depSchema,
+} from '@erudit-js/prose/elements/link/dependency/core';
+import { problemSchema } from '@erudit-js/prose/elements/problem/problem';
+import { subProblemSchema } from '@erudit-js/prose/elements/problem/problems';
+
+import { createImageStorage } from '../storage/image';
+import { createVideoStorage } from '../storage/video';
+import { createCalloutStorage } from '../storage/callout';
+import { createLinkStorage } from '../storage/link';
+import { createProblemScriptStorage } from '../storage/problemScript';
+
+export async function finalizeProse(
+    proseElement: ProseElement<AnySchema>,
+): Promise<FinalizedProse> {
+    const storage: GenericStorage = {};
+
+    await fillStorage({
+        storage,
+        proseElement,
+        storageCreators: PROSE_REGISTRY.getStorageCreators(),
+        step: async (element) => {
+            switch (true) {
+                case isProseElement(element, imageSchema):
+                    await createImageStorage(element, storage);
+                    break;
+                case isProseElement(element, videoSchema):
+                    await createVideoStorage(element, storage);
+                    break;
+                case isProseElement(element, calloutSchema):
+                    await createCalloutStorage(element, storage);
+                    break;
+                case isProseElement(element, refSchema):
+                case isProseElement(element, referenceSchema):
+                case isProseElement(element, depSchema):
+                case isProseElement(element, dependencySchema):
+                    await createLinkStorage(element, storage);
+                    break;
+                case isProseElement(element, problemSchema):
+                case isProseElement(element, subProblemSchema):
+                    await createProblemScriptStorage(element, storage);
+                    break;
+            }
+        },
+    });
+
+    return {
+        proseElement,
+        storage,
+    };
+}

package/server/erudit/prose/repository/get.ts

@@ -0,0 +1,54 @@
+import { eq } from 'drizzle-orm';
+import type { AnySchema, ProseElement } from '@jsprose/core';
+import type { ContentProseType } from '@erudit-js/core/content/prose';
+import { isTopicPart } from '@erudit-js/core/content/topic';
+
+export async function getContentProse(
+    contentType: ContentProseType,
+    contentId: string,
+): Promise<ProseElement<AnySchema>> {
+    const navNode = ERUDIT.contentNav.getNodeOrThrow(contentId);
+    const fullContentId = navNode.fullId;
+
+    if (isTopicPart(contentType)) {
+        const dbTopic = (await ERUDIT.db.query.topics.findFirst({
+            columns: {
+                [contentType]: true,
+            },
+            where: eq(ERUDIT.db.schema.topics.fullId, fullContentId),
+        }))!;
+
+        // @ts-expect-error we know that contentType is a valid key here
+        return dbTopic[contentType]!;
+    }
+
+    if (contentType === 'page') {
+        const dbPage = (await ERUDIT.db.query.pages.findFirst({
+            columns: {
+                prose: true,
+            },
+            where: eq(ERUDIT.db.schema.pages.fullId, fullContentId),
+        }))!;
+        return dbPage.prose;
+    }
+
+    throw createError({
+        statusCode: 400,
+        statusMessage: `Unable to get prose for content ${contentType} "${contentId}"!`,
+    });
+}
+
+export async function getContributorProse(
+    contributorId: string,
+): Promise<ProseElement<AnySchema> | undefined> {
+    const dbContributor = await ERUDIT.db.query.contributors.findFirst({
+        columns: {
+            description: true,
+        },
+        where: eq(ERUDIT.db.schema.contributors.contributorId, contributorId),
+    });
+
+    return dbContributor?.description || undefined;
+}
+
+// @TODO: Get news item prose

package/server/erudit/prose/repository/resolve.ts

@@ -0,0 +1,17 @@
+import type { AnySchema, RawElement } from '@jsprose/core';
+import { resolveEruditRawElement, type ResolveStep } from '@erudit-js/prose';
+
+export async function resolveEruditProse(
+    rawElement: RawElement<AnySchema>,
+    linkable: boolean,
+    step?: ResolveStep,
+) {
+    return await resolveEruditRawElement({
+        context: {
+            language: ERUDIT.config.public.project.language.current,
+            linkable,
+        },
+        rawElement,
+        step,
+    });
+}

package/server/erudit/prose/storage/callout.ts

@@ -0,0 +1,14 @@
+import type { ProseElement, GenericStorage } from '@jsprose/core';
+import type { calloutSchema } from '@erudit-js/prose/elements/callout/core';
+import { createCalloutStorage as _createCalloutStorage } from '@erudit-js/prose/elements/callout/storage';
+
+export async function createCalloutStorage(
+    element: ProseElement<typeof calloutSchema>,
+    storage: GenericStorage,
+) {
+    storage[element.storageKey!] = _createCalloutStorage(
+        ERUDIT.config.paths.project,
+        ERUDIT.config.public.project.baseUrl,
+        element.data.iconSrc,
+    );
+}

package/server/erudit/prose/storage/image.ts

@@ -0,0 +1,20 @@
+import type { GenericStorage, ProseElement } from '@jsprose/core';
+import type {
+    imageSchema,
+    ImageStorage,
+} from '@erudit-js/prose/elements/image/core';
+import { createImageStorage as _createImageStorage } from '@erudit-js/prose/elements/image/storage';
+
+export async function createImageStorage(
+    element: ProseElement<typeof imageSchema>,
+    storage: GenericStorage,
+) {
+    const imageAbsPath = element.data.src;
+    const imageStorage = await _createImageStorage(
+        ERUDIT.config.paths.project,
+        ERUDIT.config.public.project.baseUrl,
+        imageAbsPath,
+    );
+
+    storage[element.storageKey!] = imageStorage satisfies ImageStorage;
+}

package/server/erudit/prose/storage/link.ts

@@ -0,0 +1,226 @@
+import {
+    ProseError,
+    uniqueName2Id,
+    type GenericStorage,
+    type ProseElement,
+} from '@jsprose/core';
+
+import { isTopicPart } from '@erudit-js/core/content/topic';
+import type { ContentPointer } from '@erudit-js/core/content/pointer';
+import type {
+    referenceSchema,
+    refSchema,
+} from '@erudit-js/prose/elements/link/reference/core';
+import type {
+    dependencySchema,
+    depSchema,
+} from '@erudit-js/prose/elements/link/dependency/core';
+import type { LinkStorage } from '@erudit-js/prose/elements/link/storage';
+
+export async function createLinkStorage(
+    element:
+        | ProseElement<typeof refSchema>
+        | ProseElement<typeof referenceSchema>
+        | ProseElement<typeof depSchema>
+        | ProseElement<typeof dependencySchema>,
+    storage: GenericStorage,
+) {
+    let linkStorage: LinkStorage | undefined;
+
+    const storageKeyParts = element.storageKey!.split('/');
+    const linkType = storageKeyParts[0];
+    const strProseLink = storageKeyParts.slice(1).join('/');
+
+    if (linkType === '<link:direct>') {
+        linkStorage = {
+            type: 'direct',
+            resolvedHref: strProseLink,
+            previewRequest: {
+                type: 'direct-link',
+                href: strProseLink,
+            },
+        };
+    } else if (linkType === '<link:global>') {
+        const proseLinkParts = strProseLink.split('/');
+        const uniquePart = proseLinkParts.pop();
+
+        if (uniquePart?.startsWith('$')) {
+            //
+            // Unique link
+            //
+
+            const contentPointer = await getContentPointerFor(
+                proseLinkParts.join('/'),
+            );
+
+            const shortId = ERUDIT.contentNav.getNodeOrThrow(
+                contentPointer.id,
+            ).shortId;
+
+            const contentTitle = await ERUDIT.repository.content.title(
+                contentPointer.id,
+            );
+
+            const uniqueName = uniquePart.slice(1);
+            const unique = await ERUDIT.repository.content.unique(
+                contentPointer.id,
+                contentPointer.type === 'topic' ? contentPointer.part : 'page',
+                uniqueName,
+            );
+
+            if (contentPointer.type === 'topic') {
+                linkStorage = {
+                    type: 'unique',
+                    schemaName: unique.prose.schemaName,
+                    elementTitle: unique.title || undefined,
+                    content: {
+                        contentType: 'topic',
+                        contentTitle,
+                        topicPart: contentPointer.part,
+                    },
+                    resolvedHref: PAGES.topic(
+                        contentPointer.part,
+                        shortId,
+                        uniqueName2Id(uniqueName),
+                    ),
+                    previewRequest: {
+                        type: 'unique',
+                        contentFullId: contentPointer.id,
+                        contentType: 'topic',
+                        topicPart: contentPointer.part,
+                        uniqueName: uniqueName,
+                    },
+                };
+            } else {
+                linkStorage = {
+                    type: 'unique',
+                    schemaName: unique.prose.schemaName,
+                    elementTitle: unique.title || undefined,
+                    content: {
+                        contentType: contentPointer.type,
+                        contentTitle,
+                    },
+                    resolvedHref: PAGES.page(
+                        shortId,
+                        uniqueName2Id(uniqueName),
+                    ),
+                    previewRequest: {
+                        type: 'unique',
+                        contentFullId: contentPointer.id,
+                        contentType: 'page',
+                        uniqueName: uniqueName,
+                    },
+                };
+            }
+        } else {
+            //
+            // Content item link
+            //
+
+            const contentPointer = await getContentPointerFor(strProseLink);
+
+            const shortId = ERUDIT.contentNav.getNodeOrThrow(
+                contentPointer.id,
+            ).shortId;
+
+            const contentTitle = await ERUDIT.repository.content.title(
+                contentPointer.id,
+            );
+
+            if (contentPointer.type === 'topic') {
+                linkStorage = {
+                    type: 'contentItem',
+                    content: {
+                        contentType: 'topic',
+                        contentTitle,
+                        topicPart: contentPointer.part,
+                    },
+                    resolvedHref: PAGES.topic(contentPointer.part, shortId),
+                    previewRequest: {
+                        type: 'content-page',
+                        contentType: 'topic',
+                        topicPart: contentPointer.part,
+                        fullId: contentPointer.id,
+                    },
+                };
+            } else {
+                linkStorage = {
+                    type: 'contentItem',
+                    content: {
+                        contentType: contentPointer.type,
+                        contentTitle,
+                    },
+                    resolvedHref: PAGES[contentPointer.type](shortId),
+                    previewRequest: {
+                        type: 'content-page',
+                        contentType: contentPointer.type,
+                        fullId: contentPointer.id,
+                    },
+                };
+            }
+        }
+    }
+
+    if (!linkStorage) {
+        throw new ProseError(
+            `Unable to create prose link storage for link: ${element.storageKey}`,
+        );
+    }
+
+    storage[element.storageKey!] = linkStorage;
+}
+
+async function getContentPointerFor(
+    contentId: string,
+): Promise<ContentPointer> {
+    if (!contentId) {
+        throw new ProseError(`Invalid content ID: "${contentId}"!`);
+    }
+
+    const contentNavNode = ERUDIT.contentNav.getNode(contentId);
+
+    if (contentNavNode) {
+        if (contentNavNode.type === 'topic') {
+            const defaultTopicPart =
+                await ERUDIT.repository.content.defaultTopicPart(
+                    contentNavNode.fullId,
+                );
+
+            return {
+                type: 'topic',
+                id: contentNavNode.fullId,
+                part: defaultTopicPart,
+            };
+        } else {
+            return {
+                type: contentNavNode.type,
+                id: contentNavNode.fullId,
+            };
+        }
+    }
+
+    const contentIdParts = contentId.split('/');
+    const maybeTopicPart = contentIdParts.pop()!;
+
+    if (!isTopicPart(maybeTopicPart)) {
+        throw new ProseError(
+            `Prose link part "${contentId}" must be a valid topic part!`,
+        );
+    }
+
+    const shortenedContentNavNode = ERUDIT.contentNav.getNode(
+        contentIdParts.join('/'),
+    );
+
+    if (shortenedContentNavNode) {
+        return {
+            type: 'topic',
+            id: shortenedContentNavNode.fullId,
+            part: maybeTopicPart,
+        };
+    }
+
+    throw new ProseError(
+        `Unable to find content for prose link: "${contentId}"!`,
+    );
+}

package/server/erudit/prose/storage/problemScript.ts

@@ -0,0 +1,21 @@
+import type { GenericStorage, ProseElement } from '@jsprose/core';
+import type { problemSchema } from '@erudit-js/prose/elements/problem/problem';
+import type { subProblemSchema } from '@erudit-js/prose/elements/problem/problems';
+import { createProblemScriptStorage as _createProblemScriptStorage } from '@erudit-js/prose/elements/problem/storage';
+
+export async function createProblemScriptStorage(
+    element:
+        | ProseElement<typeof problemSchema>
+        | ProseElement<typeof subProblemSchema>,
+    storage: GenericStorage,
+) {
+    if (!element.storageKey) {
+        return;
+    }
+
+    storage[element.storageKey!] = _createProblemScriptStorage(
+        ERUDIT.config.paths.project,
+        ERUDIT.config.public.project.baseUrl,
+        element.storageKey.replace('problemScript:', ''),
+    );
+}

package/server/erudit/prose/storage/video.ts

@@ -0,0 +1,14 @@
+import type { GenericStorage, ProseElement } from '@jsprose/core';
+import type { videoSchema } from '@erudit-js/prose/elements/video/core';
+import { createVideoStorage as _createVideoStorage } from '@erudit-js/prose/elements/video/storage';
+
+export async function createVideoStorage(
+    element: ProseElement<typeof videoSchema>,
+    storage: GenericStorage,
+) {
+    storage[element.storageKey!] = _createVideoStorage(
+        ERUDIT.config.paths.project,
+        ERUDIT.config.public.project.baseUrl,
+        element.data.src,
+    );
+}

package/server/erudit/prose/transform/bundleProblemScript.ts

@@ -0,0 +1,6 @@
+export async function bundleProblemScript(problemId: string) {
+    // Создаем фейковый stdin для esbuild, в котором импортирует требуемый скрипт из файла, где он объявлен
+    // Так на выходе получим только бандл скрипта, без лишних зависимостей
+}
+
+// Функция для вызова ESBuild бандлера, чтобы собирать problem скрипты и прочее

package/server/erudit/prose/transform/extensions.ts

@@ -0,0 +1,15 @@
+export const CODE_EXTENSIONS = ['json', 'ts', 'tsx', 'js', 'jsx'];
+
+export const STATIC_ASSET_EXTENSIONS = [
+    'png',
+    'jpg',
+    'jpeg',
+    'gif',
+    'bmp',
+    'webp',
+    'svg',
+    'mp4',
+    'webm',
+];
+
+export const EXTENSIONS = [...CODE_EXTENSIONS, ...STATIC_ASSET_EXTENSIONS];

package/server/erudit/quote/repository/ids.ts

@@ -0,0 +1,31 @@
+import { createQuoteId, type QuoteIds } from '@erudit-js/core/quote';
+import { eq } from 'drizzle-orm';
+
+export async function getQuoteIds(): Promise<QuoteIds> {
+    const ids: QuoteIds = {};
+
+    const dbCameos = await ERUDIT.db.query.cameos.findMany({
+        columns: { cameoId: true },
+    });
+
+    if (dbCameos.length > 0) {
+        ids.cameo = dbCameos.map((dbCameo) =>
+            createQuoteId('cameo', dbCameo.cameoId),
+        );
+    }
+
+    if (ERUDIT.config.public.project.sponsors?.enabled) {
+        const dbSponsors = await ERUDIT.db.query.sponsors.findMany({
+            columns: { sponsorId: true },
+            where: eq(ERUDIT.db.schema.sponsors.hasMessages, true),
+        });
+
+        if (dbSponsors.length > 0) {
+            ids.sponsor = dbSponsors.map((dbSponsor) =>
+                createQuoteId('sponsor', dbSponsor.sponsorId),
+            );
+        }
+    }
+
+    return ids;
+}

package/server/erudit/repository.ts

@@ -0,0 +1,96 @@
+import { getContentBreadcrumbs } from './content/repository/breadcrumbs';
+import { getContentLink } from './content/repository/contentLink';
+import {
+    getDefaultTopicPart,
+    getTopicParts,
+} from './content/repository/topicParts';
+import { countContributors } from './contributors/repository/count';
+import { countSponsors } from './sponsors/repository/count';
+import { resolveEruditProse } from './prose/repository/resolve';
+import { pushFile } from './db/repository/pushFile';
+import { pushProblemScript } from './db/repository/pushProblemScript';
+import { pushProseLink } from './db/repository/pushProseLink';
+import { getContentProse, getContributorProse } from './prose/repository/get';
+import { finalizeProse } from './prose/repository/finalize';
+import { getContentTitle } from './content/repository/title';
+import {
+    getContentHeadingUnique,
+    getContentUnique,
+} from './content/repository/unique';
+import { getContentDecoration } from './content/repository/decoration';
+import { getContentFlags } from './content/repository/flags';
+import { getContentConnections } from './content/repository/connections';
+import { getQuoteIds } from './quote/repository/ids';
+import { getContributorAvatarUrl } from './contributors/repository/avatarUrl';
+import { getSponsorAvatarUrl } from './sponsors/repository/avatarUrl';
+import { getContentDescription } from './content/repository/description';
+import { getContentChildren } from './content/repository/children';
+import {
+    addContentElementCount,
+    getContentStats,
+} from './content/repository/stats';
+import { countNewsBatches, getNewsNextBatch } from './news/repository/batch';
+import {
+    countContributions,
+    getContentContributions,
+    getContributorContributions,
+} from './contributors/repository/contributions';
+import { getContentSeo } from './content/repository/seo';
+import { getContentElementSnippets } from './content/repository/elementSnippets';
+
+export const repository = {
+    db: {
+        pushFile: pushFile,
+        pushProblemScript: pushProblemScript,
+        pushProseLink: pushProseLink,
+    },
+    contributors: {
+        count: countContributors,
+        countContributions,
+        contributorContributions: getContributorContributions,
+        avatarUrl: getContributorAvatarUrl,
+    },
+    quotes: {
+        ids: getQuoteIds,
+    },
+    sponsors: {
+        count: countSponsors,
+        avatarUrl: getSponsorAvatarUrl,
+    },
+    content: {
+        topicParts: getTopicParts,
+        defaultTopicPart: getDefaultTopicPart,
+        unique: getContentUnique,
+        uniqueHeading: getContentHeadingUnique,
+        link: getContentLink,
+        breadcrumbs: getContentBreadcrumbs,
+        title: getContentTitle,
+        description: getContentDescription,
+        decoration: getContentDecoration,
+        elementSnippets: getContentElementSnippets,
+        flags: getContentFlags,
+        connections: getContentConnections,
+        children: getContentChildren,
+        stats: getContentStats,
+        addElementCount: addContentElementCount,
+        contentContributions: getContentContributions,
+        seo: getContentSeo,
+    },
+    prose: {
+        resolve: resolveEruditProse,
+        getContent: getContentProse,
+        getContributor: getContributorProse,
+        finalize: finalizeProse,
+    },
+    news: {
+        countBatches: countNewsBatches,
+        batch: getNewsNextBatch,
+    },
+} as const;
+
+export type EruditServerRepository = typeof repository;
+
+export async function setupServerRepository() {
+    ERUDIT.repository = repository;
+    ERUDIT.log.success('Repository setup complete!');
+}