@warlock.js/cascade 1.0.0

package/cjs/model/model.js

@@ -0,0 +1,843 @@
+'use strict';var reinforcements=require('@mongez/reinforcements'),supportiveIs=require('@mongez/supportive-is'),timeWizard=require('@mongez/time-wizard'),dayjs=require('dayjs'),mongodb=require('mongodb');require('../casts/arrayOf.js');var castModel=require('../casts/castModel.js'),oneOf=require('../casts/oneOf.js');require('../casts/shapedArray.js');var relationships=require('./relationships.js'),types=require('./types.js');function _interopDefault(e){return e&&e.__esModule?e:{default:e}}var dayjs__default=/*#__PURE__*/_interopDefault(dayjs);class Model
+// <
+//   ModelDocument extends Document = any,
+//   ModelSchema extends Schema<ModelDocument> = any,
+// >
+ extends relationships.RelationshipModel {
+    /**
+     * Model Initial Document data
+     */
+    initialData = {};
+    /**
+     * Model Document data
+     */
+    data;
+    /**
+     * Define Default value data that will be merged with the models' data
+     * on the create process
+     */
+    defaultValue = {};
+    /**
+     * A flag to determine if the model is being restored
+     */
+    isRestored = false;
+    /**
+     * Model casts types
+     */
+    casts = {};
+    /**
+     * Set custom casts that will be used to cast the model's data are not related to the current value of the collection's column
+     *
+     * For example: `name` is not a column in the given data, but it will be concatenation of `firstName` and `lastName`
+     */
+    customCasts = {};
+    /**
+     * Guarded fields
+     */
+    guarded = [];
+    /**
+     * Fillable fields
+     */
+    filled = [];
+    /**
+     * Embedded columns
+     */
+    embedded = [];
+    /**
+     * Embed all columns except the given columns
+     */
+    embedAllExcept = [];
+    /**
+     * Embed all columns except timestamps and created|updated|deleted by columns
+     */
+    embedAllExceptTimestampsAndUserColumns = false;
+    /**
+     * Created at column
+     */
+    createdAtColumn = "createdAt";
+    /**
+     * Updated at column
+     */
+    updatedAtColumn = "updatedAt";
+    /**
+     * Deleted at column
+     */
+    deletedAtColumn = "deletedAt";
+    /**
+     * Created by column
+     */
+    createdByColumn = "createdBy";
+    /**
+     * Updated by column
+     */
+    updatedByColumn = "updatedBy";
+    /**
+     * Deleted by column
+     */
+    deletedByColumn = "deletedBy";
+    /**
+     * Date format
+     */
+    dateFormat = "DD-MM-YYYY";
+    /**
+     * A flag to determine if the id is auto generated not added manually
+     */
+    autoGeneratedId = false;
+    /**
+     * Is active column
+     */
+    isActiveColumn = "isActive";
+    /**
+     * Original data
+     */
+    originalData = {};
+    /**
+     * Constructor
+     */
+    constructor(originalData = {}) {
+        super();
+        if (originalData instanceof Model) {
+            this.originalData = reinforcements.clone(originalData.data);
+        }
+        else {
+            this.originalData = reinforcements.clone(originalData);
+        }
+        if (typeof originalData?._id === "string") {
+            try {
+                originalData._id = new mongodb.ObjectId(originalData._id);
+            }
+            catch (error) {
+                originalData._id = new mongodb.ObjectId();
+            }
+        }
+        this.data = reinforcements.clone(this.originalData);
+        this.initialData = reinforcements.clone(this.originalData);
+        // this is necessary as clone() will generate a new _id for the data
+        // so we need to keep the original _id
+        if (originalData?._id) {
+            this.originalData._id = new mongodb.ObjectId(originalData._id);
+            this.data._id = new mongodb.ObjectId(originalData._id);
+            this.initialData._id = new mongodb.ObjectId(originalData._id);
+        }
+    }
+    /**
+     * Get save columns which are the casts keys
+     */
+    get castColumns() {
+        return Object.keys(this.casts);
+    }
+    /**
+     * Get value from original data
+     */
+    original(key, defaultValue) {
+        return reinforcements.get(this.originalData, key, defaultValue);
+    }
+    /**
+     * Get all data except the guarded fields
+     */
+    get publicData() {
+        return reinforcements.except(this.data, this.guarded);
+    }
+    /**
+     * Get guarded data
+     */
+    get guardedData() {
+        return reinforcements.only(this.data, this.guarded);
+    }
+    /**
+     * Get the model's id
+     */
+    get id() {
+        return this.get("id");
+    }
+    /**
+     * Check if current user is active
+     */
+    get isActive() {
+        return Boolean(this.get(this.isActiveColumn));
+    }
+    /**
+     * Get mongodb id
+     */
+    get _id() {
+        return this.get("_id");
+    }
+    /**
+     * Mark the current model as being restored
+     */
+    markAsRestored() {
+        this.isRestored = true;
+    }
+    /**
+     * Set a column in the model data
+     */
+    set(column, value) {
+        this.data = reinforcements.set(this.data, column, value);
+        return this;
+    }
+    /**
+     * Increment the given column by the given value
+     */
+    increment(column, value = 1) {
+        return this.set(column, this.get(column, 0) + value);
+    }
+    /**
+     * Decrement the given column by the given value
+     */
+    decrement(column, value = 1) {
+        return this.set(column, this.get(column, 0) - value);
+    }
+    /**
+     * Get initial value of the given column
+     */
+    getInitial(column, defaultValue) {
+        return reinforcements.get(this.initialData, column, defaultValue);
+    }
+    /**
+     * Get value of the given column
+     */
+    get(column, defaultValue) {
+        return reinforcements.get(this.data, column, defaultValue);
+    }
+    /**
+     * Return the value of the given column as a string
+     */
+    string(column, defaultValue) {
+        return String(this.get(column, defaultValue));
+    }
+    /**
+     * Return the value of the given column as an integer
+     */
+    int(column, defaultValue) {
+        return parseInt(this.get(column, defaultValue));
+    }
+    /**
+     * Return the value of the given column as a float
+     */
+    float(column, defaultValue) {
+        return parseFloat(this.get(column, defaultValue));
+    }
+    /**
+     * Return the value of the given column as a number
+     */
+    number(column, defaultValue) {
+        return Number(this.get(column, defaultValue));
+    }
+    /**
+     * Return the value of the given column as a boolean
+     */
+    bool(column, defaultValue) {
+        return Boolean(this.get(column, defaultValue));
+    }
+    /**
+     * Determine whether the given column exists in the document
+     */
+    has(column) {
+        return reinforcements.get(this.data, column) !== undefined;
+    }
+    /**
+     * Get all columns except the given ones
+     */
+    except(columns) {
+        return reinforcements.except(this.data, columns);
+    }
+    /**
+     * Get only the given columns
+     */
+    only(columns) {
+        return reinforcements.only(this.data, columns);
+    }
+    /**
+     * Get only id
+     */
+    get onlyId() {
+        return this.only(["id"]);
+    }
+    /**
+     * Unset or remove the given columns from the data
+     */
+    unset(...columns) {
+        this.data = reinforcements.except(this.data, columns);
+        return this;
+    }
+    /**
+     * Replace the entire document data with the given new data
+     */
+    replaceWith(data) {
+        if (!data.id && this.data.id) {
+            data.id = this.data.id;
+        }
+        if (!data._id && this.data._id) {
+            data._id = this.data._id;
+        }
+        this.data = data;
+        return this;
+    }
+    /**
+     * Merge the given documents to current document
+     */
+    merge(data) {
+        this.data = reinforcements.merge(this.data, data);
+        return this;
+    }
+    /**
+     * Push the given values to the given column
+     * If the given column does not exists, it will be created
+     * If the given value exists but not an array it will be ignored
+     */
+    push(column, ...values) {
+        const currentValue = this.get(column);
+        if (Array.isArray(currentValue)) {
+            this.set(column, [...currentValue, ...values]);
+        }
+        else if (!currentValue) {
+            this.set(column, values);
+        }
+        return this;
+    }
+    /**
+     * Push the given values to the given column only if not exists
+     */
+    pushOnce(column, ...values) {
+        const currentValue = this.get(column);
+        if (Array.isArray(currentValue)) {
+            const newValues = Array.from(new Set([...currentValue, ...values]));
+            this.set(column, newValues);
+        }
+        else if (!currentValue) {
+            this.set(column, values);
+        }
+        return this;
+    }
+    /**
+     * Add the given values to the beginning of the given column
+     * If the given column does not exists, it will be created
+     * If the given value exists but not an array it will be ignored
+     */
+    unshift(column, ...values) {
+        const currentValue = this.get(column);
+        if (Array.isArray(currentValue)) {
+            this.set(column, [...values, ...currentValue]);
+        }
+        else if (!currentValue) {
+            this.set(column, values);
+        }
+        return this;
+    }
+    /**
+     * Add the given values to the beginning of the given column only if not exists
+     */
+    unshiftOnce(column, ...values) {
+        const currentValue = this.get(column);
+        if (Array.isArray(currentValue)) {
+            const newValues = Array.from(new Set([...values, ...currentValue]));
+            this.set(column, newValues);
+        }
+        else if (!currentValue) {
+            this.set(column, values);
+        }
+        return this;
+    }
+    /**
+     * Perform saving operation either by updating or creating a new record in database
+     */
+    async save(mergedData, { triggerEvents = true, cast = true, forceUpdate = false, } = {}) {
+        const saveEvents = [];
+        try {
+            if (mergedData) {
+                this.merge(mergedData);
+            }
+            let mode = "create";
+            let currentModel;
+            // check if the data contains the primary id column
+            if (!this.isNewModel()) {
+                // perform an update operation
+                // check if the data has changed
+                // if not changed, then do not do anything
+                if (cast) {
+                    await this.castData(forceUpdate);
+                }
+                if (this.shouldUpdate(this.originalData, this.data) === false) {
+                    return this;
+                }
+                currentModel = new this.constructor(this.originalData);
+                mode = "update";
+                const updatedAtColumn = this.updatedAtColumn;
+                if (updatedAtColumn) {
+                    // updateAtColumn is supposed to be part of the Schema
+                    this.data[updatedAtColumn] = new Date();
+                }
+                if (triggerEvents) {
+                    const selfModelEvents = this.getModelEvents();
+                    const ModelEvents = this.getBaseModelEvents();
+                    await this.onSaving();
+                    await this.onUpdating();
+                    await selfModelEvents.trigger("updating", this, currentModel);
+                    await selfModelEvents.trigger("saving", this, currentModel);
+                    await ModelEvents.trigger("updating", this, currentModel);
+                    await ModelEvents.trigger("saving", this, currentModel);
+                }
+                await this.getQuery().replace(this.getCollection(), {
+                    _id: this.data._id,
+                }, this.data);
+                if (triggerEvents) {
+                    const selfModelEvents = this.getModelEvents();
+                    const ModelEvents = this.getBaseModelEvents();
+                    saveEvents.push(this.onSaved(), this.onUpdated(), selfModelEvents.trigger("updated", this, currentModel), selfModelEvents.trigger("saved", this, currentModel), ModelEvents.trigger("updated", this, currentModel), ModelEvents.trigger("saved", this, currentModel));
+                }
+            }
+            else {
+                let tries = 3;
+                while (tries > 0) {
+                    try {
+                        // await this.getDatabase().startSessionContext(async ({ session }) => {
+                        // check for default values and merge it with the data
+                        await this.checkDefaultValues();
+                        // if the column does not exist, then create it
+                        if (!this.data.id || this.autoGeneratedId) {
+                            this.autoGeneratedId = true;
+                            await this.generateNextId();
+                        }
+                        const now = new Date();
+                        const createdAtColumn = this.createdAtColumn;
+                        // if the column does not exist, then create it
+                        if (this.data[createdAtColumn]) {
+                            this.data[createdAtColumn] = new Date(this.data[createdAtColumn]);
+                        }
+                        else if (createdAtColumn) {
+                            this.data[createdAtColumn] = now;
+                        }
+                        // if the column does not exist, then create it
+                        const updatedAtColumn = this.updatedAtColumn;
+                        if (updatedAtColumn) {
+                            this.data[updatedAtColumn] = now;
+                        }
+                        if (cast) {
+                            await this.castData();
+                        }
+                        if (triggerEvents) {
+                            const selfModelEvents = this.getModelEvents();
+                            const ModelEvents = this.getBaseModelEvents();
+                            await this.onSaving();
+                            await this.onCreating();
+                            await selfModelEvents.trigger("creating", this);
+                            await selfModelEvents.trigger("saving", this);
+                            await ModelEvents.trigger("creating", this);
+                            await ModelEvents.trigger("saving", this);
+                        }
+                        this.data = (await this.getQuery().create(this.getCollection(), this.data));
+                        if (triggerEvents) {
+                            const selfModelEvents = this.getModelEvents();
+                            const ModelEvents = this.getBaseModelEvents();
+                            saveEvents.push(this.onSaved(), this.onCreated(), selfModelEvents.trigger("created", this), selfModelEvents.trigger("saved", this), ModelEvents.trigger("created", this), ModelEvents.trigger("saved", this));
+                        }
+                        break;
+                    }
+                    catch (error) {
+                        console.log(error.message);
+                        console.log(error.trace);
+                        // Handle duplicate key error
+                        if (error instanceof mongodb.MongoServerError && error.code === 11000) {
+                            if (tries < 2) {
+                                const duplicateField = error.keyValue;
+                                const fieldName = Object.keys(duplicateField)[0];
+                                const errorMessage = `A record with the same ${fieldName} already exists.`;
+                                if (this.autoGeneratedId) {
+                                    this.unset("id");
+                                }
+                                throw new Error(errorMessage);
+                            }
+                            else {
+                                tries--;
+                            }
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (!this.data.id)
+                return this;
+            this.originalData = reinforcements.clone(this.data);
+            // @see constructor
+            this.originalData._id = this.data._id;
+            if (triggerEvents) {
+                await Promise.all(saveEvents);
+                this.startSyncing(mode, currentModel);
+            }
+            return this;
+        }
+        catch (error) {
+            console.log("Error in " + this.constructor.name + ".save()");
+            console.log(error);
+            throw error;
+        }
+    }
+    /**
+     * Generate and return next id
+     */
+    async generateNextId() {
+        this.set("id", await this.getStaticProperty("genNextId").bind(this.constructor)());
+        return this.id;
+    }
+    /**
+     * Perform saving but without any events triggers
+     */
+    async silentSaving(mergedData, options) {
+        return await this.save(mergedData, {
+            triggerEvents: false,
+            ...(options || {}),
+        });
+    }
+    /**
+     * Determine whether the model should be updated or not
+     */
+    shouldUpdate(originalData, data) {
+        return reinforcements.areEqual(originalData, data) === false;
+    }
+    /**
+     * Triggered before saving the model either by creating or updating
+     */
+    async onSaving() {
+        //
+    }
+    /**
+     * Triggered after saving the model either by creating or updating
+     */
+    async onSaved() {
+        //
+    }
+    /**
+     * Triggered before creating the model
+     */
+    async onCreating() {
+        //
+    }
+    /**
+     * Triggered after creating the model
+     */
+    async onCreated() {
+        //
+    }
+    /**
+     * Triggered before updating the model
+     */
+    async onUpdating() {
+        //
+    }
+    /**
+     * Triggered after updating the model
+     */
+    async onUpdated() {
+        //
+    }
+    /**
+     * Triggered before deleting the model
+     */
+    async onDeleting() {
+        //
+    }
+    /**
+     * Triggered after deleting the model
+     */
+    async onDeleted() {
+        //
+    }
+    /**
+     * Cast data before saving
+     */
+    async castData(forceUpdate = false) {
+        for (const column in this.casts) {
+            if (!forceUpdate && !this.isDirty(column)) {
+                continue;
+            }
+            let value = this.get(column);
+            if (value === undefined)
+                continue;
+            const castType = this.casts[column];
+            const castValue = async (value) => {
+                if (castType.prototype instanceof Model) {
+                    // if cast type is passed as model class, then get its embedded data
+                    value = await castModel.castModel(castType)(value);
+                }
+                else if (castType?.model) {
+                    // it means the user is passing a custom model embedding i.e Model.embed('embedToProduct') => Product to embed from the getter property
+                    // embedToProduct
+                    // @see EmbeddedModel
+                    value = await castModel.castModel(castType.model, castType.embeddedKey)(value);
+                }
+                else if (typeof castType === "object") {
+                    // it means the user is passing an enum object
+                    value = await oneOf.castEnum(castType)(value);
+                }
+                else if (value instanceof Model) {
+                    value = value.embeddedData;
+                }
+                else if (typeof castType === "function") {
+                    value = await castType(value, column, this);
+                }
+                else {
+                    value = this.castValue(value, castType);
+                }
+                return value;
+            };
+            // if the cast type is passed in array
+            // it means we just need to pass the value to the first function
+            // second argument will be the column name
+            // and the third argument will be the model instance
+            if (Array.isArray(castType)) {
+                value = await castType[0](value, column, this);
+            }
+            else if (Array.isArray(value) && castType !== "localized") {
+                // if cast type is array, then we'll keep the value as it is
+                // now we want to add a new validation rule that to check
+                // if the value is an array of localized objects
+                // if so, then each value in the array should have `localeCode` and `value` keys
+                // if so, then it will be cast only to the value key inside each object
+                // so the final output will be localeCode and `castValue` of the value key
+                if (castType === "array") ;
+                else if (value[0]?.localeCode && value[0]?.value) {
+                    value = await Promise.all(value.map(async (item) => {
+                        return {
+                            localeCode: item.localeCode,
+                            value: await castValue(item.value),
+                        };
+                    }));
+                }
+                else {
+                    value = await Promise.all(value.map(async (item) => {
+                        return await castValue(item);
+                    }));
+                }
+            }
+            else {
+                value = await castValue(value);
+            }
+            if (Array.isArray(value)) {
+                value = value.filter(value => value !== null && value !== undefined);
+            }
+            if (value !== undefined) {
+                this.set(column, value);
+            }
+            else {
+                this.unset(column);
+            }
+        }
+        for (const column in this.customCasts) {
+            const castType = this.customCasts[column];
+            const value = await castType(this, column);
+            if (value !== undefined) {
+                this.set(column, value);
+            }
+            else {
+                this.unset(column);
+            }
+        }
+    }
+    /**
+     * Return only the given columns to be used in output
+     */
+    outputOnly(columns) {
+        return this.clone(this.only(columns));
+    }
+    /**
+     * Return all columns except the given columns to be used in output
+     */
+    outputExcept(columns) {
+        return this.clone(this.except(columns));
+    }
+    /**
+     * Cast the given value based on the given cast type
+     */
+    castValue(value, castType) {
+        const isEmptyValue = supportiveIs.isEmpty(value);
+        if (typeof value === "object") {
+            if (value === null)
+                return undefined;
+        }
+        else if (isEmptyValue)
+            return undefined;
+        switch (castType) {
+            case "string":
+                return isEmptyValue ? "" : String(value).trim();
+            case "localized":
+                // if (isEmptyValue) return [];
+                // if (!Array.isArray(value)) return [];
+                if (!Array.isArray(value))
+                    return undefined;
+                return value
+                    .filter(value => !supportiveIs.isEmpty(value) && supportiveIs.isPlainObject(value))
+                    .map(item => {
+                    return {
+                        localeCode: item.localeCode,
+                        value: item.value,
+                    };
+                });
+            case "number":
+                // return isEmptyValue ? 0 : Number(value);
+                return Number(value);
+            case "int":
+            case "integer":
+                // return isEmptyValue ? 0 : parseInt(value);
+                return parseInt(value);
+            case "float":
+                // return isEmptyValue ? 0 : parseFloat(value);
+                return parseFloat(value);
+            case "bool":
+            case "boolean": {
+                // if (isEmptyValue) return false;
+                if (value === "true")
+                    return true;
+                if (value === "false" || value === "0" || value === 0)
+                    return false;
+                return Boolean(value);
+            }
+            case "date": {
+                if (dayjs__default.default.isDayjs(value)) {
+                    value = value.toDate();
+                }
+                if (value instanceof Date) {
+                    return timeWizard.toUTC(value);
+                }
+                return timeWizard.toUTC(new Date(value));
+            }
+            case "location": {
+                // if (isEmptyValue) return null;
+                const lat = value?.[0] || value?.lat;
+                const lng = value?.[1] || value?.lng;
+                const address = value?.address || value?.formattedAddress;
+                return {
+                    type: "Point",
+                    coordinates: [Number(lat), Number(lng)],
+                    address,
+                };
+            }
+            case "object": {
+                // if (isEmptyValue) return {};
+                if (typeof value === "string") {
+                    try {
+                        return JSON.parse(value);
+                    }
+                    catch (error) {
+                        return undefined;
+                    }
+                }
+                return value;
+            }
+            case "array": {
+                // if (isEmptyValue) return [];
+                if (typeof value === "string") {
+                    return JSON.parse(value);
+                }
+                return value;
+            }
+            case "mixed":
+            case "any":
+            default:
+                return value;
+        }
+    }
+    /**
+     * Check for default values
+     */
+    checkDefaultValues() {
+        // if default value is empty, then do nothing
+        if (supportiveIs.isEmpty(this.defaultValue))
+            return;
+        const defaultValue = { ...this.defaultValue };
+        for (const key in defaultValue) {
+            const value = defaultValue[key];
+            if (typeof value === "function") {
+                defaultValue[key] = value(this);
+            }
+        }
+        // merge the data with default value
+        this.data = reinforcements.merge(defaultValue, this.data);
+    }
+    /**
+     * Destroy the model and delete it from database collection
+     */
+    async destroy() {
+        if (!this.data._id)
+            return;
+        if (this.deletedAtColumn) {
+            this.set(this.deletedAtColumn, new Date());
+        }
+        const deleteStrategy = this.getStaticProperty("deleteStrategy");
+        if (deleteStrategy === types.ModelDeleteStrategy.moveToTrash) {
+            const collectionName = this.getCollection();
+            class Trash extends Model {
+                static collection = collectionName + "Trash";
+            }
+            // we need to wrap the trash collection inside a model class so it get a generated timestamps and id
+            Trash.create({
+                document: this.data,
+            });
+        }
+        const selfModelEvents = this.getModelEvents();
+        const ModelEvents = this.getBaseModelEvents();
+        await this.onDeleting();
+        await selfModelEvents.trigger("deleting", this);
+        await ModelEvents.trigger("deleting", this);
+        // the document will be deleted from database collection if the delete strategy is not soft delete
+        if (deleteStrategy !== types.ModelDeleteStrategy.softDelete) {
+            await this.getQuery().deleteOne(this.getCollection(), {
+                _id: this.data._id,
+            });
+        }
+        else if (deleteStrategy === types.ModelDeleteStrategy.softDelete) {
+            await this.getQuery().updateOne(this.getCollection(), {
+                _id: this.data._id,
+            }, this.data);
+        }
+        this.onDeleted();
+        selfModelEvents.trigger("deleted", this);
+        ModelEvents.trigger("deleted", this);
+        this.syncDestruction();
+    }
+    /**
+     * Determine if the given column is dirty column
+     *
+     * Dirty columns are columns that their values have been changed from the original data
+     */
+    isDirty(column) {
+        if (!column) {
+            return reinforcements.areEqual(reinforcements.clone(this.data), reinforcements.clone(this.originalData)) === false;
+        }
+        if (this.isNewModel())
+            return true;
+        const currentValue = reinforcements.get(this.data, column);
+        const originalValue = reinforcements.get(this.originalData, column);
+        return reinforcements.areEqual(reinforcements.clone(currentValue), reinforcements.clone(originalValue)) === false;
+    }
+    /**
+     * Check if current model is a new model
+     */
+    isNewModel() {
+        return !this.data._id || (this.data._id && this.isRestored);
+    }
+    /**
+     * Get embedded data
+     */
+    get embeddedData() {
+        if (this.embedAllExcept.length > 0) {
+            return reinforcements.except(this.data, this.embedAllExcept);
+        }
+        if (this.embedAllExceptTimestampsAndUserColumns) {
+            return reinforcements.except(this.data, [
+                this.createdAtColumn,
+                this.updatedAtColumn,
+                this.deletedAtColumn,
+                this.createdByColumn,
+                this.updatedByColumn,
+                this.deletedByColumn,
+            ]);
+        }
+        return this.embedded.length > 0 ? this.only(this.embedded) : this.data;
+    }
+    /**
+     * Clone the model
+     */
+    clone(data = this.data) {
+        return new this.constructor(reinforcements.clone(data));
+    }
+}exports.Model=Model;//# sourceMappingURL=model.js.map