@warlock.js/cascade 4.0.30 → 4.0.39

package/cjs/model/model.js

@@ -1,1134 +0,0 @@
-'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'),crudModel=require('./crud-model.js'),joinable=require('./joinable.js'),ModelAggregate=require('./ModelAggregate.js'),ModelSync=require('./ModelSync.js'),RelationshipWithMany=require('./RelationshipWithMany.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,
-//   Schema extends Schema<ModelDocument> = any,
-// >
- extends crudModel.CrudModel {
-    /**
-     * Model Initial Document data
-     */
-    initialData = {};
-    /**
-     * Model relationships defined using the joinable API.
-     *
-     * Each key represents a relationship name that can be referenced when running queries.
-     * Each value defines how to join another collection to the current model.
-     *
-     * @example
-     * Basic definition:
-     * ```ts
-     * public static relations = {
-     *   // Join users collection where local createdBy.id matches user's id
-     *   author: User.joinable("createdBy.id", "id").single().as("author"),
-     * }
-     * ```
-     * @usage
-     * Example of calling:
-     * ```ts
-     * Post.aggregate().joining("author").get(); // use `joining` method to join the `author` relationship
-     * // Where `author` is the name of the relationship defined in the `relations` property
-     * ```
-     */
-    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 this.originalData._id === "string") {
-            this.originalData._id = new mongodb.ObjectId(this.originalData._id);
-        }
-        this.data = reinforcements.clone(this.originalData);
-        this.initialData = reinforcements.clone(this.originalData);
-    }
-    /**
-     * 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 model is active
-     */
-    get isActive() {
-        return this.bool(this.isActiveColumn);
-    }
-    /**
-     * Check if current model created by the given user (user model)
-     */
-    isCreatedBy(user) {
-        return this.get("createdBy.id") === user.id;
-    }
-    /**
-     * Check if current model last updated by the given user (user model)
-     */
-    isUpdatedBy(user) {
-        return this.get("updatedBy.id") === user.id;
-    }
-    /**
-     * 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;
-    }
-    /**
-     * Get the value of the given column and remove it from the data
-     */
-    pluck(column) {
-        const value = this.get(column);
-        this.unset(column);
-        return value;
-    }
-    /**
-     * 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(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;
-    }
-    async prepareDataForCreating(cast = true, triggerEvents = true) {
-        // 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 (createdAtColumn && !this.data[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);
-        }
-    }
-    /**
-     * Perform saving operation either by updating or creating a new record in database
-     */
-    async save(mergedData, { triggerEvents = true, cast = true, forceUpdate = false, } = {}) {
-        const isNewModel = this.isNewModel();
-        try {
-            if (mergedData) {
-                this.merge(mergedData);
-            }
-            // const logLevel = getDatabaseDebugLevel();
-            let currentModel;
-            // check if the data contains the primary id column
-            if (!isNewModel) {
-                // perform an update operation
-                // check if the data has changed
-                // if not changed, then do not do anything
-                if (cast) {
-                    // this.logInfo("Casting data before saving");
-                    await this.castData(forceUpdate);
-                    // this.logInfo("Data has been casted");
-                }
-                if (this.shouldUpdate(this.originalData, this.data) === false) {
-                    return this;
-                }
-                currentModel = new this.constructor(this.originalData);
-                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);
-                }
-                // const data = { ...this.data };
-                // if (isPlainObject(data._id)) {
-                //   delete data._id;
-                // }
-                const filter = {};
-                if (supportiveIs.isEmpty(this._id)) {
-                    filter._id = this.data._id;
-                }
-                else {
-                    filter.id = this.id;
-                }
-                await this.getQuery().replace(this.getCollection(), filter, this.data);
-                if (triggerEvents) {
-                    this.triggerUpdatedEvents(currentModel);
-                }
-            }
-            else {
-                let tries = 3;
-                while (tries > 0) {
-                    try {
-                        await this.prepareDataForCreating(cast, triggerEvents);
-                        this.data = (await this.getQuery().create(this.getCollection(), this.data));
-                        if (triggerEvents) {
-                            this.triggerCreatedEvents();
-                        }
-                        break;
-                    }
-                    catch (error) {
-                        console.log(error);
-                        // 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;
-            return this;
-        }
-        catch (error) {
-            console.log("Error in " + this.constructor.name + ".save()");
-            console.log(error);
-            throw error;
-        }
-    }
-    /**
-     * Serialize the model data for storage in database
-     */
-    serialize() {
-        return {
-            ...this.data,
-            _id: this.data._id ? this.data._id.toString() : undefined,
-        };
-    }
-    /**
-     * Generate and return next id
-     */
-    async generateNextId() {
-        this.set("id", await this.getStaticProperty("genNextId").bind(this.constructor)());
-        return this.id;
-    }
-    /**
-     * Trigger created events
-     */
-    triggerCreatedEvents() {
-        const selfModelEvents = this.getModelEvents();
-        const ModelEvents = this.getBaseModelEvents();
-        this.onSaved();
-        this.onCreated();
-        selfModelEvents.trigger("created", this);
-        selfModelEvents.trigger("saved", this);
-        ModelEvents.trigger("created", this);
-        ModelEvents.trigger("saved", this);
-        this.startSyncing("create");
-    }
-    /**
-     * Trigger updated events
-     */
-    triggerUpdatedEvents(oldModel) {
-        const selfModelEvents = this.getModelEvents();
-        const ModelEvents = this.getBaseModelEvents();
-        this.onSaved();
-        this.onUpdated();
-        selfModelEvents.trigger("updated", this, oldModel);
-        selfModelEvents.trigger("saved", this, oldModel);
-        ModelEvents.trigger("updated", this, oldModel);
-        ModelEvents.trigger("saved", this, oldModel);
-        this.startSyncing("update", oldModel);
-    }
-    /**
-     * 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() {
-        // Check initial data instead of current data since it represents
-        // the original state when the model was instantiated
-        const hasMongoId = Boolean(this.data._id) && !this.isRestored;
-        // Check for numeric id in initial data
-        // const hasNumericId = Boolean(this.data?.id) && !this.isRestored;
-        return !hasMongoId;
-    }
-    /**
-     * 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 newQuery() {
-        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;
-    }
-    /**
-     * Refresh the model with new data from database
-     * This method will update the current data with the new data from database
-     */
-    async refresh() {
-        const key = this.data._id ? "_id" : "id";
-        const value = this.data._id ?? this.data.id;
-        const data = await this.getQuery().first(this.getCollection(), {
-            [key]: value,
-        });
-        if (!data)
-            return;
-        this.data = data;
-        return this;
-    }
-    /**
-     * Fetch data from database and return it in a new model
-     */
-    async reload() {
-        const key = this.data._id ? "_id" : "id";
-        const value = this.data._id ?? this.data.id;
-        if (!value) {
-            throw new Error("Model ID is required to reload the model");
-        }
-        const data = await this.getQuery().first(this.getCollection(), {
-            [key]: value,
-        });
-        return new this.constructor(data);
-    }
-    /**
-     * 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(
-    /**
-     * Local field to the current model
-     */
-    localField, 
-    /**
-     * Foreign field in the joinable model
-     */
-    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