@webda/core 2.0.0-beta.1 → 2.0.0

package/lib/stores/store.js

@@ -1,40 +1,31 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-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");
-const query_1 = require("./webdaql/query");
-class StoreNotFoundError extends core_1.WebdaError {
+import { WebdaError } from "../core.js";
+import { CoreModel } from "../models/coremodel.js";
+import { Route, Service, ServiceParameters } from "../services/service.js";
+import { WebdaQL } from "./webdaql/query.js";
+export class StoreNotFoundError extends WebdaError {
     constructor(uuid, storeName) {
         super("STORE_NOTFOUND", `Item not found ${uuid} Store(${storeName})`);
     }
 }
-exports.StoreNotFoundError = StoreNotFoundError;
-class UpdateConditionFailError extends core_1.WebdaError {
+export class UpdateConditionFailError extends 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 {
+export class StoreParameters extends ServiceParameters {
     constructor(params, service) {
-        var _a, _b, _c, _d;
-        var _e;
+        var _a;
         super(params);
-        (_a = this.model) !== null && _a !== void 0 ? _a : (this.model = "Webda/CoreModel");
+        this.model ?? (this.model = "Webda/CoreModel");
         let expose = params.expose;
         if (typeof expose == "boolean") {
             expose = {};
@@ -51,7 +42,8 @@ class StoreParameters extends service_1.ServiceParameters {
         if (expose) {
             expose.restrict = expose.restrict || {};
             this.expose = expose;
-            (_b = (_e = this.expose).queryMethod) !== null && _b !== void 0 ? _b : (_e.queryMethod = "GET");
+            (_a = this.expose).queryMethod ?? (_a.queryMethod = "GET");
+            this.url = expose.url;
         }
         if (params.map) {
             throw new Error("Deprecated map usage, use a MapperService");
@@ -59,11 +51,10 @@ class StoreParameters extends service_1.ServiceParameters {
         if (params.index) {
             throw new Error("Deprecated index usage, use an AggregatorService");
         }
-        (_c = this.strict) !== null && _c !== void 0 ? _c : (this.strict = true);
-        (_d = this.slowQueryThreshold) !== null && _d !== void 0 ? _d : (this.slowQueryThreshold = 30000);
+        this.strict ?? (this.strict = true);
+        this.slowQueryThreshold ?? (this.slowQueryThreshold = 30000);
     }
 }
-exports.StoreParameters = StoreParameters;
 /**
  * This class handle NoSQL storage and mapping (duplication) between NoSQL object
  * TODO Create the mapping documentation
@@ -98,7 +89,7 @@ exports.StoreParameters = StoreParameters;
  *   }
  * @category CoreServices
  */
-class Store extends service_1.Service {
+class Store extends Service {
     constructor() {
         super(...arguments);
         /**
@@ -127,26 +118,19 @@ class Store extends service_1.Service {
             slowQueries: 0
         };
     }
-    /**
-     * Load the parameters for a service
-     */
-    loadParameters(params) {
-        return new StoreParameters(params, this);
-    }
     /**
      * Retrieve the Model
      *
      * @throws Error if model is not found
      */
     computeParameters() {
-        var _a;
         super.computeParameters();
         const p = this.parameters;
         this._model = this._webda.getModel(p.model);
         this._uuidField = this._model.getUuidField();
         this._lastUpdateField = this._model.getLastUpdateField();
         this._creationDateField = this._model.getCreationField();
-        (_a = this._cacheStore) === null || _a === void 0 ? void 0 : _a.computeParameters();
+        this._cacheStore?.computeParameters();
         this.cacheStorePatchException();
     }
     logSlowQuery(_query, _reason, _time) {
@@ -168,29 +152,45 @@ class Store extends service_1.Service {
      * @param raiseIfNotFound
      * @returns
      */
-    _getFromCache(uid, raiseIfNotFound = false) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let res = yield ((_a = this._cacheStore) === null || _a === void 0 ? void 0 : _a._get(uid));
-            if (!res) {
-                res = yield this._get(uid, raiseIfNotFound);
-            }
-            else {
-                res.__store = this;
-            }
-            return res;
-        });
+    async _getFromCache(uid, raiseIfNotFound = false) {
+        let res = await this._cacheStore?._get(uid);
+        if (!res) {
+            res = await this._get(uid, raiseIfNotFound);
+        }
+        else {
+            res.__store = this;
+        }
+        return res;
     }
     /**
      * Get object from store
      * @param uid
      * @returns
      */
-    getObject(uid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.metrics.get++;
-            return this._getFromCache(uid);
-        });
+    async getObject(uid) {
+        this.metrics.get++;
+        return this._getFromCache(uid);
+    }
+    /**
+     * @override
+     */
+    getUrl(url, methods) {
+        // If url is absolute
+        if (url.startsWith("/")) {
+            return url;
+        }
+        const expose = this.parameters.expose;
+        if (!expose.url ||
+            (url === "." && methods.includes("POST") && expose.restrict.create) ||
+            (url === "./{uuid}" && methods.includes("DELETE") && expose.restrict.delete) ||
+            (url === "./{uuid}" && methods.includes("PATCH") && expose.restrict.update) ||
+            (url === "./{uuid}" && methods.includes("PUT") && expose.restrict.update) ||
+            (url === "./{uuid}" && methods.includes("GET") && expose.restrict.get) ||
+            (url === ".{?q}" && methods.includes("GET") && expose.restrict.query) ||
+            (url === "." && methods.includes("PUT") && expose.restrict.query)) {
+            return undefined;
+        }
+        return super.getUrl(url, methods);
     }
     /**
      * @inheritdoc
@@ -199,60 +199,52 @@ class Store extends service_1.Service {
         if (!this.parameters.expose) {
             return;
         }
+        super.initRoutes();
         // We enforce ExposeParameters within the constructor
         const expose = this.parameters.expose;
-        if (!expose.restrict.create) {
-            this.addRoute(expose.url, ["POST"], this.httpCreate, {
-                model: this._model.name,
-                post: {
-                    description: `The way to create a new ${this._model.name} model`,
-                    summary: "Create a new " + this._model.name,
-                    operationId: `create${this._model.name}`,
-                    responses: {
-                        "200": {
-                            description: "Retrieve model",
-                            content: {
-                                "application/json": {
-                                // schema: this._model.name
+        // Query endpoint
+        if (!expose.restrict.query) {
+            let requestBody;
+            if (expose.queryMethod === "PUT") {
+                requestBody = {
+                    content: {
+                        "application/json": {
+                            schema: {
+                                properties: {
+                                    q: {
+                                        type: "string"
+                                    }
                                 }
                             }
-                        },
-                        "400": {
-                            description: "Object is invalid"
-                        },
-                        "403": {
-                            description: "You don't have permissions"
-                        },
-                        "409": {
-                            description: "Object already exists"
                         }
                     }
-                }
-            });
-        }
-        // Dont even create the route that are restricted so we can ease up the test on handler
-        let methods = [];
-        if (!expose.restrict.update) {
-            methods.push("PUT");
-            methods.push("PATCH");
-        }
-        if (!expose.restrict.get) {
-            methods.push("GET");
-        }
-        // Query endpoint
-        if (!expose.restrict.query) {
-            this.addRoute(expose.queryMethod === "GET" ? `${expose.url}{?q}` : expose.url, [expose.queryMethod], this.httpQuery, {
+                };
+            }
+            this.addRoute(expose.queryMethod === "GET" ? `.{?q}` : ".", [expose.queryMethod], this.httpQuery, {
                 model: this._model.name,
                 [expose.queryMethod.toLowerCase()]: {
                     description: `Query on ${this._model.name} model with WebdaQL`,
                     summary: "Query " + this._model.name,
-                    operationId: `create${this._model.name}`,
+                    operationId: `query${this._model.name}`,
+                    requestBody,
                     responses: {
                         "200": {
                             description: "Retrieve models",
                             content: {
                                 "application/json": {
-                                // schema: this._model.name
+                                    schema: {
+                                        properties: {
+                                            contiuationToken: {
+                                                type: "string"
+                                            },
+                                            results: {
+                                                type: "array",
+                                                items: {
+                                                    $ref: `#/components/schemas/${this._model.name}`
+                                                }
+                                            }
+                                        }
+                                    }
                                 }
                             }
                         },
@@ -266,87 +258,7 @@ class Store extends service_1.Service {
                 }
             });
         }
-        if (!expose.restrict.delete) {
-            methods.push("DELETE");
-        }
-        if (methods.length) {
-            this.addRoute(expose.url + "/{uuid}", methods, this.httpRoute, {
-                model: this._model.name,
-                get: {
-                    description: `Retrieve ${this._model.name} model if permissions allow`,
-                    summary: "Retrieve a " + this._model.name,
-                    operationId: `get${this._model.name}`,
-                    responses: {
-                        "200": {
-                        //model: this._model.name
-                        },
-                        "400": {
-                            description: "Object is invalid"
-                        },
-                        "403": {
-                            description: "You don't have permissions"
-                        },
-                        "404": {
-                            description: "Unknown object"
-                        }
-                    }
-                },
-                put: {
-                    description: `Update a ${this._model.name} if the permissions allow`,
-                    summary: "Update a " + this._model.name,
-                    operationId: `updatet${this._model.name}`,
-                    responses: {
-                        "200": {
-                        // model: this._model.name
-                        },
-                        "400": {
-                            description: "Object is invalid"
-                        },
-                        "403": {
-                            description: "You don't have permissions"
-                        },
-                        "404": {
-                            description: "Unknown object"
-                        }
-                    }
-                },
-                patch: {
-                    description: `Patch a ${this._model.name} if the permissions allow`,
-                    summary: "Patch a " + this._model.name,
-                    operationId: `updatet${this._model.name}`,
-                    responses: {
-                        "204": {
-                            description: ""
-                        },
-                        "400": {
-                            description: "Object is invalid"
-                        },
-                        "403": {
-                            description: "You don't have permissions"
-                        },
-                        "404": {
-                            description: "Unknown object"
-                        }
-                    }
-                },
-                delete: {
-                    operationId: `delete${this._model.name}`,
-                    description: `Delete ${this._model.name} if the permissions allow`,
-                    summary: "Delete a " + this._model.name,
-                    responses: {
-                        "204": {
-                            description: ""
-                        },
-                        "403": {
-                            description: "You don't have permissions"
-                        },
-                        "404": {
-                            description: "Unknown object"
-                        }
-                    }
-                }
-            });
-        }
+        // Model actions
         if (this._model && this._model.getActions) {
             let actions = this._model.getActions();
             Object.keys(actions).forEach(name => {
@@ -361,7 +273,7 @@ class Store extends service_1.Service {
                         throw Error("Action static method _" + name + " does not exist");
                     }
                     executer = this.httpGlobalAction;
-                    this.addRoute(expose.url + "/" + name, action.methods, executer, action.openapi);
+                    this.addRoute(`./${name}`, action.methods, executer, action.openapi);
                 }
                 else {
                     // By default will grab the object and then call the action
@@ -369,7 +281,7 @@ class Store extends service_1.Service {
                         throw Error("Action method _" + name + " does not exist");
                     }
                     executer = this.httpAction;
-                    this.addRoute(expose.url + "/{uuid}/" + name, action.methods, executer, action.openapi);
+                    this.addRoute(`./{uuid}/${name}`, action.methods, executer, action.openapi);
                 }
             });
         }
@@ -379,17 +291,10 @@ class Store extends service_1.Service {
      * Used mainly in test
      */
     setModel(model) {
-        var _a;
         this._model = model;
-        (_a = this._cacheStore) === null || _a === void 0 ? void 0 : _a.setModel(model);
+        this._cacheStore?.setModel(model);
         this.parameters.strict = false;
     }
-    /**
-     * Get the url where the store is exposed
-     */
-    getUrl() {
-        return this.parameters.expose.url;
-    }
     /**
      * We should ignore exception from the store
      */
@@ -429,20 +334,17 @@ class Store extends service_1.Service {
      */
     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;
+            object = this._model.factory(this._model, object);
         }
         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]) {
+        for (let i in this._reverseMap) {
+            object[_a = this._reverseMap[i].property] ?? (object[_a] = []);
+            for (let j in object[this._reverseMap[i].property]) {
                 // 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());
@@ -463,72 +365,63 @@ class Store extends service_1.Service {
             mapper: store
         });
     }
-    incrementAttribute(uid, prop, value) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            // If value === 0 no need to update anything
-            if (value === 0) {
-                return Promise.resolve();
-            }
-            let updateDate = new Date();
-            this.metrics.increment++;
-            yield this._incrementAttribute(uid, prop, value, updateDate);
-            yield ((_a = this._cacheStore) === null || _a === void 0 ? void 0 : _a._incrementAttribute(uid, prop, value, updateDate));
-            return this.emitSync("Store.PartialUpdated", {
-                object_id: uid,
-                store: this,
-                updateDate,
-                partial_update: {
-                    increment: {
-                        value: value,
-                        property: prop
-                    }
+    async incrementAttribute(uid, prop, value) {
+        // If value === 0 no need to update anything
+        if (value === 0) {
+            return Promise.resolve();
+        }
+        let updateDate = new Date();
+        this.metrics.increment++;
+        await this._incrementAttribute(uid, prop, value, updateDate);
+        await this._cacheStore?._incrementAttribute(uid, prop, value, updateDate);
+        return this.emitSync("Store.PartialUpdated", {
+            object_id: uid,
+            store: this,
+            updateDate,
+            partial_update: {
+                increment: {
+                    value: value,
+                    property: prop
                 }
-            });
+            }
         });
     }
-    upsertItemToCollection(uid, prop, item, index = undefined, itemWriteCondition = undefined, itemWriteConditionField = undefined) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (itemWriteConditionField === undefined) {
-                itemWriteConditionField = this._uuidField;
-            }
-            let updateDate = new Date();
-            this.metrics.collectionUpsert++;
-            yield this._upsertItemToCollection(uid, prop, item, index, itemWriteCondition, itemWriteConditionField, updateDate);
-            yield ((_a = this._cacheStore) === null || _a === void 0 ? void 0 : _a._upsertItemToCollection(uid, prop, item, index, itemWriteCondition, itemWriteConditionField, updateDate));
-            yield this.emitSync("Store.PartialUpdated", {
-                object_id: uid,
-                store: this,
-                updateDate,
-                partial_update: {
-                    addItem: {
-                        value: item,
-                        property: prop,
-                        index: index
-                    }
+    async upsertItemToCollection(uid, prop, item, index = undefined, itemWriteCondition = undefined, itemWriteConditionField = undefined) {
+        if (itemWriteConditionField === undefined) {
+            itemWriteConditionField = this._uuidField;
+        }
+        let updateDate = new Date();
+        this.metrics.collectionUpsert++;
+        await this._upsertItemToCollection(uid, prop, item, index, itemWriteCondition, itemWriteConditionField, updateDate);
+        await this._cacheStore?._upsertItemToCollection(uid, prop, item, index, itemWriteCondition, itemWriteConditionField, updateDate);
+        await this.emitSync("Store.PartialUpdated", {
+            object_id: uid,
+            store: this,
+            updateDate,
+            partial_update: {
+                addItem: {
+                    value: item,
+                    property: prop,
+                    index: index
                 }
-            });
+            }
         });
     }
-    deleteItemFromCollection(uid, prop, index, itemWriteCondition, itemWriteConditionField = this._uuidField) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let updateDate = new Date();
-            this.metrics.collectionDelete++;
-            yield this._deleteItemFromCollection(uid, prop, index, itemWriteCondition, itemWriteConditionField, updateDate);
-            yield ((_a = this._cacheStore) === null || _a === void 0 ? void 0 : _a._deleteItemFromCollection(uid, prop, index, itemWriteCondition, itemWriteConditionField, updateDate));
-            yield this.emitSync("Store.PartialUpdated", {
-                object_id: uid,
-                store: this,
-                updateDate,
-                partial_update: {
-                    deleteItem: {
-                        property: prop,
-                        index: index
-                    }
+    async deleteItemFromCollection(uid, prop, index, itemWriteCondition, itemWriteConditionField = this._uuidField) {
+        let updateDate = new Date();
+        this.metrics.collectionDelete++;
+        await this._deleteItemFromCollection(uid, prop, index, itemWriteCondition, itemWriteConditionField, updateDate);
+        await this._cacheStore?._deleteItemFromCollection(uid, prop, index, itemWriteCondition, itemWriteConditionField, updateDate);
+        await this.emitSync("Store.PartialUpdated", {
+            object_id: uid,
+            store: this,
+            updateDate,
+            partial_update: {
+                deleteItem: {
+                    property: prop,
+                    index: index
                 }
-            });
+            }
         });
     }
     /**
@@ -536,121 +429,132 @@ class Store extends service_1.Service {
      * @param query
      * @param context to apply permission
      */
-    query(query, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let queryValidator = new query_1.WebdaQL.QueryValidator(query);
-            let offset = queryValidator.getOffset();
-            const limit = queryValidator.getLimit();
-            const parsedQuery = queryValidator.getQuery();
-            // Emit the default event
-            yield this.emitSync("Store.Query", {
-                query,
-                parsedQuery,
-                store: this,
-                context
-            });
-            const result = {
-                results: [],
-                continuationToken: undefined
-            };
-            /*
-              Offset are split in two with _
-        
-              MainOffset is the database offset, retrieving a page from the database
-              SubOffset is the offset within the page
-        
-              As we filter through the page, for additional filters or permissions, the page cut
-              by database does not endup being our final page cut, so we need a page offset to
-              abstract this completely
-             */
-            let [mainOffset, subOffset] = offset.split("_");
-            let secondOffset = parseInt(subOffset || "0");
-            let duration = Date.now();
-            this.metrics.query++;
-            while (result.results.length < limit) {
-                let tmpResults = yield this.find(Object.assign(Object.assign({}, parsedQuery), { continuationToken: mainOffset }));
-                // If no filter is returned assume it is by mistake and apply filtering
-                if (tmpResults.filter === undefined) {
-                    tmpResults.filter = queryValidator.getExpression();
-                    this.log("WARN", `Store '${this.getName()}' postquery full filtering`);
+    async query(query, context) {
+        let permissionQuery = this._model.getPermissionQuery(context);
+        let partialPermission = true;
+        let fullQuery;
+        if (permissionQuery) {
+            partialPermission = permissionQuery.partial;
+            if (query.trim() !== "") {
+                fullQuery = `(${permissionQuery.query}) AND ${query}`;
+            }
+            else {
+                fullQuery = permissionQuery.query;
+            }
+        }
+        else {
+            fullQuery = query;
+        }
+        let queryValidator = new WebdaQL.QueryValidator(fullQuery);
+        let offset = queryValidator.getOffset();
+        const limit = queryValidator.getLimit();
+        const parsedQuery = queryValidator.getQuery();
+        // Emit the default event
+        await this.emitSync("Store.Query", {
+            query,
+            parsedQuery,
+            store: this,
+            context
+        });
+        const result = {
+            results: [],
+            continuationToken: undefined
+        };
+        /*
+          Offset are split in two with _
+    
+          MainOffset is the database offset, retrieving a page from the database
+          SubOffset is the offset within the page
+    
+          As we filter through the page, for additional filters or permissions, the page cut
+          by database does not endup being our final page cut, so we need a page offset to
+          abstract this completely
+         */
+        let [mainOffset, subOffset] = offset.split("_");
+        let secondOffset = parseInt(subOffset || "0");
+        let duration = Date.now();
+        this.metrics.query++;
+        while (result.results.length < limit) {
+            let tmpResults = await this.find({ ...parsedQuery, continuationToken: mainOffset });
+            // If no filter is returned assume it is by mistake and apply filtering
+            if (tmpResults.filter === undefined) {
+                tmpResults.filter = queryValidator.getExpression();
+                this.log("WARN", `Store '${this.getName()}' postquery full filtering`);
+            }
+            let subOffsetCount = 0;
+            for (let item of tmpResults.results) {
+                // Because of dynamic filter and permission we need to suboffset the pagination
+                subOffsetCount++;
+                if (subOffsetCount <= secondOffset) {
+                    continue;
                 }
-                let subOffsetCount = 0;
-                for (let item of tmpResults.results) {
-                    // Because of dynamic filter and permission we need to suboffset the pagination
-                    subOffsetCount++;
-                    if (subOffsetCount <= secondOffset) {
-                        continue;
+                if (tmpResults.filter !== true && !tmpResults.filter.eval(item)) {
+                    continue;
+                }
+                if (context && partialPermission) {
+                    try {
+                        await item.canAct(context, "get");
                     }
-                    if (tmpResults.filter !== true && !tmpResults.filter.eval(item)) {
+                    catch (err) {
                         continue;
                     }
-                    if (context) {
-                        try {
-                            yield item.canAct(context, "get");
-                        }
-                        catch (err) {
-                            continue;
-                        }
+                }
+                result.results.push(item);
+                if (result.results.length >= limit) {
+                    if (subOffsetCount === tmpResults.results.length) {
+                        result.continuationToken = tmpResults.continuationToken;
                     }
-                    result.results.push(item);
-                    if (result.results.length >= limit) {
-                        if (subOffsetCount === tmpResults.results.length) {
-                            result.continuationToken = tmpResults.continuationToken;
-                        }
-                        else {
-                            result.continuationToken = `${mainOffset}_${subOffsetCount}`;
-                        }
-                        break;
+                    else {
+                        result.continuationToken = `${mainOffset}_${subOffsetCount}`;
                     }
-                }
-                // Update both offset
-                mainOffset = tmpResults.continuationToken;
-                // Fresh new query so we do not need to skip
-                secondOffset = 0;
-                if (mainOffset === undefined || result.results.length >= limit) {
                     break;
                 }
             }
-            duration = Date.now() - duration;
-            this.metrics.queryDuration =
-                (this.metrics.queryDuration * (this.metrics.query - 1) + duration) / this.metrics.query;
-            if (duration > this.parameters.slowQueryThreshold) {
-                this.logSlowQuery(query, "", duration);
+            // Update both offset
+            mainOffset = tmpResults.continuationToken;
+            // Fresh new query so we do not need to skip
+            secondOffset = 0;
+            if (mainOffset === undefined || result.results.length >= limit) {
+                break;
             }
-            yield this.emitSync("Store.Queried", {
-                query,
-                parsedQuery: parsedQuery,
-                store: this,
-                continuationToken: result.continuationToken,
-                results: result.results,
-                context
-            });
-            return result;
+        }
+        duration = Date.now() - duration;
+        this.metrics.queryDuration =
+            (this.metrics.queryDuration * (this.metrics.query - 1) + duration) / this.metrics.query;
+        if (duration > this.parameters.slowQueryThreshold) {
+            this.logSlowQuery(query, "", duration);
+        }
+        await this.emitSync("Store.Queried", {
+            query,
+            parsedQuery: parsedQuery,
+            store: this,
+            continuationToken: result.continuationToken,
+            results: result.results,
+            context
         });
+        return result;
     }
     /**
      * Expose query to http
      */
-    httpQuery(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let query;
-            if (ctx.getHttpContext().getMethod() === "GET") {
-                query = ctx.getParameters().q;
-            }
-            else {
-                query = (yield ctx.getRequestBody()).q;
-            }
-            try {
-                ctx.write(yield this.query(query, ctx));
-            }
-            catch (err) {
-                if (err instanceof SyntaxError) {
-                    this.log("INFO", "Query syntax error");
-                    throw 400;
-                }
-                throw err;
+    async httpQuery(ctx) {
+        let query;
+        if (ctx.getHttpContext().getMethod() === "GET") {
+            query = ctx.getParameters().q;
+        }
+        else {
+            query = (await ctx.getRequestBody()).q;
+        }
+        try {
+            ctx.write(await this.query(query, ctx));
+        }
+        catch (err) {
+            if (err instanceof SyntaxError) {
+                this.log("INFO", "Query syntax error");
+                throw 400;
             }
-        });
+            throw err;
+        }
     }
     /**
      * Save an object
@@ -661,36 +565,33 @@ class Store extends service_1.Service {
      *
      * Might want to rename to create
      */
-    save(object, ctx = undefined) {
-        var _a, _b;
-        var _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            object = this.initModel(object);
-            // Dates should be store by the Store
-            (_a = object[_c = this._creationDateField]) !== null && _a !== void 0 ? _a : (object[_c] = new Date());
-            object[this._lastUpdateField] = new Date();
-            if (ctx) {
-                object.setContext(ctx);
-            }
-            yield this.emitSync("Store.Save", {
-                object: object,
-                store: this,
-                context: ctx
-            });
-            // Handle object auto listener
-            yield object._onSave();
-            this.metrics.save++;
-            let res = yield this._save(object);
-            yield ((_b = this._cacheStore) === null || _b === void 0 ? void 0 : _b._save(object));
-            object = this.initModel(res);
-            yield this.emitSync("Store.Saved", {
-                object: object,
-                store: this,
-                context: ctx
-            });
-            yield object._onSaved();
-            return object;
+    async save(object, ctx = undefined) {
+        var _a;
+        object = this.initModel(object);
+        // Dates should be store by the Store
+        object[_a = this._creationDateField] ?? (object[_a] = new Date());
+        object[this._lastUpdateField] = new Date();
+        if (ctx) {
+            object.setContext(ctx);
+        }
+        await this.emitSync("Store.Save", {
+            object: object,
+            store: this,
+            context: ctx
+        });
+        // Handle object auto listener
+        await object._onSave();
+        this.metrics.save++;
+        let res = await this._save(object);
+        await this._cacheStore?._save(object);
+        object = this.initModel(res);
+        await this.emitSync("Store.Saved", {
+            object: object,
+            store: this,
+            context: ctx
         });
+        await object._onSaved();
+        return object;
     }
     /**
      * Patch an object
@@ -699,10 +600,8 @@ class Store extends service_1.Service {
      * @param reverseMap
      * @returns
      */
-    patch(object, reverseMap = true) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.update(object, reverseMap, true);
-        });
+    async patch(object, reverseMap = true) {
+        return this.update(object, reverseMap, true);
     }
     /**
      * Check if an UpdateCondition is met
@@ -737,6 +636,26 @@ class Store extends service_1.Service {
             throw new UpdateConditionFailError(model.getUuid(), `${collection}[${index}].${conditionField}`, condition);
         }
     }
+    /**
+     * Update conditionally
+     * @param uuid
+     * @param updates
+     * @param conditionField
+     * @param condition
+     */
+    async conditionalPatch(uuid, updates, conditionField, condition) {
+        try {
+            await this._patch(updates, uuid, condition, conditionField);
+            await this._cacheStore?.patch({ uuid, ...updates });
+            return true;
+        }
+        catch (err) {
+            if (err instanceof UpdateConditionFailError) {
+                return false;
+            }
+            throw err;
+        }
+    }
     /**
      *
      * @param model
@@ -747,116 +666,114 @@ class Store extends service_1.Service {
      * @param itemWriteConditionField
      * @param updateDate
      */
-    simulateUpsertItemToCollection(model, prop, item, updateDate, index, itemWriteCondition, itemWriteConditionField) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (prop === "__proto__") {
-                throw new Error("Cannot update __proto__: js/prototype-polluting-assignment");
-            }
-            this.checkCollectionUpdateCondition(model, prop, itemWriteConditionField, itemWriteCondition, index);
-            if (index === undefined) {
-                if (model[prop] === undefined) {
-                    model[prop] = [item];
-                }
-                else {
-                    model[prop].push(item);
-                }
+    async simulateUpsertItemToCollection(model, prop, item, updateDate, index, itemWriteCondition, itemWriteConditionField) {
+        if (prop === "__proto__") {
+            throw new Error("Cannot update __proto__: js/prototype-polluting-assignment");
+        }
+        this.checkCollectionUpdateCondition(model, prop, itemWriteConditionField, itemWriteCondition, index);
+        if (index === undefined) {
+            if (model[prop] === undefined) {
+                model[prop] = [item];
             }
             else {
-                model[prop][index] = item;
+                model[prop].push(item);
             }
-            model[this._lastUpdateField] = updateDate;
-            yield this._save(model);
-        });
+        }
+        else {
+            model[prop][index] = item;
+        }
+        model[this._lastUpdateField] = updateDate;
+        await this._save(model);
     }
     /**
      * Update an object
      *
+     * If no attribute can be updated then return undefined
+     *
      * @param {Object} Object to save
      * @param {Boolean} reverseMap internal use only, for disable map resolution
      * @return {Promise} with saved object
      */
-    update(object, reverseMap = true, partial = false) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            /** @ignore */
-            var saved;
-            var loaded;
-            // Dont allow to update collections from map
-            if (this._reverseMap != undefined && reverseMap) {
-                for (let i in this._reverseMap) {
-                    if (object[this._reverseMap[i].property] != undefined) {
-                        delete object[this._reverseMap[i].property];
-                    }
+    async update(object, reverseMap = true, partial = false) {
+        /** @ignore */
+        let saved;
+        let loaded;
+        // Dont allow to update collections from map
+        if (this._reverseMap != undefined && reverseMap) {
+            for (let i in this._reverseMap) {
+                if (object[this._reverseMap[i].property] != undefined) {
+                    delete object[this._reverseMap[i].property];
                 }
             }
-            if (Object.keys(object).length < 2) {
-                return {};
-            }
-            object[this._lastUpdateField] = new Date();
-            this.metrics.get++;
-            let load = yield this._getFromCache(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);
-            if (object instanceof coremodel_1.CoreModel) {
-                loaded.setContext(object.getContext());
-            }
-            if (partial) {
-                yield this.emitSync(`Store.PatchUpdate`, {
-                    object: loaded,
-                    store: this,
-                    update: object
-                });
-            }
-            else {
-                yield this.emitSync(`Store.Update`, {
-                    object: loaded,
-                    store: this,
-                    update: object
-                });
-            }
-            yield loaded._onUpdate(object);
-            let res;
-            if (partial) {
-                this.metrics.partialUpdate++;
-                yield this._patch(object, object[this._uuidField], load[this._lastUpdateField], this._lastUpdateField);
-                yield ((_a = this._cacheStore) === null || _a === void 0 ? void 0 : _a._patch(object, object[this._uuidField], load[this._lastUpdateField], this._lastUpdateField));
-                res = object;
-            }
-            else {
-                // Copy back the mappers
-                for (let i in this._reverseMap) {
-                    object[this._reverseMap[i].property] = loaded[this._reverseMap[i].property];
-                }
-                this.metrics.update++;
-                res = yield this._update(object, object[this._uuidField], load[this._lastUpdateField], this._lastUpdateField);
-                yield ((_b = this._cacheStore) === null || _b === void 0 ? void 0 : _b._update(object, object[this._uuidField], load[this._lastUpdateField], this._lastUpdateField));
-            }
-            // Return updated
-            for (let i in res) {
-                loaded[i] = res[i];
-            }
-            for (let i in object) {
-                loaded[i] = object[i];
-            }
-            saved = this.initModel(loaded);
-            if (partial) {
-                yield this.emitSync(`Store.PatchUpdated`, {
-                    object: saved,
-                    store: this
-                });
-            }
-            else {
-                yield this.emitSync(`Store.Updated`, {
-                    object: saved,
-                    store: this
-                });
+        }
+        if (Object.keys(object).length < 2) {
+            return undefined;
+        }
+        object[this._lastUpdateField] = new Date();
+        this.metrics.get++;
+        let load = await this._getFromCache(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);
+        if (object instanceof CoreModel) {
+            loaded.setContext(object.getContext());
+        }
+        if (partial) {
+            await this.emitSync(`Store.PatchUpdate`, {
+                object: loaded,
+                store: this,
+                update: object
+            });
+        }
+        else {
+            await this.emitSync(`Store.Update`, {
+                object: loaded,
+                store: this,
+                update: object
+            });
+        }
+        await loaded._onUpdate(object);
+        let res;
+        if (partial) {
+            this.metrics.partialUpdate++;
+            await this._patch(object, object[this._uuidField], load[this._lastUpdateField], this._lastUpdateField);
+            await this._cacheStore?._patch(object, object[this._uuidField], load[this._lastUpdateField], this._lastUpdateField);
+            res = object;
+        }
+        else {
+            // Copy back the mappers
+            for (let i in this._reverseMap) {
+                object[this._reverseMap[i].property] = loaded[this._reverseMap[i].property];
             }
-            yield saved._onUpdated();
-            return saved;
-        });
+            object = this.initModel(object);
+            this.metrics.update++;
+            res = await this._update(object, object[this._uuidField], load[this._lastUpdateField], this._lastUpdateField);
+            await this._cacheStore?._update(object, object[this._uuidField], load[this._lastUpdateField], this._lastUpdateField);
+        }
+        // Return updated
+        for (let i in res) {
+            loaded[i] = res[i];
+        }
+        for (let i in object) {
+            loaded[i] = object[i];
+        }
+        saved = this.initModel(loaded);
+        if (partial) {
+            await this.emitSync(`Store.PatchUpdated`, {
+                object: saved,
+                store: this
+            });
+        }
+        else {
+            await this.emitSync(`Store.Updated`, {
+                object: saved,
+                store: this
+            });
+        }
+        await saved._onUpdated();
+        return saved;
     }
     /**
      * Remove an attribute from an object
@@ -865,18 +782,15 @@ class Store extends service_1.Service {
      * @param attribute
      * @returns
      */
-    removeAttribute(uuid, attribute, itemWriteCondition, itemWriteConditionField) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            this.metrics.attributeDelete++;
-            yield this._removeAttribute(uuid, attribute, itemWriteCondition, itemWriteConditionField);
-            yield ((_a = this._cacheStore) === null || _a === void 0 ? void 0 : _a._removeAttribute(uuid, attribute, itemWriteCondition, itemWriteConditionField));
-            yield this.emitSync("Store.PartialUpdated", {
-                object_id: uuid,
-                partial_update: {
-                    deleteAttribute: attribute
-                }
-            });
+    async removeAttribute(uuid, attribute, itemWriteCondition, itemWriteConditionField) {
+        this.metrics.attributeDelete++;
+        await this._removeAttribute(uuid, attribute, itemWriteCondition, itemWriteConditionField);
+        await this._cacheStore?._removeAttribute(uuid, attribute, itemWriteCondition, itemWriteConditionField);
+        await this.emitSync("Store.PartialUpdated", {
+            object_id: uuid,
+            partial_update: {
+                deleteAttribute: attribute
+            }
         });
     }
     /**
@@ -886,21 +800,17 @@ class Store extends service_1.Service {
      * @param uuid
      * @returns
      */
-    cascadeDelete(obj, _uuid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // We dont need uuid but Binary store will need it
-            return this.delete(obj.getUuid());
-        });
+    async cascadeDelete(obj, _uuid) {
+        // We dont need uuid but Binary store will need it
+        return this.delete(obj.getUuid());
     }
     /**
      * 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* () {
-            return this.delete(uid, undefined, undefined, true);
-        });
+    async forceDelete(uid) {
+        return this.delete(uid, undefined, undefined, true);
     }
     /**
      * Delete an object
@@ -909,62 +819,59 @@ class Store extends service_1.Service {
      * @param {Boolean} delete sync even if asyncDelete is active
      * @return {Promise} the deletion promise
      */
-    delete(uid, writeCondition, writeConditionField, sync = false) {
-        var _a, _b;
-        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;
-            }
-            else {
-                this.metrics.get++;
-                to_delete = yield this._getFromCache(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);
-            }
-            // Check condition as we have the object
-            if (writeCondition) {
-                if (to_delete[writeConditionField] !== writeCondition) {
-                    throw new UpdateConditionFailError(to_delete.getUuid(), writeConditionField, writeCondition);
-                }
+    async delete(uid, writeCondition, writeConditionField, sync = false) {
+        /** @ignore */
+        let to_delete;
+        // Allow full object or just its uuid
+        if (typeof uid === "object") {
+            to_delete = uid;
+        }
+        else {
+            this.metrics.get++;
+            to_delete = await this._getFromCache(uid);
+            if (to_delete === undefined) {
+                return;
             }
-            // Send preevent
-            yield this.emitSync("Store.Delete", {
-                object: to_delete,
-                store: this
-            });
-            yield to_delete._onDelete();
-            // If async we just tag the object as deleted
-            if (this.parameters.asyncDelete && !sync) {
-                this.metrics.partialUpdate++;
-                yield this._patch({
-                    __deleted: true
-                }, to_delete.getUuid());
-                yield ((_a = this._cacheStore) === null || _a === void 0 ? void 0 : _a._patch({
-                    __deleted: true
-                }, to_delete.getUuid()));
+            if (to_delete.__type !== this._model.name && this.parameters.strict) {
+                this.log("WARN", `Object '${uid}' was not created by this store`);
+                return;
             }
-            else {
-                this.metrics.delete++;
-                // Delete from the DB for real
-                yield this._delete(to_delete.getUuid(), writeCondition, writeConditionField);
-                yield ((_b = this._cacheStore) === null || _b === void 0 ? void 0 : _b._delete(to_delete.getUuid(), writeCondition, writeConditionField));
+            to_delete = this.initModel(to_delete);
+        }
+        // Check condition as we have the object
+        if (writeCondition) {
+            if (to_delete[writeConditionField] !== writeCondition) {
+                throw new UpdateConditionFailError(to_delete.getUuid(), writeConditionField, writeCondition);
             }
-            // Send post event
-            yield this.emitSync("Store.Deleted", {
-                object: to_delete,
-                store: this
-            });
-            yield to_delete._onDeleted();
+        }
+        // Send preevent
+        await this.emitSync("Store.Delete", {
+            object: to_delete,
+            store: this
+        });
+        await to_delete._onDelete();
+        // If async we just tag the object as deleted
+        if (this.parameters.asyncDelete && !sync) {
+            this.metrics.partialUpdate++;
+            await this._patch({
+                __deleted: true
+            }, to_delete.getUuid());
+            await this._cacheStore?._patch({
+                __deleted: true
+            }, to_delete.getUuid());
+        }
+        else {
+            this.metrics.delete++;
+            // Delete from the DB for real
+            await this._delete(to_delete.getUuid(), writeCondition, writeConditionField);
+            await this._cacheStore?._delete(to_delete.getUuid(), writeCondition, writeConditionField);
+        }
+        // Send post event
+        await this.emitSync("Store.Deleted", {
+            object: to_delete,
+            store: this
         });
+        await to_delete._onDeleted();
     }
     /**
      * By default we cannot know if the store will trigger or not
@@ -980,22 +887,31 @@ class Store extends service_1.Service {
      * @param {string} id
      * @returns {Promise<Map<string, any>>}
      */
-    getConfiguration(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.metrics.get++;
-            let object = yield this._getFromCache(id);
-            if (!object) {
-                return undefined;
-            }
-            let result = {};
-            for (let i in object) {
-                if (i === this._uuidField || i === this._lastUpdateField || i.startsWith("_")) {
-                    continue;
-                }
-                result[i] = object[i];
+    async getConfiguration(id) {
+        this.metrics.get++;
+        let object = await this._getFromCache(id);
+        if (!object) {
+            return undefined;
+        }
+        let result = {};
+        for (let i in object) {
+            if (i === this._uuidField || i === this._lastUpdateField || i.startsWith("_")) {
+                continue;
             }
-            return result;
-        });
+            result[i] = object[i];
+        }
+        return result;
+    }
+    /**
+     * Upsert the uuid object
+     * @param uuid
+     * @param data
+     */
+    async put(uuid, data) {
+        if (await this.exists(uuid)) {
+            return this.update({ ...data, uuid });
+        }
+        return this.save({ ...data, uuid });
     }
     /**
      * Get an object
@@ -1003,31 +919,29 @@ class Store extends service_1.Service {
      * @param {String} uuid to get
      * @return {Promise} the object retrieved ( can be undefined if not found )
      */
-    get(uid, ctx = undefined) {
-        return __awaiter(this, void 0, void 0, function* () {
-            /** @ignore */
-            if (!uid) {
-                return undefined;
-            }
-            this.metrics.get++;
-            let object = yield this._getFromCache(uid);
-            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", {
-                object: object,
-                store: this,
-                context: ctx
-            });
-            yield object._onGet();
-            return object;
+    async get(uid, ctx = undefined, defaultValue = undefined) {
+        /** @ignore */
+        if (!uid) {
+            return undefined;
+        }
+        this.metrics.get++;
+        let object = await this._getFromCache(uid);
+        if (!object) {
+            return defaultValue ? this.initModel(defaultValue) : 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);
+        await this.emitSync("Store.Get", {
+            object: object,
+            store: this,
+            context: ctx
         });
+        await object._onGet();
+        return object;
     }
     /**
      * Set one attribute in an object
@@ -1039,161 +953,154 @@ class Store extends service_1.Service {
      * @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);
-        });
+    async setAttribute(uid, property, value) {
+        let patch = {};
+        patch[property] = value;
+        patch[this.getUuidField()] = uid;
+        await this.patch(patch);
     }
     /**
      * @override
      */
-    simulateFind(query, uuids) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let result = {
-                results: [],
-                continuationToken: undefined,
-                filter: true
-            };
-            let count = 0;
-            let limit = query.limit;
-            let offset = parseInt(query.continuationToken || "0");
-            let originalOffset = offset;
-            if (query.orderBy && query.orderBy.length) {
-                offset = 0;
-                // We need to retrieve everything to orderBy after
-                limit = Number.MAX_SAFE_INTEGER;
+    async simulateFind(query, uuids) {
+        let result = {
+            results: [],
+            continuationToken: undefined,
+            filter: true
+        };
+        let count = 0;
+        let limit = query.limit;
+        let offset = parseInt(query.continuationToken || "0");
+        let originalOffset = offset;
+        if (query.orderBy && query.orderBy.length) {
+            offset = 0;
+            // We need to retrieve everything to orderBy after
+            limit = Number.MAX_SAFE_INTEGER;
+        }
+        // Need to transfert to Array
+        for (let uuid of uuids) {
+            count++;
+            // Offset start
+            if (offset >= count) {
+                continue;
             }
-            // Need to transfert to Array
-            for (let uuid of uuids) {
-                count++;
-                // Offset start
-                if (offset >= count) {
-                    continue;
-                }
-                let obj = yield this._getFromCache(uuid);
-                if (obj && query.filter.eval(obj)) {
-                    result.results.push(obj);
-                    if (result.results.length >= limit) {
-                        result.continuationToken = count.toString();
-                        return result;
-                    }
+            let obj = await this._getFromCache(uuid);
+            if (obj && query.filter.eval(obj)) {
+                result.results.push(obj);
+                if (result.results.length >= limit) {
+                    result.continuationToken = count.toString();
+                    return result;
                 }
             }
-            // Order by
-            if (query.orderBy && query.orderBy.length) {
-                // Sorting the results
-                result.results.sort((a, b) => {
-                    let valA, valB;
-                    for (let orderBy of query.orderBy) {
-                        let invert = orderBy.direction === "ASC" ? 1 : -1;
-                        valA = query_1.WebdaQL.ComparisonExpression.getAttributeValue(a, orderBy.field.split("."));
-                        valB = query_1.WebdaQL.ComparisonExpression.getAttributeValue(b, orderBy.field.split("."));
-                        if (valA === valB) {
-                            continue;
-                        }
-                        if (typeof valA === "string") {
-                            return valA.localeCompare(valB) * invert;
-                        }
-                        return (valA < valB ? -1 : 1) * invert;
+        }
+        // Order by
+        if (query.orderBy && query.orderBy.length) {
+            // Sorting the results
+            result.results.sort((a, b) => {
+                let valA, valB;
+                for (let orderBy of query.orderBy) {
+                    let invert = orderBy.direction === "ASC" ? 1 : -1;
+                    valA = WebdaQL.ComparisonExpression.getAttributeValue(a, orderBy.field.split("."));
+                    valB = WebdaQL.ComparisonExpression.getAttributeValue(b, orderBy.field.split("."));
+                    if (valA === valB) {
+                        continue;
                     }
-                    return -1;
-                });
-                result.results = result.results.slice(originalOffset, query.limit + originalOffset);
-                if (result.results.length >= query.limit) {
-                    result.continuationToken = (query.limit + originalOffset).toString();
+                    if (typeof valA === "string") {
+                        return valA.localeCompare(valB) * invert;
+                    }
+                    return (valA < valB ? -1 : 1) * invert;
                 }
+                return -1;
+            });
+            result.results = result.results.slice(originalOffset, query.limit + originalOffset);
+            if (result.results.length >= query.limit) {
+                result.continuationToken = (query.limit + originalOffset).toString();
             }
-            return result;
-        });
+        }
+        return result;
+    }
+    getOpenApiReplacements() {
+        return {
+            modelName: this._model.name
+        };
     }
     /**
      * Handle POST
      * @param ctx
      */
-    httpCreate(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let body = yield ctx.getRequestBody();
-            var object = new this._model();
-            object.setContext(ctx);
-            object.load(body);
-            object[this._creationDateField] = new Date();
-            yield object.canAct(ctx, "create");
-            try {
-                yield object.validate(ctx, body);
-            }
-            catch (err) {
-                this.log("INFO", "Object is not valid", err);
-                throw 400;
-            }
-            if (object[this._uuidField] && (yield this.exists(object[this._uuidField]))) {
-                throw 409;
-            }
-            yield this.save(object, ctx);
-            ctx.write(object);
-            yield this.emitSync("Store.WebCreate", {
-                context: ctx,
-                values: body,
-                object: object,
-                store: this
-            });
+    async httpCreate(ctx) {
+        let body = await ctx.getRequestBody();
+        let object = this._model.factory(this._model, body, ctx);
+        object[this._creationDateField] = new Date();
+        await object.canAct(ctx, "create");
+        try {
+            await object.validate(ctx, body);
+        }
+        catch (err) {
+            this.log("INFO", "Object is not valid", err);
+            throw 400;
+        }
+        if (object[this._uuidField] && (await this.exists(object[this._uuidField]))) {
+            throw 409;
+        }
+        await this.save(object, ctx);
+        ctx.write(object);
+        await this.emitSync("Store.WebCreate", {
+            context: ctx,
+            values: body,
+            object: object,
+            store: this
         });
     }
     /**
      * Handle obect action
      * @param ctx
      */
-    httpAction(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let action = ctx.getHttpContext().getUrl().split("/").pop();
-            let object = yield this.get(ctx.parameter("uuid"), ctx);
-            if (object === undefined || object.__deleted) {
-                throw 404;
-            }
-            yield object.canAct(ctx, action);
-            yield this.emitSync("Store.Action", {
-                action: action,
-                object: object,
-                store: this,
-                context: ctx
-            });
-            let res = yield object["_" + action](ctx);
-            if (res) {
-                ctx.write(res);
-            }
-            yield this.emitSync("Store.Actioned", {
-                action: action,
-                object: object,
-                store: this,
-                context: ctx,
-                result: res
-            });
+    async httpAction(ctx) {
+        let action = ctx.getHttpContext().getUrl().split("/").pop();
+        let object = await this.get(ctx.parameter("uuid"), ctx);
+        if (object === undefined || object.__deleted) {
+            throw 404;
+        }
+        await object.canAct(ctx, action);
+        await this.emitSync("Store.Action", {
+            action: action,
+            object: object,
+            store: this,
+            context: ctx
+        });
+        let res = await object["_" + action](ctx);
+        if (res) {
+            ctx.write(res);
+        }
+        await this.emitSync("Store.Actioned", {
+            action: action,
+            object: object,
+            store: this,
+            context: ctx,
+            result: res
         });
     }
     /**
      * Handle collection action
      * @param ctx
      */
-    httpGlobalAction(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let action = ctx.getHttpContext().getUrl().split("/").pop();
-            yield this.emitSync("Store.Action", {
-                action: action,
-                store: this,
-                context: ctx
-            });
-            let res = yield this._model["_" + action](ctx);
-            if (res) {
-                ctx.write(res);
-            }
-            yield this.emitSync("Store.Actioned", {
-                action: action,
-                store: this,
-                context: ctx,
-                result: res
-            });
+    async httpGlobalAction(ctx) {
+        let action = ctx.getHttpContext().getUrl().split("/").pop();
+        await this.emitSync("Store.Action", {
+            action: action,
+            store: this,
+            context: ctx
+        });
+        let res = await this._model["_" + action](ctx);
+        if (res) {
+            ctx.write(res);
+        }
+        await this.emitSync("Store.Actioned", {
+            action: action,
+            store: this,
+            context: ctx,
+            result: res
         });
     }
     /**
@@ -1201,62 +1108,60 @@ class Store extends service_1.Service {
      *
      * @param ctx context of the request
      */
-    httpUpdate(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let body = yield ctx.getRequestBody();
-            let uuid = ctx.parameter("uuid");
-            body[this._uuidField] = uuid;
-            let object = yield this.get(uuid, ctx);
-            if (!object || object.__deleted)
-                throw 404;
-            yield object.canAct(ctx, "update");
-            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
-                Object.keys(updateObject)
-                    .filter(i => i !== "__class")
-                    .forEach(i => {
-                    delete updateObject[i];
-                });
-                updateObject.setContext(ctx);
-                updateObject.load(body);
-                yield this.patch(updateObject);
-                object = undefined;
+    async httpUpdate(ctx) {
+        let body = await ctx.getRequestBody();
+        let uuid = ctx.parameter("uuid");
+        body[this._uuidField] = uuid;
+        let object = await this.get(uuid, ctx);
+        if (!object || object.__deleted)
+            throw 404;
+        await object.canAct(ctx, "update");
+        if (ctx.getHttpContext().getMethod() === "PATCH") {
+            try {
+                await object.validate(ctx, body);
             }
-            else {
-                let updateObject = new this._model();
-                updateObject.load(body);
-                // Copy back the _ attributes
-                Object.keys(object)
-                    .filter(i => i.startsWith("_"))
-                    .forEach(i => {
-                    updateObject[i] = object[i];
-                });
-                try {
-                    yield updateObject.validate(ctx, body);
-                }
-                catch (err) {
-                    this.log("INFO", "Object invalid", err);
-                    throw 400;
-                }
-                // Add mappers back to
-                object = yield this.update(updateObject);
+            catch (err) {
+                this.log("INFO", "Object invalid", err);
+                throw 400;
             }
-            ctx.write(object);
-            yield this.emitSync("Store.WebUpdate", {
-                context: ctx,
-                updates: body,
-                object: object,
-                store: this,
-                method: ctx.getHttpContext().getMethod()
+            let updateObject = new this._model();
+            // Clean any default attributes from the model
+            Object.keys(updateObject)
+                .filter(i => i !== "__class")
+                .forEach(i => {
+                delete updateObject[i];
             });
+            updateObject.setContext(ctx);
+            updateObject.load(body);
+            await this.patch(updateObject);
+            object = undefined;
+        }
+        else {
+            let updateObject = new this._model();
+            updateObject.load(body);
+            // Copy back the _ attributes
+            Object.keys(object)
+                .filter(i => i.startsWith("_"))
+                .forEach(i => {
+                updateObject[i] = object[i];
+            });
+            try {
+                await updateObject.validate(ctx, body);
+            }
+            catch (err) {
+                this.log("INFO", "Object invalid", err);
+                throw 400;
+            }
+            // Add mappers back to
+            object = await this.update(updateObject);
+        }
+        ctx.write(object);
+        await this.emitSync("Store.WebUpdate", {
+            context: ctx,
+            updates: body,
+            object: object,
+            store: this,
+            method: ctx.getHttpContext().getMethod()
         });
     }
     /**
@@ -1264,32 +1169,25 @@ class Store extends service_1.Service {
      *
      * @param ctx context of the request
      */
-    httpGet(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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;
-                }
-                yield object.canAct(ctx, "get");
-                ctx.write(object);
-                yield this.emitSync("Store.WebGet", {
-                    context: ctx,
-                    object: object,
-                    store: this
-                });
-                ctx.write(object);
-            }
-            else {
-                // List probably
-            }
+    async httpGet(ctx) {
+        let uuid = ctx.parameter("uuid");
+        let object = await this.get(uuid, ctx);
+        await this.emitSync("Store.WebGetNotFound", {
+            context: ctx,
+            uuid,
+            store: this
         });
+        if (object === undefined || object.__deleted) {
+            throw 404;
+        }
+        await object.canAct(ctx, "get");
+        ctx.write(object);
+        await this.emitSync("Store.WebGet", {
+            context: ctx,
+            object: object,
+            store: this
+        });
+        ctx.write(object);
     }
     /**
      * Handle HTTP request
@@ -1297,31 +1195,21 @@ class Store extends service_1.Service {
      * @param ctx context of the request
      * @returns
      */
-    httpRoute(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let uuid = ctx.parameter("uuid");
-            if (ctx.getHttpContext().getMethod() == "GET") {
-                return this.httpGet(ctx);
-            }
-            else if (ctx.getHttpContext().getMethod() == "DELETE") {
-                let object = yield this.get(uuid, ctx);
-                if (!object || object.__deleted)
-                    throw 404;
-                yield object.canAct(ctx, "delete");
-                // http://stackoverflow.com/questions/28684209/huge-delay-on-delete-requests-with-204-response-and-no-content-in-objectve-c#
-                // IOS don't handle 204 with Content-Length != 0 it seems
-                // Have trouble to handle the Content-Length on API Gateway so returning an empty object for now
-                ctx.write({});
-                yield this.delete(uuid);
-                yield this.emitSync("Store.WebDelete", {
-                    context: ctx,
-                    object_id: uuid,
-                    store: this
-                });
-            }
-            else if (ctx.getHttpContext().getMethod() === "PUT" || ctx.getHttpContext().getMethod() === "PATCH") {
-                return this.httpUpdate(ctx);
-            }
+    async httpRoute(ctx) {
+        let uuid = ctx.parameter("uuid");
+        let object = await this.get(uuid, ctx);
+        if (!object || object.__deleted)
+            throw 404;
+        await object.canAct(ctx, "delete");
+        // http://stackoverflow.com/questions/28684209/huge-delay-on-delete-requests-with-204-response-and-no-content-in-objectve-c#
+        // IOS don't handle 204 with Content-Length != 0 it seems
+        // Have trouble to handle the Content-Length on API Gateway so returning an empty object for now
+        ctx.write({});
+        await this.delete(uuid);
+        await this.emitSync("Store.WebDelete", {
+            context: ctx,
+            object_id: uuid,
+            store: this
         });
     }
     /**
@@ -1331,5 +1219,135 @@ class Store extends service_1.Service {
         return this._uuidField;
     }
 }
-exports.Store = Store;
+__decorate([
+    Route(".", ["POST"], false, {
+        post: {
+            description: "The way to create a new ${modelName} model",
+            summary: "Create a new ${modelName}",
+            operationId: "create${modelName}",
+            requestBody: {
+                content: {
+                    "application/json": {
+                        schema: {
+                            $ref: "#/components/schemas/${modelName}"
+                        }
+                    }
+                }
+            },
+            responses: {
+                "200": {
+                    description: "Retrieve model",
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: "#/components/schemas/${modelName}"
+                            }
+                        }
+                    }
+                },
+                "400": {
+                    description: "Object is invalid"
+                },
+                "403": {
+                    description: "You don't have permissions"
+                },
+                "409": {
+                    description: "Object already exists"
+                }
+            }
+        }
+    })
+], Store.prototype, "httpCreate", null);
+__decorate([
+    Route("./{uuid}", ["PUT", "PATCH"], false, {
+        put: {
+            description: "Update a ${modelName} if the permissions allow",
+            summary: "Update a ${modelName}",
+            operationId: "updatet${modelName}",
+            schemas: {
+                input: "${modelName}",
+                output: "${modelName}"
+            },
+            responses: {
+                "200": {},
+                "400": {
+                    description: "Object is invalid"
+                },
+                "403": {
+                    description: "You don't have permissions"
+                },
+                "404": {
+                    description: "Unknown object"
+                }
+            }
+        },
+        patch: {
+            description: "Patch a ${modelName} if the permissions allow",
+            summary: "Patch a ${modelName}",
+            operationId: "partialUpdatet${modelName}",
+            schemas: {
+                input: "${modelName}"
+            },
+            responses: {
+                "204": {
+                    description: ""
+                },
+                "400": {
+                    description: "Object is invalid"
+                },
+                "403": {
+                    description: "You don't have permissions"
+                },
+                "404": {
+                    description: "Unknown object"
+                }
+            }
+        }
+    })
+], Store.prototype, "httpUpdate", null);
+__decorate([
+    Route("./{uuid}", ["GET"], false, {
+        get: {
+            description: "Retrieve ${modelName} model if permissions allow",
+            summary: "Retrieve a ${modelName}",
+            operationId: "get${modelName}",
+            schemas: {
+                output: "${modelName}"
+            },
+            responses: {
+                "200": {},
+                "400": {
+                    description: "Object is invalid"
+                },
+                "403": {
+                    description: "You don't have permissions"
+                },
+                "404": {
+                    description: "Unknown object"
+                }
+            }
+        }
+    })
+], Store.prototype, "httpGet", null);
+__decorate([
+    Route("./{uuid}", ["DELETE"], false, {
+        delete: {
+            operationId: "delete${modelName}",
+            description: "Delete ${modelName} if the permissions allow",
+            summary: "Delete a ${modelName}",
+            responses: {
+                "204": {
+                    description: ""
+                },
+                "403": {
+                    description: "You don't have permissions"
+                },
+                "404": {
+                    description: "Unknown object"
+                }
+            }
+        }
+    })
+], Store.prototype, "httpRoute", null);
+export { Store };
 //# sourceMappingURL=store.js.map