fix duplicate message

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

@@ -72,7 +72,7 @@ export type IMessage = z.infer<typeof MessageEntitySchema>;
 
 export class MessageEntity {
 
-  $id?: number
+  $id?: string
   id?: string
   roomId?: string
   receiverId?: number

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

@@ -3,7 +3,7 @@ import { Observable as  DexieObservable, PromiseExtended } from 'Dexie';
 import { AttachmentTable } from "src/app/infra/database/dexie/instance/chat/schema/attachment";
 import { Result } from "neverthrow";
 import { MemberTable, MemberTableSchema } from "src/app/infra/database/dexie/instance/chat/schema/members";
-import { RepositoryResult, RepositoryResultNew } from "src/app/infra/repository";
+import { RepositoryResult } from "src/app/infra/repository";
 import { z } from "zod";
 import { MemberListUPdateStatusInputDTO } from "src/app/module/chat/domain/use-case/socket/member-list-update-status-use-case.service";
 import { Observable } from "rxjs";
@@ -26,7 +26,7 @@ export type IGetMemberLive = z.infer<typeof GetMemberLiveInput>
 export abstract class IMemberLocalRepository extends DexieRepository<AttachmentTable, AttachmentTable> {
 
   abstract directMember(input:IDirectMemberInput): Promise<Result<MemberTable, any>>
-  abstract addMember(data: MemberTable):  Promise<RepositoryResultNew<number, MemberTable>>
+  abstract addMember(data: MemberTable):  Promise<RepositoryResult<number, MemberTable>>
   abstract updateMemberRole(data: MemberTable):  Promise<Result<number, any>>
   abstract updateMembersStatus(data: MemberListUPdateStatusInputDTO):  Promise<Result<true, any>>
   abstract allMemberOnline(roomId:string):  DexieObservable<boolean>

src/app/infra/database/dexie/instance/chat/schema/attachment.ts

@@ -5,7 +5,7 @@ import { MessageAttachmentFileType, MessageAttachmentSource } from "src/app/core
 
 export const AttachmentTableSchema = z.object({
   $id: z.number().optional(), // local id
-  $messageId: z.number(),
+  $messageId: z.string(),
   attachmentId: z.string().optional(),
   file: z.instanceof(Blob),
   base64: zodDataUrlSchema.nullable().optional(),

src/app/infra/database/dexie/instance/chat/schema/message.ts

@@ -3,7 +3,8 @@ import { MessageAttachmentFileType, MessageAttachmentSource } from 'src/app/core
 import { z } from 'zod';
 
 export const MessageTableSchema = z.object({
-  $id: z.number().optional(),
+  $id: z.string().optional(),
+  $createAt: z.number().optional(),
   id: z.string().uuid().optional(),
   roomId: z.string().uuid().optional(),
   message: z.string().nullable().optional(),
@@ -48,5 +49,5 @@ export const MessageTableSchema = z.object({
 
 export type MessageTable = z.infer<typeof MessageTableSchema>
 export type DexieMessageTable = EntityTable<MessageTable, '$id'>;
-export const messageTableColumn = '++$id, id, roomId, senderId, message, messageType, canEdit, oneShot, requireUnlock'
+export const messageTableColumn = '$id, id, roomId, senderId, message, messageType, canEdit, oneShot, requireUnlock'
 

src/app/infra/database/dexie/service.ts

@@ -13,7 +13,7 @@ import { BoldTableColumn, DexieBoldTable } from './instance/chat/schema/bold';
 
 
 // Database declaration (move this to its own module also)
-export const chatDatabase = new Dexie('chat-database-infra',{
+export const chatDatabase = new Dexie('chat-database-v1',{
 //  indexedDB: new FDBFactory,
 //   IDBKeyRange: FDBKeyRange, // Mocking IDBKeyRange
 }) as Dexie & {

src/app/infra/repository/adapter.ts

@@ -3,13 +3,12 @@ import { ZodError} from 'zod';
 import { IDBError } from './types';
 
 // Define a type for the Result of repository operations
-export type RepositoryResult<T, E> = Result<T, Error | ZodError<E>>;
-export type RepositoryResultNew<T, E> = Result<T, IDBError<E>>;
+export type RepositoryResult<T, E> = Result<T, IDBError<E>>;
 export abstract class IDexieRepository<T, R> {
 
-  abstract insert(document: T): Promise<RepositoryResultNew<number, T>>
+  abstract insert(document: T): Promise<RepositoryResult<number, T>>
 
-  abstract insertMany(documents: T[]): Promise<RepositoryResult<number[], ZodError<T>>>
+  abstract insertMany(documents: T[]): Promise<RepositoryResult<number[], T[]>>
 
   abstract update(id: any, updatedDocument: Partial<T>) : Promise<RepositoryResult<number, T>>
 

src/app/infra/repository/dexie/dexie-repository.service.ts

@@ -2,15 +2,15 @@ import { Result, ok, err } from 'neverthrow';
 import { EntityTable } from 'Dexie';
 import { ZodError, ZodObject, ZodSchema } from 'zod';
 import { Logger } from 'src/app/services/logger/main/service';
-import { IDexieRepository, RepositoryResultNew } from '../adapter'
-import { IDBError } from '../types';
+import { IDexieRepository, RepositoryResult } from '../adapter'
+import { IDBError, IDexieError } from '../types';
 
 // Define a type for the Result of repository operations
 
 class DBError<T> extends Error implements IDBError<T> {
   zodError?: ZodError<T>;
   parameters: T;
-  error?: any;
+  error?: IDexieError;
 
   constructor(data: IDBError<T>) {
     super(data.message);
@@ -18,6 +18,11 @@ class DBError<T> extends Error implements IDBError<T> {
     this.parameters = data.parameters;
     this.error = data.error;
 
+    Logger.error(data.message, {
+      zodError: this.zodError,
+      parameters: this.parameters
+    })
+
     // // Manually capture the stack trace if needed
     // if (Error.captureStackTrace) {
     //   Error.captureStackTrace(this, DBError);
@@ -25,9 +30,6 @@ class DBError<T> extends Error implements IDBError<T> {
   }
 }
 
-
-type RepositoryResult<T, E> = Result<T, Error | ZodError<E>>;
-
 export class DexieRepository<T, R> implements IDexieRepository<T, R> {
   private table: EntityTable<any, any>;
   private ZodSchema: ZodSchema<T>
@@ -39,7 +41,7 @@ export class DexieRepository<T, R> implements IDexieRepository<T, R> {
     this.ZodPartialSchema = (ZodSchema as ZodObject<any>).partial() as any;
   }
 
-  async insert(document: T): Promise<RepositoryResultNew<number, T>> {
+  async insert(document: T): Promise<RepositoryResult<any, T>> {
 
     const dataValidation = this.ZodSchema.safeParse(document)
 
@@ -47,19 +49,15 @@ export class DexieRepository<T, R> implements IDexieRepository<T, R> {
       try {
         const id = await this.table.add(dataValidation.data);
         return ok(id);
-      } catch (error) {
-        console.log(error)
+      } catch (_error) {
+        const error: IDexieError = _error
         return err(new DBError({
-          message: `dexie.js failed to insert into ${this.table.name}`,
+          message: `dexie.js failed to insert into ${this.table.name}, ${error.message}`,
           parameters: document,
           error: error
         }))
       }
     } else {
-      Logger.error(`dexie.js failed to insert into ${this.table.name}, invalid data`, {
-        data: document,
-        zodError: dataValidation.error.issues
-      });
       return err(new DBError({
         message: `dexie.js failed to insert into ${this.table.name}, invalid data`,
         parameters: document,
@@ -68,27 +66,29 @@ export class DexieRepository<T, R> implements IDexieRepository<T, R> {
     }
   }
 
-  async insertMany(documents: T[]): Promise<RepositoryResult<number[], ZodError<T>>> {
+  async insertMany(documents: T[]): Promise<RepositoryResult<number[], T[]>> {
     // Validate each document
     const schema = this.ZodSchema.array()
 
     const validationResult = schema.safeParse(documents)
     if(!validationResult.success) {
-      Logger.error(`dexie.js failed to insert many into ${this.table.name}, invalid data`, {
-        data: document,
-        zodError: validationResult.error.issues
-      });
-      return err((validationResult as unknown as ZodError<T>))
+      return err(new DBError({
+        message: `dexie.js failed to insert many into ${this.table.name}, invalid data`,
+        parameters: documents,
+        zodError: validationResult.error
+      }))
     }
 
     try {
       const ids = await this.table.bulkAdd(documents as any);
       return ok(ids);
-    } catch (error) {
-      Logger.error(`dexie.js failed to insert many into ${this.table.name}`, {
-        data: document
-      });
-      return err(new Error('Failed to insert multiple documents: ' + error.message));
+    } catch (_error) {
+      const error: IDexieError = _error
+      return err(new DBError({
+        message: `dexie.js failed to insert into many ${this.table.name}, ${error.message}`,
+        parameters: documents,
+        error: error
+      }))
     }
   }
 
@@ -100,19 +100,26 @@ export class DexieRepository<T, R> implements IDexieRepository<T, R> {
       try {
         const updatedCount = await this.table.update(id, dataValidation.data);
         return ok(updatedCount);
-      } catch (error) {
-        Logger.error(`dexie.js failed to update into ${this.table.name}, invalid data`, {
-          data: updatedDocument,
-          id,
-        });
-        return err(new Error('Failed to update document: ' + error.message));
+      } catch (_error) {
+        const error: IDexieError = _error
+        return err(new DBError({
+          message: `dexie.js Failed to update  into ${this.table.name}, ${error.message} `,
+          parameters: {
+            ...updatedDocument,
+            [this.table.schema.primKey.name]: id
+          } as unknown as T,
+          error: error
+        }))
       }
     } else {
-      Logger.error(`dexie.js failed to update into ${this.table.name}, invalid data`, {
-        data: document,
-        zodError: dataValidation.error.issues
-      });
-      return err((dataValidation as unknown as ZodError<T>))
+      return err(new DBError({
+        message: `dexie.js failed to update into ${this.table.name}, invalid data`,
+        parameters: {
+          ...updatedDocument,
+          [this.table.schema.primKey.name]: id
+        } as unknown as T,
+        zodError: dataValidation.error
+      }))
     }
   }
 
@@ -125,15 +132,20 @@ export class DexieRepository<T, R> implements IDexieRepository<T, R> {
       try {
         const updatedCount = await this.table.bulkPut(dataValidation.data);
         return ok(updatedCount);
-      } catch (error) {
-        return err(new Error('Failed to update document: ' + error.message));
+      } catch (_error) {
+        const error: IDexieError = _error
+        return err(new DBError({
+          message: `dexie.js Failed to update  into ${this.table.name}, ${error.message} `,
+          parameters: document,
+          error: error
+        }))
       }
     } else {
-      Logger.error(`dexie.js failed to update many into ${this.table.name}, invalid data`, {
-        data: document,
-        zodError: dataValidation.error.issues
-      });
-      return err((dataValidation as unknown as ZodError<T>))
+      return err(new DBError({
+        message: `dexie.js failed to update many into ${this.table.name}, invalid data`,
+        parameters: updatedDocument ,
+        zodError: dataValidation.error
+      }))
     }
   }
 
@@ -142,8 +154,13 @@ export class DexieRepository<T, R> implements IDexieRepository<T, R> {
     try {
       await this.table.delete(id);
       return ok(undefined);
-    } catch (error) {
-      return err(new Error('Failed to delete document: ' + error.message));
+    } catch (_error) {
+      const error: IDexieError = _error
+      return err(new DBError({
+        message: `dexie.js Failed to delete  into ${this.table.name}, ${error.message} `,
+        parameters: id,
+        error: error
+      }))
     }
   }
 
@@ -151,8 +168,13 @@ export class DexieRepository<T, R> implements IDexieRepository<T, R> {
     try {
       const document = await this.table.get(id);
       return ok(document);
-    } catch (error) {
-      return err(new Error('Failed to find document by ID: ' + error.message));
+    } catch (_error) {
+      const error: IDexieError = _error
+      return err(new DBError({
+        message: `dexie.js Failed to delete  into ${this.table.name}, ${error.message} `,
+        parameters: id,
+        error: error
+      }))
     }
   }
 
@@ -160,11 +182,13 @@ export class DexieRepository<T, R> implements IDexieRepository<T, R> {
     try {
       const documents: any = await this.table.where(filter).toArray();
       return ok(documents);
-    } catch (error) {
-      Logger.error(`dexie.js failed to find  into ${this.table.name}`, {
-        data: filter,
-      });
-      return err(new Error('Failed to find documents: ' + error.message));
+    } catch (_error) {
+      const error: IDexieError = _error;
+      return err(new DBError({
+        message: `dexie.js Failed to find  into ${this.table.name}, ${error.message} `,
+        parameters: filter as any,
+        error: error
+      }))
     }
   }
 
@@ -172,12 +196,13 @@ export class DexieRepository<T, R> implements IDexieRepository<T, R> {
     try {
       const document = await this.table.where(filter).first();
       return ok(document);
-    } catch (error) {
-      Logger.error(`dexie.js failed to findOne  into ${this.table.name}`, {
-        data: filter,
-        error
-      });
-      return err(new Error('Failed to find document: ' + error.message));
+    } catch (_error) {
+      const error: IDexieError = _error
+      return err(new DBError({
+        message: `dexie.js Failed to findOne  into ${this.table.name}, ${error.message} `,
+        parameters: filter as any,
+        error: error
+      }))
     }
   }
 
@@ -185,8 +210,13 @@ export class DexieRepository<T, R> implements IDexieRepository<T, R> {
     try {
       const documents = await this.table.toArray()
       return ok(documents);
-    } catch (error) {
-      return err(new Error('Failed to retrieve all documents: ' + error.message));
+    } catch (_error) {
+      const error: IDexieError = _error
+      return err(new DBError({
+        message: `dexie.js Failed to findAll  into ${this.table.name}, ${error.message} `,
+        parameters: null,
+        error: error
+      }))
     }
   }
 
@@ -194,8 +224,13 @@ export class DexieRepository<T, R> implements IDexieRepository<T, R> {
     try {
       const count = filter ? await this.table.where(filter).count() : await this.table.count();
       return ok(count);
-    } catch (error) {
-      return err(new Error('Failed to count documents: ' + error.message));
+    } catch (_error) {
+      const error: IDexieError = _error
+      return err(new DBError({
+        message: `dexie.js Failed to count  into ${this.table.name}, ${error.message}`,
+        parameters: filter as any,
+        error: error
+      }))
     }
   }
 }

src/app/infra/repository/types.ts

@@ -37,10 +37,20 @@ import { ZodError } from "zod"
 //   command: DatabaseOperationEnum;
 // };
 
-
 export type IDBError<T> = {
   message: string,
   zodError?: ZodError<T>,
   parameters?: T,
-  error?: any
+  error?: IDexieError
+}
+
+export interface IDexieError extends Error {
+  name: string;  // The name of the error, e.g., 'NotFoundError', 'ConstraintError'
+  message: string;  // The error message
+  stack?: string;  // Optional stack trace
+  inner?: Error;  // Some Dexie errors have an inner error
+  dbName?: string;  // The name of the Dexie database where the error occurred
+  tableName?: string;  // The name of the table where the error occurred
+  operation?: string;  // The operation being performed (e.g., 'put', 'get', 'delete')
+  key?: any;  // The key involved in the operation, if applicable
 }

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

@@ -8,6 +8,7 @@ import { chatDatabase } from 'src/app/infra/database/dexie/service';
 import { IMessageLocalRepository } from 'src/app/core/chat/repository/message/message-local-repository';
 import { BehaviorSubject, combineLatest, from, Observable } from 'rxjs';
 import { filter, map } from 'rxjs/operators';
+import { v4 as uuidv4 } from 'uuid'
 
 @Injectable({
   providedIn: 'root'
@@ -15,6 +16,7 @@ import { filter, map } from 'rxjs/operators';
 export class MessageLocalDataSourceService extends DexieRepository<MessageTable, MessageEntity> implements IMessageLocalRepository  {
 
   private creatingSubject : BehaviorSubject<MessageTable> = new BehaviorSubject<MessageTable>(null);
+  private lastTimestamp = 0;
 
   constructor() {
     super(chatDatabase.message, MessageTableSchema)
@@ -26,6 +28,23 @@ export class MessageLocalDataSourceService extends DexieRepository<MessageTable,
   private onCreatingHook() {
     chatDatabase.message.hook('creating', (primaryKey, obj, transaction) => {
 
+      let now = Date.now();
+
+      // If the current time is the same as the last, increment
+      if (now <= this.lastTimestamp) {
+        obj.$createAt = this.lastTimestamp + 1;
+        this.lastTimestamp = this.lastTimestamp + 1;
+      } else {
+        this.lastTimestamp = now;
+        obj.$createAt = now;
+      }
+
+      if(obj.id) {
+        obj.$id = obj.id
+      } else {
+        obj.$id = 'Local-'+uuidv4()
+      }
+
       this.creatingSubject.next(obj)
     });
   }

src/app/module/chat/domain/use-case/message/message-download-attachment-user-case.service.ts

@@ -6,7 +6,7 @@ import { AttachmentLocalDataSource } from 'src/app/module/chat/data/repository/a
 import { z } from 'zod';
 
 const DownloadMessageAttachmentByMessageIdSchema = z.object({
-  $messageId: z.number(),
+  $messageId: z.string(),
   id: z.string()
 })
 

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

@@ -90,7 +90,7 @@ export class RoomBoldSyncUseCaseService {
           await this.boldLocalRepository.open()
           const result = await this.boldLocalRepository.findOne({roomId: newMessage.roomId})
 
-          if(result.isOk() && !result.value) {
+          if(result.isOk() && !result.value?.bold) {
             const result = await this.boldLocalRepository.insert({roomId: newMessage.roomId, bold: 1})
           } else if(result.isOk() && result.value.bold == 0) {
             const result = await this.boldLocalRepository.update(newMessage.roomId, {bold: 1})

src/app/ui/chat/component/messages/messages.page.html

@@ -154,7 +154,7 @@
       <div *ngIf="message.ballon" class="text-center ballon">
         {{ message.message }}
       </div>
-      <div class="rotate-div emoji-container" *ngIf="message.isDeleted != true && message.messageType != IMessageType.information">
+      <div class="rotate-div emoji-container" *ngIf="message.isDeleted != true && message.messageType != IMessageType.information && message.ballon != true">
         <span *ngFor="let reaction of message.reactions" class="emoji-icon">
           {{ reaction.reaction }}
         </span>

src/app/ui/chat/component/messages/messages.page.ts

@@ -307,6 +307,23 @@ export class MessagesPage implements OnInit, OnChanges, AfterViewInit, OnDestroy
     this.date = {}
     const allMessage = [];
 
+    // let ids = {}
+    // messages = messages.filter((message: any) => {
+    //   if (message.$createAt) {
+    //     if (!ids[message.$createAt]) {
+    //       ids[message.$createAt] = true;
+    //       return true; // Keep this message
+    //     } else {
+    //       console.log('delete');
+    //       return false; // Remove this message
+    //     }
+    //   }
+    //   return true; // Keep messages without an id
+    // });
+
+
+    messages = messages.sort((a: any, b: any) => a.$createAt - b.$createAt)
+
     for(const message of messages) {
       const date = whatsappDate(message.sentAt, false)
       if(!this.date[date]) {