@webda/core 4.0.0-beta.1 → 4.0.0-beta.3

package/lib/stores/store.js

@@ -1,70 +1,129 @@
-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;
-};
-import { Counter, Histogram } from "../core.js";
-import { MemoryStore, ModelMapLoaderImplementation, Throttler, WebdaError } from "../index.js";
-import { CoreModel } from "../models/coremodel.js";
-import { Route, Service, ServiceParameters } from "../services/service.js";
-import * as WebdaQL from "@webda/ql";
+import { Counter, Histogram } from "../metrics/metrics.js";
+import * as WebdaError from "../errors/errors.js";
+import { registerRepository } from "@webda/models";
+import { ServiceParameters } from "../services/serviceparameters.js";
+import { Service } from "../services/service.js";
+import { useApplication, useModel, useModelId } from "../application/hooks.js";
+import { useLog } from "../loggers/hooks.js";
+import { useCore, useModelMetadata } from "../core/hooks.js";
+/** Error thrown when an item is not found in a store */
 export class StoreNotFoundError extends WebdaError.CodeError {
+    /** Create a new StoreNotFoundError
+     * @param uuid - the item primary key
+     * @param storeName - the store name
+     */
     constructor(uuid, storeName) {
         super("STORE_NOTFOUND", `Item not found ${uuid} Store(${storeName})`);
     }
 }
+/** Error thrown when a conditional update fails due to a version/condition mismatch */
 export class UpdateConditionFailError extends WebdaError.CodeError {
+    /** Create a new UpdateConditionFailError
+     * @param uuid - the item primary key
+     * @param conditionField - the condition field name
+     * @param condition - the expected condition value
+     */
     constructor(uuid, conditionField, condition) {
         super("STORE_UPDATE_CONDITION_FAILED", `UpdateCondition not met on ${uuid}.${conditionField} === ${condition instanceof Date ? condition.toISOString() : condition}`);
     }
 }
 /**
  * Store parameter
+ *
+ * @internal — Store configuration schema. Authored in `webda.config`/deployment
+ * files; not consumed by app code directly.
  */
 export class StoreParameters extends ServiceParameters {
-    constructor(params, service) {
-        var _a;
-        super(params);
-        this.model ?? (this.model = "Webda/CoreModel");
-        let expose = params.expose;
-        if (typeof expose == "boolean") {
-            expose = {};
-            expose.url = "/" + service.getName().toLowerCase();
-        }
-        else if (typeof expose == "string") {
-            expose = {
-                url: expose
-            };
-        }
-        else if (typeof expose == "object" && expose.url == undefined) {
-            expose.url = "/" + service.getName().toLowerCase();
+    /**
+     * Models managed by this Store.
+     *
+     * @default ["Webda/RegistryEntry"]
+     */
+    models;
+    /**
+     * Allow to load object that does not have the type data
+     *
+     * If set to true, then the Store will only managed the defined _model and no
+     * model extending this one
+     *
+     * @default false
+     */
+    strict;
+    /**
+     * When __type model not found, use the model
+     * If strict is setup this parameter is not used
+     *
+     * @default true
+     */
+    defaultModel;
+    /**
+     * If set, Store will ignore the __type
+     *
+     * @default false
+     */
+    forceModel;
+    /**
+     * Slow query threshold
+     *
+     * @default 30000
+     */
+    slowQueryThreshold;
+    /**
+     * Model Aliases to allow easier rename of Model
+     */
+    modelAliases;
+    /**
+     * Disable default memory cache
+     */
+    noCache;
+    /**
+     * Load store parameters with defaults for model type, strict mode, and aliases
+     * @param params - the service parameters
+     * @returns the result
+     */
+    load(params) {
+        // REFACTOR >= 5
+        if (params.expose) {
+            throw new Error("Expose is not supported anymore, use DomainService instead");
         }
-        if (expose) {
-            expose.restrict = expose.restrict || {};
-            this.expose = expose;
-            (_a = this.expose).queryMethod ?? (_a.queryMethod = "GET");
-            this.url = expose.url;
+        // END_REFACTOR
+        super.load(params);
+        // Deprecation mapping: model + additionalModels → models[]
+        const hasModels = Array.isArray(params.models);
+        const hasModel = typeof params.model === "string";
+        // Presence check (not length) used for the conflict guard so that
+        // `{ models: [...], additionalModels: [] }` is still detected as ambiguous.
+        const hasAdditionalKey = Array.isArray(params.additionalModels);
+        // Length check used for the deprecation branch: an empty additionalModels
+        // alongside a bare `model` is unambiguous and should not warn on its own.
+        const hasAdditional = hasAdditionalKey && params.additionalModels.length > 0;
+        if (hasModels && (hasModel || hasAdditionalKey)) {
+            throw new Error("StoreParameters: `models` and `model`/`additionalModels` are mutually exclusive — ambiguous configuration");
         }
-        if (params.map) {
-            throw new Error("Deprecated map usage, use a MapperService");
+        if (hasModels) {
+            this.models = [...params.models];
         }
-        if (params.index) {
-            throw new Error("Deprecated index usage, use an AggregatorService");
+        else if (hasModel || hasAdditional) {
+            useLog("WARN", `StoreParameters: \`model\` and \`additionalModels\` are deprecated. Use \`models: [...]\` instead.`);
+            this.models = [params.model ?? "Webda/RegistryEntry", ...(params.additionalModels ?? [])];
         }
-        this.strict ?? (this.strict = false);
-        this.defaultModel ?? (this.defaultModel = true);
-        this.forceModel ?? (this.forceModel = false);
-        this.slowQueryThreshold ?? (this.slowQueryThreshold = 30000);
-        this.modelAliases ?? (this.modelAliases = {});
-        this.additionalModels ?? (this.additionalModels = []);
+        else {
+            this.models = ["Webda/RegistryEntry"];
+        }
+        // When the caller passed `models[]` (or nothing at all), backfill the deprecated
+        // fields from the canonical `models[]` so any code still reading `parameters.model`
+        // or `parameters.additionalModels` keeps working. In the legacy-input branch
+        // `super.load(params)` already set both via Object.assign, so the `??=` is a no-op.
+        this.strict ??= false;
+        this.defaultModel ??= true;
+        this.forceModel ??= false;
+        this.slowQueryThreshold ??= 30000;
+        this.modelAliases ??= {};
+        return this;
     }
 }
 /**
  * This class handle NoSQL storage and mapping (duplication) between NoSQL object
- * TODO Create the mapping documentation
- *
- * It use basic CRUD, and can expose those 4 to through HTTP
  *
  * It emits events :
  *   Store.Save: Before saving the object
@@ -77,106 +136,162 @@ export class StoreParameters extends ServiceParameters {
  *   Store.Action: When an action will be done on an object
  *   Store.Actioned: When an action has been done on an object
  *
- * Mapping:
- *
- *
- * Parameters
- *
- *  map: { ... }
- *  expose: { // Enable the HTTP exposure
- *      url: '', // The url to expose to by default it is service name in lowercase ( users for example )
- *      restrict: {
- *	       create: true, // Don't expose the POST /users
- *         update: true, // Don't expose the PUT /users/{uuid}
- *         delete: true, // Don't expose the DELETE /users/{uuid}
- *         get: true // Don't expose the GET /users/{uuid}
- *      }
- *   }
+ * @internal — Subclassed by store packages only. App code never references a
+ * Store directly: use `useRepository(Model)` or static model methods
+ * (`Model.create()`, `Model.query()`, `Model.ref()`).
  * @category CoreServices
  */
 class Store extends Service {
-    constructor() {
-        super(...arguments);
-        /**
-         * Contain the reverse map
-         */
-        this._reverseMap = [];
-        /**
-         * Store teh manager hierarchy with their depth
-         */
-        this._modelsHierarchy = {};
-        /**
-         * Contain the model uuid field
-         */
-        this._uuidField = "uuid";
+    /** All model classes managed by this store. Index 0 is the legacy "primary" model. */
+    _models = [];
+    /** Metadata for each model in `_models`, keyed by Identifier. */
+    _modelMetadatas = new Map();
+    /** Store the manager hierarchy with their depth */
+    _modelsHierarchy = {};
+    /**
+     * Override the resolved model class for this store at runtime. Used by
+     * the abstract `StoreTest` harness so test fixtures can substitute a
+     * subclass with extra fields in place of the configured model. In
+     * production this is a no-op the framework never calls.
+     * @param model - the substitute model class
+     */
+    setModelDefinitionHelper(model) {
+        this._models[0] = model;
+    }
+    /**
+     * Compute and register repositories for all known models based on available stores.
+     *
+     * Called from `Store.init()` so each store's init triggers a recompute.
+     * Cannot be cached: the FIRST store to init (typically `Registry`) would
+     * claim every model with its fallback repository, and subsequent
+     * stores wouldn't get a chance to claim their configured models.
+     * Re-running is idempotent — `registerRepository` overwrites map entries
+     * in place, and the resolution loop is deterministic per current
+     * service/model state.
+     */
+    static computeStores() {
+        // Gather all stores and register Repository
+        const stores = Object.values(useCore().getServices()).filter(s => s instanceof Store);
+        const models = Object.values(useApplication().getModels());
+        const registry = useCore().getService("Registry");
+        // Check each available models
+        for (const model of models) {
+            // Model can be null?
+            if (!model)
+                continue;
+            if (!model.Metadata || !Array.isArray(model.Metadata.PrimaryKey)) {
+                useLog("WARN", `${useModelId(model)} does not have Metadata or PrimaryKey defined`);
+                continue;
+            }
+            let currentValue = -1;
+            let currentStore = undefined;
+            for (const store of stores) {
+                const value = store.handleModel(model);
+                if (value < 0 || (value > currentValue && currentValue !== -1)) {
+                    continue;
+                }
+                currentValue = value;
+                currentStore = store;
+            }
+            if (!currentStore) {
+                useLog("TRACE", `${useModelId(model)} fallback to Registry store`);
+                currentStore = registry;
+            }
+            // Register the repository
+            registerRepository(model, currentStore.getRepository(model));
+            useLog("DEBUG", `${useModelId(model)} using store ${currentStore.getName()}`);
+        }
     }
     /**
-     * Retrieve the Model
+     * Retrieve the Models and build the models hierarchy map.
      *
-     * @throws Error if model is not found
+     * Walks `parameters.models[]` (the canonical flat list introduced in Task 1).
+     * If the list is empty or contains only the default "Webda/RegistryEntry"
+     * fallback, the hierarchy stays empty and the store will not claim any model
+     * — preserving the pre-migration fallback behaviour for test-only or
+     * misconfigured stores.
      */
     computeParameters() {
         super.computeParameters();
-        const app = this.getWebda().getApplication();
-        const p = this.parameters;
-        this._model = app.getModel(p.model);
-        this._modelType = this._model.getIdentifier();
-        this._uuidField = this._model.getUuidField();
-        if (!this.parameters.noCache) {
-            this._cacheStore = new MemoryStore(this._webda, `_${this.getName()}_cache`, {
-                model: this.parameters.model
-            });
-            this._cacheStore.computeParameters();
-            this._cacheStore.initMetrics();
-            this.cacheStorePatchException();
+        const ids = this.parameters.models ?? [];
+        // Empty / default RegistryEntry → leave hierarchy empty (preserves test-only / fallback behaviour).
+        const isOnlyDefault = ids.length === 1 && ids[0] === "Webda/RegistryEntry";
+        if (ids.length === 0 || isOnlyDefault) {
+            return;
         }
-        const recursive = (tree, depth) => {
-            var _a;
-            for (let i in tree) {
-                (_a = this._modelsHierarchy)[i] ?? (_a[i] = depth);
-                this._modelsHierarchy[i] = Math.min(depth, this._modelsHierarchy[i]);
-                this._modelsHierarchy[app.completeNamespace(i)] = this._modelsHierarchy[i];
-                recursive(app.getModelHierarchy(i).children, depth + 1);
+        this._models = [];
+        this._modelMetadatas = new Map();
+        this._modelsHierarchy = {};
+        // Subclasses in ModelMetadata are resolved to ModelClass objects at runtime
+        // (see Application.setModelMetadata). Accept both string IDs and ModelClass
+        // references so the hierarchy is keyed by string identifier throughout.
+        const recursive = (subclasses, depth) => {
+            for (const entry of subclasses) {
+                let subModel;
+                let subId;
+                if (typeof entry === "string") {
+                    subId = entry;
+                    try {
+                        subModel = useModel(entry);
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                else {
+                    subModel = entry;
+                    subId = useModelId(subModel);
+                }
+                if (!subId || !subModel)
+                    continue;
+                this._modelsHierarchy[subId] = Math.min(depth, this._modelsHierarchy[subId] ?? depth);
+                const subMeta = useModelMetadata(subModel);
+                if (!subMeta)
+                    continue;
+                recursive(subMeta.Subclasses ?? [], depth + 1);
             }
         };
-        // Compute the hierarchy
-        this._modelsHierarchy[this._model.getIdentifier(false)] = 0;
-        this._modelsHierarchy[this._model.getIdentifier()] = 0;
-        // Strict Store only store their model
-        if (!this.parameters.strict) {
-            recursive(this._model.getHierarchy().children, 1);
-        }
-        // Add additional models
-        if (this.parameters.additionalModels.length) {
-            // Strict mode is to only allow one model per store
-            if (this.parameters.strict) {
-                this.log("ERROR", "Cannot add additional models in strict mode");
+        for (const id of ids) {
+            let model;
+            try {
+                model = useModel(id);
             }
-            else {
-                for (let modelType of this.parameters.additionalModels) {
-                    const model = app.getModel(modelType);
-                    this._modelsHierarchy[model.getIdentifier(false)] = 0;
-                    this._modelsHierarchy[model.getIdentifier()] = 0;
-                    recursive(model.getHierarchy().children, 1);
-                }
+            catch {
+                model = undefined;
+            }
+            if (!model) {
+                useLog("TRACE", `Store ${this.getName?.() ?? "unknown"}: model not found: ${id}`);
+                continue;
+            }
+            const meta = useModelMetadata(model);
+            if (!meta) {
+                useLog("WARN", `Store ${this.getName?.() ?? "unknown"}: model metadata not found for ${id}`);
+                continue;
+            }
+            this._models.push(model);
+            this._modelMetadatas.set(meta.Identifier, meta);
+            this._modelsHierarchy[meta.Identifier] = 0;
+            if (!this.parameters.strict) {
+                recursive(meta.Subclasses ?? [], 1);
             }
-        }
-        if (this.getParameters().expose) {
-            this.log("WARN", "Exposing a store is not recommended, use a DomainService instead to expose all your CoreModel");
         }
     }
+    /**
+     * Log a slow query (placeholder for future implementation)
+     * @param _query - the query to execute
+     * @param _reason - the reason
+     * @param _time - the time
+     */
     logSlowQuery(_query, _reason, _time) {
         // TODO Need to implement: https://github.com/loopingz/webda.io/issues/202
     }
     /**
-     * Invalidate a cache entry
-     * @param uid
+     * Initialize the store
+     * @returns this for chaining
      */
-    async invalidateCache(uid) {
-        if (this._cacheStore) {
-            this.metrics.cache_invalidations.inc();
-            await this._cacheStore.delete(uid, undefined, undefined, true);
-        }
+    async init() {
+        Store.computeStores();
+        return super.init();
     }
     /**
      * @override
@@ -192,1619 +307,44 @@ class Store extends Service {
             name: "slow_queries",
             help: "Number of slow queries encountered"
         });
-        this.metrics.cache_invalidations = this.getMetric(Counter, {
-            name: "cache_invalidations",
-            help: "Number of cache invalidation encountered"
-        });
-        this.metrics.cache_hits = this.getMetric(Counter, {
-            name: "cache_hits",
-            help: "Number of cache hits"
-        });
+        // this.metrics.cache_invalidations = this.getMetric(Counter, {
+        //   name: "cache_invalidations",
+        //   help: "Number of cache invalidation encountered"
+        // });
+        // this.metrics.cache_hits = this.getMetric(Counter, {
+        //   name: "cache_hits",
+        //   help: "Number of cache hits"
+        // });
         this.metrics.queries = this.getMetric(Histogram, {
             name: "queries",
             help: "Query duration"
         });
     }
     /**
-     * Return Store current model
-     * @returns
+     * All models managed by this store.
+     * @returns the array of model classes managed by this store
      */
-    getModel() {
-        return this._model;
+    getModels() {
+        return this._models;
     }
     /**
      * Return if a model is handled by the store
-     * @param model
+     * @param model - the model to use
      * @return distance from the managed class -1 means not managed, 0 manage exactly this model, >0 manage an ancestor model
      *
+     * @returns the result number
      */
     handleModel(model) {
-        const name = this.getWebda().getApplication().getModelName(model);
+        const name = useModelId(model);
         return this._modelsHierarchy[name] ?? -1;
     }
     /**
-     * Get From Cache or main
-     * @param uuid
-     * @param raiseIfNotFound
-     * @returns
-     */
-    async _getFromCache(uuid, raiseIfNotFound = false) {
-        let res = await this._cacheStore?._get(uuid);
-        if (!res) {
-            res = await this._get(uuid, raiseIfNotFound);
-            if (res) {
-                await this._cacheStore?._save(res);
-            }
-        }
-        else {
-            this.metrics.cache_hits.inc();
-            res.__store = this;
-        }
-        return res;
-    }
-    /**
-     * Get object from store
-     * @param uid
-     * @returns
-     */
-    async getObject(uid) {
-        this.metrics.operations_total.inc({ operation: "get" });
-        return this._getFromCache(uid);
-    }
-    /**
-     * @override
-     */
-    getUrl(url, methods) {
-        // If url is absolute
-        if (url.startsWith("/")) {
-            return url;
-        }
-        // Parent url to find here
-        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);
-    }
-    static getOpenAPI() { }
-    /**
-     * @inheritdoc
-     */
-    initRoutes() {
-        if (!this.parameters.expose) {
-            return;
-        }
-        super.initRoutes();
-        // We enforce ExposeParameters within the constructor
-        const expose = this.parameters.expose;
-        this.getWebda().getRouter().registerModelUrl(this.parameters.model, expose.url);
-        // Query endpoint
-        if (!expose.restrict.query) {
-            let requestBody;
-            if (expose.queryMethod === "PUT") {
-                requestBody = {
-                    content: {
-                        "application/json": {
-                            schema: {
-                                properties: {
-                                    q: {
-                                        type: "string"
-                                    }
-                                }
-                            }
-                        }
-                    }
-                };
-            }
-            this.addRoute(expose.queryMethod === "GET" ? `.{?q}` : ".", [expose.queryMethod], this.httpQuery, {
-                model: this.parameters.model,
-                [expose.queryMethod.toLowerCase()]: {
-                    description: `Query on ${this.parameters.model} model with WebdaQL`,
-                    summary: "Query " + this.parameters.model,
-                    operationId: `query${this._model.name}`,
-                    requestBody,
-                    responses: {
-                        "200": {
-                            description: `Retrieve models ${this._model.name}`,
-                            content: {
-                                "application/json": {
-                                    schema: {
-                                        properties: {
-                                            continuationToken: {
-                                                type: "string"
-                                            },
-                                            results: {
-                                                type: "array",
-                                                items: {
-                                                    $ref: `#/components/schemas/${this._model.name}`
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        },
-                        "400": {
-                            description: "Query is invalid"
-                        },
-                        "403": {
-                            description: "You don't have permissions"
-                        }
-                    }
-                }
-            });
-        }
-        // Model actions
-        if (this._model && this._model.getActions) {
-            let actions = this._model.getActions();
-            Object.keys(actions).forEach(name => {
-                let action = actions[name];
-                action.method ?? (action.method = name);
-                if (!action.methods) {
-                    action.methods = ["PUT"];
-                }
-                let executer;
-                if (action.global) {
-                    // By default will grab the object and then call the action
-                    if (!this._model[action.method]) {
-                        throw Error("Action static method " + action.method + " does not exist");
-                    }
-                    executer = this.httpGlobalAction;
-                    this.addRoute(`./${name}`, action.methods, executer, action.openapi);
-                }
-                else {
-                    // By default will grab the object and then call the action
-                    if (!this._model.prototype[action.method]) {
-                        throw Error("Action method " + action.method + " does not exist");
-                    }
-                    executer = ctx => this.httpAction(ctx, action.method);
-                    this.addRoute(`./{uuid}/${name}`, action.methods, executer, action.openapi);
-                }
-            });
-        }
-    }
-    /**
-     * OVerwrite the model
-     * Used mainly in test
-     */
-    setModel(model) {
-        this._model = model;
-        this._cacheStore?.setModel(model);
-        this.parameters.strict = false;
-    }
-    /**
-     * We should ignore exception from the store
-     */
-    cacheStorePatchException() {
-        const replacer = original => {
-            return (...args) => {
-                return original
-                    .bind(this._cacheStore, ...args)()
-                    .catch(err => {
-                    this.log("TRACE", `Ignoring cache exception ${this._name}: ${err.message}`);
-                });
-            };
-        };
-        for (let i of [
-            "_get",
-            "_patch",
-            "_update",
-            "_delete",
-            "_incrementAttributes",
-            "_upsertItemToCollection",
-            "_deleteItemFromCollection",
-            "_removeAttribute"
-        ]) {
-            this._cacheStore[i] = replacer(this._cacheStore[i]);
-        }
-    }
-    /**
-     * Init a model from the current stored data
-     *
-     * Initial the reverse map as well
-     *
-     * @param object
-     * @returns
-     */
-    initModel(object = {}) {
-        var _a;
-        object.__type ?? (object.__type = this.getWebda().getApplication().getModelFromInstance(object) || this._modelType);
-        // Make sure to send a model object
-        if (!(object instanceof this._model)) {
-            // Dynamic load type
-            if (object.__type && !this.getParameters().forceModel) {
-                try {
-                    const modelType = this.getWebda()
-                        .getApplication()
-                        .getModel(this.parameters.modelAliases[object.__type] || object.__type);
-                    object = new modelType().load(object, true);
-                }
-                catch (err) {
-                    if (!this.parameters.defaultModel) {
-                        throw new Error(`Unknown model ${object.__type} found for Store(${this.getName()})`);
-                    }
-                    object = this._model.factory(object);
-                }
-            }
-            else {
-                object = this._model.factory(object);
-            }
-        }
-        if (!object.getUuid()) {
-            object.setUuid(object.generateUid(object));
-        }
-        object.__store = this;
-        for (let i in this._reverseMap) {
-            object[_a = this._reverseMap[i].property] ?? (object[_a] = []);
-            for (let j in object[this._reverseMap[i].property]) {
-                if (object[this._reverseMap[i].property][j] instanceof ModelMapLoaderImplementation) {
-                    continue;
-                }
-                // Use Partial
-                object[this._reverseMap[i].property][j] = this._reverseMap[i].mapper.newModel(object[this._reverseMap[i].property][j]);
-                object[this._reverseMap[i].property][j].setContext(object.getContext());
-            }
-        }
-        return object;
-    }
-    /**
-     * Get a new model with this data preloaded
-     * @param object
-     * @returns
-     */
-    newModel(object = {}) {
-        let result = this.initModel(object);
-        Object.keys(object).forEach(k => result.__dirty.add(k));
-        return result;
-    }
-    /**
-     * Add reverse map information
-     *
-     * @param prop
-     * @param cascade
-     * @param store
-     */
-    addReverseMap(prop, store) {
-        this._reverseMap.push({
-            property: prop,
-            mapper: store
-        });
-    }
-    /**
-     * Increment attributes of an object
-     *
-     * @param uid
-     * @param info
-     * @returns
-     */
-    async incrementAttributes(uid, info) {
-        let params = info.filter(i => i.value !== 0);
-        // If value === 0 no need to update anything
-        if (params.length === 0) {
-            return;
-        }
-        let updateDate = new Date();
-        this.metrics.operations_total.inc({ operation: "increment" });
-        await this._incrementAttributes(uid, params, updateDate);
-        const evt = {
-            object_id: uid,
-            store: this,
-            updateDate,
-            partial_update: {
-                increments: params
-            }
-        };
-        await this.emitStoreEvent("Store.PartialUpdated", evt);
-        return updateDate;
-    }
-    /**
-     * Helper function that call incrementAttributes
-     * @param uid
-     * @param prop
-     * @param value
-     * @returns
-     */
-    async incrementAttribute(uid, prop, value) {
-        return this.incrementAttributes(uid, [{ property: prop, value }]);
-    }
-    /**
-     * Add or update an item to an array in the model
-     *
-     * @param uid of the model
-     * @param prop of the model to add in
-     * @param item to add in the array
-     * @param index if specified update item in this index
-     * @param itemWriteCondition value of the condition to test (in case of update)
-     * @param itemWriteConditionField field to read the condition from (in case of update)
-     */
-    async upsertItemToCollection(uid, prop, item, index = undefined, itemWriteCondition = undefined, itemWriteConditionField = this._uuidField) {
-        let updateDate = new Date();
-        this.metrics.operations_total.inc({ operation: "collectionUpsert" });
-        await this._upsertItemToCollection(uid, prop, item, index, itemWriteCondition, itemWriteConditionField, updateDate);
-        await this.emitStoreEvent("Store.PartialUpdated", {
-            object_id: uid,
-            store: this,
-            updateDate,
-            partial_update: {
-                addItem: {
-                    value: item,
-                    property: prop,
-                    index: index
-                }
-            }
-        });
-        return updateDate;
-    }
-    /**
-     * Remove an item from an array in the model
-     *
-     * @param uid of the model
-     * @param prop of the model to remove from
-     * @param index of the item to remove in the array
-     * @param itemWriteCondition value of the condition
-     * @param itemWriteConditionField field to read the condition from
-     */
-    async deleteItemFromCollection(uid, prop, index, itemWriteCondition, itemWriteConditionField = this._uuidField) {
-        let updateDate = new Date();
-        this.metrics.operations_total.inc({ operation: "collectionDelete" });
-        await this._deleteItemFromCollection(uid, prop, index, itemWriteCondition, itemWriteConditionField, updateDate);
-        await this.emitStoreEvent("Store.PartialUpdated", {
-            object_id: uid,
-            store: this,
-            updateDate,
-            partial_update: {
-                deleteItem: {
-                    property: prop,
-                    index: index
-                }
-            }
-        });
-        return updateDate;
-    }
-    /**
-     * Iterate through the results
-     *
-     * This can be resource consuming
-     *
-     * @param query
-     * @param context
-     */
-    async *iterate(query = "", context) {
-        if (query.includes("OFFSET")) {
-            throw new Error("Cannot contain an OFFSET for iterate method");
-        }
-        let continuationToken;
-        do {
-            let q = query + (continuationToken !== undefined ? ` OFFSET "${continuationToken}"` : "");
-            let page = await this.query(q, context);
-            for (let item of page.results) {
-                yield item;
-            }
-            continuationToken = page.continuationToken;
-        } while (continuationToken);
-    }
-    // REFACTOR . >= 4
-    /**
-     * Query all the results
-     *
-     *
-     * @param query
-     * @param context
-     * @returns
-     * @deprecated use iterate instead
-     */
-    async queryAll(query, context) {
-        let res = [];
-        for await (let item of this.iterate(query, context)) {
-            res.push(item);
-        }
-        return res;
-    }
-    // END_REFACTOR
-    /**
-     * Check that __type Comparison is only used with = and CONTAINS
-     * If CONTAINS is used, move __type to __types
-     * If __type = store._model, remove it
-     */
-    queryTypeUpdater(query) {
-        return query;
-    }
-    /**
-     * Query store with WebdaQL
-     * @param query
-     * @param context to apply permission
-     */
-    async query(query, context) {
-        let permissionQuery = this._model.getPermissionQuery(context);
-        let partialPermission = true;
-        let fullQuery = query;
-        if (permissionQuery) {
-            partialPermission = permissionQuery.partial;
-            fullQuery = WebdaQL.PrependCondition(query, permissionQuery.query);
-        }
-        let queryValidator = new WebdaQL.QueryValidator(fullQuery);
-        let offset = queryValidator.getOffset();
-        const limit = queryValidator.getLimit();
-        const parsedQuery = this.queryTypeUpdater(queryValidator.getQuery());
-        parsedQuery.limit = limit;
-        // __type is a special field to filter on the type of the object
-        // 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.operations_total.inc({ operation: "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) {
-                item.setContext(context);
-                // 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 && (await item.canAct(context, "get")) !== true) {
-                    continue;
-                }
-                result.results.push(item);
-                if (result.results.length >= limit) {
-                    if (subOffsetCount === tmpResults.results.length) {
-                        result.continuationToken = tmpResults.continuationToken;
-                    }
-                    else {
-                        result.continuationToken = `${mainOffset}_${subOffsetCount}`;
-                    }
-                    break;
-                }
-            }
-            // 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.queries.observe(duration / 1000);
-        if (duration > this.parameters.slowQueryThreshold) {
-            this.logSlowQuery(query, "", duration);
-            this.metrics.slow_queries_total.inc();
-        }
-        await this.emitSync("Store.Queried", {
-            query,
-            parsedQuery: parsedQuery,
-            store: this,
-            continuationToken: result.continuationToken,
-            results: result.results,
-            context
-        });
-        return result;
-    }
-    /**
-     * Expose query to http
-     */
-    async httpQuery(ctx) {
-        let query;
-        if (ctx.getHttpContext().getMethod() === "GET") {
-            query = ctx.getParameters().q;
-        }
-        else {
-            query = WebdaQL.unsanitize((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 new WebdaError.BadRequest("Query syntax error");
-            }
-            throw err;
-        }
-    }
-    /**
-     * Handle StoreEvent and update cache based on it
-     * Then emit the event, it allows the cache to be updated
-     * before listeners are called
-     *
-     * @param event
-     * @param data
-     */
-    async emitStoreEvent(event, data) {
-        if (event === "Store.Deleted") {
-            await this._cacheStore?._delete(data.object_id);
-        }
-        else if (event === "Store.PartialUpdated") {
-            const partialEvent = data;
-            if (partialEvent.partial_update.increments) {
-                await this._cacheStore?._incrementAttributes(partialEvent.object_id, partialEvent.partial_update.increments, partialEvent.updateDate);
-            }
-            else if (partialEvent.partial_update.deleteAttribute) {
-                await this._cacheStore?._removeAttribute(partialEvent.object_id, partialEvent.partial_update.deleteAttribute, partialEvent.updateDate);
-            }
-            else if (partialEvent.partial_update.addItem) {
-                await this._cacheStore?._upsertItemToCollection(partialEvent.object_id, partialEvent.partial_update.addItem.property, partialEvent.partial_update.addItem.value, partialEvent.partial_update.addItem.index, undefined, undefined, partialEvent.updateDate);
-            }
-            else if (partialEvent.partial_update.deleteItem) {
-                await this._cacheStore?._deleteItemFromCollection(partialEvent.object_id, partialEvent.partial_update.deleteItem.property, partialEvent.partial_update.deleteItem.index, undefined, undefined, partialEvent.updateDate);
-            }
-            else if (partialEvent.partial_update.patch) {
-                await this._cacheStore?._patch(partialEvent.partial_update.patch, partialEvent.object_id);
-            }
-            else {
-                await this.invalidateCache(partialEvent.object_id);
-            }
-        }
-        else if (event === "Store.Updated") {
-            await this._cacheStore?._update(data.update, data.object_id);
-        }
-        else if (event === "Store.PatchUpdated") {
-            await this._cacheStore?._patch(data.object, data.object_id);
-        }
-        await this.emitSync(event, data);
-    }
-    /**
-     * 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
-     */
-    async save(object, ctx = undefined) {
-        if (object instanceof this._model && object._creationDate !== undefined && object._lastUpdate !== undefined) {
-            if (ctx) {
-                object.setContext(ctx);
-            }
-            return await object.save();
-        }
-        return this.create(object, ctx);
-    }
-    /**
-     *
-     * @param object
-     * @param ctx
-     * @returns
-     */
-    async create(object, ctx = undefined) {
-        object = this.initModel(object);
-        // Dates should be store by the Store
-        if (!object._creationDate) {
-            object._creationDate = object._lastUpdate = new Date();
-        }
-        else {
-            object._lastUpdate = new Date();
-        }
-        const ancestors = this.getWebda().getApplication().getModelHierarchy(object.__type).ancestors;
-        object.__types = [object.__type, ...ancestors].filter(i => i !== "Webda/CoreModel" && i !== "CoreModel");
-        if (ctx) {
-            object.setContext(ctx);
-        }
-        // Handle object auto listener
-        const evt = {
-            object: object,
-            object_id: object.getUuid(),
-            store: this,
-            context: ctx
-        };
-        await Promise.all([
-            this.emitSync("Store.Save", evt),
-            object?.__class.emitSync("Store.Save", evt),
-            object._onSave()
-        ]);
-        this.metrics.operations_total.inc({ operation: "save" });
-        let res = await this._save(object);
-        await this._cacheStore?._save(object);
-        object = this.initModel(res);
-        const evtSaved = {
-            object: object,
-            object_id: object.getUuid(),
-            store: this,
-            context: ctx
-        };
-        await Promise.all([
-            this.emitSync("Store.Saved", evtSaved),
-            object?.__class.emitSync("Store.Saved", evtSaved),
-            object._onSaved()
-        ]);
-        return object;
-    }
-    /**
-     * Patch an object
-     *
-     * @param object
-     * @param reverseMap
-     * @returns
-     */
-    async patch(object, reverseMap = true, conditionField, conditionValue) {
-        return this.update(object, reverseMap, true, conditionField, conditionValue);
-    }
-    /**
-     * Check if an UpdateCondition is met
-     * @param model
-     * @param conditionField
-     * @param condition
-     * @param uid
+     * Check that keys are valid
+     * All keys of model stored in a Store must have the same type of primary key
      */
-    checkUpdateCondition(model, conditionField, condition, uid) {
-        if (conditionField) {
-            // Add toString to manage Date object
-            if (model[conditionField].toString() !== condition.toString()) {
-                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);
-        }
-    }
-    /**
-     * Update conditionally
-     * @param uuid
-     * @param updates
-     * @param conditionField
-     * @param condition
-     */
-    async conditionalPatch(uuid, updates, conditionField, condition) {
-        try {
-            await this._patch(updates, uuid, condition, conditionField);
-            // CoreModel should also emit this one but cannot do within this context
-            await this.emitStoreEvent("Store.PartialUpdated", {
-                object_id: uuid,
-                partial_update: {
-                    patch: updates
-                },
-                store: this
-            });
-            return true;
-        }
-        catch (err) {
-            if (err instanceof UpdateConditionFailError) {
-                return false;
-            }
-            throw err;
-        }
-    }
-    /**
-     *
-     * @param model
-     * @param prop
-     * @param item
-     * @param index
-     * @param itemWriteCondition
-     * @param itemWriteConditionField
-     * @param updateDate
-     */
-    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].push(item);
-            }
-        }
-        else {
-            model[prop][index] = item;
-        }
-        model._lastUpdate = 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
-     */
-    async update(object, reverseMap = true, partial = false, conditionField, conditionValue) {
-        /** @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 undefined;
-        }
-        object._lastUpdate = new Date();
-        this.metrics.operations_total.inc({ operation: "get" });
-        const uuid = object.getUuid ? object.getUuid() : object[this._uuidField];
-        let load = await this._getFromCache(uuid, true);
-        if (load.__type !== this._modelType && this.parameters.strict) {
-            this.log("WARN", `Object '${uuid}' was not created by this store ${load.__type}:${this._modelType}`);
-            throw new StoreNotFoundError(uuid, this.getName());
-        }
-        loaded = this.initModel(load);
-        if (object instanceof CoreModel) {
-            loaded.setContext(object.getContext());
-        }
-        const update = object;
-        const evt = {
-            object: loaded,
-            object_id: loaded.getUuid(),
-            store: this,
-            update
-        };
-        await Promise.all([
-            this.emitSync(partial ? `Store.PatchUpdate` : `Store.Update`, evt),
-            object?.__class?.emitSync(partial ? `Store.PatchUpdate` : `Store.Update`, evt),
-            loaded._onUpdate(object)
-        ]);
-        let res;
-        if (conditionField !== null) {
-            conditionField ?? (conditionField = "_lastUpdate");
-            conditionValue ?? (conditionValue = load[conditionField]);
-        }
-        if (partial) {
-            this.metrics.operations_total.inc({ operation: "partialUpdate" });
-            await this._patch(object, uuid, conditionValue, conditionField);
-            res = object;
-        }
-        else {
-            // Copy back the mappers
-            for (let i in this._reverseMap) {
-                object[this._reverseMap[i].property] = loaded[this._reverseMap[i].property];
-            }
-            object = this.initModel(object);
-            this.metrics.operations_total.inc({ operation: "update" });
-            res = await this._update(object, uuid, conditionValue, conditionField);
-        }
-        // Reinit save
-        saved = this.initModel({
-            ...loaded,
-            ...res
-        });
-        const evtUpdated = {
-            object: saved,
-            object_id: saved.getUuid(),
-            store: this,
-            update,
-            previous: loaded
-        };
-        await Promise.all([
-            this.emitStoreEvent(partial ? `Store.PatchUpdated` : `Store.Updated`, evtUpdated),
-            saved?.__class.emitSync(partial ? `Store.PatchUpdated` : `Store.Updated`, evtUpdated),
-            saved._onUpdated()
-        ]);
-        return saved;
-    }
-    /**
-     * Manage the store migration for __type case sensitivity
-     */
-    async v3Migration() {
-        // Compute case for all object
-        await this.recomputeTypeCase();
-        // Compute all __types
-        await this.recomputeTypes();
-        // We do not move to short id as it is not compatible with v2
-    }
-    /**
-     *
-     */
-    async recomputeTypeShortId() {
-        this.log("INFO", "Ensuring __type is using its short id form");
-        const app = this.getWebda().getApplication();
-        // We need to be laxist for migration
-        this.parameters.strict = false;
-        await this.migration("typesShortId", async (item) => {
-            if (item.__type !== undefined && item.__type.includes("/")) {
-                const model = app.getWebdaObject("models", item.__type);
-                const name = app.getShortId(app.getModelName(model));
-                if (name !== item.__type) {
-                    this.log("INFO", "Migrating type " + item.__type + " to " + name);
-                    return {
-                        __type: name
-                    };
-                }
-            }
-        });
-    }
-    /**
-     * Ensure model aliases are not used in this store
-     *
-     * So alias can be cleaned
-     */
-    async cleanModelAliases() {
-        this.log("INFO", "Ensuring __type is not using any aliases");
-        // We need to be laxist for migration
-        this.parameters.strict = false;
-        await this.migration("cleanAliases", async (item) => {
-            if (this.parameters.modelAliases[item.__type]) {
-                this.log("INFO", "Migrating type " + item.__type + " to " + this.parameters.modelAliases[item.__type]);
-                return {
-                    __type: this.parameters.modelAliases[item.__type]
-                };
-            }
-        });
-    }
-    /**
-     * Recompute type case
-     */
-    async recomputeTypeCase() {
-        this.log("INFO", "Ensuring __type is case sensitive from migration from v2.x");
-        const app = this.getWebda().getApplication();
-        // We need to be laxist for migration
-        this.parameters.strict = false;
-        await this.migration("typesCase", async (item) => {
-            if (item.__type !== undefined) {
-                if (!app.hasWebdaObject("models", item.__type, true) && app.hasWebdaObject("models", item.__type, false)) {
-                    const model = app.getWebdaObject("models", item.__type, false);
-                    const name = app.getModelName(model);
-                    if (model) {
-                        this.log("INFO", "Migrating type " + item.__type + " to " + name);
-                        return {
-                            __type: name
-                        };
-                    }
-                }
-            }
-        });
-    }
-    /**
-     * Recompute the __types for all objects (storeMigration.Registry.typesCompute)
-     */
-    async recomputeTypes() {
-        this.log("INFO", "Ensuring __types is correct from migration from v2.x");
-        // Update __types for each __type will be more efficient
-        await this.migration("typesCompute", async (item) => {
-            let __types = this.getWebda().getApplication().getModelTypes(item);
-            if (!item.__types ||
-                item.__types.length !== __types.length ||
-                !__types.every((element, index) => element === item.__types[index])) {
-                this.log("INFO", "Migrating types " + JSON.stringify(item.__types) + " to " + JSON.stringify(__types), "for", item.__type, item.getUuid());
-                return {
-                    __types
-                };
-            }
-        });
-    }
-    /**
-     * Delete a migration
-     * @param name
-     */
-    async cancelMigration(name) {
-        await this.getWebda().getRegistry().delete(`storeMigration.${this.getName()}.${name}`);
-    }
-    /**
-     * Get a migration
-     * @param name
-     */
-    async getMigration(name) {
-        return await this.getWebda().getRegistry().get(`storeMigration.${this.getName()}.${name}`);
-    }
-    /**
-     * Add a migration mechanism to store
-     * @param name
-     * @param patcher
-     */
-    async migration(name, patcher, batchSize = 500) {
-        let status = await this.getWebda().getRegistry().get(`storeMigration.${this.getName()}.${name}`, undefined, {});
-        status.count ?? (status.count = 0);
-        status.updated ?? (status.updated = 0);
-        const worker = new Throttler(20);
-        do {
-            const res = await this.query(status.continuationToken ? `LIMIT ${batchSize} OFFSET "${status.continuationToken}"` : `LIMIT ${batchSize}`);
-            status.count += res.results.length;
-            for (let item of res.results) {
-                let updated = await patcher(item);
-                if (updated !== undefined) {
-                    status.updated++;
-                    if (typeof updated === "function") {
-                        worker.queue(updated);
-                    }
-                    else {
-                        worker.queue(async () => {
-                            await item.patch(updated, null);
-                        });
-                    }
-                }
-            }
-            this.log("INFO", `storeMigration.${this.getName()}.${name}: Migrated ${status.count} items: ${status.updated} updated`);
-            status.continuationToken = res.continuationToken;
-            await worker.wait();
-            await status.save();
-        } while (status.continuationToken);
-    }
-    /**
-     * Remove an attribute from an object
-     *
-     * @param uuid
-     * @param attribute
-     * @returns
-     */
-    async removeAttribute(uuid, attribute, itemWriteCondition, itemWriteConditionField) {
-        this.metrics.operations_total.inc({ operation: "attributeDelete" });
-        await this._removeAttribute(uuid, attribute, itemWriteCondition, itemWriteConditionField);
-        await this.emitStoreEvent("Store.PartialUpdated", {
-            object_id: uuid,
-            partial_update: {
-                deleteAttribute: attribute
-            },
-            store: this
-        });
-    }
-    /**
-     * Cascade delete a related object
-     *
-     * @param obj
-     * @param uuid
-     * @returns
-     */
-    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
-     */
-    async forceDelete(uid) {
-        return this.delete(uid, undefined, undefined, true);
-    }
-    /**
-     * Delete an object
-     *
-     * @param {String} uuid to delete
-     * @param {Boolean} delete sync even if asyncDelete is active
-     * @return {Promise} the deletion promise
-     */
-    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.operations_total.inc({ operation: "get" });
-            to_delete = await this._getFromCache(uid);
-            if (to_delete === undefined) {
-                return;
-            }
-            if (to_delete.__type !== this._modelType && this.parameters.strict) {
-                this.log("WARN", `Object '${uid}' was not created by this store ${to_delete.__type}:${this._modelType}`);
-                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);
-            }
-        }
-        const evt = {
-            object: to_delete,
-            object_id: to_delete.getUuid(),
-            store: this
-        };
-        // Send preevent
-        await Promise.all([
-            this.emitSync("Store.Delete", evt),
-            to_delete?.__class.emitSync("Store.Delete", evt),
-            to_delete._onDelete()
-        ]);
-        // If async we just tag the object as deleted
-        if (this.parameters.asyncDelete && !sync) {
-            this.metrics.operations_total.inc({ operation: "partialUpdate" });
-            await this._patch({
-                __deleted: true
-            }, to_delete.getUuid());
-            await this._cacheStore?._patch({
-                __deleted: true
-            }, to_delete.getUuid());
-        }
-        else {
-            this.metrics.operations_total.inc({ operation: "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
-        const evtDeleted = {
-            object: to_delete,
-            object_id: to_delete.getUuid(),
-            store: this
-        };
-        await Promise.all([
-            this.emitStoreEvent("Store.Deleted", evtDeleted),
-            to_delete.__class.emitSync("Store.Deleted", evtDeleted),
-            to_delete._onDeleted()
-        ]);
-    }
-    /**
-     * By default we cannot know if the store will trigger or not
-     *
-     * @param id
-     * @param callback
-     */
-    canTriggerConfiguration(_id, _callback) {
-        return false;
-    }
-    /**
-     * Provide a way to store configuration in store
-     * @param {string} id
-     * @returns {Promise<Map<string, any>>}
-     */
-    async getConfiguration(id) {
-        this.metrics.operations_total.inc({ operation: "get" });
-        let object = await this._getFromCache(id);
-        if (!object) {
-            return undefined;
-        }
-        let result = {};
-        for (let i in object) {
-            if (i === this._uuidField || i === "_lastUpdate" || i.startsWith("_")) {
-                continue;
-            }
-            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 instanceof CoreModel ? data.setUuid(uuid) : { ...data, uuid });
-    }
-    /**
-     * Get an object
-     *
-     * @param {String} uuid to get
-     * @return {Promise} the object retrieved ( can be undefined if not found )
-     */
-    async get(uid, ctx = undefined, defaultValue = undefined) {
-        /** @ignore */
-        if (!uid) {
-            return undefined;
-        }
-        this.metrics.operations_total.inc({ operation: "get" });
-        let object = await this._getFromCache(uid);
-        if (!object) {
-            return defaultValue ? this.initModel(defaultValue).setUuid(uid) : undefined;
-        }
-        if (object.__type !== this._modelType && this.parameters.strict) {
-            this.log("WARN", `Object '${uid}' was not created by this store ${object.__type}:${this._modelType}`);
-            return undefined;
-        }
-        object = this.initModel(object);
-        object.setContext(ctx);
-        const evt = {
-            object: object,
-            object_id: object.getUuid(),
-            store: this,
-            context: ctx
-        };
-        await Promise.all([this.emitSync("Store.Get", evt), object.__class.emitSync("Store.Get", evt), object._onGet()]);
-        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
-     */
-    async setAttribute(uid, property, value) {
-        let patch = {};
-        patch[property] = value;
-        patch[this.getUuidField()] = uid;
-        await this.patch(patch);
-    }
-    /**
-     * @override
-     */
-    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;
-            }
-            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 = WebdaQL.ComparisonExpression.getAttributeValue(a, orderBy.field.split("."));
-                    valB = 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;
-                }
-                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;
-    }
-    getOpenApiReplacements() {
-        return {
-            modelName: this._model.name
-        };
-    }
-    /**
-     * Handle POST
-     * @param ctx
-     */
-    async httpCreate(ctx) {
-        return this.operationCreate(ctx, this.parameters.model);
-    }
-    /**
-     * Create a new object based on the context
-     * @param ctx
-     * @param model
-     */
-    async operationCreate(ctx, model) {
-        let body = await ctx.getInput();
-        const modelPrototype = this.getWebda().getApplication().getModel(model);
-        let object = modelPrototype.factory(body, ctx);
-        object._creationDate = new Date();
-        await object.checkAct(ctx, "create");
-        try {
-            await object.validate(ctx, body);
-        }
-        catch (err) {
-            this.log("INFO", "Object is not valid", err);
-            throw new WebdaError.BadRequest("Object is not valid");
-        }
-        if (object[this._uuidField] && (await this.exists(object[this._uuidField]))) {
-            throw new WebdaError.Conflict("Object already exists");
-        }
-        await this.save(object, ctx);
-        ctx.write(object);
-        const evt = {
-            context: ctx,
-            values: body,
-            object: object,
-            object_id: object.getUuid(),
-            store: this
-        };
-        await Promise.all([object.__class.emitSync("Store.WebCreate", evt), this.emitSync("Store.WebCreate", evt)]);
-    }
-    /**
-     * Handle obect action
-     * @param ctx
-     */
-    async httpAction(ctx, actionMethod) {
-        let action = ctx.getHttpContext().getUrl().split("/").pop();
-        actionMethod ?? (actionMethod = action);
-        let object = await this.get(ctx.parameter("uuid"), ctx);
-        if (object === undefined || object.__deleted) {
-            throw new WebdaError.NotFound("Object not found or is deleted");
-        }
-        const inputSchema = `${object.__class.getIdentifier(false)}.${action}.input`;
-        if (this.getWebda().getApplication().hasSchema(inputSchema)) {
-            const input = await ctx.getInput();
-            try {
-                this.getWebda().validateSchema(inputSchema, input);
-            }
-            catch (err) {
-                this.log("INFO", "Object invalid", err);
-                this.log("INFO", "Object invalid", inputSchema, input, this.getWebda().getApplication().getSchema(inputSchema));
-                throw new WebdaError.BadRequest("Body is invalid");
-            }
-        }
-        await object.checkAct(ctx, action);
-        const evt = {
-            action: action,
-            object: object,
-            store: this,
-            context: ctx
-        };
-        await Promise.all([this.emitSync("Store.Action", evt), object.__class.emitSync("Store.Action", evt)]);
-        const res = await object[actionMethod](ctx);
-        if (res) {
-            ctx.write(res);
-        }
-        const evtActioned = {
-            action: action,
-            object: object,
-            store: this,
-            context: ctx,
-            result: res
-        };
-        await Promise.all([
-            this.emitSync("Store.Actioned", evtActioned),
-            object?.__class.emitSync("Store.Actioned", evtActioned)
-        ]);
-    }
-    /**
-     * Handle collection action
-     * @param ctx
-     */
-    async httpGlobalAction(ctx, model = this._model) {
-        let action = ctx.getHttpContext().getUrl().split("/").pop();
-        const evt = {
-            action: action,
-            store: this,
-            context: ctx,
-            model
-        };
-        await Promise.all([this.emitSync("Store.Action", evt), model.emitSync("Store.Action", evt)]);
-        const res = await model[action](ctx);
-        if (res) {
-            ctx.write(res);
-        }
-        const evtActioned = {
-            action: action,
-            store: this,
-            context: ctx,
-            result: res,
-            model
-        };
-        await Promise.all([this.emitSync("Store.Actioned", evtActioned), model?.emitSync("Store.Actioned", evtActioned)]);
-    }
-    /**
-     * Handle HTTP Update for an object
-     *
-     * @param ctx context of the request
-     */
-    async httpUpdate(ctx) {
-        const { uuid } = ctx.getParameters();
-        const body = await ctx.getInput();
-        body[this._uuidField] = uuid;
-        let object = await this.get(uuid, ctx);
-        if (!object || object.__deleted)
-            throw new WebdaError.NotFound("Object not found or is deleted");
-        await object.checkAct(ctx, "update");
-        if (ctx.getHttpContext().getMethod() === "PATCH") {
-            try {
-                await object.validate(ctx, body, true);
-            }
-            catch (err) {
-                this.log("INFO", "Object invalid", err, object);
-                throw new WebdaError.BadRequest("Object is not valid");
-            }
-            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.setUuid(uuid);
-            updateObject.load(body, false, false);
-            await this.patch(updateObject);
-            object = undefined;
-        }
-        else {
-            let updateObject = new this._model();
-            updateObject.setContext(ctx);
-            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 new WebdaError.BadRequest("Object is not valid");
-            }
-            // Add mappers back to
-            object = await this.update(updateObject);
-        }
-        ctx.write(object);
-        const evt = {
-            context: ctx,
-            updates: body,
-            object: object,
-            store: this,
-            method: ctx.getHttpContext().getMethod()
-        };
-        await Promise.all([object?.__class.emitSync("Store.WebUpdate", evt), this.emitSync("Store.WebUpdate", evt)]);
-    }
-    /**
-     * Handle GET on object
-     *
-     * @param ctx context of the request
-     */
-    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 new WebdaError.NotFound("Object not found or is deleted");
-        }
-        await object.checkAct(ctx, "get");
-        ctx.write(object);
-        const evt = {
-            context: ctx,
-            object: object,
-            store: this
-        };
-        await Promise.all([this.emitSync("Store.WebGet", evt), object.__class.emitSync("Store.WebGet", evt)]);
-        ctx.write(object);
-    }
-    /**
-     * Handle HTTP request
-     *
-     * @param ctx context of the request
-     * @returns
-     */
-    async httpDelete(ctx) {
-        let uuid = ctx.parameter("uuid");
-        let object = await this.get(uuid, ctx);
-        if (!object || object.__deleted)
-            throw new WebdaError.NotFound("Object not found or is deleted");
-        await object.checkAct(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
-        // Might still run into: Have trouble to handle the Content-Length on API Gateway so returning an empty object for now
-        ctx.writeHead(204, { "Content-Length": "0" });
-        await this.delete(uuid);
-        const evt = {
-            context: ctx,
-            object_id: uuid,
-            store: this
-        };
-        await Promise.all([this.emitSync("Store.WebDelete", evt), object.__class.emitSync("Store.WebDelete", evt)]);
-    }
-    /**
-     * Return the model uuid field
-     */
-    getUuidField() {
-        return this._uuidField;
-    }
-    /**
-     * Check if an object exists
-     * @abstract
-     * @params {String} uuid of the object or the object
-     */
-    async exists(uid) {
-        if (typeof uid !== "string") {
-            uid = uid.getUuid();
-        }
-        return this._exists(uid);
+    checkKeys() {
+        // TODO Implement
     }
 }
-__decorate([
-    Route(".", ["POST"], {
-        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"], {
-        put: {
-            description: "Update a ${modelName} if the permissions allow",
-            summary: "Update a ${modelName}",
-            operationId: "update${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"], {
-        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"], {
-        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, "httpDelete", null);
 export { Store };
 //# sourceMappingURL=store.js.map