@mnbroatch/boardgame.io 0.0.1

package/src/server/index.test.ts

@@ -0,0 +1,265 @@
+/*
+ * Copyright 2017 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 request from 'supertest';
+
+import { Server, createServerRunConfig, getPortFromServer } from '.';
+import type { KoaServer } from '.';
+import type { SocketIO } from './transport/socketio';
+import type { Game, StorageAPI } from '../types';
+
+const game: Game = { seed: 0 };
+
+const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+beforeEach(warn.mockReset);
+afterAll(warn.mockRestore);
+
+jest.mock('../core/logger', () => ({
+  info: () => {},
+  error: () => {},
+}));
+
+jest.mock('koa-socket-2', () => {
+  class MockSocket {
+    on() {}
+  }
+
+  return class {
+    constructor() {
+      (this as any).socket = new MockSocket();
+    }
+    attach(app) {
+      app.io = app._io = this;
+    }
+    of() {
+      return this;
+    }
+    on(type, callback) {
+      callback((this as any).socket);
+    }
+    adapter() {
+      return this;
+    }
+  };
+});
+
+describe('new', () => {
+  test('custom db implementation', () => {
+    const game: Game = {};
+    const db = {} as StorageAPI.Sync;
+    const server = Server({ games: [game], db });
+    expect(server.db).toBe(db);
+  });
+
+  test('custom transport implementation', () => {
+    const game: Game = {};
+    const transport = { init: jest.fn() } as unknown as SocketIO;
+    Server({ games: [game], transport });
+    expect(transport.init).toBeCalled();
+  });
+
+  test('custom auth implementation', () => {
+    const game: Game = {};
+    const authenticateCredentials = () => true;
+    const server = Server({ games: [game], authenticateCredentials });
+    expect(server.db).not.toBeNull();
+  });
+
+  test('logs a warning if origins not set', () => {
+    Server({ games: [{}] });
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining('Server `origins` option is not set.')
+    );
+  });
+
+  test('does not log a warning if origins set', () => {
+    Server({ games: [{}], origins: [] });
+    expect(warn).not.toHaveBeenCalled();
+  });
+});
+
+describe('run', () => {
+  let server: ReturnType<typeof Server> | null;
+  let runningServer: { appServer: KoaServer; apiServer?: KoaServer } | null;
+
+  beforeEach(() => {
+    server = null;
+    runningServer = null;
+  });
+
+  afterEach(() => {
+    if (server && runningServer) {
+      const { apiServer, appServer } = runningServer;
+      server.kill({ apiServer, appServer });
+    }
+  });
+
+  test('single server running', async () => {
+    server = Server({ games: [game] });
+    runningServer = await server.run(undefined);
+
+    expect(server).not.toBeUndefined();
+    expect(runningServer.appServer).not.toBeUndefined();
+    expect(runningServer.apiServer).toBeUndefined();
+  });
+
+  test('multiple servers running', async () => {
+    server = Server({ games: [game] });
+    runningServer = await server.run({
+      port: 57890,
+      lobbyConfig: { apiPort: 57891 },
+    });
+
+    expect(server).not.toBeUndefined();
+    expect(runningServer.appServer).not.toBeUndefined();
+    expect(runningServer.apiServer).not.toBeUndefined();
+  });
+
+  test('calls app callback', async () => {
+    const callback = jest.fn();
+    server = Server({ games: [game] });
+    runningServer = await server.run({ callback });
+    expect(callback).toHaveBeenCalled();
+  });
+
+  test('calls API callback', async () => {
+    const apiCallback = jest.fn();
+    server = Server({ games: [game] });
+    runningServer = await server.run({
+      lobbyConfig: { apiPort: 9999, apiCallback },
+    });
+    expect(apiCallback).toHaveBeenCalled();
+  });
+
+  test('runs route middleware', async () => {
+    const usedMiddleware = jest.fn(async (_ctx, next) => {
+      await next;
+    });
+    const unusedMiddleware = jest.fn(async (_ctx, next) => {
+      await next;
+    });
+    server = Server({ games: [game] });
+    server.router.use('/games', usedMiddleware);
+    server.router.use('/games/unused', unusedMiddleware);
+    runningServer = await server.run(8888);
+
+    await request(runningServer.appServer).get('/games');
+    expect(usedMiddleware).toHaveBeenCalled();
+    expect(unusedMiddleware).not.toHaveBeenCalled();
+  });
+});
+
+describe('kill', () => {
+  test('call close on both servers', async () => {
+    const apiServer = {
+      close: jest.fn(),
+    } as unknown as KoaServer;
+    const appServer = {
+      close: jest.fn(),
+    } as unknown as KoaServer;
+    const server = Server({ games: [game] });
+
+    server.kill({ appServer, apiServer });
+
+    expect(apiServer.close).toBeCalled();
+    expect(appServer.close).toBeCalled();
+  });
+
+  test('do not fail if api server is not defined', async () => {
+    const appServer = {
+      close: jest.fn(),
+    } as unknown as KoaServer;
+    const server = Server({ games: [game] });
+
+    expect(() => server.kill({ appServer })).not.toThrowError();
+    expect(appServer.close).toBeCalled();
+  });
+});
+
+describe('createServerRunConfig', () => {
+  // TODO use data-driven-test here after upgrading to Jest 23+.
+  test('should return valid config with different server run arguments', () => {
+    const mockCallback = () => {};
+    const mockApiCallback = () => {};
+
+    expect(createServerRunConfig(8000)).toEqual({
+      port: 8000,
+      callback: undefined,
+    });
+    expect(createServerRunConfig(8000, mockCallback)).toEqual({
+      port: 8000,
+      callback: mockCallback,
+    });
+
+    expect(createServerRunConfig({})).toEqual({
+      port: undefined,
+      callback: undefined,
+    });
+    expect(createServerRunConfig({ port: 1234 })).toEqual({
+      port: 1234,
+      callback: undefined,
+    });
+    expect(
+      createServerRunConfig({ port: 1234, callback: mockCallback })
+    ).toEqual({
+      port: 1234,
+      callback: mockCallback,
+    });
+
+    expect(
+      createServerRunConfig({ port: 1234, lobbyConfig: { apiPort: 5467 } })
+    ).toEqual({
+      port: 1234,
+      callback: undefined,
+      lobbyConfig: { apiPort: 5467 },
+    });
+    expect(
+      createServerRunConfig({
+        port: 1234,
+        callback: mockCallback,
+        lobbyConfig: {
+          apiPort: 5467,
+          apiCallback: mockApiCallback,
+        },
+      })
+    ).toEqual({
+      port: 1234,
+      callback: mockCallback,
+      lobbyConfig: {
+        apiPort: 5467,
+        apiCallback: mockApiCallback,
+      },
+    });
+  });
+});
+
+describe('getPortFromServer', () => {
+  test('returns null', () => {
+    expect(
+      getPortFromServer({
+        address: () => null,
+      } as KoaServer)
+    ).toBeNull();
+  });
+
+  test('returns port', () => {
+    expect(
+      getPortFromServer({
+        address: () => '8000',
+      } as KoaServer)
+    ).toBe('8000');
+  });
+
+  test('returns port from address object', () => {
+    expect(
+      getPortFromServer({
+        address: () => ({ port: '8000' }),
+      } as unknown as KoaServer)
+    ).toBe('8000');
+  });
+});

package/src/server/index.ts

@@ -0,0 +1,175 @@
+/*
+ * Copyright 2017 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 Koa from 'koa';
+import Router from '@koa/router';
+import type { CorsOptions } from 'cors';
+
+import { configureRouter, configureApp } from './api';
+import { DBFromEnv } from './db';
+import { ProcessGameConfig } from '../core/game';
+import * as logger from '../core/logger';
+import { Auth } from './auth';
+import { SocketIO } from './transport/socketio';
+import type { Server as ServerTypes, Game, StorageAPI } from '../types';
+
+export type KoaServer = ReturnType<Koa['listen']>;
+export { configureRouter };
+export { configureApp };
+
+interface ServerConfig {
+  port?: number;
+  callback?: () => void;
+  lobbyConfig?: {
+    apiPort: number;
+    apiCallback?: () => void;
+  };
+}
+
+interface HttpsOptions {
+  cert: string;
+  key: string;
+}
+
+/**
+ * Build config object from server run arguments.
+ */
+export const createServerRunConfig = (
+  portOrConfig: number | ServerConfig,
+  callback?: () => void
+): ServerConfig =>
+  portOrConfig && typeof portOrConfig === 'object'
+    ? {
+        ...portOrConfig,
+        callback: portOrConfig.callback || callback,
+      }
+    : { port: portOrConfig as number, callback };
+
+export const getPortFromServer = (
+  server: KoaServer
+): string | number | null => {
+  const address = server.address();
+  if (typeof address === 'string') return address;
+  if (address === null) return null;
+  return address.port;
+};
+
+interface ServerOpts {
+  games: Game[];
+  origins?: CorsOptions['origin'];
+  apiOrigins?: CorsOptions['origin'];
+  db?: StorageAPI.Async | StorageAPI.Sync;
+  transport?: SocketIO;
+  uuid?: () => string;
+  authenticateCredentials?: ServerTypes.AuthenticateCredentials;
+  generateCredentials?: ServerTypes.GenerateCredentials;
+  https?: HttpsOptions;
+}
+
+/**
+ * Instantiate a game server.
+ *
+ * @param games - The games that this server will handle.
+ * @param db - The interface with the database.
+ * @param transport - The interface with the clients.
+ * @param authenticateCredentials - Function to test player credentials.
+ * @param origins - Allowed origins to use this server, e.g. `['http://localhost:3000']`.
+ * @param apiOrigins - Allowed origins to use the Lobby API, defaults to `origins`.
+ * @param generateCredentials - Method for API to generate player credentials.
+ * @param https - HTTPS configuration options passed through to the TLS module.
+ * @param lobbyConfig - Configuration options for the Lobby API server.
+ */
+export function Server({
+  games,
+  db,
+  transport,
+  https,
+  uuid,
+  origins,
+  apiOrigins = origins,
+  generateCredentials = uuid,
+  authenticateCredentials,
+}: ServerOpts) {
+  const app: ServerTypes.App = new Koa();
+
+  games = games.map((game) => ProcessGameConfig(game));
+
+  if (db === undefined) {
+    db = DBFromEnv();
+  }
+  app.context.db = db;
+
+  const auth = new Auth({ authenticateCredentials, generateCredentials });
+  app.context.auth = auth;
+
+  if (transport === undefined) {
+    transport = new SocketIO({ https });
+  }
+  if (origins === undefined) {
+    console.warn(
+      'Server `origins` option is not set.\n' +
+        'Since boardgame.io@0.45, CORS is not enabled by default and you must ' +
+        'explicitly set the origins that are allowed to connect to the server.\n' +
+        'See https://boardgame.io/documentation/#/api/Server'
+    );
+  }
+  transport.init(app, games, origins);
+
+  const router = new Router<any, ServerTypes.AppCtx>();
+
+  return {
+    app,
+    db,
+    auth,
+    router,
+    transport,
+
+    run: async (portOrConfig: number | ServerConfig, callback?: () => void) => {
+      const serverRunConfig = createServerRunConfig(portOrConfig, callback);
+      configureRouter({ router, db, games, uuid, auth });
+
+      // DB
+      await db.connect();
+
+      // Lobby API
+      const lobbyConfig = serverRunConfig.lobbyConfig;
+      let apiServer: KoaServer | undefined;
+      if (!lobbyConfig || !lobbyConfig.apiPort) {
+        configureApp(app, router, apiOrigins);
+      } else {
+        // Run API in a separate Koa app.
+        const api: ServerTypes.App = new Koa();
+        api.context.db = db;
+        api.context.auth = auth;
+        configureApp(api, router, apiOrigins);
+        await new Promise((resolve) => {
+          apiServer = api.listen(lobbyConfig.apiPort, resolve);
+        });
+        if (lobbyConfig.apiCallback) lobbyConfig.apiCallback();
+        logger.info(`API serving on ${getPortFromServer(apiServer)}...`);
+      }
+
+      // Run Game Server (+ API, if necessary).
+      let appServer: KoaServer;
+      await new Promise((resolve) => {
+        appServer = app.listen(serverRunConfig.port, resolve);
+      });
+      if (serverRunConfig.callback) serverRunConfig.callback();
+      logger.info(`App serving on ${getPortFromServer(appServer)}...`);
+
+      return { apiServer, appServer };
+    },
+
+    kill: (servers: { apiServer?: KoaServer; appServer: KoaServer }) => {
+      if (servers.apiServer) {
+        servers.apiServer.close();
+      }
+      servers.appServer.close();
+    },
+  };
+}

package/src/server/transport/pubsub/generic-pub-sub.ts

@@ -0,0 +1,11 @@
+/** Generic interface for pub-subs.  */
+export interface GenericPubSub<T> {
+  // Publish an event for a match.
+  publish(channelId: string, payload: T);
+
+  // Subscribes to events related to a single match.
+  subscribe(channelId: string, callback: (payload: T) => void): void;
+
+  // Cleans up subscription for a given channel.
+  unsubscribeAll(channelId: string);
+}

package/src/server/transport/pubsub/in-memory-pub-sub.test.ts

@@ -0,0 +1,47 @@
+import { InMemoryPubSub } from './in-memory-pub-sub';
+
+const CHANNEL_FOO = 'foo';
+
+describe('in-memory pubsub', () => {
+  it('should receive message from subscription', () => {
+    const pubSub = new InMemoryPubSub<string>();
+    const callback = jest.fn();
+    pubSub.subscribe(CHANNEL_FOO, callback);
+    const payload = 'hello world';
+    pubSub.publish(CHANNEL_FOO, payload);
+    expect(callback).toHaveBeenCalledWith(payload);
+  });
+
+  it('should receive message from two subscriptions', () => {
+    const pubSub = new InMemoryPubSub<string>();
+    const callback1 = jest.fn();
+    const callback2 = jest.fn();
+    pubSub.subscribe(CHANNEL_FOO, callback1);
+    pubSub.subscribe(CHANNEL_FOO, callback2);
+    const payload = 'hello world';
+    pubSub.publish(CHANNEL_FOO, payload);
+    expect(callback1).toHaveBeenCalledWith(payload);
+    expect(callback2).toHaveBeenCalledWith(payload);
+  });
+
+  it('should unsubscribe', () => {
+    const pubSub = new InMemoryPubSub<string>();
+    const callback = jest.fn();
+    pubSub.subscribe(CHANNEL_FOO, callback);
+    pubSub.unsubscribeAll(CHANNEL_FOO);
+    const payload = 'hello world';
+    pubSub.publish(CHANNEL_FOO, payload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+
+  it('should ignore extra unsubscribe', () => {
+    const pubSub = new InMemoryPubSub<string>();
+    const callback = jest.fn();
+    pubSub.subscribe(CHANNEL_FOO, callback);
+    pubSub.unsubscribeAll(CHANNEL_FOO);
+    pubSub.unsubscribeAll(CHANNEL_FOO); // do nothing
+    const payload = 'hello world';
+    pubSub.publish(CHANNEL_FOO, payload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/server/transport/pubsub/in-memory-pub-sub.ts

@@ -0,0 +1,28 @@
+import type { GenericPubSub } from './generic-pub-sub';
+
+export class InMemoryPubSub<T> implements GenericPubSub<T> {
+  callbacks: Map<string, ((payload: T) => void)[]> = new Map();
+
+  publish(channelId: string, payload: T) {
+    if (!this.callbacks.has(channelId)) {
+      return;
+    }
+    const allCallbacks = this.callbacks.get(channelId);
+    for (const callback of allCallbacks) {
+      callback(payload);
+    }
+  }
+
+  subscribe(channelId: string, callback: (payload: T) => void): void {
+    if (!this.callbacks.has(channelId)) {
+      this.callbacks.set(channelId, []);
+    }
+    this.callbacks.get(channelId).push(callback);
+  }
+
+  unsubscribeAll(channelId: string) {
+    if (this.callbacks.has(channelId)) {
+      this.callbacks.delete(channelId);
+    }
+  }
+}