@lobehub/chat 1.19.2 → 1.19.4

package/src/server/metadata.test.ts

@@ -0,0 +1,138 @@
+// @vitest-environment node
+import { describe, expect, it } from 'vitest';
+
+import { BRANDING_NAME } from '@/const/branding';
+import { OG_URL } from '@/const/url';
+
+import { Meta } from './metadata';
+
+describe('Metadata', () => {
+  const meta = new Meta();
+
+  describe('generate', () => {
+    it('should generate metadata with default values', () => {
+      const result = meta.generate({
+        title: 'Test Title',
+        url: 'https://example.com',
+      });
+
+      expect(result).toMatchObject({
+        title: 'Test Title',
+        description: expect.any(String),
+        openGraph: expect.objectContaining({
+          title: `Test Title · ${BRANDING_NAME}`,
+          description: expect.any(String),
+          images: [{ url: OG_URL, alt: `Test Title · ${BRANDING_NAME}` }],
+        }),
+        twitter: expect.objectContaining({
+          title: `Test Title · ${BRANDING_NAME}`,
+          description: expect.any(String),
+          images: [OG_URL],
+        }),
+      });
+    });
+
+    it('should generate metadata with custom values', () => {
+      const result = meta.generate({
+        title: 'Custom Title',
+        description: 'Custom description',
+        image: 'https://custom-image.com',
+        url: 'https://example.com/custom',
+        type: 'article',
+        tags: ['tag1', 'tag2'],
+        locale: 'fr-FR',
+        alternate: true,
+      });
+
+      expect(result).toMatchObject({
+        title: 'Custom Title',
+        description: expect.stringContaining('Custom description'),
+        openGraph: expect.objectContaining({
+          title: `Custom Title · ${BRANDING_NAME}`,
+          description: 'Custom description',
+          images: [{ url: 'https://custom-image.com', alt: `Custom Title · ${BRANDING_NAME}` }],
+          type: 'article',
+          locale: 'fr-FR',
+        }),
+        twitter: expect.objectContaining({
+          title: `Custom Title · ${BRANDING_NAME}`,
+          description: 'Custom description',
+          images: ['https://custom-image.com'],
+        }),
+        alternates: expect.objectContaining({
+          languages: expect.any(Object),
+        }),
+      });
+    });
+  });
+
+  describe('genAlternateLocales', () => {
+    it('should generate alternate locales correctly', () => {
+      const result = (meta as any).genAlternateLocales('en', '/test');
+
+      expect(result).toHaveProperty('x-default', expect.stringContaining('/test'));
+      expect(result).toHaveProperty('zh-CN', expect.stringContaining('hl=zh-CN'));
+      expect(result).not.toHaveProperty('en');
+    });
+  });
+
+  describe('genTwitter', () => {
+    it('should generate Twitter metadata correctly', () => {
+      const result = (meta as any).genTwitter({
+        title: 'Twitter Title',
+        description: 'Twitter description',
+        image: 'https://twitter-image.com',
+        url: 'https://example.com/twitter',
+      });
+
+      expect(result).toEqual({
+        card: 'summary_large_image',
+        title: 'Twitter Title',
+        description: 'Twitter description',
+        images: ['https://twitter-image.com'],
+        site: '@lobehub',
+        url: 'https://example.com/twitter',
+      });
+    });
+  });
+
+  describe('genOpenGraph', () => {
+    it('should generate OpenGraph metadata correctly', () => {
+      const result = (meta as any).genOpenGraph({
+        title: 'OG Title',
+        description: 'OG description',
+        image: 'https://og-image.com',
+        url: 'https://example.com/og',
+        locale: 'es-ES',
+        type: 'article',
+        alternate: true,
+      });
+
+      expect(result).toMatchObject({
+        title: 'OG Title',
+        description: 'OG description',
+        images: [{ url: 'https://og-image.com', alt: 'OG Title' }],
+        locale: 'es-ES',
+        type: 'article',
+        url: 'https://example.com/og',
+        siteName: 'LobeChat',
+        alternateLocale: expect.arrayContaining([
+          'ar',
+          'bg-BG',
+          'de-DE',
+          'en-US',
+          'es-ES',
+          'fr-FR',
+          'ja-JP',
+          'ko-KR',
+          'pt-BR',
+          'ru-RU',
+          'tr-TR',
+          'zh-CN',
+          'zh-TW',
+          'vi-VN',
+        ]),
+      });
+    });
+  });
+});

package/src/server/metadata.ts

@@ -3,8 +3,9 @@ import qs from 'query-string';
 
 import { BRANDING_NAME } from '@/const/branding';
 import { DEFAULT_LANG } from '@/const/locale';
-import { OG_URL, getCanonicalUrl } from '@/const/url';
+import { OG_URL } from '@/const/url';
 import { Locales, locales } from '@/locales/resources';
+import { getCanonicalUrl } from '@/server/utils/url';
 import { formatDescLength, formatTitleLength } from '@/utils/genOG';
 
 export class Meta {
@@ -59,7 +60,6 @@ export class Meta {
     let links: any = {};
     const defaultLink = getCanonicalUrl(path);
     for (const alterLocales of locales) {
-      if (locale === alterLocales) continue;
       links[alterLocales] = qs.stringifyUrl({
         query: { hl: alterLocales },
         url: defaultLink,
@@ -125,7 +125,7 @@ export class Meta {
     };
 
     if (alternate) {
-      data['alternateLocale'] = locales.filter((l) => l !== locale);
+      data['alternateLocale'] = locales;
     }
 
     return data;

package/src/server/modules/AssistantStore/index.test.ts

@@ -13,7 +13,7 @@ describe('AssistantStore', () => {
 
   it('should return the index URL for a not supported language', () => {
     const agentMarket = new AssistantStore();
-    const url = agentMarket.getAgentIndexUrl('ko-KR');
+    const url = agentMarket.getAgentIndexUrl('xxx' as any);
     expect(url).toBe('https://chat-agents.lobehub.com');
   });
 

package/src/server/modules/AssistantStore/index.ts

@@ -4,10 +4,6 @@ import { appEnv } from '@/config/app';
 import { DEFAULT_LANG, isLocaleNotSupport } from '@/const/locale';
 import { Locales, normalizeLocale } from '@/locales/resources';
 
-const checkSupportLocale = (lang: Locales) => {
-  return isLocaleNotSupport(lang) || normalizeLocale(lang) !== 'zh-CN';
-};
-
 export class AssistantStore {
   private readonly baseUrl: string;
 
@@ -16,13 +12,13 @@ export class AssistantStore {
   }
 
   getAgentIndexUrl = (lang: Locales = DEFAULT_LANG) => {
-    if (checkSupportLocale(lang)) return this.baseUrl;
+    if (isLocaleNotSupport(lang)) return this.baseUrl;
 
     return urlJoin(this.baseUrl, `index.${normalizeLocale(lang)}.json`);
   };
 
   getAgentUrl = (identifier: string, lang: Locales = DEFAULT_LANG) => {
-    if (checkSupportLocale(lang)) return urlJoin(this.baseUrl, `${identifier}.json`);
+    if (isLocaleNotSupport(lang)) return urlJoin(this.baseUrl, `${identifier}.json`);
 
     return urlJoin(this.baseUrl, `${identifier}.${normalizeLocale(lang)}.json`);
   };

package/src/server/sitemap.test.ts

@@ -0,0 +1,179 @@
+// @vitest-environment node
+import { describe, expect, it, vi } from 'vitest';
+
+import { getCanonicalUrl } from '@/server/utils/url';
+import { AssistantCategory, PluginCategory } from '@/types/discover';
+
+import { LAST_MODIFIED, Sitemap, SitemapType } from './sitemap';
+
+describe('Sitemap', () => {
+  const sitemap = new Sitemap();
+
+  describe('getIndex', () => {
+    it('should return a valid sitemap index', () => {
+      const index = sitemap.getIndex();
+      expect(index).toContain('<?xml version="1.0" encoding="UTF-8"?>');
+      expect(index).toContain('<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">');
+      [
+        SitemapType.Pages,
+        SitemapType.Assistants,
+        SitemapType.Plugins,
+        SitemapType.Models,
+        SitemapType.Providers,
+      ].forEach((type) => {
+        expect(index).toContain(`<loc>${getCanonicalUrl(`/sitemap/${type}.xml`)}</loc>`);
+      });
+      expect(index).toContain(`<lastmod>${LAST_MODIFIED}</lastmod>`);
+    });
+  });
+
+  describe('getPage', () => {
+    it('should return a valid page sitemap', async () => {
+      const pageSitemap = await sitemap.getPage();
+      expect(pageSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/'),
+          changeFrequency: 'monthly',
+          priority: 0.4,
+        }),
+      );
+      expect(pageSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/discover'),
+          changeFrequency: 'daily',
+          priority: 0.7,
+        }),
+      );
+      Object.values(AssistantCategory).forEach((category) => {
+        expect(pageSitemap).toContainEqual(
+          expect.objectContaining({
+            url: getCanonicalUrl(`/discover/assistants/${category}`),
+            changeFrequency: 'daily',
+            priority: 0.7,
+          }),
+        );
+      });
+      Object.values(PluginCategory).forEach((category) => {
+        expect(pageSitemap).toContainEqual(
+          expect.objectContaining({
+            url: getCanonicalUrl(`/discover/plugins/${category}`),
+            changeFrequency: 'daily',
+            priority: 0.7,
+          }),
+        );
+      });
+    });
+  });
+
+  describe('getAssistants', () => {
+    it('should return a valid assistants sitemap', async () => {
+      vi.spyOn(sitemap['discoverService'], 'getAssistantList').mockResolvedValue([
+        // @ts-ignore
+        { identifier: 'test-assistant', createdAt: '2023-01-01' },
+      ]);
+
+      const assistantsSitemap = await sitemap.getAssistants();
+      expect(assistantsSitemap.length).toBe(14);
+      expect(assistantsSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/discover/assistant/test-assistant'),
+          lastModified: '2023-01-01T00:00:00.000Z',
+        }),
+      );
+      expect(assistantsSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/discover/assistant/test-assistant?hl=zh-CN'),
+          lastModified: '2023-01-01T00:00:00.000Z',
+        }),
+      );
+    });
+  });
+
+  describe('getPlugins', () => {
+    it('should return a valid plugins sitemap', async () => {
+      vi.spyOn(sitemap['discoverService'], 'getPluginList').mockResolvedValue([
+        // @ts-ignore
+        { identifier: 'test-plugin', createdAt: '2023-01-01' },
+      ]);
+
+      const pluginsSitemap = await sitemap.getPlugins();
+      expect(pluginsSitemap.length).toBe(14);
+      expect(pluginsSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/discover/plugin/test-plugin'),
+          lastModified: '2023-01-01T00:00:00.000Z',
+        }),
+      );
+      expect(pluginsSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/discover/plugin/test-plugin?hl=ja-JP'),
+          lastModified: '2023-01-01T00:00:00.000Z',
+        }),
+      );
+    });
+  });
+
+  describe('getModels', () => {
+    it('should return a valid models sitemap', async () => {
+      vi.spyOn(sitemap['discoverService'], 'getModelList').mockResolvedValue([
+        // @ts-ignore
+        { identifier: 'test:model', createdAt: '2023-01-01' },
+      ]);
+
+      const modelsSitemap = await sitemap.getModels();
+      expect(modelsSitemap.length).toBe(14);
+      expect(modelsSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/discover/model/test:model'),
+          lastModified: '2023-01-01T00:00:00.000Z',
+        }),
+      );
+      expect(modelsSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/discover/model/test:model?hl=ko-KR'),
+          lastModified: '2023-01-01T00:00:00.000Z',
+        }),
+      );
+    });
+  });
+
+  describe('getProviders', () => {
+    it('should return a valid providers sitemap', async () => {
+      vi.spyOn(sitemap['discoverService'], 'getProviderList').mockResolvedValue([
+        // @ts-ignore
+        { identifier: 'test-provider', createdAt: '2023-01-01' },
+      ]);
+
+      const providersSitemap = await sitemap.getProviders();
+      expect(providersSitemap.length).toBe(14);
+      expect(providersSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/discover/provider/test-provider'),
+          lastModified: '2023-01-01T00:00:00.000Z',
+        }),
+      );
+      expect(providersSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/discover/provider/test-provider?hl=ar'),
+          lastModified: '2023-01-01T00:00:00.000Z',
+        }),
+      );
+    });
+  });
+
+  describe('getRobots', () => {
+    it('should return correct robots.txt entries', () => {
+      const robots = sitemap.getRobots();
+      expect(robots).toContain(getCanonicalUrl('/sitemap-index.xml'));
+      [
+        SitemapType.Pages,
+        SitemapType.Assistants,
+        SitemapType.Plugins,
+        SitemapType.Models,
+        SitemapType.Providers,
+      ].forEach((type) => {
+        expect(robots).toContain(getCanonicalUrl(`/sitemap/${type}.xml`));
+      });
+    });
+  });
+});

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();