feat: Conditional log redacting in long form move (#1089)

* test: Add conditional redact cases

* feat: Conditional log redacting in long form move

* Reduces nesting

Co-authored-by: Vinny <1034631+vdfdev@users.noreply.github.com>
Co-authored-by: vdfdev <me@vdf.dev>

Author: 3 people

src/core/reducer.test.ts

@@ -415,6 +415,62 @@ describe('Random inside setup()', () => {
   });
 });
 
+describe('redact', () => {
+  const game: Game = {
+    setup: () => ({
+      isASecret: false,
+    }),
+    moves: {
+      A: {
+        move: (G) => G,
+        redact: (G) => G.isASecret,
+      },
+      B: (G) => {
+        return { ...G, isASecret: true };
+      },
+    },
+  };
+
+  const reducer = CreateGameReducer({ game });
+
+  let state = InitializeGame({ game });
+
+  test('move A is not secret and is not redact', () => {
+    state = reducer(state, makeMove('A', ['not redact'], '0'));
+    expect(state.G).toMatchObject({
+      isASecret: false,
+    });
+    const [lastLogEntry] = state.deltalog.slice(-1);
+    expect(lastLogEntry).toMatchObject({
+      action: {
+        payload: {
+          type: 'A',
+          args: ['not redact'],
+        },
+      },
+      redact: false,
+    });
+  });
+
+  test('move A is secret and is redact', () => {
+    state = reducer(state, makeMove('B', ['not redact'], '0'));
+    state = reducer(state, makeMove('A', ['redact'], '0'));
+    expect(state.G).toMatchObject({
+      isASecret: true,
+    });
+    const [lastLogEntry] = state.deltalog.slice(-1);
+    expect(lastLogEntry).toMatchObject({
+      action: {
+        payload: {
+          type: 'A',
+          args: ['redact'],
+        },
+      },
+      redact: true,
+    });
+  });
+});
+
 describe('undo / redo', () => {
   const game: Game = {
     seed: 0,

src/core/reducer.ts

@@ -120,6 +120,8 @@ function initializeDeltalog(
 
   if (typeof move === 'object' && move.redact === true) {
     logEntry.redact = true;
+  } else if (typeof move === 'object' && move.redact instanceof Function) {
+    logEntry.redact = move.redact(state.G, state.ctx);
   }
 
   return {

src/master/filter-player-view.test.ts

@@ -308,3 +308,74 @@ describe('redactLog', () => {
     ]);
   });
 });
+
+test('make move args to be secret depends on G via conditional redact', async () => {
+  const game = {
+    setup: () => ({
+      isASecret: false,
+    }),
+    moves: {
+      A: {
+        move: (G) => G,
+        redact: (G) => G.isASecret,
+      },
+      B: (G) => {
+        return { ...G, isASecret: true };
+      },
+    },
+  };
+
+  const send = jest.fn();
+  const master = new Master(game, new InMemory(), TransportAPI(send));
+  const filterPlayerView = getFilterPlayerView(game);
+
+  const actionA0 = ActionCreators.makeMove('A', ['not redacted'], '0');
+  const actionB = ActionCreators.makeMove('B', ['not redacted'], '0');
+  const actionA1 = ActionCreators.makeMove('A', ['redacted'], '0');
+
+  // test: ping-pong two moves, then sync and check the log
+  await master.onSync('matchID', '0', undefined, 2);
+  await master.onUpdate(actionA0, 0, 'matchID', '0');
+  await master.onUpdate(actionB, 1, 'matchID', '0');
+  await master.onUpdate(actionA1, 2, 'matchID', '0');
+  await master.onSync('matchID', '1', undefined, 2);
+
+  const payload = send.mock.calls[send.mock.calls.length - 1][0];
+  expect(
+    (filterPlayerView('1', payload).args[1] as SyncInfo).log
+  ).toMatchObject([
+    {
+      action: {
+        type: 'MAKE_MOVE',
+        payload: {
+          type: 'A',
+          args: ['not redacted'],
+          playerID: '0',
+        },
+      },
+      _stateID: 0,
+    },
+    {
+      action: {
+        type: 'MAKE_MOVE',
+        payload: {
+          type: 'B',
+          args: ['not redacted'],
+          playerID: '0',
+        },
+      },
+      _stateID: 1,
+    },
+    {
+      action: {
+        type: 'MAKE_MOVE',
+        payload: {
+          type: 'A',
+          args: null,
+          playerID: '0',
+        },
+      },
+      _stateID: 2,
+    },
+  ]);
+});

src/types.ts

@@ -203,7 +203,7 @@ export interface LongFormMove<
   CtxWithPlugins extends Ctx = Ctx
 > {
   move: MoveFn<G, CtxWithPlugins>;
-  redact?: boolean;
+  redact?: boolean | ((G: G, ctx: CtxWithPlugins) => boolean);
   noLimit?: boolean;
   client?: boolean;
   undoable?: boolean | ((G: G, ctx: CtxWithPlugins) => boolean);