add the ability for plugins to define their own actions

Author: nicolodavis

src/client/client.js

@@ -52,27 +52,12 @@ function createDispatchers(
   }, {});
 }
 
-/**
- * createEventDispatchers
- *
- * Creates a set of dispatchers to dispatch game flow events.
- * @param {Array} eventNames - A list of event names.
- * @param {object} store - The Redux store to create dispatchers for.
- * @param {string} playerID - The ID of the player dispatching these events.
- * @param {string} credentials - A key indicating that the player is authorized to play.
- */
-export const createEventDispatchers = createDispatchers.bind(null, 'gameEvent');
-
-/**
- * createMoveDispatchers
- *
- * Creates a set of dispatchers to make moves.
- * @param {Array} moveNames - A list of move names.
- * @param {object} store - The Redux store to create dispatchers for.
- * @param {string} playerID - The ID of the player dispatching these events.
- * @param {string} credentials - A key indicating that the player is authorized to play.
- */
+// Creates a set of dispatchers to make moves.
 export const createMoveDispatchers = createDispatchers.bind(null, 'makeMove');
+// Creates a set of dispatchers to dispatch game flow events.
+export const createEventDispatchers = createDispatchers.bind(null, 'gameEvent');
+// Creates a set of dispatchers to dispatch actions to plugins.
+export const createPluginDispatchers = createDispatchers.bind(null, 'plugin');
 
 /**
  * Implementation of Client (see below).
@@ -395,6 +380,14 @@ class _ClientImpl {
       this.credentials,
       this.multiplayer
     );
+
+    this.plugins = createPluginDispatchers(
+      this.game.pluginNames,
+      this.store,
+      this.playerID,
+      this.credentials,
+      this.multiplayer
+    );
   }
 
   updatePlayerID(playerID) {

src/core/action-creators.ts

@@ -107,3 +107,16 @@ export const undo = () => ({
 export const redo = () => ({
   type: Actions.REDO as typeof Actions.REDO,
 });
+
+/**
+ * Allows plugins to define their own actions and intercept them.
+ */
+export const plugin = (
+  type: string,
+  args?: any,
+  playerID?: string | null,
+  credentials?: string
+) => ({
+  type: Actions.PLUGIN as typeof Actions.PLUGIN,
+  payload: { type, args, playerID, credentials },
+});

src/core/action-types.ts

@@ -13,3 +13,4 @@ export const RESET = 'RESET';
 export const SYNC = 'SYNC';
 export const UNDO = 'UNDO';
 export const UPDATE = 'UPDATE';
+export const PLUGIN = 'PLUGIN';

src/core/game.ts

@@ -14,6 +14,7 @@ import * as logging from './logger';
 type ProcessedGameConfig = GameConfig & {
   flow: object;
   moveNames: string[];
+  pluginNames: string[];
   processMove: Function;
 };
 
@@ -76,6 +77,8 @@ export function Game(
 
     moveNames: flow.moveNames as string[],
 
+    pluginNames: game.plugins.map(p => p.name) as string[],
+
     processMove: (state: State, action: ActionPayload.MakeMove) => {
       let moveFn = flow.getMove(state.ctx, action.type, action.playerID);
 

src/core/reducer.ts

@@ -263,6 +263,10 @@ export function CreateGameReducer({
         };
       }
 
+      case Actions.PLUGIN: {
+        return plugins.ProcessAction(state, action, { game });
+      }
+
       default: {
         return state;
       }

src/plugins/main.test.js

@@ -133,3 +133,48 @@ describe('default values', () => {
     expect(client.getState().plugins.test.data).toEqual(pluginData);
   });
 });
+
+describe('actions', () => {
+  let client;
+
+  beforeAll(() => {
+    const game = {
+      plugins: [
+        {
+          name: 'test',
+
+          setup: () => ({
+            initial: true,
+          }),
+
+          action: (_, payload) => {
+            return payload.args[0];
+          },
+        },
+        {
+          name: 'nosetup',
+          action: () => ({ action: true }),
+        },
+      ],
+    };
+
+    client = Client({ game });
+  });
+
+  test('setup', () => {
+    expect(client.getState().plugins.test.data).toEqual({
+      initial: true,
+    });
+    expect(client.getState().plugins.nosetup).toBeUndefined();
+  });
+
+  test('take action', () => {
+    const payload = { payload: true };
+
+    client.plugins.test(payload);
+    client.plugins.nosetup(payload);
+
+    expect(client.getState().plugins.test.data).toEqual(payload);
+    expect(client.getState().plugins.nosetup.data).toEqual({ action: true });
+  });
+});

src/plugins/main.ts

@@ -9,7 +9,14 @@
 import PluginImmer from './plugin-immer';
 import PluginRandom from './plugin-random';
 import PluginEvents from './plugin-events';
-import { PartialGameState, State, GameConfig, Plugin, Ctx } from '../types';
+import {
+  PartialGameState,
+  State,
+  GameConfig,
+  Plugin,
+  Ctx,
+  ActionShape,
+} from '../types';
 
 interface PluginOpts {
   game: GameConfig;
@@ -21,6 +28,33 @@ interface PluginOpts {
  */
 const DEFAULT_PLUGINS = [PluginImmer, PluginRandom, PluginEvents];
 
+/**
+ * Allow plugins to intercept actions and process them.
+ */
+export const ProcessAction = (
+  state: State,
+  action: ActionShape.Plugin,
+  opts: PluginOpts
+): State => {
+  opts.game.plugins
+    .filter(plugin => plugin.action !== undefined)
+    .filter(plugin => plugin.name === action.payload.type)
+    .forEach(plugin => {
+      const name = plugin.name;
+      const pluginState = state.plugins[name] || { data: {} };
+      const data = plugin.action(pluginState.data, action.payload);
+
+      state = {
+        ...state,
+        plugins: {
+          ...state.plugins,
+          [name]: { ...pluginState, data },
+        },
+      };
+    });
+  return state;
+};
+
 /**
  * The API's created by various plugins are stored in the plugins
  * section of the state object:

src/types.ts

@@ -60,6 +60,10 @@ export interface LogEntry {
 
 export interface Plugin {
   name: string;
+  setup?: Function;
+  action?: Function;
+  api?: Function;
+  flush?: Function;
 }
 
 export interface LongFormMove {
@@ -173,6 +177,7 @@ export namespace Server {
 export namespace CredentialedActionShape {
   export type MakeMove = ReturnType<typeof ActionCreators.makeMove>;
   export type GameEvent = ReturnType<typeof ActionCreators.gameEvent>;
+  export type Plugin = ReturnType<typeof ActionCreators.plugin>;
   export type AutomaticGameEvent = ReturnType<
     typeof ActionCreators.automaticGameEvent
   >;
@@ -184,7 +189,8 @@ export namespace CredentialedActionShape {
     | ActionShape.Update
     | ActionShape.Reset
     | ActionShape.Undo
-    | ActionShape.Redo;
+    | ActionShape.Redo
+    | ActionShape.Plugin;
 }
 
 export namespace ActionShape {
@@ -194,6 +200,7 @@ export namespace ActionShape {
   >;
   export type MakeMove = StripCredentials<CredentialedActionShape.MakeMove>;
   export type GameEvent = StripCredentials<CredentialedActionShape.GameEvent>;
+  export type Plugin = StripCredentials<CredentialedActionShape.Plugin>;
   export type AutomaticGameEvent = StripCredentials<
     CredentialedActionShape.AutomaticGameEvent
   >;
@@ -210,7 +217,8 @@ export namespace ActionShape {
     | Update
     | Reset
     | Undo
-    | Redo;
+    | Redo
+    | Plugin;
 }
 
 export namespace ActionPayload {