@kaspernj/api-maker 1.0.445 → 1.0.447

package/build/base-model.js

@@ -0,0 +1,828 @@
+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 { digg } from "diggerize";
+import FormDataObjectizer from "form-data-objectizer";
+import * as inflection from "inflection";
+import ModelName from "./model-name";
+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;
+};
+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
+    };
+  }
+  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.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.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());
+}
+//# 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":[]}