mobx-keystone 2.1.0 → 2.3.0

package/src/action/modelFlow.ts

@@ -65,68 +65,53 @@ export function flow<R, Args extends any[]>({
     const genThrow = gen.throw!.bind(gen)
 
     const promise = new Promise<R>((resolve, reject) => {
-      function onFulfilled(res: any): void {
+      function finish(
+        stepType: ActionContextAsyncStepType,
+        resolution: FlowFinisher["resolution"],
+        value: unknown
+      ): void {
+        wrapInAction({
+          nameOrNameFn: name,
+          // we use a flow finisher to allow middlewares to tweak the return value before resolution
+          fn: (val: any): FlowFinisher => ({
+            value: val,
+            resolution,
+            accepter: resolve,
+            rejecter: reject,
+          }),
+          actionType: ActionContextActionType.Async,
+          overrideContext: ctxOverride(stepType),
+          isFlowFinisher: true,
+        }).call(target, value)
+      }
+
+      function resume(
+        genFn: (value: any) => IteratorResult<any>,
+        stepType: ActionContextAsyncStepType,
+        value: unknown
+      ): void {
         let ret: unknown
         try {
           ret = wrapInAction({
             nameOrNameFn: name,
-            fn: genNext,
+            fn: genFn,
             actionType: ActionContextActionType.Async,
-            overrideContext: ctxOverride(ActionContextAsyncStepType.Resume),
-          }).call(target, res)
+            overrideContext: ctxOverride(stepType),
+          }).call(target, value)
         } catch (e) {
-          wrapInAction({
-            nameOrNameFn: name,
-            fn: (err: any) => {
-              // we use a flow finisher to allow middlewares to tweak the return value before resolution
-              return {
-                value: err,
-                resolution: "reject",
-
-                accepter: resolve,
-                rejecter: reject,
-              } as FlowFinisher
-            },
-            actionType: ActionContextActionType.Async,
-            overrideContext: ctxOverride(ActionContextAsyncStepType.Throw),
-            isFlowFinisher: true,
-          }).call(target, e)
+          finish(ActionContextAsyncStepType.Throw, "reject", e)
           return
         }
 
         next(ret)
       }
 
-      function onRejected(err: unknown): void {
-        let ret: unknown
-        try {
-          ret = wrapInAction({
-            nameOrNameFn: name,
-            fn: genThrow,
-            actionType: ActionContextActionType.Async,
-            overrideContext: ctxOverride(ActionContextAsyncStepType.ResumeError),
-          }).call(target, err)
-        } catch (e) {
-          wrapInAction({
-            nameOrNameFn: name,
-            fn: (err: any) => {
-              // we use a flow finisher to allow middlewares to tweak the return value before resolution
-              return {
-                value: err,
-                resolution: "reject",
-
-                accepter: resolve,
-                rejecter: reject,
-              } as FlowFinisher
-            },
-            actionType: ActionContextActionType.Async,
-            overrideContext: ctxOverride(ActionContextAsyncStepType.Throw),
-            isFlowFinisher: true,
-          }).call(target, e)
-          return
-        }
+      function onFulfilled(res: unknown): void {
+        resume(genNext, ActionContextAsyncStepType.Resume, res)
+      }
 
-        next(ret)
+      function onRejected(err: unknown): void {
+        resume(genThrow, ActionContextAsyncStepType.ResumeError, err)
       }
 
       function next(ret: any): void {
@@ -134,23 +119,7 @@ export function flow<R, Args extends any[]>({
           // an async iterator
           Promise.resolve(ret).then(next, reject).catch(reject)
         } else if (ret.done) {
-          // done
-          wrapInAction({
-            nameOrNameFn: name,
-            fn: (val: any) => {
-              // we use a flow finisher to allow middlewares to tweak the return value before resolution
-              return {
-                value: val,
-                resolution: "accept",
-
-                accepter: resolve,
-                rejecter: reject,
-              } as FlowFinisher
-            },
-            actionType: ActionContextActionType.Async,
-            overrideContext: ctxOverride(ActionContextAsyncStepType.Return),
-            isFlowFinisher: true,
-          }).call(target, ret.value)
+          finish(ActionContextAsyncStepType.Return, "accept", ret.value)
         } else {
           // continue
           Promise.resolve(ret.value).then(onFulfilled, onRejected).catch(reject)

package/src/actionMiddlewares/actionTrackingMiddleware.ts

@@ -178,8 +178,11 @@ export function actionTrackingMiddleware(
   const resumeSuspendSupport = !!hooks.onResume || !!hooks.onSuspend
 
   const filter: ActionMiddleware["filter"] = (ctx) => {
-    if (ctx.type === ActionContextActionType.Sync) {
-      // start and finish is on the same context
+    if (
+      ctx.type === ActionContextActionType.Sync ||
+      ctx.asyncStepType === ActionContextAsyncStepType.Spawn
+    ) {
+      // (for sync actions start and finish are on the same context)
       const accepted = userFilter(ctx)
       if (accepted) {
         setCtxData(ctx, {
@@ -188,39 +191,21 @@ export function actionTrackingMiddleware(
         })
       }
       return accepted
-    } else {
-      switch (ctx.asyncStepType) {
-        case ActionContextAsyncStepType.Spawn: {
-          const accepted = userFilter(ctx)
-          if (accepted) {
-            setCtxData(ctx, {
-              startAccepted: true,
-              state: State.Idle,
-            })
-          }
-          return accepted
-        }
+    }
 
-        case ActionContextAsyncStepType.Return:
-        case ActionContextAsyncStepType.Throw: {
-          // depends if the spawn one was accepted or not
-          const data = getCtxData(ctx.spawnAsyncStepContext!)
-          return data ? data.startAccepted : false
-        }
+    // the other steps depend on whether the spawn one was accepted or not
+    const spawnAccepted = () => !!getCtxData(ctx.spawnAsyncStepContext!)?.startAccepted
+    switch (ctx.asyncStepType) {
+      case ActionContextAsyncStepType.Return:
+      case ActionContextAsyncStepType.Throw:
+        return spawnAccepted()
 
-        case ActionContextAsyncStepType.Resume:
-        case ActionContextAsyncStepType.ResumeError:
-          if (resumeSuspendSupport) {
-            // depends if the spawn one was accepted or not
-            const data = getCtxData(ctx.spawnAsyncStepContext!)
-            return data ? data.startAccepted : false
-          } else {
-            return false
-          }
+      case ActionContextAsyncStepType.Resume:
+      case ActionContextAsyncStepType.ResumeError:
+        return resumeSuspendSupport && spawnAccepted()
 
-        default:
-          return false
-      }
+      default:
+        return false
     }
   }
 
@@ -311,57 +296,42 @@ export function actionTrackingMiddleware(
       }
     }
 
-    if (ctx.type === ActionContextActionType.Sync) {
-      let retObj = start(simpleCtx)
-
-      if (retObj) {
+    if (
+      ctx.type === ActionContextActionType.Sync ||
+      ctx.asyncStepType === ActionContextAsyncStepType.Spawn
+    ) {
+      const overriddenRetObj = start(simpleCtx)
+      if (overriddenRetObj) {
         // action canceled / overridden by onStart
         resume(simpleCtx, true)
         suspend(simpleCtx)
-        retObj = finish(simpleCtx, retObj)
-      } else {
-        try {
-          retObj = { result: ActionTrackingResult.Return, value: next() }
-        } catch (err) {
-          retObj = { result: ActionTrackingResult.Throw, value: err }
-        }
-        retObj = finish(simpleCtx, retObj)
+        return returnOrThrowActionTrackingReturn(finish(simpleCtx, overriddenRetObj))
+      }
+
+      if (ctx.type !== ActionContextActionType.Sync) {
+        // a flow finishes in its return / throw step
+        return next()
       }
 
-      return returnOrThrowActionTrackingReturn(retObj)
+      let retObj: ActionTrackingReturn
+      try {
+        retObj = { result: ActionTrackingResult.Return, value: next() }
+      } catch (err) {
+        retObj = { result: ActionTrackingResult.Throw, value: err }
+      }
+      return returnOrThrowActionTrackingReturn(finish(simpleCtx, retObj))
     } else {
       // async
 
       switch (ctx.asyncStepType) {
-        case ActionContextAsyncStepType.Spawn: {
-          let retObj = start(simpleCtx)
-          if (retObj) {
-            // action canceled / overridden by onStart
-            resume(simpleCtx, true)
-            suspend(simpleCtx)
-            retObj = finish(simpleCtx, retObj)
-            return returnOrThrowActionTrackingReturn(retObj)
-          } else {
-            return next()
-          }
-        }
-
-        case ActionContextAsyncStepType.Return: {
-          const flowFinisher: FlowFinisher = next()
-          const retObj = finish(simpleCtx, {
-            result: ActionTrackingResult.Return,
-            value: flowFinisher.value,
-          })
-          flowFinisher.resolution =
-            retObj.result === ActionTrackingResult.Return ? "accept" : "reject"
-          flowFinisher.value = retObj.value
-          return flowFinisher
-        }
-
+        case ActionContextAsyncStepType.Return:
         case ActionContextAsyncStepType.Throw: {
           const flowFinisher: FlowFinisher = next()
           const retObj = finish(simpleCtx, {
-            result: ActionTrackingResult.Throw,
+            result:
+              ctx.asyncStepType === ActionContextAsyncStepType.Return
+                ? ActionTrackingResult.Return
+                : ActionTrackingResult.Throw,
             value: flowFinisher.value,
           })
           flowFinisher.resolution =

package/src/actionMiddlewares/transactionMiddleware.ts

@@ -122,7 +122,7 @@ export function transaction(...args: any[]): void {
 
     checkDecoratorContext("transaction", ctx.name, ctx.static)
     if (ctx.kind !== "method" && ctx.kind !== "field") {
-      throw failure(`@transaction can only be used on fields or methods}`)
+      throw failure(`@transaction can only be used on fields or methods`)
     }
 
     ctx.addInitializer(function (this: any) {

package/src/actionMiddlewares/undoMiddleware.ts

@@ -428,11 +428,11 @@ export class UndoManager {
     const event = events[events.length - 1].data
 
     withoutUndo(() => {
-      toSingleEvents(event)
-        .reverse()
-        .forEach((e) => {
-          applyPatches(this.subtreeRoot, e.inversePatches, true)
-        })
+      applyPatches(
+        this.subtreeRoot,
+        toSingleEvents(event).map((e) => e.inversePatches),
+        true
+      )
 
       // restore the attached state before the operation was made
       if (event.attachedState) {
@@ -456,9 +456,10 @@ export class UndoManager {
     const event = events[events.length - 1].data
 
     withoutUndo(() => {
-      toSingleEvents(event).forEach((e) => {
-        applyPatches(this.subtreeRoot, e.patches)
-      })
+      applyPatches(
+        this.subtreeRoot,
+        toSingleEvents(event).map((e) => e.patches)
+      )
 
       // restore the attached state after the operation was made
       if (event.attachedState) {
@@ -601,11 +602,11 @@ export class UndoManager {
     const genThrow = gen.throw.bind(gen)
 
     const promise = new Promise<R>((resolve, reject) => {
-      function onFulfilled(res: any): void {
+      function resume(genFn: (value: any) => IteratorResult<any>, value: unknown): void {
         group.resume()
         let ret: unknown
         try {
-          ret = genNext(res)
+          ret = genFn(value)
         } catch (e) {
           group.end()
           reject(e as Error)
@@ -616,19 +617,12 @@ export class UndoManager {
         next(ret)
       }
 
-      function onRejected(err: unknown): void {
-        group.resume()
-        let ret: unknown
-        try {
-          ret = genThrow(err)
-        } catch (e) {
-          group.end()
-          reject(e as Error)
-          return
-        }
+      function onFulfilled(res: unknown): void {
+        resume(genNext, res)
+      }
 
-        group.pause()
-        next(ret)
+      function onRejected(err: unknown): void {
+        resume(genThrow, err)
       }
 
       function next(ret: any): void {

package/src/context/context.ts

@@ -162,25 +162,19 @@ class ContextClass<T> implements Context<T> {
     })
   })
 
-  set = action((node: object, value: T) => {
-    assertTweakedObject(node, "node")
-
-    this.nodeContextValue.set(node, {
-      type: "value",
-      value,
-    })
-    this.reportNodeAtomChanged(node)
-  })
-
-  private _setComputed(node: object, computedValueFn: IComputedValue<T>) {
+  private setNodeContextValue(node: object, contextValue: ContextValue<T>) {
     assertTweakedObject(node, "node")
 
-    this.nodeContextValue.set(node, { type: "computed", value: computedValueFn })
+    this.nodeContextValue.set(node, contextValue)
     this.reportNodeAtomChanged(node)
   }
 
+  set = action((node: object, value: T) => {
+    this.setNodeContextValue(node, { type: "value", value })
+  })
+
   setComputed = action((node: object, valueFn: () => T) => {
-    this._setComputed(node, computed(valueFn))
+    this.setNodeContextValue(node, { type: "computed", value: computed(valueFn) })
   })
 
   unset = action((node: object) => {
@@ -190,42 +184,27 @@ class ContextClass<T> implements Context<T> {
     this.reportNodeAtomChanged(node)
   })
 
-  apply = action(<R>(fn: () => R, value: T): R => {
+  private applyOverride<R>(fn: () => R, contextValue: ContextValue<T>): R {
     const old = this.overrideContextValue.get()
-    this.overrideContextValue.set({
-      type: "value",
-      value,
-    })
+    this.overrideContextValue.set(contextValue)
 
     try {
       const ret = fn()
       if (isTweakedObject(ret, false)) {
-        this.set(ret, value)
+        this.setNodeContextValue(ret, contextValue)
       }
       return ret
     } finally {
       this.overrideContextValue.set(old)
     }
+  }
+
+  apply = action(<R>(fn: () => R, value: T): R => {
+    return this.applyOverride(fn, { type: "value", value })
   })
 
   applyComputed = action(<R>(fn: () => R, valueFn: () => T): R => {
-    const computedValueFn = computed(valueFn)
-
-    const old = this.overrideContextValue.get()
-    this.overrideContextValue.set({
-      type: "computed",
-      value: computedValueFn,
-    })
-
-    try {
-      const ret = fn()
-      if (isTweakedObject(ret, false)) {
-        this._setComputed(ret, computedValueFn)
-      }
-      return ret
-    } finally {
-      this.overrideContextValue.set(old)
-    }
+    return this.applyOverride(fn, { type: "computed", value: computed(valueFn) })
   })
 
   constructor(defaultValue?: T) {

package/src/dataModel/utils.ts

@@ -13,37 +13,14 @@ export function isDataModel(model: unknown): model is AnyDataModel {
   return model instanceof BaseDataModel
 }
 
-/**
- * @internal
- *
- * Asserts something is actually a data model.
- *
- * @param model
- * @param argName
- */
-export function assertIsDataModel(
-  model: unknown,
-  argName: string,
-  customErrMsg = "must be a data model instance"
-): asserts model is AnyDataModel {
-  if (!isDataModel(model)) {
-    throw failure(`${argName} ${customErrMsg}`)
-  }
-}
-
 /**
  * @internal
  */
 export function isDataModelClass(modelClass: unknown): modelClass is ModelClass<AnyDataModel> {
-  if (typeof modelClass !== "function") {
-    return false
-  }
-
-  if (modelClass !== BaseDataModel && !(modelClass.prototype instanceof BaseDataModel)) {
-    return false
-  }
-
-  return true
+  return (
+    typeof modelClass === "function" &&
+    (modelClass === BaseDataModel || modelClass.prototype instanceof BaseDataModel)
+  )
 }
 
 /**
@@ -57,7 +34,7 @@ export function assertIsDataModelClass(
     throw failure(`${argName} must be a class`)
   }
 
-  if (modelClass !== BaseDataModel && !(modelClass.prototype instanceof BaseDataModel)) {
+  if (!isDataModelClass(modelClass)) {
     throw failure(`${argName} must extend DataModel`)
   }
 }