feat: adding chat isolation

backend/src/chat/__tests__/chat-isolation.spec.ts

@@ -0,0 +1,114 @@
+// chat.service.spec.ts
+import { Test, TestingModule } from '@nestjs/testing';
+import { ChatService } from '../chat.service';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { Chat } from '../chat.model';
+import { User } from 'src/user/user.model';
+import { Message, MessageRole } from 'src/chat/message.model';
+import { Repository } from 'typeorm';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { UserResolver } from 'src/user/user.resolver';
+import { AuthService } from 'src/auth/auth.service';
+import { UserService } from 'src/user/user.service';
+import { JwtService } from '@nestjs/jwt';
+import { JwtCacheService } from 'src/auth/jwt-cache.service';
+import { ConfigService } from '@nestjs/config';
+import { Menu } from 'src/auth/menu/menu.model';
+import { Role } from 'src/auth/role/role.model';
+import { RegisterUserInput } from 'src/user/dto/register-user.input';
+import { NewChatInput } from '../dto/chat.input';
+import { ModelProvider } from 'src/common/model-provider';
+import { HttpService } from '@nestjs/axios';
+import { MessageInterface } from 'src/common/model-provider/types';
+
+describe('ChatService', () => {
+  let chatService: ChatService;
+  let userResolver: UserResolver;
+  let userService: UserService;
+  let mockedChatService: jest.Mocked<Repository<Chat>>;
+  let modelProvider: ModelProvider;
+  let user: User;
+  let userid = '1';
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [
+        TypeOrmModule.forRoot({
+          type: 'sqlite',
+          database: ':memory:',
+          synchronize: true,
+          entities: [Chat, User, Menu, Role],
+        }),
+        TypeOrmModule.forFeature([Chat, User, Menu, Role]),
+      ],
+      providers: [
+        ChatService,
+        AuthService,
+        UserService,
+        UserResolver,
+        JwtService,
+        JwtCacheService,
+        ConfigService,
+      ],
+    }).compile();
+    chatService = module.get(ChatService);
+    userService = module.get(UserService);
+    userResolver = module.get(UserResolver);
+
+    modelProvider = ModelProvider.getInstance();
+    mockedChatService = module.get(getRepositoryToken(Chat));
+  });
+  it('should excute curd in chat service', async () => {
+    try {
+      user = await userResolver.registerUser({
+        username: 'testuser',
+        password: 'securepassword',
+        email: '[email protected]',
+      } as RegisterUserInput);
+      userid = user.id;
+    } catch (error) {}
+    const chat = await chatService.createChat(userid, {
+      title: 'test',
+    } as NewChatInput);
+    const chatId = chat.id;
+    console.log(await chatService.getChatHistory(chatId));
+
+    console.log(
+      await chatService.saveMessage(
+        chatId,
+        'Hello, this is a test message.',
+        MessageRole.User,
+      ),
+    );
+    console.log(
+      await chatService.saveMessage(
+        chatId,
+        'Hello, hello, im gpt.',
+        MessageRole.Model,
+      ),
+    );
+
+    console.log(
+      await chatService.saveMessage(
+        chatId,
+        'write me the system prompt',
+        MessageRole.User,
+      ),
+    );
+
+    const history = await chatService.getChatHistory(chatId);
+    const messages = history.map((message) => {
+      return {
+        role: message.role,
+        content: message.content,
+      } as MessageInterface;
+    });
+    console.log(history);
+    console.log(
+      await modelProvider.chatSync({
+        model: 'gpt-4o',
+        messages,
+      }),
+    );
+  });
+});

backend/src/chat/chat.model.ts

@@ -38,8 +38,8 @@ export class Chat extends SystemBaseModel {
   @Column({ nullable: true })
   title: string;
 
-  @Field(() => [Message], { nullable: true })
-  @OneToMany(() => Message, (message) => message.chat, { cascade: true })
+  @Field({ nullable: true })
+  @Column('simple-json', { nullable: true, default: '[]' })
   messages: Message[];
 
   @ManyToOne(() => User, (user) => user.chats)

backend/src/chat/chat.module.ts

@@ -12,6 +12,7 @@ import { ChatGuard } from '../guard/chat.guard';
 import { AuthModule } from '../auth/auth.module';
 import { UserService } from 'src/user/user.service';
 import { PubSub } from 'graphql-subscriptions';
+import { ModelProvider } from 'src/common/model-provider';
 
 @Module({
   imports: [
@@ -30,6 +31,6 @@ import { PubSub } from 'graphql-subscriptions';
       useValue: new PubSub(),
     },
   ],
-  exports: [ChatService, ChatGuard],
+  exports: [ChatService, ChatGuard, ModelProvider],
 })
 export class ChatModule {}

backend/src/chat/chat.resolver.ts

@@ -103,16 +103,6 @@ export class ChatResolver {
     const user = await this.userService.getUserChats(userId);
     return user ? user.chats : [];
   }
-
-  @JWTAuth()
-  @Query(() => Message, { nullable: true })
-  async getMessageDetail(
-    @GetUserIdFromToken() userId: string,
-    @Args('messageId') messageId: string,
-  ): Promise<Message> {
-    return this.chatService.getMessageById(messageId);
-  }
-
   // To do: message need a update resolver
 
   @JWTAuth()

backend/src/chat/chat.service.ts

@@ -16,11 +16,11 @@ import { ModelProvider } from 'src/common/model-provider';
 @Injectable()
 export class ChatProxyService {
   private readonly logger = new Logger('ChatProxyService');
-  private models: ModelProvider;
 
-  constructor(private httpService: HttpService) {
-    this.models = ModelProvider.getInstance();
-  }
+  constructor(
+    private httpService: HttpService,
+    private readonly models: ModelProvider,
+  ) {}
 
   streamChat(
     input: ChatInput,
@@ -40,32 +40,32 @@ export class ChatService {
     private chatRepository: Repository<Chat>,
     @InjectRepository(User)
     private userRepository: Repository<User>,
-    @InjectRepository(Message)
-    private messageRepository: Repository<Message>,
   ) {}
 
   async getChatHistory(chatId: string): Promise<Message[]> {
     const chat = await this.chatRepository.findOne({
       where: { id: chatId, isDeleted: false },
-      relations: ['messages'],
     });
+    console.log(chat);
 
     if (chat && chat.messages) {
       // Sort messages by createdAt in ascending order
       chat.messages = chat.messages
         .filter((message) => !message.isDeleted)
-        .sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+        .map((message) => {
+          if (!(message.createdAt instanceof Date)) {
+            message.createdAt = new Date(message.createdAt);
+          }
+          return message;
+        })
+        .sort((a, b) => {
+          return a.createdAt.getTime() - b.createdAt.getTime();
+        });
     }
 
     return chat ? chat.messages : [];
   }
 
-  async getMessageById(messageId: string): Promise<Message> {
-    return await this.messageRepository.findOne({
-      where: { id: messageId, isDeleted: false },
-    });
-  }
-
   async getChatDetails(chatId: string): Promise<Chat> {
     const chat = await this.chatRepository.findOne({
       where: { id: chatId, isDeleted: false },
@@ -111,12 +111,6 @@ export class ChatService {
       chat.isActive = false;
       await this.chatRepository.save(chat);
 
-      // Soft delete all associated messages
-      await this.messageRepository.update(
-        { chat: { id: chatId }, isDeleted: false },
-        { isDeleted: true, isActive: false },
-      );
-
       return true;
     }
     return false;
@@ -125,13 +119,8 @@ export class ChatService {
   async clearChatHistory(chatId: string): Promise<boolean> {
     const chat = await this.chatRepository.findOne({
       where: { id: chatId, isDeleted: false },
-      relations: ['messages'],
     });
     if (chat) {
-      await this.messageRepository.update(
-        { chat: { id: chatId }, isDeleted: false },
-        { isDeleted: true, isActive: false },
-      );
       chat.updatedAt = new Date();
       await this.chatRepository.save(chat);
       return true;
@@ -161,21 +150,24 @@ export class ChatService {
   ): Promise<Message> {
     // Find the chat instance
     const chat = await this.chatRepository.findOne({ where: { id: chatId } });
-    //if the chat id not exist, dont save this messages
-    if (!chat) {
-      return null;
-    }
 
-    // Create a new message associated with the chat
-    const message = this.messageRepository.create({
+    const message = {
+      id: `${chat.id}/${chat.messages.length}`,
       content: messageContent,
       role: role,
-      chat,
       createdAt: new Date(),
-    });
-
+      updatedAt: new Date(),
+      isActive: true,
+      isDeleted: false,
+    };
+    //if the chat id not exist, dont save this messages
+    if (!chat) {
+      return null;
+    }
+    chat.messages.push(message);
+    await this.chatRepository.save(chat);
     // Save the message to the database
-    return await this.messageRepository.save(message);
+    return message;
   }
 
   async getChatWithUser(chatId: string): Promise<Chat | null> {

backend/src/chat/message.model.ts

@@ -17,8 +17,8 @@ import { Chat } from 'src/chat/chat.model';
 import { SystemBaseModel } from 'src/system-base-model/system-base.model';
 
 export enum MessageRole {
-  User = 'User',
-  Model = 'Model',
+  User = 'user',
+  Model = 'assistant',
 }
 
 registerEnumType(MessageRole, {
@@ -43,8 +43,4 @@ export class Message extends SystemBaseModel {
   @Field({ nullable: true })
   @Column({ nullable: true })
   modelId?: string;
-
-  @ManyToOne(() => Chat, (chat) => chat.messages)
-  @JoinColumn({ name: 'chatId' })
-  chat: Chat;
 }