@takaro/modules 0.0.1 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takaro/modules",
-  "version": "0.0.1",
+  "version": "0.0.5",
   "description": "Built-in modules for Takaro",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
@@ -17,10 +17,6 @@
   "keywords": [],
   "author": "",
   "license": "ISC",
-  "dependencies": {
-    "@takaro/apiclient": "^0.0.1"
-  },
-  "devDependencies": {
-    "@takaro/test": "0.0.1"
-  }
-}
+  "dependencies": {},
+  "devDependencies": {}
+}

package/scripts/buildBuiltinJson.ts

@@ -1,13 +1,33 @@
 import 'reflect-metadata';
 import { getModules } from '@takaro/modules';
 import { writeFile } from 'fs/promises';
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'path';
+
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
 
 async function main() {
+  // Built in modules
+  // TODO: we should probably 'export' them in CI and save it as JSON so it's consistent with the community modules
   const modules = await getModules();
   const modulesJson = JSON.stringify(modules, null, 2);
   await writeFile('dist/modules.json', modulesJson);
   await writeFile('../web-docs/pages/modules.json', modulesJson);
   await writeFile('../e2e/src/web-main/fixtures/modules.json', modulesJson);
+
+  // Community modules
+  const files = await readdir(`${__dirname}/../src/community-modules/modules`);
+  const communityModules: Array<string> = [];
+
+  for (const file of files) {
+    const content = await readFile(`${__dirname}/../src/community-modules/modules/${file}`, 'utf-8');
+    communityModules.push(JSON.parse(content));
+  }
+
+  const communityModulesJson = JSON.stringify(communityModules, null, 2);
+  await writeFile('dist/community-modules.json', communityModulesJson);
+  await writeFile('../web-docs/pages/community-modules.json', communityModulesJson);
+  await writeFile('../e2e/src/web-main/fixtures/community-modules.json', communityModulesJson);
 }
 
 // eslint-disable-next-line no-console

package/src/BuiltinModule.ts

@@ -74,7 +74,7 @@ export class IPermission extends TakaroDTO<IPermission> {
   friendlyName: string;
   @IsOptional()
   @IsBoolean()
-  canHaveCount?: boolean = false;
+  canHaveCount?: boolean;
 }
 
 export class BuiltinModule<T> extends TakaroDTO<T> {

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

@@ -1,5 +1,4 @@
-import { IntegrationTest, expect } from '@takaro/test';
-import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
 import { GameEvents } from '../dto/index.js';
 
 const group = 'Aliases';
@@ -23,26 +22,26 @@ const tests = [
               },
             },
           }),
-        }
+        },
       );
 
-      const setEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      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.msg).to.be.eq('Teleport test set.');
+      expect((await setEvents)[0].data.meta.msg).to.be.eq('Teleport test set.');
 
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      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.msg).to.be.eq('Teleported to test.');
+      expect((await events)[0].data.meta.msg).to.be.eq('Teleported to test.');
     },
   }),
 ];

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

@@ -0,0 +1,72 @@
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
+import { GameEvents } from '../dto/index.js';
+import { EventChatMessageChannelEnum } from '@takaro/apiclient';
+
+const group = 'Bug repros';
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    name: 'Bug repro: can trigger 2 hooks for the same event inside a single module',
+    setup: modulesTestSetup,
+    test: async function () {
+      const genFn = (param: string) => {
+        return `import { data, takaro } from '@takaro/helpers';
+        async function main() {
+            const { player } = data;
+            await takaro.gameserver.gameServerControllerSendMessage(data.gameServerId, {
+                message: '${param} hook',
+            });
+        }
+        await main();`;
+      };
+
+      const mod = (
+        await this.client.module.moduleControllerCreate({
+          name: 'Test module',
+        })
+      ).data.data;
+      // Add the buggy hooks
+      await this.client.hook.hookControllerCreate({
+        name: 'Test hook 1',
+        moduleId: mod.id,
+        regex: 'test msg',
+        eventType: 'chat-message',
+        function: genFn('First'),
+      });
+
+      await this.client.hook.hookControllerCreate({
+        name: 'Test hook 2',
+        moduleId: mod.id,
+        regex: 'test msg',
+        eventType: 'chat-message',
+        function: genFn('Second'),
+      });
+
+      await this.client.gameserver.gameServerControllerInstallModule(this.setupData.gameserver.id, mod.id);
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      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,
+        },
+      });
+
+      expect((await events).length).to.be.eq(2);
+      expect((await events).map((e) => e.data.meta.msg)).to.include.members(['First hook', 'Second hook']);
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

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

@@ -1,5 +1,4 @@
-import { IntegrationTest, expect } from '@takaro/test';
-import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
 import { GameEvents } from '../dto/gameEvents.js';
 import { CommandArgumentCreateDTO } from '@takaro/apiclient';
 
@@ -77,7 +76,7 @@ const tests = [
       },
     ]),
     test: async function () {
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/test "test"',
@@ -85,8 +84,8 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.be.eq(
-        'The value for "test" should be a number. Please correct it and try again.'
+      expect((await events)[0].data.meta.msg).to.be.eq(
+        'The value for "test" should be a number. Please correct it and try again.',
       );
     },
   }),
@@ -100,7 +99,7 @@ const tests = [
       { name: 'number', type: 'number', position: 2, defaultValue: '42' },
     ]),
     test: async function () {
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/test "test"',
@@ -108,7 +107,7 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.be.eq('{"name":"test","public":false,"number":42}');
+      expect((await events)[0].data.meta.msg).to.be.eq('{"name":"test","public":false,"number":42}');
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -120,7 +119,7 @@ const tests = [
       { name: 'public', type: 'boolean', position: 1 },
     ]),
     test: async function () {
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/test "test test" true',
@@ -128,7 +127,7 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.be.eq('{"name":"test test","public":true}');
+      expect((await events)[0].data.meta.msg).to.be.eq('{"name":"test test","public":true}');
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -137,7 +136,7 @@ const tests = [
     snapshot: false,
     setup: playerArgSetup,
     test: async function () {
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
 
       const pogRes = await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
         filters: {
@@ -153,8 +152,8 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(2);
-      expect((await events)[0].data.msg).to.be.eq(pog.gameId);
-      expect((await events)[1].data.msg).to.be.eq(pog.positionX?.toString());
+      expect((await events)[0].data.meta.msg).to.be.eq(pog.gameId);
+      expect((await events)[1].data.meta.msg).to.be.eq(pog.positionX?.toString());
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -163,7 +162,7 @@ const tests = [
     snapshot: false,
     setup: playerArgSetup,
     test: async function () {
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
 
       const pogRes = await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
         filters: {
@@ -179,8 +178,8 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(2);
-      expect((await events)[0].data.msg).to.be.eq(pog.gameId);
-      expect((await events)[1].data.msg).to.be.eq(pog.positionX?.toString());
+      expect((await events)[0].data.meta.msg).to.be.eq(pog.gameId);
+      expect((await events)[1].data.meta.msg).to.be.eq(pog.positionX?.toString());
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -189,7 +188,7 @@ const tests = [
     snapshot: false,
     setup: playerArgSetup,
     test: async function () {
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
 
       const pogRes = await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
         filters: {
@@ -205,8 +204,8 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(2);
-      expect((await events)[0].data.msg).to.be.eq(pog.gameId);
-      expect((await events)[1].data.msg).to.be.eq(pog.positionX?.toString());
+      expect((await events)[0].data.meta.msg).to.be.eq(pog.gameId);
+      expect((await events)[1].data.meta.msg).to.be.eq(pog.positionX?.toString());
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -215,7 +214,7 @@ const tests = [
     snapshot: false,
     setup: playerArgSetup,
     test: async function () {
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
 
       const pogRes = await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
         filters: {
@@ -231,8 +230,8 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(2);
-      expect((await events)[0].data.msg).to.be.eq(pog.gameId);
-      expect((await events)[1].data.msg).to.be.eq(pog.positionX?.toString());
+      expect((await events)[0].data.meta.msg).to.be.eq(pog.gameId);
+      expect((await events)[1].data.meta.msg).to.be.eq(pog.positionX?.toString());
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -241,7 +240,7 @@ const tests = [
     snapshot: false,
     setup: playerArgSetup,
     test: async function () {
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
       // Find a letter contained in one of the players' names
       const letterToSearch = ['e', 'a'].find((letter) => {
@@ -256,7 +255,7 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.match(/Multiple players found/);
+      expect((await events)[0].data.meta.msg).to.match(/Multiple players found/);
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -265,7 +264,7 @@ const tests = [
     snapshot: false,
     setup: playerArgSetup,
     test: async function () {
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/test itsimpossiblethatwewilleverfindaplayerwiththisnameright',
@@ -273,7 +272,7 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.match(/No player found with the name or ID/);
+      expect((await events)[0].data.meta.msg).to.match(/No player found with the name or ID/);
     },
   }),
 ];