@warlock.js/cascade 1.0.5 → 1.0.7

package/cjs/model/model.js

@@ -0,0 +1,1028 @@
+'use strict';var reinforcements=require('@mongez/reinforcements'),supportiveIs=require('@mongez/supportive-is'),timeWizard=require('@mongez/time-wizard'),dayjs=require('dayjs'),mongodb=require('mongodb'),castModel=require('../casts/castModel.js'),oneOf=require('../casts/oneOf.js'),deepDiff=require('../utils/deep-diff.js'),joinableProxy=require('../utils/joinable-proxy.js'),ModelAggregate=require('./ModelAggregate.js'),ModelSync=require('./ModelSync.js'),RelationshipWithMany=require('./RelationshipWithMany.js'),crudModel=require('./crud-model.js'),joinable=require('./joinable.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 crudModel.CrudModel {
+    /**
+     * Model Initial Document data
+     */
+    initialData = {};
+    /**
+     * Relations list
+     */
+    static relations = {};
+    /**
+     * 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 = {};
+    /**
+     * Sync with list
+     */
+    syncWith = [];
+    /**
+     * 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 = {};
+    /**
+     * List of dirty columns
+     */
+    dirtyColumns = {};
+    /**
+     * 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) {
+        const currentValue = this.get(column);
+        this.data = reinforcements.set(this.data, column, value);
+        if (currentValue !== value) {
+            reinforcements.set(this.dirtyColumns, column, {
+                oldValue: currentValue,
+                newValue: 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) {
+        const currentValues = this.only(columns);
+        this.data = reinforcements.except(this.data, columns);
+        for (const column in currentValues) {
+            reinforcements.set(this.dirtyColumns, column, {
+                oldValue: currentValues[column],
+                newValue: undefined,
+            });
+        }
+        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;
+        }
+        const currentData = reinforcements.clone(this.data);
+        this.data = data;
+        const dirtyValues = deepDiff.deepDiff(currentData, this.data);
+        reinforcements.merge(this.dirtyColumns, dirtyValues);
+        return this;
+    }
+    /**
+     * Merge the given documents to current document
+     */
+    merge(data) {
+        const currentData = reinforcements.clone(this.data);
+        this.data = reinforcements.merge(this.data, data);
+        const dirtyValues = deepDiff.deepDiff(currentData, this.data);
+        reinforcements.merge(this.dirtyColumns, dirtyValues);
+        for (const column in this.data) {
+            if (this.data[column] !== currentData[column]) {
+                reinforcements.set(this.dirtyColumns, column, {
+                    oldValue: currentData[column],
+                    newValue: this.data[column],
+                });
+            }
+        }
+        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.getStaticProperty("autoGenerateId")) {
+                            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));
+    }
+    /**
+     * Get relationship with the given model class
+     */
+    hasMany(modelClass, column) {
+        return new RelationshipWithMany.RelationshipWithMany(this, modelClass, column);
+    }
+    /**
+     * Get new aggregate for current model
+     */
+    static aggregate() {
+        return new ModelAggregate.ModelAggregate(this);
+    }
+    /**
+     * @alias aggregate
+     */
+    static $() {
+        return this.aggregate();
+    }
+    /**
+     * Get query builder
+     * @alias aggregate
+     */
+    static queryBuilder() {
+        return new ModelAggregate.ModelAggregate(this);
+    }
+    /**
+     * Sync with the given model
+     */
+    static sync(columns, embedMethod = "embedData") {
+        return new ModelSync.ModelSync(this, columns, embedMethod);
+    }
+    /**
+     * Sync data on saving
+     */
+    startSyncing(saveMode, oldModel) {
+        for (const modelSync of this.syncWith) {
+            modelSync.sync(this, saveMode, oldModel);
+        }
+    }
+    /**
+     * Sync destruction
+     * Called when destroy method is called
+     */
+    syncDestruction() {
+        for (const modelSync of this.syncWith) {
+            modelSync.syncDestruction(this);
+        }
+    }
+    /**
+     * The syncing model (That calls startSyncing) is being embedded in multiple documents of current model
+     * I.e Country.syncMany('cities') while current model is City
+     */
+    static syncMany(columns, embedMethod = "embedData") {
+        return new ModelSync.ModelSync(this, columns, embedMethod).syncMany();
+    }
+    /**
+     * Reassociate a model/object/document with the current model
+     * If the model is already associated, it will be updated
+     * If not, it will be associated
+     * the model/document must have an id
+     *
+     * If it is a model, you can set the embed method to use
+     */
+    reassociate(column, model, embedWith) {
+        const columnValue = model instanceof Model
+            ? embedWith
+                ? model[embedWith]()
+                : model.embeddedData
+            : model;
+        if (columnValue === undefined)
+            return this;
+        // make a deep copy so when changing the data, it won't affect the original data
+        const documentsList = reinforcements.clone(this.get(column, []));
+        const index = documentsList.findIndex((doc) => (doc?.id || doc) === (columnValue?.id || columnValue));
+        if (index === -1) {
+            documentsList.push(columnValue);
+        }
+        else {
+            documentsList[index] = columnValue;
+        }
+        this.set(column, [...documentsList]);
+        return this;
+    }
+    /**
+     * Associate a model with the current model
+     */
+    associate(column, model, embedWith) {
+        const columnValue = model instanceof Model
+            ? embedWith
+                ? model[embedWith]()
+                : model.embeddedData
+            : model;
+        if (columnValue === undefined)
+            return this;
+        const documentsList = this.get(column, []);
+        documentsList.push(columnValue);
+        this.set(column, documentsList);
+        return this;
+    }
+    /**
+     * Disassociate a model with the current model
+     */
+    disassociate(column, model) {
+        const columnValue = model instanceof Model ? model.embeddedData : model;
+        if (columnValue === undefined)
+            return this;
+        const documentsList = this.get(column, []);
+        if (!Array.isArray(documentsList))
+            return this;
+        const index = documentsList.findIndex((doc) => (doc?.id || doc) === (columnValue?.id || columnValue));
+        if (index !== -1) {
+            documentsList.splice(index, 1);
+        }
+        this.set(column, documentsList);
+        return this;
+    }
+    /**
+     * Make a wrapper to list when models should be updated when only one of the given columns is updated
+     */
+    syncUpdateWhenChange(columns, syncModels) {
+        return syncModels.map(syncModel => {
+            syncModel.updateWhenChange(columns);
+            return syncModel;
+        });
+    }
+    /**
+     * Get a Joinable instance for current model
+     */
+    static joinable(localField, foreignField, single, as) {
+        const joinable$1 = new joinable.Joinable(this);
+        if (localField) {
+            joinable$1.localField(localField);
+        }
+        if (foreignField) {
+            joinable$1.foreignField(foreignField);
+        }
+        if (single) {
+            joinable$1.single(single);
+        }
+        if (as) {
+            joinable$1.as(as);
+        }
+        return joinableProxy.joinableProxy(joinable$1);
+    }
+}exports.Model=Model;//# sourceMappingURL=model.js.map