Feature/chats business entity

src/app.module.ts

@@ -26,6 +26,7 @@ import { PolicyModule } from './core/policy/policy.module';
 import { SystemApiModule } from './api/system-api/system-api.module';
 import { LoggerMiddleware } from './common/middleware';
 import { WebsocketApiModule } from './api/websocket-api/websocket-api.module';
+import { ChatEntityModule } from './entities/chats/chat.entity.module';
 
 @Module({
   imports: [
@@ -55,6 +56,7 @@ import { WebsocketApiModule } from './api/websocket-api/websocket-api.module';
     PolicyModule,
     SystemApiModule,
     WebsocketApiModule,
+    ChatEntityModule,
   ],
   providers: [
     {

src/common/types/chats.types.ts

@@ -1,32 +1,44 @@
+/* eslint-disable import/no-cycle */
 import { type ObjectId } from 'mongoose';
 import {
   AdminInterface,
   AnyUserInterface,
   RecipientInterface,
   VolunteerInterface,
 } from './user.types';
-import { MongooseIdAndTimestampsInterface } from './system.types';
-
-export interface MessageInterface {
-  _id: ObjectId | string;
+import { ChatType, ChatTypes, MongooseIdAndTimestampsInterface } from './system.types';
+// eslint-disable-next-line import/no-cycle
+import { Chat } from '../../datalake/chats/schemas/chat.schema';
+import { SystemChat } from '../../datalake/chats/schemas/system-chat.schema';
+import { TaskChat } from '../../datalake/chats/schemas/task-chat.schema';
+import { ConflictChatWithVolunteer } from '../../datalake/chats/schemas/conflict-volunteer-chat.schema';
+import { ConflictChatWithRecipient } from '../../datalake/chats/schemas/conflict-recipient-chat.schema';
+
+export interface MessageModelInterface {
   body: string;
   attaches: string[];
-  createdAt: Date | string;
   author: AnyUserInterface;
-  chatId: ObjectId | string;
+  chatId: ObjectId | string | null;
+  timestamp: Date;
 }
 
-export const ChatTypes = {
-  TASK_CHAT: 'TaskChat',
-  SYSTEM_CHAT: 'SystemChat',
-  CONFLICT_CHAT_WITH_VOLUNTEER: 'ConflictChatWithVolunteer',
-  CONFLICT_CHAT_WITH_RECIPIENT: 'ConflictChatWithRecipient',
-} as const;
+export interface MessageInterface extends MessageModelInterface, MongooseIdAndTimestampsInterface {}
 
-export type ChatType = keyof typeof ChatTypes;
+export interface VirginMessageInterface {
+  body: string;
+  author: AnyUserInterface;
+  chatId: ObjectId | string | null;
+  attaches?: string[];
+}
+
+export type TaskChatType = typeof ChatType.TASK_CHAT;
+export type SystemChatType = typeof ChatType.SYSTEM_CHAT;
+export type VolunteerConflictChatType = typeof ChatType.CONFLICT_CHAT_WITH_VOLUNTEER;
+export type RecipientConflictChatType = typeof ChatType.CONFLICT_CHAT_WITH_RECIPIENT;
+export type AnyConflictChatType = VolunteerConflictChatType | RecipientConflictChatType;
 
 export interface ChatModelInterface {
-  type: ChatType;
+  type: ChatTypes;
   isActive: boolean;
 }
 
@@ -82,6 +94,19 @@ export interface ConflictChatWithRecipientInterface
     ConflictChatWithRecipientModelInterface,
     MongooseIdAndTimestampsInterface {}
 
+export type AnyChatInterface =
+  | TaskChatInterface
+  | SystemChatInterface
+  | ConflictChatWithVolunteerInterface
+  | ConflictChatWithRecipientInterface;
+
+export type AnyChat =
+  | Chat
+  | SystemChat
+  | TaskChat
+  | ConflictChatWithVolunteer
+  | ConflictChatWithRecipient;
+
 export interface WatermarkInterface {
   watermark: string;
   unreads: number;
@@ -159,7 +184,26 @@ export type AnyUserChatsResponseDtoInterface =
   | GetUserChatsResponseDtoInterface
   | GetAdminChatsResponseDtoInterface;
 
-export type CreateTaskChatDtoType = Pick<
-  TaskChatInterface,
-  'taskId' | 'type' | 'volunteer' | 'recipient'
->;
+export type CreateChatEntityDtoBaseType<T> = T extends TaskChatType
+  ? Pick<TaskChatInterface, 'taskId' | 'type' | 'volunteer' | 'recipient'>
+  : T extends SystemChatType
+  ? Pick<SystemChatInterface, 'type' | 'user'>
+  : T extends VolunteerConflictChatType
+  ? Pick<ConflictChatWithVolunteerInterface, 'type' | 'taskId' | 'admin' | 'volunteer'>
+  : T extends RecipientConflictChatType
+  ? Pick<ConflictChatWithRecipientInterface, 'type' | 'taskId' | 'admin' | 'recipient'>
+  : never;
+
+export type CreateTaskChatEntityDtoType = CreateChatEntityDtoBaseType<TaskChatType>;
+export type CreateSystemChatEntityDtoType = CreateChatEntityDtoBaseType<SystemChatType>;
+export type CreateConflictVolunteerChatEntityDtoType =
+  CreateChatEntityDtoBaseType<VolunteerConflictChatType>;
+export type CreateConflictRecipientChatEntityDtoType =
+  CreateChatEntityDtoBaseType<RecipientConflictChatType>;
+export type CreateChatEntityDtoTypes =
+  | CreateTaskChatEntityDtoType
+  | CreateSystemChatEntityDtoType
+  | CreateConflictVolunteerChatEntityDtoType
+  | CreateConflictRecipientChatEntityDtoType;
+
+export type CreateChatDtoType<T extends CreateChatEntityDtoTypes> = Omit<T, '_id' | 'type'>;

src/common/types/entities.interfaces.ts

@@ -0,0 +1,31 @@
+import { ObjectId } from 'mongoose';
+import {
+  AnyChatInterface,
+  CreateChatEntityDtoTypes,
+  MessageInterface,
+  VirginMessageInterface,
+} from './chats.types';
+
+export interface ChatEntityInterface {
+  readonly chatId: ObjectId | string;
+  readonly meta: AnyChatInterface;
+  readonly messages: Array<MessageInterface>;
+
+  create(dto: CreateChatEntityDtoTypes): Promise<ChatEntityInterface>;
+
+  toObject(): { metadata: AnyChatInterface; messages: Array<MessageInterface> };
+
+  setOpponentChat(opponentChatId: ObjectId | string): Promise<ChatEntityInterface>;
+
+  find(chatId: string): Promise<ChatEntityInterface>;
+
+  find(dto: Record<string, unknown>): Promise<ChatEntityInterface>;
+
+  find(...data): Promise<ChatEntityInterface>;
+
+  postMessage(dto: VirginMessageInterface): Promise<MessageInterface>;
+
+  close(): Promise<ChatEntityInterface>;
+
+  reopen(): Promise<ChatEntityInterface>;
+}

src/common/types/system.types.ts

@@ -1,3 +1,5 @@
+import { ObjectId } from 'mongoose';
+
 export type ServerConfiguration = {
   port: number;
   ws_port: number;
@@ -35,8 +37,17 @@ export type AppConfiguration = {
 };
 
 export interface MongooseIdAndTimestampsInterface {
-  _id: string;
-  id?: string;
-  createdAt: string;
-  updatedAt: string;
+  _id: string | ObjectId;
+  id?: string | ObjectId;
+  createdAt: string | Date;
+  updatedAt: string | Date;
 }
+
+export const ChatType = {
+  TASK_CHAT: 'TASK_CHAT',
+  SYSTEM_CHAT: 'SYSTEM_CHAT',
+  CONFLICT_CHAT_WITH_VOLUNTEER: 'CONFLICT_CHAT_WITH_VOLUNTEER',
+  CONFLICT_CHAT_WITH_RECIPIENT: 'CONFLICT_CHAT_WITH_RECIPIENT',
+} as const;
+// export const ChatTypes = ChatType;
+export type ChatTypes = keyof typeof ChatType;

src/common/utils/is-conflict-recipient-chat.ts

@@ -0,0 +1,7 @@
+import { ConflictChatWithVolunteer } from '../../datalake/chats/schemas/conflict-volunteer-chat.schema';
+import { ChatType } from '../types/system.types';
+import { Chat } from '../../datalake/chats/schemas/chat.schema';
+
+export function isConflictChatWithRecipient(chat: unknown): chat is ConflictChatWithVolunteer {
+  return chat instanceof Chat && chat.type === ChatType.CONFLICT_CHAT_WITH_RECIPIENT;
+}

src/common/utils/is-conflict-volunteer-chat.ts

@@ -0,0 +1,7 @@
+import { ConflictChatWithVolunteer } from '../../datalake/chats/schemas/conflict-volunteer-chat.schema';
+import { ChatType } from '../types/system.types';
+import { Chat } from '../../datalake/chats/schemas/chat.schema';
+
+export function isConflictChatWithVolunteer(chat: unknown): chat is ConflictChatWithVolunteer {
+  return chat instanceof Chat && chat.type === ChatType.CONFLICT_CHAT_WITH_VOLUNTEER;
+}

src/common/utils/is-system-chat.ts

@@ -0,0 +1,8 @@
+import { SystemChat } from '../../datalake/chats/schemas/system-chat.schema';
+import { Chat } from '../../datalake/chats/schemas/chat.schema';
+import { ChatType } from '../types/system.types';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function isSystemChat(chat: unknown): chat is SystemChat {
+  return chat instanceof Chat && chat.type === ChatType.SYSTEM_CHAT;
+}

src/common/utils/is-task-chat.ts

@@ -0,0 +1,7 @@
+import { TaskChat } from '../../datalake/chats/schemas/task-chat.schema';
+import { ChatType } from '../types/system.types';
+import { Chat } from '../../datalake/chats/schemas/chat.schema';
+
+export function isTaskChat(chat: unknown): chat is TaskChat {
+  return chat instanceof Chat && chat.type === ChatType.TASK_CHAT;
+}

src/datalake/chats/schemas/chat.schema.ts

@@ -1,6 +1,8 @@
 import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
 import { Document, ObjectId, SchemaTypes } from 'mongoose';
-import { ChatModelInterface, ChatType, ChatTypes } from '../../../common/types/chats.types';
+// eslint-disable-next-line import/no-cycle
+import { ChatModelInterface } from '../../../common/types/chats.types';
+import { ChatType, ChatTypes } from '../../../common/types/system.types';
 
 @Schema({
   timestamps: true,
@@ -21,9 +23,9 @@ export class Chat extends Document implements ChatModelInterface {
   @Prop({
     required: true,
     type: SchemaTypes.String,
-    enum: Object.values(ChatTypes),
+    enum: Object.values(ChatType),
   })
-  type: ChatType;
+  type: ChatTypes;
 
   @Prop({
     required: true,

src/datalake/chats/schemas/system-chat.schema.ts

@@ -1,5 +1,6 @@
-import { SchemaTypes } from 'mongoose';
+import { Document, SchemaTypes } from 'mongoose';
 import { Prop, Schema, SchemaFactory, raw } from '@nestjs/mongoose';
+// eslint-disable-next-line import/no-cycle
 import { SystemChatModelInterface } from '../../../common/types/chats.types';
 import {
   VolunteerInterface,

src/datalake/messages/schemas/messages.schema.ts

@@ -1,7 +1,7 @@
 import { Prop, raw, Schema, SchemaFactory } from '@nestjs/mongoose';
 import { Document, SchemaTypes } from 'mongoose';
 import { type ObjectId } from 'mongoose';
-import { MessageInterface } from '../../../common/types/chats.types';
+import { MessageModelInterface } from '../../../common/types/chats.types';
 import { AnyUserInterface } from '../../../common/types/user.types';
 import { rawUserProfile } from '../../../common/constants/mongoose-fields-raw-definition';
 
@@ -12,10 +12,7 @@ import { rawUserProfile } from '../../../common/constants/mongoose-fields-raw-de
     virtuals: true,
   },
 })
-export class Message extends Document implements MessageInterface {
-  @Prop({ required: true, type: SchemaTypes.ObjectId })
-  _id: ObjectId;
-
+export class Message extends Document implements MessageModelInterface {
   @Prop({ required: true, type: SchemaTypes.String })
   title: string;
 
@@ -25,14 +22,14 @@ export class Message extends Document implements MessageInterface {
   @Prop({ required: false, default: [], type: [SchemaTypes.String] })
   attaches: string[];
 
-  @Prop({ required: true, type: SchemaTypes.Date })
-  createdAt: Date;
-
   @Prop({ required: true, type: raw(rawUserProfile) })
   author: AnyUserInterface;
 
   @Prop({ required: true, type: SchemaTypes.ObjectId })
   chatId: ObjectId;
+
+  @Prop({ required: true, type: SchemaTypes.Date })
+  timestamp: Date;
 }
 
 export const MessagesSchema = SchemaFactory.createForClass(Message);

src/entities/chats/chat.entity.module.ts

@@ -0,0 +1,36 @@
+import { Module } from '@nestjs/common';
+import { ModelDefinition, MongooseModule } from '@nestjs/mongoose';
+import { ChatEntity } from './chat.entity';
+import { Chat, ChatSchema } from '../../datalake/chats/schemas/chat.schema';
+import { TaskChat, TaskChatSchema } from '../../datalake/chats/schemas/task-chat.schema';
+import { SystemChat, SystemChatSchema } from '../../datalake/chats/schemas/system-chat.schema';
+import {
+  ConflictChatWithVolunteer,
+  ConflictChatWithVolunteerSchema,
+} from '../../datalake/chats/schemas/conflict-volunteer-chat.schema';
+import {
+  ConflictChatWithRecipient,
+  ConflictChatWithRecipientSchema,
+} from '../../datalake/chats/schemas/conflict-recipient-chat.schema';
+import { Message, MessagesSchema } from '../../datalake/messages/schemas/messages.schema';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([
+      {
+        name: Chat.name,
+        schema: ChatSchema,
+        discriminators: [
+          { name: TaskChat.name, schema: TaskChatSchema },
+          { name: SystemChat.name, schema: SystemChatSchema },
+          { name: ConflictChatWithVolunteer.name, schema: ConflictChatWithVolunteerSchema },
+          { name: ConflictChatWithRecipient.name, schema: ConflictChatWithRecipientSchema },
+        ],
+      } as ModelDefinition,
+      { name: Message.name, schema: MessagesSchema },
+    ]),
+  ],
+  providers: [ChatEntity],
+  exports: [ChatEntity],
+})
+export class ChatEntityModule {}