@mnbroatch/boardgame.io 0.0.1

package/src/server/db/flatfile.ts

@@ -0,0 +1,228 @@
+import * as StorageAPI from './base';
+import type { State, Server, LogEntry } from '../../types';
+
+/*
+ * 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.
+ */
+
+interface InitOptions {
+  dir: string;
+  logging?: boolean;
+  ttl?: boolean;
+}
+
+/**
+ * FlatFile data storage.
+ */
+export class FlatFile extends StorageAPI.Async {
+  private games: {
+    init: (opts: InitOptions) => Promise<void>;
+    setItem: (id: string, value: any) => Promise<any>;
+    getItem: (id: string) => Promise<State | Server.MatchData | LogEntry[]>;
+    removeItem: (id: string) => Promise<void>;
+    clear: () => void;
+    keys: () => Promise<string[]>;
+  };
+  private dir: string;
+  private logging?: boolean;
+  private ttl?: boolean;
+  private fileQueues: { [key: string]: Promise<any> };
+
+  constructor({ dir, logging, ttl }: InitOptions) {
+    super();
+    this.games = require('node-persist');
+    this.dir = dir;
+    this.logging = logging || false;
+    this.ttl = ttl || false;
+    this.fileQueues = {};
+  }
+
+  private async chainRequest(
+    key: string,
+    request: () => Promise<any>
+  ): Promise<any> {
+    if (!(key in this.fileQueues)) this.fileQueues[key] = Promise.resolve();
+
+    this.fileQueues[key] = this.fileQueues[key].then(request, request);
+    return this.fileQueues[key];
+  }
+
+  private async getItem<T extends any = any>(key: string): Promise<T> {
+    return this.chainRequest(key, () => this.games.getItem(key));
+  }
+
+  private async setItem<T extends any = any>(
+    key: string,
+    value: T
+  ): Promise<any> {
+    return this.chainRequest(key, () => this.games.setItem(key, value));
+  }
+
+  private async removeItem(key: string): Promise<void> {
+    return this.chainRequest(key, () => this.games.removeItem(key));
+  }
+
+  async connect() {
+    await this.games.init({
+      dir: this.dir,
+      logging: this.logging,
+      ttl: this.ttl,
+    });
+    return;
+  }
+
+  /**
+   * Create new match.
+   *
+   * @param matchID
+   * @param opts
+   * @override
+   */
+  async createMatch(
+    matchID: string,
+    opts: StorageAPI.CreateMatchOpts
+  ): Promise<void> {
+    // Store initial state separately for easy retrieval later.
+    const key = InitialStateKey(matchID);
+
+    await this.setItem(key, opts.initialState);
+    await this.setState(matchID, opts.initialState);
+    await this.setMetadata(matchID, opts.metadata);
+  }
+
+  async fetch<O extends StorageAPI.FetchOpts>(
+    matchID: string,
+    opts: O
+  ): Promise<StorageAPI.FetchResult<O>> {
+    const result = {} as StorageAPI.FetchFields;
+
+    if (opts.state) {
+      result.state = (await this.getItem(matchID)) as State;
+    }
+
+    if (opts.metadata) {
+      const key = MetadataKey(matchID);
+      result.metadata = (await this.getItem(key)) as Server.MatchData;
+    }
+
+    if (opts.log) {
+      const key = LogKey(matchID);
+      result.log = (await this.getItem(key)) as LogEntry[];
+    }
+
+    if (opts.initialState) {
+      const key = InitialStateKey(matchID);
+      result.initialState = (await this.getItem(key)) as State;
+    }
+
+    return result as StorageAPI.FetchResult<O>;
+  }
+
+  async clear() {
+    return this.games.clear();
+  }
+
+  async setState(id: string, state: State, deltalog?: LogEntry[]) {
+    if (deltalog && deltalog.length > 0) {
+      const key = LogKey(id);
+      const log: LogEntry[] = ((await this.getItem(key)) as LogEntry[]) || [];
+
+      await this.setItem(key, [...log, ...deltalog]);
+    }
+
+    return await this.setItem(id, state);
+  }
+
+  async setMetadata(id: string, metadata: Server.MatchData): Promise<void> {
+    const key = MetadataKey(id);
+
+    return await this.setItem(key, metadata);
+  }
+
+  async wipe(id: string) {
+    const keys = await this.games.keys();
+    if (!keys.includes(id)) return;
+
+    await this.removeItem(id);
+    await this.removeItem(InitialStateKey(id));
+    await this.removeItem(LogKey(id));
+    await this.removeItem(MetadataKey(id));
+  }
+
+  /**
+   * List matches IDs.
+   *
+   * @param opts
+   * @override
+   */
+  async listMatches(opts?: StorageAPI.ListMatchesOpts): Promise<string[]> {
+    const keys = await this.games.keys();
+    const suffix = ':metadata';
+
+    const arr = await Promise.all(
+      keys.map(async (k) => {
+        if (!k.endsWith(suffix)) {
+          return false;
+        }
+
+        const matchID = k.slice(0, k.length - suffix.length);
+
+        if (!opts) {
+          return matchID;
+        }
+
+        const game = await this.fetch(matchID, {
+          state: true,
+          metadata: true,
+        });
+
+        if (opts.gameName && opts.gameName !== game.metadata.gameName) {
+          return false;
+        }
+
+        if (opts.where !== undefined) {
+          if (typeof opts.where.isGameover !== 'undefined') {
+            const isGameover = typeof game.metadata.gameover !== 'undefined';
+            if (isGameover !== opts.where.isGameover) {
+              return false;
+            }
+          }
+
+          if (
+            typeof opts.where.updatedBefore !== 'undefined' &&
+            game.metadata.updatedAt >= opts.where.updatedBefore
+          ) {
+            return false;
+          }
+
+          if (
+            typeof opts.where.updatedAfter !== 'undefined' &&
+            game.metadata.updatedAt <= opts.where.updatedAfter
+          ) {
+            return false;
+          }
+        }
+
+        return matchID;
+      })
+    );
+
+    return arr.filter((r): r is string => typeof r === 'string');
+  }
+}
+
+function InitialStateKey(matchID: string) {
+  return `${matchID}:initial`;
+}
+
+function MetadataKey(matchID: string) {
+  return `${matchID}:metadata`;
+}
+
+function LogKey(matchID: string) {
+  return `${matchID}:log`;
+}

package/src/server/db/index.test.ts

@@ -0,0 +1,8 @@
+import { DBFromEnv, FlatFile } from '.';
+
+test('FLATFILE_DIR', () => {
+  process.env.FLATFILE_DIR = 'test';
+  const db = DBFromEnv();
+  expect(db).toBeInstanceOf(FlatFile);
+  delete process.env.FLATFILE_DIR;
+});

package/src/server/db/index.ts

@@ -0,0 +1,12 @@
+import { InMemory } from './inmemory';
+import { FlatFile } from './flatfile';
+
+const DBFromEnv = () => {
+  return process.env.FLATFILE_DIR
+    ? new FlatFile({
+        dir: process.env.FLATFILE_DIR,
+      })
+    : new InMemory();
+};
+
+export { InMemory, FlatFile, DBFromEnv };

package/src/server/db/inmemory.test.ts

@@ -0,0 +1,143 @@
+/*
+ * 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 { InMemory } from './inmemory';
+import type { State, Server } from '../../types';
+
+describe('InMemory', () => {
+  let db: InMemory;
+
+  beforeAll(() => {
+    db = new InMemory();
+    db.connect();
+  });
+
+  // Must return undefined when no game exists.
+  test('must return undefined when no game exists', () => {
+    const { state } = db.fetch('matchID', { state: true });
+    expect(state).toEqual(undefined);
+  });
+
+  test('createMatch', () => {
+    const stateEntry: unknown = { a: 1 };
+
+    // Create match.
+    db.createMatch('matchID', {
+      metadata: {
+        gameName: 'tic-tac-toe',
+        updatedAt: new Date(2020, 1).getTime(),
+      } as Server.MatchData,
+      initialState: stateEntry as State,
+    });
+
+    // Must return created game.
+    const { state } = db.fetch('matchID', { state: true });
+    expect(state).toEqual(stateEntry);
+
+    // Fetch initial state.
+    const { initialState } = db.fetch('matchID', { initialState: true });
+    expect(initialState).toEqual(stateEntry);
+  });
+
+  describe('listMatches', () => {
+    test('filter by gameName', () => {
+      let keys = db.listMatches();
+      expect(keys).toEqual(['matchID']);
+      keys = db.listMatches({ gameName: 'tic-tac-toe' });
+      expect(keys).toEqual(['matchID']);
+      keys = db.listMatches({ gameName: 'chess' });
+      expect(keys).toEqual([]);
+    });
+
+    test('filter by isGameover', () => {
+      const stateEntry: unknown = { a: 1 };
+      db.createMatch('matchID2', {
+        metadata: {
+          gameName: 'tic-tac-toe',
+          gameover: 'gameover',
+          updatedAt: new Date(2020, 3).getTime(),
+        } as Server.MatchData,
+        initialState: stateEntry as State,
+      });
+
+      let keys = db.listMatches({});
+      expect(keys).toEqual(['matchID', 'matchID2']);
+      keys = db.listMatches({ where: { isGameover: true } });
+      expect(keys).toEqual(['matchID2']);
+      keys = db.listMatches({ where: { isGameover: false } });
+      expect(keys).toEqual(['matchID']);
+    });
+
+    test('filter by updatedBefore', () => {
+      const stateEntry: unknown = { a: 1 };
+      db.createMatch('matchID3', {
+        metadata: {
+          gameName: 'tic-tac-toe',
+          updatedAt: new Date(2020, 5).getTime(),
+        } as Server.MatchData,
+        initialState: stateEntry as State,
+      });
+      const timestamp = new Date(2020, 4);
+
+      let keys = db.listMatches({});
+      expect(keys).toEqual(['matchID', 'matchID2', 'matchID3']);
+      keys = db.listMatches({ where: { updatedBefore: timestamp.getTime() } });
+      expect(keys).toEqual(['matchID', 'matchID2']);
+    });
+
+    test('filter by updatedAfter', () => {
+      const timestamp = new Date(2020, 4);
+
+      let keys = db.listMatches({});
+      expect(keys).toEqual(['matchID', 'matchID2', 'matchID3']);
+      keys = db.listMatches({ where: { updatedAfter: timestamp.getTime() } });
+      expect(keys).toEqual(['matchID3']);
+    });
+
+    test('filter combined', () => {
+      const timestamp = new Date(2020, 4);
+      const timestamp2 = new Date(2020, 2, 15);
+      let keys = db.listMatches({
+        gameName: 'chess',
+        where: { isGameover: true },
+      });
+      expect(keys).toEqual([]);
+      keys = db.listMatches({
+        where: { isGameover: true, updatedBefore: timestamp.getTime() },
+      });
+      expect(keys).toEqual(['matchID2']);
+      keys = db.listMatches({
+        where: { isGameover: false, updatedBefore: timestamp.getTime() },
+      });
+      expect(keys).toEqual(['matchID']);
+      keys = db.listMatches({
+        where: { isGameover: true, updatedAfter: timestamp.getTime() },
+      });
+      expect(keys).toEqual([]);
+      keys = db.listMatches({
+        where: { isGameover: false, updatedAfter: timestamp.getTime() },
+      });
+      expect(keys).toEqual(['matchID3']);
+      keys = db.listMatches({
+        where: {
+          updatedBefore: timestamp.getTime(),
+          updatedAfter: timestamp2.getTime(),
+        },
+      });
+      expect(keys).toEqual(['matchID2']);
+    });
+  });
+
+  test('remove', () => {
+    // Must remove game from DB
+    db.wipe('matchID');
+    expect(db.fetch('matchID', { state: true })).toEqual({});
+    // Shall not return error
+    db.wipe('matchID');
+  });
+});

package/src/server/db/inmemory.ts

@@ -0,0 +1,143 @@
+import type { State, Server, LogEntry } from '../../types';
+import * as StorageAPI from './base';
+
+/*
+ * 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.
+ */
+
+/**
+ * InMemory data storage.
+ */
+export class InMemory extends StorageAPI.Sync {
+  protected state: Map<string, State>;
+  protected initial: Map<string, State>;
+  protected metadata: Map<string, Server.MatchData>;
+  protected log: Map<string, LogEntry[]>;
+
+  /**
+   * Creates a new InMemory storage.
+   */
+  constructor() {
+    super();
+    this.state = new Map();
+    this.initial = new Map();
+    this.metadata = new Map();
+    this.log = new Map();
+  }
+
+  /**
+   * Create a new match.
+   *
+   * @override
+   */
+  createMatch(matchID: string, opts: StorageAPI.CreateMatchOpts) {
+    this.initial.set(matchID, opts.initialState);
+    this.setState(matchID, opts.initialState);
+    this.setMetadata(matchID, opts.metadata);
+  }
+
+  /**
+   * Write the match metadata to the in-memory object.
+   */
+  setMetadata(matchID: string, metadata: Server.MatchData) {
+    this.metadata.set(matchID, metadata);
+  }
+
+  /**
+   * Write the match state to the in-memory object.
+   */
+  setState(matchID: string, state: State, deltalog?: LogEntry[]): void {
+    if (deltalog && deltalog.length > 0) {
+      const log = this.log.get(matchID) || [];
+      this.log.set(matchID, [...log, ...deltalog]);
+    }
+    this.state.set(matchID, state);
+  }
+
+  /**
+   * Fetches state for a particular matchID.
+   */
+  fetch<O extends StorageAPI.FetchOpts>(
+    matchID: string,
+    opts: O
+  ): StorageAPI.FetchResult<O> {
+    const result = {} as StorageAPI.FetchFields;
+
+    if (opts.state) {
+      result.state = this.state.get(matchID);
+    }
+
+    if (opts.metadata) {
+      result.metadata = this.metadata.get(matchID);
+    }
+
+    if (opts.log) {
+      result.log = this.log.get(matchID) || [];
+    }
+
+    if (opts.initialState) {
+      result.initialState = this.initial.get(matchID);
+    }
+
+    return result as StorageAPI.FetchResult<O>;
+  }
+
+  /**
+   * Remove the match state from the in-memory object.
+   */
+  wipe(matchID: string) {
+    this.state.delete(matchID);
+    this.metadata.delete(matchID);
+  }
+
+  /**
+   * Return all keys.
+   *
+   * @override
+   */
+  listMatches(opts?: StorageAPI.ListMatchesOpts): string[] {
+    return [...this.metadata.entries()]
+      .filter(([, metadata]) => {
+        if (!opts) {
+          return true;
+        }
+
+        if (
+          opts.gameName !== undefined &&
+          metadata.gameName !== opts.gameName
+        ) {
+          return false;
+        }
+
+        if (opts.where !== undefined) {
+          if (opts.where.isGameover !== undefined) {
+            const isGameover = metadata.gameover !== undefined;
+            if (isGameover !== opts.where.isGameover) {
+              return false;
+            }
+          }
+
+          if (
+            opts.where.updatedBefore !== undefined &&
+            metadata.updatedAt >= opts.where.updatedBefore
+          ) {
+            return false;
+          }
+
+          if (
+            opts.where.updatedAfter !== undefined &&
+            metadata.updatedAt <= opts.where.updatedAfter
+          ) {
+            return false;
+          }
+        }
+
+        return true;
+      })
+      .map(([key]) => key);
+  }
+}

package/src/server/db/localstorage.test.ts

@@ -0,0 +1,73 @@
+import { nanoid } from 'nanoid';
+import { LocalStorage } from './localstorage';
+import type { State, Server } from '../../types';
+
+describe('LocaLStorage', () => {
+  let db: LocalStorage;
+
+  beforeAll(() => {
+    db = new LocalStorage(nanoid());
+    db.connect();
+  });
+
+  // Must return undefined when no game exists.
+  test('must return undefined when no game exists', () => {
+    const { state } = db.fetch('gameID', { state: true });
+    expect(state).toEqual(undefined);
+  });
+
+  test('create game', () => {
+    const stateEntry: unknown = { a: 1 };
+
+    // Create game.
+    db.createMatch('gameID', {
+      metadata: {
+        gameName: 'tic-tac-toe',
+      } as Server.MatchData,
+      initialState: stateEntry as State,
+    });
+
+    // Must return created game.
+    const { state } = db.fetch('gameID', { state: true });
+    expect(state).toEqual(stateEntry);
+
+    // Fetch initial state.
+    const { initialState } = db.fetch('gameID', { initialState: true });
+    expect(initialState).toEqual(stateEntry);
+  });
+
+  test('listGames', () => {
+    let keys = db.listMatches({});
+    expect(keys).toEqual(['gameID']);
+    keys = db.listMatches({ gameName: 'tic-tac-toe' });
+    expect(keys).toEqual(['gameID']);
+    keys = db.listMatches({ gameName: 'chess' });
+    expect(keys).toEqual([]);
+  });
+
+  test('remove', () => {
+    // Must remove game from DB
+    db.wipe('gameID');
+    expect(db.fetch('gameID', { state: true })).toEqual({});
+    // Shall not return error
+    db.wipe('gameID');
+  });
+
+  test('must create new empty db if other localstorage key is used', () => {
+    // create another localstorage with anothr key
+    const db2 = new LocalStorage(nanoid());
+    const stateEntry: unknown = { a: 1 };
+
+    // create game in db
+    db.createMatch('gameID', {
+      metadata: {
+        gameName: 'tic-tac-toe',
+      } as Server.MatchData,
+      initialState: stateEntry as State,
+    });
+
+    // game shouldnt be visible in db2
+    const { state } = db2.fetch('gameID', { state: true });
+    expect(state).toEqual(undefined);
+  });
+});

package/src/server/db/localstorage.ts

@@ -0,0 +1,44 @@
+import { InMemory } from './inmemory';
+
+class WithLocalStorageMap<Key, Value> extends Map {
+  key: string;
+
+  constructor(key: string) {
+    super();
+    this.key = key;
+    const cache = JSON.parse(localStorage.getItem(this.key)) || [];
+    cache.forEach((entry: [Key, Value]) => this.set(...entry));
+  }
+
+  sync(): void {
+    const entries = [...this.entries()];
+    localStorage.setItem(this.key, JSON.stringify(entries));
+  }
+
+  set(key: Key, value: Value): this {
+    super.set(key, value);
+    this.sync();
+    return this;
+  }
+
+  delete(key: Key): boolean {
+    const result = super.delete(key);
+    this.sync();
+    return result;
+  }
+}
+
+/**
+ * locaStorage data storage.
+ */
+export class LocalStorage extends InMemory {
+  constructor(storagePrefix = 'bgio') {
+    super();
+    const StorageMap = (stateKey: string) =>
+      new WithLocalStorageMap(`${storagePrefix}_${stateKey}`);
+    this.state = StorageMap('state');
+    this.initial = StorageMap('initial');
+    this.metadata = StorageMap('metadata');
+    this.log = StorageMap('log');
+  }
+}