@lobehub/lobehub 2.0.0-next.276 → 2.0.0-next.278

package/src/server/routers/lambda/__tests__/share.test.ts

@@ -0,0 +1,227 @@
+import { TRPCError } from '@trpc/server';
+import { describe, expect, it, vi } from 'vitest';
+
+import { TopicShareModel } from '@/database/models/topicShare';
+
+vi.mock('@/database/models/topicShare', () => ({
+  TopicShareModel: {
+    findByShareIdWithAccessCheck: vi.fn(),
+    incrementPageViewCount: vi.fn(),
+  },
+}));
+
+vi.mock('@/database/server', () => ({
+  getServerDB: vi.fn(),
+}));
+
+describe('shareRouter', () => {
+  describe('getSharedTopic', () => {
+    it('should return shared topic data for valid share', async () => {
+      const mockShare = {
+        agentAvatar: 'avatar.png',
+        agentBackgroundColor: '#fff',
+        agentId: 'agent-1',
+        agentMarketIdentifier: 'market-id',
+        agentSlug: 'agent-slug',
+        agentTitle: 'Test Agent',
+        groupAvatar: null,
+        groupBackgroundColor: null,
+        groupId: null,
+        groupMembers: undefined,
+        groupTitle: null,
+        ownerId: 'user-1',
+        shareId: 'share-123',
+        title: 'Test Topic',
+        topicId: 'topic-1',
+        visibility: 'link',
+      };
+
+      vi.mocked(TopicShareModel.findByShareIdWithAccessCheck).mockResolvedValue(mockShare);
+      vi.mocked(TopicShareModel.incrementPageViewCount).mockResolvedValue(undefined);
+
+      const ctx = {
+        serverDB: {} as any,
+        userId: 'user-1',
+      };
+
+      const share = await TopicShareModel.findByShareIdWithAccessCheck(
+        ctx.serverDB,
+        'share-123',
+        ctx.userId,
+      );
+
+      expect(share).toBeDefined();
+      expect(share.shareId).toBe('share-123');
+      expect(share.topicId).toBe('topic-1');
+      expect(share.title).toBe('Test Topic');
+      expect(share.visibility).toBe('link');
+
+      // Verify incrementPageViewCount would be called
+      await TopicShareModel.incrementPageViewCount(ctx.serverDB, 'share-123');
+      expect(TopicShareModel.incrementPageViewCount).toHaveBeenCalledWith(
+        ctx.serverDB,
+        'share-123',
+      );
+    });
+
+    it('should return agent meta when share has agent', async () => {
+      const mockShare = {
+        agentAvatar: 'avatar.png',
+        agentBackgroundColor: '#ffffff',
+        agentId: 'agent-1',
+        agentMarketIdentifier: 'market-agent',
+        agentSlug: 'test-agent',
+        agentTitle: 'Test Agent Title',
+        groupAvatar: null,
+        groupBackgroundColor: null,
+        groupId: null,
+        groupMembers: undefined,
+        groupTitle: null,
+        ownerId: 'user-1',
+        shareId: 'share-123',
+        title: 'Topic with Agent',
+        topicId: 'topic-1',
+        visibility: 'link',
+      };
+
+      vi.mocked(TopicShareModel.findByShareIdWithAccessCheck).mockResolvedValue(mockShare);
+
+      const ctx = {
+        serverDB: {} as any,
+        userId: null,
+      };
+
+      const share = await TopicShareModel.findByShareIdWithAccessCheck(
+        ctx.serverDB,
+        'share-123',
+        undefined,
+      );
+
+      expect(share.agentId).toBe('agent-1');
+      expect(share.agentAvatar).toBe('avatar.png');
+      expect(share.agentTitle).toBe('Test Agent Title');
+      expect(share.agentMarketIdentifier).toBe('market-agent');
+      expect(share.agentSlug).toBe('test-agent');
+    });
+
+    it('should return group meta when share has group', async () => {
+      const mockShare = {
+        agentAvatar: null,
+        agentBackgroundColor: null,
+        agentId: null,
+        agentMarketIdentifier: null,
+        agentSlug: null,
+        agentTitle: null,
+        groupAvatar: 'group-avatar.png',
+        groupBackgroundColor: '#000000',
+        groupId: 'group-1',
+        groupMembers: [
+          { avatar: 'member1.png', backgroundColor: '#111' },
+          { avatar: 'member2.png', backgroundColor: '#222' },
+        ],
+        groupTitle: 'Test Group',
+        ownerId: 'user-1',
+        shareId: 'share-456',
+        title: 'Group Topic',
+        topicId: 'topic-2',
+        visibility: 'link',
+      };
+
+      vi.mocked(TopicShareModel.findByShareIdWithAccessCheck).mockResolvedValue(mockShare);
+
+      const ctx = {
+        serverDB: {} as any,
+        userId: 'user-2',
+      };
+
+      const share = await TopicShareModel.findByShareIdWithAccessCheck(
+        ctx.serverDB,
+        'share-456',
+        ctx.userId,
+      );
+
+      expect(share.groupId).toBe('group-1');
+      expect(share.groupTitle).toBe('Test Group');
+      expect(share.groupAvatar).toBe('group-avatar.png');
+      expect(share.groupMembers).toHaveLength(2);
+    });
+
+    it('should throw NOT_FOUND for non-existent share', async () => {
+      vi.mocked(TopicShareModel.findByShareIdWithAccessCheck).mockRejectedValue(
+        new TRPCError({ code: 'NOT_FOUND', message: 'Share not found' }),
+      );
+
+      const ctx = {
+        serverDB: {} as any,
+        userId: 'user-1',
+      };
+
+      await expect(
+        TopicShareModel.findByShareIdWithAccessCheck(ctx.serverDB, 'non-existent', ctx.userId),
+      ).rejects.toThrow(TRPCError);
+    });
+
+    it('should throw FORBIDDEN for private share accessed by non-owner', async () => {
+      vi.mocked(TopicShareModel.findByShareIdWithAccessCheck).mockRejectedValue(
+        new TRPCError({ code: 'FORBIDDEN', message: 'This share is private' }),
+      );
+
+      const ctx = {
+        serverDB: {} as any,
+        userId: 'other-user',
+      };
+
+      await expect(
+        TopicShareModel.findByShareIdWithAccessCheck(ctx.serverDB, 'private-share', ctx.userId),
+      ).rejects.toThrow(TRPCError);
+
+      try {
+        await TopicShareModel.findByShareIdWithAccessCheck(
+          ctx.serverDB,
+          'private-share',
+          ctx.userId,
+        );
+      } catch (error) {
+        expect((error as TRPCError).code).toBe('FORBIDDEN');
+      }
+    });
+
+    it('should allow owner to access private share', async () => {
+      const mockShare = {
+        agentAvatar: null,
+        agentBackgroundColor: null,
+        agentId: null,
+        agentMarketIdentifier: null,
+        agentSlug: null,
+        agentTitle: null,
+        groupAvatar: null,
+        groupBackgroundColor: null,
+        groupId: null,
+        groupMembers: undefined,
+        groupTitle: null,
+        ownerId: 'owner-user',
+        shareId: 'private-share',
+        title: 'Private Topic',
+        topicId: 'topic-private',
+        visibility: 'private',
+      };
+
+      vi.mocked(TopicShareModel.findByShareIdWithAccessCheck).mockResolvedValue(mockShare);
+
+      const ctx = {
+        serverDB: {} as any,
+        userId: 'owner-user',
+      };
+
+      const share = await TopicShareModel.findByShareIdWithAccessCheck(
+        ctx.serverDB,
+        'private-share',
+        ctx.userId,
+      );
+
+      expect(share).toBeDefined();
+      expect(share.ownerId).toBe('owner-user');
+      expect(share.visibility).toBe('private');
+    });
+  });
+});

package/src/server/routers/lambda/__tests__/topic.test.ts

@@ -1,11 +1,16 @@
 import { describe, expect, it, vi } from 'vitest';
 
 import { TopicModel } from '@/database/models/topic';
+import { TopicShareModel } from '@/database/models/topicShare';
 
 vi.mock('@/database/models/topic', () => ({
   TopicModel: vi.fn(),
 }));
 
+vi.mock('@/database/models/topicShare', () => ({
+  TopicShareModel: vi.fn(),
+}));
+
 vi.mock('@/database/server', () => ({
   getServerDB: vi.fn(),
 }));
@@ -260,4 +265,173 @@ describe('topicRouter', () => {
       expect(result).toEqual([{ id: 'topic1', title: 'Test' }]);
     });
   });
+
+  describe('topic sharing', () => {
+    it('should handle enableSharing with default visibility', async () => {
+      const mockCreate = vi.fn().mockResolvedValue({
+        id: 'share-123',
+        topicId: 'topic1',
+        userId: 'user1',
+        visibility: 'private',
+      });
+
+      vi.mocked(TopicShareModel).mockImplementation(
+        () =>
+          ({
+            create: mockCreate,
+          }) as any,
+      );
+
+      const ctx = {
+        topicShareModel: new TopicShareModel({} as any, 'user1'),
+      };
+
+      const result = await ctx.topicShareModel.create('topic1');
+
+      expect(mockCreate).toHaveBeenCalledWith('topic1');
+      expect(result.id).toBe('share-123');
+      expect(result.visibility).toBe('private');
+    });
+
+    it('should handle enableSharing with link visibility', async () => {
+      const mockCreate = vi.fn().mockResolvedValue({
+        id: 'share-456',
+        topicId: 'topic1',
+        userId: 'user1',
+        visibility: 'link',
+      });
+
+      vi.mocked(TopicShareModel).mockImplementation(
+        () =>
+          ({
+            create: mockCreate,
+          }) as any,
+      );
+
+      const ctx = {
+        topicShareModel: new TopicShareModel({} as any, 'user1'),
+      };
+
+      const result = await ctx.topicShareModel.create('topic1', 'link');
+
+      expect(mockCreate).toHaveBeenCalledWith('topic1', 'link');
+      expect(result.visibility).toBe('link');
+    });
+
+    it('should handle disableSharing', async () => {
+      const mockDeleteByTopicId = vi.fn().mockResolvedValue(undefined);
+
+      vi.mocked(TopicShareModel).mockImplementation(
+        () =>
+          ({
+            deleteByTopicId: mockDeleteByTopicId,
+          }) as any,
+      );
+
+      const ctx = {
+        topicShareModel: new TopicShareModel({} as any, 'user1'),
+      };
+
+      await ctx.topicShareModel.deleteByTopicId('topic1');
+
+      expect(mockDeleteByTopicId).toHaveBeenCalledWith('topic1');
+    });
+
+    it('should handle updateShareVisibility', async () => {
+      const mockUpdateVisibility = vi.fn().mockResolvedValue({
+        id: 'share-123',
+        topicId: 'topic1',
+        visibility: 'link',
+      });
+
+      vi.mocked(TopicShareModel).mockImplementation(
+        () =>
+          ({
+            updateVisibility: mockUpdateVisibility,
+          }) as any,
+      );
+
+      const ctx = {
+        topicShareModel: new TopicShareModel({} as any, 'user1'),
+      };
+
+      const result = await ctx.topicShareModel.updateVisibility('topic1', 'link');
+
+      expect(mockUpdateVisibility).toHaveBeenCalledWith('topic1', 'link');
+      expect(result.visibility).toBe('link');
+    });
+
+    it('should handle getShareInfo', async () => {
+      const mockGetByTopicId = vi.fn().mockResolvedValue({
+        id: 'share-123',
+        topicId: 'topic1',
+        visibility: 'link',
+      });
+
+      vi.mocked(TopicShareModel).mockImplementation(
+        () =>
+          ({
+            getByTopicId: mockGetByTopicId,
+          }) as any,
+      );
+
+      const ctx = {
+        topicShareModel: new TopicShareModel({} as any, 'user1'),
+      };
+
+      const result = await ctx.topicShareModel.getByTopicId('topic1');
+
+      expect(mockGetByTopicId).toHaveBeenCalledWith('topic1');
+      expect(result).toEqual({
+        id: 'share-123',
+        topicId: 'topic1',
+        visibility: 'link',
+      });
+    });
+
+    it('should return null when getShareInfo for non-shared topic', async () => {
+      const mockGetByTopicId = vi.fn().mockResolvedValue(null);
+
+      vi.mocked(TopicShareModel).mockImplementation(
+        () =>
+          ({
+            getByTopicId: mockGetByTopicId,
+          }) as any,
+      );
+
+      const ctx = {
+        topicShareModel: new TopicShareModel({} as any, 'user1'),
+      };
+
+      const result = await ctx.topicShareModel.getByTopicId('non-shared-topic');
+
+      expect(mockGetByTopicId).toHaveBeenCalledWith('non-shared-topic');
+      expect(result).toBeNull();
+    });
+
+    it('should handle all visibility types', async () => {
+      const mockCreate = vi.fn();
+
+      vi.mocked(TopicShareModel).mockImplementation(
+        () =>
+          ({
+            create: mockCreate,
+          }) as any,
+      );
+
+      const ctx = {
+        topicShareModel: new TopicShareModel({} as any, 'user1'),
+      };
+
+      // Test private visibility
+      mockCreate.mockResolvedValueOnce({ visibility: 'private' });
+      await ctx.topicShareModel.create('topic1', 'private');
+      expect(mockCreate).toHaveBeenLastCalledWith('topic1', 'private');
+
+      // Test link visibility
+      mockCreate.mockResolvedValueOnce({ visibility: 'link' });
+      await ctx.topicShareModel.create('topic2', 'link');
+      expect(mockCreate).toHaveBeenLastCalledWith('topic2', 'link');
+    });
+  });
 });

package/src/server/routers/lambda/index.ts

@@ -37,6 +37,7 @@ import { ragEvalRouter } from './ragEval';
 import { searchRouter } from './search';
 import { sessionRouter } from './session';
 import { sessionGroupRouter } from './sessionGroup';
+import { shareRouter } from './share';
 import { threadRouter } from './thread';
 import { topicRouter } from './topic';
 import { uploadRouter } from './upload';
@@ -77,6 +78,7 @@ export const lambdaRouter = router({
   search: searchRouter,
   session: sessionRouter,
   sessionGroup: sessionGroupRouter,
+  share: shareRouter,
   thread: threadRouter,
   topic: topicRouter,
   upload: uploadRouter,

package/src/server/routers/lambda/message.ts

@@ -4,10 +4,12 @@ import {
   UpdateMessagePluginSchema,
   UpdateMessageRAGParamsSchema,
 } from '@lobechat/types';
+import { TRPCError } from '@trpc/server';
 import { z } from 'zod';
 
 import { MessageModel } from '@/database/models/message';
-import { authedProcedure, router } from '@/libs/trpc/lambda';
+import { TopicShareModel } from '@/database/models/topicShare';
+import { authedProcedure, publicProcedure, router } from '@/libs/trpc/lambda';
 import { serverDatabase } from '@/libs/trpc/lambda/middleware';
 import { FileService } from '@/server/services/file';
 import { MessageService } from '@/server/services/message';
@@ -89,7 +91,8 @@ export const messageRouter = router({
     return ctx.messageModel.getHeatmaps();
   }),
 
-  getMessages: messageProcedure
+  getMessages: publicProcedure
+    .use(serverDatabase)
     .input(
       z.object({
         agentId: z.string().nullable().optional(),
@@ -99,11 +102,41 @@ export const messageRouter = router({
         sessionId: z.string().nullable().optional(),
         threadId: z.string().nullable().optional(),
         topicId: z.string().nullable().optional(),
+        topicShareId: z.string().optional(),
       }),
     )
     .query(async ({ input, ctx }) => {
-      return ctx.messageModel.query(input, {
-        postProcessUrl: (path) => ctx.fileService.getFullFileUrl(path),
+      const { topicShareId, ...queryParams } = input;
+
+      // Public access via topicShareId
+      if (topicShareId) {
+        const share = await TopicShareModel.findByShareIdWithAccessCheck(
+          ctx.serverDB,
+          topicShareId,
+          ctx.userId ?? undefined,
+        );
+
+        const messageModel = new MessageModel(ctx.serverDB, share.ownerId);
+        const fileService = new FileService(ctx.serverDB, share.ownerId);
+
+        return messageModel.query(
+          { ...queryParams, topicId: share.topicId },
+          {
+            postProcessUrl: (path) => fileService.getFullFileUrl(path),
+          },
+        );
+      }
+
+      // Authenticated access - require userId
+      if (!ctx.userId) {
+        throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Authentication required' });
+      }
+
+      const messageModel = new MessageModel(ctx.serverDB, ctx.userId);
+      const fileService = new FileService(ctx.serverDB, ctx.userId);
+
+      return messageModel.query(queryParams, {
+        postProcessUrl: (path) => fileService.getFullFileUrl(path),
       });
     }),
 

package/src/server/routers/lambda/share.ts

@@ -0,0 +1,55 @@
+import type { SharedTopicData } from '@lobechat/types';
+import { z } from 'zod';
+
+import { TopicShareModel } from '@/database/models/topicShare';
+import { publicProcedure, router } from '@/libs/trpc/lambda';
+import { serverDatabase } from '@/libs/trpc/lambda/middleware';
+
+export const shareRouter = router({
+  /**
+   * Get shared topic metadata for public access
+   * Uses shareId (not topicId) for access
+   * Visibility check: owner can always access, others depend on visibility setting
+   */
+  getSharedTopic: publicProcedure
+    .use(serverDatabase)
+    .input(z.object({ shareId: z.string() }))
+    .query(async ({ input, ctx }): Promise<SharedTopicData> => {
+      const share = await TopicShareModel.findByShareIdWithAccessCheck(
+        ctx.serverDB,
+        input.shareId,
+        ctx.userId ?? undefined,
+      );
+
+      // Increment page view count after visibility check passes
+      await TopicShareModel.incrementPageViewCount(ctx.serverDB, input.shareId);
+
+      return {
+        agentId: share.agentId,
+        agentMeta: share.agentId
+          ? {
+              avatar: share.agentAvatar,
+              backgroundColor: share.agentBackgroundColor,
+              marketIdentifier: share.agentMarketIdentifier,
+              slug: share.agentSlug,
+              title: share.agentTitle,
+            }
+          : undefined,
+        groupId: share.groupId,
+        groupMeta: share.groupId
+          ? {
+              avatar: share.groupAvatar,
+              backgroundColor: share.groupBackgroundColor,
+              members: share.groupMembers,
+              title: share.groupTitle,
+            }
+          : undefined,
+        shareId: share.shareId,
+        title: share.title,
+        topicId: share.topicId,
+        visibility: share.visibility as SharedTopicData['visibility'],
+      };
+    }),
+});
+
+export type ShareRouter = typeof shareRouter;

package/src/server/routers/lambda/topic.ts

@@ -8,6 +8,7 @@ import { after } from 'next/server';
 import { z } from 'zod';
 
 import { TopicModel } from '@/database/models/topic';
+import { TopicShareModel } from '@/database/models/topicShare';
 import { AgentMigrationRepo } from '@/database/repositories/agentMigration';
 import { TopicImporterRepo } from '@/database/repositories/topicImporter';
 import { agents, chatGroups, chatGroupsAgents } from '@/database/schemas';
@@ -30,6 +31,7 @@ const topicProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
       agentMigrationRepo: new AgentMigrationRepo(ctx.serverDB, ctx.userId),
       topicImporterRepo: new TopicImporterRepo(ctx.serverDB, ctx.userId),
       topicModel: new TopicModel(ctx.serverDB, ctx.userId),
+      topicShareModel: new TopicShareModel(ctx.serverDB, ctx.userId),
     },
   });
 });
@@ -138,6 +140,29 @@ export const topicRouter = router({
       return data.id;
     }),
 
+  /**
+   * Disable sharing for a topic (deletes share record)
+   */
+  disableSharing: topicProcedure
+    .input(z.object({ topicId: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      return ctx.topicShareModel.deleteByTopicId(input.topicId);
+    }),
+
+  /**
+   * Enable sharing for a topic (creates share record)
+   */
+  enableSharing: topicProcedure
+    .input(
+      z.object({
+        topicId: z.string(),
+        visibility: z.enum(['private', 'link']).optional(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.topicShareModel.create(input.topicId, input.visibility);
+    }),
+
   getAllTopics: topicProcedure.query(async ({ ctx }) => {
     return ctx.topicModel.queryAll();
   }),
@@ -148,6 +173,12 @@ export const topicRouter = router({
       return ctx.topicModel.getCronTopicsGroupedByCronJob(input.agentId);
     }),
 
+  getShareInfo: topicProcedure
+    .input(z.object({ topicId: z.string() }))
+    .query(async ({ input, ctx }) => {
+      return ctx.topicShareModel.getByTopicId(input.topicId);
+    }),
+
   getTopics: topicProcedure
     .input(
       z.object({
@@ -419,6 +450,20 @@ export const topicRouter = router({
       return ctx.topicModel.queryByKeyword(input.keywords, resolved.sessionId);
     }),
 
+  /**
+   * Update share visibility
+   */
+  updateShareVisibility: topicProcedure
+    .input(
+      z.object({
+        topicId: z.string(),
+        visibility: z.enum(['private', 'link']),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.topicShareModel.updateVisibility(input.topicId, input.visibility);
+    }),
+
   updateTopic: topicProcedure
     .input(
       z.object({

package/src/services/chatGroup/index.ts

@@ -89,10 +89,7 @@ class ChatGroupService {
    * Batch create virtual agents and add them to an existing group.
    * This is more efficient than calling createAgentOnly multiple times.
    */
-  batchCreateAgentsInGroup = (
-    groupId: string,
-    agents: GroupMemberConfig[],
-  ) => {
+  batchCreateAgentsInGroup = (groupId: string, agents: GroupMemberConfig[]) => {
     return lambdaClient.group.batchCreateAgentsInGroup.mutate({
       agents: agents as Partial<AgentItem>[],
       groupId,

package/src/services/message/index.ts

@@ -28,6 +28,7 @@ export interface MessageQueryContext {
   groupId?: string;
   threadId?: string | null;
   topicId?: string | null;
+  topicShareId?: string;
 }
 
 export class MessageService {

package/src/services/topic/index.ts

@@ -85,6 +85,22 @@ export class TopicService {
     return lambdaClient.topic.updateTopicMetadata.mutate({ id, metadata });
   };
 
+  getShareInfo = (topicId: string) => {
+    return lambdaClient.topic.getShareInfo.query({ topicId });
+  };
+
+  enableSharing = (topicId: string, visibility?: 'private' | 'link') => {
+    return lambdaClient.topic.enableSharing.mutate({ topicId, visibility });
+  };
+
+  updateShareVisibility = (topicId: string, visibility: 'private' | 'link') => {
+    return lambdaClient.topic.updateShareVisibility.mutate({ topicId, visibility });
+  };
+
+  disableSharing = (topicId: string) => {
+    return lambdaClient.topic.disableSharing.mutate({ topicId });
+  };
+
   removeTopic = (id: string) => {
     return lambdaClient.topic.removeTopic.mutate({ id });
   };

package/src/store/serverConfig/selectors.ts

@@ -3,6 +3,7 @@ import { type ServerConfigStore } from './store';
 export const featureFlagsSelectors = (s: ServerConfigStore) => s.featureFlags;
 
 export const serverConfigSelectors = {
+  enableBusinessFeatures: (s: ServerConfigStore) => s.serverConfig.enableBusinessFeatures || false,
   enableEmailVerification: (s: ServerConfigStore) =>
     s.serverConfig.enableEmailVerification || false,
   enableKlavis: (s: ServerConfigStore) => s.serverConfig.enableKlavis || false,