@takaro/modules 0.0.10 → 0.0.13

package/src/__tests__/aliases.integration.test.ts

@@ -40,6 +40,46 @@ const tests = [
         playerId: this.setupData.players[0].id,
       });
 
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.meta.msg).to.be.eq('Teleported to test.');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Aliases are case insensitive',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.teleportsModule.id,
+        {
+          systemConfig: JSON.stringify({
+            commands: {
+              teleport: {
+                delay: 0,
+                aliases: ['tp', 'tellyport'],
+              },
+            },
+          }),
+        },
+      );
+
+      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/settp test',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await setEvents).length).to.be.eq(1);
+      expect((await setEvents)[0].data.meta.msg).to.be.eq('Teleport test set.');
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/TelLyPoRt test',
+        playerId: this.setupData.players[0].id,
+      });
+
       expect((await events).length).to.be.eq(1);
       expect((await events)[0].data.meta.msg).to.be.eq('Teleported to test.');
     },

package/src/__tests__/bugRepros.integration.test.ts

@@ -1,5 +1,5 @@
 import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
-import { GameEvents } from '../dto/index.js';
+import { GameEvents, HookEvents } from '../dto/index.js';
 import { EventChatMessageChannelEnum } from '@takaro/apiclient';
 
 const group = 'Bug repros';
@@ -63,6 +63,168 @@ const tests = [
       expect((await events).map((e) => e.data.meta.msg)).to.include.members(['First hook', 'Second hook']);
     },
   }),
+  // Before, the event "hook-executed" would not have the correct result logs saved
+  // The TakaroDTO validation was rejecting it because "not a string"
+  // `An instance of TakaroEventHookExecuted has failed the validation:\n - property result.logs[1].msg has failed the following constraints: isString \n - property result.logs[2].msg has failed the following constraints: isString \n"`
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    name: 'Bug repro: console.log in a function works with objects',
+    setup: modulesTestSetup,
+    test: async function () {
+      const mod = (
+        await this.client.module.moduleControllerCreate({
+          name: 'Test module',
+        })
+      ).data.data;
+      await this.client.hook.hookControllerCreate({
+        name: 'Test hook 1',
+        moduleId: mod.id,
+        regex: 'test msg',
+        eventType: 'chat-message',
+        function: `import { data, takaro } from '@takaro/helpers';
+        async function main() {
+          console.log("foo");
+          console.log({ foo: "bar" });
+          console.log(["baz", 1]);
+        }
+        await main();`,
+      });
+
+      await this.client.gameserver.gameServerControllerInstallModule(this.setupData.gameserver.id, mod.id);
+
+      const listener = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.HOOK_EXECUTED, 1);
+
+      await this.client.hook.hookControllerTrigger({
+        eventType: 'chat-message',
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: mod.id,
+        playerId: this.setupData.players[0].id,
+        eventMeta: {
+          msg: 'test msg',
+          channel: EventChatMessageChannelEnum.Global,
+        },
+      });
+
+      const result = (await listener)[0].data.meta.result;
+      expect(result.success).to.be.true;
+      const logs = result.logs;
+      const msgs = logs.map((l: any) => l.msg);
+      expect(msgs).to.include.members(['foo', JSON.stringify({ foo: 'bar' }), JSON.stringify(['baz', 1])]);
+    },
+  }),
+  /**
+   * Repro for https://github.com/gettakaro/takaro/issues/1047
+   * System config uses the names of functions to create structure
+   * If a module is installed, and you then rename the function, the system config will be broken
+   */
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    name: 'Bug repro: renaming functions breaks system config #1047',
+    setup: modulesTestSetup,
+    test: async function () {
+      const mod = (
+        await this.client.module.moduleControllerCreate({
+          name: 'Test module',
+        })
+      ).data.data;
+      const createdCommand = await this.client.command.commandControllerCreate({
+        name: 'testcmd',
+        moduleId: mod.id,
+        trigger: 'testpong',
+        function: `import { data, takaro } from '@takaro/helpers';
+        async function main() {
+            const { player } = data;
+            await takaro.gameserver.gameServerControllerSendMessage(data.gameServerId, {
+                message: 'pong',
+            });
+        }
+        await main();`,
+      });
+
+      await this.client.gameserver.gameServerControllerInstallModule(this.setupData.gameserver.id, mod.id, {
+        userConfig: JSON.stringify({}),
+        systemConfig: JSON.stringify({ commands: { testcmd: { aliases: ['foobar'] } } }),
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/foobar',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.meta.msg).to.be.eq('pong');
+
+      // Rename the function
+      await this.client.command.commandControllerUpdate(createdCommand.data.data.id, { name: 'testcmd2' });
+
+      const eventsAfter = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/foobar',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await eventsAfter).length).to.be.eq(1);
+      expect((await eventsAfter)[0].data.meta.msg).to.be.eq('pong');
+    },
+  }),
+  /**
+   * Repro for https://github.com/gettakaro/takaro/issues/1405
+   * When providing invalid code, Takaro trips over itself and throws a nasty error
+   * Instead, it should catch it properly and return an actionable message for the user
+   */
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    name: 'Bug repro: invalid module code throws bad error #1405',
+    setup: modulesTestSetup,
+    test: async function () {
+      const mod = (
+        await this.client.module.moduleControllerCreate({
+          name: 'Test module',
+        })
+      ).data.data;
+      await this.client.command.commandControllerCreate({
+        name: 'testcmd',
+        moduleId: mod.id,
+        trigger: 'test',
+        // Yes, very bad code! This is what a user might accidentally do
+        function: `import { data, takaro } from '@takaro/helpers';
+
+          const messed = (await takaro.variable.variableControllerSearch({ search: { key: [\`object Object\`] } })).data.data
+          for (const thisVar of messed) {
+            let originalString = thisVar.key;
+            let newString = originalString.replace("[object Object]", "2024-09-20");
+
+            await takaro.variable.variableControllerUpdate(thisVar.id, { key: newString, value: thisVar.value });
+
+          }
+          data.player.pm(\`done\`).
+          `,
+      });
+
+      await this.client.gameserver.gameServerControllerInstallModule(this.setupData.gameserver.id, mod.id, {
+        userConfig: JSON.stringify({}),
+        systemConfig: JSON.stringify({}),
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.COMMAND_EXECUTED, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/test',
+        playerId: this.setupData.players[0].id,
+      });
+
+      console.log(JSON.stringify((await events)[0].data.meta.result, null, 2));
+      const result = (await events)[0].data.meta.result;
+      expect(result.success).to.be.false;
+      expect(result.reason).to.include('SyntaxError: Unexpected end of input.');
+    },
+  }),
 ];
 
 describe(group, function () {

package/src/__tests__/{economyUtils.shop.integration.test.ts → economy/claim.integration.test.ts}

@@ -1,123 +1,13 @@
-import { faker } from '@faker-js/faker';
-import { Client, ShopListingOutputDTO, UserOutputDTO } from '@takaro/apiclient';
+import { EventsAwaiter, expect, IntegrationTest, IShopSetup, shopSetup } from '@takaro/test';
+import { HookEvents } from '../../dto/index.js';
 
-import {
-  EventsAwaiter,
-  integrationConfig,
-  expect,
-  modulesTestSetup,
-  IModuleTestsSetupData,
-  IntegrationTest,
-} from '@takaro/test';
-import { HookEvents } from '../dto/index.js';
-
-const group = 'EconomyUtils:Shop';
-
-interface IShopSetup extends IModuleTestsSetupData {
-  userClient: Client;
-  listing100: ShopListingOutputDTO;
-  listing33: ShopListingOutputDTO;
-}
-
-async function createUserForPlayer(client: Client, playerId: string, gameServerId: string) {
-  const password = 'shop-tester-password-very-safe';
-
-  let user: UserOutputDTO | null = null;
-
-  user = (
-    await client.user.userControllerCreate({
-      name: 'test',
-      email: `test-${faker.internet.email()}`,
-      password,
-    })
-  ).data.data;
-
-  const userClient = new Client({ auth: { username: user.email, password }, url: integrationConfig.get('host') });
-  await userClient.login();
-
-  const eventsAwaiter = new EventsAwaiter();
-  await eventsAwaiter.connect(client);
-  const chatEventWaiter = eventsAwaiter.waitForEvents(HookEvents.CHAT_MESSAGE);
-  await client.command.commandControllerTrigger(gameServerId, {
-    msg: '/link',
-    playerId,
-  });
-  const chatEvents = await chatEventWaiter;
-  expect(chatEvents).to.have.length(1);
-  const code = chatEvents[0].data.meta.msg.match(/code=(\w+-\w+-\w+)/)[1];
-  await userClient.user.userControllerLinkPlayerProfile({ email: user.email, code });
-
-  return {
-    user,
-    client: userClient,
-  };
-}
-
-async function setupShop(client: Client, gameServerId: string) {
-  const items = (await client.item.itemControllerSearch()).data.data;
-
-  const listing100Res = await client.shopListing.shopListingControllerCreate({
-    gameServerId: gameServerId,
-    items: [{ itemId: items[0].id, amount: 1 }],
-    price: 100,
-    name: 'Test item',
-  });
-
-  const listing33Res = await client.shopListing.shopListingControllerCreate({
-    gameServerId: gameServerId,
-    items: [{ itemId: items[1].id, amount: 1 }],
-    price: 33,
-    name: 'Test item 2',
-  });
-
-  return {
-    listing100: listing100Res.data.data,
-    listing33: listing33Res.data.data,
-  };
-}
-
-const customSetup = async function (this: IntegrationTest<IShopSetup>): Promise<IShopSetup> {
-  const setupData = await modulesTestSetup.bind(this as unknown as IntegrationTest<IModuleTestsSetupData>)();
-
-  await this.client.settings.settingsControllerSet('economyEnabled', {
-    value: 'true',
-    gameServerId: setupData.gameserver.id,
-  });
-
-  await this.client.settings.settingsControllerSet('economyEnabled', {
-    value: 'true',
-  });
-  await this.client.settings.settingsControllerSet('currencyName', {
-    gameServerId: setupData.gameserver.id,
-    value: 'test coin',
-  });
-
-  await this.client.gameserver.gameServerControllerInstallModule(
-    setupData.gameserver.id,
-    setupData.economyUtilsModule.id,
-  );
-
-  const { client: userClient } = await createUserForPlayer(
-    this.client,
-    setupData.players[0].id,
-    setupData.gameserver.id,
-  );
-  const { listing100, listing33 } = await setupShop(this.client, setupData.gameserver.id);
-
-  await this.client.playerOnGameserver.playerOnGameServerControllerAddCurrency(
-    setupData.gameserver.id,
-    setupData.players[0].id,
-    { currency: 250 },
-  );
-
-  return { ...setupData, userClient, listing100, listing33 };
-};
+const group = 'EconomyUtils:Shop:Claim';
 
 const tests = [
   new IntegrationTest<IShopSetup>({
     group,
     snapshot: false,
-    setup: customSetup,
+    setup: shopSetup,
     name: 'Can claim an order happy path',
     test: async function () {
       await this.setupData.userClient.shopOrder.shopOrderControllerCreate({
@@ -137,7 +27,7 @@ const tests = [
   new IntegrationTest<IShopSetup>({
     group,
     snapshot: false,
-    setup: customSetup,
+    setup: shopSetup,
     name: 'Shows a friendly error when there are no pending orders',
     test: async function () {
       const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 1);
@@ -153,7 +43,7 @@ const tests = [
   new IntegrationTest<IShopSetup>({
     group,
     snapshot: false,
-    setup: customSetup,
+    setup: shopSetup,
     name: 'Handles double-claiming an order',
     test: async function () {
       await this.setupData.userClient.shopOrder.shopOrderControllerCreate({
@@ -182,7 +72,7 @@ const tests = [
   new IntegrationTest<IShopSetup>({
     group,
     snapshot: false,
-    setup: customSetup,
+    setup: shopSetup,
     name: 'Only claims the first order by default',
     test: async function () {
       await this.setupData.userClient.shopOrder.shopOrderControllerCreate({
@@ -217,7 +107,7 @@ const tests = [
   new IntegrationTest<IShopSetup>({
     group,
     snapshot: false,
-    setup: customSetup,
+    setup: shopSetup,
     name: 'Can claim all orders in one go',
     test: async function () {
       await this.setupData.userClient.shopOrder.shopOrderControllerCreate({
@@ -237,9 +127,9 @@ const tests = [
 
       expect(await events).to.have.length(4);
       expect((await events)[0].data.meta.msg).to.equal('You have received items from a shop order.');
-      expect((await events)[1].data.meta.msg).to.equal('1x Wood');
+      expect((await events)[1].data.meta.msg).to.equal('1x Stone');
       expect((await events)[2].data.meta.msg).to.equal('You have received items from a shop order.');
-      expect((await events)[3].data.meta.msg).to.equal('1x Stone');
+      expect((await events)[3].data.meta.msg).to.equal('1x Wood');
     },
   }),
 ];

package/src/__tests__/{economyUtils.integration.test.ts → economy/economyUtils.integration.test.ts}

@@ -6,9 +6,9 @@ import {
   chatMessageSorter,
   EventsAwaiter,
 } from '@takaro/test';
-import { GameEvents } from '../dto/index.js';
+import { GameEvents } from '../../dto/index.js';
 
-const group = 'Economy utils suite';
+const group = 'EconomyUtils';
 
 const customSetup = async function (this: IntegrationTest<IModuleTestsSetupData>): Promise<IModuleTestsSetupData> {
   const setupData = await modulesTestSetup.bind(this)();

package/src/__tests__/economy/shop.integration.test.ts

@@ -0,0 +1,153 @@
+import { EventsAwaiter, expect, IntegrationTest, IShopSetup, shopSetup } from '@takaro/test';
+import { HookEvents } from '../../dto/index.js';
+
+const group = 'EconomyUtils:Shop:Browse';
+
+const tests = [
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Calling /shop without arguments displays help information',
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 5);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/shop',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect(await events).to.have.length(5);
+      expect((await events)[0].data.meta.msg).to.eq(
+        'This command allows you to browse the shop and view available items.',
+      );
+      expect((await events)[1].data.meta.msg).to.eq('Usage: /shop [page] [item] [action]');
+      expect((await events)[2].data.meta.msg).to.eq('/shop 2 - View the second page of shop items');
+      expect((await events)[3].data.meta.msg).to.eq('/shop 1 3 - View details about the third item on the first page');
+      expect((await events)[4].data.meta.msg).to.eq('/shop 1 3 buy - Purchase the third item on the first page');
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'First page shows the first 5 items',
+    test: async function () {
+      await this.setupData.createListings(this.client, { gameServerId: this.setupData.gameserver.id, amount: 5 });
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 5);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/shop 1',
+        playerId: this.setupData.players[0].id,
+      });
+
+      console.log(JSON.stringify((await events)[0].data.meta.msg, null, 2));
+      expect(await events).to.have.length(5);
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Can view the second page of shop items',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.utilsModule.id,
+      );
+      await this.setupData.createListings(this.client, { gameServerId: this.setupData.gameserver.id, amount: 5 });
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 3);
+      const commandExecutedEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(
+        HookEvents.COMMAND_EXECUTED,
+        1,
+      );
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/shop 2',
+        playerId: this.setupData.players[0].id,
+      });
+
+      await commandExecutedEvent;
+
+      // We trigger the ping command to make sure we can see the FULL output of the previous command
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/ping',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect(await events).to.have.length(3);
+      expect((await events)[(await events).length - 1].data.meta.msg).to.eq('Pong!');
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'When no items are available, shows a message',
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 1);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/shop 5',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect(await events).to.have.length(1);
+      expect((await events)[0].data.meta.msg).to.equal('No items found.');
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Can show details about an item',
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 2);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/shop 1 1',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect(await events).to.have.length(2);
+      expect((await events)[0].data.meta.msg).to.equal('Listing Test item - 100 test coin');
+      expect((await events)[1].data.meta.msg).to.equal('- 1x Stone.  Description: Stone can get you stoned');
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Shows an error when requesting details for an invalid item',
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 1);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/shop 1 5',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect(await events).to.have.length(1);
+      expect((await events)[0].data.meta.msg).to.equal(
+        'Item not found. Please select an item from the list, valid options are 1-2.',
+      );
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Can buy an item',
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 2);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/shop 1 1 buy',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect(await events).to.have.length(2);
+      expect((await events)[0].data.meta.msg).to.equal('You have purchased Test item for 100 test coin.');
+      expect((await events)[1].data.meta.msg).to.equal('You have received items from a shop order.');
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

package/src/__tests__/serverMessages.integration.test.ts

@@ -1,6 +1,5 @@
 import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
 import { GameEvents } from '../dto/index.js';
-import { sleep } from '@takaro/util';
 
 const group = 'Server messages';
 
@@ -77,24 +76,39 @@ const tests = [
 
       // We should see each of our test messages at least once
 
-      const numberOfEvents = 10;
-      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(
-        GameEvents.CHAT_MESSAGE,
-        numberOfEvents,
-      );
+      const firstEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.serverMessagesModule.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.serverMessagesModule.id,
+      });
+
+      expect((await firstEvents).length).to.be.eq(1);
+      expect((await firstEvents)[0].data.meta.msg).to.be.eq('Test message 1');
+
+      const secondEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.serverMessagesModule.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.serverMessagesModule.id,
+      });
+
+      expect((await secondEvents).length).to.be.eq(1);
+      expect((await secondEvents)[0].data.meta.msg).to.be.eq('Test message 2');
+
+      // After this, it should loop back to the first message
+      const thirdEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.serverMessagesModule.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.serverMessagesModule.id,
+      });
 
-      for (let i = 0; i < numberOfEvents; i++) {
-        await sleep(Math.floor(Math.random() * 10) + 1);
-        await this.client.cronjob.cronJobControllerTrigger({
-          cronjobId: this.setupData.serverMessagesModule.cronJobs[0].id,
-          gameServerId: this.setupData.gameserver.id,
-          moduleId: this.setupData.serverMessagesModule.id,
-        });
-      }
-
-      const messages = (await events).map((e) => e.data.meta.msg);
-      expect(messages).to.include('Test message 1');
-      expect(messages).to.include('Test message 2');
+      expect((await thirdEvents).length).to.be.eq(1);
+      expect((await thirdEvents)[0].data.meta.msg).to.be.eq('Test message 1');
     },
   }),
 ];

package/src/dto/takaroEvents.ts

@@ -1,6 +1,5 @@
 import {
   IsBoolean,
-  IsDefined,
   IsEnum,
   IsIP,
   IsISO31661Alpha2,
@@ -141,9 +140,6 @@ export class TakaroEventCommandExecuted extends BaseEvent<TakaroEventCommandExec
   @IsString()
   type = TakaroEvents.COMMAND_EXECUTED;
 
-  @IsDefined()
-  data: Record<string, unknown>;
-
   @ValidateNested()
   @Type(() => TakaroEventFunctionResult)
   result: TakaroEventFunctionResult;
@@ -158,9 +154,6 @@ export class TakaroEventHookExecuted extends BaseEvent<TakaroEventHookExecuted>
   @IsString()
   type = TakaroEvents.HOOK_EXECUTED;
 
-  @IsDefined()
-  data: Record<string, unknown>;
-
   @ValidateNested()
   @Type(() => TakaroEventFunctionResult)
   result: TakaroEventFunctionResult;
@@ -175,9 +168,6 @@ export class TakaroEventCronjobExecuted extends BaseEvent<TakaroEventCronjobExec
   @IsString()
   type = TakaroEvents.CRONJOB_EXECUTED;
 
-  @IsDefined()
-  data: Record<string, unknown>;
-
   @ValidateNested()
   @Type(() => TakaroEventFunctionResult)
   result: TakaroEventFunctionResult;

package/src/main.ts

@@ -8,6 +8,7 @@ import { Lottery } from './modules/lottery/index.js';
 import { PlayerOnboarding } from './modules/playerOnboarding/index.js';
 import { ServerMessages } from './modules/serverMessages/index.js';
 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';
@@ -28,6 +29,7 @@ export function getModules(): Array<BuiltinModule<unknown>> {
       new EconomyUtils(),
       new Lottery(),
       new GeoBlock(),
+      new TimedShutdown(),
     ];
   }