issue#21 add chat apis

backend/src/chat/chat.model.ts

@@ -1,10 +1,49 @@
-import { Field, InputType, ObjectType } from '@nestjs/graphql';
+import {
+  Field,
+  InputType,
+  ObjectType,
+  ID,
+  registerEnumType,
+} from '@nestjs/graphql';
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ManyToOne,
+  OneToMany,
+  JoinColumn,
+} from 'typeorm';
+import { forwardRef } from '@nestjs/common';
+import { Message } from 'src/chat/message.model';
+import { SystemBaseModel } from 'src/system-base-model/system-base.model';
+import { User } from 'src/user/user.model';
+
+@Entity()
+@ObjectType()
+export class Chat extends SystemBaseModel {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(() => ID)
+  id: string;
+
+  @Field({ nullable: true })
+  @Column({ nullable: true })
+  title: string;
+
+  @Field(() => [Message], { nullable: true })
+  @OneToMany(() => Message, (message) => message.chat, { cascade: true })
+  messages: Message[];
+
+  @ManyToOne(() => User, (user) => user.chats)
+  @Field(() => User)
+  user: User;
+}
 
 @ObjectType('ChatCompletionDeltaType')
 class ChatCompletionDelta {
   @Field({ nullable: true })
   content?: string;
 }
+
 @ObjectType('ChatCompletionChunkType')
 export class ChatCompletionChunk {
   @Field()
@@ -37,9 +76,3 @@ class ChatCompletionChoice {
   @Field({ nullable: true })
   finish_reason: string | null;
 }
-
-@InputType('ChatInputType')
-export class ChatInput {
-  @Field()
-  message: string;
-}

backend/src/chat/chat.module.ts

@@ -3,10 +3,28 @@ import { GraphQLModule } from '@nestjs/graphql';
 import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
 import { HttpModule } from '@nestjs/axios';
 import { ChatResolver } from './chat.resolver';
-import { ChatProxyService } from './chat.service';
+import { ChatProxyService, ChatService } from './chat.service';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { User } from 'src/user/user.model';
+import { Chat } from './chat.model';
+import { Message } from 'src/chat/message.model';
+import { ChatGuard } from '../guard/chat.guard';
+import { AuthModule } from '../auth/auth.module';
+import { UserService } from 'src/user/user.service';
 
 @Module({
-  imports: [HttpModule],
-  providers: [ChatResolver, ChatProxyService],
+  imports: [
+    HttpModule,
+    TypeOrmModule.forFeature([Chat, User, Message]),
+    AuthModule,
+  ],
+  providers: [
+    ChatResolver,
+    ChatProxyService,
+    ChatService,
+    ChatGuard,
+    UserService,
+  ],
+  exports: [ChatService, ChatGuard],
 })
 export class ChatModule {}

backend/src/chat/chat.resolver.ts

@@ -1,21 +1,42 @@
-import { Resolver, Subscription, Args } from '@nestjs/graphql';
-import { ChatCompletionChunk, ChatInput } from './chat.model';
-import { ChatProxyService } from './chat.service';
+import { Resolver, Subscription, Args, Query, Mutation } from '@nestjs/graphql';
+import { ChatCompletionChunk } from './chat.model';
+import { ChatProxyService, ChatService } from './chat.service';
+import { UserService } from 'src/user/user.service';
+import { Chat } from './chat.model';
+import { Message, Role } from 'src/chat/message.model';
+import {
+  NewChatInput,
+  UpateChatTitleInput,
+  ChatInput,
+} from 'src/chat/dto/chat.input';
+import { UseGuards } from '@nestjs/common';
+import { ChatGuard, MessageGuard } from '../guard/chat.guard';
+import { GetUserIdFromToken } from '../decorator/get-auth-token';
 
 @Resolver('Chat')
 export class ChatResolver {
-  constructor(private chatProxyService: ChatProxyService) {}
+  constructor(
+    private chatProxyService: ChatProxyService,
+    private chatService: ChatService,
+    private userService: UserService,
+  ) {}
 
   @Subscription(() => ChatCompletionChunk, {
     nullable: true,
     resolve: (value) => value,
   })
   async *chatStream(@Args('input') input: ChatInput) {
     const iterator = this.chatProxyService.streamChat(input.message);
-
+    this.chatService.saveMessage(input.chatId, null, input.message, Role.User);
     try {
       for await (const chunk of iterator) {
         if (chunk) {
+          await this.chatService.saveMessage(
+            input.chatId,
+            chunk.id,
+            chunk.choices[0].delta.content,
+            Role.Model,
+          );
           yield chunk;
         }
       }
@@ -24,4 +45,66 @@ export class ChatResolver {
       throw new Error('Chat stream failed');
     }
   }
+
+  @Query(() => [Chat], { nullable: true })
+  async getUserChats(@GetUserIdFromToken() userId: string): Promise<Chat[]> {
+    const user = await this.userService.getUserChats(userId);
+    return user ? user.chats : []; // Return chats if user exists, otherwise return an empty array
+  }
+
+  @UseGuards(MessageGuard)
+  @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
+
+  @UseGuards(ChatGuard)
+  @Query(() => [Message])
+  async getChatHistory(@Args('chatId') chatId: string): Promise<Message[]> {
+    return this.chatService.getChatHistory(chatId);
+  }
+
+  @UseGuards(ChatGuard)
+  @Query(() => Chat, { nullable: true })
+  async getChatDetails(@Args('chatId') chatId: string): Promise<Chat> {
+    return this.chatService.getChatDetails(chatId);
+  }
+
+  // @Query(() => [Message])
+  // getAvailableModelTags(@Args('chatId') chatId: string): Message[] {
+  //   return this.chatService.getChatHistory(chatId);
+  // }
+
+  @Mutation(() => Chat)
+  async createChat(
+    @GetUserIdFromToken() userId: string,
+    @Args('newChatInput') newChatInput: NewChatInput,
+  ): Promise<Chat> {
+    return this.chatService.createChat(userId, newChatInput);
+  }
+
+  @UseGuards(ChatGuard)
+  @Mutation(() => Boolean)
+  async deleteChat(@Args('chatId') chatId: string): Promise<boolean> {
+    return this.chatService.deleteChat(chatId);
+  }
+
+  @UseGuards(ChatGuard)
+  @Mutation(() => Boolean)
+  async clearChatHistory(@Args('chatId') chatId: string): Promise<boolean> {
+    return this.chatService.clearChatHistory(chatId);
+  }
+
+  @UseGuards(ChatGuard)
+  @Mutation(() => Chat, { nullable: true })
+  async updateChatTitle(
+    @Args('upateChatTitleInput') upateChatTitleInput: UpateChatTitleInput,
+  ): Promise<Chat> {
+    return this.chatService.updateChatTitle(upateChatTitleInput);
+  }
 }

backend/src/chat/chat.service.ts

@@ -1,6 +1,11 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { HttpService } from '@nestjs/axios';
-import { ChatCompletionChunk } from './chat.model';
+import { ChatCompletionChunk, Chat } from './chat.model';
+import { Message, Role } from 'src/chat/message.model';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { User } from 'src/user/user.model';
+import { NewChatInput, UpateChatTitleInput } from 'src/chat/dto/chat.input';
 
 type CustomAsyncIterableIterator<T> = AsyncIterator<T> & {
   [Symbol.asyncIterator](): AsyncIterableIterator<T>;
@@ -132,3 +137,112 @@ export class ChatProxyService {
     );
   }
 }
+
+@Injectable()
+export class ChatService {
+  constructor(
+    @InjectRepository(Chat)
+    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 },
+      order: { createdAt: 'ASC' },
+      relations: ['messages'],
+    });
+    return chat ? chat.messages : [];
+  }
+
+  async getMessageById(messageId: string): Promise<Message> {
+    return await this.messageRepository.findOne({
+      where: { id: messageId },
+    });
+  }
+
+  async getChatDetails(chatId: string): Promise<Chat> {
+    return this.chatRepository.findOne({
+      where: { id: chatId },
+      relations: ['messages'],
+    });
+  }
+
+  async createChat(userId: string, newChatInput: NewChatInput): Promise<Chat> {
+    // Fetch the user entity using the userId
+    const user = await this.userRepository.findOne({ where: { id: userId } });
+    if (!user) {
+      throw new Error('User not found');
+    }
+
+    // Create a new chat and associate it with the user
+    const newChat = this.chatRepository.create({
+      title: newChatInput.title,
+      messages: [],
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      user: user, // Associate the user with the chat
+    });
+
+    return await this.chatRepository.save(newChat);
+  }
+
+  async deleteChat(chatId: string): Promise<boolean> {
+    const result = await this.chatRepository.delete(chatId);
+    return result.affected > 0;
+  }
+
+  async clearChatHistory(chatId: string): Promise<boolean> {
+    const chat = await this.chatRepository.findOne({
+      where: { id: chatId },
+      relations: ['messages'],
+    });
+    if (chat) {
+      chat.messages = [];
+      chat.updatedAt = new Date();
+      await this.chatRepository.save(chat);
+      return true;
+    }
+    return false;
+  }
+
+  async updateChatTitle(
+    upateChatTitleInput: UpateChatTitleInput,
+  ): Promise<Chat> {
+    const chat = await this.chatRepository.findOne({
+      where: { id: upateChatTitleInput.chatId },
+    });
+    if (chat) {
+      chat.title = upateChatTitleInput.title;
+      chat.updatedAt = new Date();
+      return await this.chatRepository.save(chat);
+    }
+    return null;
+  }
+
+  async saveMessage(
+    chatId: string,
+    chunkId: string | null,
+    messageContent: string,
+    role: Role,
+  ): Promise<Message> {
+    // Find the chat instance
+    const chat = await this.chatRepository.findOne({ where: { id: chatId } });
+    if (!chat) throw new Error('Chat not found');
+
+    // Create a new message associated with the chat
+    const message = this.messageRepository.create({
+      id: chunkId || null,
+      content: messageContent,
+      role: role,
+      chat,
+      createdAt: new Date(),
+    });
+
+    // Save the message to the database
+    return await this.messageRepository.save(message);
+  }
+}

backend/src/chat/dto/chat.input.ts

@@ -0,0 +1,27 @@
+// DTOs for Project APIs
+import { InputType, Field, ID } from '@nestjs/graphql';
+import { Message } from 'src/chat/message.model';
+
+@InputType()
+export class NewChatInput {
+  @Field({ nullable: true })
+  title: string;
+}
+
+@InputType()
+export class UpateChatTitleInput {
+  @Field()
+  chatId: string;
+
+  @Field({ nullable: true })
+  title: string;
+}
+
+@InputType('ChatInputType')
+export class ChatInput {
+  @Field()
+  chatId: string;
+
+  @Field()
+  message: string;
+}