erudit 3.0.0-dev.20 → 3.0.0-dev.21

package/server/plugin/sponsor/build.ts

@@ -0,0 +1,82 @@
+import chalk from 'chalk';
+import { glob } from 'glob';
+import type { Sponsor, SponsorConfig } from '@erudit-js/cog/schema';
+
+import { PROJECT_DIR } from '#erudit/globalPaths';
+import { ERUDIT_SERVER } from '@server/global';
+import { debug, logger } from '@server/logger';
+
+import { getSponsorCount, readSponsorConfig } from './repository';
+
+export async function buildSponsors() {
+    if (!ERUDIT_SERVER.CONFIG.sponsors) {
+        return;
+    }
+
+    debug.start('Building sponsors...');
+
+    const sponsorIds = await searchSponsorIds();
+
+    if (sponsorIds.length === 0) {
+        logger.warn('No sponsors found!');
+        return;
+    }
+
+    ERUDIT_SERVER.SPONSORS = {
+        tier1Ids: [],
+        tier2Ids: [],
+        avatars: {},
+    };
+
+    for (const sponsorId of sponsorIds) {
+        const sponsorAvatar = await searchSponsorAvatar(sponsorId);
+
+        let config: SponsorConfig<Sponsor>;
+        try {
+            config = await readSponsorConfig(sponsorId);
+        } catch (error) {
+            logger.error(
+                `Failed to read sponsor config for: ${sponsorId}! ${error}`,
+            );
+            continue;
+        }
+
+        if (config.tier === 'tier1') {
+            ERUDIT_SERVER.SPONSORS.tier1Ids.push(sponsorId);
+        } else if (config.tier === 'tier2') {
+            ERUDIT_SERVER.SPONSORS.tier2Ids.push(sponsorId);
+        } else {
+            logger.warn(
+                `Sponsor ${sponsorId} has an unknown tier: ${config.tier}!`,
+            );
+            continue;
+        }
+
+        ERUDIT_SERVER.SPONSORS.avatars[sponsorId] = sponsorAvatar;
+    }
+
+    logger.success(
+        `Sponsors built successfully!`,
+        chalk.dim(`(${getSponsorCount()})`),
+    );
+}
+
+async function searchSponsorIds() {
+    const dirs = await glob(PROJECT_DIR + '/sponsors/*/sponsor.{ts,js}', {
+        posix: true,
+    });
+
+    return dirs.map((dir) => dir.split('/').slice(-2, -1)[0]!);
+}
+
+export async function searchSponsorAvatar(
+    sponsorId: string,
+): Promise<string | undefined> {
+    const pattern = `sponsors/${sponsorId}/avatar.*`;
+    const avatars = await glob(pattern, {
+        cwd: PROJECT_DIR,
+        posix: true,
+    });
+
+    return avatars.pop();
+}

package/server/plugin/sponsor/index.ts

@@ -0,0 +1,5 @@
+export interface ServerSponsors {
+    tier1Ids: string[];
+    tier2Ids: string[];
+    avatars: Record<string, string | undefined>;
+}

package/server/plugin/sponsor/repository.ts

@@ -0,0 +1,56 @@
+import type { SponsorConfig, Sponsor } from '@erudit-js/cog/schema';
+
+import { PROJECT_DIR } from '#erudit/globalPaths';
+import { ERUDIT_SERVER } from '@server/global';
+import { IMPORT } from '@server/importer';
+
+export function getSponsorIds() {
+    const sponsors = ERUDIT_SERVER?.SPONSORS;
+
+    if (!sponsors) {
+        return [];
+    }
+
+    const tier1Ids = sponsors.tier1Ids || [];
+    const tier2Ids = sponsors.tier2Ids || [];
+
+    return [...tier1Ids, ...tier2Ids];
+}
+
+export function getSponsorCount() {
+    return getSponsorIds().length;
+}
+
+export async function readSponsorConfig(sponsorId: string) {
+    const config = (await IMPORT(
+        `${PROJECT_DIR}/sponsors/${sponsorId}/sponsor`,
+        { default: true },
+    )) as SponsorConfig<Sponsor>;
+
+    return config;
+}
+
+export async function retrieveSponsor(sponsorId: string): Promise<Sponsor> {
+    const config = await readSponsorConfig(sponsorId);
+    const avatar = ERUDIT_SERVER.SPONSORS?.avatars[sponsorId];
+
+    if (!config) {
+        throw new Error(`Sponsor config not found for ID: ${sponsorId}`);
+    }
+
+    return {
+        ...config,
+        sponsorId,
+        avatar,
+    };
+}
+
+export function getTier2SponsorIds() {
+    const sponsors = ERUDIT_SERVER?.SPONSORS;
+
+    if (!sponsors) {
+        return [];
+    }
+
+    return sponsors.tier2Ids || [];
+}

package/server/routes/asset/[...assetPath].ts

@@ -0,0 +1,34 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+
+import { PROJECT_DIR } from '#erudit/globalPaths';
+
+export default defineEventHandler(async (event) => {
+    setHeader(event, 'Content-Type', 'application/octet-stream');
+    const assetPath = event.context.params?.assetPath?.trim();
+
+    if (typeof assetPath !== 'string' || !assetPath) {
+        throw createError({
+            statusCode: 400,
+            message: 'Invalid asset path!',
+        });
+    }
+
+    const fsPath = PROJECT_DIR + '/' + assetPath;
+
+    if (!existsSync(fsPath)) {
+        throw createError({
+            statusCode: 404,
+            message: `Asset not found: ${assetPath}`,
+        });
+    }
+
+    const fileContent = await readFile(fsPath).catch((err) => {
+        throw createError({
+            statusCode: 500,
+            message: `Failed to read asset "${assetPath}"! Error: ${err.message}`,
+        });
+    });
+
+    return fileContent;
+});

package/server/routes/robots.txt.ts

@@ -0,0 +1,9 @@
+export default defineEventHandler((event) => {
+    setHeader(event, 'Content-Type', 'text/plain');
+    const robots = `
+User-agent: *
+Allow: /
+    `.trim();
+
+    return robots;
+});

package/server/routes/sitemap.xml.ts

@@ -0,0 +1,103 @@
+import { Not } from 'typeorm';
+import type { ContentType } from '@erudit-js/cog/schema';
+
+import { ERUDIT_SERVER } from '@server/global';
+import { DbTopic } from '@server/db/entities/Topic';
+import { getShortContentId } from '@server/repository/contentId';
+import { DbContent } from '@server/db/entities/Content';
+import { DbContributor } from '@server/db/entities/Contributor';
+
+import {
+    createContentLink,
+    createContributorLink,
+    createTopicPartLink,
+} from '@shared/link';
+import { trailingSlash } from '@erudit/utils/url';
+
+export default defineEventHandler(async (event) => {
+    setHeader(event, 'Content-Type', 'application/xml');
+
+    const routes = [
+        ...staticRoutes(),
+        ...(await topicRoutes()),
+        ...(await contentRoutes()),
+        ...(await contributorsRoutes()),
+    ];
+
+    const buildUrl = ERUDIT_SERVER.CONFIG.site?.buildUrl || '';
+    const baseUrl = ERUDIT_SERVER.CONFIG.site?.baseUrl || '/';
+
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${routes
+    .map(
+        (route) =>
+            `    <url>
+        <loc>${trailingSlash(buildUrl + baseUrl, false) + route}</loc>
+        <lastmod>${new Date().toISOString().slice(0, 10)}</lastmod>
+    </url>`,
+    )
+    .join('\n')}
+</urlset>`;
+});
+
+function staticRoutes() {
+    const routes = ['/', '/contributors/'];
+
+    if (ERUDIT_SERVER.CONFIG.sponsors) {
+        routes.push('/sponsors/');
+    }
+
+    return routes;
+}
+
+async function topicRoutes() {
+    const dbTopics = await ERUDIT_SERVER.DB.manager.find(DbTopic, {
+        select: ['contentId', 'parts'],
+    });
+
+    const topicRoutes: string[] = [];
+
+    for (const dbTopic of dbTopics) {
+        const shortId = getShortContentId(dbTopic.contentId);
+        for (const part of dbTopic.parts) {
+            topicRoutes.push(createTopicPartLink(part, shortId));
+        }
+    }
+
+    return topicRoutes;
+}
+
+async function contentRoutes() {
+    const dbContentItems = await ERUDIT_SERVER.DB.manager.find(DbContent, {
+        select: ['contentId', 'type'],
+        where: {
+            type: Not('topic' as ContentType),
+        },
+    });
+
+    const contentRoutes: string[] = [];
+
+    for (const dbContent of dbContentItems) {
+        const shortId = getShortContentId(dbContent.contentId);
+        contentRoutes.push(createContentLink(dbContent.type, shortId));
+    }
+
+    return contentRoutes;
+}
+
+async function contributorsRoutes() {
+    const dbContributors = await ERUDIT_SERVER.DB.manager.find(DbContributor, {
+        select: ['contributorId'],
+    });
+
+    const contributorRoutes: string[] = [];
+
+    for (const dbContributor of dbContributors) {
+        contributorRoutes.push(
+            createContributorLink(dbContributor.contributorId),
+        );
+    }
+
+    return contributorRoutes;
+}

package/shared/asset.ts

@@ -1,6 +1,5 @@
 import {
     PUBLIC_CONTENT_ASSET,
-    PUBLIC_CONTRIBUTOR_ASSET,
     PUBLIC_ERUDIT_ASSET,
     PUBLIC_USER_ASSET,
 } from '@erudit/const';
@@ -9,10 +8,6 @@ export function eruditAsset(path: string) {
     return PUBLIC_ERUDIT_ASSET + path;
 }
 
-export function contributorAsset(path: string) {
-    return PUBLIC_CONTRIBUTOR_ASSET + path;
-}
-
 export function contentAsset(path: string) {
     return PUBLIC_CONTENT_ASSET + path;
 }

package/shared/contributor.ts

@@ -7,6 +7,7 @@ export interface ContentContributor {
 }
 
 export interface Contribution {
+    bookId?: string;
     bookTitle?: string;
     contentType: ContentType;
     contentTitle: string;

package/shared/link.ts

@@ -5,7 +5,7 @@ import type {
 } from '@erudit-js/cog/schema';
 
 export function createBitranLocationLink(location: BitranLocation) {
-    let link = `/${location.type}/${location.path}`;
+    let link = `/${location.type}/${location.path}/`;
 
     if (location.unique) link += `#${location.unique}`;
 
@@ -16,13 +16,13 @@ export function createContentLink(contentType: ContentType, contentId: string) {
     // if (contentType === 'topic')
     //     throw Error(`Use 'createTopicPartLink' to create links to topics!`);
 
-    return `/${contentType}/${contentId}`;
+    return `/${contentType}/${contentId}/`;
 }
 
 export function createTopicPartLink(topicPart: TopicPart, contentId: string) {
-    return `/${topicPart}/${contentId}`;
+    return `/${topicPart}/${contentId}/`;
 }
 
 export function createContributorLink(contributorId: string) {
-    return `/contributor/${contributorId}`;
+    return `/contributor/${contributorId}/`;
 }

package/shared/types/language.ts

@@ -23,7 +23,8 @@ export interface EruditPhrases {
     main_page: string;
     contributors: string;
     contributors_page_description: string;
-    contributors_page_invite: (link: string) => string;
+    contributors_page_invite: string;
+    become_contributor: string;
     contributor: string;
     contribution: string;
     contributions_explain: (count: number) => string;
@@ -73,6 +74,10 @@ export interface EruditPhrases {
     references: string;
     reference_source_featured: string;
     references_description: string;
+    // Sponsors
+    sponsors: string;
+    sponsors_description: string;
+    become_sponsor: string;
 }
 
 export type EruditPhraseId = keyof Partial<EruditPhrases>;

package/test/utils/url.test.ts

@@ -0,0 +1,99 @@
+import { trailingSlash, normalizeUrl } from '../../utils/url';
+
+describe('trailingSlash', () => {
+    describe('when add is true', () => {
+        it('should add trailing slash to path without one', () => {
+            expect(trailingSlash('/path', true)).toBe('/path/');
+        });
+
+        it('should preserve trailing slash when path already has one', () => {
+            expect(trailingSlash('/path/', true)).toBe('/path/');
+        });
+
+        it('should return root path unchanged', () => {
+            expect(trailingSlash('/', true)).toBe('/');
+        });
+
+        it('should add trailing slash to empty path', () => {
+            expect(trailingSlash('', true)).toBe('/');
+        });
+    });
+
+    describe('when add is false', () => {
+        it('should remove trailing slash from path', () => {
+            expect(trailingSlash('/path/', false)).toBe('/path');
+        });
+
+        it('should preserve path without trailing slash', () => {
+            expect(trailingSlash('/path', false)).toBe('/path');
+        });
+
+        it('should return root path unchanged', () => {
+            expect(trailingSlash('/', false)).toBe('/');
+        });
+
+        it('should handle empty path', () => {
+            expect(trailingSlash('', false)).toBe('');
+        });
+    });
+});
+
+describe('normalizeUrl', () => {
+    describe('with protocol', () => {
+        it('should normalize multiple slashes in path', () => {
+            expect(
+                normalizeUrl('https://example.com//path//to///resource'),
+            ).toBe('https://example.com/path/to/resource');
+        });
+
+        it('should preserve protocol and domain', () => {
+            expect(normalizeUrl('https://example.com/path')).toBe(
+                'https://example.com/path',
+            );
+        });
+
+        it('should handle different protocols', () => {
+            expect(normalizeUrl('http://example.com//path')).toBe(
+                'http://example.com/path',
+            );
+        });
+
+        it('should handle custom protocols', () => {
+            expect(normalizeUrl('custom+protocol://example.com//path')).toBe(
+                'custom+protocol://example.com/path',
+            );
+        });
+    });
+
+    describe('without protocol', () => {
+        it('should normalize multiple slashes in relative path', () => {
+            expect(normalizeUrl('/path//to///resource')).toBe(
+                '/path/to/resource',
+            );
+        });
+
+        it('should handle single slash', () => {
+            expect(normalizeUrl('/')).toBe('/');
+        });
+
+        it('should normalize empty segments', () => {
+            expect(normalizeUrl('///')).toBe('/');
+        });
+
+        it('should handle path without leading slash', () => {
+            expect(normalizeUrl('path//to/resource')).toBe('path/to/resource');
+        });
+    });
+
+    describe('edge cases', () => {
+        it('should handle empty string', () => {
+            expect(normalizeUrl('')).toBe('');
+        });
+
+        it('should handle query parameters and fragments', () => {
+            expect(
+                normalizeUrl('https://example.com//path?query=1#fragment'),
+            ).toBe('https://example.com/path?query=1#fragment');
+        });
+    });
+});

package/utils/ext.ts

@@ -0,0 +1,41 @@
+export const imageExtensions = [
+    'png',
+    'jpg',
+    'jpeg',
+    'gif',
+    'webp',
+    'avif',
+] as const;
+
+export const videoExtensions = ['mp4', 'webm', 'ogg'] as const;
+
+export type FileType = 'image' | 'video' | 'unknown';
+
+export function detectFileType(filename: string): FileType {
+    const ext = filename.split('.').pop()?.toLowerCase();
+
+    if (ext) {
+        if (imageExtensions.includes(ext as (typeof imageExtensions)[number])) {
+            return 'image';
+        }
+
+        if (videoExtensions.includes(ext as (typeof videoExtensions)[number])) {
+            return 'video';
+        }
+    }
+
+    return 'unknown';
+}
+
+export function detectStrictFileType<T extends FileType>(
+    filename: string,
+    ...types: T[]
+): T {
+    const fileType = detectFileType(filename);
+    if (!types.includes(fileType as T)) {
+        throw new Error(
+            `Invalid file type "${fileType}" of file "${filename}"! Expected one of: ${types.join(', ')}.`,
+        );
+    }
+    return fileType as T;
+}

package/utils/url.ts

@@ -0,0 +1,23 @@
+export function trailingSlash(path: string, add: boolean): string {
+    if (path === '/') {
+        return '/';
+    }
+
+    if (add) {
+        return path.endsWith('/') ? path : `${path}/`;
+    }
+
+    return path.endsWith('/') ? path.slice(0, -1) : path;
+}
+
+export function normalizeUrl(url: string): string {
+    // Handle protocol and origin separately
+    const protocolMatch = url.match(/^([a-z][a-z\d+\-.]*:\/\/[^\/]+)/i);
+    const protocol = protocolMatch ? protocolMatch[1] : '';
+    const pathPart = protocol ? url.slice(protocol.length) : url;
+
+    // Normalize path by removing empty segments
+    const normalizedPath = pathPart.replace(/\/+/g, '/');
+
+    return protocol + normalizedPath;
+}

package/app/components/contributor/ContributorAvatar.vue

@@ -1,45 +0,0 @@
-<script lang="ts" setup>
-const props = defineProps<{ contributorId: string; avatar?: string }>();
-const baseUrlPath = useBaseUrlPath();
-
-const hasAvatar = computed(() => !!props.avatar);
-</script>
-
-<template>
-    <div
-        :class="$style.contributorAvatar"
-        :style="{
-            ...(!hasAvatar
-                ? {
-                      backgroundImage: `url(${eruditAsset('user.svg')})`,
-                      backgroundColor: stringColor(props.contributorId),
-                      backgroundBlendMode: 'hard-light',
-                  }
-                : {}),
-        }"
-    >
-        <img
-            v-if="hasAvatar"
-            :src="baseUrlPath(contributorAsset(avatar!))"
-            loading="lazy"
-        />
-    </div>
-</template>
-
-<style lang="scss" module>
-.contributorAvatar {
-    --_avatarSize: 40px;
-    --_avatarBlendColor: var(--brand);
-
-    position: relative;
-    width: var(--_avatarSize);
-    height: var(--_avatarSize);
-    border-radius: 50%;
-    overflow: hidden;
-    background: var(--border);
-
-    > img {
-        display: block;
-    }
-}
-</style>

package/app/components/main/content/ContentSection.vue

@@ -1,45 +0,0 @@
-<template>
-    <hr :class="$style.hr" />
-    <slot></slot>
-</template>
-
-<style lang="scss" module>
-@mixin shade {
-    height: 50px;
-    border-bottom: 2px solid var(--border);
-    background: linear-gradient(to bottom, transparent, var(--bgAside));
-}
-
-@mixin simple {
-    height: var(--gap);
-}
-
-.hr {
-    border: none;
-
-    &::before,
-    &::after {
-        display: block;
-        content: '';
-    }
-
-    &:nth-of-type(odd) {
-        &::before {
-            @include shade;
-        }
-        &::after {
-            @include simple;
-        }
-    }
-
-    &:nth-of-type(even) {
-        &::before {
-            @include simple;
-        }
-        &::after {
-            @include shade;
-            transform: scaleY(-1);
-        }
-    }
-}
-</style>

package/app/public/user.svg

@@ -1,10 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 500 500">
-  <defs>
-    <linearGradient id="gradient" x1="0" y1="500" x2="500" y2="0" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#bcbcbc"/>
-      <stop offset="1" stop-color="#e6e6e6"/>
-    </linearGradient>
-  </defs>
-  <rect width="500" height="500" fill="url(#gradient)"/>
-  <path d="M250,224c-20.62,0-38.28-7.34-52.97-22.03-14.69-14.69-22.03-32.34-22.03-52.97s7.34-38.28,22.03-52.97,32.34-22.03,52.97-22.03,38.28,7.34,52.97,22.03,22.03,32.34,22.03,52.97-7.34,38.28-22.03,52.97c-14.69,14.69-32.34,22.03-52.97,22.03ZM100,374v-52.5c0-10.62,2.73-20.39,8.2-29.3,5.47-8.91,12.73-15.7,21.8-20.39,19.38-9.69,39.06-16.95,59.06-21.8,20-4.84,40.31-7.27,60.94-7.27s40.94,2.42,60.94,7.27c20,4.84,39.69,12.11,59.06,21.8,9.06,4.69,16.33,11.48,21.8,20.39,5.47,8.91,8.2,18.67,8.2,29.3v52.5H100ZM137.5,336.5h225v-15c0-3.44-.86-6.56-2.58-9.37-1.72-2.81-3.98-5-6.8-6.56-16.87-8.44-33.91-14.77-51.09-18.98-17.19-4.22-34.53-6.33-52.03-6.33s-34.84,2.11-52.03,6.33c-17.19,4.22-34.22,10.55-51.09,18.98-2.81,1.56-5.08,3.75-6.8,6.56s-2.58,5.94-2.58,9.37v15ZM250,186.5c10.31,0,19.14-3.67,26.48-11.02,7.34-7.34,11.02-16.17,11.02-26.48s-3.67-19.14-11.02-26.48c-7.34-7.34-16.17-11.02-26.48-11.02s-19.14,3.67-26.48,11.02c-7.34,7.34-11.02,16.17-11.02,26.48s3.67,19.14,11.02,26.48c7.34,7.34,16.17,11.02,26.48,11.02Z" fill="#666"/>
-</svg>

package/app/scripts/aside/minor/topic.ts

@@ -1,3 +0,0 @@
-import type { Location } from '@shared/location';
-
-export const topicLocation = ref<Location>();

package/utils/slash.ts

@@ -1,11 +0,0 @@
-export function trailingSlash(path: string, add: boolean): string {
-    if (path === '/') {
-        return '/';
-    }
-
-    if (add) {
-        return path.endsWith('/') ? path : `${path}/`;
-    }
-
-    return path.endsWith('/') ? path.slice(0, -1) : path;
-}