@lobehub/chat 1.19.3 → 1.19.5

package/src/server/ld.test.ts

@@ -0,0 +1,102 @@
+// @vitest-environment node
+import { describe, expect, it } from 'vitest';
+
+import { DEFAULT_LANG } from '@/const/locale';
+
+import { AUTHOR_LIST, Ld } from './ld';
+
+describe('Ld', () => {
+  const ld = new Ld();
+
+  describe('generate', () => {
+    it('should generate correct LD+JSON structure', () => {
+      const result = ld.generate({
+        title: 'Test Title',
+        description: 'Test Description',
+        url: 'https://example.com/test',
+        locale: DEFAULT_LANG,
+      });
+
+      expect(result['@context']).toBe('https://schema.org');
+      expect(Array.isArray(result['@graph'])).toBe(true);
+      expect(result['@graph'].length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('genOrganization', () => {
+    it('should generate correct organization structure', () => {
+      const org = ld.genOrganization();
+
+      expect(org['@type']).toBe('Organization');
+      expect(org.name).toBe('LobeHub');
+      expect(org.url).toBe('https://lobehub.com/');
+    });
+  });
+
+  describe('getAuthors', () => {
+    it('should return default author when no ids provided', () => {
+      const author = ld.getAuthors();
+      expect(author['@type']).toBe('Organization');
+    });
+
+    it('should return person when valid id provided', () => {
+      const author = ld.getAuthors(['arvinxx']);
+      expect(author['@type']).toBe('Person');
+      // @ts-ignore
+      expect(author.name).toBe(AUTHOR_LIST.arvinxx.name);
+    });
+  });
+
+  describe('genWebPage', () => {
+    it('should generate correct webpage structure', () => {
+      const webpage = ld.genWebPage({
+        title: 'Test Page',
+        description: 'Test Description',
+        url: 'https://example.com/test',
+        locale: DEFAULT_LANG,
+      });
+
+      expect(webpage['@type']).toBe('WebPage');
+      expect(webpage.name).toBe('Test Page · LobeChat');
+      expect(webpage.description).toBe('Test Description');
+    });
+  });
+
+  describe('genImageObject', () => {
+    it('should generate correct image object', () => {
+      const image = ld.genImageObject({
+        image: 'https://example.com/image.jpg',
+        url: 'https://example.com/test',
+      });
+
+      expect(image['@type']).toBe('ImageObject');
+      expect(image.url).toBe('https://example.com/image.jpg');
+    });
+  });
+
+  describe('genWebSite', () => {
+    it('should generate correct website structure', () => {
+      const website = ld.genWebSite();
+
+      expect(website['@type']).toBe('WebSite');
+      expect(website.name).toBe('LobeChat');
+    });
+  });
+
+  describe('genArticle', () => {
+    it('should generate correct article structure', () => {
+      const article = ld.genArticle({
+        title: 'Test Article',
+        description: 'Test Description',
+        url: 'https://example.com/test',
+        author: ['arvinxx'],
+        identifier: 'test-id',
+        locale: DEFAULT_LANG,
+      });
+
+      expect(article['@type']).toBe('Article');
+      expect(article.headline).toBe('Test Article · LobeChat');
+      expect(article.author['@type']).toBe('Person');
+    });
+  });
+});

package/src/server/ld.ts

@@ -3,15 +3,9 @@ import urlJoin from 'url-join';
 
 import { BRANDING_NAME } from '@/const/branding';
 import { DEFAULT_LANG } from '@/const/locale';
-import {
-  EMAIL_BUSINESS,
-  EMAIL_SUPPORT,
-  OFFICIAL_SITE,
-  OFFICIAL_URL,
-  X,
-  getCanonicalUrl,
-} from '@/const/url';
+import { EMAIL_BUSINESS, EMAIL_SUPPORT, OFFICIAL_SITE, OFFICIAL_URL, X } from '@/const/url';
 import { Locales } from '@/locales/resources';
+import { getCanonicalUrl } from '@/server/utils/url';
 
 import pkg from '../../package.json';
 
@@ -37,7 +31,7 @@ export const AUTHOR_LIST = {
   },
 };
 
-class Ld {
+export class Ld {
   generate({
     image = '/og/cover.png',
     article,

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`));
+      });
+    });
+  });
+});