Introduced enforceActions: "strict" mode, fixes #1473

flow-typed/mobx.js

@@ -3,7 +3,7 @@
 export type IObservableMapInitialValues<K, V> = IMapEntries<K, V> | KeyValueMap<V> | IMap<K, V>
 
 export interface IMobxConfigurationOptions {
-    enforceActions?: boolean,
+    enforceActions?: boolean | "strict",
     computedRequiresReaction?: boolean,
     isolateGlobalState?: boolean,
     disableErrorBoundaries?: boolean,

src/api/configure.ts

@@ -3,34 +3,44 @@ import { reserveArrayBuffer } from "../types/observablearray"
 import { setReactionScheduler } from "../core/reaction"
 
 export function configure(options: {
-    enforceActions?: boolean
+    enforceActions?: boolean | "strict"
     computedRequiresReaction?: boolean
     isolateGlobalState?: boolean
     disableErrorBoundaries?: boolean
     arrayBuffer?: number
     reactionScheduler?: (f: () => void) => void
 }): void {
-    if (options.enforceActions !== undefined) {
-        globalState.enforceActions = !!options.enforceActions
-        globalState.allowStateChanges = !options.enforceActions
+    const {
+        enforceActions,
+        computedRequiresReaction,
+        disableErrorBoundaries,
+        arrayBuffer,
+        reactionScheduler
+    } = options
+    if (enforceActions !== undefined) {
+        if (typeof enforceActions !== "boolean" && enforceActions !== "strict")
+            return fail(`Invalid configuration for 'enforceActions': ${enforceActions}`)
+        globalState.enforceActions = enforceActions
+        globalState.allowStateChanges =
+            enforceActions === true || enforceActions === "strict" ? false : true
     }
-    if (options.computedRequiresReaction !== undefined) {
-        globalState.computedRequiresReaction = !!options.computedRequiresReaction
+    if (computedRequiresReaction !== undefined) {
+        globalState.computedRequiresReaction = !!computedRequiresReaction
     }
     if (options.isolateGlobalState === true) {
         isolateGlobalState()
     }
-    if (options.disableErrorBoundaries !== undefined) {
-        if (options.disableErrorBoundaries === true)
+    if (disableErrorBoundaries !== undefined) {
+        if (disableErrorBoundaries === true)
             console.warn(
                 "WARNING: Debug feature only. MobX will NOT recover from errors if this is on."
             )
-        globalState.disableErrorBoundaries = !!options.disableErrorBoundaries
+        globalState.disableErrorBoundaries = !!disableErrorBoundaries
     }
-    if (typeof options.arrayBuffer === "number") {
-        reserveArrayBuffer(options.arrayBuffer)
+    if (typeof arrayBuffer === "number") {
+        reserveArrayBuffer(arrayBuffer)
     }
-    if (options.reactionScheduler) {
-        setReactionScheduler(options.reactionScheduler)
+    if (reactionScheduler) {
+        setReactionScheduler(reactionScheduler)
     }
 }

src/core/derivation.ts

@@ -126,7 +126,7 @@ export function checkIfStateModificationsAreAllowed(atom: IAtom) {
                 `Computed values are not allowed to cause side effects by changing observables that are already being observed. Tried to modify: ${atom.name}`
         )
     // Should not be possible to change observed state outside strict mode, except during initialization, see #563
-    if (!globalState.allowStateChanges && hasObservers)
+    if (!globalState.allowStateChanges && (hasObservers || globalState.enforceActions === "strict"))
         fail(
             process.env.NODE_ENV !== "production" &&
                 (globalState.enforceActions

src/core/globalstate.ts

@@ -75,7 +75,7 @@ export class MobXGlobals {
     /**
      * If strict mode is enabled, state changes are by default not allowed
      */
-    enforceActions = false
+    enforceActions: boolean | "strict" = false
 
     /**
      * Spy callbacks

test/base/strict-mode.js

@@ -186,6 +186,30 @@ test("strict mode checks", function() {
     d()
 })
 
+test("enforceActions 'strict' does not allow changing unobserved observables", () => {
+    try {
+        mobx.configure({ enforceActions: "strict" })
+        const x = mobx.observable({
+            a: 1,
+            b: 2
+        })
+        const d = mobx.autorun(() => {
+            x.a
+        })
+
+        expect(() => {
+            x.a = 2
+        }).toThrow(/Since strict-mode is enabled/)
+        expect(() => {
+            x.b = 2
+        }).toThrow(/Since strict-mode is enabled/)
+
+        d()
+    } finally {
+        mobx.configure({ enforceActions: false })
+    }
+})
+
 test("warn on unsafe reads", function() {
     try {
         mobx.configure({ computedRequiresReaction: true })