@kaspernj/api-maker 1.0.2053 → 1.0.2055

package/build/base-model.js

@@ -1,10 +1,10 @@
 import Attribute from "./base-model/attribute";
 import AttributeNotLoadedError from "./attribute-not-loaded-error";
 import CacheKeyGenerator from "./cache-key-generator";
-import Collection from "./collection";
-import CommandsPool from "./commands-pool";
-import Config from "./config";
-import CustomError from "./custom-error";
+import Collection from "./collection.js";
+import CommandsPool from "./commands-pool.js";
+import Config from "./config.js";
+import CustomError from "./custom-error.js";
 import { digg } from "diggerize";
 import FormDataObjectizer from "form-data-objectizer";
 import * as inflection from "inflection";
@@ -13,816 +13,1024 @@ import NotLoadedError from "./not-loaded-error";
 import objectToFormData from "object-to-formdata";
 import Reflection from "./base-model/reflection";
 import Scope from "./base-model/scope";
-import Services from "./services";
-import ValidationError from "./validation-error";
-import { ValidationErrors } from "./validation-errors";
-const objectToUnderscore = object => {
-  const newObject = {};
-  for (const key in object) {
-    const underscoreKey = inflection.underscore(key);
-    newObject[underscoreKey] = object[key];
-  }
-  return newObject;
-};
+import Services from "./services.js";
+import ValidationError from "./validation-error.js";
+import { ValidationErrors } from "./validation-errors.js";
+/**
+ * @typedef {object} ModelClassDataType
+ * @property {import("./base-model/attribute.js").AttributeArgType[]} attributes
+ * @property {string} collectionName
+ * @property {string} name
+ * @property {string} paramKey
+ * @property {string} primaryKey
+ * @property {object} ransackable_attributes
+ */
+/**
+ * @typedef {object} ParseValidationErrorsOptions
+ * @property {object} [form]
+ * @property {boolean} [throwValidationError]
+ */
+function objectToUnderscore(object) {
+    const newObject = {};
+    for (const key in object) {
+        const underscoreKey = inflection.underscore(key);
+        newObject[underscoreKey] = object[key];
+    }
+    return newObject;
+}
 export default class BaseModel {
-  static apiMakerType = "BaseModel";
-  static attributes() {
-    const attributes = digg(this.modelClassData(), "attributes");
-    const result = [];
-    for (const attributeKey in attributes) {
-      const attributeData = attributes[attributeKey];
-      const attribute = new Attribute(attributeData);
-      result.push(attribute);
-    }
-    return result;
-  }
-  static hasAttribute(attributeName) {
-    const attributes = digg(this.modelClassData(), "attributes");
-    const lowerCaseAttributeName = inflection.underscore(attributeName);
-    if (lowerCaseAttributeName in attributes) return true;
-    return false;
-  }
-  static modelClassData() {
-    throw new Error("modelClassData should be overriden by child");
-  }
-  static newCustomEvent = validationErrors => {
-    return new CustomEvent("validation-errors", {
-      detail: validationErrors
-    });
-  };
-  static sendValidationErrorsEvent = (validationErrors, options) => {
-    if (options && options.form) {
-      const event = BaseModel.newCustomEvent(validationErrors);
-      options.form.dispatchEvent(event);
-    }
-  };
-  static async find(id) {
-    const query = {};
-    query[`${this.primaryKey()}_eq`] = id;
-    const model = await this.ransack(query).first();
-    if (model) {
-      return model;
-    } else {
-      throw new CustomError("Record not found");
-    }
-  }
-  static async findOrCreateBy(findOrCreateByArgs, args = {}) {
-    const result = await Services.current().sendRequest("Models::FindOrCreateBy", {
-      additional_data: args.additionalData,
-      find_or_create_by_args: findOrCreateByArgs,
-      resource_name: digg(this.modelClassData(), "name")
-    });
-    const model = digg(result, "model");
-    return model;
-  }
-  static modelName() {
-    return new ModelName({
-      modelClassData: this.modelClassData()
-    });
-  }
-  static primaryKey() {
-    return digg(this.modelClassData(), "primaryKey");
-  }
-  static ransack(query = {}) {
-    return new Collection({
-      modelClass: this
-    }, {
-      ransack: query
-    });
-  }
-  static select(select) {
-    return this.ransack().select(select);
-  }
-  static ransackableAssociations() {
-    const relationships = digg(this.modelClassData(), "ransackable_associations");
-    const reflections = [];
-    for (const relationshipData of relationships) {
-      reflections.push(new Reflection(relationshipData));
-    }
-    return reflections;
-  }
-  static ransackableAttributes() {
-    const attributes = digg(this.modelClassData(), "ransackable_attributes");
-    const result = [];
-    for (const attributeData of attributes) {
-      result.push(new Attribute(attributeData));
-    }
-    return result;
-  }
-  static ransackableScopes() {
-    const ransackableScopes = digg(this.modelClassData(), "ransackable_scopes");
-    const result = [];
-    for (const scopeData of ransackableScopes) {
-      const scope = new Scope(scopeData);
-      result.push(scope);
-    }
-    return result;
-  }
-  static reflections() {
-    const relationships = digg(this.modelClassData(), "relationships");
-    const reflections = [];
-    for (const relationshipData of relationships) {
-      const reflection = new Reflection(relationshipData);
-      reflections.push(reflection);
-    }
-    return reflections;
-  }
-  static reflection(name) {
-    const foundReflection = this.reflections().find(reflection => reflection.name() == name);
-    if (!foundReflection) {
-      throw new Error(`No such reflection: ${name} in ${this.reflections().map(reflection => reflection.name()).join(", ")}`);
-    }
-    return foundReflection;
-  }
-  static _token() {
-    const csrfTokenElement = document.querySelector("meta[name='csrf-token']");
-    if (csrfTokenElement) {
-      return csrfTokenElement.getAttribute("content");
-    }
-  }
-  constructor(args = {}) {
-    this.changes = {};
-    this.newRecord = args.isNewRecord;
-    this.relationshipsCache = {};
-    this.relationships = {};
-    if (args && args.data && args.data.a) {
-      this._readModelDataFromArgs(args);
-    } else if (args.a) {
-      this.abilities = args.b || {};
-      this.modelData = objectToUnderscore(args.a);
-    } else if (args) {
-      this.abilities = {};
-      this.modelData = objectToUnderscore(args);
-    } else {
-      this.abilities = {};
-      this.modelData = {};
-    }
-  }
-  assignAttributes(newAttributes) {
-    for (const key in newAttributes) {
-      const newValue = newAttributes[key];
-      const attributeUnderscore = inflection.underscore(key);
-      let applyChange = true;
-      let deleteChange = false;
-      if (this.isAttributeLoaded(key)) {
-        const oldValue = this.readAttribute(key);
-        const originalValue = this.modelData[attributeUnderscore];
-        if (newValue == oldValue) {
-          applyChange = false;
-        } else if (newValue == originalValue) {
-          applyChange = false;
-          deleteChange = true;
-        }
-      }
-      if (applyChange) {
-        this.changes[attributeUnderscore] = newValue;
-      } else if (deleteChange) {
-        delete this.changes[attributeUnderscore];
-      }
-    }
-  }
-  attributes() {
-    const result = {};
-    for (const key in this.modelData) {
-      result[key] = this.modelData[key];
-    }
-    for (const key in this.changes) {
-      result[key] = this.changes[key];
-    }
-    return result;
-  }
-  can(givenAbilityName) {
-    const abilityName = inflection.underscore(givenAbilityName);
-    if (!(abilityName in this.abilities)) {
-      throw new Error(`Ability ${abilityName} hasn't been loaded for ${digg(this.modelClassData(), "name")}`);
-    }
-    return this.abilities[abilityName];
-  }
-  clone() {
-    const clone = new this.constructor();
-    clone.abilities = {
-      ...this.abilities
-    };
-    clone.modelData = {
-      ...this.modelData
-    };
-    clone.relationships = {
-      ...this.relationships
-    };
-    clone.relationshipsCache = {
-      ...this.relationshipsCache
-    };
-    return clone;
-  }
-  cacheKey() {
-    if (this.isPersisted()) {
-      const keyParts = [this.modelClassData().paramKey, this.primaryKey()];
-      if ("updated_at" in this.modelData) {
-        const updatedAt = this.updatedAt();
-        if (typeof updatedAt != "object") {
-          throw new Error(`updatedAt wasn't an object: ${typeof updatedAt}`);
-        } else if (!("getTime" in updatedAt)) {
-          throw new Error(`updatedAt didn't support getTime with class: ${updatedAt.constructor && updatedAt.constructor.name}`);
-        }
-        keyParts.push(`updatedAt-${this.updatedAt().getTime()}`);
-      }
-      return keyParts.join("-");
-    } else {
-      return this.uniqueKey();
-    }
-  }
-  localCacheKey() {
-    const cacheKeyGenerator = new CacheKeyGenerator(this);
-    return cacheKeyGenerator.local();
-  }
-  fullCacheKey() {
-    const cacheKeyGenerator = new CacheKeyGenerator(this);
-    return cacheKeyGenerator.cacheKey();
-  }
-  static all() {
-    return this.ransack();
-  }
-  async create(attributes, options) {
-    if (attributes) this.assignAttributes(attributes);
-    const paramKey = this.modelClassData().paramKey;
-    const modelData = this.getAttributes();
-    const dataToUse = {};
-    dataToUse[paramKey] = modelData;
-    let response;
-    try {
-      response = await CommandsPool.addCommand({
-        args: {
-          save: dataToUse
-        },
-        command: `${this.modelClassData().collectionName}-create`,
-        collectionName: this.modelClassData().collectionName,
-        primaryKey: this.primaryKey(),
-        type: "create"
-      }, {});
-    } catch (error) {
-      BaseModel.parseValidationErrors({
-        error,
-        model: this,
-        options
-      });
-      throw error;
-    }
-    if (response.model) {
-      this._refreshModelFromResponse(response);
-      this.changes = {};
-    }
-    return {
-      model: this,
-      response
-    };
-  }
-  async createRaw(rawData, options = {}) {
-    const objectData = BaseModel._objectDataFromGivenRawData(rawData, options);
-    let response;
-    try {
-      response = await CommandsPool.addCommand({
-        args: {
-          save: objectData
-        },
-        command: `${this.modelClassData().collectionName}-create`,
-        collectionName: this.modelClassData().collectionName,
-        primaryKey: this.primaryKey(),
-        type: "create"
-      }, {});
-    } catch (error) {
-      BaseModel.parseValidationErrors({
-        error,
-        model: this,
-        options
-      });
-      throw error;
-    }
-    if (response.model) {
-      this._refreshModelDataFromResponse(response);
-      this.changes = {};
-    }
-    return {
-      model: this,
-      response
+    static apiMakerType = "BaseModel";
+    /** @returns {Attribute[]} */
+    static attributes() {
+        const attributes = this.modelClassData().attributes;
+        const result = [];
+        for (const attributeKey in attributes) {
+            const attributeData = attributes[attributeKey];
+            const attribute = new Attribute(attributeData);
+            result.push(attribute);
+        }
+        return result;
+    }
+    /** @returns {boolean} */
+    static hasAttribute(attributeName) {
+        const attributes = digg(this.modelClassData(), "attributes");
+        const lowerCaseAttributeName = inflection.underscore(attributeName);
+        if (lowerCaseAttributeName in attributes)
+            return true;
+        return false;
+    }
+    /**
+     * @interface
+     * @returns {ModelClassDataType}
+     */
+    static modelClassData() {
+        throw new Error("modelClassData should be overriden by child");
+    }
+    /**
+     * @param {ValidationErrors} validationErrors
+     * @returns {CustomEvent}
+     */
+    static newCustomEvent = (validationErrors) => {
+        return new CustomEvent("validation-errors", { detail: validationErrors });
     };
-  }
-  async destroy() {
-    const response = await CommandsPool.addCommand({
-      args: {
-        query_params: this.collection && this.collection.params()
-      },
-      command: `${this.modelClassData().collectionName}-destroy`,
-      collectionName: this.modelClassData().collectionName,
-      primaryKey: this.primaryKey(),
-      type: "destroy"
-    }, {});
-    if (response.success) {
-      if (response.model) {
-        this._refreshModelDataFromResponse(response);
+    /**
+     * @param {ValidationErrors} validationErrors
+     * @param {object} [options]
+     * @param {object} [options.form]
+     * @param {boolean} [options.throwValidationError]
+     */
+    static sendValidationErrorsEvent(validationErrors, options) {
+        if (options && options.form) {
+            const event = BaseModel.newCustomEvent(validationErrors);
+            options.form.dispatchEvent(event);
+        }
+    }
+    /**
+     * @template {typeof BaseModel} T
+     * @this {T}
+     * @param {number | string} id
+     * @returns {Promise<InstanceType<T>>}
+     */
+    static async find(id) {
+        /** @type {Record<string, any>} */
+        const query = {};
+        query[`${this.primaryKey()}_eq`] = id;
+        const model = /** @type {InstanceType<T>} */ (await this.ransack(query).first());
+        if (model) {
+            return model;
+        }
+        else {
+            throw new CustomError("Record not found");
+        }
+    }
+    /**
+     * @template {typeof BaseModel} T
+     * @this {T}
+     * @param {Record<string, any>} findOrCreateByArgs
+     * @returns {Promise<InstanceType<T>>}
+     */
+    static async findOrCreateBy(findOrCreateByArgs, args = {}) {
+        const result = await Services.current().sendRequest("Models::FindOrCreateBy", {
+            additional_data: args.additionalData,
+            find_or_create_by_args: findOrCreateByArgs,
+            resource_name: digg(this.modelClassData(), "name")
+        });
+        const model = /** @type {InstanceType<T>} */ (digg(result, "model"));
+        return model;
+    }
+    /** @returns {ModelName} */
+    static modelName() {
+        return new ModelName({ modelClassData: this.modelClassData() });
+    }
+    /** @returns {string} */
+    static primaryKey() {
+        return digg(this.modelClassData(), "primaryKey");
+    }
+    /**
+     * @template {typeof BaseModel} MC
+     * @this {MC}
+     * @param {Record<string, any>} [query]
+     * @returns {import("./collection.js").default<MC>}
+     */
+    static ransack(query = {}) {
+        const ModelClass = /** @type {MC} */ (this);
+        return new Collection({ modelClass: ModelClass }, { ransack: query });
+    }
+    /**
+     * @template {typeof BaseModel} MC
+     * @this {MC}
+     * @param {Record<string, any>} [select]
+     * @returns {import("./collection.js").default<MC>}
+     */
+    static select(select) {
+        return this.ransack().select(select);
+    }
+    /** @returns {Reflection[]} */
+    static ransackableAssociations() {
+        const relationships = digg(this.modelClassData(), "ransackable_associations");
+        const reflections = [];
+        for (const relationshipData of relationships) {
+            reflections.push(new Reflection(relationshipData));
+        }
+        return reflections;
+    }
+    /** @returns {Attribute[]} */
+    static ransackableAttributes() {
+        const attributes = this.modelClassData().ransackable_attributes;
+        const result = [];
+        for (const attributeData of attributes) {
+            result.push(new Attribute(attributeData));
+        }
+        return result;
+    }
+    /** @returns {Scope[]} */
+    static ransackableScopes() {
+        const ransackableScopes = digg(this.modelClassData(), "ransackable_scopes");
+        const result = [];
+        for (const scopeData of ransackableScopes) {
+            const scope = new Scope(scopeData);
+            result.push(scope);
+        }
+        return result;
+    }
+    /** @returns {Reflection[]} */
+    static reflections() {
+        const relationships = digg(this.modelClassData(), "relationships");
+        const reflections = [];
+        for (const relationshipData of relationships) {
+            const reflection = new Reflection(relationshipData);
+            reflections.push(reflection);
+        }
+        return reflections;
+    }
+    /** @returns {Reflection} */
+    static reflection(name) {
+        const foundReflection = this.reflections().find((reflection) => reflection.name() == name);
+        if (!foundReflection) {
+            throw new Error(`No such reflection: ${name} in ${this.reflections().map((reflection) => reflection.name()).join(", ")}`);
+        }
+        return foundReflection;
+    }
+    /**
+     * @returns {string}
+     */
+    static _token() {
+        const csrfTokenElement = document.querySelector("meta[name='csrf-token']");
+        if (csrfTokenElement) {
+            return csrfTokenElement.getAttribute("content");
+        }
+    }
+    constructor(args = {}) {
         this.changes = {};
-      }
-      return {
-        model: this,
-        response
-      };
-    } else {
-      this.handleResponseError(response);
-    }
-  }
-  async ensureAbilities(listOfAbilities) {
-    // Populate an array with a list of abilities currently not loaded
-    const abilitiesToLoad = [];
-    for (const abilityInList of listOfAbilities) {
-      if (!(abilityInList in this.abilities)) {
-        abilitiesToLoad.push(abilityInList);
-      }
-    }
-
-    // Load the missing abilities if any
-    if (abilitiesToLoad.length > 0) {
-      const primaryKeyName = this.constructor.primaryKey();
-      const ransackParams = {};
-      ransackParams[`${primaryKeyName}_eq`] = this.primaryKey();
-      const abilitiesParams = {};
-      abilitiesParams[digg(this.modelClassData(), "name")] = abilitiesToLoad;
-      const anotherModel = await this.constructor.ransack(ransackParams).abilities(abilitiesParams).first();
-      if (!anotherModel) {
-        throw new Error(`Could not look up the same model ${this.primaryKey()} with abilities: ${abilitiesToLoad.join(", ")}`);
-      }
-      const newAbilities = anotherModel.abilities;
-      for (const newAbility in newAbilities) {
-        this.abilities[newAbility] = newAbilities[newAbility];
-      }
-    }
-  }
-  getAttributes = () => Object.assign(this.modelData, this.changes);
-  handleResponseError(response) {
-    BaseModel.parseValidationErrors({
-      model: this,
-      response
-    });
-    throw new new CustomError("Response wasn't successful", {
-      model: this,
-      response
-    })();
-  }
-  identifierKey() {
-    if (!this._identifierKey) this._identifierKey = this.isPersisted() ? this.primaryKey() : this.uniqueKey();
-    return this._identifierKey;
-  }
-  isAssociationLoaded = associationName => this.isAssociationLoadedUnderscore(inflection.underscore(associationName));
-  isAssociationLoadedUnderscore(associationNameUnderscore) {
-    if (associationNameUnderscore in this.relationshipsCache) return true;
-    return false;
-  }
-  isAssociationPresent(associationName) {
-    if (this.isAssociationLoaded(associationName)) return true;
-    if (associationName in this.relationships) return true;
-    return false;
-  }
-  static parseValidationErrors({
-    error,
-    model,
-    options
-  }) {
-    if (!(error instanceof ValidationError)) return;
-    if (!error.args.response.validation_errors) return;
-    const validationErrors = new ValidationErrors({
-      model,
-      validationErrors: digg(error, "args", "response", "validation_errors")
-    });
-    BaseModel.sendValidationErrorsEvent(validationErrors, options);
-    if (!options || options.throwValidationError != false) {
-      throw error;
-    }
-  }
-  static humanAttributeName(attributeName) {
-    const keyName = digg(this.modelClassData(), "i18nKey");
-    const i18n = Config.getI18n();
-    if (i18n) return i18n.t(`activerecord.attributes.${keyName}.${BaseModel.snakeCase(attributeName)}`, {
-      defaultValue: attributeName
-    });
-    return inflection.humanize(attributeName);
-  }
-  isAttributeChanged(attributeName) {
-    const attributeNameUnderscore = inflection.underscore(attributeName);
-    const attributeData = this.modelClassData().attributes.find(attribute => digg(attribute, "name") == attributeNameUnderscore);
-    if (!attributeData) {
-      const attributeNames = this.modelClassData().attributes.map(attribute => digg(attribute, "name"));
-      throw new Error(`Couldn't find an attribute by that name: "${attributeName}" in: ${attributeNames.join(", ")}`);
-    }
-    if (!(attributeNameUnderscore in this.changes)) return false;
-    const oldValue = this.modelData[attributeNameUnderscore];
-    const newValue = this.changes[attributeNameUnderscore];
-    const changedMethod = this[`_is${inflection.camelize(attributeData.type, true)}Changed`];
-    if (!changedMethod) throw new Error(`Don't know how to handle type: ${attributeData.type}`);
-    return changedMethod(oldValue, newValue);
-  }
-  isChanged() {
-    const keys = Object.keys(this.changes);
-    if (keys.length > 0) {
-      return true;
-    } else {
-      return false;
-    }
-  }
-  isNewRecord() {
-    if (this.newRecord !== undefined) {
-      return this.newRecord;
-    } else if ("id" in this.modelData && this.modelData.id) {
-      return false;
-    } else {
-      return true;
-    }
-  }
-  isPersisted = () => !this.isNewRecord();
-  static snakeCase = string => inflection.underscore(string);
-  savedChangeToAttribute(attributeName) {
-    if (!this.previousModelData) return false;
-    const attributeNameUnderscore = inflection.underscore(attributeName);
-    const attributeData = this.modelClassData().attributes.find(attribute => attribute.name == attributeNameUnderscore);
-    if (!attributeData) {
-      const attributeNames = this.modelClassData().attributes.map(attribute => attribute.name);
-      throw new Error(`Couldn't find an attribute by that name: "${attributeName}" in: ${attributeNames.join(", ")}`);
-    }
-    if (!(attributeNameUnderscore in this.previousModelData)) return true;
-    const oldValue = this.previousModelData[attributeNameUnderscore];
-    const newValue = this.modelData[attributeNameUnderscore];
-    const changedMethodName = `_is${inflection.camelize(attributeData.type)}Changed`;
-    const changedMethod = this[changedMethodName];
-    if (!changedMethod) throw new Error(`Don't know how to handle type: ${attributeData.type}`);
-    return changedMethod(oldValue, newValue);
-  }
-  setNewModel(model) {
-    this.setNewModelData(model);
-    for (const relationshipName in model.relationships) {
-      this.relationships[relationshipName] = model.relationships[relationshipName];
-    }
-    for (const relationshipCacheName in model.relationshipsCache) {
-      this.relationshipsCache[relationshipCacheName] = model.relationshipsCache[name];
-    }
-  }
-  setNewModelData(model) {
-    if (!("modelData" in model)) throw new Error(`No modelData in model: ${JSON.stringify(model)}`);
-    this.previousModelData = Object.assign({}, digg(this, "modelData"));
-    for (const attributeName in model.modelData) {
-      this.modelData[attributeName] = model.modelData[attributeName];
-    }
-  }
-  _isDateChanged(oldValue, newValue) {
-    if (Date.parse(oldValue) != Date.parse(newValue)) return true;
-  }
-  _isIntegerChanged(oldValue, newValue) {
-    if (parseInt(oldValue, 10) != parseInt(newValue, 10)) return true;
-  }
-  _isStringChanged(oldValue, newValue) {
-    const oldConvertedValue = `${oldValue}`;
-    const newConvertedValue = `${newValue}`;
-    if (oldConvertedValue != newConvertedValue) return true;
-  }
-  modelClassData = () => this.constructor.modelClassData();
-  async reload() {
-    const params = this.collection && this.collection.params();
-    const ransackParams = {};
-    ransackParams[`${this.constructor.primaryKey()}_eq`] = this.primaryKey();
-    let query = this.constructor.ransack(ransackParams);
-    if (params) {
-      if (params.preload) {
-        query.queryArgs.preload = params.preload;
-      }
-      if (params.select) {
-        query.queryArgs.select = params.select;
-      }
-      if (params.select_columns) {
-        query.queryArgs.selectColumns = params.select_columns;
-      }
-    }
-    const model = await query.first();
-    this.setNewModel(model);
-    this.changes = {};
-  }
-  save() {
-    if (this.isNewRecord()) {
-      return this.create();
-    } else {
-      return this.update();
-    }
-  }
-  saveRaw(rawData, options = {}) {
-    if (this.isNewRecord()) {
-      return this.createRaw(rawData, options);
-    } else {
-      return this.updateRaw(rawData, options);
-    }
-  }
-  async update(newAttributes, options) {
-    if (newAttributes) {
-      this.assignAttributes(newAttributes);
-    }
-    if (Object.keys(this.changes).length == 0) {
-      return {
-        model: this
-      };
-    }
-    const paramKey = this.modelClassData().paramKey;
-    const modelData = this.changes;
-    const dataToUse = {};
-    dataToUse[paramKey] = modelData;
-    let response;
-    try {
-      response = await CommandsPool.addCommand({
-        args: {
-          query_params: this.collection && this.collection.params(),
-          save: dataToUse
-        },
-        command: `${this.modelClassData().collectionName}-update`,
-        collectionName: this.modelClassData().collectionName,
-        primaryKey: this.primaryKey(),
-        type: "update"
-      }, {});
-    } catch (error) {
-      BaseModel.parseValidationErrors({
-        error,
-        model: this,
-        options
-      });
-      throw error;
-    }
-    if (response.success) {
-      if (response.model) {
-        this._refreshModelFromResponse(response);
+        this.newRecord = args.isNewRecord;
+        this.relationshipsCache = {};
+        this.relationships = {};
+        if (args && args.data && args.data.a) {
+            this._readModelDataFromArgs(args);
+        }
+        else if (args.a) {
+            this.abilities = args.b || {};
+            this.modelData = objectToUnderscore(args.a);
+        }
+        else if (args) {
+            this.abilities = {};
+            this.modelData = objectToUnderscore(args);
+        }
+        else {
+            this.abilities = {};
+            this.modelData = {};
+        }
+    }
+    /**
+     * @param {Record<string, any>} newAttributes
+     * @returns {void}
+     */
+    assignAttributes(newAttributes) {
+        for (const key in newAttributes) {
+            const newValue = newAttributes[key];
+            const attributeUnderscore = inflection.underscore(key);
+            let applyChange = true;
+            let deleteChange = false;
+            if (this.isAttributeLoaded(key)) {
+                const oldValue = this.readAttribute(key);
+                const originalValue = this.modelData[attributeUnderscore];
+                if (newValue == oldValue) {
+                    applyChange = false;
+                }
+                else if (newValue == originalValue) {
+                    applyChange = false;
+                    deleteChange = true;
+                }
+            }
+            if (applyChange) {
+                this.changes[attributeUnderscore] = newValue;
+            }
+            else if (deleteChange) {
+                delete this.changes[attributeUnderscore];
+            }
+        }
+    }
+    /** @returns {Record<string, any>} */
+    attributes() {
+        const result = {};
+        for (const key in this.modelData) {
+            result[key] = this.modelData[key];
+        }
+        for (const key in this.changes) {
+            result[key] = this.changes[key];
+        }
+        return result;
+    }
+    /**
+     * @param {string} givenAbilityName
+     * @returns {boolean}
+     */
+    can(givenAbilityName) {
+        const abilityName = inflection.underscore(givenAbilityName);
+        if (!(abilityName in this.abilities)) {
+            throw new Error(`Ability ${abilityName} hasn't been loaded for ${digg(this.modelClassData(), "name")}`);
+        }
+        return this.abilities[abilityName];
+    }
+    /**
+     * @template {BaseModel} Self
+     * @this {Self}
+     * @returns {Self}
+     */
+    clone() {
+        const ModelClass = /** @type {new (...args: any[]) => Self} */ (this.constructor);
+        const clone = new ModelClass();
+        clone.abilities = { ...this.abilities };
+        clone.modelData = { ...this.modelData };
+        clone.relationships = { ...this.relationships };
+        clone.relationshipsCache = { ...this.relationshipsCache };
+        return clone;
+    }
+    /** @returns {number | string} */
+    cacheKey() {
+        if (this.isPersisted()) {
+            const keyParts = [
+                this.modelClassData().paramKey,
+                this.primaryKey()
+            ];
+            if ("updated_at" in this.modelData) {
+                // @ts-expect-error
+                const updatedAt = this.updatedAt();
+                if (typeof updatedAt != "object") {
+                    throw new Error(`updatedAt wasn't an object: ${typeof updatedAt}`);
+                }
+                else if (!("getTime" in updatedAt)) {
+                    throw new Error(`updatedAt didn't support getTime with class: ${updatedAt.constructor && updatedAt.constructor.name}`);
+                }
+                // @ts-expect-error
+                keyParts.push(`updatedAt-${this.updatedAt().getTime()}`);
+            }
+            return keyParts.join("-");
+        }
+        else {
+            return this.uniqueKey();
+        }
+    }
+    /** @returns {string} */
+    localCacheKey() {
+        const cacheKeyGenerator = new CacheKeyGenerator(this);
+        return cacheKeyGenerator.local();
+    }
+    /** @returns {string} */
+    fullCacheKey() {
+        const cacheKeyGenerator = new CacheKeyGenerator(this);
+        return cacheKeyGenerator.cacheKey();
+    }
+    /**
+     * @template {typeof BaseModel} MC
+     * @this {MC}
+     * @returns {Collection<MC>}
+     */
+    static all() {
+        return this.ransack();
+    }
+    /**
+     * @param {Record<string, any>} [attributes]
+     * @param {object} [options]
+     * @returns {Promise<{
+     *   model: BaseModel,
+     *   response: object
+     * }>}
+     */
+    async create(attributes, options) {
+        if (attributes)
+            this.assignAttributes(attributes);
+        const paramKey = this.modelClassData().paramKey;
+        const modelData = this.getAttributes();
+        const dataToUse = {};
+        dataToUse[paramKey] = modelData;
+        let response;
+        try {
+            response = await CommandsPool.addCommand({
+                args: {
+                    save: dataToUse
+                },
+                command: `${this.modelClassData().collectionName}-create`,
+                collectionName: this.modelClassData().collectionName,
+                primaryKey: this.primaryKey(),
+                type: "create"
+            }, {});
+        }
+        catch (error) {
+            BaseModel.parseValidationErrors({ error, model: this, options });
+            throw error;
+        }
+        if (response.model) {
+            this._refreshModelFromResponse(response);
+            this.changes = {};
+        }
+        return { model: this, response };
+    }
+    /**
+     * @param {FormData | Record<string, any>} rawData
+     * @param {object} [options]
+     */
+    async createRaw(rawData, options = {}) {
+        const objectData = BaseModel._objectDataFromGivenRawData(rawData, options);
+        let response;
+        try {
+            response = await CommandsPool.addCommand({
+                args: {
+                    save: objectData
+                },
+                command: `${this.modelClassData().collectionName}-create`,
+                collectionName: this.modelClassData().collectionName,
+                primaryKey: this.primaryKey(),
+                type: "create"
+            }, {});
+        }
+        catch (error) {
+            BaseModel.parseValidationErrors({ error, model: this, options });
+            throw error;
+        }
+        if (response.model) {
+            this._refreshModelDataFromResponse(response);
+            this.changes = {};
+        }
+        return { model: this, response };
+    }
+    /** @returns {Promise<{model: BaseModel, response: object}>} */
+    async destroy() {
+        const response = await CommandsPool.addCommand({
+            args: { query_params: this.collection && this.collection.params() },
+            command: `${this.modelClassData().collectionName}-destroy`,
+            collectionName: this.modelClassData().collectionName,
+            primaryKey: this.primaryKey(),
+            type: "destroy"
+        }, {});
+        if (response.success) {
+            if (response.model) {
+                this._refreshModelDataFromResponse(response);
+                this.changes = {};
+            }
+            return { model: this, response };
+        }
+        else {
+            this.handleResponseError(response);
+        }
+    }
+    async ensureAbilities(listOfAbilities) {
+        // Populate an array with a list of abilities currently not loaded
+        const abilitiesToLoad = [];
+        for (const abilityInList of listOfAbilities) {
+            if (!(abilityInList in this.abilities)) {
+                abilitiesToLoad.push(abilityInList);
+            }
+        }
+        // Load the missing abilities if any
+        if (abilitiesToLoad.length > 0) {
+            const primaryKeyName = this.modelClass().primaryKey();
+            const ransackParams = {};
+            ransackParams[`${primaryKeyName}_eq`] = this.primaryKey();
+            const abilitiesParams = {};
+            abilitiesParams[digg(this.modelClassData(), "name")] = abilitiesToLoad;
+            const anotherModel = await this.modelClass()
+                .ransack(ransackParams)
+                .abilities(abilitiesParams)
+                .first();
+            if (!anotherModel) {
+                throw new Error(`Could not look up the same model ${this.primaryKey()} with abilities: ${abilitiesToLoad.join(", ")}`);
+            }
+            const newAbilities = anotherModel.abilities;
+            for (const newAbility in newAbilities) {
+                this.abilities[newAbility] = newAbilities[newAbility];
+            }
+        }
+    }
+    /**
+     * @returns {Record<string, any>}
+     */
+    getAttributes() { return Object.assign(this.modelData, this.changes); }
+    asd;
+    handleResponseError(response) {
+        // @ts-expect-error
+        BaseModel.parseValidationErrors({ model: this, response });
+        throw new CustomError("Response wasn't successful", { model: this, response });
+    }
+    /**
+     * @returns {number | string}
+     */
+    identifierKey() {
+        if (!this._identifierKey)
+            this._identifierKey = this.isPersisted() ? this.primaryKey() : this.uniqueKey();
+        return this._identifierKey;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isAssociationLoaded(associationName) { return this.isAssociationLoadedUnderscore(inflection.underscore(associationName)); }
+    /**
+     * @returns {boolean}
+     */
+    isAssociationLoadedUnderscore(associationNameUnderscore) {
+        if (associationNameUnderscore in this.relationshipsCache)
+            return true;
+        return false;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isAssociationPresent(associationName) {
+        if (this.isAssociationLoaded(associationName))
+            return true;
+        if (associationName in this.relationships)
+            return true;
+        return false;
+    }
+    /**
+     * @param {object} args
+     * @param {any} args.error
+     * @param {BaseModel} [args.model]
+     * @param {ParseValidationErrorsOptions} args.options
+     */
+    static parseValidationErrors({ error, model, options }) {
+        if (!(error instanceof ValidationError))
+            return;
+        if (!error.args.response.validation_errors)
+            return;
+        const validationErrors = new ValidationErrors({
+            model,
+            validationErrors: digg(error, "args", "response", "validation_errors")
+        });
+        BaseModel.sendValidationErrorsEvent(validationErrors, options);
+        if (!options || options.throwValidationError != false) {
+            throw error;
+        }
+    }
+    static humanAttributeName(attributeName) {
+        const keyName = digg(this.modelClassData(), "i18nKey");
+        // @ts-expect-error
+        const i18n = Config.getI18n();
+        if (i18n)
+            return i18n.t(`activerecord.attributes.${keyName}.${BaseModel.snakeCase(attributeName)}`, { defaultValue: attributeName });
+        return inflection.humanize(attributeName);
+    }
+    /**
+     * @param {string} attributeName
+     * @returns {boolean}
+     */
+    isAttributeChanged(attributeName) {
+        const attributeNameUnderscore = inflection.underscore(attributeName);
+        const attributeData = this.modelClassData().attributes.find((attribute) => digg(attribute, "name") == attributeNameUnderscore);
+        if (!attributeData) {
+            const attributeNames = this.modelClassData().attributes.map((attribute) => digg(attribute, "name"));
+            throw new Error(`Couldn't find an attribute by that name: "${attributeName}" in: ${attributeNames.join(", ")}`);
+        }
+        if (!(attributeNameUnderscore in this.changes))
+            return false;
+        const oldValue = this.modelData[attributeNameUnderscore];
+        const newValue = this.changes[attributeNameUnderscore];
+        const changedMethod = this[`_is${inflection.camelize(attributeData.type, true)}Changed`];
+        if (!changedMethod)
+            throw new Error(`Don't know how to handle type: ${attributeData.type}`);
+        return changedMethod(oldValue, newValue);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isChanged() {
+        const keys = Object.keys(this.changes);
+        if (keys.length > 0) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isNewRecord() {
+        if (this.newRecord !== undefined) {
+            return this.newRecord;
+        }
+        else if ("id" in this.modelData && this.modelData.id) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isPersisted() { return !this.isNewRecord(); }
+    /**
+     * @param {string} string
+     * @returns {string}
+     */
+    static snakeCase(string) { return inflection.underscore(string); }
+    /**
+     * @param {string} attributeName
+     * @returns {boolean}
+     */
+    savedChangeToAttribute(attributeName) {
+        if (!this.previousModelData)
+            return false;
+        const attributeNameUnderscore = inflection.underscore(attributeName);
+        const attributeData = this.modelClassData().attributes.find((attribute) => attribute.name == attributeNameUnderscore);
+        if (!attributeData) {
+            const attributeNames = this.modelClassData().attributes.map((attribute) => attribute.name);
+            throw new Error(`Couldn't find an attribute by that name: "${attributeName}" in: ${attributeNames.join(", ")}`);
+        }
+        if (!(attributeNameUnderscore in this.previousModelData))
+            return true;
+        const oldValue = this.previousModelData[attributeNameUnderscore];
+        const newValue = this.modelData[attributeNameUnderscore];
+        const changedMethodName = `_is${inflection.camelize(attributeData.type)}Changed`;
+        const changedMethod = this[changedMethodName];
+        if (!changedMethod)
+            throw new Error(`Don't know how to handle type: ${attributeData.type}`);
+        return changedMethod(oldValue, newValue);
+    }
+    /**
+     * @param {BaseModel} model
+     * @returns {void}
+     */
+    setNewModel(model) {
+        this.setNewModelData(model);
+        for (const relationshipName in model.relationships) {
+            this.relationships[relationshipName] = model.relationships[relationshipName];
+        }
+        for (const relationshipCacheName in model.relationshipsCache) {
+            this.relationshipsCache[relationshipCacheName] = model.relationshipsCache[name];
+        }
+    }
+    setNewModelData(model) {
+        if (!("modelData" in model))
+            throw new Error(`No modelData in model: ${JSON.stringify(model)}`);
+        this.previousModelData = Object.assign({}, digg(this, "modelData"));
+        for (const attributeName in model.modelData) {
+            this.modelData[attributeName] = model.modelData[attributeName];
+        }
+    }
+    _isDateChanged(oldValue, newValue) {
+        if (Date.parse(oldValue) != Date.parse(newValue))
+            return true;
+    }
+    _isIntegerChanged(oldValue, newValue) {
+        if (parseInt(oldValue, 10) != parseInt(newValue, 10))
+            return true;
+    }
+    _isStringChanged(oldValue, newValue) {
+        const oldConvertedValue = `${oldValue}`;
+        const newConvertedValue = `${newValue}`;
+        if (oldConvertedValue != newConvertedValue)
+            return true;
+    }
+    /** @returns {ModelClassDataType} */
+    modelClassData() { return this.modelClass().modelClassData(); }
+    /**
+     * @returns {Promise<void>}
+     */
+    async reload() {
+        const params = this.collection && this.collection.params();
+        const ransackParams = {};
+        ransackParams[`${this.modelClass().primaryKey()}_eq`] = this.primaryKey();
+        let query = this.modelClass().ransack(ransackParams);
+        if (params) {
+            if (params.preload) {
+                query.queryArgs.preload = params.preload;
+            }
+            if (params.select) {
+                query.queryArgs.select = params.select;
+            }
+            if (params.select_columns) {
+                query.queryArgs.selectColumns = params.select_columns;
+            }
+        }
+        const model = await query.first();
+        this.setNewModel(model);
         this.changes = {};
-      }
-      return {
-        response,
-        model: this
-      };
-    } else {
-      this.handleResponseError(response);
-    }
-  }
-  _refreshModelFromResponse(response) {
-    let newModel = digg(response, "model");
-    if (Array.isArray(newModel)) newModel = newModel[0];
-    this.setNewModel(newModel);
-  }
-  _refreshModelDataFromResponse(response) {
-    let newModel = digg(response, "model");
-    if (Array.isArray(newModel)) newModel = newModel[0];
-    this.setNewModelData(newModel);
-  }
-  static _objectDataFromGivenRawData(rawData, options) {
-    if (rawData instanceof FormData || rawData.nodeName == "FORM") {
-      const formData = FormDataObjectizer.formDataFromObject(rawData, options);
-      return FormDataObjectizer.toObject(formData);
-    }
-    return rawData;
-  }
-  async updateRaw(rawData, options = {}) {
-    const objectData = BaseModel._objectDataFromGivenRawData(rawData, options);
-    let response;
-    try {
-      response = await CommandsPool.addCommand({
-        args: {
-          query_params: this.collection && this.collection.params(),
-          save: objectData,
-          simple_model_errors: options?.simpleModelErrors
-        },
-        command: `${this.modelClassData().collectionName}-update`,
-        collectionName: this.modelClassData().collectionName,
-        primaryKey: this.primaryKey(),
-        type: "update"
-      }, {});
-    } catch (error) {
-      BaseModel.parseValidationErrors({
-        error,
-        model: this,
-        options
-      });
-      throw error;
-    }
-    if (response.model) {
-      this._refreshModelFromResponse(response);
-      this.changes = {};
-    }
-    return {
-      response,
-      model: this
-    };
-  }
-  isValid() {
-    throw new Error("Not implemented yet");
-  }
-  async isValidOnServer() {
-    const modelData = this.getAttributes();
-    const paramKey = this.modelClassData().paramKey;
-    const dataToUse = {};
-    dataToUse[paramKey] = modelData;
-    const response = await CommandsPool.addCommand({
-      args: {
-        save: dataToUse
-      },
-      command: `${this.modelClassData().collectionName}-valid`,
-      collectionName: this.modelClassData().collectionName,
-      primaryKey: this.primaryKey(),
-      type: "valid"
-    }, {});
-    return {
-      valid: response.valid,
-      errors: response.errors
-    };
-  }
-  modelClass = () => this.constructor;
-  preloadRelationship(relationshipName, model) {
-    this.relationshipsCache[BaseModel.snakeCase(relationshipName)] = model;
-    this.relationships[BaseModel.snakeCase(relationshipName)] = model;
-  }
-  markForDestruction() {
-    this._markedForDestruction = true;
-  }
-  markedForDestruction = () => this._markedForDestruction;
-  uniqueKey() {
-    if (!this.uniqueKeyValue) {
-      const min = 5000000000000000;
-      const max = 9007199254740991;
-      const randomBetween = Math.floor(Math.random() * (max - min + 1) + min);
-      this.uniqueKeyValue = randomBetween;
-    }
-    return this.uniqueKeyValue;
-  }
-  static async _callCollectionCommand(args, commandArgs) {
-    const formOrDataObject = args.args;
-    try {
-      return await CommandsPool.addCommand(args, commandArgs);
-    } catch (error) {
-      let form;
-      if (commandArgs.form) {
-        form = commandArgs.form;
-      } else if (formOrDataObject?.nodeName == "FORM") {
-        form = formOrDataObject;
-      }
-      if (form) BaseModel.parseValidationErrors({
-        error,
-        options: {
-          form
-        }
-      });
-      throw error;
-    }
-  }
-  _callMemberCommand = (args, commandArgs) => CommandsPool.addCommand(args, commandArgs);
-  static _postDataFromArgs(args) {
-    let postData;
-    if (args) {
-      if (args instanceof FormData) {
-        postData = args;
-      } else {
-        postData = objectToFormData.serialize(args, {}, null, "args");
-      }
-    } else {
-      postData = new FormData();
-    }
-    return postData;
-  }
-  readAttribute(attributeName) {
-    const attributeNameUnderscore = inflection.underscore(attributeName);
-    return this.readAttributeUnderscore(attributeNameUnderscore);
-  }
-  readAttributeUnderscore(attributeName) {
-    if (attributeName in this.changes) {
-      return this.changes[attributeName];
-    } else if (attributeName in this.modelData) {
-      return this.modelData[attributeName];
-    } else if (this.isNewRecord()) {
-      // Return null if this is a new record and the attribute name is a recognized attribute
-      const attributes = digg(this.modelClassData(), "attributes");
-      if (attributeName in attributes) return null;
-    }
-    if (this.isPersisted()) {
-      throw new AttributeNotLoadedError(`No such attribute: ${digg(this.modelClassData(), "name")}#${attributeName}: ${JSON.stringify(this.modelData)}`);
-    }
-  }
-  isAttributeLoaded(attributeName) {
-    const attributeNameUnderscore = inflection.underscore(attributeName);
-    if (attributeNameUnderscore in this.changes) return true;
-    if (attributeNameUnderscore in this.modelData) return true;
-    return false;
-  }
-  _isPresent(value) {
-    if (!value) {
-      return false;
-    } else if (typeof value == "string" && value.match(/^\s*$/)) {
-      return false;
-    }
-    return true;
-  }
-  async _loadBelongsToReflection(args, queryArgs = {}) {
-    if (args.reflectionName in this.relationships) {
-      return this.relationships[args.reflectionName];
-    } else if (args.reflectionName in this.relationshipsCache) {
-      return this.relationshipsCache[args.reflectionName];
-    } else {
-      const collection = new Collection(args, queryArgs);
-      const model = await collection.first();
-      this.relationshipsCache[args.reflectionName] = model;
-      return model;
-    }
-  }
-  _readBelongsToReflection({
-    reflectionName
-  }) {
-    if (reflectionName in this.relationships) {
-      return this.relationships[reflectionName];
-    } else if (reflectionName in this.relationshipsCache) {
-      return this.relationshipsCache[reflectionName];
-    }
-    if (this.isNewRecord()) return null;
-    const loadedRelationships = Object.keys(this.relationshipsCache);
-    const modelClassName = digg(this.modelClassData(), "name");
-    throw new NotLoadedError(`${modelClassName}#${reflectionName} hasn't been loaded yet. Only these were loaded: ${loadedRelationships.join(", ")}`);
-  }
-  async _loadHasManyReflection(args, queryArgs = {}) {
-    if (args.reflectionName in this.relationships) {
-      return this.relationships[args.reflectionName];
-    } else if (args.reflectionName in this.relationshipsCache) {
-      return this.relationshipsCache[args.reflectionName];
-    }
-    const collection = new Collection(args, queryArgs);
-    const models = await collection.toArray();
-    this.relationshipsCache[args.reflectionName] = models;
-    return models;
-  }
-  async _loadHasOneReflection(args, queryArgs = {}) {
-    if (args.reflectionName in this.relationships) {
-      return this.relationships[args.reflectionName];
-    } else if (args.reflectionName in this.relationshipsCache) {
-      return this.relationshipsCache[args.reflectionName];
-    } else {
-      const collection = new Collection(args, queryArgs);
-      const model = await collection.first();
-      this.relationshipsCache[args.reflectionName] = model;
-      return model;
-    }
-  }
-  _readHasOneReflection({
-    reflectionName
-  }) {
-    if (reflectionName in this.relationships) {
-      return this.relationships[reflectionName];
-    } else if (reflectionName in this.relationshipsCache) {
-      return this.relationshipsCache[reflectionName];
-    }
-    if (this.isNewRecord()) {
-      return null;
-    }
-    const loadedRelationships = Object.keys(this.relationshipsCache);
-    const modelClassName = digg(this.modelClassData(), "name");
-    throw new NotLoadedError(`${modelClassName}#${reflectionName} hasn't been loaded yet. Only these were loaded: ${loadedRelationships.join(", ")}`);
-  }
-  _readModelDataFromArgs(args) {
-    this.abilities = args.data.b || {};
-    this.collection = args.collection;
-    this.modelData = objectToUnderscore(args.data.a);
-    this.preloadedRelationships = args.data.r;
-  }
-  _readPreloadedRelationships(preloaded) {
-    if (!this.preloadedRelationships) {
-      return;
-    }
-    const relationships = digg(this.modelClassData(), "relationships");
-    for (const relationshipName in this.preloadedRelationships) {
-      const relationshipData = this.preloadedRelationships[relationshipName];
-      const relationshipClassData = relationships.find(relationship => digg(relationship, "name") == relationshipName);
-      if (!relationshipClassData) {
-        const modelName = digg(this.modelClassData(), "name");
-        const relationshipsList = relationships.map(relationship => relationship.name).join(", ");
-        throw new Error(`Could not find the relation ${relationshipName} on the ${modelName} model: ${relationshipsList}`);
-      }
-      const relationshipType = digg(relationshipClassData, "collectionName");
-      if (relationshipName in this.relationshipsCache) {
-        throw new Error(`${relationshipName} has already been loaded`);
-      }
-      if (!relationshipClassData) {
-        throw new Error(`No relationship on ${digg(this.modelClassData(), "name")} by that name: ${relationshipName}`);
-      }
-      if (!relationshipData) {
-        this.relationshipsCache[relationshipName] = null;
-        this.relationships[relationshipName] = null;
-      } else if (Array.isArray(relationshipData)) {
-        this.relationshipsCache[relationshipName] = [];
-        this.relationships[relationshipName] = [];
-        for (const relationshipId of relationshipData) {
-          const model = preloaded.getModel(relationshipType, relationshipId);
-          this.relationshipsCache[relationshipName].push(model);
-          this.relationships[relationshipName].push(model);
-        }
-      } else {
-        const model = preloaded.getModel(relationshipType, relationshipData);
-        this.relationshipsCache[relationshipName] = model;
-        this.relationships[relationshipName] = model;
-      }
-    }
-  }
-  primaryKey = () => this.readAttributeUnderscore(this.constructor.primaryKey());
+    }
+    /**
+     * @returns {Promise<{model: BaseModel, response?: object}>}
+     */
+    save() {
+        if (this.isNewRecord()) {
+            return this.create();
+        }
+        else {
+            return this.update();
+        }
+    }
+    /**
+     * @returns {Promise<{model: BaseModel, response: object}>}
+     */
+    saveRaw(rawData, options = {}) {
+        if (this.isNewRecord()) {
+            return this.createRaw(rawData, options);
+        }
+        else {
+            return this.updateRaw(rawData, options);
+        }
+    }
+    /**
+     * @param {Record<string, any>} [newAttributes]
+     * @param {ParseValidationErrorsOptions} [options]
+     * @returns {Promise<{
+     *   model: BaseModel,
+     *   response?: object
+     * }>}
+     */
+    async update(newAttributes, options) {
+        if (newAttributes) {
+            this.assignAttributes(newAttributes);
+        }
+        if (Object.keys(this.changes).length == 0) {
+            return { model: this };
+        }
+        const paramKey = this.modelClassData().paramKey;
+        const modelData = this.changes;
+        const dataToUse = {};
+        dataToUse[paramKey] = modelData;
+        let response;
+        try {
+            response = await CommandsPool.addCommand({
+                args: {
+                    query_params: this.collection && this.collection.params(),
+                    save: dataToUse
+                },
+                command: `${this.modelClassData().collectionName}-update`,
+                collectionName: this.modelClassData().collectionName,
+                primaryKey: this.primaryKey(),
+                type: "update"
+            }, {});
+        }
+        catch (error) {
+            BaseModel.parseValidationErrors({ error, model: this, options });
+            throw error;
+        }
+        if (response.success) {
+            if (response.model) {
+                this._refreshModelFromResponse(response);
+                this.changes = {};
+            }
+            return { response, model: this };
+        }
+        else {
+            this.handleResponseError(response);
+        }
+    }
+    _refreshModelFromResponse(response) {
+        let newModel = digg(response, "model");
+        if (Array.isArray(newModel))
+            newModel = newModel[0];
+        this.setNewModel(newModel);
+    }
+    _refreshModelDataFromResponse(response) {
+        let newModel = digg(response, "model");
+        if (Array.isArray(newModel))
+            newModel = newModel[0];
+        this.setNewModelData(newModel);
+    }
+    /**
+     * @param {FormData | Record<string, any>} rawData
+     * @param {object} options
+     * @returns {Record<string, any>}
+     */
+    static _objectDataFromGivenRawData(rawData, options) {
+        if (rawData instanceof FormData || rawData.nodeName == "FORM") {
+            const formData = FormDataObjectizer.formDataFromObject(rawData, options);
+            return FormDataObjectizer.toObject(formData);
+        }
+        return rawData;
+    }
+    async updateRaw(rawData, options = {}) {
+        const objectData = BaseModel._objectDataFromGivenRawData(rawData, options);
+        let response;
+        try {
+            response = await CommandsPool.addCommand({
+                args: {
+                    query_params: this.collection && this.collection.params(),
+                    save: objectData,
+                    simple_model_errors: options?.simpleModelErrors
+                },
+                command: `${this.modelClassData().collectionName}-update`,
+                collectionName: this.modelClassData().collectionName,
+                primaryKey: this.primaryKey(),
+                type: "update"
+            }, {});
+        }
+        catch (error) {
+            BaseModel.parseValidationErrors({ error, model: this, options });
+            throw error;
+        }
+        if (response.model) {
+            this._refreshModelFromResponse(response);
+            this.changes = {};
+        }
+        return { response, model: this };
+    }
+    isValid() {
+        throw new Error("Not implemented yet");
+    }
+    async isValidOnServer() {
+        const modelData = this.getAttributes();
+        const paramKey = this.modelClassData().paramKey;
+        const dataToUse = {};
+        dataToUse[paramKey] = modelData;
+        const response = await CommandsPool.addCommand({
+            args: {
+                save: dataToUse
+            },
+            command: `${this.modelClassData().collectionName}-valid`,
+            collectionName: this.modelClassData().collectionName,
+            primaryKey: this.primaryKey(),
+            type: "valid"
+        }, {});
+        return { valid: response.valid, errors: response.errors };
+    }
+    /**
+     * @template {BaseModel} Self
+     * @this {Self}
+     * @returns {typeof BaseModel & (new (...args: any[]) => Self)}
+     */
+    modelClass() {
+        return /** @type {any} */ (this.constructor);
+    }
+    preloadRelationship(relationshipName, model) {
+        this.relationshipsCache[BaseModel.snakeCase(relationshipName)] = model;
+        this.relationships[BaseModel.snakeCase(relationshipName)] = model;
+    }
+    /**
+     * @returns {void}
+     */
+    markForDestruction() {
+        this._markedForDestruction = true;
+    }
+    /**
+     * @returns {boolean}
+     */
+    markedForDestruction() { return this._markedForDestruction || false; }
+    /**
+     * @returns {number}
+     */
+    uniqueKey() {
+        if (!this.uniqueKeyValue) {
+            const min = 5000000000000000;
+            const max = 9007199254740991;
+            const randomBetween = Math.floor(Math.random() * (max - min + 1) + min);
+            this.uniqueKeyValue = randomBetween;
+        }
+        return this.uniqueKeyValue;
+    }
+    static async _callCollectionCommand(args, commandArgs) {
+        const formOrDataObject = args.args;
+        try {
+            return await CommandsPool.addCommand(args, commandArgs);
+        }
+        catch (error) {
+            let form;
+            if (commandArgs.form) {
+                form = commandArgs.form;
+            }
+            else if (formOrDataObject?.nodeName == "FORM") {
+                form = formOrDataObject;
+            }
+            if (form)
+                BaseModel.parseValidationErrors({ error, options: { form } });
+            throw error;
+        }
+    }
+    _callMemberCommand = (args, commandArgs) => CommandsPool.addCommand(args, commandArgs);
+    static _postDataFromArgs(args) {
+        let postData;
+        if (args) {
+            if (args instanceof FormData) {
+                postData = args;
+            }
+            else {
+                postData = objectToFormData.serialize(args, {}, null, "args");
+            }
+        }
+        else {
+            postData = new FormData();
+        }
+        return postData;
+    }
+    /**
+     * @param {string} attributeName
+     * @returns {any}
+     */
+    readAttribute(attributeName) {
+        const attributeNameUnderscore = inflection.underscore(attributeName);
+        return this.readAttributeUnderscore(attributeNameUnderscore);
+    }
+    /**
+     * @param {string} attributeName
+     * @returns {any}
+     */
+    readAttributeUnderscore(attributeName) {
+        if (attributeName in this.changes) {
+            return this.changes[attributeName];
+        }
+        else if (attributeName in this.modelData) {
+            return this.modelData[attributeName];
+        }
+        else if (this.isNewRecord()) {
+            // Return null if this is a new record and the attribute name is a recognized attribute
+            const attributes = digg(this.modelClassData(), "attributes");
+            if (attributeName in attributes)
+                return null;
+        }
+        if (this.isPersisted()) {
+            throw new AttributeNotLoadedError(`No such attribute: ${digg(this.modelClassData(), "name")}#${attributeName}: ${JSON.stringify(this.modelData)}`);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isAttributeLoaded(attributeName) {
+        const attributeNameUnderscore = inflection.underscore(attributeName);
+        if (attributeNameUnderscore in this.changes)
+            return true;
+        if (attributeNameUnderscore in this.modelData)
+            return true;
+        return false;
+    }
+    _isPresent(value) {
+        if (!value) {
+            return false;
+        }
+        else if (typeof value == "string" && value.match(/^\s*$/)) {
+            return false;
+        }
+        return true;
+    }
+    async _loadBelongsToReflection(args, queryArgs = {}) {
+        if (args.reflectionName in this.relationships) {
+            return this.relationships[args.reflectionName];
+        }
+        else if (args.reflectionName in this.relationshipsCache) {
+            return this.relationshipsCache[args.reflectionName];
+        }
+        else {
+            const collection = new Collection(args, queryArgs);
+            const model = await collection.first();
+            this.relationshipsCache[args.reflectionName] = model;
+            return model;
+        }
+    }
+    _readBelongsToReflection({ reflectionName }) {
+        if (reflectionName in this.relationships) {
+            return this.relationships[reflectionName];
+        }
+        else if (reflectionName in this.relationshipsCache) {
+            return this.relationshipsCache[reflectionName];
+        }
+        if (this.isNewRecord())
+            return null;
+        const loadedRelationships = Object.keys(this.relationshipsCache);
+        const modelClassName = digg(this.modelClassData(), "name");
+        throw new NotLoadedError(`${modelClassName}#${reflectionName} hasn't been loaded yet. Only these were loaded: ${loadedRelationships.join(", ")}`);
+    }
+    /**
+     * @template {typeof import("./base-model.js").default} AssocMC
+     * @param {import("./collection.js").CollectionArgsType<AssocMC>} args
+     * @param {import("./collection.js").QueryArgsType} queryArgs
+     * @returns {Promise<Array<InstanceType<AssocMC>>>}
+     */
+    async _loadHasManyReflection(args, queryArgs = {}) {
+        if (args.reflectionName in this.relationships) {
+            return this.relationships[args.reflectionName];
+        }
+        else if (args.reflectionName in this.relationshipsCache) {
+            return this.relationshipsCache[args.reflectionName];
+        }
+        const collection = new Collection(args, queryArgs);
+        const models = await collection.toArray();
+        this.relationshipsCache[args.reflectionName] = models;
+        return models;
+    }
+    /**
+     * @template {typeof import("./base-model.js").default} AssocMC
+     * @param {import("./collection.js").CollectionArgsType<AssocMC>} args
+     * @param {import("./collection.js").QueryArgsType} queryArgs
+     * @returns {Promise<InstanceType<AssocMC>>}
+     */
+    async _loadHasOneReflection(args, queryArgs = {}) {
+        if (args.reflectionName in this.relationships) {
+            return this.relationships[args.reflectionName];
+        }
+        else if (args.reflectionName in this.relationshipsCache) {
+            return this.relationshipsCache[args.reflectionName];
+        }
+        else {
+            const collection = new Collection(args, queryArgs);
+            const model = await collection.first();
+            this.relationshipsCache[args.reflectionName] = model;
+            return model;
+        }
+    }
+    _readHasOneReflection({ reflectionName }) {
+        if (reflectionName in this.relationships) {
+            return this.relationships[reflectionName];
+        }
+        else if (reflectionName in this.relationshipsCache) {
+            return this.relationshipsCache[reflectionName];
+        }
+        if (this.isNewRecord()) {
+            return null;
+        }
+        const loadedRelationships = Object.keys(this.relationshipsCache);
+        const modelClassName = digg(this.modelClassData(), "name");
+        throw new NotLoadedError(`${modelClassName}#${reflectionName} hasn't been loaded yet. Only these were loaded: ${loadedRelationships.join(", ")}`);
+    }
+    _readModelDataFromArgs(args) {
+        this.abilities = args.data.b || {};
+        this.collection = args.collection;
+        this.modelData = objectToUnderscore(args.data.a);
+        this.preloadedRelationships = args.data.r;
+    }
+    _readPreloadedRelationships(preloaded) {
+        if (!this.preloadedRelationships) {
+            return;
+        }
+        const relationships = digg(this.modelClassData(), "relationships");
+        for (const relationshipName in this.preloadedRelationships) {
+            const relationshipData = this.preloadedRelationships[relationshipName];
+            const relationshipClassData = relationships.find((relationship) => digg(relationship, "name") == relationshipName);
+            if (!relationshipClassData) {
+                const modelName = digg(this.modelClassData(), "name");
+                const relationshipsList = relationships.map((relationship) => relationship.name).join(", ");
+                throw new Error(`Could not find the relation ${relationshipName} on the ${modelName} model: ${relationshipsList}`);
+            }
+            const relationshipType = digg(relationshipClassData, "collectionName");
+            if (relationshipName in this.relationshipsCache) {
+                throw new Error(`${relationshipName} has already been loaded`);
+            }
+            if (!relationshipClassData) {
+                throw new Error(`No relationship on ${digg(this.modelClassData(), "name")} by that name: ${relationshipName}`);
+            }
+            if (!relationshipData) {
+                this.relationshipsCache[relationshipName] = null;
+                this.relationships[relationshipName] = null;
+            }
+            else if (Array.isArray(relationshipData)) {
+                this.relationshipsCache[relationshipName] = [];
+                this.relationships[relationshipName] = [];
+                for (const relationshipId of relationshipData) {
+                    const model = preloaded.getModel(relationshipType, relationshipId);
+                    this.relationshipsCache[relationshipName].push(model);
+                    this.relationships[relationshipName].push(model);
+                }
+            }
+            else {
+                const model = preloaded.getModel(relationshipType, relationshipData);
+                this.relationshipsCache[relationshipName] = model;
+                this.relationships[relationshipName] = model;
+            }
+        }
+    }
+    /**
+     * @returns {number|string}
+     */
+    primaryKey() { return this.readAttributeUnderscore(this.modelClass().primaryKey()); }
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Attribute","AttributeNotLoadedError","CacheKeyGenerator","Collection","CommandsPool","Config","CustomError","digg","FormDataObjectizer","inflection","ModelName","NotLoadedError","objectToFormData","Reflection","Scope","Services","ValidationError","ValidationErrors","objectToUnderscore","object","newObject","key","underscoreKey","underscore","BaseModel","apiMakerType","attributes","modelClassData","result","attributeKey","attributeData","attribute","push","hasAttribute","attributeName","lowerCaseAttributeName","Error","newCustomEvent","validationErrors","CustomEvent","detail","sendValidationErrorsEvent","options","form","event","dispatchEvent","find","id","query","primaryKey","model","ransack","first","findOrCreateBy","findOrCreateByArgs","args","current","sendRequest","additional_data","additionalData","find_or_create_by_args","resource_name","modelName","modelClass","select","ransackableAssociations","relationships","reflections","relationshipData","ransackableAttributes","ransackableScopes","scopeData","scope","reflection","name","foundReflection","map","join","_token","csrfTokenElement","document","querySelector","getAttribute","constructor","changes","newRecord","isNewRecord","relationshipsCache","data","a","_readModelDataFromArgs","abilities","b","modelData","assignAttributes","newAttributes","newValue","attributeUnderscore","applyChange","deleteChange","isAttributeLoaded","oldValue","readAttribute","originalValue","can","givenAbilityName","abilityName","clone","cacheKey","isPersisted","keyParts","paramKey","updatedAt","getTime","uniqueKey","localCacheKey","cacheKeyGenerator","local","fullCacheKey","all","create","getAttributes","dataToUse","response","addCommand","save","command","collectionName","type","error","parseValidationErrors","_refreshModelFromResponse","createRaw","rawData","objectData","_objectDataFromGivenRawData","_refreshModelDataFromResponse","destroy","query_params","collection","params","success","handleResponseError","ensureAbilities","listOfAbilities","abilitiesToLoad","abilityInList","length","primaryKeyName","ransackParams","abilitiesParams","anotherModel","newAbilities","newAbility","Object","assign","identifierKey","_identifierKey","isAssociationLoaded","associationName","isAssociationLoadedUnderscore","associationNameUnderscore","isAssociationPresent","validation_errors","throwValidationError","humanAttributeName","keyName","i18n","getI18n","t","snakeCase","defaultValue","humanize","isAttributeChanged","attributeNameUnderscore","attributeNames","changedMethod","camelize","isChanged","keys","undefined","string","savedChangeToAttribute","previousModelData","changedMethodName","setNewModel","setNewModelData","relationshipName","relationshipCacheName","JSON","stringify","_isDateChanged","Date","parse","_isIntegerChanged","parseInt","_isStringChanged","oldConvertedValue","newConvertedValue","reload","preload","queryArgs","select_columns","selectColumns","update","saveRaw","updateRaw","newModel","Array","isArray","FormData","nodeName","formData","formDataFromObject","toObject","simple_model_errors","simpleModelErrors","isValid","isValidOnServer","valid","errors","preloadRelationship","markForDestruction","_markedForDestruction","markedForDestruction","uniqueKeyValue","min","max","randomBetween","Math","floor","random","_callCollectionCommand","commandArgs","formOrDataObject","_callMemberCommand","_postDataFromArgs","postData","serialize","readAttributeUnderscore","_isPresent","value","match","_loadBelongsToReflection","reflectionName","_readBelongsToReflection","loadedRelationships","modelClassName","_loadHasManyReflection","models","toArray","_loadHasOneReflection","_readHasOneReflection","preloadedRelationships","r","_readPreloadedRelationships","preloaded","relationshipClassData","relationship","relationshipsList","relationshipType","relationshipId","getModel"],"sources":["../src/base-model.js"],"sourcesContent":["import Attribute from \"./base-model/attribute\"\nimport AttributeNotLoadedError from \"./attribute-not-loaded-error\"\nimport CacheKeyGenerator from \"./cache-key-generator\"\nimport Collection from \"./collection\"\nimport CommandsPool from \"./commands-pool\"\nimport Config from \"./config\"\nimport CustomError from \"./custom-error\"\nimport {digg} from \"diggerize\"\nimport FormDataObjectizer from \"form-data-objectizer\"\nimport * as inflection from \"inflection\"\nimport ModelName from \"./model-name\"\nimport NotLoadedError from \"./not-loaded-error\"\nimport objectToFormData from \"object-to-formdata\"\nimport Reflection from \"./base-model/reflection\"\nimport Scope from \"./base-model/scope\"\nimport Services from \"./services\"\nimport ValidationError from \"./validation-error\"\nimport {ValidationErrors} from \"./validation-errors\"\n\nconst objectToUnderscore = (object) => {\n  const newObject = {}\n\n  for (const key in object) {\n    const underscoreKey = inflection.underscore(key)\n\n    newObject[underscoreKey] = object[key]\n  }\n\n  return newObject\n}\n\nexport default class BaseModel {\n  static apiMakerType = \"BaseModel\"\n\n  static attributes() {\n    const attributes = digg(this.modelClassData(), \"attributes\")\n    const result = []\n\n    for (const attributeKey in attributes) {\n      const attributeData = attributes[attributeKey]\n      const attribute = new Attribute(attributeData)\n\n      result.push(attribute)\n    }\n\n    return result\n  }\n\n  static hasAttribute(attributeName) {\n    const attributes = digg(this.modelClassData(), \"attributes\")\n    const lowerCaseAttributeName = inflection.underscore(attributeName)\n\n    if (lowerCaseAttributeName in attributes) return true\n\n    return false\n  }\n\n  static modelClassData() {\n    throw new Error(\"modelClassData should be overriden by child\")\n  }\n\n  static newCustomEvent = (validationErrors) => {\n    return new CustomEvent(\"validation-errors\", {detail: validationErrors})\n  }\n\n  static sendValidationErrorsEvent = (validationErrors, options) => {\n    if (options && options.form) {\n      const event = BaseModel.newCustomEvent(validationErrors)\n      options.form.dispatchEvent(event)\n    }\n  }\n\n  static async find(id) {\n    const query = {}\n\n    query[`${this.primaryKey()}_eq`] = id\n\n    const model = await this.ransack(query).first()\n\n    if (model) {\n      return model\n    } else {\n      throw new CustomError(\"Record not found\")\n    }\n  }\n\n  static async findOrCreateBy(findOrCreateByArgs, args = {}) {\n    const result = await Services.current().sendRequest(\"Models::FindOrCreateBy\", {\n      additional_data: args.additionalData,\n      find_or_create_by_args: findOrCreateByArgs,\n      resource_name: digg(this.modelClassData(), \"name\")\n    })\n    const model = digg(result, \"model\")\n\n    return model\n  }\n\n  static modelName() {\n    return new ModelName({modelClassData: this.modelClassData()})\n  }\n\n  static primaryKey() {\n    return digg(this.modelClassData(), \"primaryKey\")\n  }\n\n  static ransack(query = {}) {\n    return new Collection({modelClass: this}, {ransack: query})\n  }\n\n  static select(select) {\n    return this.ransack().select(select)\n  }\n\n  static ransackableAssociations() {\n    const relationships = digg(this.modelClassData(), \"ransackable_associations\")\n    const reflections = []\n\n    for (const relationshipData of relationships) {\n      reflections.push(new Reflection(relationshipData))\n    }\n\n    return reflections\n  }\n\n  static ransackableAttributes() {\n    const attributes = digg(this.modelClassData(), \"ransackable_attributes\")\n    const result = []\n\n    for (const attributeData of attributes) {\n      result.push(new Attribute(attributeData))\n    }\n\n    return result\n  }\n\n  static ransackableScopes() {\n    const ransackableScopes = digg(this.modelClassData(), \"ransackable_scopes\")\n    const result = []\n\n    for (const scopeData of ransackableScopes) {\n      const scope = new Scope(scopeData)\n\n      result.push(scope)\n    }\n\n    return result\n  }\n\n  static reflections() {\n    const relationships = digg(this.modelClassData(), \"relationships\")\n    const reflections = []\n\n    for (const relationshipData of relationships) {\n      const reflection = new Reflection(relationshipData)\n\n      reflections.push(reflection)\n    }\n\n    return reflections\n  }\n\n  static reflection(name) {\n    const foundReflection = this.reflections().find((reflection) => reflection.name() == name)\n\n    if (!foundReflection) {\n      throw new Error(`No such reflection: ${name} in ${this.reflections().map((reflection) => reflection.name()).join(\", \")}`)\n    }\n\n    return foundReflection\n  }\n\n  static _token() {\n    const csrfTokenElement = document.querySelector(\"meta[name='csrf-token']\")\n\n    if (csrfTokenElement) {\n      return csrfTokenElement.getAttribute(\"content\")\n    }\n  }\n\n  constructor(args = {}) {\n    this.changes = {}\n    this.newRecord = args.isNewRecord\n    this.relationshipsCache = {}\n    this.relationships = {}\n\n    if (args && args.data && args.data.a) {\n      this._readModelDataFromArgs(args)\n    } else if (args.a) {\n      this.abilities = args.b || {}\n      this.modelData = objectToUnderscore(args.a)\n    } else if (args) {\n      this.abilities = {}\n      this.modelData = objectToUnderscore(args)\n    } else {\n      this.abilities = {}\n      this.modelData = {}\n    }\n  }\n\n  assignAttributes(newAttributes) {\n    for (const key in newAttributes) {\n      const newValue = newAttributes[key]\n      const attributeUnderscore = inflection.underscore(key)\n\n      let applyChange = true\n      let deleteChange = false\n\n      if (this.isAttributeLoaded(key)) {\n        const oldValue = this.readAttribute(key)\n        const originalValue = this.modelData[attributeUnderscore]\n\n        if (newValue == oldValue) {\n          applyChange = false\n        } else if (newValue == originalValue) {\n          applyChange = false\n          deleteChange = true\n        }\n      }\n\n      if (applyChange) {\n        this.changes[attributeUnderscore] = newValue\n      } else if (deleteChange) {\n        delete this.changes[attributeUnderscore]\n      }\n    }\n  }\n\n  attributes() {\n    const result = {}\n\n    for (const key in this.modelData) {\n      result[key] = this.modelData[key]\n    }\n\n    for (const key in this.changes) {\n      result[key] = this.changes[key]\n    }\n\n    return result\n  }\n\n  can(givenAbilityName) {\n    const abilityName = inflection.underscore(givenAbilityName)\n\n    if (!(abilityName in this.abilities)) {\n      throw new Error(`Ability ${abilityName} hasn't been loaded for ${digg(this.modelClassData(), \"name\")}`)\n    }\n\n    return this.abilities[abilityName]\n  }\n\n  clone() {\n    const clone = new this.constructor()\n\n    clone.abilities = {...this.abilities}\n    clone.modelData = {...this.modelData}\n    clone.relationships = {...this.relationships}\n    clone.relationshipsCache = {...this.relationshipsCache}\n\n    return clone\n  }\n\n  cacheKey() {\n    if (this.isPersisted()) {\n      const keyParts = [\n        this.modelClassData().paramKey,\n        this.primaryKey()\n      ]\n\n      if (\"updated_at\" in this.modelData) {\n        const updatedAt = this.updatedAt()\n\n        if (typeof updatedAt != \"object\") {\n          throw new Error(`updatedAt wasn't an object: ${typeof updatedAt}`)\n        } else if (!(\"getTime\" in updatedAt)) {\n          throw new Error(`updatedAt didn't support getTime with class: ${updatedAt.constructor && updatedAt.constructor.name}`)\n        }\n\n        keyParts.push(`updatedAt-${this.updatedAt().getTime()}`)\n      }\n\n      return keyParts.join(\"-\")\n    } else {\n      return this.uniqueKey()\n    }\n  }\n\n  localCacheKey() {\n    const cacheKeyGenerator = new CacheKeyGenerator(this)\n\n    return cacheKeyGenerator.local()\n  }\n\n  fullCacheKey() {\n    const cacheKeyGenerator = new CacheKeyGenerator(this)\n\n    return cacheKeyGenerator.cacheKey()\n  }\n\n  static all() {\n    return this.ransack()\n  }\n\n  async create(attributes, options) {\n    if (attributes) this.assignAttributes(attributes)\n    const paramKey = this.modelClassData().paramKey\n    const modelData = this.getAttributes()\n    const dataToUse = {}\n    dataToUse[paramKey] = modelData\n    let response\n\n    try {\n      response = await CommandsPool.addCommand(\n        {\n          args: {\n            save: dataToUse\n          },\n          command: `${this.modelClassData().collectionName}-create`,\n          collectionName: this.modelClassData().collectionName,\n          primaryKey: this.primaryKey(),\n          type: \"create\"\n        },\n        {}\n      )\n    } catch (error) {\n      BaseModel.parseValidationErrors({error, model: this, options})\n      throw error\n    }\n\n    if (response.model) {\n      this._refreshModelFromResponse(response)\n      this.changes = {}\n    }\n\n    return {model: this, response}\n  }\n\n  async createRaw(rawData, options = {}) {\n    const objectData = BaseModel._objectDataFromGivenRawData(rawData, options)\n\n    let response\n\n    try {\n      response = await CommandsPool.addCommand(\n        {\n          args: {\n            save: objectData\n          },\n          command: `${this.modelClassData().collectionName}-create`,\n          collectionName: this.modelClassData().collectionName,\n          primaryKey: this.primaryKey(),\n          type: \"create\"\n        },\n        {}\n      )\n    } catch (error) {\n      BaseModel.parseValidationErrors({error, model: this, options})\n      throw error\n    }\n\n    if (response.model) {\n      this._refreshModelDataFromResponse(response)\n      this.changes = {}\n    }\n\n    return {model: this, response}\n  }\n\n  async destroy() {\n    const response = await CommandsPool.addCommand(\n      {\n        args: {query_params: this.collection && this.collection.params()},\n        command: `${this.modelClassData().collectionName}-destroy`,\n        collectionName: this.modelClassData().collectionName,\n        primaryKey: this.primaryKey(),\n        type: \"destroy\"\n      },\n      {}\n    )\n\n    if (response.success) {\n      if (response.model) {\n        this._refreshModelDataFromResponse(response)\n        this.changes = {}\n      }\n\n      return {model: this, response}\n    } else {\n      this.handleResponseError(response)\n    }\n  }\n\n  async ensureAbilities(listOfAbilities) {\n    // Populate an array with a list of abilities currently not loaded\n    const abilitiesToLoad = []\n\n    for (const abilityInList of listOfAbilities) {\n      if (!(abilityInList in this.abilities)) {\n        abilitiesToLoad.push(abilityInList)\n      }\n    }\n\n    // Load the missing abilities if any\n    if (abilitiesToLoad.length > 0) {\n      const primaryKeyName = this.constructor.primaryKey()\n      const ransackParams = {}\n      ransackParams[`${primaryKeyName}_eq`] = this.primaryKey()\n\n      const abilitiesParams = {}\n      abilitiesParams[digg(this.modelClassData(), \"name\")] = abilitiesToLoad\n\n      const anotherModel = await this.constructor\n        .ransack(ransackParams)\n        .abilities(abilitiesParams)\n        .first()\n\n      if (!anotherModel) {\n        throw new Error(`Could not look up the same model ${this.primaryKey()} with abilities: ${abilitiesToLoad.join(\", \")}`)\n      }\n\n      const newAbilities = anotherModel.abilities\n      for (const newAbility in newAbilities) {\n        this.abilities[newAbility] = newAbilities[newAbility]\n      }\n    }\n  }\n\n  getAttributes = () => Object.assign(this.modelData, this.changes)\n\n  handleResponseError(response) {\n    BaseModel.parseValidationErrors({model: this, response})\n    throw new new CustomError(\"Response wasn't successful\", {model: this, response})\n  }\n\n  identifierKey() {\n    if (!this._identifierKey) this._identifierKey = this.isPersisted() ? this.primaryKey() : this.uniqueKey()\n\n    return this._identifierKey\n  }\n\n  isAssociationLoaded = (associationName) => this.isAssociationLoadedUnderscore(inflection.underscore(associationName))\n  isAssociationLoadedUnderscore (associationNameUnderscore) {\n    if (associationNameUnderscore in this.relationshipsCache) return true\n    return false\n  }\n\n  isAssociationPresent(associationName) {\n    if (this.isAssociationLoaded(associationName)) return true\n    if (associationName in this.relationships) return true\n    return false\n  }\n\n  static parseValidationErrors({error, model, options}) {\n    if (!(error instanceof ValidationError)) return\n    if (!error.args.response.validation_errors) return\n\n    const validationErrors = new ValidationErrors({\n      model,\n      validationErrors: digg(error, \"args\", \"response\", \"validation_errors\")\n    })\n\n    BaseModel.sendValidationErrorsEvent(validationErrors, options)\n\n    if (!options || options.throwValidationError != false) {\n      throw error\n    }\n  }\n\n  static humanAttributeName(attributeName) {\n    const keyName = digg(this.modelClassData(), \"i18nKey\")\n    const i18n = Config.getI18n()\n\n    if (i18n) return i18n.t(`activerecord.attributes.${keyName}.${BaseModel.snakeCase(attributeName)}`, {defaultValue: attributeName})\n\n    return inflection.humanize(attributeName)\n  }\n\n  isAttributeChanged(attributeName) {\n    const attributeNameUnderscore = inflection.underscore(attributeName)\n    const attributeData = this.modelClassData().attributes.find((attribute) => digg(attribute, \"name\") == attributeNameUnderscore)\n\n    if (!attributeData) {\n      const attributeNames = this.modelClassData().attributes.map((attribute) => digg(attribute, \"name\"))\n\n      throw new Error(`Couldn't find an attribute by that name: \"${attributeName}\" in: ${attributeNames.join(\", \")}`)\n    }\n\n    if (!(attributeNameUnderscore in this.changes))\n      return false\n\n    const oldValue = this.modelData[attributeNameUnderscore]\n    const newValue = this.changes[attributeNameUnderscore]\n    const changedMethod = this[`_is${inflection.camelize(attributeData.type, true)}Changed`]\n\n    if (!changedMethod)\n      throw new Error(`Don't know how to handle type: ${attributeData.type}`)\n\n    return changedMethod(oldValue, newValue)\n  }\n\n  isChanged() {\n    const keys = Object.keys(this.changes)\n\n    if (keys.length > 0) {\n      return true\n    } else {\n      return false\n    }\n  }\n\n  isNewRecord() {\n    if (this.newRecord !== undefined) {\n      return this.newRecord\n    } else if (\"id\" in this.modelData && this.modelData.id) {\n      return false\n    } else {\n      return true\n    }\n  }\n\n  isPersisted = () => !this.isNewRecord()\n\n  static snakeCase = (string) => inflection.underscore(string)\n\n  savedChangeToAttribute(attributeName) {\n    if (!this.previousModelData)\n      return false\n\n    const attributeNameUnderscore = inflection.underscore(attributeName)\n    const attributeData = this.modelClassData().attributes.find((attribute) => attribute.name == attributeNameUnderscore)\n\n    if (!attributeData) {\n      const attributeNames = this.modelClassData().attributes.map((attribute) => attribute.name)\n      throw new Error(`Couldn't find an attribute by that name: \"${attributeName}\" in: ${attributeNames.join(\", \")}`)\n    }\n\n    if (!(attributeNameUnderscore in this.previousModelData))\n      return true\n\n    const oldValue = this.previousModelData[attributeNameUnderscore]\n    const newValue = this.modelData[attributeNameUnderscore]\n    const changedMethodName = `_is${inflection.camelize(attributeData.type)}Changed`\n    const changedMethod = this[changedMethodName]\n\n    if (!changedMethod)\n      throw new Error(`Don't know how to handle type: ${attributeData.type}`)\n\n    return changedMethod(oldValue, newValue)\n  }\n\n  setNewModel(model) {\n    this.setNewModelData(model)\n\n    for(const relationshipName in model.relationships) {\n      this.relationships[relationshipName] = model.relationships[relationshipName]\n    }\n\n    for(const relationshipCacheName in model.relationshipsCache) {\n      this.relationshipsCache[relationshipCacheName] = model.relationshipsCache[name]\n    }\n  }\n\n  setNewModelData(model) {\n    if (!(\"modelData\" in model)) throw new Error(`No modelData in model: ${JSON.stringify(model)}`)\n\n    this.previousModelData = Object.assign({}, digg(this, \"modelData\"))\n\n    for(const attributeName in model.modelData) {\n      this.modelData[attributeName] = model.modelData[attributeName]\n    }\n  }\n\n  _isDateChanged(oldValue, newValue) {\n    if (Date.parse(oldValue) != Date.parse(newValue))\n      return true\n  }\n\n  _isIntegerChanged(oldValue, newValue) {\n    if (parseInt(oldValue, 10) != parseInt(newValue, 10))\n      return true\n  }\n\n  _isStringChanged (oldValue, newValue) {\n    const oldConvertedValue = `${oldValue}`\n    const newConvertedValue = `${newValue}`\n\n    if (oldConvertedValue != newConvertedValue)\n      return true\n  }\n\n  modelClassData = () => this.constructor.modelClassData()\n\n  async reload() {\n    const params = this.collection && this.collection.params()\n    const ransackParams = {}\n    ransackParams[`${this.constructor.primaryKey()}_eq`] = this.primaryKey()\n\n    let query = this.constructor.ransack(ransackParams)\n\n    if (params) {\n      if (params.preload) {\n        query.queryArgs.preload = params.preload\n      }\n\n      if (params.select) {\n        query.queryArgs.select = params.select\n      }\n\n      if (params.select_columns) {\n        query.queryArgs.selectColumns = params.select_columns\n      }\n    }\n\n    const model = await query.first()\n    this.setNewModel(model)\n    this.changes = {}\n  }\n\n  save() {\n    if (this.isNewRecord()) {\n      return this.create()\n    } else {\n      return this.update()\n    }\n  }\n\n  saveRaw(rawData, options = {}) {\n    if (this.isNewRecord()) {\n      return this.createRaw(rawData, options)\n    } else {\n      return this.updateRaw(rawData, options)\n    }\n  }\n\n  async update(newAttributes, options) {\n    if (newAttributes) {\n      this.assignAttributes(newAttributes)\n    }\n\n    if (Object.keys(this.changes).length == 0) {\n      return {model: this}\n    }\n\n    const paramKey = this.modelClassData().paramKey\n    const modelData = this.changes\n    const dataToUse = {}\n    dataToUse[paramKey] = modelData\n    let response\n\n    try {\n      response = await CommandsPool.addCommand(\n        {\n          args: {\n            query_params: this.collection && this.collection.params(),\n            save: dataToUse\n          },\n          command: `${this.modelClassData().collectionName}-update`,\n          collectionName: this.modelClassData().collectionName,\n          primaryKey: this.primaryKey(),\n          type: \"update\"\n        },\n        {}\n      )\n    } catch (error) {\n      BaseModel.parseValidationErrors({error, model: this, options})\n      throw error\n    }\n\n    if (response.success) {\n      if (response.model) {\n        this._refreshModelFromResponse(response)\n        this.changes = {}\n      }\n\n      return {response, model: this}\n    } else {\n      this.handleResponseError(response)\n    }\n  }\n\n  _refreshModelFromResponse(response) {\n    let newModel = digg(response, \"model\")\n\n    if (Array.isArray(newModel)) newModel = newModel[0]\n\n    this.setNewModel(newModel)\n  }\n\n  _refreshModelDataFromResponse(response) {\n    let newModel = digg(response, \"model\")\n\n    if (Array.isArray(newModel)) newModel = newModel[0]\n\n    this.setNewModelData(newModel)\n  }\n\n  static _objectDataFromGivenRawData(rawData, options) {\n    if (rawData instanceof FormData || rawData.nodeName == \"FORM\") {\n      const formData = FormDataObjectizer.formDataFromObject(rawData, options)\n\n      return FormDataObjectizer.toObject(formData)\n    }\n\n    return rawData\n  }\n\n  async updateRaw(rawData, options = {}) {\n    const objectData = BaseModel._objectDataFromGivenRawData(rawData, options)\n    let response\n\n    try {\n      response = await CommandsPool.addCommand(\n        {\n          args: {\n            query_params: this.collection && this.collection.params(),\n            save: objectData,\n            simple_model_errors: options?.simpleModelErrors\n          },\n          command: `${this.modelClassData().collectionName}-update`,\n          collectionName: this.modelClassData().collectionName,\n          primaryKey: this.primaryKey(),\n          type: \"update\"\n        },\n        {}\n      )\n    } catch (error) {\n      BaseModel.parseValidationErrors({error, model: this, options})\n      throw error\n    }\n\n    if (response.model) {\n      this._refreshModelFromResponse(response)\n      this.changes = {}\n    }\n\n    return {response, model: this}\n  }\n\n  isValid() {\n    throw new Error(\"Not implemented yet\")\n  }\n\n  async isValidOnServer() {\n    const modelData = this.getAttributes()\n    const paramKey = this.modelClassData().paramKey\n    const dataToUse = {}\n    dataToUse[paramKey] = modelData\n\n    const response = await CommandsPool.addCommand(\n      {\n        args: {\n          save: dataToUse\n        },\n        command: `${this.modelClassData().collectionName}-valid`,\n        collectionName: this.modelClassData().collectionName,\n        primaryKey: this.primaryKey(),\n        type: \"valid\"\n      },\n      {}\n    )\n\n    return {valid: response.valid, errors: response.errors}\n  }\n\n  modelClass = () => this.constructor\n\n  preloadRelationship(relationshipName, model) {\n    this.relationshipsCache[BaseModel.snakeCase(relationshipName)] = model\n    this.relationships[BaseModel.snakeCase(relationshipName)] = model\n  }\n\n  markForDestruction() {\n    this._markedForDestruction = true\n  }\n\n  markedForDestruction = () => this._markedForDestruction\n\n  uniqueKey() {\n    if (!this.uniqueKeyValue) {\n      const min = 5000000000000000\n      const max = 9007199254740991\n      const randomBetween = Math.floor(Math.random() * (max - min + 1) + min)\n      this.uniqueKeyValue = randomBetween\n    }\n\n    return this.uniqueKeyValue\n  }\n\n  static async _callCollectionCommand(args, commandArgs) {\n    const formOrDataObject = args.args\n\n    try {\n      return await CommandsPool.addCommand(args, commandArgs)\n    } catch (error) {\n      let form\n\n      if (commandArgs.form) {\n        form = commandArgs.form\n      } else if (formOrDataObject?.nodeName == \"FORM\") {\n        form = formOrDataObject\n      }\n\n      if (form) BaseModel.parseValidationErrors({error, options: {form}})\n\n      throw error\n    }\n  }\n\n  _callMemberCommand = (args, commandArgs) => CommandsPool.addCommand(args, commandArgs)\n\n  static _postDataFromArgs(args) {\n    let postData\n\n    if (args) {\n      if (args instanceof FormData) {\n        postData = args\n      } else {\n        postData = objectToFormData.serialize(args, {}, null, \"args\")\n      }\n    } else {\n      postData = new FormData()\n    }\n\n    return postData\n  }\n\n  readAttribute(attributeName) {\n    const attributeNameUnderscore = inflection.underscore(attributeName)\n\n    return this.readAttributeUnderscore(attributeNameUnderscore)\n  }\n\n  readAttributeUnderscore(attributeName) {\n    if (attributeName in this.changes) {\n      return this.changes[attributeName]\n    } else if (attributeName in this.modelData) {\n      return this.modelData[attributeName]\n    } else if (this.isNewRecord()) {\n      // Return null if this is a new record and the attribute name is a recognized attribute\n      const attributes = digg(this.modelClassData(), \"attributes\")\n\n      if (attributeName in attributes) return null\n    }\n\n    if (this.isPersisted()) {\n      throw new AttributeNotLoadedError(`No such attribute: ${digg(this.modelClassData(), \"name\")}#${attributeName}: ${JSON.stringify(this.modelData)}`)\n    }\n  }\n\n  isAttributeLoaded(attributeName) {\n    const attributeNameUnderscore = inflection.underscore(attributeName)\n\n    if (attributeNameUnderscore in this.changes) return true\n    if (attributeNameUnderscore in this.modelData) return true\n    return false\n  }\n\n  _isPresent(value) {\n    if (!value) {\n      return false\n    } else if (typeof value == \"string\" && value.match(/^\\s*$/)) {\n      return false\n    }\n\n    return true\n  }\n\n  async _loadBelongsToReflection(args, queryArgs = {}) {\n    if (args.reflectionName in this.relationships) {\n      return this.relationships[args.reflectionName]\n    } else if (args.reflectionName in this.relationshipsCache) {\n      return this.relationshipsCache[args.reflectionName]\n    } else {\n      const collection = new Collection(args, queryArgs)\n      const model = await collection.first()\n      this.relationshipsCache[args.reflectionName] = model\n      return model\n    }\n  }\n\n  _readBelongsToReflection({reflectionName}) {\n    if (reflectionName in this.relationships) {\n      return this.relationships[reflectionName]\n    } else if (reflectionName in this.relationshipsCache) {\n      return this.relationshipsCache[reflectionName]\n    }\n\n    if (this.isNewRecord()) return null\n\n    const loadedRelationships = Object.keys(this.relationshipsCache)\n    const modelClassName = digg(this.modelClassData(), \"name\")\n\n    throw new NotLoadedError(`${modelClassName}#${reflectionName} hasn't been loaded yet. Only these were loaded: ${loadedRelationships.join(\", \")}`)\n  }\n\n  async _loadHasManyReflection(args, queryArgs = {}) {\n    if (args.reflectionName in this.relationships) {\n      return this.relationships[args.reflectionName]\n    } else if (args.reflectionName in this.relationshipsCache) {\n      return this.relationshipsCache[args.reflectionName]\n    }\n\n    const collection = new Collection(args, queryArgs)\n    const models = await collection.toArray()\n\n    this.relationshipsCache[args.reflectionName] = models\n\n    return models\n  }\n\n  async _loadHasOneReflection(args, queryArgs = {}) {\n    if (args.reflectionName in this.relationships) {\n      return this.relationships[args.reflectionName]\n    } else if (args.reflectionName in this.relationshipsCache) {\n      return this.relationshipsCache[args.reflectionName]\n    } else {\n      const collection = new Collection(args, queryArgs)\n      const model = await collection.first()\n\n      this.relationshipsCache[args.reflectionName] = model\n\n      return model\n    }\n  }\n\n  _readHasOneReflection({reflectionName}) {\n    if (reflectionName in this.relationships) {\n      return this.relationships[reflectionName]\n    } else if (reflectionName in this.relationshipsCache) {\n      return this.relationshipsCache[reflectionName]\n    }\n\n    if (this.isNewRecord()) {\n      return null\n    }\n\n    const loadedRelationships = Object.keys(this.relationshipsCache)\n    const modelClassName = digg(this.modelClassData(), \"name\")\n\n    throw new NotLoadedError(`${modelClassName}#${reflectionName} hasn't been loaded yet. Only these were loaded: ${loadedRelationships.join(\", \")}`)\n  }\n\n  _readModelDataFromArgs(args) {\n    this.abilities = args.data.b || {}\n    this.collection = args.collection\n    this.modelData = objectToUnderscore(args.data.a)\n    this.preloadedRelationships = args.data.r\n  }\n\n  _readPreloadedRelationships(preloaded) {\n    if (!this.preloadedRelationships) {\n      return\n    }\n\n    const relationships = digg(this.modelClassData(), \"relationships\")\n\n    for (const relationshipName in this.preloadedRelationships) {\n      const relationshipData = this.preloadedRelationships[relationshipName]\n      const relationshipClassData = relationships.find((relationship) => digg(relationship, \"name\") == relationshipName)\n\n      if (!relationshipClassData) {\n        const modelName = digg(this.modelClassData(), \"name\")\n        const relationshipsList = relationships.map((relationship) => relationship.name).join(\", \")\n\n        throw new Error(`Could not find the relation ${relationshipName} on the ${modelName} model: ${relationshipsList}`)\n      }\n\n      const relationshipType = digg(relationshipClassData, \"collectionName\")\n\n      if (relationshipName in this.relationshipsCache) {\n        throw new Error(`${relationshipName} has already been loaded`)\n      }\n\n      if (!relationshipClassData) {\n        throw new Error(`No relationship on ${digg(this.modelClassData(), \"name\")} by that name: ${relationshipName}`)\n      }\n\n      if (!relationshipData) {\n        this.relationshipsCache[relationshipName] = null\n        this.relationships[relationshipName] = null\n      } else if (Array.isArray(relationshipData)) {\n        this.relationshipsCache[relationshipName] = []\n        this.relationships[relationshipName] = []\n\n        for (const relationshipId of relationshipData) {\n          const model = preloaded.getModel(relationshipType, relationshipId)\n\n          this.relationshipsCache[relationshipName].push(model)\n          this.relationships[relationshipName].push(model)\n        }\n      } else {\n        const model = preloaded.getModel(relationshipType, relationshipData)\n\n        this.relationshipsCache[relationshipName] = model\n        this.relationships[relationshipName] = model\n      }\n    }\n  }\n\n  primaryKey = () => this.readAttributeUnderscore(this.constructor.primaryKey())\n}\n"],"mappings":"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","ignoreList":[]}
+//# sourceMappingURL=base-model.js.map