@takaro/modules 0.0.14 → 0.0.18

package/src/__tests__/teleports/publicteleports.integration.test.ts

@@ -1,5 +1,6 @@
 import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
 import { GameEvents } from '../../dto/index.js';
+import { describe } from 'node:test';
 
 const group = 'Teleports suite';
 
@@ -10,15 +11,13 @@ const tests = [
     setup: modulesTestSetup,
     name: 'Can set teleports as public, allowing other players to use it',
     test: async function () {
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id,
-        {
-          userConfig: JSON.stringify({
-            allowPublicTeleports: true,
-          }),
-        },
-      );
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          allowPublicTeleports: true,
+        }),
+      });
 
       const setTpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
@@ -56,15 +55,13 @@ const tests = [
     setup: modulesTestSetup,
     name: 'Can set public teleports as private again',
     test: async function () {
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id,
-        {
-          userConfig: JSON.stringify({
-            allowPublicTeleports: true,
-          }),
-        },
-      );
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          allowPublicTeleports: true,
+        }),
+      });
 
       const setTpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
@@ -115,16 +112,14 @@ const tests = [
     setup: modulesTestSetup,
     name: 'When configured to not allow public teleports, creating public teleports is not allowed',
     test: async function () {
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id,
-        {
-          userConfig: JSON.stringify({
-            allowPublicTeleports: false,
-            timeout: 0,
-          }),
-        },
-      );
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          allowPublicTeleports: false,
+          timeout: 0,
+        }),
+      });
 
       const setTpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
@@ -153,16 +148,14 @@ const tests = [
     setup: modulesTestSetup,
     name: 'When configured to not allow public teleports, players cannot teleport to public teleports',
     test: async function () {
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id,
-        {
-          userConfig: JSON.stringify({
-            allowPublicTeleports: true,
-            timeout: 0,
-          }),
-        },
-      );
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          allowPublicTeleports: true,
+          timeout: 0,
+        }),
+      });
 
       const setTpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
@@ -194,16 +187,14 @@ const tests = [
       expect((await tpEvent).length).to.be.eq(1);
       expect((await tpEvent)[0].data.meta.msg).to.be.eq('Teleported to test.');
 
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id,
-        {
-          userConfig: JSON.stringify({
-            allowPublicTeleports: false,
-            timeout: 0,
-          }),
-        },
-      );
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          allowPublicTeleports: false,
+          timeout: 0,
+        }),
+      });
 
       const tpEvent2 = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
@@ -222,6 +213,15 @@ const tests = [
     setup: modulesTestSetup,
     name: 'If player does not have role to create public teleports, command gets denied',
     test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          allowPublicTeleports: true,
+          timeout: 0,
+        }),
+      });
+
       const useTeleportsRole = await this.client.permissionCodesToInputs(['TELEPORTS_USE']);
       await this.client.role.roleControllerUpdate(this.setupData.role.id, {
         permissions: [
@@ -232,17 +232,6 @@ const tests = [
         ],
       });
 
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id,
-        {
-          userConfig: JSON.stringify({
-            allowPublicTeleports: true,
-            timeout: 0,
-          }),
-        },
-      );
-
       const setTpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
@@ -270,8 +259,18 @@ const tests = [
     group,
     snapshot: false,
     setup: modulesTestSetup,
+    attempts: 5,
     name: 'Prohibits players from settings more public teleports than their role allows',
     test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          allowPublicTeleports: true,
+          timeout: 0,
+        }),
+      });
+
       const permissionRes = await this.client.permissionCodesToInputs(['TELEPORTS_CREATE_PUBLIC', 'TELEPORTS_USE']);
       await this.client.role.roleControllerUpdate(this.setupData.role.id, {
         permissions: [
@@ -286,17 +285,6 @@ const tests = [
         ],
       });
 
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id,
-        {
-          userConfig: JSON.stringify({
-            allowPublicTeleports: true,
-            timeout: 0,
-          }),
-        },
-      );
-
       const setTpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 4);
 
       await Promise.all(

package/src/__tests__/teleports/teleport.integration.test.ts

@@ -1,5 +1,6 @@
 import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
 import { GameEvents } from '../../dto/index.js';
+import { describe } from 'node:test';
 
 const group = 'Teleports suite';
 
@@ -10,10 +11,10 @@ const tests = [
     setup: modulesTestSetup,
     name: 'Can teleport with /tp',
     test: async function () {
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id,
-      );
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+      });
 
       const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
@@ -40,10 +41,10 @@ const tests = [
     setup: modulesTestSetup,
     name: 'Shows an error when teleporting to a non-existing teleport',
     test: async function () {
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id,
-      );
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+      });
       const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
@@ -61,15 +62,13 @@ const tests = [
     setup: modulesTestSetup,
     name: 'Times out when teleporting faster than set timeout',
     test: async function () {
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id,
-        {
-          userConfig: JSON.stringify({
-            timeout: 5000,
-          }),
-        },
-      );
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          timeout: 5000,
+        }),
+      });
 
       const setTpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 

package/src/__tests__/teleports/tpManagement.integration.test.ts

@@ -1,5 +1,6 @@
 import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
 import { GameEvents } from '../../dto/index.js';
+import { describe } from 'node:test';
 
 const group = 'Teleports suite';
 
@@ -10,10 +11,10 @@ const tests = [
     setup: modulesTestSetup,
     name: 'Can set a teleport with /settp',
     test: async function () {
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id,
-      );
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+      });
       const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
@@ -31,10 +32,10 @@ const tests = [
     setup: modulesTestSetup,
     name: 'Shows an error when setting a teleport with an existing name',
     test: async function () {
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id,
-      );
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+      });
 
       const firstEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
@@ -65,10 +66,10 @@ const tests = [
     setup: modulesTestSetup,
     name: 'Cannot set more than the user-defined amount of max teleports',
     test: async function () {
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id,
-      );
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+      });
 
       const useTeleportsRole = await this.client.permissionCodesToInputs(['TELEPORTS_USE']);
       await this.client.role.roleControllerUpdate(this.setupData.role.id, {
@@ -115,10 +116,10 @@ const tests = [
     setup: modulesTestSetup,
     name: 'Can remove teleports with /deletetp',
     test: async function () {
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id,
-      );
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+      });
       const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 3);
 
       await Promise.all(
@@ -151,10 +152,10 @@ const tests = [
     setup: modulesTestSetup,
     name: 'Shows an error when removing a non-existing teleport',
     test: async function () {
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id,
-      );
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+      });
       const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/deletetp test',

package/src/__tests__/teleports/waypoints.integration.test.ts

@@ -8,6 +8,7 @@ import {
 } from '@takaro/test';
 import { GameEvents, HookEvents } from '../../dto/index.js';
 import { GameServerTypesOutputDTOTypeEnum, PlayerOutputDTO, RoleOutputDTO } from '@takaro/apiclient';
+import { describe } from 'node:test';
 
 const group = 'Teleports - waypoints';
 
@@ -21,7 +22,10 @@ interface WaypointsSetup extends IModuleTestsSetupData {
 const waypointsSetup = async function (this: IntegrationTest<WaypointsSetup>): Promise<WaypointsSetup> {
   const setupData = await modulesTestSetup.bind(this as unknown as IntegrationTest<IModuleTestsSetupData>)();
 
-  await this.client.gameserver.gameServerControllerInstallModule(setupData.gameserver.id, setupData.teleportsModule.id);
+  await this.client.module.moduleInstallationsControllerInstallModule({
+    gameServerId: setupData.gameserver.id,
+    versionId: setupData.teleportsModule.latestVersion.id,
+  });
 
   const playersRes = await this.client.player.playerControllerSearch();
 
@@ -55,7 +59,7 @@ const waypointsSetup = async function (this: IntegrationTest<WaypointsSetup>): P
   };
 };
 
-async function setupSecondServer() {
+async function setupSecondServer(this: IntegrationTest<WaypointsSetup>) {
   const newGameServer = await this.client.gameserver.gameServerControllerCreate({
     name: 'newServer',
     connectionInfo: JSON.stringify({
@@ -65,10 +69,10 @@ async function setupSecondServer() {
     type: GameServerTypesOutputDTOTypeEnum.Mock,
   });
 
-  await this.client.gameserver.gameServerControllerInstallModule(
-    newGameServer.data.data.id,
-    this.setupData.teleportsModule.id,
-  );
+  await this.client.module.moduleInstallationsControllerInstallModule({
+    gameServerId: newGameServer.data.data.id,
+    versionId: this.setupData.teleportsModule.latestVersion.id,
+  });
 
   const connectedEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(
     GameEvents.PLAYER_CONNECTED,
@@ -635,6 +639,48 @@ const tests = [
       expect((await teleportEvents2)[0].data.meta.msg).to.be.eq('You are not allowed to use the waypoint A.');
     },
   }),
+  new IntegrationTest<WaypointsSetup>({
+    group,
+    snapshot: false,
+    setup: waypointsSetup,
+    name: 'Reconciler recreates waypoints when deleting the waypoints module',
+    test: async function () {
+      // Create a waypoint
+      // Delete the waypoints module
+      // Create another waypoint
+      // Both should be present in the waypoints module
+
+      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/setwaypoint A',
+        playerId: this.setupData.moderator.id,
+      });
+      expect((await setEvents)[0].data.meta.msg).to.be.eq('Waypoint A set.');
+
+      const waypointsModuleToRemove = await this.client.module.moduleControllerSearch({
+        filters: { name: ['Waypoints'] },
+      });
+      if (!waypointsModuleToRemove.data.data.length) {
+        throw new Error('Waypoints module not found');
+      }
+
+      await this.client.module.moduleControllerRemove(waypointsModuleToRemove.data.data[0].id);
+
+      const setEvents2 = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/setwaypoint B',
+        playerId: this.setupData.moderator.id,
+      });
+      expect((await setEvents2)[0].data.meta.msg).to.be.eq('Waypoint B set.');
+
+      const waypointsModule = await this.client.module.moduleControllerSearch({ filters: { name: ['Waypoints'] } });
+      if (!waypointsModule.data.data.length) {
+        throw new Error('Waypoints module not found');
+      }
+
+      expect(waypointsModule.data.data[0].latestVersion.commands).to.be.lengthOf(2);
+    },
+  }),
 ];
 
 describe(group, function () {

package/src/dto/takaroEvents.ts

@@ -42,6 +42,9 @@ export const TakaroEvents = {
   SHOP_ORDER_CREATED: 'shop-order-created',
   SHOP_ORDER_STATUS_CHANGED: 'shop-order-status-changed',
   PLAYER_LINKED: 'player-linked',
+  GAMESERVER_CREATED: 'gameserver-created',
+  GAMESERVER_UPDATED: 'gameserver-updated',
+  GAMESERVER_DELETED: 'gameserver-deleted',
 } as const;
 
 export class BaseTakaroEvent<T> extends BaseEvent<T> {
@@ -330,6 +333,21 @@ export class TakaroEventPlayerLinked extends BaseEvent<TakaroEventPlayerLinked>
   type = TakaroEvents.PLAYER_LINKED;
 }
 
+export class TakaroEventGameserverCreated extends BaseEvent<TakaroEventGameserverCreated> {
+  @IsString()
+  type = TakaroEvents.GAMESERVER_CREATED;
+}
+
+export class TakaroEventGameserverUpdated extends BaseEvent<TakaroEventGameserverUpdated> {
+  @IsString()
+  type = TakaroEvents.GAMESERVER_UPDATED;
+}
+
+export class TakaroEventGameserverDeleted extends BaseEvent<TakaroEventGameserverDeleted> {
+  @IsString()
+  type = TakaroEvents.GAMESERVER_DELETED;
+}
+
 export const TakaroEventsMapping = {
   [TakaroEvents.ROLE_ASSIGNED]: TakaroEventRoleAssigned,
   [TakaroEvents.PLAYER_NEW_IP_DETECTED]: TakaroEventPlayerNewIpDetected,
@@ -356,4 +374,7 @@ export const TakaroEventsMapping = {
   [TakaroEvents.SHOP_ORDER_CREATED]: TakaroEventShopOrderCreated,
   [TakaroEvents.SHOP_ORDER_STATUS_CHANGED]: TakaroEventShopOrderStatusChanged,
   [TakaroEvents.PLAYER_LINKED]: TakaroEventPlayerLinked,
+  [TakaroEvents.GAMESERVER_CREATED]: TakaroEventGameserverCreated,
+  [TakaroEvents.GAMESERVER_UPDATED]: TakaroEventGameserverUpdated,
+  [TakaroEvents.GAMESERVER_DELETED]: TakaroEventGameserverDeleted,
 } as const;

package/src/main.ts

@@ -1,5 +1,6 @@
-import { BuiltinModule } from './BuiltinModule.js';
+import { ModuleTransferDTO } from './BuiltinModule.js';
 import { ChatBridge } from './modules/chatBridge/index.js';
+import { DailyRewards } from './modules/dailyRewards/index.js';
 import { EconomyUtils } from './modules/economyUtils/index.js';
 import { GeoBlock } from './modules/geoBlock/index.js';
 import { Gimme } from './modules/gimme/index.js';
@@ -11,12 +12,20 @@ import { Teleports } from './modules/teleports/index.js';
 import { TimedShutdown } from './modules/timedShutdown/index.js';
 import { Utils } from './modules/utils/index.js';
 
-export { BuiltinModule, ICommand, ICommandArgument, ICronJob, IHook, IFunction } from './BuiltinModule.js';
+export {
+  ModuleTransferDTO,
+  ModuleTransferVersionDTO,
+  ICommand,
+  ICommandArgument,
+  ICronJob,
+  IHook,
+  IFunction,
+} from './BuiltinModule.js';
 export * from './dto/index.js';
 
-let cached: Array<BuiltinModule<unknown>> | null = null;
+let cached: Array<ModuleTransferDTO<unknown>> | null = null;
 
-export function getModules(): Array<BuiltinModule<unknown>> {
+export function getModules(): Array<ModuleTransferDTO<unknown>> {
   if (!cached) {
     cached = [
       new Utils(),
@@ -30,6 +39,7 @@ export function getModules(): Array<BuiltinModule<unknown>> {
       new Lottery(),
       new GeoBlock(),
       new TimedShutdown(),
+      new DailyRewards(),
     ];
   }
 

package/src/modules/chatBridge/index.ts

@@ -1,58 +1,61 @@
-import { BuiltinModule, IHook } from '../../BuiltinModule.js';
+import { ModuleTransferDTO, IHook, ModuleTransferVersionDTO } from '../../BuiltinModule.js';
 import { HookEvents } from '../../dto/index.js';
 
-export class ChatBridge extends BuiltinModule<ChatBridge> {
+export class ChatBridge extends ModuleTransferDTO<ChatBridge> {
   constructor() {
-    super(
-      'chatBridge',
-      'Connect chat to other services like Discord.',
-      JSON.stringify({
-        $schema: 'http://json-schema.org/draft-07/schema#',
-        type: 'object',
-        properties: {
-          sendPlayerConnected: {
-            title: 'Send player connected',
-            type: 'boolean',
-            description: 'Send a message when a player connects.',
-            default: true,
+    super();
+    this.name = 'chatBridge';
+    this.versions = [
+      new ModuleTransferVersionDTO({
+        tag: '0.0.1',
+        description: 'Connect chat to other services like Discord.',
+        configSchema: JSON.stringify({
+          $schema: 'http://json-schema.org/draft-07/schema#',
+          type: 'object',
+          properties: {
+            sendPlayerConnected: {
+              title: 'Send player connected',
+              type: 'boolean',
+              description: 'Send a message when a player connects.',
+              default: true,
+            },
+            sendPlayerDisconnected: {
+              title: 'Send player disconnected',
+              type: 'boolean',
+              description: 'Send a message when a player disconnects.',
+              default: true,
+            },
+            onlyGlobalChat: {
+              title: 'Only global chat',
+              type: 'boolean',
+              default: true,
+              description: 'Only relay messages from global chat. (no team chat or private messages)',
+            },
           },
-          sendPlayerDisconnected: {
-            title: 'Send player disconnected',
-            type: 'boolean',
-            description: 'Send a message when a player disconnects.',
-            default: true,
-          },
-          onlyGlobalChat: {
-            title: 'Only global chat',
-            type: 'boolean',
-            default: true,
-            description: 'Only relay messages from global chat. (no team chat or private messages)',
-          },
-        },
-        additionalProperties: false,
-      }),
-    );
-
-    this.hooks = [
-      new IHook({
-        eventType: HookEvents.DISCORD_MESSAGE,
-        name: 'DiscordToGame',
-        function: this.loadFn('hooks', 'DiscordToGame'),
-      }),
-      new IHook({
-        eventType: HookEvents.CHAT_MESSAGE,
-        name: 'GameToDiscord',
-        function: this.loadFn('hooks', 'GameToDiscord'),
-      }),
-      new IHook({
-        eventType: HookEvents.PLAYER_CONNECTED,
-        name: 'PlayerConnected',
-        function: this.loadFn('hooks', 'PlayerConnected'),
-      }),
-      new IHook({
-        eventType: HookEvents.PLAYER_DISCONNECTED,
-        name: 'PlayerDisconnected',
-        function: this.loadFn('hooks', 'PlayerDisconnected'),
+          additionalProperties: false,
+        }),
+        hooks: [
+          new IHook({
+            eventType: HookEvents.DISCORD_MESSAGE,
+            name: 'DiscordToGame',
+            function: this.loadFn('hooks', 'DiscordToGame'),
+          }),
+          new IHook({
+            eventType: HookEvents.CHAT_MESSAGE,
+            name: 'GameToDiscord',
+            function: this.loadFn('hooks', 'GameToDiscord'),
+          }),
+          new IHook({
+            eventType: HookEvents.PLAYER_CONNECTED,
+            name: 'PlayerConnected',
+            function: this.loadFn('hooks', 'PlayerConnected'),
+          }),
+          new IHook({
+            eventType: HookEvents.PLAYER_DISCONNECTED,
+            name: 'PlayerDisconnected',
+            function: this.loadFn('hooks', 'PlayerDisconnected'),
+          }),
+        ],
       }),
     ];
   }