Freeze core graph state boundaries

Author: JackWilb

packages/core/src/graph/graph-slice.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import produce from 'immer';
+import produce, { freeze } from 'immer';
 import {
     ActionCreatorWithPayload,
     createAction,
@@ -121,9 +121,11 @@ export function graphSliceCreator<State, Event extends string>(
         ),
     };
 
+    const frozenGraph = freeze(graph, true);
+
     return {
         actions,
-        getInitialState: () => graph,
+        getInitialState: () => frozenGraph,
         reduce(g, action) {
             switch (action.type) {
                 case actions.addMetadata.type:
@@ -171,7 +173,7 @@ export function graphSliceCreator<State, Event extends string>(
                         draft.current = payload.id;
                     });
                 case actions.load.type:
-                    return action.payload;
+                    return freeze(action.payload, true);
                 default:
                     return g;
             }

packages/core/tests/graph.spec.ts

@@ -67,4 +67,32 @@ describe('initializeProvenanceGraph', () => {
         graph.update(graph.changeCurrent(graph.root.id));
         expect(listener).toHaveBeenCalledTimes(1);
     });
+
+    it('freezes the initial state so external mutation does not change the root snapshot', () => {
+        const initialState = {
+            count: 0,
+            nested: {
+                value: 1,
+            },
+        };
+        const graph = initializeProvenanceGraph<typeof initialState, 'increment'>(
+            initialState
+        );
+
+        expect(Object.isFrozen(initialState)).toBe(true);
+        expect(Object.isFrozen(initialState.nested)).toBe(true);
+
+        expect(() => {
+            initialState.nested.value = 2;
+        }).toThrow(TypeError);
+
+        expect(
+            (
+                graph.root.state as {
+                    type: 'checkpoint';
+                    val: typeof initialState;
+                }
+            ).val.nested.value
+        ).toBe(1);
+    });
 });

packages/core/tests/import_export.spec.ts

@@ -101,4 +101,33 @@ describe('Export', () => {
         expect(imported.current.id).toBe(exportObject.root);
         await expect(imported.to(orphan.id)).rejects.toThrow();
     });
+
+    it('freezes imported graph objects so later external mutation cannot rewrite the store', async () => {
+        const { trrack, add } = setup();
+
+        await trrack.apply('Add', add(2));
+
+        const exportObject = trrack.exportObject();
+        const rootNode = exportObject.nodes[exportObject.root] as {
+            state: {
+                type: 'checkpoint';
+                val: {
+                    counter: number;
+                };
+            };
+        };
+        const { trrack: imported } = setup();
+        imported.importObject(exportObject);
+
+        expect(Object.isFrozen(exportObject)).toBe(true);
+        expect(Object.isFrozen(exportObject.nodes)).toBe(true);
+        expect(Object.isFrozen(rootNode.state.val)).toBe(true);
+        expect(imported.getState().counter).toBe(2);
+
+        expect(() => {
+            rootNode.state.val.counter = 99;
+        }).toThrow(TypeError);
+
+        expect(imported.getState().counter).toBe(2);
+    });
 });