@mnbroatch/boardgame.io 0.0.1

package/dist/types/src/server/db/base.d.ts

@@ -0,0 +1,192 @@
+import type { Object } from 'ts-toolbelt';
+import type { State, Server, LogEntry } from '../../types';
+export declare enum Type {
+    SYNC = 0,
+    ASYNC = 1
+}
+/**
+ * Type guard that checks if a storage implementation is synchronous.
+ */
+export declare function isSynchronous(storageAPI: Sync | Async): storageAPI is Sync;
+/**
+ * Indicates which fields the fetch operation should return.
+ */
+export interface FetchOpts {
+    state?: boolean;
+    log?: boolean;
+    metadata?: boolean;
+    initialState?: boolean;
+}
+/**
+ * Data that can be retrieved from a database fetch query
+ */
+export interface FetchFields {
+    state: State;
+    log: LogEntry[];
+    metadata: Server.MatchData;
+    initialState: State;
+}
+/**
+ * The result of the fetch operation.
+ */
+export declare type FetchResult<O extends FetchOpts> = Object.Pick<FetchFields, Object.SelectKeys<O, true>>;
+/**
+ * Options passed when listing matches.
+ */
+export interface ListMatchesOpts {
+    gameName?: string;
+    where?: {
+        isGameover?: boolean;
+        updatedBefore?: number;
+        updatedAfter?: number;
+    };
+}
+/**
+ * @deprecated Use ListMatchesOpts instead
+ */
+export interface ListGamesOpts {
+    gameName?: string;
+    where?: {
+        isGameover?: boolean;
+        updatedBefore?: number;
+        updatedAfter?: number;
+    };
+}
+/**
+ * Options passed when creating a new match.
+ */
+export interface CreateMatchOpts {
+    initialState: State;
+    metadata: Server.MatchData;
+}
+/**
+ * @deprecated Use CreateMatchOpts instead
+ */
+export interface CreateGameOpts {
+    initialState: State;
+    metadata: Server.MatchData;
+}
+export declare abstract class Async {
+    type(): Type;
+    /**
+     * Connect.
+     */
+    abstract connect(): any;
+    /**
+     * Create a new match.
+     *
+     * This might just need to call setState and setMetadata in
+     * most implementations.
+     *
+     * However, it exists as a separate call so that the
+     * implementation can provision things differently when
+     * a match is created.  For example, it might stow away the
+     * initial match state in a separate field for easier retrieval.
+     */
+    createMatch(matchID: string, opts: CreateMatchOpts): Promise<void>;
+    /**
+     * Create a new game.
+     *
+     * This might just need to call setState and setMetadata in
+     * most implementations.
+     *
+     * However, it exists as a separate call so that the
+     * implementation can provision things differently when
+     * a game is created.  For example, it might stow away the
+     * initial game state in a separate field for easier retrieval.
+     *
+     * @deprecated Use createMatch instead, if implemented
+     */
+    createGame?(matchID: string, opts: CreateGameOpts): Promise<void>;
+    /**
+     * Update the game state.
+     *
+     * If passed a deltalog array, setState should append its contents to the
+     * existing log for this game.
+     */
+    abstract setState(matchID: string, state: State, deltalog?: LogEntry[]): Promise<void>;
+    /**
+     * Update the game metadata.
+     */
+    abstract setMetadata(matchID: string, metadata: Server.MatchData): Promise<void>;
+    /**
+     * Fetch the game state.
+     */
+    abstract fetch<O extends FetchOpts>(matchID: string, opts: O): Promise<FetchResult<O>>;
+    /**
+     * Remove the game state.
+     */
+    abstract wipe(matchID: string): Promise<void>;
+    /**
+     * Return all matches.
+     */
+    listMatches(opts?: ListMatchesOpts): Promise<string[]>;
+    /**
+     * Return all games.
+     *
+     * @deprecated Use listMatches instead, if implemented
+     */
+    listGames?(opts?: ListGamesOpts): Promise<string[]>;
+}
+export declare abstract class Sync {
+    type(): Type;
+    /**
+     * Connect.
+     */
+    connect(): void;
+    /**
+     * Create a new match.
+     *
+     * This might just need to call setState and setMetadata in
+     * most implementations.
+     *
+     * However, it exists as a separate call so that the
+     * implementation can provision things differently when
+     * a match is created.  For example, it might stow away the
+     * initial match state in a separate field for easier retrieval.
+     */
+    createMatch(matchID: string, opts: CreateMatchOpts): void;
+    /**
+     * Create a new game.
+     *
+     * This might just need to call setState and setMetadata in
+     * most implementations.
+     *
+     * However, it exists as a separate call so that the
+     * implementation can provision things differently when
+     * a game is created.  For example, it might stow away the
+     * initial game state in a separate field for easier retrieval.
+     *
+     * @deprecated Use createMatch instead, if implemented
+     */
+    createGame?(matchID: string, opts: CreateGameOpts): void;
+    /**
+     * Update the match state.
+     *
+     * If passed a deltalog array, setState should append its contents to the
+     * existing log for this match.
+     */
+    abstract setState(matchID: string, state: State, deltalog?: LogEntry[]): void;
+    /**
+     * Update the match metadata.
+     */
+    abstract setMetadata(matchID: string, metadata: Server.MatchData): void;
+    /**
+     * Fetch the match state.
+     */
+    abstract fetch<O extends FetchOpts>(matchID: string, opts: O): FetchResult<O>;
+    /**
+     * Remove the match state.
+     */
+    abstract wipe(matchID: string): void;
+    /**
+     * Return all matches.
+     */
+    listMatches(opts?: ListMatchesOpts): string[];
+    /**
+     * Return all games.
+     *
+     * @deprecated Use listMatches instead, if implemented
+     */
+    listGames?(opts?: ListGamesOpts): string[];
+}

package/dist/types/src/server/db/flatfile.d.ts

@@ -0,0 +1,44 @@
+import * as StorageAPI from './base';
+import type { State, Server, LogEntry } from '../../types';
+interface InitOptions {
+    dir: string;
+    logging?: boolean;
+    ttl?: boolean;
+}
+/**
+ * FlatFile data storage.
+ */
+export declare class FlatFile extends StorageAPI.Async {
+    private games;
+    private dir;
+    private logging?;
+    private ttl?;
+    private fileQueues;
+    constructor({ dir, logging, ttl }: InitOptions);
+    private chainRequest;
+    private getItem;
+    private setItem;
+    private removeItem;
+    connect(): Promise<void>;
+    /**
+     * Create new match.
+     *
+     * @param matchID
+     * @param opts
+     * @override
+     */
+    createMatch(matchID: string, opts: StorageAPI.CreateMatchOpts): Promise<void>;
+    fetch<O extends StorageAPI.FetchOpts>(matchID: string, opts: O): Promise<StorageAPI.FetchResult<O>>;
+    clear(): Promise<void>;
+    setState(id: string, state: State, deltalog?: LogEntry[]): Promise<any>;
+    setMetadata(id: string, metadata: Server.MatchData): Promise<void>;
+    wipe(id: string): Promise<void>;
+    /**
+     * List matches IDs.
+     *
+     * @param opts
+     * @override
+     */
+    listMatches(opts?: StorageAPI.ListMatchesOpts): Promise<string[]>;
+}
+export {};

package/dist/types/src/server/db/flatfile.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/server/db/index.d.ts

@@ -0,0 +1,4 @@
+import { InMemory } from './inmemory';
+import { FlatFile } from './flatfile';
+declare const DBFromEnv: () => FlatFile | InMemory;
+export { InMemory, FlatFile, DBFromEnv };

package/dist/types/src/server/db/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/server/db/inmemory.d.ts

@@ -0,0 +1,43 @@
+import type { State, Server, LogEntry } from '../../types';
+import * as StorageAPI from './base';
+/**
+ * InMemory data storage.
+ */
+export declare 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();
+    /**
+     * Create a new match.
+     *
+     * @override
+     */
+    createMatch(matchID: string, opts: StorageAPI.CreateMatchOpts): void;
+    /**
+     * Write the match metadata to the in-memory object.
+     */
+    setMetadata(matchID: string, metadata: Server.MatchData): void;
+    /**
+     * Write the match state to the in-memory object.
+     */
+    setState(matchID: string, state: State, deltalog?: LogEntry[]): void;
+    /**
+     * Fetches state for a particular matchID.
+     */
+    fetch<O extends StorageAPI.FetchOpts>(matchID: string, opts: O): StorageAPI.FetchResult<O>;
+    /**
+     * Remove the match state from the in-memory object.
+     */
+    wipe(matchID: string): void;
+    /**
+     * Return all keys.
+     *
+     * @override
+     */
+    listMatches(opts?: StorageAPI.ListMatchesOpts): string[];
+}

package/dist/types/src/server/db/inmemory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/server/db/localstorage.d.ts

@@ -0,0 +1,7 @@
+import { InMemory } from './inmemory';
+/**
+ * locaStorage data storage.
+ */
+export declare class LocalStorage extends InMemory {
+    constructor(storagePrefix?: string);
+}

package/dist/types/src/server/db/localstorage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/server/index.d.ts

@@ -0,0 +1,68 @@
+/// <reference types="koa__router" />
+/// <reference types="node" />
+import Koa from 'koa';
+import Router from '@koa/router';
+import type { CorsOptions } from 'cors';
+import { configureRouter, configureApp } from './api';
+import { Auth } from './auth';
+import { SocketIO } from './transport/socketio';
+import type { Server as ServerTypes, Game, StorageAPI } from '../types';
+export declare 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 declare const createServerRunConfig: (portOrConfig: number | ServerConfig, callback?: () => void) => ServerConfig;
+export declare const getPortFromServer: (server: KoaServer) => string | number | null;
+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 declare function Server({ games, db, transport, https, uuid, origins, apiOrigins, generateCredentials, authenticateCredentials, }: ServerOpts): {
+    app: ServerTypes.App;
+    db: StorageAPI.Async | StorageAPI.Sync;
+    auth: Auth;
+    router: Router<any, ServerTypes.AppCtx>;
+    transport: SocketIO;
+    run: (portOrConfig: number | ServerConfig, callback?: () => void) => Promise<{
+        apiServer: import("http").Server;
+        appServer: import("http").Server;
+    }>;
+    kill: (servers: {
+        apiServer?: KoaServer;
+        appServer: KoaServer;
+    }) => void;
+};

package/dist/types/src/server/index.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,6 @@
+/** Generic interface for pub-subs.  */
+export interface GenericPubSub<T> {
+    publish(channelId: string, payload: T): any;
+    subscribe(channelId: string, callback: (payload: T) => void): void;
+    unsubscribeAll(channelId: string): any;
+}

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

@@ -0,0 +1,7 @@
+import type { GenericPubSub } from './generic-pub-sub';
+export declare class InMemoryPubSub<T> implements GenericPubSub<T> {
+    callbacks: Map<string, ((payload: T) => void)[]>;
+    publish(channelId: string, payload: T): void;
+    subscribe(channelId: string, callback: (payload: T) => void): void;
+    unsubscribeAll(channelId: string): void;
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/types/src/server/transport/socketio-simultaneous.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/server/transport/socketio.d.ts

@@ -0,0 +1,65 @@
+/// <reference types="node" />
+import type { CorsOptions } from 'cors';
+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 } from '../../master/master';
+import type { Game, Server } from '../../types';
+import type { GenericPubSub } from './pubsub/generic-pub-sub';
+import type { IntermediateTransportData } from '../../master/master';
+/**
+ * API that's exposed by SocketIO for the Master to send
+ * information to the clients.
+ */
+export declare const TransportAPI: (matchID: string, socket: IOTypes.Socket, filterPlayerView: any, pubSub: GenericPubSub<IntermediateTransportData>) => MasterTransport;
+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 declare class SocketIO {
+    protected clientInfo: Map<string, Client>;
+    protected roomInfo: Map<string, Set<string>>;
+    protected perMatchQueue: Map<string, PQueue>;
+    private readonly https;
+    private readonly socketAdapter;
+    private readonly socketOpts;
+    protected pubSub: GenericPubSub<IntermediateTransportData>;
+    constructor({ https, socketAdapter, socketOpts, pubSub }?: SocketOpts);
+    /**
+     * Unregister client data for a socket.
+     */
+    private removeClient;
+    /**
+     * Register client data for a socket.
+     */
+    private addClient;
+    private subscribePubSubChannel;
+    private unsubscribePubSubChannel;
+    init(app: Server.App & {
+        _io?: IOTypes.Server;
+    }, games: Game[], origins?: CorsOptions['origin']): void;
+    /**
+     * Create a PQueue for a given matchID if none exists and return it.
+     * @param matchID
+     * @returns
+     */
+    getMatchQueue(matchID: string): PQueue;
+    /**
+     * Delete a PQueue for a given matchID.
+     * @param matchID
+     */
+    deleteMatchQueue(matchID: string): void;
+}
+export { Master };

package/dist/types/src/server/transport/socketio.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/server/util.d.ts

@@ -0,0 +1,35 @@
+import type { Server, State, Game } from '../types';
+/**
+ * Creates a new match metadata object.
+ */
+export declare const createMetadata: ({ game, unlisted, setupData, numPlayers, }: {
+    game: Game;
+    numPlayers: number;
+    setupData?: any;
+    unlisted?: boolean;
+}) => Server.MatchData;
+/**
+ * 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 declare const createMatch: ({ game, numPlayers, setupData, unlisted, }: {
+    game: Game;
+    numPlayers: number;
+    setupData: any;
+    unlisted: boolean;
+}) => {
+    metadata: Server.MatchData;
+    initialState: State;
+} | {
+    setupDataError: string;
+};
+/**
+ * Given players, returns the count of players.
+ */
+export declare const getNumPlayers: (players: Server.MatchData['players']) => number;
+/**
+ * Given players, tries to find the ID of the first player that can be joined.
+ * Returns `undefined` if there’s no available ID.
+ */
+export declare const getFirstAvailablePlayerID: (players: Server.MatchData['players']) => string | undefined;

package/dist/types/src/testing/mock-random.d.ts

@@ -0,0 +1,15 @@
+import type { RandomAPI } from '../plugins/random/random';
+import RandomPlugin from '../plugins/plugin-random';
+/**
+ * Test helper that creates a plugin to override the built-in random API.
+ *
+ * @param overrides - A map of method names to mock functions.
+ *
+ * @example
+ * const game = {
+ *   plugins: [
+ *     MockRandom({ D6: () => 1 }),
+ *   ],
+ * };
+ */
+export declare const MockRandom: (overrides?: Partial<Record<"D4" | "D6" | "D10" | "D12" | "D20" | "Die" | "Number" | "Shuffle", (...args: any[]) => any>>) => Omit<typeof RandomPlugin, 'flush'>;

package/dist/types/src/testing/mock-random.test.d.ts

@@ -0,0 +1 @@
+export {};