add interface

src/app/core/chat/entity/message.ts

@@ -1,7 +1,20 @@
 import { z } from "zod";
-import { MessageAttachmentFileType, MessageAttachmentSource } from "../../../module/chat/data/dto/message/messageOutputDTO";
 import { base64Schema } from "src/app/utils/zod";
 
+
+export enum MessageAttachmentSource {
+  Webtrix = 1,
+  Device,
+}
+
+export enum MessageAttachmentFileType {
+  Doc = 1,
+  Image ,
+  Audio ,
+  Video
+}
+
+
 export const MessageEntitySchema = z.object({
   $id: z.any().optional(),
   id: z.string().optional(),

src/app/core/chat/repository/attachment/attachment-local-repository.ts

@@ -0,0 +1,9 @@
+import { MessageTable } from "src/app/infra/database/dexie/instance/chat/schema/message";
+import { DexieRepository } from "src/app/infra/repository/dexie/dexie-repository.service";
+import { MessageEntity } from "../../entity/message";
+import { Observable as  DexieObservable, PromiseExtended } from 'Dexie';
+import { AttachmentTable } from "src/app/infra/database/dexie/instance/chat/schema/attachment";
+
+export abstract class IAttachmentLocalRepository extends DexieRepository<AttachmentTable, AttachmentTable> {
+
+}

src/app/core/chat/repository/attachment/attachment-remote-repository.ts

@@ -0,0 +1,6 @@
+import { DataSourceReturn } from "src/app/services/Repositorys/type";
+import { IMessageGetAllByRoomIdOutPut } from "../../usecase/message/message-get-all-by-room-Id";
+
+export abstract class IAttachmentRemoteRepository  {
+  abstract getAttachment(id: string | number): DataSourceReturn<Blob>
+}

src/app/core/chat/repository/dto/messageInputDtO.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { MessageAttachmentFileType, MessageAttachmentSource } from "./messageOutputDTO";
+import { base64Schema } from "src/app/utils/zod";
+
+export const MessageInputDTOSchema = z.object({
+  roomId: z.string().uuid().optional(),
+  receiverId: z.number().optional(),
+  senderId: z.number(),
+  message: z.string().nullable().optional(),
+  messageType: z.number(),
+  canEdit: z.boolean(),
+  oneShot: z.boolean(),
+  requireUnlock: z.boolean(),
+  requestId: z.string(),
+  attachment: z.object({
+    fileType: z.nativeEnum(MessageAttachmentFileType),
+    source: z.nativeEnum(MessageAttachmentSource),
+    file: base64Schema.optional(),
+    fileName: z.string().optional(),
+    applicationId: z.number().optional(),
+    docId: z.number().optional(),
+    mimeType: z.string().optional()
+  }).optional()
+});
+
+
+export type MessageInputDTO = z.infer<typeof MessageInputDTOSchema>

src/app/core/chat/repository/dto/messageOutputDTO.ts

@@ -0,0 +1,53 @@
+import { z } from "zod"
+
+export enum MessageAttachmentSource {
+  Webtrix = 1,
+  Device,
+}
+
+export enum MessageAttachmentFileType {
+  Doc = 1,
+  Image ,
+  Audio ,
+  Video
+}
+
+export const MessageOutPutDataDTOSchema = z.object({
+  id: z.string(),
+  roomId: z.string(),
+  sender: z.object({
+    wxUserId: z.number(),
+    wxFullName: z.string(),
+    wxeMail: z.string(),
+    userPhoto: z.string().optional()
+  }),
+  message: z.string().nullable().optional(),
+  messageType: z.number(),
+  sentAt: z.string(),
+  canEdit: z.boolean(),
+  oneShot: z.boolean(),
+  requireUnlock: z.boolean(),
+  requestId: z.string().optional().nullable(),
+  reactions: z.object({
+    id: z.string(),
+    reactedAt: z.string(),
+    reaction: z.string(),
+    sender: z.object({}),
+  }).array(),
+  info: z.array(z.object({
+    memberId: z.number(),
+    readAt: z.string().nullable(),
+    deliverAt: z.string().nullable()
+  })),
+  attachments: z.array(z.object({
+    fileType: z.nativeEnum(MessageAttachmentFileType),
+    source: z.nativeEnum(MessageAttachmentSource),
+    file: z.string().optional(),
+    fileName: z.string().optional(),
+    applicationId: z.number().optional(),
+    docId: z.string().optional(),
+    id: z.string().optional()
+  }))
+});
+
+export type MessageOutPutDataDTO = z.infer<typeof MessageOutPutDataDTOSchema>

src/app/core/chat/repository/member/member-local-repository.ts

@@ -0,0 +1,9 @@
+import { MessageTable } from "src/app/infra/database/dexie/instance/chat/schema/message";
+import { DexieRepository } from "src/app/infra/repository/dexie/dexie-repository.service";
+import { MessageEntity } from "../../entity/message";
+import { Observable as  DexieObservable, PromiseExtended } from 'Dexie';
+import { AttachmentTable } from "src/app/infra/database/dexie/instance/chat/schema/attachment";
+
+export abstract class IMemberLocalRepository extends DexieRepository<AttachmentTable, AttachmentTable> {
+
+}

src/app/core/chat/repository/member/member-remote-repository.ts

@@ -0,0 +1,10 @@
+import { DataSourceReturn } from "src/app/services/Repositorys/type";
+import { Result } from "neverthrow";
+import { UserRemoveListInputDTO } from "src/app/module/chat/data/dto/room/userRemoveListInputDTO";
+import { AddMemberToRoomInputDTO } from "src/app/module/chat/domain/use-case/member/member-add-use-case.service";
+
+export abstract class IMemberRemoteRepository  {
+  abstract addMemberToRoom(data: AddMemberToRoomInputDTO): DataSourceReturn<AddMemberToRoomInputDTO>
+
+  abstract removeMemberFromRoom(data: UserRemoveListInputDTO): Promise<Result<any ,any>> 
+}

src/app/core/chat/repository/message/message-local-repository.ts

@@ -0,0 +1,11 @@
+import { MessageTable } from "src/app/infra/database/dexie/instance/chat/schema/message";
+import { DexieRepository } from "src/app/infra/repository/dexie/dexie-repository.service";
+import { MessageEntity } from "../../entity/message";
+import { Observable as  DexieObservable, PromiseExtended } from 'Dexie';
+
+export abstract class IMessageLocalRepository extends DexieRepository<MessageTable, MessageEntity> {
+  abstract setAllSenderToFalse(): void
+  abstract getItems(roomId: string): PromiseExtended<MessageEntity[]>
+  abstract getItemsLive(roomId: string): DexieObservable<MessageEntity[]> 
+  abstract getOfflineMessages(): Promise<MessageEntity[]>
+}

src/app/core/chat/repository/message/message-remote-repository.ts

@@ -0,0 +1,6 @@
+import { DataSourceReturn } from "src/app/services/Repositorys/type";
+import { IMessageGetAllByRoomIdOutPut } from "../../usecase/message/message-get-all-by-room-Id";
+
+export abstract class IMessageRemoteRepository {
+  abstract getMessagesFromRoom(id: string): DataSourceReturn<IMessageGetAllByRoomIdOutPut>
+}

src/app/core/chat/repository/message/message-socket-repository.ts

@@ -0,0 +1,29 @@
+import { HubConnection } from "@microsoft/signalr";
+import { Result } from "neverthrow";
+import { MessageInputDTO } from '../dto/messageInputDtO'
+import { MessageCreateOutPutDataDTO } from "src/app/module/chat/domain/use-case/message/message-create-use-case.service";
+import { MessageMarkAsReadInput } from "src/app/module/chat/domain/use-case/message/message-mark-as-read-use-case.service";
+import { MessageDeleteInputDTO } from "src/app/module/chat/domain/use-case/message/message-delete-by-id-live-use-case.service";
+import { MessageOutPutDataDTO } from "../dto/messageOutputDTO";
+import { Observable } from "rxjs";
+import { MessageReactionInput } from "src/app/module/chat/domain/use-case/message/message-reaction-by-id-use-case.service";
+import { MessageUpdateInput } from "src/app/module/chat/domain/use-case/message/message-update-by-id-use-case.service";
+
+export abstract class IMessageSocketRepository {
+
+  abstract connect(): Promise<Result<HubConnection, false>>
+  abstract sendGroupMessage(data: MessageInputDTO): Promise<Result<MessageCreateOutPutDataDTO, any>> 
+  abstract sendDirectMessage(data: MessageInputDTO): Promise<Result<MessageCreateOutPutDataDTO, any>> 
+
+  // abstract sendDeliverAt(): Promise<Result<any, any>>
+  abstract sendReadAt(data: MessageMarkAsReadInput): Promise<Result<any, any>>
+  abstract sendDelete(data: MessageDeleteInputDTO): Promise<Result<any, any>>
+
+  abstract listenToMessages(): Observable<MessageOutPutDataDTO>
+  abstract listenToDeleteMessages(): Observable<MessageOutPutDataDTO>
+  abstract listenToUpdateMessages(): Observable<MessageOutPutDataDTO>
+
+  abstract reactToMessageSocket(data: MessageReactionInput): void
+  abstract updateMessage(input: MessageUpdateInput): void
+  abstract sendMessageDelete(data: MessageDeleteInputDTO): Promise<Result<any, any>>
+}

src/app/core/chat/usecase/message/http-listen-to-message-load-history-use-case.ts

@@ -1,17 +1,16 @@
 import { HttpErrorResponse } from "@angular/common/http";
 import { Injectable } from "@angular/core";
-import { Result } from "neverthrow";
 import { Observable } from "rxjs";
 import { filter, map } from "rxjs/operators";
 import { HttpAdapter } from "src/app/infra/http/adapter";
-import { MessageOutPutDTO } from "src/app/module/chat/data/dto/message/messageOutputDTO";
 import { z } from "zod";
+import { IMessageGetAllByRoomIdOutPut } from "./message-get-all-by-room-Id";
 
 const HttpListenToMessageLoadHistoryUseCaseInputSchema = z.object({
   roomId: z.string()
 })
 
-export type HttpListenToMessageLoadHistoryUseCaseInput = z.infer<typeof HttpListenToMessageLoadHistoryUseCaseInputSchema> 
+export type HttpListenToMessageLoadHistoryUseCaseInput = z.infer<typeof HttpListenToMessageLoadHistoryUseCaseInputSchema>
 
 @Injectable({
   providedIn: 'root'
@@ -22,13 +21,13 @@ export class HttpListenToMessageLoadHistoryUseCase{
     private http: HttpAdapter
   ) {}
 
-  execute(input: HttpListenToMessageLoadHistoryUseCaseInput): Observable<MessageOutPutDTO>  {
+  execute(input: HttpListenToMessageLoadHistoryUseCaseInput): Observable<IMessageGetAllByRoomIdOutPut>  {
     return this.http.listen().pipe(
       filter((response)=> response.isOk()),
       filter((response: any)=> {
         return response.value.url.includes(`Room/${input.roomId}/Messages`)
       }),
-      map((response: any) => response.value.data as MessageOutPutDTO)
+      map((response: any) => response.value.data as IMessageGetAllByRoomIdOutPut)
     )
   }
-}
+}

src/app/core/chat/usecase/message/message-get-all-by-room-Id.ts

@@ -0,0 +1,64 @@
+import { HttpErrorResponse } from "@angular/common/http";
+import { Injectable } from "@angular/core";
+import { Result } from "neverthrow";
+import { Observable } from "rxjs";
+import { filter, map } from "rxjs/operators";
+import { HttpAdapter } from "src/app/infra/http/adapter";
+import { MessageAttachmentFileType, MessageAttachmentSource } from "src/app/module/chat/data/dto/message/messageOutputDTO";
+import { z } from "zod";
+
+export const MessageGetAllByRoomIdUseCaseOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string(),
+  data: z.object({
+    id: z.string(),
+    roomId: z.string(),
+    sender: z.object({
+      wxUserId: z.number(),
+      wxFullName: z.string(),
+      wxeMail: z.string(),
+      userPhoto: z.string().nullable().optional()
+    }),
+    message: z.string().nullable().optional(),
+    messageType: z.number(),
+    sentAt: z.string(),
+    canEdit: z.boolean(),
+    oneShot: z.boolean(),
+    requireUnlock: z.boolean(),
+    requestId: z.string().optional().nullable(),
+    reactions: z.object({
+      id: z.string(),
+      reactedAt: z.string(),
+      reaction: z.string(),
+      sender: z.object({}),
+    }).array(),
+    info: z.array(z.object({
+      memberId: z.number(),
+      readAt: z.string().nullable(),
+      deliverAt: z.string().nullable()
+    })),
+    attachments: z.array(z.object({
+      fileType: z.nativeEnum(MessageAttachmentFileType),
+      source: z.nativeEnum(MessageAttachmentSource),
+      file: z.string().optional(),
+      fileName: z.string().optional(),
+      applicationId: z.number().optional(),
+      docId: z.string().optional(),
+      id: z.string().optional()
+    }))
+  }).array()
+})
+
+export type IMessageGetAllByRoomIdOutPut = z.infer<typeof MessageGetAllByRoomIdUseCaseOutputSchema>
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MessageGetAllByRoomIdUseCase{
+
+  constructor(
+    private http: HttpAdapter
+  ) {}
+
+  execute(input: any) {}
+}

src/app/infra/socket/signalR/signal-r.service.ts

@@ -6,7 +6,6 @@ import { Plugins } from '@capacitor/core';
 import { filter, map, skip, switchMap } from 'rxjs/operators';
 import { Result } from 'neverthrow';
 import { HubConnection } from '@microsoft/signalr';
-import { MessageOutPutDataDTO } from 'src/app/module/chat/data/dto/message/messageOutputDTO';
 import { UserTypingDTO } from 'src/app/module/chat/data/dto/typing/typingInputDTO';
 import { ISignalRInput } from '../type';
 

src/app/module/chat/data/dto/message/messageOutputDTO.ts

@@ -50,11 +50,4 @@ export const MessageOutPutDataDTOSchema = z.object({
   }))
 });
 
-export const MessageOutPutDTOSchema = z.object({
-  success: z.boolean(),
-  message: z.string(),
-  data: MessageOutPutDataDTOSchema.array()
-});
-
 export type MessageOutPutDataDTO = z.infer<typeof MessageOutPutDataDTOSchema>
-export type MessageOutPutDTO = z.infer<typeof MessageOutPutDTOSchema>

src/app/module/chat/data/dto/room/addMemberToRoomInputDto.ts

@@ -1,8 +0,0 @@
-import { z } from "zod";
-
-export const AddMemberToRoomInputDTOSchema = z.object({
-  id: z.string(),
-  members: z.array(z.number()),
-});
-
-export type AddMemberToRoomInputDTO = z.infer<typeof AddMemberToRoomInputDTOSchema>

src/app/module/chat/data/repository/attachment/attachment-local-repository.service.ts

@@ -1,5 +1,6 @@
 import { Injectable } from '@angular/core';
 import { Subject } from 'rxjs';
+import { IAttachmentLocalRepository } from 'src/app/core/chat/repository/attachment/attachment-local-repository';
 import { AttachmentTable, AttachmentTableSchema } from 'src/app/infra/database/dexie/instance/chat/schema/attachment';
 import { chatDatabase } from 'src/app/infra/database/dexie/service';
 import { DexieRepository } from 'src/app/infra/repository/dexie/dexie-repository.service';
@@ -7,7 +8,7 @@ import { DexieRepository } from 'src/app/infra/repository/dexie/dexie-repository
 @Injectable({
   providedIn: 'root'
 })
-export class AttachmentLocalDataSource extends DexieRepository<AttachmentTable, AttachmentTable>  {
+export class AttachmentLocalDataSource extends DexieRepository<AttachmentTable, AttachmentTable> implements IAttachmentLocalRepository {
 
   messageSubject = new Subject();
 

src/app/module/chat/data/repository/attachment/attachment-remote-repository.service.ts

@@ -1,13 +1,12 @@
 import { Injectable, Input } from '@angular/core';
+import { IAttachmentRemoteRepository } from 'src/app/core/chat/repository/attachment/attachment-remote-repository';
 import { HttpService } from 'src/app/services/http.service';
 import { DataSourceReturn } from 'src/app/services/Repositorys/type';
-import { MessageOutPutDTO } from '../../dto/message/messageOutputDTO';
-import { MessageAttachmentByMessageIdInput } from '../../../domain/use-case/message/message-attachment-by-message-id.service';
 
 @Injectable({
   providedIn: 'root'
 })
-export class AttachmentRemoteDataSourceService {
+export class AttachmentRemoteDataSourceService implements IAttachmentRemoteRepository {
   private baseUrl = 'https://gdapi-dev.dyndns.info/stage/api/v2/Chat'; // Your base URL
 
   constructor(

src/app/module/chat/data/repository/member/member-list-local-repository.service.ts

@@ -8,11 +8,12 @@ import { MemberListUPdateStatusInputDTO } from '../../../domain/use-case/socket/
 import { from } from 'rxjs';
 import { MemberTable, MemberTableSchema } from 'src/app/infra/database/dexie/instance/chat/schema/members';
 import { chatDatabase } from 'src/app/infra/database/dexie/service';
+import { IMemberLocalRepository } from 'src/app/core/chat/repository/member/member-local-repository';
 
 @Injectable({
   providedIn: 'root'
 })
-export class MemberListLocalRepository extends DexieRepository<MemberTable, MemberTable> {
+export class MemberListLocalRepository extends DexieRepository<MemberTable, MemberTable> implements IMemberLocalRepository {
 
   constructor() {
     super(chatDatabase.members, MemberTableSchema)

src/app/module/chat/data/repository/member/member-list-remote-repository.service.ts

@@ -3,13 +3,13 @@ import { Result } from 'neverthrow';
 import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
 import { HttpService } from 'src/app/services/http.service';
 import { DataSourceReturn } from 'src/app/services/Repositorys/type';
-import { AddMemberToRoomInputDTOSchema, AddMemberToRoomInputDTO } from '../../dto/room/addMemberToRoomInputDto';
+import { IMemberRemoteRepository } from 'src/app/core/chat/repository/member/member-remote-repository';
-import { UserRemoveListInputDTOSchema, UserRemoveListInputDTO } from '../../dto/room/userRemoveListInputDTO';
+import { UserRemoveListInputDTO, UserRemoveListInputDTOSchema } from "src/app/module/chat/data/dto/room/userRemoveListInputDTO";
-
+import { AddMemberToRoomInputDTO, AddMemberToRoomInputDTOSchema } from '../../../domain/use-case/member/member-add-use-case.service';
 @Injectable({
   providedIn: 'root'
 })
-export class MemberListRemoteRepository {
+export class MemberListRemoteRepository implements IMemberRemoteRepository {
 
   private baseUrl = 'https://gdapi-dev.dyndns.info/stage/api/v2/Chat'; // Your base URL
 

src/app/module/chat/data/repository/message/message-live-signalr-data-source.service.ts

@@ -4,21 +4,15 @@ import { v4 as uuidv4 } from 'uuid'
 import { InstanceId } from '../../../domain/chat-service.service';
 import { MessageUpdateInput } from '../../../domain/use-case/message/message-update-by-id-use-case.service';
 import { MessageOutPutDataDTO } from '../../dto/message/messageOutputDTO';
-import { MessageInputDTO } from '../../dto/message/messageInputDtO';
 import { MessageReactionInput } from '../../../domain/use-case/message/message-reaction-by-id-use-case.service';
 import { SignalRService } from 'src/app/infra/socket/signalR/signal-r.service';
 import { filter, map } from 'rxjs/operators';
 import { SocketMessage } from 'src/app/infra/socket/signalR/signalR';
+import { IMessageSocketRepository } from 'src/app/core/chat/repository/message/message-socket-repository';
+import { MessageCreateOutPutDataDTO } from '../../../domain/use-case/message/message-create-use-case.service';
+import { MessageInputDTO } from 'src/app/core/chat/repository/dto/messageInputDtO'
+import { MessageMarkAsReadInput } from '../../../domain/use-case/message/message-mark-as-read-use-case.service';
 
-interface msgObj {
-  roomId: string;
-  senderId: string;
-  message:string;
-  messageType:1;
-  canEdit:Boolean;
-  oneShot:Boolean;
-  requestId: string;
-}
 
 interface sendDeliverAt {
   memberId: number,
@@ -28,18 +22,11 @@ interface sendDeliverAt {
 }
 
 
-export interface sendReadAt {
- memberId: number,
- messageId:string,
- roomId: string,
- requestId: string
-}
-
 
 @Injectable({
   providedIn: 'root'
 })
-export class MessageSocketRepositoryService {
+export class MessageSocketRepositoryService implements IMessageSocketRepository {
 
   constructor(
     private socket: SignalRService
@@ -60,7 +47,7 @@ export class MessageSocketRepositoryService {
       data.requestId = InstanceId +'@'+ uuidv4();
     }
 
-    const result =  await this.socket.sendData<MessageOutPutDataDTO>({
+    const result =  await this.socket.sendData<MessageCreateOutPutDataDTO>({
       method: 'sendMessage',
       data: data,
     })
@@ -90,7 +77,7 @@ export class MessageSocketRepositoryService {
     return result;
   }
 
-  async sendReadAt(data: sendReadAt) {
+  async sendReadAt(data: MessageMarkAsReadInput) {
     const result =  await this.socket.sendData<any>({
       method: 'ReadAt',
       data: data as any,

src/app/module/chat/data/repository/message/message-local-data-source.service.ts

@@ -8,11 +8,12 @@ import { DexieRepository } from 'src/app/infra/repository/dexie/dexie-repository
 import { Observable as  DexieObservable, PromiseExtended } from 'Dexie';
 import { MessageTable, MessageTableSchema } from 'src/app/infra/database/dexie/instance/chat/schema/message';
 import { chatDatabase } from 'src/app/infra/database/dexie/service';
+import { IMessageLocalRepository } from 'src/app/core/chat/repository/message/message-local-repository';
 
 @Injectable({
   providedIn: 'root'
 })
-export class MessageLocalDataSourceService extends DexieRepository<MessageTable, MessageEntity>  {
+export class MessageLocalDataSourceService extends DexieRepository<MessageTable, MessageEntity> implements IMessageLocalRepository  {
 
 
   constructor() {

src/app/module/chat/data/repository/message/message-remote-data-source.service.ts

@@ -1,22 +1,15 @@
 import { Injectable } from '@angular/core';
 import { HttpService } from 'src/app/services/http.service';
-import { MessageInputDTO, MessageInputDTOSchema } from '../../dto/message/messageInputDtO';
-import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
-import { APIReturn } from 'src/app/services/decorators/api-validate-schema.decorator';
-import { MessageOutPutDataDTOSchema, MessageOutPutDTO, MessageOutPutDTOSchema } from '../../dto/message/messageOutputDTO';
 import { DataSourceReturn } from 'src/app/services/Repositorys/type';
 import { SignalRService } from 'src/app/infra/socket/signalR/signal-r.service';
-import { MessageUpdateInput } from '../../../domain/use-case/message/message-update-by-id-use-case.service';
-import { SessionStore } from 'src/app/store/session.service';
-import { MessageDeleteInputDTO } from '../../dto/message/messageDeleteInputDTO';
-import { InstanceId } from '../../../domain/chat-service.service';
-import { v4 as uuidv4 } from 'uuid'
 import { HttpAdapter } from 'src/app/infra/http/adapter';
+import { IMessageGetAllByRoomIdOutPut } from 'src/app/core/chat/usecase/message/message-get-all-by-room-Id';
+import { IMessageRemoteRepository } from 'src/app/core/chat/repository/message/message-remote-repository';
 
 @Injectable({
   providedIn: 'root'
 })
-export class MessageRemoteDataSourceService {
+export class MessageRemoteDataSourceService implements IMessageRemoteRepository {
 
   private baseUrl = 'https://gdapi-dev.dyndns.info/stage/api/v2/Chat'; // Your base URL
 
@@ -26,34 +19,17 @@ export class MessageRemoteDataSourceService {
     private http: HttpAdapter
   ) {}
 
-  @APIReturn(MessageOutPutDTOSchema, 'post/Messages')
-  @ValidateSchema(MessageInputDTOSchema)
-  async sendMessage(data: MessageInputDTO) {
-    return await this.httpService.post<MessageOutPutDTO>(`${this.baseUrl}/Messages`, data);
-  }
-
-  // async reactToMessage(id: string, reaction: any) {
-  //   return await this.httpService.post<any>(`${this.baseUrl}/Messages/${id}/React`, reaction);
-  // }
-
 
   // @APIReturn(MessageOutPutDTOSchema, 'get/Messages')
-  async getMessagesFromRoom(id: string): DataSourceReturn<MessageOutPutDTO>  {
+  async getMessagesFromRoom(id: string): DataSourceReturn<IMessageGetAllByRoomIdOutPut>  {
 
-    var a = await this.http.get<MessageOutPutDTO>(`${this.baseUrl}/Room/${id}/Messages`)
+    var a = await this.http.get<IMessageGetAllByRoomIdOutPut>(`${this.baseUrl}/Room/${id}/Messages`)
 
     return a.map((e) => {
       return e.data
     })
-    
+
-    return await this.httpService.get(`${this.baseUrl}/Room/${id}/Messages`);
+    // return await this.httpService.get(`${this.baseUrl}/Room/${id}/Messages`);
   }
 
-
-  @APIReturn(MessageOutPutDTOSchema, 'get/Messages/attachment')
-  async getAttachment(id: string): DataSourceReturn<MessageOutPutDTO>  {
-    return await this.httpService.get(`${this.baseUrl}/attachment/${id}`);
-  }
-
-
 }

src/app/module/chat/data/repository/room/room-local-repository.service.ts

@@ -1,9 +1,5 @@
 import { Injectable } from '@angular/core';
-import { RoomListItemOutPutDTO, RoomListOutPutDTO } from '../../dto/room/roomListOutputDTO';
 import { liveQuery, Observable } from 'Dexie';
-import { err, ok, Result } from 'neverthrow';
-import { z } from 'zod';
-import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
 import { DexieRepository } from 'src/app/infra/repository/dexie/dexie-repository.service';
 import { from } from 'rxjs';
 import { RoomTable, RoomTableSchema } from 'src/app/infra/database/dexie/instance/chat/schema/room';

src/app/module/chat/data/repository/room/room-remote-repository.service.ts

@@ -4,7 +4,7 @@ import { HttpService } from 'src/app/services/http.service';
 import { RoomListOutPutDTO, RoomListOutPutDTOSchema } from '../../dto/room/roomListOutputDTO';
 import { RoomInputDTO, RoomInputDTOSchema } from '../../dto/room/roomInputDTO';
 import { RoomOutPutDTO, RoomOutPutDTOSchema } from '../../dto/room/roomOutputDTO';
-import { AddMemberToRoomInputDTO, AddMemberToRoomInputDTOSchema } from '../../dto/room/addMemberToRoomInputDto';
+import { AddMemberToRoomInputDTO, AddMemberToRoomInputDTOSchema } from '../../../domain/use-case/member/member-add-use-case.service';
 import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
 import { RoomByIdInputDTO, RoomByIdInputDTOSchema } from '../../dto/room/roomByIdInputDTO';
 import { RoomByIdOutputDTO, RoomByIdOutputDTOSchema } from '../../dto/room/roomByIdOutputDTO';

src/app/module/chat/data/repository/room/room-socket-repository.service.spec.ts

@@ -1,16 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-
-import { RoomSocketRepositoryService } from './room-socket-repository.service';
-
-describe('RoomSocketRepositoryService', () => {
-  let service: RoomSocketRepositoryService;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({});
-    service = TestBed.inject(RoomSocketRepositoryService);
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-});

src/app/module/chat/domain/adapter.ts

@@ -5,8 +5,7 @@ import { MessageEntity } from "src/app/core/chat/entity/message";
 import { HttpListenToMessageLoadHistoryUseCaseInput } from "src/app/core/chat/usecase/message/http-listen-to-message-load-history-use-case";
 import { HttpResult } from "src/app/infra/http/type";
 import { UseCase } from "src/app/utils/use-case-interface";
-import { MessageOutPutDTO } from "../data/dto/message/messageOutputDTO";
+import { IMessageGetAllByRoomIdOutPut } from 'src/app/core/chat/usecase/message/message-get-all-by-room-Id'
-
 export abstract class ITemplateCreateAdapter implements UseCase<MessageEntity, any> {
   execute(input: MessageEntity): Promise<any> {
     throw new Error("Method not implemented.");
@@ -18,5 +17,5 @@ export abstract class SocketOnReconnectAdapter {
 }
 
 export abstract class HttpListenToMessageLoadHistoryAdapter {
-  abstract execute(input: HttpListenToMessageLoadHistoryUseCaseInput): Observable<MessageOutPutDTO>
+  abstract execute(input: HttpListenToMessageLoadHistoryUseCaseInput): Observable<IMessageGetAllByRoomIdOutPut>
 }

src/app/module/chat/domain/chat-service.service.ts

@@ -35,13 +35,13 @@ import { MessageEntity } from '../../../core/chat/entity/message';
 import { MessageAttachmentByMessageIdInput, MessageAttachmentByMessageIdUseCase } from './use-case/message/message-attachment-by-message-id.service';
 import { RoomInputDTO } from '../data/dto/room/roomInputDTO';
 import { UserRemoveListInputDTO } from '../data/dto/room/userRemoveListInputDTO';
-import { AddMemberToRoomInputDTO } from '../data/dto/room/addMemberToRoomInputDto';
+import { AddMemberToRoomInputDTO, AddMemberToRoomInputDTOSchema } from '../domain/use-case/member/member-add-use-case.service';
 import { RoomUpdateInputDTO } from '../data/dto/room/roomUpdateInputDTO';
 import { RoomType } from "src/app/core/chat/entity/group";
-import { sendReadAt } from "src/app/module/chat/data/repository/message/message-live-signalr-data-source.service";
 import { HttpListenToMessageLoadHistoryAdapter } from './adapter'
 import { HttpListenToMessageLoadHistoryUseCaseInput } from 'src/app/core/chat/usecase/message/http-listen-to-message-load-history-use-case';
 import { MessageSocketRepositoryService } from 'src/app/module/chat/data/repository/message/message-live-signalr-data-source.service'
+import { MessageMarkAsReadInput } from "src/app/module/chat/domain/use-case/message/message-mark-as-read-use-case.service";
 
 export const InstanceId = uuidv4();
 
@@ -230,7 +230,7 @@ export class ChatServiceService {
 
   }
 
-  sendReadAt(sendReadAt: sendReadAt) {
+  sendReadAt(sendReadAt: MessageMarkAsReadInput) {
     return this.MessageMarkAsReadUseCaseService.execute(sendReadAt)
   }
 

src/app/module/chat/domain/use-case/member/member-add-use-case.service.ts

@@ -1,7 +1,16 @@
 import { Injectable } from '@angular/core';
 import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
-import { AddMemberToRoomInputDTO } from '../../../data/dto/room/addMemberToRoomInputDto';
 import { RoomRemoteDataSourceService } from '../../../data/repository/room/room-remote-repository.service';
+import { z } from 'zod';
+
+
+export const AddMemberToRoomInputDTOSchema = z.object({
+  id: z.string(),
+  members: z.array(z.number()),
+});
+
+export type AddMemberToRoomInputDTO = z.infer<typeof AddMemberToRoomInputDTOSchema>
+
 
 @Injectable({
   providedIn: 'root'

src/app/module/chat/domain/use-case/message/listen-message-by-roomId.service.ts

@@ -3,7 +3,14 @@ import { filter, map } from 'rxjs/operators';
 import { InstanceId } from '../../chat-service.service';
 import { MessageSocketRepositoryService } from 'src/app/module/chat/data/repository/message/message-live-signalr-data-source.service'
 import { MessageEntity } from '../../../../../core/chat/entity/message';
-import { UseCase } from 'src/app/utils/use-case-interface';
+import { z } from 'zod';
+
+
+export const ListenMessageByRoomIdNewInputDTOSchema = z.object({
+  roomId: z.string(),
+});
+export type ListenMessageByRoomIdNewInputDTO = z.infer<typeof ListenMessageByRoomIdNewInputDTOSchema>
+
 
 @Injectable({
   providedIn: 'root'
@@ -14,10 +21,10 @@ export class ListenMessageByRoomIdNewUseCase {
     private MessageSocketRepositoryService: MessageSocketRepositoryService
   ) { }
 
-  execute({roomId}: {roomId: string}) {
+  execute(data: ListenMessageByRoomIdNewInputDTO) {
 
     return this.MessageSocketRepositoryService.listenToMessages().pipe(
-      filter((message) => !message?.requestId?.startsWith(InstanceId) && message?.roomId == roomId),
+      filter((message) => !message?.requestId?.startsWith(InstanceId) && message?.roomId == data.roomId),
       map(message => Object.assign(new MessageEntity(), message))
     )
 

src/app/module/chat/domain/use-case/message/listen-message-update-by-roomId.service.ts

@@ -1,6 +1,14 @@
 import { Injectable } from '@angular/core';
 import { filter } from 'rxjs/operators';
 import { MessageSocketRepositoryService } from '../../../data/repository/message/message-live-signalr-data-source.service';
+import { z } from 'zod';
+
+export const ListenMessageUpdateByRoomIdInputDTOSchema = z.object({
+  roomId: z.string(),
+});
+export type ListenMessageUpdateByRoomIdInputDTO = z.infer<typeof ListenMessageUpdateByRoomIdInputDTOSchema>
+
+
 
 @Injectable({
   providedIn: 'root'
@@ -11,9 +19,9 @@ export class ListenMessageUpdateByRoomIdUseCase {
     private messageLiveSignalRDataSourceService: MessageSocketRepositoryService,
   ) { }
 
-  execute({roomId}) {
+  execute(input: ListenMessageUpdateByRoomIdInputDTO) {
     return this.messageLiveSignalRDataSourceService.listenToUpdateMessages().pipe(
-      filter((message) => roomId == message?.roomId )
+      filter((message) => input.roomId == message?.roomId )
     )
   }
 }

src/app/module/chat/domain/use-case/message/listen-send-message.service.ts

@@ -2,6 +2,14 @@ import { Injectable } from '@angular/core';
 import { MessageSocketRepositoryService } from 'src/app/module/chat/data/repository/message/message-live-signalr-data-source.service'
 import { InstanceId } from '../../chat-service.service';
 import { filter, map } from 'rxjs/operators';
+import { z } from 'zod';
+
+export const ListenSendMessageInputDTOSchema = z.object({
+  roomId: z.string(),
+});
+export type ListenSendMessageInputDTO = z.infer<typeof ListenSendMessageInputDTOSchema>
+
+
 
 @Injectable({
   providedIn: 'root'

src/app/module/chat/domain/use-case/message/listene-message-delete-by-roomId.service.ts

@@ -2,6 +2,14 @@ import { Injectable } from '@angular/core';
 import { filter } from 'rxjs/operators';
 import { SignalRService } from 'src/app/infra/socket/signalR/signal-r.service';
 import { MessageSocketRepositoryService } from 'src/app/module/chat/data/repository/message/message-live-signalr-data-source.service'
+import { z } from 'zod';
+
+export const ListenMessageDeleteByRoomIdInputDTOSchema = z.object({
+  roomId: z.string(),
+});
+export type ListenMessageDeleteByRoomIdInputDTO = z.infer<typeof ListenMessageDeleteByRoomIdInputDTOSchema>
+
+
 @Injectable({
   providedIn: 'root'
 })
@@ -11,7 +19,7 @@ export class ListenMessageDeleteByRoomIdService {
     private MessageSocketRepositoryService: MessageSocketRepositoryService,
   ) { }
 
-  execute({roomId}) {
+  execute({roomId}: ListenMessageDeleteByRoomIdInputDTO) {
     return this.MessageSocketRepositoryService.listenToDeleteMessages().pipe(
       filter((message) => {
         return roomId == message?.roomId

src/app/module/chat/domain/use-case/message/message-create-use-case.service.ts

@@ -17,19 +17,54 @@ import { TracingType, XTracerAsync } from 'src/app/services/monitoring/opentelem
 import { MemberListLocalRepository } from 'src/app/module/chat/data/repository/member/member-list-local-repository.service'
 import { SessionStore } from 'src/app/store/session.service';
 import { MessageTable } from 'src/app/infra/database/dexie/instance/chat/schema/message';
+import { MessageAttachmentFileType } from 'src/app/core/chat/repository/dto/messageOutputDTO';
 
-const MessageInputUseCaseSchema = z.object({
-  memberId: z.number(),
-  roomId: z.string(),
-  message: z.string()
-})
 
 export enum MessageEnum {
   Direct = 1,
   group = 2
 }
 
-export type MessageInputUseCase = z.infer< typeof MessageInputUseCaseSchema>
+
+export const MessageCreatePutDataDTOSchema = z.object({
+  id: z.string(),
+  roomId: z.string(),
+  sender: z.object({
+    wxUserId: z.number(),
+    wxFullName: z.string(),
+    wxeMail: z.string(),
+    userPhoto: z.string().optional()
+  }),
+  message: z.string().nullable().optional(),
+  messageType: z.number(),
+  sentAt: z.string(),
+  canEdit: z.boolean(),
+  oneShot: z.boolean(),
+  requireUnlock: z.boolean(),
+  requestId: z.string().optional().nullable(),
+  reactions: z.object({
+    id: z.string(),
+    reactedAt: z.string(),
+    reaction: z.string(),
+    sender: z.object({}),
+  }).array(),
+  info: z.array(z.object({
+    memberId: z.number(),
+    readAt: z.string().nullable(),
+    deliverAt: z.string().nullable()
+  })),
+  attachments: z.array(z.object({
+    fileType: z.nativeEnum(MessageAttachmentFileType),
+    source: z.nativeEnum(MessageAttachmentSource),
+    file: z.string().optional(),
+    fileName: z.string().optional(),
+    applicationId: z.number().optional(),
+    docId: z.string().optional(),
+    id: z.string().optional()
+  }))
+});
+
+export type MessageCreateOutPutDataDTO = z.infer<typeof MessageCreatePutDataDTOSchema>
 
 @Injectable({
   providedIn: 'root'

src/app/module/chat/domain/use-case/message/message-delete-by-id-live-use-case.service.ts

@@ -1,7 +1,5 @@
 import { Injectable } from '@angular/core';
 import { z } from 'zod';
-import { SafeValidateSchema, ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
-import { MessageRemoteDataSourceService } from '../../../data/repository/message/message-remote-data-source.service';
 import { MessageSocketRepositoryService } from '../../../data/repository/message/message-live-signalr-data-source.service';
 import { XTracerAsync, TracingType } from 'src/app/services/monitoring/opentelemetry/tracer';
 export const MessageDeleteInputDTOSchema = z.object({

src/app/module/chat/domain/use-case/message/message-mark-as-read-use-case.service.ts

@@ -1,6 +1,17 @@
 import { Injectable } from '@angular/core';
-import { MessageSocketRepositoryService, sendReadAt } from '../../../data/repository/message/message-live-signalr-data-source.service';
+import { MessageSocketRepositoryService } from '../../../data/repository/message/message-live-signalr-data-source.service';
 import { XTracerAsync, TracingType } from 'src/app/services/monitoring/opentelemetry/tracer';
+import { z } from 'zod';
+
+export const MessageMarkAsReadInputSchema = z.object({
+  memberId: z.number(),
+  messageId: z.string(),
+  roomId: z.string(),
+  requestId: z.string()
+})
+
+export type MessageMarkAsReadInput = z.infer<typeof MessageMarkAsReadInputSchema>
+
 @Injectable({
   providedIn: 'root'
 })
@@ -12,7 +23,7 @@ export class MessageMarkAsReadUseCaseService {
 
 
   @XTracerAsync({name:'MessageMarkAsReadUseCaseService', module:'chat',  bugPrint: true})
-  async execute(sendReadAt: sendReadAt, tracing?: TracingType) {
+  async execute(sendReadAt: MessageMarkAsReadInput, tracing?: TracingType) {
-    return this.MessageSocketRepositoryService.sendReadAt(sendReadAt)
+    return this.MessageSocketRepositoryService.sendReadAt(sendReadAt as any)
   }
 }

src/app/module/chat/domain/use-case/message/message-read-at-by-id-use-case.service.ts

@@ -1,32 +0,0 @@
-import { Injectable } from '@angular/core';
-import { err, ok } from 'neverthrow';
-import { SessionStore } from 'src/app/store/session.service';
-import { MessageLocalDataSourceService } from '../../../data/repository/message/message-local-data-source.service';
-import { MessageSocketRepositoryService } from '../../../data/repository/message/message-live-signalr-data-source.service';
-import { MessageRemoteDataSourceService } from '../../../data/repository/message/message-remote-data-source.service';
-import { SignalRService } from 'src/app/infra/socket/signalR/signal-r.service';
-
-
-@Injectable({
-  providedIn: 'root'
-})
-export class MessageReadAtByIdUseCaseService {
-
-  constructor(
-    private MessageSocketRepositoryService: MessageSocketRepositoryService,
-    private messageLiveSignalRDataSourceService: SignalRService,
-    private messageLocalDataSourceService: MessageLocalDataSourceService,
-  ) { }
-
-  async execute({roomId}) {
-    // const result = await this.messageLocalDataSourceService.getLastMessageByRoomId(roomId)
-    // if(result.isOk()) {
-    //   if(result.value) {
-
-    //     return await this.MessageSocketRepositoryService.sendReadAt({roomId, memberId: SessionStore.user.UserId, messageId: result.value.id, requestId: ''})
-    //   }
-    //   return ok(true)
-    // }
-    // return err(false)
-  }
-}

src/app/module/chat/domain/use-case/message/message-send-use-case.service.ts

@@ -1,31 +0,0 @@
-import { Injectable } from '@angular/core';
-import { MessageEntity } from '../../../../../core/chat/entity/message';
-import { z } from 'zod';
-
-const MessageInputUseCaseSchema = z.object({
-  memberId: z.number(),
-  roomId: z.string(),
-  message: z.string()
-})
-
-export type MessageInputUseCase = z.infer< typeof MessageInputUseCaseSchema>
-
-@Injectable({
-  providedIn: 'root'
-})
-export class MessageCreateUseCaseService {
-
-  constructor() { }
-
-
-  async execute(input: MessageEntity) {
-
-    // const result = await this.MessageRepositoryService.(input)
-
-    // if(result.isOk()) {
-
-    // }
-
-    // return result
-  }
-}

src/app/module/chat/domain/use-case/message/message-to-async-ui.service.ts

@@ -1,9 +0,0 @@
-import { Injectable } from '@angular/core';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class MessageToAsyncUIService {
-
-  constructor() { }
-}

src/app/module/chat/domain/use-case/room/room-create-use-case.service.ts

@@ -1,12 +1,21 @@
 import { Injectable } from '@angular/core';
-import { create } from 'domain';
 import { SessionStore } from 'src/app/store/session.service';
 import { RoomRemoteDataSourceService } from '../../../data/repository/room/room-remote-repository.service';
 import { RoomSocketRepositoryService } from '../../../data/repository/room/room-socket-repository.service';
-import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
-import { RoomInputDTO } from '../../../data/dto/room/roomInputDTO';
 import { RoomLocalRepository } from '../../../data/repository/room/room-local-repository.service';
 import { TracingType, XTracerAsync } from 'src/app/services/monitoring/opentelemetry/tracer';
+import { z } from "zod";
+
+export const CreateRoomInputDTOSchema = z.object({
+  roomName: z.string(),
+  createdBy: z.number(),
+  roomType: z.number(),
+  expirationDate: z.string().nullable().optional(),
+  members: z.array(z.number())
+});
+
+
+export type CreateRoomInputDTO = z.infer<typeof CreateRoomInputDTOSchema>
 
 @Injectable({
   providedIn: 'root'
@@ -19,9 +28,8 @@ export class CreateRoomUseCaseService {
     private RoomSocketRepositoryService: RoomSocketRepositoryService
   ) { }
 
-
   @XTracerAsync({name:'room-create-use-case.service', module:'chat',  bugPrint: true, waitNThrow: 5000})
-  async execute(data: RoomInputDTO, tracing?: TracingType) {
+  async execute(data: CreateRoomInputDTO, tracing?: TracingType) {
 
     const result = await this.RoomSocketRepositoryService.CreateGroup(data)
     // const result = await this.roomRemoteDataSourceService.createRoom(data)

src/app/module/chat/domain/use-case/room/room-get-list-use-case.service.ts

@@ -3,7 +3,6 @@ import { roomListDetermineChanges } from '../../../data/async/list/rooms/roomLis
 import { RoomRemoteDataSourceService } from '../../../data/repository/room/room-remote-repository.service';
 import { RoomLocalRepository } from '../../../data/repository/room/room-local-repository.service';
 import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
-import { isHttpResponse } from 'src/app/services/http.service';
 import { CronJobService } from 'src/app/utils/task-scheduler'
 @Injectable({
   providedIn: 'root'

src/app/module/chat/domain/use-case/socket/socket-message-create-use-case.service.ts

@@ -2,7 +2,29 @@ import { Injectable, Input } from '@angular/core';
 import { MessageLocalDataSourceService } from '../../../data/repository/message/message-local-data-source.service';
 import { TracingType, XTracerAsync } from 'src/app/services/monitoring/opentelemetry/tracer';
 import { ParamsValidation } from 'src/app/services/decorators/validate-schema.decorator';
-import { MessageOutPutDataDTOSchema } from '../../../data/dto/message/messageOutputDTO';
+import { MessageEntitySchema } from 'src/app/core/chat/entity/message';
+import { z } from 'zod';
+
+const SocketMessageCreateOutputSchema = MessageEntitySchema.pick({
+  id: true,
+  attachments: true,
+  canEdit: true,
+  editedAt: true,
+  info: true,
+  isDeleted: true,
+  message: true,
+  messageType: true,
+  oneShot: true,
+  reactions: true,
+  receiverId: true,
+  requireUnlock: true,
+  roomId: true,
+  sender: true,
+  sending: true,
+  sentAt: true,
+})
+
+export type ISocketMessageCreateOutput = z.infer<typeof SocketMessageCreateOutputSchema>
 
 @Injectable({
   providedIn: 'root'
@@ -14,9 +36,9 @@ export class SocketMessageCreateUseCaseService {
   ) { }
 
   @XTracerAsync({name:'Socket-Message-Create-UseCase', module:'chat',  bugPrint: true})
-  async execute(input: any, tracing?: TracingType) {
+  async execute(input: ISocketMessageCreateOutput, tracing?: TracingType) {
 
-    ParamsValidation(MessageOutPutDataDTOSchema, input, tracing)
+    ParamsValidation(SocketMessageCreateOutputSchema, input, tracing)
 
     const incomingMessage =  {
       ...input,

src/app/module/chat/domain/use-case/socket/socket-message-delete-use-case.service.ts

@@ -1,6 +1,29 @@
 import { Injectable } from '@angular/core';
 import { MessageLocalDataSourceService } from '../../../data/repository/message/message-local-data-source.service';
-import { MessageOutPutDataDTO } from '../../../data/dto/message/messageOutputDTO';
+import { MessageEntitySchema } from 'src/app/core/chat/entity/message';
+import { z } from 'zod';
+
+const SocketMessageDeleteOutputSchema = MessageEntitySchema.pick({
+  id: true,
+  attachments: true,
+  canEdit: true,
+  editedAt: true,
+  info: true,
+  isDeleted: true,
+  message: true,
+  messageType: true,
+  oneShot: true,
+  reactions: true,
+  receiverId: true,
+  requireUnlock: true,
+  roomId: true,
+  sender: true,
+  sending: true,
+  sentAt: true,
+})
+
+
+export type ISocketMessageDeleteOutput = z.infer<typeof SocketMessageDeleteOutputSchema>
 
 @Injectable({
   providedIn: 'root'
@@ -12,7 +35,7 @@ export class SocketMessageDeleteUseCaseService {
   ) { }
 
 
-  async execute(input: MessageOutPutDataDTO) {
+  async execute(input: ISocketMessageDeleteOutput) {
     const result = await this.messageLocalDataSourceService.update(input.id, { isDeleted: true})
 
     if(result.isOk()) {

src/app/module/chat/domain/use-case/socket/socket-message-update-use-case.service.ts

@@ -2,9 +2,32 @@ import { Injectable } from '@angular/core';
 import { MessageLocalDataSourceService } from '../../../data/repository/message/message-local-data-source.service';
 import { MessageOutPutDataDTO, MessageOutPutDataDTOSchema } from '../../../data/dto/message/messageOutputDTO';
 import { ParamsValidation, SafeValidateSchema, ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
-import { MessageInputDTOSchema } from '../../../data/dto/message/messageInputDtO';
 import { TracingType, XTracerAsync } from 'src/app/services/monitoring/opentelemetry/tracer';
+import { MessageEntitySchema } from 'src/app/core/chat/entity/message';
+import { z } from 'zod';
+import { MessageTable } from 'src/app/infra/database/dexie/instance/chat/schema/message';
 
+
+const SocketMessageUpdateOutputSchema = MessageEntitySchema.pick({
+  id: true,
+  attachments: true,
+  canEdit: true,
+  editedAt: true,
+  info: true,
+  isDeleted: true,
+  message: true,
+  messageType: true,
+  oneShot: true,
+  reactions: true,
+  receiverId: true,
+  requireUnlock: true,
+  roomId: true,
+  sender: true,
+  sending: true,
+  sentAt: true,
+})
+
+export type ISocketMessageUpdateOutput = z.infer<typeof SocketMessageUpdateOutputSchema>
 @Injectable({
   providedIn: 'root'
 })
@@ -16,21 +39,19 @@ export class SocketMessageUpdateUseCaseService {
 
 
   @XTracerAsync({name:'Socket-Message-Update-UseCase', bugPrint: true, module:'chat',})
-  async execute(data: MessageOutPutDataDTO, tracing?: TracingType) {
+  async execute(input: ISocketMessageUpdateOutput, tracing?: TracingType) {
 
-    ParamsValidation(MessageOutPutDataDTOSchema, data, tracing)
+    ParamsValidation(MessageOutPutDataDTOSchema, input, tracing)
     tracing?.addEvent("Message existe?")
-    const result = await this.messageLocalDataSourceService.findOne({id: data.id})
+    const result = await this.messageLocalDataSourceService.findOne({id: input.id})
 
-    const incomingMessage =  {
+    const messageToSave: MessageTable = input
-      ...data,
+    messageToSave.sending = false
-      sending: false
-    }
 
     if(result.isOk() && result.value) {
       
       tracing?.addEvent("Message found")
-      const updateResult = await this.messageLocalDataSourceService.update(result.value.$id, incomingMessage)
+      const updateResult = await this.messageLocalDataSourceService.update(result.value.$id, messageToSave)
       tracing.setAttribute('outcome', 'success')
       return updateResult
     } else if(result.isOk() && !result.value) {