Merge pull request #65 from mobxjs/improved-types

WIP: Improved types, Fixes #64, #56, #9

Author: mweststrate

README.md

@@ -0,0 +1,8 @@
+# 0.2.0
+
+* Renamed `createFactory` to `types.model` (breaking!)
+* Renamed `composeFactory` to `types.extend` (breaking!)
+* Models are no longer constructed by invoking the factory as function, but by calling `factory.create` (breaking!)
+* Introduced `identifier`
+* Introduced / improved `reference`
+* Greatly improved typescript support, type inference etc. However there are still limitations as the full typesystem of MST cannot be expressed in TypeScript. Especially concerning the type of snapshots and the possibility to use snapshots as first class value.

changelog.md

@@ -1,8 +1,4 @@
-import {isObservable} from "mobx"
-import {isModel} from "./factories"
-import {resolve} from "../top-level-api"
-import {addHiddenFinalProp, invariant, isPlainObject, isPrimitive} from "../utils"
-import {Node, getNode, getRelativePath} from "./node"
+import { action as mobxAction, isObservable } from "mobx"
 
 export type IActionCall = {
     name: string;
@@ -12,59 +8,56 @@ export type IActionCall = {
 
 export type IActionHandler  = (actionCall: IActionCall, next: () => void) => void
 
-export function createNonActionWrapper(instance: any, key: any, func: any) {
-    addHiddenFinalProp(instance, key, func.bind(instance))
-}
+export function createActionInvoker(name: string, fn: Function) {
+    const action = mobxAction(name, fn)
 
-export function createActionWrapper(instance: any, key: any, action: Function) {
-    addHiddenFinalProp(
-        instance,
-        key,
-        function(...args: any[]) {
-            const adm = getNode(instance)
-            const runAction = () => {
-                return action.apply(instance, args)
-            }
-            if (adm.isRunningAction()) {
-                // an action is already running in this tree, invoking this action does not emit a new action
-                return runAction()
-            } else {
-                // start the action!
-                const root = adm.root
-                root._isRunningAction = true
-                try {
-                    return adm.emitAction(
-                        adm,
-                        {
-                            name: key,
-                            path: "",
-                            args: args.map((arg, index) => serializeArgument(adm, key, index, arg))
-                        },
-                        runAction
-                    )
-                } finally {
-                    root._isRunningAction = false
-                }
+    const actionInvoker = function () {
+        const adm = getMST(this)
+        if (adm.isRunningAction()) {
+            // an action is already running in this tree, invoking this action does not emit a new action
+            return action.apply(this, arguments)
+        } else {
+            // start the action!
+            const root = adm.root
+            const args = arguments
+            root._isRunningAction = true
+            try {
+                return adm.emitAction(
+                    adm,
+                    {
+                        name: name,
+                        path: "",
+                        args: argsToArray(args).map((arg, index) => serializeArgument(adm, name, index, arg))
+                    },
+                    () => action.apply(this, args)
+                )
+            } finally {
+                root._isRunningAction = false
             }
         }
-    )
+    }
+
+    // This construction helps producing a better function name in the stack trace, but could be optimized
+    // away in prod builds, and `invoker` be returned directly
+    return createNamedFunction(name, actionInvoker)
 }
 
-function serializeArgument(adm: Node, actionName: string, index: number, arg: any): any {
+
+function serializeArgument(adm: MSTAdminisration, actionName: string, index: number, arg: any): any {
     if (isPrimitive(arg))
         return arg
-    if (isModel(arg)) {
-        const targetNode = getNode(arg)
+    if (isMST(arg)) {
+        const targetNode = getMST(arg)
         if (adm.root !== targetNode.root)
             throw new Error(`Argument ${index} that was passed to action '${actionName}' is a model that is not part of the same state tree. Consider passing a snapshot or some representative ID instead`)
         return ({
-            $ref: getRelativePath(adm, getNode(arg))
+            $ref: getRelativePath(adm, getMST(arg))
         })
     }
     if (typeof arg === "function")
         throw new Error(`Argument ${index} that was passed to action '${actionName}' should be a primitive, model object or plain object, received a function`)
     if (typeof arg === "object" && !isPlainObject(arg))
-        throw new Error(`Argument ${index} that was passed to action '${actionName}' should be a primitive, model object or plain object, received a ${(arg && arg.constructor) ? arg.constructor.name : "Complex Object"}`)
+        throw new Error(`Argument ${index} that was passed to action '${actionName}' should be a primitive, model object or plain object, received a ${(arg as any && (arg as any).constructor) ? (arg as any).constructor.name : "Complex Object"}`)
     if (isObservable(arg))
         throw new Error(`Argument ${index} that was passed to action '${actionName}' should be a primitive, model object or plain object, received an mobx observable.`)
     try {
@@ -77,7 +70,7 @@ function serializeArgument(adm: Node, actionName: string, index: number, arg: an
     }
 }
 
-function deserializeArgument(adm: Node, value: any): any {
+function deserializeArgument(adm: MSTAdminisration, value: any): any {
     if (typeof value === "object") {
         const keys = Object.keys(value)
         if (keys.length === 1 && keys[0] === "$ref")
@@ -86,10 +79,15 @@ function deserializeArgument(adm: Node, value: any): any {
     return value
 }
 
-export function applyActionLocally(node: Node, instance: any, action: IActionCall) {
+export function applyActionLocally(node: MSTAdminisration, instance: any, action: IActionCall) {
     invariant(typeof instance[action.name] === "function", `Action '${action.name}' does not exist in '${node.path}'`)
     instance[action.name].apply(
         instance,
         action.args ? action.args.map(v => deserializeArgument(node, v)) : []
     )
 }
+
+import {isMST, getMST, getRelativePath} from "./mst-node"
+import {MSTAdminisration} from "./mst-node-administration"
+import {resolve} from "../top-level-api"
+import {invariant, isPlainObject, isPrimitive, argsToArray, createNamedFunction} from "../utils"

src/core/action.ts

@@ -0,0 +1,39 @@
+import { IType, Type, typecheck } from "./type"
+
+/**
+ * A complex type produces a MST node (Node in the state tree)
+ */
+export abstract class ComplexType<S, T> extends Type<S, T> {
+    create(snapshot: any = this.getDefaultSnapshot()) {
+        typecheck(this, snapshot)
+        const instance = this.createNewInstance()
+        // tslint:disable-next-line:no_unused-variable
+        const node = new MSTAdminisration(instance, this)
+        this.finalizeNewInstance(instance, snapshot)
+        Object.seal(instance)
+        return instance
+    }
+
+    abstract createNewInstance(): any
+    abstract finalizeNewInstance(target: any, snapshot: any): void
+    abstract applySnapshot(node: MSTAdminisration, target: any, snapshot: any): void
+    abstract getDefaultSnapshot(): any
+    abstract getChildMSTs(node: MSTAdminisration, target: any): [string, MSTAdminisration][]
+    abstract getChildMST(node: MSTAdminisration, target: any, key: string): MSTAdminisration | null
+    abstract serialize(node: MSTAdminisration, target: any): any
+    abstract applyPatchLocally(node: MSTAdminisration, target: any, subpath: string, patch: IJsonPatch): void
+    abstract getChildType(key: string): IType<any, any>
+    abstract isValidSnapshot(snapshot: any): boolean
+
+    is(value: any): value is S | IMSTNode<S, T> {
+        if (!value || typeof value !== "object")
+            return false
+        if (hasMST(value))
+            return this.isValidSnapshot(getMST(value).snapshot) // could check factory, but that doesn't check structurally...
+        return this.isValidSnapshot(value)
+    }
+}
+
+import { IMSTNode, hasMST, getMST } from "./mst-node"
+import { MSTAdminisration } from "./mst-node-administration"
+import { IJsonPatch } from "./json-patch"

src/core/complex-type.ts

@@ -0,0 +1,6 @@
+export * from "./type"
+export * from "./complex-type"
+export * from "./mst-node"
+export * from "./mst-node-administration"
+export * from "./action"
+export * from "./json-patch"

src/core/factories.ts

@@ -11,8 +11,6 @@ export interface IJsonPatch {
 }
 
 
-// TODO: use https://www.npmjs.com/package/json-pointer
-
 /**
  * escape slashes and backslashes
  * http://tools.ietf.org/html/rfc6901
@@ -32,13 +30,12 @@ export function joinJsonPath(path: string[]): string {
     // `/` refers to property with an empty name, while `` refers to root itself!
     if (path.length === 0)
         return ""
-    return "/" + path.map(escapeJsonPath).join("/")
+    return path.map(escapeJsonPath).join("/")
 }
 
 export function splitJsonPath(path: string): string[] {
     // `/` refers to property with an empty name, while `` refers to root itself!
     if (path === "")
         return []
-    invariant(path[0] === "/", `Expected path to start with '/', got: '${path}'`)
-    return path.substr(1).split("/").map(unescapeJsonPath)
+    return path.replace(/\/$/, "").split("/").map(unescapeJsonPath)
 }