refactor: change entities name

src/entities/index.ts

@@ -1,2 +1,3 @@
-export * from './mediasoup.slave.js';
-export * from './mediasoup.room.js';
+export * from './media.slave.js';
+export * from './media.room.js';
+export * from './media.peer.js';

src/entities/media.peer.ts

@@ -0,0 +1,39 @@
+import {
+  Entity,
+  BaseEntity,
+  CreateDateColumn,
+  Column,
+  PrimaryColumn,
+  ManyToOne,
+} from 'typeorm';
+import { MediaSlave } from './media.slave.js';
+import { MediaRoom } from './media.room.js';
+
+@Entity()
+export class MediaPeer extends BaseEntity {
+  @PrimaryColumn('uuid')
+  id!: string;
+
+  @Column('integer')
+  slaveId!: number;
+
+  @ManyToOne(() => MediaSlave, (slave) => slave.peers, {
+    onDelete: 'CASCADE',
+  })
+  slave!: MediaSlave;
+
+  @Column('uuid')
+  roomId!: string;
+
+  @ManyToOne(() => MediaRoom, (room) => room.peers, { onDelete: 'CASCADE' })
+  room!: MediaRoom;
+
+  @Column('text')
+  routerId!: string;
+
+  @Column({ type: 'jsonb', nullable: true })
+  metadata?: any;
+
+  @CreateDateColumn()
+  createDate!: Date;
+}

src/entities/mediasoup.room.ts → src/entities/media.room.ts

@@ -4,18 +4,25 @@ import {
   BaseEntity,
   CreateDateColumn,
   Column,
-  Index,
+  ManyToOne,
+  OneToMany,
 } from 'typeorm';
+import { MediaSlave } from './media.slave.js';
+import { MediaPeer } from './media.peer.js';
 
 @Entity()
-export class MediasoupRoom extends BaseEntity {
+export class MediaRoom extends BaseEntity {
   @PrimaryGeneratedColumn('uuid')
   id!: string;
 
-  @Index()
   @Column('integer')
   slaveId!: number;
 
+  @ManyToOne(() => MediaSlave, (slave) => slave.rooms, {
+    onDelete: 'CASCADE',
+  })
+  slave!: MediaSlave;
+
   @Column('text')
   routerId!: string;
 
@@ -24,4 +31,7 @@ export class MediasoupRoom extends BaseEntity {
 
   @CreateDateColumn()
   createDate!: Date;
+
+  @OneToMany(() => MediaPeer, (peer) => peer.room)
+  peers!: MediaRoom[];
 }

src/entities/mediasoup.slave.ts → src/entities/media.slave.ts

@@ -4,11 +4,14 @@ import {
   Column,
   BaseEntity,
   Index,
+  OneToMany,
 } from 'typeorm';
+import { MediaRoom } from './media.room.js';
+import { MediaPeer } from './media.peer.js';
 
 @Entity()
 @Index(['internalHost', 'apiPort'], { unique: true })
-export class MediasoupSlave extends BaseEntity {
+export class MediaSlave extends BaseEntity {
   @PrimaryGeneratedColumn('increment')
   id!: number;
 
@@ -29,4 +32,10 @@ export class MediasoupSlave extends BaseEntity {
 
   @Column('integer', { default: 0 })
   peerCount!: number;
+
+  @OneToMany(() => MediaRoom, (room) => room.slave)
+  rooms!: MediaRoom[];
+
+  @OneToMany(() => MediaPeer, (peer) => peer.slave)
+  peers!: MediaRoom[];
 }

src/run_slave.ts

@@ -1,21 +1,18 @@
 import 'node-fetch';
 
 import apiRouters from './apis/slave/index.js';
-import {
-  MediasoupRoomService,
-  MediasoupSlaveService,
-  mediasoupWorkerManager,
-} from './services/index.js';
+import { SlaveService, mediasoupWorkerManager } from './services/index.js';
 import { startServer, getDataSource } from './utils/index.js';
 
 async function bootstrap() {
   await startServer(apiRouters);
-  try {
-    // remove old room of dead slave
-    await new MediasoupRoomService(getDataSource()).removeAll();
-    await mediasoupWorkerManager.init();
-    await new MediasoupSlaveService(getDataSource()).addFromEnv();
-  } catch (e) {}
+
+  const slaveService = new SlaveService(getDataSource());
+  // remove old room of dead slave
+  await slaveService.removeCurrent();
+  await slaveService.addFromEnv();
+
+  await mediasoupWorkerManager.init();
 }
 
 bootstrap();

src/services/room.ts

@@ -1,4 +1,4 @@
-import { MediasoupRoom } from '../entities/index.js';
+import { MediaRoom } from '../entities/index.js';
 import { fetchApi } from '../utils/index.js';
 import { ServiceError, BaseService } from './base.js';
 import { SlaveService } from './slave.js';
@@ -14,33 +14,19 @@ export class RoomService extends BaseService {
         path: '/routers',
         method: 'POST',
       });
-      const mediasoupRoom = new MediasoupRoom();
+      const mediasoupRoom = new MediaRoom();
       mediasoupRoom.routerId = result.id;
       mediasoupRoom.slaveId = slave.id;
       Object.assign(mediasoupRoom, data);
-      await this.dataSource.getRepository(MediasoupRoom).save(mediasoupRoom);
+      await this.dataSource.getRepository(MediaRoom).save(mediasoupRoom);
       return mediasoupRoom.id;
     }
     throw new ServiceError(404, 'Slave not found');
   }
 
   async get(data: { id: string }) {
     return this.dataSource
-      .getRepository(MediasoupRoom)
+      .getRepository(MediaRoom)
       .findOne({ where: { id: data.id } });
   }
-
-  /**
-   * Remove all rooms of current slave
-   */
-  async removeAll() {
-    const slave = await this.createService(SlaveService).getCurrent();
-    if (slave) {
-      await this.dataSource
-        .createQueryBuilder(MediasoupRoom, 'MediasoupRoom')
-        .delete()
-        .where('slaveId = :slaveId', { slaveId: slave.id })
-        .execute();
-    }
-  }
 }

src/services/slave.ts

@@ -1,5 +1,5 @@
 import { constants } from '../constants.js';
-import { MediasoupSlave } from '../entities/index.js';
+import { MediaSlave } from '../entities/index.js';
 import { BaseService } from './base.js';
 
 export class SlaveService extends BaseService {
@@ -10,15 +10,15 @@ export class SlaveService extends BaseService {
     apiPort: number;
     maxPeer?: number;
   }) {
-    const mediasoupSlave = new MediasoupSlave();
+    const mediasoupSlave = new MediaSlave();
     if (![constants.CONSUMER, constants.PRODUCER].includes(data.for)) {
       throw new Error('Invalid for param');
     }
     Object.assign(mediasoupSlave, data);
     await this.dataSource
       .createQueryBuilder()
       .insert()
-      .into(MediasoupSlave)
+      .into(MediaSlave)
       .values([{ ...data, peerCount: 0 }])
       .orUpdate(
         ['externalHost', 'for', 'maxPeer', 'peerCount'],
@@ -28,15 +28,28 @@ export class SlaveService extends BaseService {
     return {};
   }
 
-  async getCurrent() {
-    return this.dataSource.getRepository(MediasoupSlave).findOne({
+  getCurrent() {
+    return this.dataSource.getRepository(MediaSlave).findOne({
       where: {
         internalHost: process.env.SLAVE_INTERNAL_HOST || 'localhost',
         apiPort: Number(process.env.PORT || 80),
       },
     });
   }
 
+  removeCurrent() {
+    return this.dataSource
+      .createQueryBuilder(MediaSlave, 'MediaSlave')
+      .delete()
+      .where('internalHost = :internalHost', {
+        internalHost: process.env.SLAVE_INTERNAL_HOST || 'localhost',
+      })
+      .andWhere('apiPort = :apiPort', {
+        apiPort: Number(process.env.PORT || 80),
+      })
+      .execute();
+  }
+
   addFromEnv() {
     return this.add({
       internalHost: process.env.SLAVE_INTERNAL_HOST || 'localhost',
@@ -47,15 +60,13 @@ export class SlaveService extends BaseService {
     });
   }
 
-  async getForNewRoom() {
-    const result = await this.dataSource
+  getForNewRoom() {
+    return this.dataSource
       .createQueryBuilder()
       .select('slave')
-      .from(MediasoupSlave, 'slave')
+      .from(MediaSlave, 'slave')
       .where('slave.for = :for', { for: constants.PRODUCER })
       .andWhere('slave.peerCount < slave.maxPeer')
       .getOne();
-
-    return result;
   }
 }