@takaro/modules 0.0.1

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@takaro/modules",
+  "version": "0.0.1",
+  "description": "Built-in modules for Takaro",
+  "main": "dist/main.js",
+  "types": "dist/main.d.ts",
+  "type": "module",
+  "scripts": {
+    "start:dev": "tsc --watch --preserveWatchOutput -p ./tsconfig.build.json",
+    "build": "tsc -p ./tsconfig.build.json",
+    "postbuild": "npm run build:builtin-json",
+    "test": "npm run test:unit --if-present && npm run test:integration --if-present",
+    "test:unit": "mocha --config ../../.mocharc.js src/**/*.unit.test.ts",
+    "test:integration": "mocha --file ../test/dist/waitUntilReady.js --config ../../.mocharc.js 'src/**/*.integration.test.ts' --exit",
+    "build:builtin-json": "node --loader ts-node/esm ./scripts/buildBuiltinJson.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@takaro/apiclient": "^0.0.1"
+  },
+  "devDependencies": {
+    "@takaro/test": "0.0.1"
+  }
+}

package/scripts/buildBuiltinJson.ts

@@ -0,0 +1,14 @@
+import 'reflect-metadata';
+import { getModules } from '@takaro/modules';
+import { writeFile } from 'fs/promises';
+
+async function main() {
+  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);
+}
+
+// eslint-disable-next-line no-console
+main().catch(console.error);

package/src/BuiltinModule.ts

@@ -0,0 +1,125 @@
+import { readFileSync, readdirSync } from 'fs';
+import path from 'path';
+import * as url from 'url';
+import { IsString, IsOptional, IsNumber, IsArray, ValidateNested, IsEnum, IsBoolean } from 'class-validator';
+import { Type } from 'class-transformer';
+import { EventTypes, HookEvents } from './dto/index.js';
+import { TakaroDTO } from '@takaro/util';
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+
+export class ICommandArgument extends TakaroDTO<ICommandArgument> {
+  @IsString()
+  name: string;
+  @IsString()
+  type: string;
+  @IsString()
+  @IsOptional()
+  helpText?: string;
+  @IsString()
+  @IsOptional()
+  defaultValue?: string | null;
+  @IsNumber()
+  @IsOptional()
+  position?: number;
+}
+
+export class ICommand extends TakaroDTO<ICommand> {
+  @IsString()
+  name: string;
+  @IsString()
+  function: string;
+  @IsString()
+  trigger: string;
+  @IsString()
+  @IsOptional()
+  helpText?: string;
+  @ValidateNested({ each: true })
+  @Type(() => ICommandArgument)
+  @IsOptional()
+  arguments: ICommandArgument[];
+}
+
+export class IHook extends TakaroDTO<IHook> {
+  @IsString()
+  name: string;
+  @IsString()
+  function: string;
+  @IsEnum(Object.values(HookEvents))
+  eventType: EventTypes;
+}
+
+export class ICronJob extends TakaroDTO<ICronJob> {
+  @IsString()
+  name: string;
+  @IsString()
+  function: string;
+  @IsString()
+  temporalValue: string;
+}
+
+export class IFunction extends TakaroDTO<IFunction> {
+  @IsString()
+  name: string;
+  @IsString()
+  function: string;
+}
+
+export class IPermission extends TakaroDTO<IPermission> {
+  @IsString()
+  permission: string;
+  @IsString()
+  description: string;
+  @IsString()
+  friendlyName: string;
+  @IsOptional()
+  @IsBoolean()
+  canHaveCount?: boolean = false;
+}
+
+export class BuiltinModule<T> extends TakaroDTO<T> {
+  constructor(name: string, description: string, configSchema: string, uiSchema: string = JSON.stringify({})) {
+    super();
+    this.name = name;
+    this.description = description;
+    this.configSchema = configSchema;
+    this.uiSchema = uiSchema;
+  }
+
+  @IsString()
+  public name: string;
+  @IsString()
+  public description: string;
+  @IsString()
+  public configSchema: string;
+  @IsString()
+  public uiSchema: string;
+
+  @ValidateNested({ each: true })
+  @Type(() => ICommand)
+  public commands: Array<ICommand> = [];
+  @ValidateNested({ each: true })
+  @Type(() => IHook)
+  public hooks: Array<IHook> = [];
+  @ValidateNested({ each: true })
+  @Type(() => ICronJob)
+  public cronJobs: Array<ICronJob> = [];
+  @ValidateNested({ each: true })
+  @Type(() => IFunction)
+  public functions: Array<IFunction> = [];
+  @IsArray()
+  @Type(() => IPermission)
+  @ValidateNested({ each: true })
+  public permissions: IPermission[] = [];
+
+  protected loadFn(type: 'commands' | 'hooks' | 'cronJobs' | 'functions', name: string) {
+    const folderPath = path.join(__dirname, 'modules', this.name, type);
+    const files = readdirSync(folderPath);
+    const file = files.find((file) => file.replace('.js', '') === name);
+    if (!file) {
+      throw new Error(`Could not find ${name} in ${this.name}'s ${type}. Did you provide a function implementation?`);
+    }
+
+    return readFileSync(path.join(folderPath, file), 'utf-8');
+  }
+}

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

@@ -0,0 +1,54 @@
+import { IntegrationTest, expect } from '@takaro/test';
+import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { GameEvents } from '../dto/index.js';
+
+const group = 'Aliases';
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Can install and use aliases',
+    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 = this.setupData.eventAwaiter.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.');
+
+      const events = this.setupData.eventAwaiter.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.');
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

package/src/__tests__/builtinmodule.unit.test.ts

@@ -0,0 +1,13 @@
+import { expect } from '@takaro/test';
+import { getModules } from '../main.js';
+
+describe('BuiltInModule', () => {
+  it('Can load module items', async () => {
+    const mods = await getModules();
+
+    const utilsModule = mods.find((mod) => mod.name === 'utils');
+
+    expect(utilsModule).to.not.be.undefined;
+    expect(utilsModule?.commands).to.have.length(2);
+  });
+});

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

@@ -0,0 +1,285 @@
+import { IntegrationTest, expect } from '@takaro/test';
+import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { GameEvents } from '../dto/gameEvents.js';
+import { CommandArgumentCreateDTO } from '@takaro/apiclient';
+
+const group = 'Command args';
+
+const createSetup = (commandArgs: CommandArgumentCreateDTO[]) => {
+  return async function (this: IntegrationTest<IModuleTestsSetupData>) {
+    const setupRes = await modulesTestSetup.bind(this)();
+    const moduleRes = await this.client.module.moduleControllerCreate({
+      name: 'test',
+    });
+
+    await this.client.command.commandControllerCreate({
+      name: 'test',
+      trigger: 'test',
+      moduleId: moduleRes.data.data.id,
+      arguments: commandArgs,
+      function: `import { getTakaro, getData } from '@takaro/helpers';
+
+      async function main() {
+        const data = await getData();
+        const takaro = await getTakaro(data);
+        const { arguments: args } = data;
+        await data.player.pm(JSON.stringify(args));
+      }
+      
+      await main();`,
+    });
+
+    await this.client.gameserver.gameServerControllerInstallModule(setupRes.gameserver.id, moduleRes.data.data.id);
+
+    return setupRes;
+  };
+};
+
+const playerArgSetup = async function (this: IntegrationTest<IModuleTestsSetupData>) {
+  const setupRes = await modulesTestSetup.bind(this)();
+  const moduleRes = await this.client.module.moduleControllerCreate({
+    name: 'test',
+  });
+
+  await this.client.command.commandControllerCreate({
+    name: 'test',
+    trigger: 'test',
+    moduleId: moduleRes.data.data.id,
+    arguments: [{ name: 'name', type: 'player', position: 0 }],
+    function: `import { getTakaro, getData } from '@takaro/helpers';
+
+    async function main() {
+      const data = await getData();
+      const takaro = await getTakaro(data);
+      const { arguments: args } = data;
+      await data.player.pm(args.name.gameId);
+      await data.player.pm(args.name.positionX.toString());
+    }
+    
+    await main();`,
+  });
+
+  await this.client.gameserver.gameServerControllerInstallModule(setupRes.gameserver.id, moduleRes.data.data.id);
+
+  return setupRes;
+};
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Sends a clear error when passing invalid arguments (passing string to number args)',
+    group,
+    snapshot: false,
+    setup: createSetup([
+      {
+        name: 'test',
+        type: 'number',
+        position: 0,
+      },
+    ]),
+    test: async function () {
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/test "test"',
+        playerId: this.setupData.players[0].id,
+      });
+
+      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.'
+      );
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Respects default values',
+    group,
+    snapshot: false,
+    setup: createSetup([
+      { name: 'name', type: 'string', position: 0 },
+      { name: 'public', type: 'boolean', position: 1, defaultValue: 'false' },
+      { name: 'number', type: 'number', position: 2, defaultValue: '42' },
+    ]),
+    test: async function () {
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/test "test"',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.be.eq('{"name":"test","public":false,"number":42}');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Handles spaces properly',
+    group,
+    snapshot: false,
+    setup: createSetup([
+      { name: 'name', type: 'string', position: 0 },
+      { name: 'public', type: 'boolean', position: 1 },
+    ]),
+    test: async function () {
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/test "test test" true',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.be.eq('{"name":"test test","public":true}');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Can do a basic player arg',
+    group,
+    snapshot: false,
+    setup: playerArgSetup,
+    test: async function () {
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      const pogRes = await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+        filters: {
+          playerId: [this.setupData.players[0].id],
+          gameServerId: [this.setupData.gameserver.id],
+        },
+      });
+      const pog = pogRes.data.data[0];
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/test ${this.setupData.players[0].name}`,
+        playerId: this.setupData.players[0].id,
+      });
+
+      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());
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Can do a player arg with partial name',
+    group,
+    snapshot: false,
+    setup: playerArgSetup,
+    test: async function () {
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      const pogRes = await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+        filters: {
+          playerId: [this.setupData.players[0].id],
+          gameServerId: [this.setupData.gameserver.id],
+        },
+      });
+      const pog = pogRes.data.data[0];
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/test ${this.setupData.players[0].name.substring(0, 3)}`,
+        playerId: this.setupData.players[0].id,
+      });
+
+      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());
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Can do a player arg with case switched',
+    group,
+    snapshot: false,
+    setup: playerArgSetup,
+    test: async function () {
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      const pogRes = await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+        filters: {
+          playerId: [this.setupData.players[0].id],
+          gameServerId: [this.setupData.gameserver.id],
+        },
+      });
+      const pog = pogRes.data.data[0];
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/test ${this.setupData.players[0].name.toUpperCase()}`,
+        playerId: this.setupData.players[0].id,
+      });
+
+      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());
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Can do a player arg with steam ID',
+    group,
+    snapshot: false,
+    setup: playerArgSetup,
+    test: async function () {
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      const pogRes = await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+        filters: {
+          playerId: [this.setupData.players[0].id],
+          gameServerId: [this.setupData.gameserver.id],
+        },
+      });
+      const pog = pogRes.data.data[0];
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/test ${this.setupData.players[0].steamId}`,
+        playerId: this.setupData.players[0].id,
+      });
+
+      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());
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Shows an error when multiple players are found',
+    group,
+    snapshot: false,
+    setup: playerArgSetup,
+    test: async function () {
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      // Find a letter contained in one of the players' names
+      const letterToSearch = ['e', 'a'].find((letter) => {
+        return this.setupData.players.some((player) => {
+          return player.name.includes(letter);
+        });
+      });
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/test ${letterToSearch}`,
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.match(/Multiple players found/);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Shows an error when no players are found',
+    group,
+    snapshot: false,
+    setup: playerArgSetup,
+    test: async function () {
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/test itsimpossiblethatwewilleverfindaplayerwiththisnameright',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.match(/No player found with the name or ID/);
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});