@fr-data-fabric/chatbot-api-nest 0.0.1

package/src/domain/use-cases/chats/chat.types.ts

@@ -0,0 +1,51 @@
+import { UserEntity } from '@domain/entities/UserEntity';
+import { DynamicStructuredTool } from 'langchain';
+
+export type AvailableTool = {
+  name: string;
+  options: Record<string, unknown>;
+};
+
+export type ToolNames<AvailableTools extends AvailableTool[]> =
+  AvailableTools[number]['name'];
+
+export type StreamEvents<AvailableTools extends AvailableTool[]> =
+  | { event: 'chat_stream'; content: string }
+  | { event: 'sources_add'; sources: Source[] }
+  | { event: 'tool_stream_start'; name: ToolNames<AvailableTools>; id: string }
+  | {
+      event: 'tool_start';
+      name: ToolNames<AvailableTools>;
+      id: string;
+      input: unknown;
+    }
+  | { event: 'tool_stream'; id: string; input: string }
+  | {
+      event: 'tool_end';
+      name: ToolNames<AvailableTools>;
+      input: string;
+      output: unknown;
+      id: string;
+    };
+
+export type ChatStreamEvents<AvailableTools extends AvailableTool[]> =
+  | StreamEvents<AvailableTools>
+  | { event: 'user_message_id'; id: string }
+  | { event: 'assistant_message_id'; id: string };
+
+export type Source = {
+  title: string;
+  link: string;
+  content: string;
+  index: number;
+};
+
+export type ToolOptions = {
+  getSourceIndex: () => number;
+  addSources: (sources: Source[]) => void;
+  currentUser: UserEntity;
+};
+
+export interface ToolClass {
+  getTool(options: ToolOptions): DynamicStructuredTool;
+}

package/src/domain/use-cases/conversations/CreateConversationUC.ts

@@ -0,0 +1,7 @@
+import { ConversationEntity } from '@domain/entities/ConversationEntity';
+import { UCInput } from '@domain/use-cases/_common';
+
+export const CREATE_CONVERSATION_UC = 'CreateConversationUC';
+export interface ICreateConversationUC {
+  execute(input: UCInput<undefined>): Promise<ConversationEntity>;
+}

package/src/domain/use-cases/conversations/DeleteConversationUC.ts

@@ -0,0 +1,29 @@
+import { ConversationEntity } from '@domain/entities/ConversationEntity';
+import type { ConversationRepository } from '@domain/interfaces/ConversationRepository';
+import { CONVERSATION_REPOSITORY } from '@domain/interfaces/ConversationRepository';
+import { DeleteByIdInput, UCInput } from '@domain/use-cases/_common';
+import type { IGetConversationUC } from '@domain/use-cases/conversations/GetConversationUC';
+import { GET_CONVERSATION_UC } from '@domain/use-cases/conversations/GetConversationUC';
+import { Inject, Injectable } from '@nestjs/common';
+
+@Injectable()
+export class DeleteConversationUC {
+  constructor(
+    @Inject(CONVERSATION_REPOSITORY)
+    private readonly conversationRepository: ConversationRepository,
+    @Inject(GET_CONVERSATION_UC)
+    private readonly getConversationUC: IGetConversationUC,
+  ) {}
+
+  async execute({
+    input,
+    currentUser,
+  }: UCInput<DeleteByIdInput>): Promise<ConversationEntity> {
+    const conversation = await this.getConversationUC.execute({
+      input: { id: input.id },
+      currentUser,
+    });
+
+    return await this.conversationRepository.remove(conversation);
+  }
+}

package/src/domain/use-cases/conversations/GenerateConversationTitleUC.ts

@@ -0,0 +1,69 @@
+import { ConversationEntity } from '@domain/entities/ConversationEntity';
+import type { ConversationRepository } from '@domain/interfaces/ConversationRepository';
+import { CONVERSATION_REPOSITORY } from '@domain/interfaces/ConversationRepository';
+import type { LLMService } from '@domain/interfaces/LLMService';
+import { LLM_SERVICE } from '@domain/interfaces/LLMService';
+import type { PromptService } from '@domain/interfaces/PromptService';
+import { PROMPT_SERVICE } from '@domain/interfaces/PromptService';
+import { UCInput } from '@domain/use-cases/_common';
+import type { IGetConversationUC } from '@domain/use-cases/conversations/GetConversationUC';
+import { GET_CONVERSATION_UC } from '@domain/use-cases/conversations/GetConversationUC';
+import { Inject, Injectable } from '@nestjs/common';
+import { Field, ID, InputType } from '@nestjs/graphql';
+
+@InputType()
+export class GenerateConversationTitleInput {
+  @Field(() => ID)
+  conversationId!: string;
+
+  @Field(() => String)
+  firstMessage!: string;
+}
+
+@Injectable()
+export class GenerateConversationTitleUC {
+  constructor(
+    @Inject(LLM_SERVICE)
+    private readonly llmService: LLMService,
+    @Inject(PROMPT_SERVICE)
+    private readonly promptService: PromptService,
+    @Inject(GET_CONVERSATION_UC)
+    private readonly getConversationUC: IGetConversationUC,
+    @Inject(CONVERSATION_REPOSITORY)
+    private readonly conversationRepository: ConversationRepository,
+  ) {}
+
+  async execute({
+    input,
+    currentUser,
+  }: UCInput<GenerateConversationTitleInput>): Promise<ConversationEntity> {
+    const conversation = await this.getConversationUC.execute({
+      currentUser,
+      input: { id: input.conversationId },
+    });
+
+    const model = this.llmService.getLLM({
+      model: 'gpt-5-nano', // TODO: make this configurable
+      provider: 'openai',
+      temperature: 0.1,
+      streaming: false,
+    });
+
+    const result = await model.invoke(
+      await this.promptService.getPrompt(
+        {
+          name: 'generate_conversation_title',
+          version: 'latest',
+        },
+        {
+          first_message: input.firstMessage,
+        },
+      ),
+    );
+
+    conversation.title = result.text;
+    await this.conversationRepository.save(conversation);
+
+    return conversation;
+  }
+}

package/src/domain/use-cases/conversations/GetConversationUC.ts

@@ -0,0 +1,18 @@
+import { ConversationEntity } from '@domain/entities/ConversationEntity';
+import { UCInput } from '@domain/use-cases/_common';
+import { Field, ID, InputType } from '@nestjs/graphql';
+
+@InputType()
+export class GetConversationInput {
+  @Field(() => ID, { nullable: true })
+  id?: string;
+
+  @Field(() => String, { nullable: true })
+  shareId?: string;
+}
+
+export const GET_CONVERSATION_UC = 'GetConversationUC';
+
+export interface IGetConversationUC {
+  execute(input: UCInput<GetConversationInput>): Promise<ConversationEntity>;
+}

package/src/domain/use-cases/conversations/GetConversationsUC.ts

@@ -0,0 +1,21 @@
+import { ConversationEntity } from '@domain/entities/ConversationEntity';
+import {
+  PaginatedInput,
+  PaginatedOutput,
+  UCInput,
+} from '@domain/use-cases/_common';
+import { Field, InputType } from '@nestjs/graphql';
+
+@InputType()
+export class GetConversationsInput extends PaginatedInput {
+  @Field(() => String, { nullable: true })
+  title?: string;
+}
+
+export const GET_CONVERSATIONS_UC = 'GetConversationsUC';
+
+export interface IGetConversationsUC {
+  execute(
+    input: UCInput<GetConversationsInput>,
+  ): Promise<PaginatedOutput<ConversationEntity>>;
+}

package/src/domain/use-cases/conversations/UpdateConversationUC.ts

@@ -0,0 +1,54 @@
+import { ConversationEntity } from '@domain/entities/ConversationEntity';
+import type { ConversationRepository } from '@domain/interfaces/ConversationRepository';
+import { CONVERSATION_REPOSITORY } from '@domain/interfaces/ConversationRepository';
+import { UCInput } from '@domain/use-cases/_common';
+import type { IGetConversationUC } from '@domain/use-cases/conversations/GetConversationUC';
+import { GET_CONVERSATION_UC } from '@domain/use-cases/conversations/GetConversationUC';
+import { Inject, Injectable } from '@nestjs/common';
+import { Field, ID, InputType } from '@nestjs/graphql';
+
+@InputType()
+export class UpdateConversationInput {
+  @Field(() => ID)
+  id!: string;
+
+  @Field({ nullable: true })
+  title?: string;
+
+  @Field({ nullable: true })
+  shared?: boolean;
+}
+
+@Injectable()
+export class UpdateConversationUC {
+  constructor(
+    @Inject(CONVERSATION_REPOSITORY)
+    private readonly conversationRepository: ConversationRepository,
+    @Inject(GET_CONVERSATION_UC)
+    private readonly getConversationUC: IGetConversationUC,
+  ) {}
+
+  async execute({
+    input,
+    currentUser,
+  }: UCInput<UpdateConversationInput>): Promise<ConversationEntity> {
+    const conversation = await this.getConversationUC.execute({
+      input: { id: input.id },
+      currentUser,
+    });
+
+    if (typeof input.title === 'string') {
+      conversation.title = input.title;
+    }
+
+    if (typeof input.shared === 'boolean') {
+      if (input.shared) {
+        conversation.shareId = crypto.randomUUID();
+      } else {
+        conversation.shareId = null;
+      }
+    }
+
+    return this.conversationRepository.save(conversation);
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './chatbot-api.module';

package/src/inputs/controllers/ChatsController.ts

@@ -0,0 +1,47 @@
+import type { UserEntity } from '@domain/entities/UserEntity';
+import {
+  SEND_CHAT_UC,
+  SendChatUC,
+  type SendMessageInput,
+} from '@domain/use-cases/chats/SendChatUC';
+import { Body, Controller, Inject, Post, Res } from '@nestjs/common';
+import type { Response } from 'express';
+import { CurrentUserRest } from 'src/inputs/controllers/_common/CurrentUserRest';
+
+@Controller('chat')
+export class ChatsController {
+  constructor(
+    @Inject(SEND_CHAT_UC)
+    private readonly sendChatUC: SendChatUC<never>,
+  ) {}
+
+  @Post('/')
+  async sendMessage(
+    @Res() res: Response,
+    @Body() input: SendMessageInput<never>,
+    @CurrentUserRest() currentUser: UserEntity,
+  ) {
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive',
+    });
+
+    const stream = await this.sendChatUC.execute({
+      input,
+      currentUser,
+    });
+
+    stream.subscribe({
+      next: (event) => {
+        res.write(JSON.stringify(event));
+      },
+      complete: () => {
+        res.end();
+      },
+      error: () => {
+        res.end();
+      },
+    });
+  }
+}

package/src/inputs/controllers/_common/CurrentUserRest.ts

@@ -0,0 +1,10 @@
+import { UserEntity } from '@domain/entities/UserEntity';
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+
+export const CurrentUserRest = createParamDecorator<unknown, UserEntity>(
+  (data: unknown, context: ExecutionContext) => {
+    const ctx = context.switchToHttp();
+
+    return ctx.getRequest<Request & { user: UserEntity }>().user;
+  },
+);

package/src/inputs/resolvers/ChatsResolver.ts

@@ -0,0 +1,40 @@
+import type { ChatEntity } from '@domain/entities/ChatEntity';
+import {
+  GqlTypeReference,
+  Parent,
+  ResolveField,
+  Resolver,
+} from '@nestjs/graphql';
+
+export function GetChatsResolver(
+  GqlChat: GqlTypeReference,
+  GqlChatSource: GqlTypeReference,
+  GqlChatTextContent: GqlTypeReference,
+  GqlToolUse: GqlTypeReference,
+) {
+  @Resolver(() => GqlChat)
+  class ChatsResolver {
+    constructor() {}
+
+    @ResolveField(() => [GqlToolUse])
+    async tools(@Parent() chat: ChatEntity): Promise<(typeof GqlToolUse)[]> {
+      return (await chat._toolUses).sort((a, b) => a.order - b.order);
+    }
+
+    @ResolveField(() => [GqlChatSource])
+    async sources(
+      @Parent() chat: ChatEntity,
+    ): Promise<(typeof GqlChatSource)[]> {
+      return await chat._sources;
+    }
+
+    @ResolveField(() => [GqlChatTextContent])
+    async textContents(
+      @Parent() chat: ChatEntity,
+    ): Promise<(typeof GqlChatTextContent)[]> {
+      return await chat._textContents;
+    }
+  }
+
+  return ChatsResolver;
+}

package/src/inputs/resolvers/ConversationsResolver.ts

@@ -0,0 +1,149 @@
+import type { ConversationEntity } from '@domain/entities/ConversationEntity';
+import type { UserEntity } from '@domain/entities/UserEntity';
+import { DeleteByIdInput } from '@domain/use-cases/_common';
+import type { ICreateConversationUC } from '@domain/use-cases/conversations/CreateConversationUC';
+import { CREATE_CONVERSATION_UC } from '@domain/use-cases/conversations/CreateConversationUC';
+import { DeleteConversationUC } from '@domain/use-cases/conversations/DeleteConversationUC';
+import {
+  GenerateConversationTitleInput,
+  GenerateConversationTitleUC,
+} from '@domain/use-cases/conversations/GenerateConversationTitleUC';
+import type { IGetConversationsUC } from '@domain/use-cases/conversations/GetConversationsUC';
+import {
+  GET_CONVERSATIONS_UC,
+  GetConversationsInput,
+} from '@domain/use-cases/conversations/GetConversationsUC';
+import type { IGetConversationUC } from '@domain/use-cases/conversations/GetConversationUC';
+import {
+  GET_CONVERSATION_UC,
+  GetConversationInput,
+} from '@domain/use-cases/conversations/GetConversationUC';
+import {
+  UpdateConversationInput,
+  UpdateConversationUC,
+} from '@domain/use-cases/conversations/UpdateConversationUC';
+import { Inject } from '@nestjs/common';
+import {
+  Args,
+  GqlTypeReference,
+  Mutation,
+  ObjectType,
+  Parent,
+  Query,
+  ResolveField,
+  Resolver,
+} from '@nestjs/graphql';
+import { CurrentUserGql } from 'src/inputs/resolvers/_common/CurrentUserGql';
+import { GqlPaginatedOutput } from 'src/inputs/resolvers/_common/GqlPaginatedOutput';
+
+export function GetConversationsResolver(
+  GqlConversation: GqlTypeReference,
+  GqlChat: GqlTypeReference,
+  GqlUser: GqlTypeReference,
+) {
+  @ObjectType('PaginatedConversations')
+  class GqlPaginatedConversations extends GqlPaginatedOutput(GqlConversation) {}
+
+  @Resolver(() => GqlConversation)
+  class ConversationsResolver {
+    constructor(
+      @Inject(GET_CONVERSATIONS_UC)
+      readonly getConversationsUC: IGetConversationsUC,
+      @Inject(GET_CONVERSATION_UC)
+      readonly getConversationUC: IGetConversationUC,
+      @Inject(CREATE_CONVERSATION_UC)
+      readonly createConversationUC: ICreateConversationUC,
+      readonly updateConversationUC: UpdateConversationUC,
+      readonly deleteConversationUC: DeleteConversationUC,
+      readonly generateConversationTitleUC: GenerateConversationTitleUC,
+    ) {}
+
+    @Query(() => GqlPaginatedConversations)
+    getConversations(
+      @Args('input') input: GetConversationsInput,
+      @CurrentUserGql() currentUser: UserEntity,
+    ): Promise<GqlPaginatedConversations> {
+      return this.getConversationsUC.execute({
+        input,
+        currentUser,
+      });
+    }
+
+    @Query(() => GqlConversation)
+    getConversation(
+      @Args('input') input: GetConversationInput,
+      @CurrentUserGql() currentUser: UserEntity,
+    ): Promise<typeof GqlConversation> {
+      return this.getConversationUC.execute({
+        input,
+        currentUser,
+      });
+    }
+
+    @Mutation(() => GqlConversation)
+    createConversation(
+      @CurrentUserGql() currentUser: UserEntity,
+    ): Promise<typeof GqlConversation> {
+      return this.createConversationUC.execute({
+        input: undefined,
+        currentUser,
+      });
+    }
+
+    @Mutation(() => GqlConversation)
+    updateConversation(
+      @Args('input') input: UpdateConversationInput,
+      @CurrentUserGql() currentUser: UserEntity,
+    ): Promise<typeof GqlConversation> {
+      return this.updateConversationUC.execute({
+        input,
+        currentUser,
+      });
+    }
+
+    @Mutation(() => GqlConversation)
+    deleteConversation(
+      @Args('input') input: DeleteByIdInput,
+      @CurrentUserGql() currentUser: UserEntity,
+    ): Promise<typeof GqlConversation> {
+      return this.deleteConversationUC.execute({
+        input,
+        currentUser,
+      });
+    }
+
+    @Mutation(() => GqlConversation)
+    generateConversationTitle(
+      @Args('input') input: GenerateConversationTitleInput,
+      @CurrentUserGql() currentUser: UserEntity,
+    ): Promise<typeof GqlConversation> {
+      return this.generateConversationTitleUC.execute({
+        input,
+        currentUser,
+      });
+    }
+
+    @ResolveField(() => GqlUser)
+    user(@Parent() conversation: ConversationEntity): Promise<typeof GqlUser> {
+      if (conversation._user instanceof Promise) {
+        return conversation._user;
+      } else {
+        return Promise.resolve(conversation._user);
+      }
+    }
+
+    @ResolveField(() => [GqlChat])
+    async chats(
+      @Parent() conversation: ConversationEntity,
+    ): Promise<(typeof GqlChat)[]> {
+      const chats = await conversation._chats;
+
+      return (
+        chats?.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime()) ??
+        []
+      );
+    }
+  }
+
+  return ConversationsResolver;
+}

package/src/inputs/resolvers/_common/CurrentUserGql.ts

@@ -0,0 +1,11 @@
+import { UserEntity } from '@domain/entities/UserEntity';
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+import { GqlExecutionContext } from '@nestjs/graphql';
+
+export const CurrentUserGql = createParamDecorator<unknown, UserEntity>(
+  (data: unknown, context: ExecutionContext) => {
+    const ctx = GqlExecutionContext.create(context);
+
+    return ctx.getContext<{ user: UserEntity }>().user;
+  },
+);

package/src/inputs/resolvers/_common/GqlPaginatedOutput.ts

@@ -0,0 +1,25 @@
+import { Type } from '@nestjs/common';
+import { Field, GqlTypeReference, Int, ObjectType } from '@nestjs/graphql';
+
+export interface IPaginatedType<T> {
+  items: T[];
+  totalCount: number;
+  hasNextPage: boolean;
+}
+
+export function GqlPaginatedOutput<T>(
+  classRef: GqlTypeReference<T>,
+): Type<IPaginatedType<T>> {
+  @ObjectType({ isAbstract: true })
+  abstract class PaginatedType implements IPaginatedType<T> {
+    @Field(() => [classRef], { nullable: true })
+    items!: T[];
+
+    @Field(() => Int)
+    totalCount!: number;
+
+    @Field()
+    hasNextPage!: boolean;
+  }
+  return PaginatedType as Type<IPaginatedType<T>>;
+}

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": false,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "target": "es2024",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "noFallthroughCasesInSwitch": false,
+    "sourceRoot": "/",
+    "paths": {
+      "@domain/*": ["src/domain/*"],
+      "@inputs/*": ["src/inputs/*"]
+    }
+  },
+  "exclude": ["node_modules", "**/*.spec.ts", "tests", "dist"]
+}