@webda/core 2.4.2 → 3.0.1

package/lib/models/coremodel.js

@@ -7,18 +7,98 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import util from "util";
 import { v4 as uuidv4 } from "uuid";
 import { Core } from "../core.js";
-import { Context } from "../utils/context.js";
+import { WebdaError } from "../errors.js";
+import { BinariesImpl, Binary } from "../services/binary.js";
+import { Throttler } from "../utils/throttler.js";
+import { createModelLinksMap, ModelLinksArray, ModelLinksSimpleArray, ModelMapLoaderImplementation } from "./relations.js";
 /**
- * Sent if action required attached CoreModel is trigger
- * A Model cannot be detached anymore
+ * Expose the model through API or GraphQL if it exists
+ * The model will be exposed using its class name + 's'
+ * If you need to have a specific plural, use the annotation WebdaPlural
+ *  to define the plural name
  *
- * @deprecated
+ * @returns
  */
-export class CoreModelUnattachedError extends Error {
-    constructor() {
-        super("No store linked to this object");
+export function Expose(params = {}) {
+    return function (target) {
+        params.restrict ?? (params.restrict = {});
+        target.Expose = params;
+    };
+}
+/**
+ *
+ */
+class CoreModelQuery {
+    constructor(type, model, attribute) {
+        this.attribute = attribute;
+        this.type = type;
+        this.model = model;
+    }
+    /**
+     * Retrieve target model definition
+     * @returns
+     */
+    getTargetModel() {
+        this.targetModel ?? (this.targetModel = Core.get().getModel(this.type));
+        return this.targetModel;
+    }
+    /**
+     * Query the object
+     * @param query
+     * @returns
+     */
+    query(query, context) {
+        return this.getTargetModel().query(this.completeQuery(query), true, context);
+    }
+    /**
+     * Complete the query with condition
+     * @param query
+     * @returns
+     */
+    completeQuery(query) {
+        query = query ? `(${query}) AND` : "";
+        query += ` ${this.attribute} = '${this.model.getUuid()}'`;
+        return query;
+    }
+    /**
+     *
+     * @param callback
+     * @param context
+     */
+    async forEach(callback, query, context, parallelism = 3) {
+        const throttler = new Throttler();
+        throttler.setConcurrency(parallelism);
+        let continuationToken;
+        do {
+            const result = await this.query(query + continuationToken ? "OFFSET " + continuationToken : "", context);
+            continuationToken = result.continuationToken;
+            for (const model of result.results) {
+                throttler.queue(() => callback(model));
+            }
+            await throttler.waitForCompletion();
+        } while (continuationToken);
+    }
+    /**
+     * Get all objects linked
+     * @param context
+     * @returns
+     */
+    async getAll(query, context) {
+        return Core.get().getModelStore(this.getTargetModel()).queryAll(this.completeQuery(query), context);
     }
 }
+__decorate([
+    NotEnumerable
+], CoreModelQuery.prototype, "type", void 0);
+__decorate([
+    NotEnumerable
+], CoreModelQuery.prototype, "model", void 0);
+__decorate([
+    NotEnumerable
+], CoreModelQuery.prototype, "attribute", void 0);
+__decorate([
+    NotEnumerable
+], CoreModelQuery.prototype, "targetModel", void 0);
 /**
  * Make a property hidden from json
  * @param target
@@ -59,6 +139,103 @@ export function Action(options = {}) {
         };
     };
 }
+export class ModelRef {
+    constructor(uuid, model) {
+        this.uuid = uuid;
+        this.model = model;
+        this.uuid = uuid === "" ? undefined : model.completeUid(uuid);
+        this.store = Core.get().getModelStore(model);
+    }
+    async get() {
+        return this.store.get(this.uuid);
+    }
+    set(id) {
+        this.uuid = id instanceof CoreModel ? id.getUuid() : id;
+    }
+    toString() {
+        return this.uuid;
+    }
+    toJSON() {
+        return this.uuid;
+    }
+    getUuid() {
+        return this.uuid;
+    }
+    deleteItemFromCollection(prop, index, itemWriteCondition, itemWriteConditionField) {
+        return this.store.deleteItemFromCollection(this.uuid, prop, index, itemWriteCondition, itemWriteConditionField);
+    }
+    upsertItemToCollection(prop, item, index, itemWriteCondition, itemWriteConditionField) {
+        return this.store.upsertItemToCollection(this.uuid, prop, item, index, itemWriteCondition, itemWriteConditionField);
+    }
+    exists() {
+        return this.store.exists(this.uuid);
+    }
+    delete() {
+        return this.store.delete(this.uuid);
+    }
+    conditionalPatch(updates, conditionField, condition) {
+        return this.store.conditionalPatch(this.uuid, updates, conditionField, condition);
+    }
+    patch(updates) {
+        return this.store.conditionalPatch(this.uuid, updates, null, undefined);
+    }
+    setAttribute(attribute, value) {
+        return this.store.setAttribute(this.uuid, attribute, value);
+    }
+    removeAttribute(attribute, itemWriteCondition, itemWriteConditionField) {
+        return this.store.removeAttribute(this.uuid, attribute, itemWriteCondition, itemWriteConditionField);
+    }
+    incrementAttributes(info) {
+        return this.store.incrementAttributes(this.uuid, info);
+    }
+}
+__decorate([
+    NotEnumerable
+], ModelRef.prototype, "store", void 0);
+__decorate([
+    NotEnumerable
+], ModelRef.prototype, "model", void 0);
+export class ModelRefWithCreate extends ModelRef {
+    /**
+     * Allow to create a model
+     * @param defaultValue
+     * @param context
+     * @param withSave
+     * @returns
+     */
+    async create(defaultValue, context, withSave = true) {
+        let result = new this.model().setContext(context).load(defaultValue, true).setUuid(this.uuid);
+        if (withSave) {
+            await result.save();
+        }
+        return result;
+    }
+    /**
+     * Load a model from the known store
+     *
+     * @param this the class from which the static is called
+     * @param id of the object to load
+     * @param defaultValue if object not found return a default object
+     * @param context to set on the object
+     * @returns
+     */
+    async getOrCreate(defaultValue, context, withSave = true) {
+        return (await this.get()) || this.create(defaultValue, context, withSave);
+    }
+}
+export class ModelRefCustom extends ModelRef {
+    constructor(uuid, model, data) {
+        super(uuid, model);
+        this.uuid = uuid;
+        Object.assign(this, data);
+    }
+    toJSON() {
+        return this;
+    }
+    getUuid() {
+        return this.uuid;
+    }
+}
 /**
  * Basic Object in Webda
  *
@@ -74,7 +251,18 @@ class CoreModel {
         this.__dirty = new Set();
         this.__class = new.target;
         // Get the store automatically now
-        this.__store = Core.get()?.getModelStore(this);
+        this.__store = Core.get()?.getModelStore(new.target);
+        // Get the type automatically now
+        this.__type = process.env.WEBDA_V2_COMPATIBLE
+            ? Core.get()?.getApplication().getModelFromInstance(this)
+            : Core.get()?.getApplication().getShortId(Core.get()?.getApplication().getModelFromInstance(this));
+    }
+    /**
+     *
+     * @returns
+     */
+    static getRelations() {
+        return Core.get()?.getApplication().getRelations(this);
     }
     /**
      * Get Store for this model
@@ -88,16 +276,72 @@ class CoreModel {
         return Core.get().getModelStore(this);
     }
     /**
-     * Create subobject for a model
+     * Complete the uid with prefix if any
      *
-     * Useful for counters
+     * Useful when object are stored with a prefix for full uuid
+     * @param uid
+     * @returns
+     */
+    static completeUid(uid) {
+        return uid;
+    }
+    /**
+     * Return the known schema
+     * @returns
+     */
+    static getSchema() {
+        const app = Core.get()?.getApplication();
+        return app?.getSchema(app.getModelFromConstructor(this));
+    }
+    /**
+     * Get a reference to a model
+     * @param this
+     * @param uid
+     * @returns
+     */
+    static ref(uid) {
+        return new ModelRefWithCreate(uid, this);
+    }
+    /**
+     * Get a reference to a model
+     * @param this
+     * @param uid
+     * @returns
+     */
+    static create(data) {
+        return new this().load(data, true).save();
+    }
+    /**
+     * Get identifier for this model
+     * @returns
+     */
+    static getIdentifier(short = true) {
+        const res = Core.get().getApplication().getModelName(this);
+        if (short) {
+            return Core.get().getApplication().getShortId(res);
+        }
+        else {
+            return res;
+        }
+    }
+    /**
+     * Get the model hierarchy
      *
+     * Ancestors will contain every model it inherits from
+     * Children will contain every model that inherits from this model in a tree structure
+     */
+    static getHierarchy() {
+        return Core.get().getApplication().getModelHierarchy(this);
+    }
+    /**
+     * Unflat an object
+     * @param data
      * @param split
      * @returns
      */
-    unflat(split = "#") {
+    static unflat(data, split = "#") {
         const res = {};
-        for (let i in this) {
+        for (let i in data) {
             const attrs = i.split(split);
             let attr = attrs.shift();
             let cur = res;
@@ -107,22 +351,78 @@ class CoreModel {
                     cur = cur[attr];
                 }
                 else {
-                    cur[attr] = this[i];
+                    cur[attr] = data[i];
                 }
                 attr = attrs.shift();
             }
         }
         return res;
     }
+    /**
+     * Create subobject for a model
+     *
+     * Useful for counters
+     *
+     * @param split
+     * @returns
+     */
+    unflat(split = "#") {
+        return CoreModel.unflat(this, split);
+    }
+    /**
+     * Flat an object into another
+     *
+     * {
+     *    a: {
+     *      b: 1
+     *    },
+     *    c: 1
+     * }
+     *
+     * become
+     *
+     * {
+     *    "a#b": 1
+     *    "c": 1
+     * }
+     *
+     * @param target
+     * @param data
+     * @param split
+     * @param prefix
+     */
+    static flat(target, data, split = "#", prefix = "") {
+        for (let i in data) {
+            if (typeof data[i] === "object") {
+                CoreModel.flat(target, data[i], split, i + split);
+            }
+            else {
+                target[prefix + i] = data[i];
+            }
+        }
+    }
     /**
      * Query for models
      * @param this
      * @param id
      * @returns
      */
-    static async query(query) {
+    static async query(query = "", includeSubclass = true, context) {
+        if (!query.includes("__type")) {
+            if (query.trim() !== "") {
+                query = ` AND ${query}`;
+            }
+            const app = Core.get().getApplication();
+            const name = app.getShortId(app.getModelName(this));
+            if (includeSubclass) {
+                query = `__types CONTAINS "${name}"${query}`;
+            }
+            else {
+                query = `__type = "${name}"${query}`;
+            }
+        }
         // @ts-ignore
-        return this.store().query(query);
+        return this.store().query(query, context);
     }
     /**
      * Return a proxy to the object to detect if dirty
@@ -137,7 +437,7 @@ class CoreModel {
                     return true;
                 },
                 get: (target, p) => {
-                    if (Array.isArray(target[p]) || (target[p] instanceof Object && target[p].prototype == Object.prototype)) {
+                    if (Array.isArray(target[p]) || target[p] instanceof Object) {
                         return new Proxy(target[p], subProxier(prop));
                     }
                     return target[p];
@@ -166,8 +466,7 @@ class CoreModel {
                 if (typeof p === "string" && p.startsWith("__")) {
                     return target[p];
                 }
-                if (Array.isArray(target[p]) ||
-                    (typeof target[p] === "object" && target[p].constructor.prototype === Object.prototype)) {
+                if (Array.isArray(target[p]) || target[p] instanceof Object) {
                     return new Proxy(target[p], subProxier(p));
                 }
                 return target[p];
@@ -226,12 +525,18 @@ class CoreModel {
     static getPermissionQuery(_ctx) {
         return null;
     }
+    async checkAct(context, action) {
+        let msg = await this.canAct(context, action);
+        if (msg !== true) {
+            throw new WebdaError.Forbidden(msg === false ? "No permission" : msg);
+        }
+    }
     /**
      * By default nothing is permitted on a CoreModel
      * @returns
      */
-    async canAct(_ctx, _action) {
-        throw 403;
+    async canAct(_context, _action) {
+        return "This model does not support any action: override checkAct";
     }
     /**
      * Get the UUID property
@@ -239,18 +544,6 @@ class CoreModel {
     static getUuidField() {
         return "uuid";
     }
-    /**
-     * Get the UUID property
-     */
-    static getLastUpdateField() {
-        return "_lastUpdate";
-    }
-    /**
-     * Get the UUID property
-     */
-    static getCreationField() {
-        return "_creationDate";
-    }
     /**
      * Create an object
      * @returns
@@ -266,21 +559,6 @@ class CoreModel {
     static instanceOf(object) {
         return (typeof object.toStoredJSON === "function" && object.__class && object.__class.factory && object.__class.instanceOf);
     }
-    /**
-     * Return if an object is attached to its store
-     * @deprecated Will be removed in 3.0
-     */
-    isAttached() {
-        return this.__store !== undefined;
-    }
-    /**
-     * Attach an object to a store instance
-     * @deprecated Will be removed in 3.0
-     */
-    attach(store) {
-        this.__store = store;
-        return this;
-    }
     /**
      * Return a unique reference within the application to the object
      *
@@ -288,10 +566,7 @@ class CoreModel {
      * @returns
      */
     getFullUuid() {
-        if (!this.isAttached()) {
-            throw new Error("Cannot return full uuid of unattached object");
-        }
-        return `${this.__store.getName()}$${this.getUuid()}`;
+        return `${this.__type.replace(/\//, "-")}$${this.getUuid()}`;
     }
     /**
      * Get an object from the full uuid
@@ -300,27 +575,13 @@ class CoreModel {
      * @param partials
      * @returns
      */
-    static async fromFullUuid(core, fullUuid, partials) {
-        const [store, uuid] = fullUuid.split("$");
-        let service = core.getService(store);
+    static async fromFullUuid(fullUuid, core = Core.get(), partials) {
+        const [model, uuid] = fullUuid.split("$");
+        let modelObject = core.getApplication().getModel(model.replace("-", "/"));
         if (partials) {
-            return service.newModel(partials).setUuid(uuid);
-        }
-        return service.get(uuid);
-    }
-    /**
-     * Remove all the attribute starting with __
-     * @param key
-     * @param value
-     * @returns
-     *
-     * @deprecated
-     */
-    _jsonFilter(key, value) {
-        if (key[0] === "_" && key.length > 1 && key[1] === "_") {
-            return undefined;
+            return new modelObject().load(partials, true).setUuid(uuid);
         }
-        return value;
+        return new modelObject().setUuid(uuid).get();
     }
     /**
      * Allow to define custom permission per attribute
@@ -339,8 +600,7 @@ class CoreModel {
             return key.startsWith("_") ? undefined : value;
         }
         else {
-            // Will be replaced by this !key.startsWith("__") in 3.0.0
-            return this._jsonFilter(key, value);
+            return !key.startsWith("__") ? value : undefined;
         }
     }
     /**
@@ -359,6 +619,7 @@ class CoreModel {
                     continue;
                 }
             }
+            // @ts-ignore
             this[prop] = val;
         }
         if (this._creationDate) {
@@ -370,8 +631,57 @@ class CoreModel {
         if (!this.getUuid()) {
             this.setUuid(this.generateUid(raw));
         }
+        this.handleRelations();
         return this;
     }
+    /**
+     * Patch every attribute that is based on a relation
+     * to add all the helpers
+     */
+    handleRelations() {
+        var _a, _b;
+        const rel = Core.get()
+            ?.getApplication()
+            ?.getRelations(this) || {};
+        for (let link of rel.links || []) {
+            const model = Core.get().getModel(link.model);
+            if (link.type === "LINK") {
+                this[_a = link.attribute] ?? (this[_a] = "");
+                if (typeof this[link.attribute] === "string") {
+                    this[link.attribute] = new ModelRef(this[link.attribute], model);
+                }
+            }
+            else if (link.type === "LINKS_ARRAY") {
+                this[link.attribute] = new ModelLinksArray(model, this[link.attribute]);
+            }
+            else if (link.type === "LINKS_SIMPLE_ARRAY") {
+                this[link.attribute] = new ModelLinksSimpleArray(model, this[link.attribute]);
+            }
+            else if (link.type === "LINKS_MAP") {
+                this[link.attribute] = createModelLinksMap(model, this[link.attribute]);
+            }
+        }
+        for (let link of rel.maps || []) {
+            this[link.attribute] = (this[link.attribute] || []).map(el => new ModelMapLoaderImplementation(Core.get().getModel(link.model), el));
+        }
+        for (let query of rel.queries || []) {
+            this[query.attribute] = new CoreModelQuery(query.model, this, query.targetAttribute);
+        }
+        if (rel.parent) {
+            this[_b = rel.parent.attribute] ?? (this[_b] = "");
+            if (typeof this[rel.parent.attribute] === "string") {
+                this[rel.parent.attribute] = new ModelRef(this[rel.parent.attribute], Core.get().getModel(rel.parent.model));
+            }
+        }
+        for (let binary of rel.binaries || []) {
+            if (binary.cardinality === "ONE") {
+                this[binary.attribute] = new Binary(binary.attribute, this);
+            }
+            else {
+                this[binary.attribute] = new BinariesImpl().assign(this, binary.attribute);
+            }
+        }
+    }
     /**
      * Context of the request
      */
@@ -385,7 +695,7 @@ class CoreModel {
      * Global object does not belong to a request
      */
     getContext() {
-        return this.__ctx || Context.getGlobalContext();
+        return this.__ctx || Core.get().getGlobalContext();
     }
     /**
      * Return the object registered store
@@ -406,9 +716,6 @@ class CoreModel {
      * @throws Error if the object is not coming from a store
      */
     async refresh() {
-        if (!this.__store) {
-            throw new CoreModelUnattachedError();
-        }
         let obj = await this.__store.get(this.getUuid());
         if (obj) {
             Object.assign(this, obj);
@@ -418,6 +725,7 @@ class CoreModel {
                     delete this[i];
                 }
             }
+            this.handleRelations();
         }
         return this;
     }
@@ -427,24 +735,8 @@ class CoreModel {
      * @throws Error if the object is not coming from a store
      */
     async delete() {
-        if (!this.__store) {
-            throw new CoreModelUnattachedError();
-        }
         return this.__store.delete(this.getUuid());
     }
-    /**
-     * Load a model from the known store
-     *
-     * @param this the class from which the static is called
-     * @param id of the object to load
-     * @param defaultValue if object not found return a default object
-     * @param context to set on the object
-     * @returns
-     */
-    static async get(id, defaultValue, context) {
-        // @ts-ignore
-        return this.store(this).get(id, context, defaultValue);
-    }
     /**
      * Patch current object with this update
      * @param obj
@@ -452,9 +744,6 @@ class CoreModel {
      * @param conditionValue
      */
     async patch(obj, conditionField, conditionValue) {
-        if (!this.__store) {
-            throw new CoreModelUnattachedError();
-        }
         await this.__store.patch({ [this.__class.getUuidField()]: this.getUuid(), ...obj }, true, conditionField, conditionValue);
         Object.assign(this, obj);
     }
@@ -464,9 +753,6 @@ class CoreModel {
      * @throws Error if the object is not coming from a store
      */
     async save(full, ...args) {
-        if (!this.__store) {
-            throw new CoreModelUnattachedError();
-        }
         // If proxy is not used and not field specified call save
         if ((!util.types.isProxy(this) && full === undefined) || full === true) {
             if (!this._creationDate || !this._lastUpdate) {
@@ -533,9 +819,6 @@ class CoreModel {
      * WARNING: Only object attached to a store can retrieve service
      */
     getService(service) {
-        if (!this.__store) {
-            throw new CoreModelUnattachedError();
-        }
         return this.__store.getService(service);
     }
     /**
@@ -555,7 +838,12 @@ class CoreModel {
             }
             if (value === undefined)
                 continue;
-            obj[i] = value;
+            if (value instanceof ModelRef) {
+                obj[i] = value.toString();
+            }
+            else {
+                obj[i] = value;
+            }
         }
         return obj;
     }
@@ -624,5 +912,17 @@ __decorate([
 __decorate([
     NotEnumerable
 ], CoreModel.prototype, "__dirty", void 0);
-export { CoreModel };
+/**
+ * CoreModel with a uuid
+ */
+class UuidModel extends CoreModel {
+    /**
+     * @override
+     */
+    validate(ctx, updates, ignoreRequired) {
+        updates.uuid ?? (updates.uuid = this.generateUid());
+        return super.validate(ctx, updates, ignoreRequired);
+    }
+}
+export { CoreModel, UuidModel };
 //# sourceMappingURL=coremodel.js.map