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,
+  UpdateChatTitleInput,
+  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,74 @@ export class ChatResolver {
       throw new Error('Chat stream failed');
     }
   }
+
+  @Query(() => [String], { nullable: true })
+  async getAvailableModelTags(
+    @GetUserIdFromToken() userId: string,
+  ): Promise<string[]> {
+    try {
+      const response = await this.chatProxyService.fetchModelTags();
+      return response.models.data.map((model) => model.id); // Adjust based on model structure
+    } catch (error) {
+      throw new Error('Failed to fetch model tags');
+    }
+  }
+
+  // this is not the final api.
+  @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);
+  }
+
+  @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('updateChatTitleInput') updateChatTitleInput: UpdateChatTitleInput,
+  ): Promise<Chat> {
+    return this.chatService.updateChatTitle(updateChatTitleInput);
+  }
 }