@takaro/gameserver 0.0.1

package/dist/getGame.d.ts

@@ -0,0 +1,8 @@
+import { GameServerOutputDTOTypeEnum, Settings } from '@takaro/apiclient';
+import { IGameServer } from './interfaces/GameServer.js';
+export declare enum GAME_SERVER_TYPE {
+    'MOCK' = "MOCK",
+    'SEVENDAYSTODIE' = "SEVENDAYSTODIE",
+    'RUST' = "RUST"
+}
+export declare function getGame(type: GAME_SERVER_TYPE | GameServerOutputDTOTypeEnum, connectionInfo: Record<string, unknown>, settings: Partial<Settings>): Promise<IGameServer>;

package/dist/getGame.js

@@ -0,0 +1,26 @@
+import { errors } from '@takaro/util';
+import { SdtdConnectionInfo } from './gameservers/7d2d/connectionInfo.js';
+import { SevenDaysToDie } from './gameservers/7d2d/index.js';
+import { MockConnectionInfo } from './gameservers/mock/connectionInfo.js';
+import { Mock } from './gameservers/mock/index.js';
+import { RustConnectionInfo } from './gameservers/rust/connectionInfo.js';
+import { Rust } from './gameservers/rust/index.js';
+export var GAME_SERVER_TYPE;
+(function (GAME_SERVER_TYPE) {
+    GAME_SERVER_TYPE["MOCK"] = "MOCK";
+    GAME_SERVER_TYPE["SEVENDAYSTODIE"] = "SEVENDAYSTODIE";
+    GAME_SERVER_TYPE["RUST"] = "RUST";
+})(GAME_SERVER_TYPE || (GAME_SERVER_TYPE = {}));
+export async function getGame(type, connectionInfo, settings) {
+    switch (type) {
+        case GAME_SERVER_TYPE.SEVENDAYSTODIE:
+            return new SevenDaysToDie(new SdtdConnectionInfo(connectionInfo), settings);
+        case GAME_SERVER_TYPE.RUST:
+            return new Rust(new RustConnectionInfo(connectionInfo), settings);
+        case GAME_SERVER_TYPE.MOCK:
+            return new Mock(new MockConnectionInfo(connectionInfo), settings);
+        default:
+            throw new errors.NotImplementedError();
+    }
+}
+//# sourceMappingURL=getGame.js.map

package/dist/getGame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getGame.js","sourceRoot":"","sources":["../src/getGame.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAC;AAGnD,MAAM,CAAN,IAAY,gBAIX;AAJD,WAAY,gBAAgB;IAC1B,iCAAe,CAAA;IACf,qDAAmC,CAAA;IACnC,iCAAe,CAAA;AACjB,CAAC,EAJW,gBAAgB,KAAhB,gBAAgB,QAI3B;AAED,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,IAAoD,EACpD,cAAuC,EACvC,QAA2B;IAE3B,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,gBAAgB,CAAC,cAAc;YAClC,OAAO,IAAI,cAAc,CAAC,IAAI,kBAAkB,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,CAAC;QAC9E,KAAK,gBAAgB,CAAC,IAAI;YACxB,OAAO,IAAI,IAAI,CAAC,IAAI,kBAAkB,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,CAAC;QACpE,KAAK,gBAAgB,CAAC,IAAI;YACxB,OAAO,IAAI,IAAI,CAAC,IAAI,kBAAkB,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,CAAC;QACpE;YACE,MAAM,IAAI,MAAM,CAAC,mBAAmB,EAAE,CAAC;IAC3C,CAAC;AACH,CAAC"}

package/dist/interfaces/GameServer.d.ts

@@ -0,0 +1,57 @@
+import { TakaroEmitter } from '../TakaroEmitter.js';
+import { IGamePlayer, IPosition } from '@takaro/modules';
+import { TakaroDTO } from '@takaro/util';
+export declare class CommandOutput extends TakaroDTO<CommandOutput> {
+    rawResult: string;
+    success: boolean;
+    errorMessage?: string;
+}
+export declare class TestReachabilityOutputDTO extends TakaroDTO<TestReachabilityOutputDTO> {
+    connectable: boolean;
+    reason?: string;
+}
+/**
+ * This is used whenever we want to target a specific player
+ * We only allow a subset of IGamePlayer here because to work across gameservers we need to be generic
+ * Eg, if we allow users to reference players by Steam ID, that wont work for all gameservers. Not all gameservers have Steam integration
+ */
+export declare class IPlayerReferenceDTO extends TakaroDTO<IPlayerReferenceDTO> {
+    gameId: string;
+}
+export declare class IItemDTO extends TakaroDTO<IItemDTO> {
+    name: string;
+    code: string;
+    description: string;
+    amount?: number;
+}
+export declare class IMessageOptsDTO extends TakaroDTO<IMessageOptsDTO> {
+    /** When specified, will send a DM to this player instead of a global message */
+    recipient?: IPlayerReferenceDTO;
+}
+export declare class BanDTO extends TakaroDTO<BanDTO> {
+    player: IPlayerReferenceDTO;
+    reason: string;
+    expiresAt: string | null;
+}
+export interface IGameServer {
+    connectionInfo: unknown;
+    getEventEmitter(): TakaroEmitter;
+    getPlayer(player: IPlayerReferenceDTO): Promise<IGamePlayer | null>;
+    getPlayers(): Promise<IGamePlayer[]>;
+    getPlayerLocation(player: IPlayerReferenceDTO): Promise<IPosition | null>;
+    getPlayerInventory(player: IPlayerReferenceDTO): Promise<IItemDTO[]>;
+    giveItem(player: IPlayerReferenceDTO, item: string, amount: number): Promise<void>;
+    listItems(): Promise<IItemDTO[]>;
+    executeConsoleCommand(rawCommand: string): Promise<CommandOutput>;
+    sendMessage(message: string, opts: IMessageOptsDTO): Promise<void>;
+    teleportPlayer(player: IPlayerReferenceDTO, x: number, y: number, z: number): Promise<void>;
+    /**
+     * Try and connect to the gameserver
+     * If anything goes wrong, this function will report a detailed reason
+     */
+    testReachability(): Promise<TestReachabilityOutputDTO>;
+    kickPlayer(player: IPlayerReferenceDTO, reason: string): Promise<void>;
+    banPlayer(options: BanDTO): Promise<void>;
+    unbanPlayer(player: IPlayerReferenceDTO): Promise<void>;
+    listBans(): Promise<BanDTO[]>;
+}

package/dist/interfaces/GameServer.js

@@ -0,0 +1,95 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { TakaroDTO } from '@takaro/util';
+import { IsBoolean, IsISO8601, IsNumber, IsOptional, IsString, ValidateNested } from 'class-validator';
+import { Type } from 'class-transformer';
+export class CommandOutput extends TakaroDTO {
+}
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], CommandOutput.prototype, "rawResult", void 0);
+__decorate([
+    IsBoolean(),
+    __metadata("design:type", Boolean)
+], CommandOutput.prototype, "success", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    __metadata("design:type", String)
+], CommandOutput.prototype, "errorMessage", void 0);
+export class TestReachabilityOutputDTO extends TakaroDTO {
+}
+__decorate([
+    IsBoolean(),
+    __metadata("design:type", Boolean)
+], TestReachabilityOutputDTO.prototype, "connectable", void 0);
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", String)
+], TestReachabilityOutputDTO.prototype, "reason", void 0);
+/**
+ * This is used whenever we want to target a specific player
+ * We only allow a subset of IGamePlayer here because to work across gameservers we need to be generic
+ * Eg, if we allow users to reference players by Steam ID, that wont work for all gameservers. Not all gameservers have Steam integration
+ */
+export class IPlayerReferenceDTO extends TakaroDTO {
+}
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], IPlayerReferenceDTO.prototype, "gameId", void 0);
+export class IItemDTO extends TakaroDTO {
+}
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], IItemDTO.prototype, "name", void 0);
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], IItemDTO.prototype, "code", void 0);
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", String)
+], IItemDTO.prototype, "description", void 0);
+__decorate([
+    IsNumber(),
+    IsOptional(),
+    __metadata("design:type", Number)
+], IItemDTO.prototype, "amount", void 0);
+export class IMessageOptsDTO extends TakaroDTO {
+}
+__decorate([
+    Type(() => IPlayerReferenceDTO),
+    ValidateNested()
+    /** When specified, will send a DM to this player instead of a global message */
+    ,
+    __metadata("design:type", IPlayerReferenceDTO)
+], IMessageOptsDTO.prototype, "recipient", void 0);
+export class BanDTO extends TakaroDTO {
+}
+__decorate([
+    Type(() => IPlayerReferenceDTO),
+    ValidateNested(),
+    __metadata("design:type", IPlayerReferenceDTO)
+], BanDTO.prototype, "player", void 0);
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], BanDTO.prototype, "reason", void 0);
+__decorate([
+    IsISO8601(),
+    IsOptional(),
+    __metadata("design:type", Object)
+], BanDTO.prototype, "expiresAt", void 0);
+//# sourceMappingURL=GameServer.js.map

package/dist/interfaces/GameServer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GameServer.js","sourceRoot":"","sources":["../../src/interfaces/GameServer.ts"],"names":[],"mappings":";;;;;;;;;AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACvG,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAEzC,MAAM,OAAO,aAAc,SAAQ,SAAwB;CAQ1D;AANC;IADC,QAAQ,EAAE;;gDACO;AAElB;IADC,SAAS,EAAE;;8CACK;AAGjB;IAFC,UAAU,EAAE;IACZ,QAAQ,EAAE;;mDACW;AAExB,MAAM,OAAO,yBAA0B,SAAQ,SAAoC;CAOlF;AALC;IADC,SAAS,EAAE;;8DACS;AAIrB;IAFC,QAAQ,EAAE;IACV,UAAU,EAAE;;yDACG;AAGlB;;;;GAIG;AACH,MAAM,OAAO,mBAAoB,SAAQ,SAA8B;CAGtE;AADC;IADC,QAAQ,EAAE;;mDACI;AAGjB,MAAM,OAAO,QAAS,SAAQ,SAAmB;CAWhD;AATC;IADC,QAAQ,EAAE;;sCACE;AAEb;IADC,QAAQ,EAAE;;sCACE;AAGb;IAFC,QAAQ,EAAE;IACV,UAAU,EAAE;;6CACO;AAGpB;IAFC,QAAQ,EAAE;IACV,UAAU,EAAE;;wCACG;AAGlB,MAAM,OAAO,eAAgB,SAAQ,SAA0B;CAK9D;AADC;IAHC,IAAI,CAAC,GAAG,EAAE,CAAC,mBAAmB,CAAC;IAC/B,cAAc,EAAE;IACjB,gFAAgF;;8BACpE,mBAAmB;kDAAC;AAGlC,MAAM,OAAO,MAAO,SAAQ,SAAiB;CAW5C;AARC;IAFC,IAAI,CAAC,GAAG,EAAE,CAAC,mBAAmB,CAAC;IAC/B,cAAc,EAAE;8BACT,mBAAmB;sCAAC;AAG5B;IADC,QAAQ,EAAE;;sCACI;AAIf;IAFC,SAAS,EAAE;IACX,UAAU,EAAE;;yCACY"}

package/dist/main.d.ts

@@ -0,0 +1,9 @@
+export * from './interfaces/GameServer.js';
+export { TakaroEmitter } from './TakaroEmitter.js';
+export { Mock } from './gameservers/mock/index.js';
+export { MockConnectionInfo, mockJsonSchema } from './gameservers/mock/connectionInfo.js';
+export { SevenDaysToDie } from './gameservers/7d2d/index.js';
+export { SdtdConnectionInfo, sdtdJsonSchema } from './gameservers/7d2d/connectionInfo.js';
+export { Rust } from './gameservers/rust/index.js';
+export { RustConnectionInfo, rustJsonSchema } from './gameservers/rust/connectionInfo.js';
+export { getGame, GAME_SERVER_TYPE } from './getGame.js';

package/dist/main.js

@@ -0,0 +1,10 @@
+export * from './interfaces/GameServer.js';
+export { TakaroEmitter } from './TakaroEmitter.js';
+export { Mock } from './gameservers/mock/index.js';
+export { MockConnectionInfo, mockJsonSchema } from './gameservers/mock/connectionInfo.js';
+export { SevenDaysToDie } from './gameservers/7d2d/index.js';
+export { SdtdConnectionInfo, sdtdJsonSchema } from './gameservers/7d2d/connectionInfo.js';
+export { Rust } from './gameservers/rust/index.js';
+export { RustConnectionInfo, rustJsonSchema } from './gameservers/rust/connectionInfo.js';
+export { getGame, GAME_SERVER_TYPE } from './getGame.js';
+//# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAE3C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAE1F,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAE1F,OAAO,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAE1F,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC"}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@takaro/gameserver",
+  "version": "0.0.1",
+  "description": "Handles abstraction between Takaro and game servers",
+  "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",
+    "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": "echo 'No tests (yet :))'"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@takaro/modules": "0.0.1",
+    "eventsource": "^2.0.2"
+  },
+  "devDependencies": {
+    "@takaro/test": "0.0.1",
+    "@types/eventsource": "^1.1.9"
+  }
+}

package/src/TakaroEmitter.ts

@@ -0,0 +1,138 @@
+import {
+  BaseEvent,
+  EventChatMessage,
+  EventEntityKilled,
+  EventLogLine,
+  EventPlayerConnected,
+  EventPlayerDeath,
+  EventPlayerDisconnected,
+  GameEvents,
+} from '@takaro/modules';
+import { errors, isTakaroDTO, logger } from '@takaro/util';
+import { isPromise } from 'util/types';
+
+const log = logger('TakaroEmitter');
+
+/**
+ * Maps event types to their listener function signatures
+ * This allows our EventEmitter to be strongly typed
+ */
+export interface IEventMap {
+  [GameEvents.LOG_LINE]: (log: EventLogLine) => Promise<void>;
+  [GameEvents.PLAYER_CONNECTED]: (player: EventPlayerConnected) => Promise<void>;
+  [GameEvents.PLAYER_DISCONNECTED]: (player: EventPlayerDisconnected) => Promise<void>;
+  [GameEvents.CHAT_MESSAGE]: (chatMessage: EventChatMessage) => Promise<void>;
+  [GameEvents.PLAYER_DEATH]: (playerDeath: EventPlayerDeath) => Promise<void>;
+  [GameEvents.ENTITY_KILLED]: (entityKilled: EventEntityKilled) => Promise<void>;
+  error: (error: errors.TakaroError | Error) => Promise<void> | void;
+}
+
+export abstract class TakaroEmitter {
+  private listenerMap: Map<keyof IEventMap, IEventMap[keyof IEventMap][]> = new Map();
+
+  abstract stop(): Promise<void>;
+  abstract start(): Promise<void>;
+
+  constructor() {
+    return getErrorProxyHandler(this);
+  }
+
+  async emit<E extends keyof IEventMap>(event: E, data: BaseEvent<unknown> | Error) {
+    try {
+      // No listeners are attached, return early
+      if (!this.listenerMap.has(event)) return;
+
+      // Validate the data, it is user-input after all :)
+      if (isTakaroDTO(data)) {
+        if (!data.timestamp) data.timestamp = new Date().toISOString();
+        // await data.validate();
+      }
+
+      const listeners = this.listenerMap.get(event);
+
+      if (listeners) {
+        for (const listener of listeners) {
+          // We know this is okay because our listener map always corresponds to the right event
+          // This is implicit in our implementation and checked in the tests
+          // @ts-expect-error Can't get the types quite right :(
+          await listener(data);
+        }
+      }
+    } catch (error) {
+      this.emit('error', error as Error);
+    }
+  }
+
+  on<E extends keyof IEventMap>(event: E, listener: IEventMap[E]): this {
+    this.listenerMap.set(event, [listener]);
+    return this;
+  }
+
+  off<E extends keyof IEventMap>(event: E, listener: IEventMap[E]): this {
+    const listeners = this.listenerMap.get(event);
+
+    if (listeners) {
+      this.listenerMap.set(
+        event,
+        listeners.filter((l) => l !== listener)
+      );
+    }
+
+    return this;
+  }
+
+  hasErrorListener() {
+    return this.listenerMap.has('error');
+  }
+}
+
+export function getErrorProxyHandler<T extends TakaroEmitter>(emitter: T) {
+  const errorProxyHandler: ProxyHandler<T> = {
+    construct(target: any, argArray) {
+      return Reflect.construct(target, argArray, TakaroEmitter);
+    },
+
+    set: function (obj, prop: keyof TakaroEmitter, value) {
+      obj[prop] = value;
+      return true;
+    },
+
+    get(target, prop: keyof TakaroEmitter) {
+      return async (...[one, two]: any[]) => {
+        try {
+          // Check if callable function
+          if (typeof target[prop] === 'function') {
+            return await target[prop](one, two);
+            // Or if its a Promise, await it
+          } else if (isPromise(target[prop])) {
+            return await target[prop];
+          } else {
+            // Otherwise, return the value
+            return target[prop];
+          }
+        } catch (error) {
+          if (!target.hasErrorListener()) {
+            log.error('Unhandled error', error);
+            const err = new Error(
+              'Unhandled error in TakaroEmitter, attach a listener to the "error" event to handle this'
+            );
+            Error.captureStackTrace(err);
+            throw err;
+          }
+
+          if (error instanceof errors.TakaroError) {
+            await target.emit('error', error);
+          } else if (error instanceof Error) {
+            await target.emit('error', error);
+          }
+
+          if (!TakaroEmitter.prototype.hasOwnProperty(prop)) {
+            return Promise.reject(error);
+          }
+        }
+      };
+    },
+  };
+
+  return new Proxy(emitter, errorProxyHandler);
+}

package/src/TakaroEmitter.unit.test.ts

@@ -0,0 +1,125 @@
+import { TakaroEmitter } from './TakaroEmitter.js';
+import { expect, sandbox } from '@takaro/test';
+import { EventLogLine, GameEvents } from '@takaro/modules';
+
+class ExtendedTakaroEmitter extends TakaroEmitter {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async start() {}
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async stop() {}
+
+  async foo() {
+    throw new Error('testing error');
+  }
+}
+
+describe('TakaroEmitter', () => {
+  it('Can listen for events', async () => {
+    const emitter = new ExtendedTakaroEmitter();
+    const spy = sandbox.spy();
+
+    emitter.on(GameEvents.LOG_LINE, spy);
+
+    await emitter.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: 'test',
+      })
+    );
+
+    expect(spy).to.have.been.calledOnce;
+
+    await emitter.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: 'test',
+      })
+    );
+
+    expect(spy).to.have.been.calledTwice;
+  });
+
+  it('Can remove a listener, which causes further events to not be received', async () => {
+    const emitter = new ExtendedTakaroEmitter();
+    const spy = sandbox.spy();
+
+    emitter.on(GameEvents.LOG_LINE, spy);
+
+    await emitter.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: 'test',
+      })
+    );
+
+    expect(spy).to.have.been.calledOnce;
+
+    emitter.off(GameEvents.LOG_LINE, spy);
+
+    await emitter.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: 'test',
+      })
+    );
+
+    expect(spy).to.have.been.calledOnce;
+  });
+
+  it('Errors happening inside extended class do not interrupt flow of events', async () => {
+    const emitter = new ExtendedTakaroEmitter();
+    const spy = sandbox.spy();
+    const errorSpy = sandbox.spy();
+
+    emitter.on(GameEvents.LOG_LINE, spy);
+    emitter.on('error', errorSpy);
+
+    await expect(emitter.foo()).to.eventually.be.rejectedWith('testing error');
+
+    expect(errorSpy).to.have.been.calledOnce;
+
+    await emitter.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: 'test',
+      })
+    );
+
+    expect(spy).to.have.been.calledOnce;
+  });
+
+  xit('Validates data on emitting', async () => {
+    const emitter = new ExtendedTakaroEmitter();
+    const spy = sandbox.spy();
+    const errorSpy = sandbox.spy();
+
+    emitter.on(GameEvents.LOG_LINE, spy);
+    emitter.on('error', errorSpy);
+
+    await emitter.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: 'test',
+        // @ts-expect-error testing validation, our types accurately detect this is invalid
+        unknownProperty: 'this should trip validation',
+      })
+    );
+
+    expect(errorSpy).to.have.been.calledOnce;
+    expect(errorSpy.getCall(0).args[0].message).to.match(
+      /property unknownProperty has failed the following constraints: whitelistValidation/
+    );
+  });
+
+  it('Throws when an error occurs and no listeners are attached to the "error" event', async () => {
+    const emitter = new ExtendedTakaroEmitter();
+    const errorSpy = sandbox.spy();
+
+    await expect(emitter.foo()).to.eventually.be.rejectedWith('Unhandled error in TakaroEmitter');
+
+    emitter.on('error', errorSpy);
+
+    await expect(emitter.foo()).to.eventually.be.rejectedWith('testing error');
+    expect(errorSpy).to.have.been.calledOnce;
+  });
+});

package/src/__tests__/gameEventEmitter.test.ts

@@ -0,0 +1,36 @@
+import { expect, sandbox } from '@takaro/test';
+import { MockConnectionInfo } from '../gameservers/mock/connectionInfo.js';
+import { Mock } from '../gameservers/mock/index.js';
+import { GameEvents } from '@takaro/modules';
+
+describe('GameEventEmitter', () => {
+  /**
+   * This test doesn't really do much interesting runtime validation
+   * It exists to ensure that the event emitter is safely typed
+   * We use @ts-expect-error so that if the compiler fails to mark these as errors, we'll know instantly
+   */
+  it('Has a typed event emitter', async () => {
+    const gameServer = new Mock(new MockConnectionInfo({}));
+    const emitter = await gameServer.getEventEmitter();
+
+    const listenerSpy = sandbox.spy();
+
+    emitter.on(GameEvents.PLAYER_CONNECTED, async (e) => {
+      expect(() => e.player.name).to.throw(
+        // Eslint and prettier disagree on how to format this
+        // And I cba fixing it for this specific instance :)
+        // eslint-disable-next-line quotes
+        "Cannot read properties of undefined (reading 'name')"
+      );
+    });
+    emitter.on(GameEvents.PLAYER_CONNECTED, listenerSpy);
+
+    // @ts-expect-error Should use the enum here
+    emitter.on('non-existent-event', listenerSpy);
+
+    // But the raw string will also work in runtime when ignoring the compilation error
+    emitter.on('player-connected', listenerSpy);
+
+    expect(listenerSpy).to.have.been.calledTwice;
+  });
+});

package/src/gameservers/7d2d/__tests__/7d2dActions.unit.test.ts

@@ -0,0 +1,91 @@
+import { expect, sandbox } from '@takaro/test';
+import { SevenDaysToDie } from '../index.js';
+import { CommandOutput } from '../../../interfaces/GameServer.js';
+import { SdtdConnectionInfo } from '../connectionInfo.js';
+
+const testData = {
+  oneBan:
+    'Ban list entries:\n  Banned until - UserID (name) - Reason\n  2023-06-29 19:39:56 - EOS_00028a9b73bb45b2b74e8f22cda7d225 (-unknown-) - Totally valid testing reason :)\n',
+  twoBans:
+    'Ban list entries:\n  Banned until - UserID (name) - Reason\n  2028-06-29 17:49:45 - EOS_0002e0daea3b493fa146ce6d06e79a57 (-unknown-) - test\n  2028-06-29 19:19:40 - EOS_00028a9b73bb45b2b74e8f22cda7d225 (-unknown-) - test\n',
+  noBans: 'Ban list entries:\n  Banned until - UserID (name) - Reason\n',
+  oneBanWithDisplayName:
+    'Ban list entries:\n  Banned until - UserID (name) - Reason\n  2023-06-29 19:40:59 - EOS_00028a9b73bb45b2b74e8f22cda7d225 (testing display name) - Totally valid testing reason :)\n',
+};
+
+const mockSdtdConnectionInfo = new SdtdConnectionInfo({
+  adminToken: 'aaa',
+  adminUser: 'aaa',
+  useTls: false,
+  host: 'localhost',
+});
+
+describe('7d2d Actions', () => {
+  describe('listBans', () => {
+    it('Can parse ban list with a single ban', async () => {
+      sandbox.stub(SevenDaysToDie.prototype, 'executeConsoleCommand').resolves(
+        new CommandOutput({
+          rawResult: testData.oneBan,
+          success: true,
+        })
+      );
+
+      const result = await new SevenDaysToDie(await mockSdtdConnectionInfo).listBans();
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0].player.gameId).to.equal('EOS_00028a9b73bb45b2b74e8f22cda7d225');
+      expect(result[0].expiresAt).to.equal('2023-06-29T19:39:56.000Z');
+    });
+
+    it('Can parse ban list with two bans', async () => {
+      sandbox.stub(SevenDaysToDie.prototype, 'executeConsoleCommand').resolves(
+        new CommandOutput({
+          rawResult: testData.twoBans,
+          success: true,
+        })
+      );
+
+      const result = await new SevenDaysToDie(await mockSdtdConnectionInfo).listBans();
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(2);
+
+      expect(result[0].player.gameId).to.equal('EOS_0002e0daea3b493fa146ce6d06e79a57');
+      expect(result[0].expiresAt).to.equal('2028-06-29T17:49:45.000Z');
+
+      expect(result[1].player.gameId).to.equal('EOS_00028a9b73bb45b2b74e8f22cda7d225');
+      expect(result[1].expiresAt).to.equal('2028-06-29T19:19:40.000Z');
+    });
+
+    it('Can parse ban list with no bans', async () => {
+      sandbox.stub(SevenDaysToDie.prototype, 'executeConsoleCommand').resolves(
+        new CommandOutput({
+          rawResult: testData.noBans,
+          success: true,
+        })
+      );
+
+      const result = await new SevenDaysToDie(await mockSdtdConnectionInfo).listBans();
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(0);
+    });
+
+    it('Can parse ban list with a single ban with a display name', async () => {
+      sandbox.stub(SevenDaysToDie.prototype, 'executeConsoleCommand').resolves(
+        new CommandOutput({
+          rawResult: testData.oneBanWithDisplayName,
+          success: true,
+        })
+      );
+
+      const result = await new SevenDaysToDie(await mockSdtdConnectionInfo).listBans();
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0].player.gameId).to.equal('EOS_00028a9b73bb45b2b74e8f22cda7d225');
+      expect(result[0].expiresAt).to.equal('2023-06-29T19:40:59.000Z');
+    });
+  });
+});