@singularsystems/neo-core 1.0.0-alpha.3 → 1.0.0-beta.0

package/dist/Model/ModelBase.js

@@ -1,180 +1,189 @@
-import { __decorate, __extends, __metadata } from "tslib";
-import * as ModelTraverser from './ModelGraphTraverser';
-import { Computed, NoTracking, Observable } from './Decorators';
-import { JSFormatter } from '../Data/Serialiser';
-import { BindableBase } from './BindableBase';
-import { Misc } from '../';
-import { SerialiseType } from './Misc';
-import { NeoTypes } from '../AppServices';
-/*
- Note:
- Any properties or methods that should not be included in the meta object should also be added to INonObservableModelBase
- Any protected methods that need to be accessed by neo code should be included in IModelBaseInternal
- */
-var ModelBase = /** @class */ (function (_super) {
-    __extends(ModelBase, _super);
-    function ModelBase() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.isNew = true;
-        _this.isSelfDirty = true;
-        return _this;
-    }
-    Object.defineProperty(ModelBase.prototype, "isDirty", {
-        /**
-         * Returns true if the object itself is dirty, or any of its children are dirty.
-         * IsNew does not affect the value of IsDirty.
-         */
-        get: function () {
-            return ModelTraverser.traverseItems(this, new ModelTraverser.BooleanRecursionState(false), function (item, state) {
-                if (item.isSelfDirty) {
-                    state.flag = true;
-                    state.stop = true;
-                }
-            }, function (list, state) {
-                var deletedList = list.deletedList;
-                if (deletedList && deletedList.length > 0) {
-                    state.flag = true;
-                    state.stop = true;
-                }
-            }).flag;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ModelBase.prototype, "isSelfValid", {
-        get: function () {
-            return this.validator.isValid;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ModelBase.prototype, "isValid", {
-        get: function () {
-            return ModelTraverser.traverseItems(this, new ModelTraverser.BooleanRecursionState(true), function (item, state) {
-                if (!item.isSelfValid) {
-                    state.flag = false;
-                    state.stop = true;
-                }
-            }).flag;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ModelBase.prototype, "readyToSave", {
-        /**
-         * Indicates that the model is dirty and valid and can be saved.
-         */
-        get: function () {
-            return this.isDirty && this.isValid;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /** Recursively sets isSelfDirty, and isNew to false on this object and its children. */
-    ModelBase.prototype.markOld = function (recurse) {
-        if (recurse === void 0) { recurse = true; }
-        if (recurse) {
-            ModelTraverser.traverseItems(this, new ModelTraverser.RecursionState(), function (item) {
-                item.isSelfDirty = false;
-                item.isNew = false;
-            });
-        }
-        else {
-            this.isSelfDirty = false;
-            this.isNew = false;
-        }
-    };
-    ModelBase.prototype.toJSObject = function (options) {
-        if (options === void 0) { options = {}; }
-        return JSFormatter.serialise(this, options);
-    };
-    /**
-     * Converts the model into a plain javascript object for use with Utils.getQueryString.
-     * Child objects, child lists and tracking state are ignored.
-     */
-    ModelBase.prototype.toQueryObject = function () {
-        return this.toJSObject({ suppressTrackingState: true, suppressChildren: true });
-    };
-    /**
-     * Passes you a query object every time one of the models properties change.
-     * This is delayed for string and numeric properties.
-     * You must call the disposer when you are done with this object.
-     * @param instance Model instance.
-     * @param callback Callback to run accepting a query object.
-     */
-    ModelBase.prototype.toQueryObjectAuto = function (callback, options) {
-        var _this = this;
-        return Misc.Globals.appService.get(NeoTypes.Core.AutoRunnerFactory).create(this, function () { return callback(_this.toQueryObject()); }, options);
-    };
-    /**
-     * Runs the provided callback whenever any of values of the properties on this object, it's value objects, or child objects (if specified) change.
-     * This is delayed for string and numeric properties.
-     * You must call the disposer when you are done with this object.
-     */
-    ModelBase.prototype.onAnyPropertyChanged = function (callback, options) {
-        return Misc.Globals.appService.get(NeoTypes.Core.AutoRunnerFactory).create(this, callback, options);
-    };
-    /**
-     * Converts a plain javascript object graph to a neo model graph.
-     * Updates child lists - Items in the child list, but not in jsArray will remain in the list.
-     * If you need to replace child lists with the jsArrays, use set() instead.
-     * This will generally be used after calling toJSObject(includeClean = false)
-     * */
-    ModelBase.prototype.update = function (jsObject) {
-        JSFormatter.deserialise(jsObject, this, null);
-    };
-    /**
-     * Performs a deep clone on an object, cloning all nested objects including their entity identifiers.
-     */
-    ModelBase.prototype.cloneWithIdentity = function () {
-        return this.constructor.mapFrom(this, { isMap: { includeEntityIdentifiers: true } });
-    };
-    /**
-     * Icon to display next to toString() text.
-     */
-    ModelBase.prototype.getIcon = function () {
-        return "fa-cube";
-    };
-    /**
-     * Indicates whether or not this object should be serialised.
-     * @param shouldSerialise The value determined by the serialiser.
-     */
-    ModelBase.prototype.canSerialise = function (shouldSerialise) {
-        return shouldSerialise;
-    };
-    /**
-     * Add custom business rules. Note, this will be called once per type and should be treated as static.
-     */
-    ModelBase.prototype.addBusinessRules = function (validationRules) {
-    };
-    __decorate([
-        NoTracking(SerialiseType.Never),
-        Observable(false),
-        __metadata("design:type", Boolean)
-    ], ModelBase.prototype, "isSuspended", void 0);
-    __decorate([
-        NoTracking(SerialiseType.Never),
-        Observable(false),
-        __metadata("design:type", Object)
-    ], ModelBase.prototype, "validator", void 0);
-    __decorate([
-        NoTracking(),
-        __metadata("design:type", Object)
-    ], ModelBase.prototype, "isNew", void 0);
-    __decorate([
-        NoTracking(),
-        __metadata("design:type", Object)
-    ], ModelBase.prototype, "isSelfDirty", void 0);
-    __decorate([
-        Computed(false),
-        __metadata("design:type", Object),
-        __metadata("design:paramtypes", [])
-    ], ModelBase.prototype, "isSelfValid", null);
-    __decorate([
-        Computed(false),
-        __metadata("design:type", Object),
-        __metadata("design:paramtypes", [])
-    ], ModelBase.prototype, "readyToSave", null);
-    return ModelBase;
-}(BindableBase));
-export default ModelBase;
+import { __decorate, __extends, __metadata } from "tslib";
+import * as ModelTraverser from './ModelGraphTraverser';
+import { Action, Computed, NoTracking, Observable } from './Decorators';
+import { JSFormatter } from '../Data/Serialiser';
+import { ValidationRules } from '../Validation/ValidationRules';
+import { BindableBase } from './BindableBase';
+import { Misc } from '../';
+import { SerialiseType } from './Misc';
+import { NeoTypes } from '../AppServices';
+/*
+ Note:
+ Any properties or methods that should not be included in the meta object should also be added to INonObservableModelBase
+ Any protected methods that need to be accessed by neo code should be included in IModelBaseInternal
+ */
+var ModelBase = /** @class */ (function (_super) {
+    __extends(ModelBase, _super);
+    function ModelBase() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.isNew = true;
+        _this.isSelfDirty = true;
+        return _this;
+    }
+    Object.defineProperty(ModelBase.prototype, "isDirty", {
+        /**
+         * Returns true if the object itself is dirty, or any of its children are dirty.
+         * IsNew does not affect the value of IsDirty.
+         */
+        get: function () {
+            return ModelTraverser.traverseItems(this, new ModelTraverser.BooleanRecursionState(false), function (item, state) {
+                if (item.isSelfDirty) {
+                    state.flag = true;
+                    state.stop = true;
+                }
+            }, function (list, state) {
+                var deletedList = list.deletedList;
+                if (deletedList && deletedList.length > 0) {
+                    state.flag = true;
+                    state.stop = true;
+                }
+            }).flag;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ModelBase.prototype, "isSelfValid", {
+        get: function () {
+            return this.validator.isValid;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ModelBase.prototype, "isValid", {
+        get: function () {
+            return ModelTraverser.traverseItems(this, new ModelTraverser.BooleanRecursionState(true), function (item, state) {
+                if (!item.isSelfValid) {
+                    state.flag = false;
+                    state.stop = true;
+                }
+            }).flag;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ModelBase.prototype, "readyToSave", {
+        /**
+         * Indicates that the model is dirty and valid and can be saved.
+         */
+        get: function () {
+            return this.isDirty && this.isValid;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** Recursively sets isSelfDirty, and isNew to false on this object and its children. */
+    ModelBase.prototype.markOld = function (recurse) {
+        if (recurse === void 0) { recurse = true; }
+        if (recurse) {
+            ModelTraverser.traverseItems(this, new ModelTraverser.RecursionState(), function (item) {
+                item.isSelfDirty = false;
+                item.isNew = false;
+            });
+        }
+        else {
+            this.isSelfDirty = false;
+            this.isNew = false;
+        }
+    };
+    ModelBase.prototype.toJSObject = function (options) {
+        if (options === void 0) { options = {}; }
+        return JSFormatter.serialise(this, options);
+    };
+    /**
+     * Converts the model into a plain javascript object for use with Utils.getQueryString.
+     * Child objects, child lists and tracking state are ignored.
+     */
+    ModelBase.prototype.toQueryObject = function () {
+        return this.toJSObject({ suppressTrackingState: true, suppressChildren: true });
+    };
+    /**
+     * Passes you a query object every time one of the models properties change.
+     * This is delayed for string and numeric properties.
+     * You must call the disposer when you are done with this object.
+     * @param instance Model instance.
+     * @param callback Callback to run accepting a query object.
+     */
+    ModelBase.prototype.toQueryObjectAuto = function (callback, options) {
+        var _this = this;
+        return Misc.Globals.appService.get(NeoTypes.Core.AutoRunnerFactory).create(this, function () { return callback(_this.toQueryObject()); }, options);
+    };
+    /**
+     * Runs the provided callback whenever any of values of the properties on this object, it's value objects, or child objects (if specified) change.
+     * This is delayed for string and numeric properties.
+     * You must call the disposer when you are done with this object.
+     */
+    ModelBase.prototype.onAnyPropertyChanged = function (callback, options) {
+        return Misc.Globals.appService.get(NeoTypes.Core.AutoRunnerFactory).create(this, callback, options);
+    };
+    /**
+     * Converts a plain javascript object graph to a neo model graph.
+     * Updates child lists - Items in the child list, but not in jsArray will remain in the list.
+     * If you need to replace child lists with the jsArrays, use set() instead.
+     * This will generally be used after calling toJSObject(includeClean = false)
+     * */
+    ModelBase.prototype.update = function (jsObject) {
+        JSFormatter.deserialise(jsObject, this, null);
+    };
+    /**
+     * Performs a deep clone on an object, cloning all nested objects including their entity identifiers.
+     */
+    ModelBase.prototype.cloneWithIdentity = function () {
+        return this.constructor.mapFrom(this, { isMap: { includeEntityIdentifiers: true } });
+    };
+    /**
+     * Icon to display next to toString() text.
+     */
+    ModelBase.prototype.getIcon = function () {
+        return "fa-cube";
+    };
+    /**
+     * Indicates whether or not this object should be serialised.
+     * @param shouldSerialise The value determined by the serialiser.
+     */
+    ModelBase.prototype.canSerialise = function (shouldSerialise) {
+        return shouldSerialise;
+    };
+    /**
+     * Add custom business rules. Note, this will be called once per type and should be treated as static.
+     */
+    ModelBase.prototype.addBusinessRules = function (validationRules) {
+    };
+    /** The server side type name used to find this type. Include the namespace if there is more than one type with the same name. */
+    ModelBase.typeName = null;
+    __decorate([
+        NoTracking(SerialiseType.Never),
+        Observable(false),
+        __metadata("design:type", Boolean)
+    ], ModelBase.prototype, "isSuspended", void 0);
+    __decorate([
+        NoTracking(SerialiseType.Never),
+        Observable(false),
+        __metadata("design:type", Object)
+    ], ModelBase.prototype, "validator", void 0);
+    __decorate([
+        NoTracking(),
+        __metadata("design:type", Object)
+    ], ModelBase.prototype, "isNew", void 0);
+    __decorate([
+        NoTracking(),
+        __metadata("design:type", Object)
+    ], ModelBase.prototype, "isSelfDirty", void 0);
+    __decorate([
+        Computed(false),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [])
+    ], ModelBase.prototype, "isSelfValid", null);
+    __decorate([
+        Computed(false),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [])
+    ], ModelBase.prototype, "readyToSave", null);
+    __decorate([
+        Action(false),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [ValidationRules]),
+        __metadata("design:returntype", void 0)
+    ], ModelBase.prototype, "addBusinessRules", null);
+    return ModelBase;
+}(BindableBase));
+export default ModelBase;

package/dist/Model/ModelCreatorBase.d.ts

@@ -1,23 +1,23 @@
-import { NeoTypeInfo } from './NeoTypeInfo';
-import { NeoModelConstructor } from './IModelBase';
-import PropertyInfo from './PropertyInfo';
-export declare abstract class ModelCreatorBase {
-    protected typeInfo: NeoTypeInfo;
-    protected alwaysInitialiseMembers: boolean;
-    /**
-     * True if all properties and methods need to be present in the property / method lists.
-     * Otherwise only decorated members will be present (Mobx = only decorated, Vue = all)
-     */
-    get shouldInitialiseAllMembers(): boolean;
-    isBindableBase(type: NeoModelConstructor): boolean;
-    isModelBase(type: NeoModelConstructor): boolean;
-    initialise(typeInfo: NeoTypeInfo, originalConstructor: NeoModelConstructor): void;
-    private addPrototypeProperties;
-    /**
-     * Ensures that lists / child objects have the correct relationType.
-     */
-    protected ensureChildInfo(instance: {}, propertyInfo: PropertyInfo): void;
-    protected addMethodInfo(methodName: string, method: Function): void;
-    protected addProperty(propertyName: string, descriptor: PropertyDescriptor): void;
-    abstract convertInstance(instance: {}): {};
-}
+import { NeoTypeInfo } from './NeoTypeInfo';
+import { IMakeBindableOptions, NeoModelConstructor } from './IModelBase';
+import PropertyInfo from './PropertyInfo';
+import IModelCreatorBase from './IModelCreatorBase';
+export declare abstract class ModelCreatorBase implements IModelCreatorBase {
+    protected typeInfo: NeoTypeInfo;
+    protected alwaysInitialiseMembers: boolean;
+    /**
+     * True if all properties and methods need to be present in the property / method lists.
+     * Otherwise only decorated members will be present (Mobx = only decorated, Vue = all)
+     */
+    get shouldInitialiseAllMembers(): boolean;
+    isBindableBase(type: NeoModelConstructor): boolean;
+    isModelBase(type: NeoModelConstructor): boolean;
+    initialise(typeInfo: NeoTypeInfo, originalConstructor: NeoModelConstructor): void;
+    private addPrototypeProperties;
+    /**
+     * Ensures that lists / child objects have the correct relationType.
+     */
+    protected ensureChildInfo(instance: {}, propertyInfo: PropertyInfo): void;
+    protected addMethodInfo(methodName: string, method: Function): void;
+    abstract convertInstance(instance: {}, options: IMakeBindableOptions): {};
+}

package/dist/Model/ModelCreatorBase.js

@@ -1,92 +1,91 @@
-import { __decorate } from "tslib";
-import { injectable } from 'inversify';
-import ModelBase from './ModelBase';
-import { RelationType } from './Misc';
-import { ChildList, ChildObject } from './Decorators';
-import ValueObject from './ValueObject';
-import { BindableBase } from './BindableBase';
-var ModelCreatorBase = /** @class */ (function () {
-    function ModelCreatorBase() {
-        this.alwaysInitialiseMembers = false;
-    }
-    Object.defineProperty(ModelCreatorBase.prototype, "shouldInitialiseAllMembers", {
-        /**
-         * True if all properties and methods need to be present in the property / method lists.
-         * Otherwise only decorated members will be present (Mobx = only decorated, Vue = all)
-         */
-        get: function () {
-            return this.typeInfo.inheritsBindableBase || this.alwaysInitialiseMembers;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ModelCreatorBase.prototype.isBindableBase = function (type) {
-        return type === BindableBase;
-    };
-    ModelCreatorBase.prototype.isModelBase = function (type) {
-        return type === ModelBase;
-    };
-    ModelCreatorBase.prototype.initialise = function (typeInfo, originalConstructor) {
-        this.typeInfo = typeInfo;
-        if (this.shouldInitialiseAllMembers) {
-            this.addPrototypeProperties(originalConstructor);
-        }
-    };
-    ModelCreatorBase.prototype.addPrototypeProperties = function (ctor) {
-        var prototype = ctor.prototype;
-        for (var _i = 0, _a = Object.getOwnPropertyNames(prototype); _i < _a.length; _i++) {
-            var propertyName = _a[_i];
-            if (propertyName !== "constructor") {
-                // Read only properties are converted to computeds
-                var descriptor = Object.getOwnPropertyDescriptor(prototype, propertyName);
-                if (descriptor.value !== void 0) {
-                    // Method
-                    if (typeof descriptor.value === 'function') {
-                        this.addMethodInfo(propertyName, descriptor.value);
-                    }
-                }
-                else if (descriptor.get) {
-                    if (this.typeInfo.inheritsBindableBase) {
-                        this.typeInfo.addComputed(propertyName, descriptor);
-                    }
-                    else {
-                        // for general objects, getters must explicitly define @Computed to become computed properties.
-                        this.addProperty(propertyName, descriptor);
-                    }
-                }
-            }
-        }
-    };
-    /**
-     * Ensures that lists / child objects have the correct relationType.
-     */
-    ModelCreatorBase.prototype.ensureChildInfo = function (instance, propertyInfo) {
-        var propertyValue = instance[propertyInfo.propertyName];
-        if (propertyValue) {
-            if (propertyValue.childObjectType) {
-                // This is a list.
-                if (propertyInfo.relationType != RelationType.ChildList) {
-                    // add missing annotation
-                    propertyInfo = ChildList(propertyValue.childObjectType)(instance, propertyInfo.propertyName);
-                }
-            }
-            else if (propertyValue instanceof ModelBase) {
-                // Child object
-                var isValueObject = propertyValue instanceof ValueObject;
-                var relationType = isValueObject ? RelationType.ValueObject : RelationType.ChildObject;
-                if (propertyInfo.relationType != relationType) {
-                    propertyInfo = ChildObject(propertyValue.constructor, isValueObject)(instance, propertyInfo.propertyName);
-                }
-            }
-        }
-    };
-    ModelCreatorBase.prototype.addMethodInfo = function (methodName, method) {
-    };
-    ModelCreatorBase.prototype.addProperty = function (propertyName, descriptor) {
-    };
-    ModelCreatorBase = __decorate([
-        injectable()
-    ], ModelCreatorBase);
-    return ModelCreatorBase;
-}());
-export { ModelCreatorBase };
+import { __decorate } from "tslib";
+import { injectable } from 'inversify';
+import ModelBase from './ModelBase';
+import { RelationType } from './Misc';
+import { ChildList, ChildObject } from './Decorators';
+import ValueObject from './ValueObject';
+import { BindableBase } from './BindableBase';
+var nonActionMethods = ["addBusinessRules", "toString"];
+export var ModelCreatorBase = /** @class */ (function () {
+    function ModelCreatorBase() {
+        this.alwaysInitialiseMembers = false;
+    }
+    Object.defineProperty(ModelCreatorBase.prototype, "shouldInitialiseAllMembers", {
+        /**
+         * True if all properties and methods need to be present in the property / method lists.
+         * Otherwise only decorated members will be present (Mobx = only decorated, Vue = all)
+         */
+        get: function () {
+            return this.typeInfo.inheritsBindableBase || this.alwaysInitialiseMembers;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ModelCreatorBase.prototype.isBindableBase = function (type) {
+        return type === BindableBase;
+    };
+    ModelCreatorBase.prototype.isModelBase = function (type) {
+        return type === ModelBase;
+    };
+    ModelCreatorBase.prototype.initialise = function (typeInfo, originalConstructor) {
+        this.typeInfo = typeInfo;
+        if (this.shouldInitialiseAllMembers) {
+            this.addPrototypeProperties(originalConstructor);
+        }
+    };
+    ModelCreatorBase.prototype.addPrototypeProperties = function (ctor) {
+        var prototype = ctor.prototype;
+        for (var _i = 0, _a = Object.getOwnPropertyNames(prototype); _i < _a.length; _i++) {
+            var propertyName = _a[_i];
+            if (propertyName !== "constructor") {
+                // Read only properties are converted to computeds
+                var descriptor = Object.getOwnPropertyDescriptor(prototype, propertyName);
+                if (descriptor.value !== void 0) {
+                    // Method
+                    if (typeof descriptor.value === 'function') {
+                        this.addMethodInfo(propertyName, descriptor.value);
+                    }
+                }
+                else if (descriptor.get) {
+                    if (this.typeInfo.inheritsBindableBase) {
+                        this.typeInfo.addComputed(propertyName, descriptor);
+                    }
+                }
+            }
+        }
+    };
+    /**
+     * Ensures that lists / child objects have the correct relationType.
+     */
+    ModelCreatorBase.prototype.ensureChildInfo = function (instance, propertyInfo) {
+        // @ts-ignore
+        var propertyValue = instance[propertyInfo.propertyName];
+        if (propertyValue) {
+            if (propertyValue.childObjectType) {
+                // This is a list.
+                if (propertyInfo.relationType != RelationType.ChildList) {
+                    // add missing annotation
+                    propertyInfo = ChildList(propertyValue.childObjectType)(instance, propertyInfo.propertyName);
+                }
+            }
+            else if (propertyValue instanceof ModelBase) {
+                // Child object
+                var isValueObject = propertyValue instanceof ValueObject;
+                var relationType = isValueObject ? RelationType.ValueObject : RelationType.ChildObject;
+                if (propertyInfo.relationType != relationType) {
+                    propertyInfo = ChildObject(propertyValue.constructor, isValueObject)(instance, propertyInfo.propertyName);
+                }
+            }
+        }
+    };
+    ModelCreatorBase.prototype.addMethodInfo = function (methodName, method) {
+        var methodInfo = this.typeInfo.addMethod(methodName);
+        if (nonActionMethods.indexOf(methodInfo.name) >= 0) {
+            methodInfo.isAction = false;
+        }
+    };
+    ModelCreatorBase = __decorate([
+        injectable()
+    ], ModelCreatorBase);
+    return ModelCreatorBase;
+}());