Database changes to make it better practise

electron/cqrs/commands/handlers/clearAllData.ts

@@ -3,6 +3,8 @@ import {
   MessageEntity,
   UserEntity,
   RoomEntity,
+  RoomChannelEntity,
+  RoomMemberEntity,
   ReactionEntity,
   BanEntity,
   AttachmentEntity,
@@ -13,6 +15,8 @@ export async function handleClearAllData(dataSource: DataSource): Promise<void>
   await dataSource.getRepository(MessageEntity).clear();
   await dataSource.getRepository(UserEntity).clear();
   await dataSource.getRepository(RoomEntity).clear();
+  await dataSource.getRepository(RoomChannelEntity).clear();
+  await dataSource.getRepository(RoomMemberEntity).clear();
   await dataSource.getRepository(ReactionEntity).clear();
   await dataSource.getRepository(BanEntity).clear();
   await dataSource.getRepository(AttachmentEntity).clear();

electron/cqrs/commands/handlers/deleteRoom.ts

@@ -1,10 +1,19 @@
 import { DataSource } from 'typeorm';
-import { RoomEntity, MessageEntity } from '../../../entities';
+import {
+  RoomChannelEntity,
+  RoomEntity,
+  RoomMemberEntity,
+  MessageEntity
+} from '../../../entities';
 import { DeleteRoomCommand } from '../../types';
 
 export async function handleDeleteRoom(command: DeleteRoomCommand, dataSource: DataSource): Promise<void> {
   const { roomId } = command.payload;
 
-  await dataSource.getRepository(RoomEntity).delete({ id: roomId });
-  await dataSource.getRepository(MessageEntity).delete({ roomId });
+  await dataSource.transaction(async (manager) => {
+    await manager.getRepository(RoomChannelEntity).delete({ roomId });
+    await manager.getRepository(RoomMemberEntity).delete({ roomId });
+    await manager.getRepository(RoomEntity).delete({ id: roomId });
+    await manager.getRepository(MessageEntity).delete({ roomId });
+  });
 }

electron/cqrs/commands/handlers/saveMessage.ts

@@ -1,23 +1,26 @@
 import { DataSource } from 'typeorm';
 import { MessageEntity } from '../../../entities';
+import { replaceMessageReactions } from '../../relations';
 import { SaveMessageCommand } from '../../types';
 
 export async function handleSaveMessage(command: SaveMessageCommand, dataSource: DataSource): Promise<void> {
-  const repo = dataSource.getRepository(MessageEntity);
   const { message } = command.payload;
-  const entity = repo.create({
-    id: message.id,
-    roomId: message.roomId,
-    channelId: message.channelId ?? null,
-    senderId: message.senderId,
-    senderName: message.senderName,
-    content: message.content,
-    timestamp: message.timestamp,
-    editedAt: message.editedAt ?? null,
-    reactions: JSON.stringify(message.reactions ?? []),
-    isDeleted: message.isDeleted ? 1 : 0,
-    replyToId: message.replyToId ?? null
-  });
+  await dataSource.transaction(async (manager) => {
+    const repo = manager.getRepository(MessageEntity);
+    const entity = repo.create({
+      id: message.id,
+      roomId: message.roomId,
+      channelId: message.channelId ?? null,
+      senderId: message.senderId,
+      senderName: message.senderName,
+      content: message.content,
+      timestamp: message.timestamp,
+      editedAt: message.editedAt ?? null,
+      isDeleted: message.isDeleted ? 1 : 0,
+      replyToId: message.replyToId ?? null
+    });
 
-  await repo.save(entity);
+    await repo.save(entity);
+    await replaceMessageReactions(manager, message.id, message.reactions ?? []);
+  });
 }

electron/cqrs/commands/handlers/saveRoom.ts

@@ -1,31 +1,36 @@
 import { DataSource } from 'typeorm';
 import { RoomEntity } from '../../../entities';
+import { replaceRoomRelations } from '../../relations';
 import { SaveRoomCommand } from '../../types';
 
 export async function handleSaveRoom(command: SaveRoomCommand, dataSource: DataSource): Promise<void> {
-  const repo = dataSource.getRepository(RoomEntity);
   const { room } = command.payload;
-  const entity = repo.create({
-    id: room.id,
-    name: room.name,
-    description: room.description ?? null,
-    topic: room.topic ?? null,
-    hostId: room.hostId,
-    password: room.password ?? null,
-    hasPassword: room.hasPassword ? 1 : 0,
-    isPrivate: room.isPrivate ? 1 : 0,
-    createdAt: room.createdAt,
-    userCount: room.userCount ?? 0,
-    maxUsers: room.maxUsers ?? null,
-    icon: room.icon ?? null,
-    iconUpdatedAt: room.iconUpdatedAt ?? null,
-    permissions: room.permissions != null ? JSON.stringify(room.permissions) : null,
-    channels: room.channels != null ? JSON.stringify(room.channels) : null,
-    members: room.members != null ? JSON.stringify(room.members) : null,
-    sourceId: room.sourceId ?? null,
-    sourceName: room.sourceName ?? null,
-    sourceUrl: room.sourceUrl ?? null
-  });
+  await dataSource.transaction(async (manager) => {
+    const repo = manager.getRepository(RoomEntity);
+    const entity = repo.create({
+      id: room.id,
+      name: room.name,
+      description: room.description ?? null,
+      topic: room.topic ?? null,
+      hostId: room.hostId,
+      password: room.password ?? null,
+      hasPassword: room.hasPassword ? 1 : 0,
+      isPrivate: room.isPrivate ? 1 : 0,
+      createdAt: room.createdAt,
+      userCount: room.userCount ?? 0,
+      maxUsers: room.maxUsers ?? null,
+      icon: room.icon ?? null,
+      iconUpdatedAt: room.iconUpdatedAt ?? null,
+      permissions: room.permissions != null ? JSON.stringify(room.permissions) : null,
+      sourceId: room.sourceId ?? null,
+      sourceName: room.sourceName ?? null,
+      sourceUrl: room.sourceUrl ?? null
+    });
 
-  await repo.save(entity);
+    await repo.save(entity);
+    await replaceRoomRelations(manager, room.id, {
+      channels: room.channels ?? [],
+      members: room.members ?? []
+    });
+  });
 }

electron/cqrs/commands/handlers/updateMessage.ts

@@ -1,41 +1,45 @@
 import { DataSource } from 'typeorm';
 import { MessageEntity } from '../../../entities';
+import { replaceMessageReactions } from '../../relations';
 import { UpdateMessageCommand } from '../../types';
 
 export async function handleUpdateMessage(command: UpdateMessageCommand, dataSource: DataSource): Promise<void> {
-  const repo = dataSource.getRepository(MessageEntity);
   const { messageId, updates } = command.payload;
-  const existing = await repo.findOne({ where: { id: messageId } });
+  await dataSource.transaction(async (manager) => {
+    const repo = manager.getRepository(MessageEntity);
+    const existing = await repo.findOne({ where: { id: messageId } });
 
-  if (!existing)
-    return;
+    if (!existing)
+      return;
 
-  if (updates.channelId !== undefined)
-    existing.channelId = updates.channelId ?? null;
+    if (updates.channelId !== undefined)
+      existing.channelId = updates.channelId ?? null;
 
-  if (updates.senderId !== undefined)
-    existing.senderId = updates.senderId;
+    if (updates.senderId !== undefined)
+      existing.senderId = updates.senderId;
 
-  if (updates.senderName !== undefined)
-    existing.senderName = updates.senderName;
+    if (updates.senderName !== undefined)
+      existing.senderName = updates.senderName;
 
-  if (updates.content !== undefined)
-    existing.content = updates.content;
+    if (updates.content !== undefined)
+      existing.content = updates.content;
 
-  if (updates.timestamp !== undefined)
-    existing.timestamp = updates.timestamp;
+    if (updates.timestamp !== undefined)
+      existing.timestamp = updates.timestamp;
 
-  if (updates.editedAt !== undefined)
-    existing.editedAt = updates.editedAt ?? null;
+    if (updates.editedAt !== undefined)
+      existing.editedAt = updates.editedAt ?? null;
 
-  if (updates.reactions !== undefined)
-    existing.reactions = JSON.stringify(updates.reactions ?? []);
+    if (updates.isDeleted !== undefined)
+      existing.isDeleted = updates.isDeleted ? 1 : 0;
 
-  if (updates.isDeleted !== undefined)
-    existing.isDeleted = updates.isDeleted ? 1 : 0;
+    if (updates.replyToId !== undefined)
+      existing.replyToId = updates.replyToId ?? null;
 
-  if (updates.replyToId !== undefined)
-    existing.replyToId = updates.replyToId ?? null;
+    await repo.save(existing);
 
-  await repo.save(existing);
+    if (updates.reactions !== undefined) {
+      await replaceMessageReactions(manager, messageId, updates.reactions ?? []);
+    }
+  });
 }

electron/cqrs/commands/handlers/updateRoom.ts

@@ -1,5 +1,6 @@
 import { DataSource } from 'typeorm';
 import { RoomEntity } from '../../../entities';
+import { replaceRoomRelations } from '../../relations';
 import { UpdateRoomCommand } from '../../types';
 import {
   applyUpdates,
@@ -12,20 +13,26 @@ const ROOM_TRANSFORMS: TransformMap = {
   hasPassword: boolToInt,
   isPrivate: boolToInt,
   userCount: (val) => (val ?? 0),
-  permissions: jsonOrNull,
-  channels: jsonOrNull,
-  members: jsonOrNull
+  permissions: jsonOrNull
 };
 
 export async function handleUpdateRoom(command: UpdateRoomCommand, dataSource: DataSource): Promise<void> {
-  const repo = dataSource.getRepository(RoomEntity);
   const { roomId, updates } = command.payload;
-  const existing = await repo.findOne({ where: { id: roomId } });
+  await dataSource.transaction(async (manager) => {
+    const repo = manager.getRepository(RoomEntity);
+    const existing = await repo.findOne({ where: { id: roomId } });
 
-  if (!existing)
-    return;
+    if (!existing)
+      return;
 
-  applyUpdates(existing, updates, ROOM_TRANSFORMS);
-  await repo.save(existing);
+    const { channels, members, ...entityUpdates } = updates;
+
+    applyUpdates(existing, entityUpdates, ROOM_TRANSFORMS);
+    await repo.save(existing);
+    await replaceRoomRelations(manager, roomId, {
+      channels,
+      members
+    });
+  });
 }