@mnbroatch/boardgame.io 0.0.1

package/src/server/transport/socketio.test.ts

@@ -0,0 +1,303 @@
+/*
+ * Copyright 2018 The boardgame.io Authors
+ *
+ * Use of this source code is governed by a MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ */
+
+import type { SocketOpts } from './socketio';
+import { TransportAPI, SocketIO } from './socketio';
+import { Auth } from '../auth';
+import { ProcessGameConfig } from '../../core/game';
+import type { Master } from '../../master/master';
+import { error } from '../../core/logger';
+import { getFilterPlayerView } from '../../master/filter-player-view';
+
+jest.mock('../../core/logger', () => ({
+  info: jest.fn(),
+  error: jest.fn(),
+}));
+
+type SyncArgs = Parameters<Master['onSync']>;
+
+type SocketIOTestAdapterOpts = SocketOpts & {
+  clientInfo?: Map<any, any>;
+  roomInfo?: Map<any, any>;
+};
+
+class SocketIOTestAdapter extends SocketIO {
+  constructor({
+    clientInfo = new Map(),
+    roomInfo = new Map(),
+    ...args
+  }: SocketIOTestAdapterOpts = {}) {
+    super(Object.keys(args).length > 0 ? args : undefined);
+    this.clientInfo = clientInfo;
+    this.roomInfo = roomInfo;
+  }
+
+  public getPubSub() {
+    return this.pubSub;
+  }
+}
+
+jest.mock('../../master/master', () => {
+  class Master {
+    onUpdate: jest.Mock<any, any>;
+    onSync: jest.Mock<any, any>;
+    onConnectionChange: jest.Mock<any, any>;
+    onChatMessage: jest.Mock<any, any>;
+
+    constructor() {
+      this.onUpdate = jest.fn();
+      this.onSync = jest.fn();
+      this.onConnectionChange = jest.fn();
+      this.onChatMessage = jest.fn();
+    }
+  }
+
+  return { Master };
+});
+
+jest.mock('koa-socket-2', () => {
+  class MockSocket {
+    id: string;
+    callbacks: Record<string, (...args: any[]) => any>;
+    emit: jest.Mock<any, any>;
+    broadcast: { emit: jest.Mock<any, any> };
+
+    constructor() {
+      this.id = 'id';
+      this.callbacks = {};
+      this.emit = jest.fn();
+      this.broadcast = { emit: jest.fn() };
+    }
+
+    async receive(type, ...args) {
+      await this.callbacks[type](args[0], args[1], args[2], args[3], args[4]);
+      return;
+    }
+
+    on(type, callback) {
+      this.callbacks[type] = callback;
+    }
+
+    to() {
+      return {
+        broadcast: this.broadcast,
+        emit: this.emit,
+      };
+    }
+
+    join() {}
+  }
+
+  class MockIO {
+    socket: MockSocket;
+    socketAdapter: any;
+
+    constructor() {
+      this.socket = new MockSocket();
+    }
+
+    adapter(socketAdapter) {
+      this.socketAdapter = socketAdapter;
+    }
+
+    attach(app) {
+      app.io = app._io = this;
+    }
+
+    of() {
+      return this;
+    }
+
+    on(type, callback) {
+      callback(this.socket);
+    }
+  }
+
+  return MockIO;
+});
+
+describe('basic', () => {
+  const auth = new Auth({ authenticateCredentials: () => true });
+  const app: any = { context: { auth } };
+  const games = [ProcessGameConfig({ seed: 0 })];
+  let clientInfo;
+  let roomInfo;
+
+  beforeEach(() => {
+    clientInfo = new Map();
+    roomInfo = new Map();
+    const transport = new SocketIOTestAdapter({ clientInfo, roomInfo });
+    transport.init(app, games);
+  });
+
+  test('is attached to app', () => {
+    expect(app.context.io).toBeDefined();
+  });
+});
+
+describe('socketAdapter', () => {
+  const auth = new Auth({ authenticateCredentials: () => true });
+  const app: any = { context: { auth } };
+  const games = [ProcessGameConfig({ seed: 0 })];
+
+  const socketAdapter = jest.fn();
+
+  beforeEach(() => {
+    const transport = new SocketIOTestAdapter({ socketAdapter });
+    transport.init(app, games);
+  });
+
+  test('socketAdapter is passed', () => {
+    expect(app.io.socketAdapter).toBe(socketAdapter);
+  });
+});
+
+describe('TransportAPI', () => {
+  let io;
+  let api;
+  const matchID = 'matchID';
+
+  beforeAll(() => {
+    const auth = new Auth({ authenticateCredentials: () => true });
+    const app: any = { context: { auth } };
+    const games = [ProcessGameConfig({ seed: 0 })];
+    const clientInfo = new Map();
+    const roomInfo = new Map();
+    const transport = new SocketIOTestAdapter({ clientInfo, roomInfo });
+    transport.init(app, games);
+    io = app.context.io;
+    const socket = io.socket;
+    const filterPlayerView = getFilterPlayerView(games[0]);
+    api = TransportAPI(
+      matchID,
+      socket,
+      filterPlayerView,
+      transport.getPubSub()
+    );
+  });
+
+  beforeEach(async () => {
+    io.socket.emit = jest.fn();
+    io.socket.id = '0';
+    const args0: SyncArgs = [matchID, '0', undefined];
+    await io.socket.receive('sync', ...args0);
+    io.socket.id = '1';
+    const args1: SyncArgs = [matchID, '1', undefined];
+    await io.socket.receive('sync', ...args1);
+  });
+
+  test('send', () => {
+    io.socket.id = '0';
+    api.send({ type: 'A', playerID: '0', args: [] });
+    expect(io.socket.emit).toHaveBeenCalledWith('A');
+  });
+
+  test('sendAll - function', () => {
+    api.sendAll({ type: 'A', args: [] });
+    expect(io.socket.emit).toHaveBeenCalledTimes(2);
+    expect(io.socket.emit).toHaveBeenCalledWith('A');
+  });
+});
+
+describe('sync / update', () => {
+  const auth = new Auth({ authenticateCredentials: () => true });
+  const app: any = { context: { auth } };
+  const games = [ProcessGameConfig({ seed: 0 })];
+  const transport = new SocketIOTestAdapter();
+  transport.init(app, games);
+  const io = app.context.io;
+
+  test('sync', () => {
+    io.socket.receive('sync', 'matchID', '0');
+    expect(error).not.toBeCalled();
+  });
+
+  test('update', () => {
+    io.socket.receive('update');
+    expect(error).not.toBeCalled();
+  });
+});
+
+describe('chat', () => {
+  const app: any = { context: {} };
+  const games = [ProcessGameConfig({ seed: 0 })];
+  const transport = new SocketIOTestAdapter();
+  transport.init(app, games);
+  const io = app.context.io;
+
+  test('chat message', async () => {
+    await io.socket.receive('chat', 'matchID', { message: 'foo' });
+    expect(error).not.toBeCalled();
+  });
+});
+
+describe('connect / disconnect', () => {
+  const auth = new Auth({ authenticateCredentials: () => true });
+  const app: any = { context: { auth } };
+  const games = [ProcessGameConfig({ seed: 0 })];
+  let clientInfo;
+  let roomInfo;
+  let io;
+
+  beforeAll(() => {
+    clientInfo = new Map();
+    roomInfo = new Map();
+    const transport = new SocketIOTestAdapter({ clientInfo, roomInfo });
+    transport.init(app, games);
+    io = app.context.io;
+  });
+
+  test('0 and 1 connect', async () => {
+    io.socket.id = '0';
+    const args0: SyncArgs = ['matchID', '0', undefined, 2];
+    await io.socket.receive('sync', ...args0);
+    io.socket.id = '1';
+    const args1: SyncArgs = ['matchID', '1', undefined, 2];
+    await io.socket.receive('sync', ...args1);
+
+    expect(clientInfo.get('0')).toMatchObject({
+      matchID: 'matchID',
+      playerID: '0',
+    });
+    expect(clientInfo.get('1')).toMatchObject({
+      matchID: 'matchID',
+      playerID: '1',
+    });
+  });
+
+  test('0 disconnects', async () => {
+    io.socket.id = '0';
+    await io.socket.receive('disconnect');
+
+    expect(clientInfo.get('0')).toBeUndefined();
+    expect(clientInfo.get('1')).toMatchObject({
+      matchID: 'matchID',
+      playerID: '1',
+    });
+    expect([...roomInfo.get('matchID')]).toEqual(['1']);
+  });
+
+  test('unknown player disconnects', async () => {
+    io.socket.id = 'unknown';
+    await io.socket.receive('disconnect');
+
+    expect(clientInfo.get('0')).toBeUndefined();
+    expect(clientInfo.get('1')).toMatchObject({
+      matchID: 'matchID',
+      playerID: '1',
+    });
+    expect([...roomInfo.get('matchID')]).toEqual(['1']);
+  });
+
+  test('1 disconnects', async () => {
+    io.socket.id = '1';
+    await io.socket.receive('disconnect');
+    expect([...clientInfo.keys()]).toHaveLength(0);
+    expect(roomInfo.get('matchID')).toBeUndefined();
+  });
+});

package/src/server/transport/socketio.ts

@@ -0,0 +1,279 @@
+/*
+ * Copyright 2018 The boardgame.io Authors
+ *
+ * Use of this source code is governed by a MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ */
+
+import type { CorsOptions } from 'cors';
+import IO from 'koa-socket-2';
+import type IOTypes from 'socket.io';
+import type { ServerOptions as HttpsOptions } from 'https';
+import PQueue from 'p-queue';
+import { Master } from '../../master/master';
+import type {
+  TransportAPI as MasterTransport,
+  TransportData,
+} from '../../master/master';
+import { getFilterPlayerView } from '../../master/filter-player-view';
+import type { Game, Server } from '../../types';
+import type { GenericPubSub } from './pubsub/generic-pub-sub';
+import type { IntermediateTransportData } from '../../master/master';
+import { InMemoryPubSub } from './pubsub/in-memory-pub-sub';
+
+const PING_TIMEOUT = 20 * 1e3;
+const PING_INTERVAL = 10 * 1e3;
+
+const emit = (socket: IOTypes.Socket, { type, args }: TransportData) => {
+  socket.emit(type, ...args);
+};
+
+function getPubSubChannelId(matchID: string): string {
+  return `MATCH-${matchID}`;
+}
+
+/**
+ * API that's exposed by SocketIO for the Master to send
+ * information to the clients.
+ */
+export const TransportAPI = (
+  matchID: string,
+  socket: IOTypes.Socket,
+  filterPlayerView: any,
+  pubSub: GenericPubSub<IntermediateTransportData>
+): MasterTransport => {
+  const send: MasterTransport['send'] = ({ playerID, ...data }) => {
+    emit(socket, filterPlayerView(playerID, data));
+  };
+
+  /**
+   * Send a message to all clients.
+   */
+  const sendAll: MasterTransport['sendAll'] = (payload) => {
+    pubSub.publish(getPubSubChannelId(matchID), payload);
+  };
+
+  return { send, sendAll };
+};
+
+export interface SocketOpts {
+  https?: HttpsOptions;
+  socketOpts?: IOTypes.ServerOptions;
+  socketAdapter?: any;
+  pubSub?: GenericPubSub<IntermediateTransportData>;
+}
+
+interface Client {
+  matchID: string;
+  playerID: string;
+  socket: IOTypes.Socket;
+  credentials: string | undefined;
+}
+
+/**
+ * Transport interface that uses socket.io
+ */
+export class SocketIO {
+  protected clientInfo: Map<string, Client>;
+  protected roomInfo: Map<string, Set<string>>;
+  protected perMatchQueue: Map<string, PQueue>;
+  private readonly https: HttpsOptions;
+  private readonly socketAdapter: any;
+  private readonly socketOpts: IOTypes.ServerOptions;
+  protected pubSub: GenericPubSub<IntermediateTransportData>;
+
+  constructor({ https, socketAdapter, socketOpts, pubSub }: SocketOpts = {}) {
+    this.clientInfo = new Map();
+    this.roomInfo = new Map();
+    this.perMatchQueue = new Map();
+    this.https = https;
+    this.socketAdapter = socketAdapter;
+    this.socketOpts = socketOpts;
+    this.pubSub = pubSub || new InMemoryPubSub();
+  }
+
+  /**
+   * Unregister client data for a socket.
+   */
+  private removeClient(socketID: string): void {
+    // Get client data for this socket ID.
+    const client = this.clientInfo.get(socketID);
+    if (!client) return;
+    // Remove client from list of connected sockets for this match.
+    const { matchID } = client;
+    const matchClients = this.roomInfo.get(matchID);
+    matchClients.delete(socketID);
+    // If the match is now empty, delete its promise queue & client ID list.
+    if (matchClients.size === 0) {
+      this.unsubscribePubSubChannel(matchID);
+      this.roomInfo.delete(matchID);
+      this.deleteMatchQueue(matchID);
+    }
+    // Remove client data from the client map.
+    this.clientInfo.delete(socketID);
+  }
+
+  /**
+   * Register client data for a socket.
+   */
+  private addClient(client: Client, game: Game): void {
+    const { matchID, socket } = client;
+    // Add client to list of connected sockets for this match.
+    let matchClients = this.roomInfo.get(matchID);
+    if (matchClients === undefined) {
+      this.subscribePubSubChannel(matchID, game);
+      matchClients = new Set<string>();
+      this.roomInfo.set(matchID, matchClients);
+    }
+    matchClients.add(socket.id);
+    // Register data for this socket in the client map.
+    this.clientInfo.set(socket.id, client);
+  }
+
+  private subscribePubSubChannel(matchID: string, game: Game) {
+    const filterPlayerView = getFilterPlayerView(game);
+    const broadcast = (payload: IntermediateTransportData) => {
+      this.roomInfo.get(matchID).forEach((clientID) => {
+        const client = this.clientInfo.get(clientID);
+        const data = filterPlayerView(client.playerID, payload);
+        emit(client.socket, data);
+      });
+    };
+
+    this.pubSub.subscribe(getPubSubChannelId(matchID), broadcast);
+  }
+
+  private unsubscribePubSubChannel(matchID: string) {
+    this.pubSub.unsubscribeAll(getPubSubChannelId(matchID));
+  }
+
+  init(
+    app: Server.App & { _io?: IOTypes.Server },
+    games: Game[],
+    origins: CorsOptions['origin'] = []
+  ) {
+    const io = new IO({
+      ioOptions: {
+        pingTimeout: PING_TIMEOUT,
+        pingInterval: PING_INTERVAL,
+        cors: {
+          origins,
+        },
+        ...this.socketOpts,
+      },
+    });
+
+    app.context.io = io;
+    io.attach(app, !!this.https, this.https);
+
+    if (this.socketAdapter) {
+      io.adapter(this.socketAdapter);
+    }
+
+    for (const game of games) {
+      const nsp = app._io.of(game.name);
+      const filterPlayerView = getFilterPlayerView(game);
+
+      nsp.on('connection', (socket: IOTypes.Socket) => {
+        socket.on('update', async (...args: Parameters<Master['onUpdate']>) => {
+          const [action, stateID, matchID, playerID] = args;
+          const master = new Master(
+            game,
+            app.context.db,
+            TransportAPI(matchID, socket, filterPlayerView, this.pubSub),
+            app.context.auth
+          );
+
+          const matchQueue = this.getMatchQueue(matchID);
+          await matchQueue.add(() =>
+            master.onUpdate(action, stateID, matchID, playerID)
+          );
+        });
+
+        socket.on('sync', async (...args: Parameters<Master['onSync']>) => {
+          const [matchID, playerID, credentials] = args;
+          socket.join(matchID);
+          this.removeClient(socket.id);
+          const requestingClient = { socket, matchID, playerID, credentials };
+          const transport = TransportAPI(
+            matchID,
+            socket,
+            filterPlayerView,
+            this.pubSub
+          );
+          const master = new Master(
+            game,
+            app.context.db,
+            transport,
+            app.context.auth
+          );
+
+          const syncResponse = await master.onSync(...args);
+          if (syncResponse && syncResponse.error === 'unauthorized') {
+            return;
+          }
+          this.addClient(requestingClient, game);
+          await master.onConnectionChange(matchID, playerID, credentials, true);
+        });
+
+        socket.on('disconnect', async () => {
+          const client = this.clientInfo.get(socket.id);
+          this.removeClient(socket.id);
+          if (client) {
+            const { matchID, playerID, credentials } = client;
+            const master = new Master(
+              game,
+              app.context.db,
+              TransportAPI(matchID, socket, filterPlayerView, this.pubSub),
+              app.context.auth
+            );
+            await master.onConnectionChange(
+              matchID,
+              playerID,
+              credentials,
+              false
+            );
+          }
+        });
+
+        socket.on(
+          'chat',
+          async (...args: Parameters<Master['onChatMessage']>) => {
+            const [matchID] = args;
+            const master = new Master(
+              game,
+              app.context.db,
+              TransportAPI(matchID, socket, filterPlayerView, this.pubSub),
+              app.context.auth
+            );
+            master.onChatMessage(...args);
+          }
+        );
+      });
+    }
+  }
+
+  /**
+   * Create a PQueue for a given matchID if none exists and return it.
+   * @param matchID
+   * @returns
+   */
+  getMatchQueue(matchID: string): PQueue {
+    if (!this.perMatchQueue.has(matchID)) {
+      // PQueue should process only one action at a time.
+      this.perMatchQueue.set(matchID, new PQueue({ concurrency: 1 }));
+    }
+    return this.perMatchQueue.get(matchID);
+  }
+
+  /**
+   * Delete a PQueue for a given matchID.
+   * @param matchID
+   */
+  deleteMatchQueue(matchID: string): void {
+    this.perMatchQueue.delete(matchID);
+  }
+}
+
+export { Master };

package/src/server/util.ts

@@ -0,0 +1,85 @@
+import { InitializeGame } from '../core/initialize';
+import type { Server, State, Game } from '../types';
+
+/**
+ * Creates a new match metadata object.
+ */
+export const createMetadata = ({
+  game,
+  unlisted,
+  setupData,
+  numPlayers,
+}: {
+  game: Game;
+  numPlayers: number;
+  setupData?: any;
+  unlisted?: boolean;
+}): Server.MatchData => {
+  const metadata: Server.MatchData = {
+    gameName: game.name,
+    unlisted: !!unlisted,
+    players: {},
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  };
+
+  if (setupData !== undefined) metadata.setupData = setupData;
+
+  for (let playerIndex = 0; playerIndex < numPlayers; playerIndex++) {
+    metadata.players[playerIndex] = { id: playerIndex };
+  }
+
+  return metadata;
+};
+
+/**
+ * Creates initial state and metadata for a new match.
+ * If the provided `setupData` doesn’t pass the game’s validation,
+ * an error object is returned instead.
+ */
+export const createMatch = ({
+  game,
+  numPlayers,
+  setupData,
+  unlisted,
+}: {
+  game: Game;
+  numPlayers: number;
+  setupData: any;
+  unlisted: boolean;
+}):
+  | { metadata: Server.MatchData; initialState: State }
+  | { setupDataError: string } => {
+  if (!numPlayers || typeof numPlayers !== 'number') numPlayers = 2;
+
+  const setupDataError =
+    game.validateSetupData && game.validateSetupData(setupData, numPlayers);
+  if (setupDataError !== undefined) return { setupDataError };
+
+  const metadata = createMetadata({ game, numPlayers, setupData, unlisted });
+  const initialState = InitializeGame({ game, numPlayers, setupData });
+
+  return { metadata, initialState };
+};
+
+/**
+ * Given players, returns the count of players.
+ */
+export const getNumPlayers = (players: Server.MatchData['players']): number =>
+  Object.keys(players).length;
+
+/**
+ * Given players, tries to find the ID of the first player that can be joined.
+ * Returns `undefined` if there’s no available ID.
+ */
+export const getFirstAvailablePlayerID = (
+  players: Server.MatchData['players']
+): string | undefined => {
+  const numPlayers = getNumPlayers(players);
+  // Try to get the first index available
+  for (let i = 0; i < numPlayers; i++) {
+    if (typeof players[i].name === 'undefined' || players[i].name === null) {
+      return String(i);
+    }
+  }
+};

package/src/testing/mock-random.test.ts

@@ -0,0 +1,45 @@
+import { Client } from '../client/client';
+import type { Game } from '../types';
+import { MockRandom } from './mock-random';
+
+test('it creates a plugin object', () => {
+  const plugin = MockRandom();
+  expect(plugin).toEqual({
+    name: 'random',
+    noClient: expect.any(Function),
+    api: expect.any(Function),
+    setup: expect.any(Function),
+    playerView: expect.any(Function),
+  });
+});
+
+test('it can override random API methods', () => {
+  const game: Game<{ roll: number }> = {
+    moves: {
+      roll: ({ G, random }) => {
+        G.roll = random.D6();
+      },
+    },
+    plugins: [MockRandom({ D6: () => 1 })],
+  };
+
+  const client = Client({ game });
+  client.moves.roll();
+  expect(client.getState().G.roll).toBe(1);
+});
+
+test('it can use non-overridden API methods', () => {
+  const game: Game<{ roll: number }> = {
+    moves: {
+      roll: ({ G, random }) => {
+        G.roll = random.D6();
+      },
+    },
+    plugins: [MockRandom({ D10: () => 1 })],
+    seed: 0,
+  };
+
+  const client = Client({ game });
+  client.moves.roll();
+  expect(client.getState().G.roll).toMatchInlineSnapshot(`4`);
+});