OV-52: add chat controller

backend/.env.example

@@ -20,3 +20,13 @@ AWS_SECRET_ACCESS_KEY=see-in-slack
 AWS_S3_REGION=eu-north-1
 AWS_S3_BUCKET_NAME=bsa-2024-outreachvids
 AWS_CLOUDFRONT_DOMAIN_ID=d2tm5q3cg1nlwf
+
+#
+# OPEN AI
+#
+OPEN_AI_KEY=SOME_SECRET_KEY
+
+#
+# SESSION
+#
+SESSION_KEY=SOME_SECRET_KEY

backend/package.json

@@ -32,6 +32,8 @@
         "@aws-sdk/client-s3": "3.635.0",
         "@aws-sdk/s3-request-presigner": "3.635.0",
         "@fastify/multipart": "8.3.0",
+        "@fastify/cookie": "9.4.0",
+        "@fastify/session": "10.9.0",
         "@fastify/static": "7.0.4",
         "@fastify/swagger": "8.15.0",
         "@fastify/swagger-ui": "4.0.1",
@@ -46,6 +48,7 @@
         "pino": "9.3.2",
         "pino-pretty": "10.3.1",
         "shared": "*",
-        "swagger-jsdoc": "6.2.8"
+        "swagger-jsdoc": "6.2.8",
+        "tiktoken": "1.0.16"
     }
 }

backend/src/bundles/chat/chat.controller.ts

@@ -0,0 +1,176 @@
+import { type FastifySessionObject } from '@fastify/session';
+
+import {
+    type ApiHandlerOptions,
+    type ApiHandlerResponse,
+    BaseController,
+} from '~/common/controller/controller.js';
+import { ApiPath } from '~/common/enums/enums.js';
+import { HttpCode, HTTPMethod } from '~/common/http/http.js';
+import { type Logger } from '~/common/logger/logger.js';
+import { MAX_TOKEN } from '~/common/services/open-ai/libs/constants/constants.js';
+
+import {
+    ChatPath,
+    OpenAIRole,
+} from '../../common/services/open-ai/libs/enums/enums.js';
+import { type OpenAIService } from '../../common/services/open-ai/open-ai.service.js';
+import { type ChatService } from './chat.service.js';
+import { type GenerateTextRequestDto } from './libs/types/types.js';
+import { textGenerationValidationSchema } from './libs/validation-schemas/validation-schemas.js';
+
+class ChatController extends BaseController {
+    private openAIService: OpenAIService;
+    private chatService: ChatService;
+
+    public constructor(
+        logger: Logger,
+        openAIService: OpenAIService,
+        chatService: ChatService,
+    ) {
+        super(logger, ApiPath.CHAT);
+
+        this.openAIService = openAIService;
+        this.chatService = chatService;
+
+        this.addRoute({
+            path: ChatPath.ROOT,
+            method: HTTPMethod.POST,
+            validation: {
+                body: textGenerationValidationSchema,
+            },
+            handler: (options) =>
+                this.generateChatAnswer(
+                    options as ApiHandlerOptions<{
+                        body: GenerateTextRequestDto;
+                        session: FastifySessionObject;
+                    }>,
+                ),
+        });
+
+        this.addRoute({
+            path: ChatPath.ROOT,
+            method: HTTPMethod.DELETE,
+            handler: (options) =>
+                this.deleteSession(
+                    options as ApiHandlerOptions<{
+                        session: FastifySessionObject;
+                    }>,
+                ),
+        });
+    }
+
+    /**
+     * @swagger
+     * /chat/:
+     *    post:
+     *      description: Returns generated text by Open AI
+     *      requestBody:
+     *        description: User message
+     *        required: true
+     *        content:
+     *          application/json:
+     *            schema:
+     *              type: object
+     *              properties:
+     *                message:
+     *                  type: string
+     *      responses:
+     *        200:
+     *          description: Successful operation
+     *          content:
+     *            application/json:
+     *              schema:
+     *                type: object
+     *                properties:
+     *                  generatedText:
+     *                    type: string
+     */
+
+    private async generateChatAnswer(
+        options: ApiHandlerOptions<{
+            body: GenerateTextRequestDto;
+            session: FastifySessionObject;
+        }>,
+    ): Promise<ApiHandlerResponse> {
+        const { body, session } = options;
+
+        session.chatHistory = this.chatService.addMessageToHistory(
+            session.chatHistory,
+            body.message,
+            OpenAIRole.USER,
+        );
+
+        session.chatHistory = this.chatService.deleteOldMessages(
+            session.chatHistory,
+            MAX_TOKEN,
+        );
+
+        const generatedText = await this.openAIService.generateText(
+            session.chatHistory,
+        );
+
+        session.chatHistory = this.chatService.addMessageToHistory(
+            session.chatHistory,
+            generatedText,
+            OpenAIRole.ASSISTANT,
+        );
+
+        return {
+            payload: { generatedText },
+            status: HttpCode.OK,
+        };
+    }
+
+    /**
+     * @swagger
+     * /chat/:
+     *    delete:
+     *      description: Clears chat history
+     *      requestBody:
+     *        description: User message
+     *        required: false
+     *      responses:
+     *        200:
+     *          description: Successful operation
+     *          content:
+     *            application/json:
+     *              schema:
+     *                type: object
+     *                properties:
+     *                  isDeleted:
+     *                    type: boolean
+     *        500:
+     *          description: Failed operation
+     *          content:
+     *            application/json:
+     *              schema:
+     *                  type: object
+     *                  properties:
+     *                    isDeleted:
+     *                      type: boolean
+     */
+    private deleteSession(
+        options: ApiHandlerOptions<{
+            session: FastifySessionObject;
+        }>,
+    ): ApiHandlerResponse {
+        const { session } = options;
+
+        session.destroy((error) => {
+            if (error) {
+                return {
+                    payload: { isDeleted: false },
+                    status: HttpCode.INTERNAL_SERVER_ERROR,
+                };
+            }
+        });
+
+        return {
+            payload: { isDeleted: true },
+            status: HttpCode.OK,
+        };
+    }
+}
+
+export { ChatController };

backend/src/bundles/chat/chat.service.ts

@@ -0,0 +1,64 @@
+import { type ValueOf } from 'shared';
+import { type Tiktoken, encoding_for_model } from 'tiktoken';
+
+import { CHAT_MODEL } from '~/common/services/open-ai/libs/constants/constants.js';
+import { type OpenAIRole } from '~/common/services/open-ai/libs/enums/enums.js';
+
+import {
+    type ChatService as ChatServiceT,
+    type Message,
+} from './libs/types/types.js';
+
+class ChatService implements ChatServiceT {
+    private modelEncoding: Tiktoken;
+
+    public constructor() {
+        this.modelEncoding = encoding_for_model(CHAT_MODEL);
+    }
+
+    public addMessageToHistory(
+        chatHistory: Message[],
+        userMessage: string,
+        role: ValueOf<typeof OpenAIRole>,
+    ): Message[] {
+        const newUserMessage = {
+            content: userMessage,
+            role,
+        };
+
+        return [...chatHistory, newUserMessage];
+    }
+
+    private countTokens(messages: Message[]): number {
+        return messages.reduce(
+            (sum, message) =>
+                sum + this.modelEncoding.encode(message.content).length,
+            0,
+        );
+    }
+
+    public deleteOldMessages(
+        messages: Message[],
+        maxTokens: number,
+    ): Message[] {
+        let totalTokens = this.countTokens(messages);
+        let updatedMessages = [...messages];
+
+        while (totalTokens > maxTokens && updatedMessages.length > 0) {
+            const [removedMessage, ...rest] = updatedMessages;
+            updatedMessages = rest;
+
+            if (!removedMessage) {
+                break;
+            }
+
+            totalTokens -= this.modelEncoding.encode(
+                removedMessage.content,
+            ).length;
+        }
+
+        return updatedMessages;
+    }
+}
+
+export { ChatService };

backend/src/bundles/chat/chat.ts

@@ -0,0 +1,10 @@
+import { logger } from '~/common/logger/logger.js';
+import { openAIService } from '~/common/services/services.js';
+
+import { ChatController } from './chat.controller.js';
+import { ChatService } from './chat.service.js';
+
+const chatService = new ChatService();
+const chatController = new ChatController(logger, openAIService, chatService);
+
+export { chatController };

backend/src/bundles/chat/libs/types/chat-service.type.ts

@@ -0,0 +1,16 @@
+import { type ValueOf } from 'shared';
+
+import { type OpenAIRole } from '~/common/services/open-ai/libs/enums/enums.js';
+
+import { type Message } from './message.type.js';
+
+type ChatService = {
+    addMessageToHistory(
+        chatHistory: Message[],
+        userMessage: string,
+        role: ValueOf<typeof OpenAIRole>,
+    ): Message[];
+    deleteOldMessages(messages: Message[], maxTokens: number): void;
+};
+
+export { type ChatService };

backend/src/common/services/open-ai/libs/types/message.type.ts → backend/src/bundles/chat/libs/types/message.type.ts

@@ -1,6 +1,6 @@
 import { type ValueOf } from 'shared';
 
-import { type OpenAIRole } from '../enums/enums.js';
+import { type OpenAIRole } from '~/common/services/open-ai/libs/enums/enums.js';
 
 type Message = {
     role: ValueOf<typeof OpenAIRole>;

backend/src/bundles/chat/libs/types/types.ts

@@ -0,0 +1,3 @@
+export { type ChatService } from './chat-service.type.js';
+export { type Message } from './message.type.js';
+export { type GenerateTextRequestDto } from 'shared';

backend/src/bundles/chat/libs/validation-schemas/validation-schemas.ts

@@ -0,0 +1 @@
+export { textGenerationValidationSchema } from 'shared';

backend/src/common/config/base-config.package.ts

@@ -47,6 +47,12 @@ class BaseConfig implements Config {
                     env: 'OPEN_AI_KEY',
                     default: null,
                 },
+                SESSION_KEY: {
+                    doc: 'Key for sessions',
+                    format: String,
+                    env: 'SESSION_KEY',
+                    default: null,
+                },
             },
             DB: {
                 CONNECTION_STRING: {

backend/src/common/config/types/environment-schema.type.ts

@@ -6,6 +6,7 @@ type EnvironmentSchema = {
         PORT: number;
         ENVIRONMENT: ValueOf<typeof AppEnvironment>;
         OPEN_AI_KEY: string;
+        SESSION_KEY: string;
     };
     DB: {
         CONNECTION_STRING: string;

backend/src/common/controller/base-controller.package.ts

@@ -49,12 +49,13 @@ class BaseController implements Controller {
     private mapRequest(
         request: Parameters<ServerAppRouteParameters['handler']>[0],
     ): ApiHandlerOptions {
-        const { body, query, params } = request;
+        const { body, query, params, session } = request;
 
         return {
             body,
             query,
             params,
+            session,
         };
     }
 }

backend/src/common/controller/types/api-handler-options.type.ts

@@ -2,6 +2,7 @@ type DefaultApiHandlerOptions = {
     body?: unknown;
     query?: unknown;
     params?: unknown;
+    session?: unknown;
 };
 
 type ApiHandlerOptions<
@@ -10,6 +11,7 @@ type ApiHandlerOptions<
     body: T['body'];
     query: T['query'];
     params: T['params'];
+    session: T['session'];
 };
 
 export { type ApiHandlerOptions };

backend/src/common/http/enums/enums.ts

@@ -1 +1 @@
-export { HttpCode } from 'shared';
+export { HttpCode, HTTPMethod } from 'shared';

backend/src/common/http/http.ts

@@ -1,3 +1,3 @@
-export { HttpCode } from './enums/enums.js';
+export { HttpCode, HTTPMethod } from './enums/enums.js';
 export { HttpError } from './exceptions/exceptions.js';
 export { type HttpMethod } from './types/types.js';

backend/src/common/plugins/libs/enums/controller-hook.enum.ts

@@ -0,0 +1,5 @@
+const ControllerHook = {
+    ON_REQUEST: 'onRequest',
+} as const;
+
+export { ControllerHook };

backend/src/common/plugins/libs/enums/enums.ts

@@ -0,0 +1 @@
+export { ControllerHook } from './controller-hook.enum.js';

backend/src/common/plugins/plugins.ts

@@ -0,0 +1 @@
+export { session } from './session/session.plugin.js';