@azrico/webobject 1.5.58 → 1.5.61

package/dist/src/WebObjects/WebObject.js

@@ -0,0 +1,654 @@
+import { SimpleObject } from "../index";
+import { array_chunks, array_first, array_intersection, array_merge, array_remove_duplicates, fn_eval_this, object_clean, object_equals, object_getStatic, object_isEmpty, wrap_array, } from "@azrico/object";
+import { string_compress, string_decompress } from "@azrico/string";
+import { gcache, gfunc } from "@azrico/global";
+import FormatHelper from "@azrico/convert";
+import WebObjectPathHelper from "./WebObjectPathHelper";
+import WebObjectHelper from "./WebObjectHelper";
+export class WebObject extends SimpleObject {
+    static __web_path = "";
+    static __protectedProperties = ["_users"];
+    //you cant create a new weboject without these properties
+    static __requiredProperties = [];
+    meta_data;
+    //created date
+    _created_date;
+    //the owner of the object
+    _creator;
+    //multiple users can work on one object
+    _users;
+    constructor(is_readonly = false) {
+        super(is_readonly);
+        this.meta_data = {};
+    }
+    /**
+     * get a list of all user ids that work on the given object
+     * _creator + _users + attentions(old)
+     * removes duplicates
+     * @returns array of ids
+     */
+    getAllUsers() {
+        return WebObject.getAllUsers(this);
+    }
+    /**
+     * get a unique list of all user ids that work on the given object
+     * `_creator + _users + attentions`
+     * @returns array of ids
+     */
+    static getAllUsers(obj) {
+        if (typeof obj != "object")
+            return [];
+        return array_remove_duplicates(array_merge(obj._creator, wrap_array(obj._users), wrap_array(obj.attentions))
+            .map((r) => String(typeof r === "object" ? WebObject.getID(r) : r))
+            .filter((s) => s));
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                                  Meta data                                 */
+    /* -------------------------------------------------------------------------- */
+    /**
+     * Update meta value of this object , meta data is stored in meta_data variable
+     * @param key
+     * @param value
+     * @param sendChange
+     * @returns
+     */
+    async setMetaValue(key, value, sendChange = "auto") {
+        if (!this.canModify) {
+            if (this.__throw_errors !== false)
+                throw Error(`Cant use setMetaValue on ${key} when on readonly mode`);
+            else
+                return false;
+        }
+        if (!key || typeof key != "string") {
+            if (this.__throw_errors !== false)
+                throw Error(`Bad key at setMetaValue`);
+            else
+                return false;
+        }
+        const old_value = WebObject.getMetaValue(this, key);
+        if (object_equals(old_value, value))
+            return false; //same value, no changes
+        const new_metalist = { ...this.get("meta_data") };
+        new_metalist[key] = value;
+        await this.set("meta_data", new_metalist);
+        if (sendChange !== false)
+            await this.notifyChanged("meta", key, value);
+        return true;
+    }
+    /**
+     * Get meta value by key
+     * @param key
+     * @returns value or undefined
+     */
+    getMetaValue(key) {
+        return WebObject.getMetaValue(this, key);
+    }
+    /**
+     * Get meta value by key
+     * @param o
+     * @param key
+     * @returns value or undefined
+     */
+    static getMetaValue(o, key) {
+        if (o == null)
+            return null;
+        if (!key || typeof key != "string")
+            return undefined;
+        let metalist = {};
+        if (typeof o === "object") {
+            metalist =
+                typeof o.get === "function" ? o.get("meta_data") : o.meta_data;
+        }
+        return metalist[key];
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                                    Save                                    */
+    /* -------------------------------------------------------------------------- */
+    static zipSaveList(svlist) {
+        if (typeof svlist === "object")
+            svlist = JSON.stringify(svlist);
+        return string_compress(svlist);
+    }
+    static unzipSaveList(svlist) {
+        try {
+            if (typeof svlist === "object") {
+                if (Array.isArray(svlist))
+                    return svlist;
+                if (svlist.__save_list)
+                    return this.unzipSaveList(svlist.__save_list);
+            }
+            else if (typeof svlist === "string")
+                return wrap_array(JSON.parse(string_decompress(svlist)));
+        }
+        catch { }
+        return wrap_array(svlist);
+    }
+    static async saveList(itemList, extraOptions = {}) {
+        if (!extraOptions)
+            extraOptions = {};
+        const chunks = array_chunks(itemList, extraOptions.chunksize ?? 50);
+        delete extraOptions.chunksize;
+        const putAddress = this.get_webpath();
+        for (let index = 0; index < chunks.length; index++) {
+            const items_to_save = chunks[index];
+            const save_array = [];
+            for (let k = 0; k < items_to_save.length; k++) {
+                const item = items_to_save[k];
+                const dlt = await item.get_deltaObject();
+                save_array.push(item.isNew
+                    ? {
+                        ...dlt,
+                    }
+                    : {
+                        _id: item.getID(),
+                        ...dlt,
+                    });
+            }
+            const resultObject = await gfunc.run_action("post", putAddress, {
+                __save_list: WebObject.zipSaveList(save_array),
+                ...extraOptions,
+            });
+            if (Array.isArray(resultObject)) {
+                for (let index = 0; index < Math.min(resultObject.length, items_to_save.length); index++) {
+                    const res = resultObject[index];
+                    const item = items_to_save[index];
+                    item.setSaveResult(res);
+                    await item.onSave();
+                }
+            }
+        }
+        for (let index = 0; index < itemList.length; index++) {
+            const item = itemList[index];
+            if (!item.isSaved)
+                return false;
+            if (item.getSaveResultType() != "normal")
+                return false;
+        }
+        return true;
+    }
+    async Save() {
+        try {
+            if (this.manager) {
+                await this.manager.setOption("saving", true);
+                await this.manager.setOption("loading", true);
+            }
+            const deltaObject = await this.get_deltaObject();
+            const putAction = "post";
+            const usepath = await WebObjectPathHelper.get_path(this, this.isNew ? "new" : "save");
+            /* ---------------------------------- save ---------------------------------- */
+            if (!object_isEmpty(deltaObject)) {
+                const canSaveResult = this.canSave(deltaObject);
+                if (canSaveResult !== true) {
+                    WebObject.addError(this, "Save not allowed", String(canSaveResult), true);
+                    this.setSaveResult(false, "canceled");
+                    return false;
+                }
+                const resultObject = await gfunc.run_action(putAction, usepath, deltaObject);
+                this.setSaveResult(resultObject, "auto", true);
+            }
+            else {
+                /* nothing to save */
+                this.setSaveResult(null, "nothing");
+            }
+            if (this.isSaved) {
+                await this.onSave();
+                return this.getSaveResult();
+            }
+        }
+        finally {
+            if (this.manager) {
+                await this.manager.setOption("saving", false);
+                await this.manager.setOption("loading", false);
+            }
+        }
+    }
+    async Delete() {
+        if (this.isNew)
+            return;
+        const usepath = await WebObjectPathHelper.get_path(this, "delete");
+        const resultObject = await gfunc.run_action("delete", usepath);
+        this.setSaveResult(resultObject, "auto", true);
+        await this.onDelete();
+        return resultObject;
+    }
+    async Lock() {
+        if (this.isNew || this.isArchived)
+            return;
+        const usepath = await WebObjectPathHelper.get_path(this, "lock");
+        const resultObject = await gfunc.run_action("post", usepath);
+        this.setSaveResult(resultObject, "auto", true);
+        await this.onLock();
+        return resultObject;
+    }
+    async UnLock() {
+        if (this.isNew || this.isArchived)
+            return;
+        const usepath = await WebObjectPathHelper.get_path(this, "unlock");
+        const resultObject = await gfunc.run_action("post", usepath);
+        this.setSaveResult(resultObject, "auto", true);
+        await this.onUnLock();
+        return resultObject;
+    }
+    async Archive() {
+        if (this.isNew || this.isArchived)
+            return;
+        const usepath = await WebObjectPathHelper.get_path(this, "archive");
+        const resultObject = await gfunc.run_action("post", usepath);
+        this.setSaveResult(resultObject, "auto", true);
+        await this.onArchive();
+        return resultObject;
+    }
+    async UnArchive() {
+        if (this.isNew || !this.isArchived)
+            return;
+        const usepath = await WebObjectPathHelper.get_path(this, "unarchive");
+        const resultObject = await gfunc.run_action("post", usepath);
+        await this.onUnArchive();
+        return resultObject;
+    }
+    /* -------------------------------------------------------------------------- */
+    canSave(deltaObj) {
+        const deltaRes = this.deltaIsValid(deltaObj);
+        if (deltaRes !== true)
+            return deltaRes;
+        return true;
+    }
+    canDelete() {
+        return true;
+    }
+    canArchive() {
+        return true;
+    }
+    deltaIsValid(d) {
+        return true;
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                                  get delta                                 */
+    /* -------------------------------------------------------------------------- */
+    /**
+     * converts this object to an basic object
+     * that can be passed into client components from server components
+     *
+     * uses `get_fullDeltaObject`
+     * @param p
+     * @returns
+     */
+    async get_basicObject() {
+        const fullobject = await this.get_fullObject();
+        for (const key in fullobject) {
+            const element = fullobject[key];
+            /* --------------------------- check for id fields -------------------------- */
+            if (element != null && typeof element === "object") {
+                if ((key === "id" || key.endsWith("_id")) &&
+                    typeof element.toString === "function") {
+                    fullobject[key] = String(element);
+                }
+                else {
+                    fullobject[key] = JSON.parse(JSON.stringify(element));
+                }
+            }
+        }
+        return fullobject;
+    }
+    /**
+     * calls the `get_deltaObject` with
+     * `allProperties` `extraProperties`
+     * set to true
+     *
+     * @returns
+     */
+    async get_fullDeltaObject(p) {
+        return await this.get_deltaObject({
+            allProperties: true,
+            extraProperties: true,
+            ...p,
+        });
+    }
+    /**
+     * calls the `get_deltaObject` with
+     * `allProperties` `extraProperties` `tempProperties`
+     * set to true
+     *
+     * @returns
+     */
+    async get_fullObject(p) {
+        return await this.get_deltaObject({
+            allProperties: true,
+            extraProperties: true,
+            tempProperties: true,
+            ...p,
+        });
+    }
+    /**
+     * You will post this to the server for saving
+     * automatically removes unchangeable fields
+     * @returns
+     */
+    async get_deltaObject(p) {
+        if (!p)
+            p = {};
+        const final_object = {};
+        const useDelta = Boolean(this.__use_delta || p.useDelta);
+        /**
+         * child objects usually dont update their __delta
+         * so we read info from all of its properties
+         */
+        const changedFields = Boolean(p.allProperties || p.isChild || !useDelta)
+            ? { ...this.allproperties }
+            : { ...this.__delta };
+        /* ------------- parse children that have WebObject as delta ------------- */
+        for (const key in this) {
+            if (key.startsWith("__") || key in changedFields)
+                continue;
+            if (WebObjectHelper.isChangedWebObjectField(this[key])) {
+                /**
+                 * if a child has any change we must add it into our delta
+                 * notice that the changes may not be saved to database depending on __changeables
+                 * but they are changes nevertheless
+                 */
+                changedFields[key] = this[key];
+            }
+        }
+        /**
+         * get keys that can be changed.
+         * intersection of keys in delta and keys that are defined as changeable
+         */
+        let changeableKeys = array_intersection(Object.keys(changedFields), WebObject.getChangeableKeys(this, p));
+        /**
+         * if parameter of changeableKeys is given, limit our keys with that param
+         */
+        if (p.changeableKeys) {
+            changeableKeys = array_intersection(changeableKeys, p.changeableKeys);
+        }
+        /* -------------------------------------------------------------------------- */
+        FormatHelper.format({
+            original: this,
+            inputobject: changedFields,
+            formats: object_getStatic(this, "__formatList"),
+            isNew: this.isNew,
+            changeableKeys: changeableKeys,
+            applyDefaults: true,
+        });
+        /* -------------------------------------------------------------------------- */
+        /*                            __functionProperties                            */
+        /* -------------------------------------------------------------------------- */
+        const functionProps = object_getStatic(this, "__functionProperties");
+        for (let index = 0; index < functionProps.length; index++) {
+            const fp = functionProps[index];
+            if (changedFields[fp])
+                changedFields[fp] = fn_eval_this(this, changedFields[fp]);
+        }
+        /* -------------------------------------------------------------------------- */
+        /*                           parse all changeableKeys                          */
+        /* -------------------------------------------------------------------------- */
+        async function parseObj(key, obj) {
+            if (obj == null)
+                return undefined;
+            if (Array.isArray(obj))
+                return await Promise.all(obj.map(async (r, i) => await parseObj(key, r)));
+            if (obj instanceof WebObject &&
+                typeof obj.get_deltaObject === "function") {
+                /* -------------------- parse changeableKeys for children -------------------- */
+                const keydot = `${key}.`;
+                let child_changeableKeys = p?.changeableKeys
+                    ?.filter((s) => s.startsWith(keydot))
+                    .map((r) => r.substring(keydot.length));
+                /**
+                 * if no key is set for children consider it as undefined
+                 * if we send the empty array to get_delta we get no keys
+                 */
+                if (child_changeableKeys == null ||
+                    child_changeableKeys?.length === 0) {
+                    child_changeableKeys = undefined;
+                }
+                /* -------------------------------------------------------------------------- */
+                //child elements have different kind of delta
+                const newobj_dlt = await obj.get_deltaObject({
+                    ...p,
+                    isChild: true,
+                    changeableKeys: child_changeableKeys,
+                });
+                if (!object_isEmpty(newobj_dlt))
+                    return newobj_dlt;
+                else
+                    return obj;
+            }
+            return obj;
+        }
+        for (const key of changeableKeys) {
+            final_object[key] = await parseObj(key, changedFields[key]);
+        }
+        /* -------------------- add acrhived and date properties -------------------- */
+        if (p.allProperties) {
+            final_object["_created_date"] = this["_created_date"];
+            final_object["_archived"] = this.isArchived;
+            final_object["_deleted"] = this.isDeleted;
+        }
+        if (p.tempProperties) {
+            final_object["__temp"] = this.__temp;
+        }
+        /* ---------------------------- add id properties --------------------------- */
+        if (p.allProperties || p.needId || p.isChild) {
+            if (this["_index_key"])
+                final_object["_index_key"] = this["_index_key"];
+            const gotIndex = this.getIndex();
+            const gotId = this.getID();
+            if (gotIndex && gotIndex >= 0)
+                final_object["_index_value"] = gotIndex;
+            if (gotId)
+                final_object["_id"] = gotId;
+        }
+        /* -------------------------------------------------------------------------- */
+        /*                             fix _user property                             */
+        /* -------------------------------------------------------------------------- */
+        if (final_object["_users"]) {
+            let tempusers = final_object["_users"];
+            if (typeof tempusers === "string")
+                tempusers = tempusers.split(",").filter((s) => s);
+            final_object["_users"] = wrap_array(tempusers);
+        }
+        if (p.clean)
+            return object_clean(final_object, false, true);
+        return final_object;
+    }
+    /* --------------------------------- Getters -------------------------------- */
+    get manager() {
+        return this.get_managerClass() || undefined;
+    }
+    get __web_path() {
+        return this.constructor["__web_path"] || this.__db_name;
+    }
+    get_webpath() {
+        return this.__web_path || this.__db_name || "";
+    }
+    static get_webpath() {
+        return this.__web_path || this.__db_name || "";
+    }
+    static get_dbname() {
+        return this.__db_name || this.__web_path || "";
+    }
+    /* -------------------------------------------------------------------------- */
+    async onDelete(...p) {
+        if (this.isSaved)
+            this.isDeleted = true;
+        return await this.manager?.onDelete(...p); //events are handled by the manager
+    }
+    async onArchive(...p) {
+        if (this.isSaved)
+            this.isArchived = true;
+        return await this.manager?.onArchive(...p); //events are handled by the manager
+    }
+    async onUnArchive(...p) {
+        if (this.isSaved)
+            this.isArchived = false;
+        return await this.manager?.onUnArchive(...p); //events are handled by the manager
+    }
+    async onLock(...p) {
+        if (this.isSaved)
+            this.isLocked = true;
+        return await this.manager?.onLock(...p); //events are handled by the manager
+    }
+    async onUnLock(...p) {
+        if (this.isSaved)
+            this.isLocked = false;
+        return await this.manager?.onUnLock(...p); //events are handled by the manager
+    }
+    async onLoad(...p) {
+        this.isDeleted = false;
+        return await this.manager?.onLoad(...p); //events are handled by the manager
+    }
+    async onSave(...p) {
+        if (this.isSaved) {
+            this.apply_changes();
+            var srObject = this.getSaveResult(true);
+            if (this.saveResultHasID(srObject)) {
+                /* -------------------------------------------------------------------------- */
+                WebObject.LoadIdsFromSaveResult(this, srObject);
+                await this.manager?.event_run("on_id_change");
+            }
+        }
+        await this.manager?.onSave(...p); //events are handled by the manager
+        await this.onAfterSave();
+        return true;
+    }
+    async onAfterSave(...p) {
+        await this.manager?.onAfterSave(...p); //events are handled by the manager
+        return true;
+    }
+    getSaveResult(original = false) {
+        let srObject = super.getSaveResult(original);
+        if (!srObject)
+            return false;
+        if (Array.isArray(srObject)) {
+            const actual_sr = srObject.find((s) => this.saveResultHasID(s));
+            if (actual_sr)
+                srObject = actual_sr;
+        }
+        return srObject;
+    }
+    async onNew(...p) {
+        return await this.manager?.onNew(...p); //events are handled by the manager
+    }
+    /* -------------------------------------------------------------------------- */
+    saveResultHasID(s) {
+        return WebObject.saveResultHasID(s);
+    }
+    static saveResultHasID(s) {
+        if (typeof s !== "object" || s == null || !s)
+            return false;
+        return (s.insertedId ||
+            s._id ||
+            (s._index_value && !Number.isNaN(s._index_value)));
+    }
+    /**
+     * Load Id and _index_value from the given save result into our object
+     * @param o
+     * @param srObject
+     * @returns
+     */
+    static LoadIdsFromSaveResult(o, srObject) {
+        if (typeof o !== "object" || typeof srObject !== "object")
+            return;
+        /* -------------------------------------------------------------------------- */
+        const srID = srObject.insertedId || srObject._id || WebObject.getID(srObject);
+        if (srID) {
+            o._id = srID;
+        }
+        /* -------------------------------------------------------------------------- */
+        if (srObject._index_value && !Number.isNaN(srObject._index_value)) {
+            o._index_value = Number(srObject._index_value);
+        }
+        /* -------------------------------------------------------------------------- */
+        if (srObject._index_key) {
+            o._index_key = srObject._index_key;
+        }
+    }
+    /* -------------------------------------------------------------------------- */
+    /**
+     * get a single web object
+     * default order of parameters : search,readonly,fetchID
+     */
+    static async get_single(...p) {
+        let search = p.shift();
+        let readonly = p.shift() ?? false;
+        let fetchID = p.shift();
+        if (object_isEmpty(search))
+            return undefined;
+        let result;
+        const params = {};
+        params.__context = readonly ? "view" : "edit";
+        switch (typeof search) {
+            case "string":
+            case "number":
+                search = String(search);
+                // const usepath =
+                //     (await WebObjectPathHelper.get_path(this, "get")) +
+                //     "/" +
+                //     search;
+                // res = await gfunc.run_action("get", usepath, params, {
+                //     fetchID: fetchID,
+                // });
+                result = await this.get_list({ __searchid: search }, readonly, fetchID);
+                break;
+            case "object":
+            default:
+                result = await this.get_list(search, readonly, fetchID);
+                break;
+        }
+        if (result)
+            result = array_first(result);
+        if (!object_isEmpty(result)) {
+            result = this.ensure(this, result);
+            WebObject.setReadonly(result, readonly);
+        }
+        return result;
+    }
+    /**
+     * Get a list of web objects
+     * default order of parameters : search,readonly,fetchID
+     */
+    static async get_list(...p) {
+        let search = p.shift();
+        let readonly = p.shift() ?? false;
+        let fetchID = p.shift();
+        if (!search)
+            search = {};
+        const usepath = await WebObjectPathHelper.get_path(this, "get");
+        let result_items = await gfunc.run_action("get", usepath, search, { fetchID: fetchID });
+        // const selftype = (this.constructor ||
+        //     Object.getPrototypeOf(this)) as any;
+        const res = WebObject.map_rowindex(WebObject.mapto(this, result_items, readonly));
+        WebObject.setReadonly(res, readonly);
+        return res;
+    }
+    /**
+     * uses `get_list` and then saves the result to `gcache`
+     * then uses the `equals` function to return matched results
+     * @param search
+     * @returns
+     */
+    static async get_list_cache(search) {
+        const all_data = await gcache.get_temp_cache(this.get_webpath(), async () => await this.get_list());
+        if (!search)
+            return all_data;
+        return all_data.filter((s) => this.equals(s, search));
+    }
+    /**
+     * uses `get_list_cache` then the `equals` function to return matched result
+     * @param search
+     * @returns
+     */
+    static async get_single_cache(search) {
+        return (await this.get_list_cache()).find((s) => this.equals(s, search));
+    }
+    /**
+     * Get a list of web objects and convert them to basic objects
+     * can be passed to client components
+     * default order of parameters : search,readonly,fetchID
+     */
+    static async get_basicList(...p) {
+        const itemlist = await this.get_list(...p);
+        return await Promise.all(itemlist.map(async (r) => await r.get_basicObject()));
+    }
+}
+export default WebObject;

package/dist/src/WebObjects/WebObjectHelper.d.ts

@@ -0,0 +1,9 @@
+import WebObject from "./WebObject";
+export declare class WebObjectHelper {
+    /**
+     * check if the given WebObject is changed or given WebObject array has any changed element
+     * @param obj
+     */
+    static isChangedWebObjectField(obj: WebObject | WebObject[] | any): boolean;
+}
+export default WebObjectHelper;

package/dist/src/WebObjects/WebObjectHelper.js

@@ -0,0 +1,18 @@
+import WebObject from "./WebObject";
+export class WebObjectHelper {
+    /**
+     * check if the given WebObject is changed or given WebObject array has any changed element
+     * @param obj
+     */
+    static isChangedWebObjectField(obj) {
+        if (typeof obj !== "object")
+            return false;
+        if (Array.isArray(obj)) {
+            const arrCheck = obj;
+            return (arrCheck.find((r) => r instanceof WebObject && r.isChanged) !=
+                undefined);
+        }
+        return obj instanceof WebObject && obj.isChanged;
+    }
+}
+export default WebObjectHelper;

package/dist/src/WebObjects/WebObjectHelper.test.d.ts

@@ -0,0 +1 @@
+export {};