@lobehub/chat 1.19.3 → 1.19.5

package/src/server/sitemap.ts

@@ -0,0 +1,243 @@
+import { flatten } from 'lodash-es';
+import { MetadataRoute } from 'next';
+import qs from 'query-string';
+import urlJoin from 'url-join';
+
+import { DEFAULT_LANG } from '@/const/locale';
+import { SITEMAP_BASE_URL } from '@/const/url';
+import { Locales, locales as allLocales } from '@/locales/resources';
+import { DiscoverService } from '@/server/services/discover';
+import { getCanonicalUrl } from '@/server/utils/url';
+import { AssistantCategory, PluginCategory } from '@/types/discover';
+import { isDev } from '@/utils/env';
+
+export interface SitemapItem {
+  alternates?: {
+    languages?: string;
+  };
+  changeFrequency?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+  lastModified?: string | Date;
+  priority?: number;
+  url: string;
+}
+
+export enum SitemapType {
+  Assistants = 'assistants',
+  Models = 'models',
+  Pages = 'pages',
+  Plugins = 'plugins',
+  Providers = 'providers',
+}
+
+export const LAST_MODIFIED = new Date().toISOString();
+
+export class Sitemap {
+  sitemapIndexs = [
+    { id: SitemapType.Pages },
+    { id: SitemapType.Assistants },
+    { id: SitemapType.Plugins },
+    { id: SitemapType.Models },
+    { id: SitemapType.Providers },
+  ];
+
+  private discoverService = new DiscoverService();
+
+  private _generateSitemapLink(url: string) {
+    return [
+      '<sitemap>',
+      `<loc>${url}</loc>`,
+      `<lastmod>${LAST_MODIFIED}</lastmod>`,
+      '</sitemap>',
+    ].join('\n');
+  }
+
+  private _formatTime(time?: string) {
+    try {
+      if (!time) return LAST_MODIFIED;
+      return new Date(time).toISOString() || LAST_MODIFIED;
+    } catch {
+      return LAST_MODIFIED;
+    }
+  }
+
+  private _genSitemapItem = (
+    lang: Locales,
+    url: string,
+    {
+      lastModified,
+      changeFrequency = 'monthly',
+      priority = 0.4,
+      noLocales,
+      locales = allLocales,
+    }: {
+      changeFrequency?: SitemapItem['changeFrequency'];
+      lastModified?: string;
+      locales?: typeof allLocales;
+      noLocales?: boolean;
+      priority?: number;
+    } = {},
+  ) => {
+    const sitemap = {
+      changeFrequency,
+      lastModified: this._formatTime(lastModified),
+      priority,
+      url:
+        lang === DEFAULT_LANG
+          ? getCanonicalUrl(url)
+          : qs.stringifyUrl({ query: { hl: lang }, url: getCanonicalUrl(url) }),
+    };
+    if (noLocales) return sitemap;
+
+    const languages: any = {};
+    for (const locale of locales) {
+      if (locale === lang) continue;
+      languages[locale] = qs.stringifyUrl({
+        query: { hl: locale },
+        url: getCanonicalUrl(url),
+      });
+    }
+    return {
+      alternates: {
+        languages,
+      },
+      ...sitemap,
+    };
+  };
+
+  private _genSitemap(
+    url: string,
+    {
+      lastModified,
+      changeFrequency = 'monthly',
+      priority = 0.4,
+      noLocales,
+      locales = allLocales,
+    }: {
+      changeFrequency?: SitemapItem['changeFrequency'];
+      lastModified?: string;
+      locales?: typeof allLocales;
+      noLocales?: boolean;
+      priority?: number;
+    } = {},
+  ) {
+    if (noLocales)
+      return [
+        this._genSitemapItem(DEFAULT_LANG, url, {
+          changeFrequency,
+          lastModified,
+          locales,
+          noLocales,
+          priority,
+        }),
+      ];
+    return locales.map((lang) =>
+      this._genSitemapItem(lang, url, {
+        changeFrequency,
+        lastModified,
+        locales,
+        noLocales,
+        priority,
+      }),
+    );
+  }
+
+  getIndex(): string {
+    return [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+      ...this.sitemapIndexs.map((item) =>
+        this._generateSitemapLink(
+          getCanonicalUrl(SITEMAP_BASE_URL, isDev ? item.id : `${item.id}.xml`),
+        ),
+      ),
+      '</sitemapindex>',
+    ].join('\n');
+  }
+
+  async getAssistants(): Promise<MetadataRoute.Sitemap> {
+    const list = await this.discoverService.getAssistantList(DEFAULT_LANG);
+    const sitmap = list.map((item) =>
+      this._genSitemap(urlJoin('/discover/assistant', item.identifier), {
+        lastModified: item?.createdAt || LAST_MODIFIED,
+      }),
+    );
+    return flatten(sitmap);
+  }
+
+  async getPlugins(): Promise<MetadataRoute.Sitemap> {
+    const list = await this.discoverService.getPluginList(DEFAULT_LANG);
+    const sitmap = list.map((item) =>
+      this._genSitemap(urlJoin('/discover/plugin', item.identifier), {
+        lastModified: item?.createdAt || LAST_MODIFIED,
+      }),
+    );
+    return flatten(sitmap);
+  }
+
+  async getModels(): Promise<MetadataRoute.Sitemap> {
+    const list = await this.discoverService.getModelList(DEFAULT_LANG);
+    const sitmap = list.map((item) =>
+      this._genSitemap(urlJoin('/discover/model', item.identifier), {
+        lastModified: item?.createdAt || LAST_MODIFIED,
+      }),
+    );
+    return flatten(sitmap);
+  }
+
+  async getProviders(): Promise<MetadataRoute.Sitemap> {
+    const list = await this.discoverService.getProviderList(DEFAULT_LANG);
+    const sitmap = list.map((item) =>
+      this._genSitemap(urlJoin('/discover/provider', item.identifier), {
+        lastModified: item?.createdAt || LAST_MODIFIED,
+      }),
+    );
+    return flatten(sitmap);
+  }
+
+  async getPage(): Promise<MetadataRoute.Sitemap> {
+    const assistantsCategory = Object.values(AssistantCategory);
+    const pluginCategory = Object.values(PluginCategory);
+    const modelCategory = await this.discoverService.getProviderList(DEFAULT_LANG);
+    return [
+      ...this._genSitemap('/', { noLocales: true }),
+      ...this._genSitemap('/chat', { noLocales: true }),
+      ...this._genSitemap('/welcome', { noLocales: true }),
+      /* ↓ cloud slot ↓ */
+
+      /* ↑ cloud slot ↑ */
+      ...this._genSitemap('/discover', { changeFrequency: 'daily', priority: 0.7 }),
+      ...this._genSitemap('/discover/assistants', { changeFrequency: 'daily', priority: 0.7 }),
+      ...assistantsCategory.flatMap((slug) =>
+        this._genSitemap(`/discover/assistants/${slug}`, {
+          changeFrequency: 'daily',
+          priority: 0.7,
+        }),
+      ),
+      ...this._genSitemap('/discover/plugins', { changeFrequency: 'daily', priority: 0.7 }),
+      ...pluginCategory.flatMap((slug) =>
+        this._genSitemap(`/discover/plugins/${slug}`, {
+          changeFrequency: 'daily',
+          priority: 0.7,
+        }),
+      ),
+      ...this._genSitemap('/discover/models', { changeFrequency: 'daily', priority: 0.7 }),
+      ...modelCategory.flatMap((slug) =>
+        this._genSitemap(`/discover/models/${slug}`, {
+          changeFrequency: 'daily',
+          priority: 0.7,
+        }),
+      ),
+      ...this._genSitemap('/discover/providers', { changeFrequency: 'daily', priority: 0.7 }),
+    ];
+  }
+  getRobots() {
+    return [
+      getCanonicalUrl('/sitemap-index.xml'),
+      ...this.sitemapIndexs.map((index) =>
+        getCanonicalUrl(SITEMAP_BASE_URL, isDev ? index.id : `${index.id}.xml`),
+      ),
+    ];
+  }
+}
+
+export const sitemapModule = new Sitemap();

package/src/server/translation.test.ts

@@ -0,0 +1,137 @@
+// @vitest-environment node
+import { cookies } from 'next/headers';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { DEFAULT_LANG, LOBE_LOCALE_COOKIE } from '@/const/locale';
+import { normalizeLocale } from '@/locales/resources';
+import * as env from '@/utils/env';
+
+import { getLocale, translation } from './translation';
+
+// Mock external dependencies
+vi.mock('next/headers', () => ({
+  cookies: vi.fn(),
+}));
+
+vi.mock('node:fs', () => ({
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+}));
+
+vi.mock('node:path', () => ({
+  join: vi.fn(),
+}));
+
+vi.mock('@/const/locale', () => ({
+  DEFAULT_LANG: 'en-US',
+  LOBE_LOCALE_COOKIE: 'LOBE_LOCALE',
+}));
+
+vi.mock('@/locales/resources', () => ({
+  normalizeLocale: vi.fn((locale) => locale),
+}));
+
+vi.mock('@/utils/env', () => ({
+  isDev: false,
+}));
+
+describe('getLocale', () => {
+  const mockCookieStore = {
+    get: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (cookies as any).mockReturnValue(mockCookieStore);
+  });
+
+  it('should return the provided locale if hl is specified', async () => {
+    const result = await getLocale('fr-FR');
+    expect(result).toBe('fr-FR');
+    expect(normalizeLocale).toHaveBeenCalledWith('fr-FR');
+  });
+
+  it('should return the locale from cookie if available', async () => {
+    mockCookieStore.get.mockReturnValue({ value: 'de-DE' });
+    const result = await getLocale();
+    expect(result).toBe('de-DE');
+    expect(mockCookieStore.get).toHaveBeenCalledWith(LOBE_LOCALE_COOKIE);
+  });
+
+  it('should return DEFAULT_LANG if no cookie is set', async () => {
+    mockCookieStore.get.mockReturnValue(undefined);
+    const result = await getLocale();
+    expect(result).toBe(DEFAULT_LANG);
+  });
+});
+
+describe('translation', () => {
+  const mockTranslations = {
+    key1: 'Value 1',
+    key2: 'Value 2 with {{param}}',
+    nested: { key: 'Nested value' },
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (fs.existsSync as any).mockReturnValue(true);
+    (fs.readFileSync as any).mockReturnValue(JSON.stringify(mockTranslations));
+    (path.join as any).mockImplementation((...args: any) => args.join('/'));
+  });
+
+  it('should return correct translation object', async () => {
+    const result = await translation('common', 'en-US');
+    expect(result).toHaveProperty('locale', 'en-US');
+    expect(result).toHaveProperty('t');
+    expect(typeof result.t).toBe('function');
+  });
+
+  it('should translate keys correctly', async () => {
+    const { t } = await translation('common', 'en-US');
+    expect(t('key1')).toBe('Value 1');
+    expect(t('key2', { param: 'test' })).toBe('Value 2 with test');
+    expect(t('nested.key')).toBe('Nested value');
+  });
+
+  it('should return key if translation is not found', async () => {
+    const { t } = await translation('common', 'en-US');
+    expect(t('nonexistent.key')).toBe('nonexistent.key');
+  });
+
+  it('should use fallback language if specified locale file does not exist', async () => {
+    (fs.existsSync as any).mockReturnValueOnce(false);
+    await translation('common', 'nonexistent-LANG');
+    expect(fs.readFileSync).toHaveBeenCalledWith(
+      expect.stringContaining(`/${DEFAULT_LANG}/common.json`),
+      'utf8',
+    );
+  });
+
+  it('should use zh-CN in dev mode when fallback is needed', async () => {
+    (fs.existsSync as any).mockReturnValueOnce(false);
+    (env.isDev as unknown as boolean) = true;
+    await translation('common', 'nonexistent-LANG');
+    expect(fs.readFileSync).toHaveBeenCalledWith(
+      expect.stringContaining('/zh-CN/common.json'),
+      'utf8',
+    );
+  });
+
+  it('should handle file reading errors', async () => {
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    (fs.readFileSync as any).mockImplementation(() => {
+      throw new Error('File read error');
+    });
+
+    const result = await translation('common', 'en-US');
+    expect(result.t('any.key')).toBe('any.key');
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'Error while reading translation file',
+      expect.any(Error),
+    );
+
+    consoleErrorSpy.mockRestore();
+  });
+});

package/src/server/utils/url.test.ts

@@ -0,0 +1,61 @@
+// @vitest-environment node
+import urlJoin from 'url-join';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+// 模拟 urlJoin 函数
+vi.mock('url-join', () => ({
+  default: vi.fn((...args) => args.join('/')),
+}));
+
+describe('getCanonicalUrl', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    // 在每个测试前重置 process.env
+    vi.resetModules();
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    // 在每个测试后恢复原始的 process.env
+    process.env = originalEnv;
+  });
+
+  it('should return correct URL for production environment', async () => {
+    process.env.VERCEL = undefined;
+    process.env.VERCEL_ENV = undefined;
+
+    const { getCanonicalUrl } = await import('./url'); // 动态导入以获取最新的环境变量状态
+    const result = getCanonicalUrl('path', 'to', 'page');
+    expect(result).toBe('https://lobechat.com/path/to/page');
+    expect(urlJoin).toHaveBeenCalledWith('https://lobechat.com', 'path', 'to', 'page');
+  });
+
+  it('should return correct URL for Vercel preview environment', async () => {
+    process.env.VERCEL = '1';
+    process.env.VERCEL_ENV = 'preview';
+    process.env.VERCEL_URL = 'preview-url.vercel.app';
+
+    const { getCanonicalUrl } = await import('./url'); // 动态导入
+    const result = getCanonicalUrl('path', 'to', 'page');
+    expect(result).toBe('https://preview-url.vercel.app/path/to/page');
+    expect(urlJoin).toHaveBeenCalledWith('https://preview-url.vercel.app', 'path', 'to', 'page');
+  });
+
+  it('should return production URL when VERCEL is set but VERCEL_ENV is production', async () => {
+    process.env.VERCEL = '1';
+    process.env.VERCEL_ENV = 'production';
+
+    const { getCanonicalUrl } = await import('./url'); // 动态导入
+    const result = getCanonicalUrl('path', 'to', 'page');
+    expect(result).toBe('https://lobechat.com/path/to/page');
+    expect(urlJoin).toHaveBeenCalledWith('https://lobechat.com', 'path', 'to', 'page');
+  });
+
+  it('should work correctly without additional path arguments', async () => {
+    const { getCanonicalUrl } = await import('./url'); // 动态导入
+    const result = getCanonicalUrl();
+    expect(result).toBe('https://lobechat.com');
+    expect(urlJoin).toHaveBeenCalledWith('https://lobechat.com');
+  });
+});

package/src/server/utils/url.ts

@@ -0,0 +1,9 @@
+import urlJoin from 'url-join';
+
+const isVercelPreview = process.env.VERCEL === '1' && process.env.VERCEL_ENV !== 'production';
+
+const vercelPreviewUrl = `https://${process.env.VERCEL_URL}`;
+
+const siteUrl = isVercelPreview ? vercelPreviewUrl : 'https://lobechat.com';
+
+export const getCanonicalUrl = (...paths: string[]) => urlJoin(siteUrl, ...paths);

package/next-sitemap.config.mjs

@@ -1,53 +0,0 @@
-import { glob } from 'glob';
-
-const isVercelPreview = process.env.VERCEL === '1' && process.env.VERCEL_ENV !== 'production';
-
-const vercelPreviewUrl = `https://${process.env.VERCEL_URL}`;
-
-const siteUrl = isVercelPreview ? vercelPreviewUrl : 'https://lobechat.com';
-
-/** @type {import('next-sitemap').IConfig} */
-const config = {
-  // next-sitemap does not work with app dir inside the /src dir (and have other problems e.g. with route groups)
-  // https://github.com/iamvishnusankar/next-sitemap/issues/700#issuecomment-1759458127
-  // https://github.com/iamvishnusankar/next-sitemap/issues/701
-  // additionalPaths is a workaround for this (once the issues are fixed, we can remove it)
-  additionalPaths: async () => {
-    const routes = await glob('src/app/**/page.{md,mdx,ts,tsx}', {
-      cwd: new URL('.', import.meta.url).pathname,
-    });
-
-    // https://nextjs.org/docs/app/building-your-application/routing/colocation#private-folders
-    const publicRoutes = routes.filter(
-      (page) => !page.split('/').some((folder) => folder.startsWith('_')),
-    );
-
-    // https://nextjs.org/docs/app/building-your-application/routing/colocation#route-groups
-    const publicRoutesWithoutRouteGroups = publicRoutes.map((page) =>
-      page
-        .split('/')
-        .filter((folder) => !folder.startsWith('(') && !folder.endsWith(')'))
-        .join('/'),
-    );
-
-    const locs = publicRoutesWithoutRouteGroups.map((route) => {
-      const path = route.replace(/^src\/app/, '').replace(/\/[^/]+$/, '');
-      const loc = path === '' ? siteUrl : `${siteUrl}/${path}`;
-
-      return loc;
-    });
-
-    const paths = locs.map((loc) => ({
-      changefreq: 'daily',
-      lastmod: new Date().toISOString(),
-      loc,
-      priority: 0.7,
-    }));
-
-    return paths;
-  },
-  generateRobotsTxt: true,
-  siteUrl,
-};
-
-export default config;