@takaro/modules 0.0.30 → 0.1.0

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

@@ -1,13 +1,8 @@
-import {
-  IntegrationTest,
-  expect,
-  integrationConfig,
-  IModuleTestsSetupData,
-  modulesTestSetup,
-  EventsAwaiter,
-} from '@takaro/test';
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
 import { GameEvents } from '../dto/index.js';
 import { describe } from 'node:test';
+import { randomUUID } from 'crypto';
+import { getMockServer } from '@takaro/mock-gameserver';
 
 const group = 'Module permissions role assignments';
 
@@ -76,16 +71,20 @@ const tests = [
     setup: cleanRoleSetup,
     name: 'Player has role on other gameserver -> command denied',
     test: async function () {
-      const newGameServer = await this.client.gameserver.gameServerControllerCreate({
-        name: 'newServer',
-        connectionInfo: JSON.stringify({
-          host: integrationConfig.get('mockGameserver.host'),
-        }),
-        type: 'MOCK',
+      if (!this.domainRegistrationToken) throw new Error('Domain registration token not set');
+      const identityToken = randomUUID();
+      const mockserver = await getMockServer({
+        mockserver: { registrationToken: this.domainRegistrationToken, identityToken },
+      });
+      this.setupData.mockservers.push(mockserver);
+      const gameserverRes = await this.client.gameserver.gameServerControllerSearch({
+        filters: { identityToken: [identityToken] },
       });
+      const newGameServer = gameserverRes.data.data[0];
+      if (!newGameServer) throw new Error('Game server not found');
 
       await this.client.player.playerControllerAssignRole(this.setupData.players[0].id, this.setupData.role.id, {
-        gameServerId: newGameServer.data.data.id,
+        gameServerId: newGameServer.id,
       });
 
       const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);

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

@@ -26,7 +26,6 @@ const tests = [
 
       expect((await events).length).to.be.eq(1);
       expect((await events)[0].data.meta.msg).to.be.eq(
-        // eslint-disable-next-line
         "This is an automated message, don't forget to read the server rules!",
       );
     },

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

@@ -141,7 +141,6 @@ const tests = [
     group,
     snapshot: false,
     setup: modulesTestSetup,
-    // eslint-disable-next-line quotes
     name: "bug repro /tplist: Player A and B have teleports set but B cannot see A's teleports",
     test: async function () {
       await this.client.module.moduleInstallationsControllerInstallModule({

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

@@ -100,6 +100,50 @@ const tests = [
       );
     },
   }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Can teleport with dimension parameter through API endpoint',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+      });
+
+      // First, set a teleport with a specific dimension via command
+      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/settp dimension_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 dimension_test set.');
+
+      // Now teleport using the API endpoint with a specific dimension
+      await this.client.gameserver.gameServerControllerTeleportPlayer(
+        this.setupData.gameserver.id,
+        this.setupData.players[0].id,
+        {
+          x: 100,
+          y: 200,
+          z: 300,
+          dimension: 'nether',
+        },
+      );
+
+      // Verify that the teleport command works with the saved teleport (which includes dimension)
+      const tpEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/tp dimension_test',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await tpEvents).length).to.be.eq(1);
+      expect((await tpEvents)[0].data.meta.msg).to.be.eq('Teleported to dimension_test.');
+    },
+  }),
 ];
 
 describe(group, function () {

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

@@ -1,14 +1,9 @@
-import {
-  IntegrationTest,
-  expect,
-  integrationConfig,
-  IModuleTestsSetupData,
-  modulesTestSetup,
-  EventsAwaiter,
-} from '@takaro/test';
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
 import { GameEvents, HookEvents } from '../../dto/index.js';
-import { GameServerTypesOutputDTOTypeEnum, PlayerOutputDTO, RoleOutputDTO } from '@takaro/apiclient';
+import { PlayerOutputDTO, RoleOutputDTO } from '@takaro/apiclient';
 import { describe } from 'node:test';
+import { randomUUID } from 'crypto';
+import { getMockServer } from '@takaro/mock-gameserver';
 
 const group = 'Teleports - waypoints';
 
@@ -69,17 +64,20 @@ const waypointsSetup = async function (this: IntegrationTest<WaypointsSetup>): P
 };
 
 async function setupSecondServer(this: IntegrationTest<WaypointsSetup>) {
-  const newGameServer = await this.client.gameserver.gameServerControllerCreate({
-    name: 'newServer',
-    connectionInfo: JSON.stringify({
-      host: integrationConfig.get('mockGameserver.host'),
-      name: 'newServer',
-    }),
-    type: GameServerTypesOutputDTOTypeEnum.Mock,
+  if (!this.domainRegistrationToken) throw new Error('Domain registration token not set');
+  const identityToken = randomUUID();
+  const mockserver = await getMockServer({
+    mockserver: { registrationToken: this.domainRegistrationToken, identityToken },
+  });
+  this.setupData.mockservers.push(mockserver);
+  const gameserverRes = await this.client.gameserver.gameServerControllerSearch({
+    filters: { identityToken: [identityToken] },
   });
+  const newGameServer = gameserverRes.data.data[0];
+  if (!newGameServer) throw new Error('Game server not found');
 
   await this.client.module.moduleInstallationsControllerInstallModule({
-    gameServerId: newGameServer.data.data.id,
+    gameServerId: newGameServer.id,
     versionId: this.setupData.teleportsModule.latestVersion.id,
   });
 
@@ -88,7 +86,7 @@ async function setupSecondServer(this: IntegrationTest<WaypointsSetup>) {
     5,
   );
 
-  await this.client.gameserver.gameServerControllerExecuteCommand(newGameServer.data.data.id, {
+  await this.client.gameserver.gameServerControllerExecuteCommand(newGameServer.id, {
     command: 'connectAll',
   });
 
@@ -96,7 +94,7 @@ async function setupSecondServer(this: IntegrationTest<WaypointsSetup>) {
 
   const newServerPlayers = (
     await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
-      filters: { gameServerId: [newGameServer.data.data.id] },
+      filters: { gameServerId: [newGameServer.id] },
     })
   ).data.data;
   const newServerModerator = newServerPlayers[0];
@@ -249,7 +247,6 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      // eslint-disable-next-line quotes
       expect((await events)[0].data.meta.msg).to.be.eq("Waypoint A doesn't exist.");
     },
   }),
@@ -546,7 +543,7 @@ const tests = [
 
       // Make a waypoint on the new gameserver
       const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
-      await this.client.command.commandControllerTrigger(newGameServer.data.data.id, {
+      await this.client.command.commandControllerTrigger(newGameServer.id, {
         msg: '/setwaypoint A',
         playerId: newServerModerator.playerId,
       });
@@ -562,16 +559,14 @@ const tests = [
       expect((await setEvents2).length).to.be.eq(1);
       expect((await setEvents2)[0].data.meta.msg).to.be.eq('Waypoint notused set.');
 
-      const useWaypointPermission = await this.client.permissionCodesToInputs([
-        `WAYPOINTS_USE_A_${newGameServer.data.data.id}`,
-      ]);
+      const useWaypointPermission = await this.client.permissionCodesToInputs([`WAYPOINTS_USE_A_${newGameServer.id}`]);
       await this.client.role.roleControllerUpdate(this.setupData.playerRole.id, {
         permissions: useWaypointPermission,
       });
 
       // Use the waypoint from the new gameserver -> success
       const teleportEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
-      await this.client.command.commandControllerTrigger(newGameServer.data.data.id, {
+      await this.client.command.commandControllerTrigger(newGameServer.id, {
         msg: '/A',
         playerId: newServerPlayer.playerId,
       });
@@ -615,7 +610,7 @@ const tests = [
 
       // Make a waypoint on the new gameserver
       const setEvents2 = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
-      await this.client.command.commandControllerTrigger(newGameServer.data.data.id, {
+      await this.client.command.commandControllerTrigger(newGameServer.id, {
         msg: '/setwaypoint A',
         playerId: newServerModerator.playerId,
       });
@@ -641,7 +636,7 @@ const tests = [
         GameEvents.CHAT_MESSAGE,
         1,
       );
-      await this.client.command.commandControllerTrigger(newGameServer.data.data.id, {
+      await this.client.command.commandControllerTrigger(newGameServer.id, {
         msg: '/A',
         playerId: newServerPlayer.playerId,
       });
@@ -742,6 +737,88 @@ const tests = [
       );
     },
   }),
+  new IntegrationTest<WaypointsSetup>({
+    group,
+    snapshot: false,
+    setup: waypointsSetup,
+    name: 'Waypoints store and use dimension information correctly',
+    test: async function () {
+      // Create a waypoint with dimension data via setwaypoint command
+      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/setwaypoint dimension_waypoint',
+        playerId: this.setupData.moderator.id,
+      });
+
+      expect((await setEvents).length).to.be.eq(1);
+      expect((await setEvents)[0].data.meta.msg).to.be.eq('Waypoint dimension_waypoint set.');
+
+      // Give player permission to use the waypoint
+      const useWaypointPermission = await this.client.permissionCodesToInputs([
+        `WAYPOINTS_USE_DIMENSION_WAYPOINT_${this.setupData.gameserver.id}`,
+      ]);
+      await this.client.role.roleControllerUpdate(this.setupData.playerRole.id, {
+        permissions: useWaypointPermission,
+      });
+
+      // Teleport to the waypoint - should include dimension data
+      const teleportEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/dimension_waypoint',
+        playerId: this.setupData.player.id,
+      });
+
+      expect((await teleportEvents).length).to.be.eq(1);
+      expect((await teleportEvents)[0].data.meta.msg).to.be.eq('Teleported to waypoint dimension_waypoint.');
+    },
+  }),
+  new IntegrationTest<WaypointsSetup>({
+    group,
+    snapshot: false,
+    setup: waypointsSetup,
+    name: 'Waypoints work with API teleport endpoint including dimension parameter',
+    test: async function () {
+      // Create a waypoint
+      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/setwaypoint api_test_waypoint',
+        playerId: this.setupData.moderator.id,
+      });
+
+      expect((await setEvents).length).to.be.eq(1);
+      expect((await setEvents)[0].data.meta.msg).to.be.eq('Waypoint api_test_waypoint set.');
+
+      // Test direct API teleport with dimension
+      await this.client.gameserver.gameServerControllerTeleportPlayer(
+        this.setupData.gameserver.id,
+        this.setupData.player.id,
+        {
+          x: 500,
+          y: 600,
+          z: 700,
+          dimension: 'end',
+        },
+      );
+
+      // Give player permission to use the waypoint
+      const useWaypointPermission = await this.client.permissionCodesToInputs([
+        `WAYPOINTS_USE_API_TEST_WAYPOINT_${this.setupData.gameserver.id}`,
+      ]);
+      await this.client.role.roleControllerUpdate(this.setupData.playerRole.id, {
+        permissions: useWaypointPermission,
+      });
+
+      // Teleport using waypoint command - should work with stored dimension
+      const teleportEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/api_test_waypoint',
+        playerId: this.setupData.player.id,
+      });
+
+      expect((await teleportEvents).length).to.be.eq(1);
+      expect((await teleportEvents)[0].data.meta.msg).to.be.eq('Teleported to waypoint api_test_waypoint.');
+    },
+  }),
 ];
 
 describe(group, function () {

package/src/dto/gameEvents.ts

@@ -1,4 +1,4 @@
-import { IsEnum, IsString, ValidateNested, IsOptional, IsNumber } from 'class-validator';
+import { IsEnum, IsString, ValidateNested, IsOptional, IsNumber, Matches } from 'class-validator';
 import { TakaroDTO } from '@takaro/util';
 import { Type } from 'class-transformer';
 import { BaseEvent } from './base.js';
@@ -41,6 +41,9 @@ export class IGamePlayer extends TakaroDTO<IGamePlayer> {
 
   @IsString()
   @IsOptional()
+  @Matches(/^[a-zA-Z0-9_-]+:[a-zA-Z0-9_-]+$/, {
+    message: "Platform ID must be in format 'platform:id' (e.g., 'minecraft:player-uuid')",
+  })
   platformId?: string;
 
   @IsString()
@@ -61,12 +64,6 @@ export class BaseGameEvent<T> extends BaseEvent<T> {
   msg: string;
 }
 
-export interface IPositionInterface {
-  x: number;
-  y: number;
-  z: number;
-}
-
 export class EventLogLine extends BaseGameEvent<EventLogLine> {
   @IsString()
   type = GameEvents.LOG_LINE;
@@ -105,13 +102,16 @@ export class EventChatMessage extends BaseGameEvent<EventChatMessage> {
   declare msg: string;
 }
 
-export class IPosition implements IPositionInterface {
+export class IPosition extends TakaroDTO<IPosition> {
   @IsNumber()
   x: number;
   @IsNumber()
   y: number;
   @IsNumber()
   z: number;
+  @IsString()
+  @IsOptional()
+  dimension?: string;
 }
 
 export class EventPlayerDeath extends BaseGameEvent<EventPlayerDeath> {

package/src/modules/dailyRewards/index.ts

@@ -1,4 +1,3 @@
-/* eslint-disable quotes */
 import {
   ModuleTransferDTO,
   ICommand,

package/src/modules/geoBlock/index.ts

@@ -57,7 +57,6 @@ export const countryCodes = [
   { code: 'CD', name: 'Congo, Democratic Republic' },
   { code: 'CK', name: 'Cook Islands' },
   { code: 'CR', name: 'Costa Rica' },
-  // eslint-disable-next-line quotes
   { code: 'CI', name: "Cote D'Ivoire" },
   { code: 'HR', name: 'Croatia' },
   { code: 'CU', name: 'Cuba' },
@@ -123,7 +122,6 @@ export const countryCodes = [
   { code: 'KR', name: 'Korea' },
   { code: 'KW', name: 'Kuwait' },
   { code: 'KG', name: 'Kyrgyzstan' },
-  // eslint-disable-next-line quotes
   { code: 'LA', name: "Lao People's Democratic Republic" },
   { code: 'LV', name: 'Latvia' },
   { code: 'LB', name: 'Lebanon' },

package/src/modules/gimme/commands/gimme.js

@@ -25,7 +25,7 @@ async function main() {
     } else {
       const item = (await takaro.item.itemControllerFindOne(randomOption.item)).data.data;
       await takaro.gameserver.gameServerControllerGiveItem(data.gameServerId, data.player.id, {
-        name: item.code,
+        name: item.id,
         amount: randomOption.amount,
         quality: randomOption.quality ?? '',
       });

package/src/modules/highPingKicker/cronJobs/Ping check.js

@@ -10,16 +10,16 @@ async function main() {
       if (player.ping > data.module.userConfig.pingThreshold) {
         const takaroPlayerRes = await takaro.player.playerControllerSearch({
           filters: {
-            steamId: player.steamId,
+            steamId: [player.steamId],
           },
         });
 
         const takaroPlayer = takaroPlayerRes.data.data[0];
 
-        const currentWarningsRes = await takaro.variable.variableControllerFind({
+        const currentWarningsRes = await takaro.variable.variableControllerSearch({
           filters: {
-            playerId: takaroPlayer.id,
-            key: VARIABLE_KEY,
+            playerId: [takaroPlayer.id],
+            key: [VARIABLE_KEY],
           },
         });
 
@@ -33,14 +33,24 @@ async function main() {
             value: '1',
           });
         } else {
-          currentWarnings = parseInt(currentWarningsRecords[0].value, 10);
+          currentWarnings = parseInt(currentWarningsRecords[0].value, 10) + 1;
+          await takaro.variable.variableControllerUpdate(currentWarningsRecords[0].id, {
+            value: currentWarnings.toString(),
+          });
         }
 
-        if (currentWarningsRecords.length === 1) {
-          await takaro.variable.variableControllerUpdate(currentWarningsRecords[0].id, {
-            value: (currentWarnings + 1).toString(),
+        // Check if player should be kicked before sending warning
+        if (currentWarnings >= data.module.userConfig.warningsBeforeKick) {
+          await takaro.gameserver.gameServerControllerKickPlayer(data.gameServerId, takaroPlayer.id, {
+            reason: `Your ping (${player.ping}) is too high, please try again later.`,
           });
 
+          // Delete the warning record after kicking
+          if (currentWarningsRecords.length > 0) {
+            await takaro.variable.variableControllerDelete(currentWarningsRecords[0].id);
+          }
+        } else {
+          // Only send warning if player won't be kicked
           await takaro.gameserver.gameServerControllerSendMessage(data.gameServerId, {
             message: `Your ping (${player.ping}) is too high. Warning ${currentWarnings}/${data.module.userConfig.warningsBeforeKick}`,
             opts: {
@@ -50,16 +60,8 @@ async function main() {
             },
           });
         }
-
-        if (currentWarnings >= data.module.userConfig.warningsBeforeKick) {
-          await takaro.gameserver.gameServerControllerKickPlayer(data.gameServerId, takaroPlayer.id, {
-            reason: `Your ping (${player.ping}) is too high, please try again later.`,
-          });
-
-          await takaro.variable.variableControllerDelete(currentWarningsRecords[0].id);
-        }
       }
-    })
+    }),
   );
 }
 

package/src/modules/highPingKicker/index.ts

@@ -6,7 +6,7 @@ export class HighPingKicker extends ModuleTransferDTO<HighPingKicker> {
     this.name = 'highPingKicker';
     this.versions = [
       new ModuleTransferVersionDTO({
-        tag: '0.0.1',
+        tag: '0.0.2',
         description: 'Automatically kick players with high ping, with warnings and configurable thresholds.',
         configSchema: JSON.stringify({
           $schema: 'http://json-schema.org/draft-07/schema#',

package/src/modules/playerOnboarding/commands/starterkit.js

@@ -32,7 +32,7 @@ async function main() {
       throw new TakaroUserError(`Item with ID ${item.item} not found.`);
     }
     return {
-      code: itemRecord.code,
+      id: itemRecord.id,
       quality: item.quality,
       amount: item.amount,
     };
@@ -41,7 +41,7 @@ async function main() {
   await Promise.all(
     fullItems.map(async (item) => {
       return takaro.gameserver.gameServerControllerGiveItem(data.gameServerId, data.player.id, {
-        name: item.code,
+        name: item.id,
         quality: item.quality ?? '',
         amount: item.amount,
       });

package/src/modules/teleports/commands/settp.js

@@ -31,7 +31,7 @@ async function main() {
 
   if (allPlayerTeleports.data.data.length >= hasPermission.count) {
     throw new TakaroUserError(
-      `You have reached the maximum number of teleports for your role, maximum allowed is ${hasPermission.count}`
+      `You have reached the maximum number of teleports for your role, maximum allowed is ${hasPermission.count}`,
     );
   }
 
@@ -42,6 +42,7 @@ async function main() {
       x: data.pog.positionX,
       y: data.pog.positionY,
       z: data.pog.positionZ,
+      dimension: data.pog.dimension,
     }),
     gameServerId,
     moduleId: mod.moduleId,

package/src/modules/teleports/commands/setwaypoint.js

@@ -17,6 +17,7 @@ async function main() {
         x: pog.positionX,
         y: pog.positionY,
         z: pog.positionZ,
+        dimension: pog.dimension,
       }),
     });
   } catch (error) {

package/src/modules/teleports/commands/teleport.js

@@ -60,6 +60,7 @@ async function main() {
       x: teleport.x,
       y: teleport.y,
       z: teleport.z,
+      dimension: teleport.dimension,
     });
 
     await data.player.pm(`Teleported to ${teleport.name}.`);
@@ -78,6 +79,7 @@ async function main() {
     x: teleport.x,
     y: teleport.y,
     z: teleport.z,
+    dimension: teleport.dimension,
   });
 
   await data.player.pm(`Teleported to ${teleport.name}.`);

package/src/modules/teleports/commands/teleportwaypoint.js

@@ -48,6 +48,7 @@ async function main() {
     x: waypoint.x,
     y: waypoint.y,
     z: waypoint.z,
+    dimension: waypoint.dimension,
   });
 
   await pog.pm(`Teleported to waypoint ${trigger}.`);

package/src/modules/teleports/index.ts

@@ -15,7 +15,7 @@ export class Teleports extends ModuleTransferDTO<Teleports> {
     this.name = 'teleports';
     this.versions = [
       new ModuleTransferVersionDTO({
-        tag: '0.0.2',
+        tag: '0.0.3',
         description: 'A set of commands to allow players to set their own teleport points and teleport to them.',
         configSchema: JSON.stringify({
           $schema: 'http://json-schema.org/draft-07/schema#',