@webda/core 1.2.1 → 1.6.0-beta.0

package/lib/stores/store.js

@@ -9,19 +9,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Store = exports.StoreParameters = void 0;
-const uuid_1 = require("uuid");
+exports.Store = exports.StoreParameters = exports.UpdateConditionFailError = exports.StoreNotFoundError = void 0;
+const core_1 = require("../core");
+const coremodel_1 = require("../models/coremodel");
 const service_1 = require("../services/service");
+class StoreNotFoundError extends core_1.WebdaError {
+    constructor(uuid, storeName) {
+        super("STORE_NOTFOUND", `Item not found ${uuid} Store(${storeName})`);
+    }
+}
+exports.StoreNotFoundError = StoreNotFoundError;
+class UpdateConditionFailError extends core_1.WebdaError {
+    constructor(uuid, conditionField, condition) {
+        super("STORE_UPDATE_CONDITION_FAILED", `UpdateCondition not met on ${uuid}.${conditionField} === ${condition instanceof Date ? condition.toISOString() : condition}`);
+    }
+}
+exports.UpdateConditionFailError = UpdateConditionFailError;
 /**
  * Store parameter
  */
 class StoreParameters extends service_1.ServiceParameters {
     constructor(params, service) {
-        var _a, _b, _c;
+        var _a, _b;
         super(params);
-        (_a = this.lastUpdateField) !== null && _a !== void 0 ? _a : (this.lastUpdateField = "_lastUpdate");
-        (_b = this.creationDateField) !== null && _b !== void 0 ? _b : (this.creationDateField = "_creationDate");
-        (_c = this.model) !== null && _c !== void 0 ? _c : (this.model = "Webda/CoreModel");
+        (_a = this.model) !== null && _a !== void 0 ? _a : (this.model = "Webda/CoreModel");
         let expose = params.expose;
         if (typeof expose == "boolean") {
             expose = {};
@@ -39,6 +50,13 @@ class StoreParameters extends service_1.ServiceParameters {
             expose.restrict = expose.restrict || {};
             this.expose = expose;
         }
+        if (params.map) {
+            throw new Error("Deprecated map usage, use a MapperService");
+        }
+        if (params.index) {
+            throw new Error("Deprecated index usage, use an AggregatorService");
+        }
+        (_b = this.strict) !== null && _b !== void 0 ? _b : (this.strict = true);
     }
 }
 exports.StoreParameters = StoreParameters;
@@ -79,8 +97,13 @@ exports.StoreParameters = StoreParameters;
 class Store extends service_1.Service {
     constructor() {
         super(...arguments);
+        /**
+         * Contain the reverse map
+         */
         this._reverseMap = [];
-        this._cascade = [];
+        /**
+         * Contain the model uuid field
+         */
         this._uuidField = "uuid";
     }
     /**
@@ -98,31 +121,31 @@ class Store extends service_1.Service {
         super.computeParameters();
         const p = this.parameters;
         this._model = this._webda.getModel(p.model);
-        if (!this._model) {
-            throw new Error(`${p.model} model is not found`);
-        }
         this._uuidField = this._model.getUuidField();
-        this._lastUpdateField = p.lastUpdateField || "_lastUpdate";
-        this._creationDateField = p.creationDateField || "_creationDate";
+        this._lastUpdateField = this._model.getLastUpdateField();
+        this._creationDateField = this._model.getCreationField();
     }
+    /**
+     * Return Store current model
+     * @returns
+     */
     getModel() {
         return this._model;
     }
-    getUuidField() {
-        return this._uuidField;
+    getLastUpdateField() {
+        return this._model.getLastUpdateField();
     }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.initMap(this.parameters.map);
-            if (this.parameters.index) {
-                yield this.createIndex();
-            }
-        });
+    getObject(uid) {
+        return this._get(uid);
     }
+    /**
+     * @inheritdoc
+     */
     initRoutes() {
         if (!this.parameters.expose) {
             return;
         }
+        // We enforce ExposeParameters within the constructor
         const expose = this.parameters.expose;
         if (!expose.restrict.create) {
             this.addRoute(expose.url, ["POST"], this.httpCreate, {
@@ -155,7 +178,6 @@ class Store extends service_1.Service {
         if (!expose.restrict.delete) {
             methods.push("DELETE");
         }
-        this._exposeUrl = expose.url;
         if (methods.length) {
             this.addRoute(expose.url + "/{uuid}", methods, this.httpRoute, {
                 model: this._model.name,
@@ -215,86 +237,77 @@ class Store extends service_1.Service {
             let actions = this._model.getActions();
             Object.keys(actions).forEach(name => {
                 let action = actions[name];
-                action.name = name;
-                if (!action.name) {
-                    throw Error("Action needs a name got:" + action);
-                }
-                if (!action.method) {
-                    action.method = ["PUT"];
+                if (!action.methods) {
+                    action.methods = ["PUT"];
                 }
+                let executer;
                 if (action.global) {
                     // By default will grab the object and then call the action
-                    if (!action._method) {
-                        if (!this._model["_" + action.name]) {
-                            throw Error("Action static method _" + action.name + " does not exist");
-                        }
-                        action._method = this.httpGlobalAction;
+                    if (!this._model["_" + name]) {
+                        throw Error("Action static method _" + name + " does not exist");
                     }
-                    this.addRoute(expose.url + "/" + action.name, action.method, action._method, action.openapi);
+                    executer = this.httpGlobalAction;
+                    this.addRoute(expose.url + "/" + name, action.methods, executer, action.openapi);
                 }
                 else {
                     // By default will grab the object and then call the action
-                    if (!action._method) {
-                        if (!this._model.prototype["_" + action.name]) {
-                            throw Error("Action method _" + action.name + " does not exist");
-                        }
-                        action._method = this.httpAction;
+                    if (!this._model.prototype["_" + name]) {
+                        throw Error("Action method _" + name + " does not exist");
                     }
-                    this.addRoute(expose.url + "/{uuid}/" + action.name, action.method, action._method, action.openapi);
+                    executer = this.httpAction;
+                    this.addRoute(expose.url + "/{uuid}/" + name, action.methods, executer, action.openapi);
                 }
             });
         }
     }
+    /**
+     * Get the url where the store is exposed
+     */
     getUrl() {
-        return this._exposeUrl;
+        return this.parameters.expose.url;
     }
+    /**
+     * Init a model from the current stored data
+     *
+     * Initial the reverse map as well
+     *
+     * @param object
+     * @returns
+     */
     initModel(object = {}) {
+        var _a;
+        var _b;
         // Make sure to send a model object
         if (!(object instanceof this._model)) {
             let model = new this._model();
             model.load(object, true);
             object = model;
         }
+        if (!object.getUuid()) {
+            object.setUuid(object.generateUid(object));
+        }
         object.__store = this;
         for (var i in this._reverseMap) {
+            (_a = object[_b = this._reverseMap[i].property]) !== null && _a !== void 0 ? _a : (object[_b] = []);
             for (var j in object[this._reverseMap[i].property]) {
-                object[this._reverseMap[i].property][j] = this._reverseMap[i].store.initModel(object[this._reverseMap[i].property][j]);
+                // Use Partial
+                object[this._reverseMap[i].property][j] = this._reverseMap[i].mapper.initModel(object[this._reverseMap[i].property][j]);
                 object[this._reverseMap[i].property][j].setContext(object.getContext());
             }
         }
         return object;
     }
-    addReverseMap(prop, cascade, store) {
+    /**
+     * Add reverse map information
+     *
+     * @param prop
+     * @param cascade
+     * @param store
+     */
+    addReverseMap(prop, store) {
         this._reverseMap.push({
             property: prop,
-            store: store
-        });
-        if (cascade) {
-            this._cascade.push(cascade);
-        }
-    }
-    isMapped(property) {
-        if (property === undefined) {
-            return false;
-        }
-        if (!this.parameters.map) {
-            return false;
-        }
-        let map = this.parameters.map;
-        for (let prop in map) {
-            // No mapped property or not in the object
-            if (map[prop].key === undefined) {
-                continue;
-            }
-            if (map[prop].fields.split(",").indexOf(property) >= 0) {
-                return true;
-            }
-        }
-        return false;
-    }
-    _incrementAttribute(uid, prop, value, updateDate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw Error("Virtual abstract class - concrete only for MixIn usage");
+            mapper: store
         });
     }
     incrementAttribute(uid, prop, value) {
@@ -305,10 +318,10 @@ class Store extends service_1.Service {
             }
             let updateDate = new Date();
             yield this._incrementAttribute(uid, prop, value, updateDate);
-            yield this._handleMapFromPartial(uid, updateDate, prop);
             return this.emitSync("Store.PartialUpdated", {
                 object_id: uid,
                 store: this,
+                updateDate,
                 partial_update: {
                     increment: {
                         value: value,
@@ -325,10 +338,10 @@ class Store extends service_1.Service {
             }
             let updateDate = new Date();
             yield this._upsertItemToCollection(uid, prop, item, index, itemWriteCondition, itemWriteConditionField, updateDate);
-            yield this._handleMapFromPartial(uid, updateDate);
             yield this.emitSync("Store.PartialUpdated", {
                 object_id: uid,
                 store: this,
+                updateDate,
                 partial_update: {
                     addItem: {
                         value: item,
@@ -339,39 +352,14 @@ class Store extends service_1.Service {
             });
         });
     }
-    _handleMapFromPartial(uid, updateDate, prop = undefined) {
+    deleteItemFromCollection(uid, prop, index, itemWriteCondition, itemWriteConditionField = this._uuidField) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.isMapped(prop) || this.isMapped(this._lastUpdateField)) {
-                // Not optimal need to reload the object
-                let object = yield this._get(uid);
-                let updates = {};
-                updates[this._lastUpdateField] = updateDate;
-                if (this.isMapped(prop)) {
-                    updates[prop] = object.prop;
-                }
-                yield this.handleMap(object, this.parameters.map, updates);
-            }
-        });
-    }
-    _upsertItemToCollection(uid, prop, item, index, itemWriteCondition, itemWriteConditionField, updateDate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw Error("Virtual abstract class - concrete only for MixIn usage");
-        });
-    }
-    deleteItemFromCollection(uid, prop, index, itemWriteCondition, itemWriteConditionField) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (index === undefined || prop === undefined) {
-                throw Error("Invalid Argument");
-            }
-            if (itemWriteConditionField === undefined) {
-                itemWriteConditionField = this._uuidField;
-            }
             let updateDate = new Date();
             yield this._deleteItemFromCollection(uid, prop, index, itemWriteCondition, itemWriteConditionField, updateDate);
-            yield this._handleMapFromPartial(uid, updateDate);
             yield this.emitSync("Store.PartialUpdated", {
                 object_id: uid,
                 store: this,
+                updateDate,
                 partial_update: {
                     deleteItem: {
                         property: prop,
@@ -381,76 +369,26 @@ class Store extends service_1.Service {
             });
         });
     }
-    _deleteItemFromCollection(uid, prop, index, itemWriteCondition, itemWriteConditionField, updateDate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw Error("Virtual abstract class - concrete only for MixIn usage");
-        });
-    }
-    createIndex() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.parameters.index || (yield this.exists("index"))) {
-                return;
-            }
-            let index = {};
-            index[this._uuidField] = "index";
-            index[this._lastUpdateField] = new Date();
-            yield this.save(index);
-        });
-    }
-    initMap(map) {
-        if (map == undefined || map._init) {
-            return;
-        }
-        for (var prop in map) {
-            var reverseStore = this._webda.getService(prop);
-            if (reverseStore === undefined || !(reverseStore instanceof Store)) {
-                map[prop]["-onerror"] = "NoStore";
-                this.log("WARN", "Can't setup mapping as store \"", prop, "\" doesn't exist");
-                continue;
-            }
-            var cascade = undefined;
-            if (map[prop].cascade) {
-                cascade = {
-                    store: this._name,
-                    name: map[prop].target
-                };
-            }
-            reverseStore.addReverseMap(map[prop].target, cascade, this);
-        }
-    }
-    toString() {
-        return this.parameters.type + "[" + this._name + "]";
-    }
-    generateUid() {
-        return uuid_1.v4();
-    }
     /**
      * Save an object
      *
      * @param {Object} Object to save
      * @param {String} Uuid to use, if not specified take the object.uuid or generate one if not found
      * @return {Promise} with saved object
+     *
+     * Might want to rename to create
      */
     save(object, ctx = undefined) {
+        var _a;
+        var _b;
         return __awaiter(this, void 0, void 0, function* () {
-            /** @ignore */
-            for (var i in this._reverseMap) {
-                if (object[this._reverseMap[i].property] === undefined) {
-                    object[this._reverseMap[i].property] = [];
-                }
-            }
-            object[this._creationDateField] = object[this._lastUpdateField] = new Date();
             object = this.initModel(object);
+            // Dates should be store by the Store
+            (_a = object[_b = this._creationDateField]) !== null && _a !== void 0 ? _a : (object[_b] = new Date());
+            object[this._lastUpdateField] = new Date();
             if (ctx) {
                 object.setContext(ctx);
             }
-            if (!object[this._uuidField]) {
-                object[this._uuidField] = object.generateUid();
-                object[this._creationDateField] = new Date();
-                if (!object[this._uuidField]) {
-                    object[this._uuidField] = this.generateUid();
-                }
-            }
             yield this.emitSync("Store.Save", {
                 object: object,
                 store: this
@@ -464,35 +402,68 @@ class Store extends service_1.Service {
                 store: this
             });
             yield object._onSaved();
-            if (this.parameters.map != undefined) {
-                yield this.handleMap(object, this.parameters.map, "created");
-            }
-            // Handle index
-            if (this.parameters.index && object[this._uuidField] !== "index" && object[this._uuidField]) {
-                yield this.handleIndex(object, "created");
-            }
             return object;
         });
     }
-    _save(object) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw Error("Virtual abstract class - concrete only for MixIn usage");
-        });
-    }
+    /**
+     * Patch an object
+     *
+     * @param object
+     * @param reverseMap
+     * @returns
+     */
     patch(object, reverseMap = true) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.update(object, reverseMap, true);
         });
     }
-    emulateUpsertItemToCollection(model, prop, item, index, itemWriteCondition, itemWriteConditionField, updateDate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (model === undefined) {
-                throw Error("NotFound");
+    /**
+     * Check if an UpdateCondition is met
+     * @param model
+     * @param conditionField
+     * @param condition
+     * @param uid
+     */
+    checkUpdateCondition(model, conditionField, condition, uid) {
+        if (conditionField) {
+            if (model[conditionField] !== condition) {
+                throw new UpdateConditionFailError(uid ? uid : model.getUuid(), conditionField, condition);
             }
+        }
+    }
+    /**
+     * Check if an UpdateCondition is met
+     * @param model
+     * @param conditionField
+     * @param condition
+     * @param uid
+     */
+    checkCollectionUpdateCondition(model, collection, conditionField, condition, index) {
+        // No index so addition to collection
+        if (index === null) {
+            // The condition must be length of the collection
+            if (!model[collection] || model[collection].length !== condition) {
+                throw new UpdateConditionFailError(model.getUuid(), collection, condition);
+            }
+        }
+        else if (condition && model[collection][index][conditionField] !== condition) {
+            throw new UpdateConditionFailError(model.getUuid(), `${collection}[${index}].${conditionField}`, condition);
+        }
+    }
+    /**
+     *
+     * @param model
+     * @param prop
+     * @param item
+     * @param index
+     * @param itemWriteCondition
+     * @param itemWriteConditionField
+     * @param updateDate
+     */
+    simulateUpsertItemToCollection(model, prop, item, updateDate, index, itemWriteCondition, itemWriteConditionField) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkCollectionUpdateCondition(model, prop, itemWriteConditionField, itemWriteCondition, index);
             if (index === undefined) {
-                if (itemWriteCondition !== undefined && model[prop].length !== itemWriteCondition) {
-                    throw Error("UpdateCondition not met");
-                }
                 if (model[prop] === undefined) {
                     model[prop] = [item];
                 }
@@ -501,9 +472,6 @@ class Store extends service_1.Service {
                 }
             }
             else {
-                if (itemWriteCondition && model[prop][index][itemWriteConditionField] != itemWriteCondition) {
-                    throw Error("UpdateCondition not met");
-                }
                 model[prop][index] = item;
             }
             model[this._lastUpdateField] = updateDate;
@@ -531,16 +499,18 @@ class Store extends service_1.Service {
                 }
             }
             let partialEvent = partial ? "Patch" : "";
-            if (Object.keys(object).length === 0) {
+            if (Object.keys(object).length < 2) {
                 return {};
             }
             object[this._lastUpdateField] = new Date();
-            let load = yield this._get(object[this._uuidField]);
+            let load = yield this._get(object[this._uuidField], true);
+            if (load.__type !== this._model.name && this.parameters.strict) {
+                this.log("WARN", `Object '${object[this._uuidField]}' was not created by this store`);
+                throw new StoreNotFoundError(object[this._uuidField], this.getName());
+            }
             loaded = this.initModel(load);
-            yield this.handleMap(loaded, this.parameters.map, object);
-            // Handle index
-            if (this.parameters.index && loaded[this._uuidField] !== "index" && loaded[this._uuidField]) {
-                yield this.handleIndex(loaded, object);
+            if (object instanceof coremodel_1.CoreModel) {
+                loaded.setContext(object.getContext());
             }
             yield this.emitSync(`Store.${partialEvent}Update`, {
                 object: loaded,
@@ -576,241 +546,45 @@ class Store extends service_1.Service {
             return saved;
         });
     }
-    getMapper(map, uuid) {
-        for (var i = 0; i < map.length; i++) {
-            if (map[i][this._uuidField] === uuid) {
-                return i;
-            }
-        }
-        return -1;
-    }
-    removeMapper(map, uuid) {
-        let i = this.getMapper(map, uuid);
-        if (i >= 0) {
-            map.splice(i, 1);
-            return true;
-        }
-        return false;
-    }
-    _handleUpdatedMap(object, map, mapped, store, updates) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var mapper = {};
-            mapper[this._uuidField] = object[this._uuidField];
-            // Update only if the key field has been updated
-            var found = false;
-            for (var field in updates) {
-                if (map.fields) {
-                    let fields = map.fields.split(",");
-                    for (let i in fields) {
-                        let mapperfield = fields[i];
-                        // Create the mapper object
-                        if (updates[mapperfield] !== undefined) {
-                            mapper[mapperfield] = updates[mapperfield];
-                            found = true;
-                        }
-                        else if (object[mapperfield] !== undefined) {
-                            mapper[mapperfield] = object[mapperfield];
-                        }
-                    }
-                }
-                // TODO Need to verify also if fields are updated
-                if (field == map.key) {
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) {
-                // None of the mapped keys has been modified -> return
-                return;
-            }
-            // check if reference object has changed
-            if (updates[map.key] != undefined && mapped[this._uuidField] != updates[map.key]) {
-                // create mapper
-                if (map.fields) {
-                    let fields = map.fields.split(",");
-                    for (var j in fields) {
-                        let mapperfield = fields[j];
-                        // Create the mapper object
-                        if (updates[mapperfield] !== undefined) {
-                            mapper[mapperfield] = updates[mapperfield];
-                        }
-                        else if (object[mapperfield] !== undefined) {
-                            mapper[mapperfield] = object[mapperfield];
-                        }
-                    }
-                }
-                let i = this.getMapper(mapped[map.target], object[this._uuidField]);
-                if (i >= 0) {
-                    // Remove the data from old object
-                    yield store.deleteItemFromCollection(mapped[this._uuidField], map.target, i, object[this._uuidField], this._uuidField);
-                }
-                // Add the data to new object
-                yield store.upsertItemToCollection(updates[map.key], map.target, mapper);
-            }
-            else {
-                return this._handleUpdatedMapMapper(object, map, mapped, store, updates);
-            }
-        });
-    }
-    _handleUpdatedMapTransferOut(object, map, mapped, store, updates) {
-        var update = {};
-        update[map.target] = mapped[map.target];
-        return store.update(update, mapped[this._uuidField], false).then(() => {
-            return this._handleUpdatedMapTransferIn(object, map, store, updates);
-        });
-    }
-    _handleUpdatedMapTransferIn(object, map, store, updates) {
-        // TODO Should be update
-        return store.get(updates[map.key]).then(mapped => {
-            if (mapped == undefined) {
-                return Promise.resolve();
-            }
-            // Enforce the collection if needed
-            if (mapped[map.target] == undefined) {
-                mapped[map.target] = [];
-            }
-            return this._handleUpdatedMapMapper(object, map, mapped, store, updates);
-        });
-    }
-    _handleUpdatedMapMapper(object, map, mapped, store, updates) {
-        // Update the mapper
-        var mapper = {};
-        mapper[this._uuidField] = object[this._uuidField];
-        if (map.fields) {
-            var fields = map.fields.split(",");
-            for (var field in fields) {
-                if (updates[fields[field]] != undefined) {
-                    mapper[fields[field]] = updates[fields[field]];
-                }
-                else {
-                    mapper[fields[field]] = object[fields[field]];
-                }
-            }
-        }
-        // Remove old reference
-        let i = this.getMapper(mapped[map.target], object[this._uuidField]);
-        // If not found just add it to the collection
-        if (i < 0) {
-            return store.upsertItemToCollection(mapped[this._uuidField], map.target, mapper);
-        }
-        // Else update with a check on the uuid
-        return store.upsertItemToCollection(mapped[this._uuidField], map.target, mapper, i, object[this._uuidField], this._uuidField);
-    }
-    _handleDeletedMap(object, map, mapped, store) {
-        // Remove from the collection
-        if (mapped[map.target] === undefined) {
-            return Promise.resolve();
-        }
-        let i = this.getMapper(mapped[map.target], object[this._uuidField]);
-        if (i >= 0) {
-            return store.deleteItemFromCollection(mapped[this._uuidField], map.target, i, object[this._uuidField], this._uuidField);
-        }
-        return Promise.resolve();
-    }
-    _handleCreatedMap(object, map, mapped, store) {
-        // Add to the object
-        var mapper = {};
-        mapper[this._uuidField] = object[this._uuidField];
-        // Add info to the mapped
-        if (map.fields) {
-            var fields = map.fields.split(",");
-            for (var field in fields) {
-                mapper[fields[field]] = object[fields[field]];
-            }
-        }
-        return store.upsertItemToCollection(mapped[this._uuidField], map.target, mapper);
-    }
-    _handleMapProperty(store, object, property, updates) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let mapped = yield store.get(object[property.key] || updates[property.key]);
-            if (mapped == undefined) {
-                return;
-            }
-            if (updates === "created") {
-                return this._handleCreatedMap(object, property, mapped, store);
-            }
-            else if (updates == "deleted") {
-                return this._handleDeletedMap(object, property, mapped, store);
-            }
-            else if (typeof updates == "object") {
-                return this._handleUpdatedMap(object, property, mapped, store, updates);
-            }
-            else {
-                return Promise.reject(Error("Unknown handleMap type " + updates));
-            }
-        });
-    }
-    removeAttribute(uuid, attribute) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._removeAttribute(uuid, attribute);
-        });
-    }
-    handleIndex(object, updates) {
+    /**
+     * Remove an attribute from an object
+     *
+     * @param uuid
+     * @param attribute
+     * @returns
+     */
+    removeAttribute(uuid, attribute, itemWriteCondition, itemWriteConditionField) {
         return __awaiter(this, void 0, void 0, function* () {
-            let mapUpdates = {};
-            if (typeof updates === "object") {
-                let toUpdate = false;
-                for (let i in updates) {
-                    if (this.parameters.index.indexOf(i) >= 0) {
-                        toUpdate = true;
-                    }
-                }
-                if (!toUpdate) {
-                    return;
+            yield this._removeAttribute(uuid, attribute, itemWriteCondition, itemWriteConditionField);
+            yield this.emitSync("Store.PartialUpdated", {
+                object_id: uuid,
+                partial_update: {
+                    deleteAttribute: attribute
                 }
-            }
-            else if (updates === "deleted") {
-                yield this.removeAttribute("index", object[this._uuidField]);
-                return;
-            }
-            else if (updates === "created") {
-                updates = object;
-            }
-            let mapper = {};
-            this.parameters.index.forEach(id => {
-                mapper[id] = updates[id];
             });
-            mapUpdates[object[this._uuidField]] = mapper;
-            mapUpdates[this._lastUpdateField] = new Date();
-            yield this._patch(mapUpdates, "index");
         });
     }
-    handleMap(object, map, updates) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let promises = [];
-            if (object === undefined) {
-                return;
-            }
-            for (let prop in map) {
-                // No mapped property or not in the object
-                if (map[prop].key === undefined ||
-                    (object[map[prop].key] === undefined && updates[map[prop].key] === undefined)) {
-                    continue;
-                }
-                let store = this.getService(prop);
-                // Cant find the store for this collection
-                if (store == undefined) {
-                    continue;
-                }
-                promises.push(this._handleMapProperty(store, object, map[prop], updates));
-            }
-            return Promise.all(promises);
-        });
-    }
-    _update(object, uid, itemWriteCondition = undefined, itemWriteConditionField = undefined) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw Error("Virtual abstract class - concrete only for MixIn usage");
-        });
-    }
-    _patch(object, uid, itemWriteCondition = undefined, itemWriteConditionField = undefined) {
+    /**
+     * Cascade delete a related object
+     *
+     * @param obj
+     * @param uuid
+     * @returns
+     */
+    cascadeDelete(obj, uuid) {
         return __awaiter(this, void 0, void 0, function* () {
-            throw Error("Virtual abstract class - concrete only for MixIn usage");
+            // We dont need uuid but Binary store will need it
+            return this.delete(obj.getUuid());
         });
     }
-    cascadeDelete(obj, uuid) {
+    /**
+     * Delete an object from the store without condition nor async
+     * @param uid to delete
+     * @returns
+     */
+    forceDelete(uid) {
         return __awaiter(this, void 0, void 0, function* () {
-            // We dont need uuid but Binary store will need it
-            return this.delete(obj[this._uuidField]);
+            return this.delete(uid, undefined, undefined, true);
         });
     }
     /**
@@ -820,58 +594,48 @@ class Store extends service_1.Service {
      * @param {Boolean} delete sync even if asyncDelete is active
      * @return {Promise} the deletion promise
      */
-    delete(uid, sync = false) {
+    delete(uid, writeCondition, writeConditionField, sync = false) {
         return __awaiter(this, void 0, void 0, function* () {
             /** @ignore */
             let to_delete;
+            // Allow full object or just its uuid
             if (typeof uid === "object") {
                 to_delete = uid;
-                uid = to_delete[this._uuidField];
-                if (!(to_delete instanceof this._model)) {
-                    to_delete = this.initModel(yield this._get(uid));
-                }
             }
             else {
-                to_delete = this.initModel(yield this._get(uid));
+                to_delete = yield this._get(uid);
+                if (to_delete === undefined) {
+                    return;
+                }
+                if (to_delete.__type !== this._model.name && this.parameters.strict) {
+                    this.log("WARN", `Object '${uid}' was not created by this store`);
+                    return;
+                }
+                to_delete = this.initModel(to_delete);
             }
-            if (to_delete === undefined) {
-                throw 404;
+            // Check condition as we have the object
+            if (writeCondition) {
+                if (to_delete[writeConditionField] !== writeCondition) {
+                    throw new UpdateConditionFailError(to_delete.getUuid(), writeConditionField, writeCondition);
+                }
             }
+            // Send preevent
             yield this.emitSync("Store.Delete", {
                 object: to_delete,
                 store: this
             });
             yield to_delete._onDelete();
-            if (this.parameters.map != undefined) {
-                yield this.handleMap(to_delete, this.parameters.map, "deleted");
-            }
-            // Handle index
-            if (this.parameters.index && to_delete[this._uuidField] !== "index" && to_delete[this._uuidField]) {
-                yield this.handleIndex(to_delete, "deleted");
-            }
-            if (this._cascade != undefined && to_delete !== undefined) {
-                var promises = [];
-                // Should deactiate the mapping in that case
-                for (let i in this._cascade) {
-                    if (typeof this._cascade[i] != "object" || to_delete[this._cascade[i].name] == undefined)
-                        continue;
-                    var targetStore = this.getService(this._cascade[i].store);
-                    if (targetStore == undefined)
-                        continue;
-                    for (var item in to_delete[this._cascade[i].name]) {
-                        promises.push(targetStore.cascadeDelete(to_delete[this._cascade[i].name][item], to_delete[this._uuidField]));
-                    }
-                }
-                yield Promise.all(promises);
-            }
+            // If async we just tag the object as deleted
             if (this.parameters.asyncDelete && !sync) {
                 yield this._patch({
                     __deleted: true
-                }, uid);
+                }, to_delete.getUuid());
             }
             else {
-                yield this._delete(uid);
+                // Delete from the DB for real
+                yield this._delete(to_delete.getUuid(), writeCondition, writeConditionField);
             }
+            // Send post event
             yield this.emitSync("Store.Deleted", {
                 object: to_delete,
                 store: this
@@ -879,37 +643,6 @@ class Store extends service_1.Service {
             yield to_delete._onDeleted();
         });
     }
-    /**
-     * Check if an object exists
-     * @abstract
-     * @params {String} uuid of the object
-     */
-    exists(uid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw Error("Virtual abstract class - concrete only for MixIn usage");
-        });
-    }
-    _delete(uid, writeCondition, itemWriteConditionField) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw Error("Virtual abstract class - concrete only for MixIn usage");
-        });
-    }
-    _get(uid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw Error("Virtual abstract class - concrete only for MixIn usage");
-        });
-    }
-    /**
-     * Get an object
-     *
-     * @param {Array} uuid to gets if undefined then retrieve the all table
-     * @return {Promise} the objects retrieved ( can be [] if not found )
-     */
-    getAll(list = undefined) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw Error("Virtual abstract class - concrete only for MixIn usage");
-        });
-    }
     /**
      * By default we cannot know if the store will trigger or not
      *
@@ -930,7 +663,7 @@ class Store extends service_1.Service {
             if (!object) {
                 return undefined;
             }
-            let result = new Map();
+            let result = {};
             for (let i in object) {
                 if (i === this._uuidField || i === this._lastUpdateField || i.startsWith("_")) {
                     continue;
@@ -956,6 +689,10 @@ class Store extends service_1.Service {
             if (!object) {
                 return undefined;
             }
+            if (object.__type !== this._model.name && this.parameters.strict) {
+                this.log("WARN", `Object '${uid}' was not created by this store`);
+                return undefined;
+            }
             object = this.initModel(object);
             object.setContext(ctx);
             yield this.emitSync("Store.Get", {
@@ -966,6 +703,34 @@ class Store extends service_1.Service {
             return object;
         });
     }
+    /**
+     * Set one attribute in an object
+     *
+     * this is an helper function that calls patch
+     *
+     * @param uid of the object
+     * @param property to update1
+     * @param value new value
+     * @returns
+     */
+    setAttribute(uid, property, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let patch = {};
+            patch[property] = value;
+            patch[this.getUuidField()] = uid;
+            yield this.patch(patch);
+        });
+    }
+    /**
+     * Search inside the store
+     *
+     * Still need to define a good abstraction for it
+     *
+     * @param request
+     * @param offset
+     * @param limit
+     * @returns
+     */
     find(request = undefined, offset = 0, limit = undefined) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.emitSync("Store.Find", {
@@ -985,12 +750,10 @@ class Store extends service_1.Service {
             return result;
         });
     }
-    _find(request, offset, limit) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw Error("Virtual abstract class - concrete only for MixIn usage");
-        });
-    }
-    // ADD THE EXECUTOR PART
+    /**
+     * Handle POST
+     * @param ctx
+     */
     httpCreate(ctx) {
         return __awaiter(this, void 0, void 0, function* () {
             let body = ctx.getRequestBody();
@@ -1019,14 +782,14 @@ class Store extends service_1.Service {
             });
         });
     }
+    /**
+     * Handle obect action
+     * @param ctx
+     */
     httpAction(ctx) {
         return __awaiter(this, void 0, void 0, function* () {
             let action = ctx.getHttpContext().getUrl().split("/").pop();
-            let uuid = ctx.parameter("uuid");
-            if (!uuid) {
-                throw 400;
-            }
-            let object = yield this.get(uuid, ctx);
+            let object = yield this.get(ctx.parameter("uuid"), ctx);
             if (object === undefined || object.__deleted) {
                 throw 404;
             }
@@ -1050,6 +813,10 @@ class Store extends service_1.Service {
             });
         });
     }
+    /**
+     * Handle collection action
+     * @param ctx
+     */
     httpGlobalAction(ctx) {
         return __awaiter(this, void 0, void 0, function* () {
             let action = ctx.getHttpContext().getUrl().split("/").pop();
@@ -1084,15 +851,22 @@ class Store extends service_1.Service {
             if (!object || object.__deleted)
                 throw 404;
             yield object.canAct(ctx, "update");
-            try {
-                yield object.validate(ctx, body);
-            }
-            catch (err) {
-                this.log("INFO", "Object invalid", err);
-                throw 400;
-            }
             if (ctx.getHttpContext().getMethod() === "PATCH") {
+                try {
+                    yield object.validate(ctx, body);
+                }
+                catch (err) {
+                    this.log("INFO", "Object invalid", err);
+                    throw 400;
+                }
                 let updateObject = new this._model();
+                // Clean any default attributes from the model
+                for (let i in updateObject) {
+                    if (i.startsWith("__")) {
+                        continue;
+                    }
+                    delete updateObject[i];
+                }
                 updateObject.setContext(ctx);
                 updateObject.load(body);
                 yield this.patch(updateObject);
@@ -1107,6 +881,13 @@ class Store extends service_1.Service {
                         updateObject[i] = object[i];
                     }
                 }
+                try {
+                    yield updateObject.validate(ctx);
+                }
+                catch (err) {
+                    this.log("INFO", "Object invalid", err);
+                    throw 400;
+                }
                 // Add mappers back to
                 object = yield this.update(updateObject);
             }
@@ -1130,6 +911,11 @@ class Store extends service_1.Service {
             let uuid = ctx.parameter("uuid");
             if (uuid) {
                 let object = yield this.get(uuid, ctx);
+                yield this.emitSync("Store.WebGetNotFound", {
+                    context: ctx,
+                    uuid,
+                    store: this
+                });
                 if (object === undefined || object.__deleted) {
                     throw 404;
                 }
@@ -1180,6 +966,12 @@ class Store extends service_1.Service {
             }
         });
     }
+    /**
+     * Return the model uuid field
+     */
+    getUuidField() {
+        return this._uuidField;
+    }
 }
 exports.Store = Store;
 //# sourceMappingURL=store.js.map