@kaspernj/api-maker 1.0.2011 → 1.0.2013

package/src/{base-model.mjs → base-model.js}

@@ -1,20 +1,61 @@
-import AttributeNotLoadedError from "./attribute-not-loaded-error.mjs"
-import Collection from "./collection.mjs"
-import CommandsPool from "./commands-pool.mjs"
-import Config from "@kaspernj/api-maker/src/config.mjs"
-import CustomError from "./custom-error.mjs"
+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 inflection from "inflection"
-import ModelName from "./model-name.mjs"
-import NotLoadedError from "./not-loaded-error.mjs"
+import * as inflection from "inflection"
+import ModelName from "./model-name"
+import NotLoadedError from "./not-loaded-error"
 import objectToFormData from "object-to-formdata"
-import Services from "./services.mjs"
-import ValidationError from "./validation-error.mjs"
-import {ValidationErrors} from "./validation-errors.mjs"
+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"
 
-class BaseModel {
-  static modelClassData () {
+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")
   }
 
@@ -29,10 +70,10 @@ class BaseModel {
     }
   }
 
-  static async find (id) {
-    const primaryKeyName = this.modelClassData().primaryKey
+  static async find(id) {
     const query = {}
-    query[`${primaryKeyName}_eq`] = id
+
+    query[`${this.primaryKey()}_eq`] = id
 
     const model = await this.ransack(query).first()
 
@@ -43,7 +84,7 @@ class BaseModel {
     }
   }
 
-  static async findOrCreateBy (findOrCreateByArgs, args = {}) {
+  static async findOrCreateBy(findOrCreateByArgs, args = {}) {
     const result = await Services.current().sendRequest("Models::FindOrCreateBy", {
       additional_data: args.additionalData,
       find_or_create_by_args: findOrCreateByArgs,
@@ -54,43 +95,119 @@ class BaseModel {
     return model
   }
 
-  static modelName () {
+  static modelName() {
     return new ModelName({modelClassData: this.modelClassData()})
   }
 
-  static ransack (query = {}) {
+  static primaryKey() {
+    return digg(this.modelClassData(), "primaryKey")
+  }
+
+  static ransack(query = {}) {
     return new Collection({modelClass: this}, {ransack: query})
   }
 
-  constructor (args = {}) {
+  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 = args.a
+      this.modelData = objectToUnderscore(args.a)
     } else if (args) {
       this.abilities = {}
-      this.modelData = args
+      this.modelData = objectToUnderscore(args)
     } else {
       this.abilities = {}
       this.modelData = {}
     }
   }
 
-  assignAttributes (newAttributes) {
+  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.readAttributeUnderscore(key)
-        const originalValue = this.modelData[key]
+        const oldValue = this.readAttribute(key)
+        const originalValue = this.modelData[attributeUnderscore]
 
         if (newValue == oldValue) {
           applyChange = false
@@ -101,18 +218,28 @@ class BaseModel {
       }
 
       if (applyChange) {
-        this.changes[key] = newValue
+        this.changes[attributeUnderscore] = newValue
       } else if (deleteChange) {
-        delete this.changes[key]
+        delete this.changes[attributeUnderscore]
       }
     }
   }
 
-  attributes () {
-    return digg(this, "modelData")
+  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) {
+  can(givenAbilityName) {
     const abilityName = inflection.underscore(givenAbilityName)
 
     if (!(abilityName in this.abilities)) {
@@ -122,17 +249,18 @@ class BaseModel {
     return this.abilities[abilityName]
   }
 
-  clone () {
+  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 () {
+  cacheKey() {
     if (this.isPersisted()) {
       const keyParts = [
         this.modelClassData().paramKey,
@@ -157,11 +285,23 @@ class BaseModel {
     }
   }
 
-  static all () {
+  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) {
+  async create(attributes, options) {
     if (attributes) this.assignAttributes(attributes)
     const paramKey = this.modelClassData().paramKey
     const modelData = this.getAttributes()
@@ -195,7 +335,7 @@ class BaseModel {
     return {model: this, response}
   }
 
-  async createRaw (rawData, options = {}) {
+  async createRaw(rawData, options = {}) {
     const objectData = BaseModel._objectDataFromGivenRawData(rawData, options)
 
     let response
@@ -226,7 +366,7 @@ class BaseModel {
     return {model: this, response}
   }
 
-  async destroy () {
+  async destroy() {
     const response = await CommandsPool.addCommand(
       {
         args: {query_params: this.collection && this.collection.params()},
@@ -250,7 +390,7 @@ class BaseModel {
     }
   }
 
-  async ensureAbilities (listOfAbilities) {
+  async ensureAbilities(listOfAbilities) {
     // Populate an array with a list of abilities currently not loaded
     const abilitiesToLoad = []
 
@@ -262,7 +402,7 @@ class BaseModel {
 
     // Load the missing abilities if any
     if (abilitiesToLoad.length > 0) {
-      const primaryKeyName = this.modelClassData().primaryKey
+      const primaryKeyName = this.constructor.primaryKey()
       const ransackParams = {}
       ransackParams[`${primaryKeyName}_eq`] = this.primaryKey()
 
@@ -285,27 +425,32 @@ class BaseModel {
     }
   }
 
-  getAttributes () {
-    return Object.assign(this.modelData, this.changes)
-  }
+  getAttributes = () => Object.assign(this.modelData, this.changes)
 
-  handleResponseError (response) {
+  handleResponseError(response) {
     BaseModel.parseValidationErrors({model: this, response})
     throw new new CustomError("Response wasn't successful", {model: this, response})
   }
 
-  identifierKey () {
+  identifierKey() {
     if (!this._identifierKey) this._identifierKey = this.isPersisted() ? this.primaryKey() : this.uniqueKey()
 
     return this._identifierKey
   }
 
-  isAssociationLoaded (associationName) {
-    if (associationName in this.relationshipsCache) return true
+  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}) {
+  static parseValidationErrors({error, model, options}) {
     if (!(error instanceof ValidationError)) return
     if (!error.args.response.validation_errors) return
 
@@ -317,11 +462,11 @@ class BaseModel {
     BaseModel.sendValidationErrorsEvent(validationErrors, options)
 
     if (!options || options.throwValidationError != false) {
-      throw new ValidationError(validationErrors, digg(error, "args"))
+      throw error
     }
   }
 
-  static humanAttributeName (attributeName) {
+  static humanAttributeName(attributeName) {
     const keyName = digg(this.modelClassData(), "i18nKey")
     const i18n = Config.getI18n()
 
@@ -330,7 +475,7 @@ class BaseModel {
     return inflection.humanize(attributeName)
   }
 
-  isAttributeChanged (attributeName) {
+  isAttributeChanged(attributeName) {
     const attributeNameUnderscore = inflection.underscore(attributeName)
     const attributeData = this.modelClassData().attributes.find((attribute) => digg(attribute, "name") == attributeNameUnderscore)
 
@@ -353,7 +498,7 @@ class BaseModel {
     return changedMethod(oldValue, newValue)
   }
 
-  isChanged () {
+  isChanged() {
     const keys = Object.keys(this.changes)
 
     if (keys.length > 0) {
@@ -363,7 +508,7 @@ class BaseModel {
     }
   }
 
-  isNewRecord () {
+  isNewRecord() {
     if (this.newRecord !== undefined) {
       return this.newRecord
     } else if ("id" in this.modelData && this.modelData.id) {
@@ -373,15 +518,11 @@ class BaseModel {
     }
   }
 
-  isPersisted () {
-    return !this.isNewRecord()
-  }
+  isPersisted = () => !this.isNewRecord()
 
-  static snakeCase (string) {
-    return inflection.underscore(string)
-  }
+  static snakeCase = (string) => inflection.underscore(string)
 
-  savedChangeToAttribute (attributeName) {
+  savedChangeToAttribute(attributeName) {
     if (!this.previousModelData)
       return false
 
@@ -407,24 +548,34 @@ class BaseModel {
     return changedMethod(oldValue, newValue)
   }
 
-  setNewModel (model) {
+  setNewModel(model) {
     this.setNewModelData(model)
-    this.relationshipsCache = digg(model, "relationshipsCache")
+
+    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) {
+  setNewModelData(model) {
     if (!("modelData" in model)) throw new Error(`No modelData in model: ${JSON.stringify(model)}`)
 
-    this.previousModelData = digg(this, "modelData")
-    this.modelData = digg(model, "modelData")
+    this.previousModelData = Object.assign({}, digg(this, "modelData"))
+
+    for(const attributeName in model.modelData) {
+      this.modelData[attributeName] = model.modelData[attributeName]
+    }
   }
 
-  _isDateChanged (oldValue, newValue) {
+  _isDateChanged(oldValue, newValue) {
     if (Date.parse(oldValue) != Date.parse(newValue))
       return true
   }
 
-  _isIntegerChanged (oldValue, newValue) {
+  _isIntegerChanged(oldValue, newValue) {
     if (parseInt(oldValue, 10) != parseInt(newValue, 10))
       return true
   }
@@ -437,15 +588,12 @@ class BaseModel {
       return true
   }
 
-  modelClassData () {
-    return this.constructor.modelClassData()
-  }
+  modelClassData = () => this.constructor.modelClassData()
 
-  async reload () {
+  async reload() {
     const params = this.collection && this.collection.params()
-    const primaryKeyName = this.modelClassData().primaryKey
     const ransackParams = {}
-    ransackParams[`${primaryKeyName}_eq`] = this.primaryKey()
+    ransackParams[`${this.constructor.primaryKey()}_eq`] = this.primaryKey()
 
     let query = this.constructor.ransack(ransackParams)
 
@@ -468,7 +616,7 @@ class BaseModel {
     this.changes = {}
   }
 
-  save () {
+  save() {
     if (this.isNewRecord()) {
       return this.create()
     } else {
@@ -476,7 +624,7 @@ class BaseModel {
     }
   }
 
-  saveRaw (rawData, options = {}) {
+  saveRaw(rawData, options = {}) {
     if (this.isNewRecord()) {
       return this.createRaw(rawData, options)
     } else {
@@ -484,9 +632,10 @@ class BaseModel {
     }
   }
 
-  async update (newAttributes, options) {
-    if (newAttributes)
+  async update(newAttributes, options) {
+    if (newAttributes) {
       this.assignAttributes(newAttributes)
+    }
 
     if (Object.keys(this.changes).length == 0) {
       return {model: this}
@@ -529,7 +678,7 @@ class BaseModel {
     }
   }
 
-  _refreshModelFromResponse (response) {
+  _refreshModelFromResponse(response) {
     let newModel = digg(response, "model")
 
     if (Array.isArray(newModel)) newModel = newModel[0]
@@ -537,7 +686,7 @@ class BaseModel {
     this.setNewModel(newModel)
   }
 
-  _refreshModelDataFromResponse (response) {
+  _refreshModelDataFromResponse(response) {
     let newModel = digg(response, "model")
 
     if (Array.isArray(newModel)) newModel = newModel[0]
@@ -545,7 +694,7 @@ class BaseModel {
     this.setNewModelData(newModel)
   }
 
-  static _objectDataFromGivenRawData (rawData, options) {
+  static _objectDataFromGivenRawData(rawData, options) {
     if (rawData instanceof FormData || rawData.nodeName == "FORM") {
       const formData = FormDataObjectizer.formDataFromObject(rawData, options)
 
@@ -555,7 +704,7 @@ class BaseModel {
     return rawData
   }
 
-  async updateRaw (rawData, options = {}) {
+  async updateRaw(rawData, options = {}) {
     const objectData = BaseModel._objectDataFromGivenRawData(rawData, options)
     let response
 
@@ -564,7 +713,8 @@ class BaseModel {
         {
           args: {
             query_params: this.collection && this.collection.params(),
-            save: objectData
+            save: objectData,
+            simple_model_errors: options?.simpleModelErrors
           },
           command: `${this.modelClassData().collectionName}-update`,
           collectionName: this.modelClassData().collectionName,
@@ -586,11 +736,11 @@ class BaseModel {
     return {response, model: this}
   }
 
-  isValid () {
+  isValid() {
     throw new Error("Not implemented yet")
   }
 
-  async isValidOnServer () {
+  async isValidOnServer() {
     const modelData = this.getAttributes()
     const paramKey = this.modelClassData().paramKey
     const dataToUse = {}
@@ -612,15 +762,20 @@ class BaseModel {
     return {valid: response.valid, errors: response.errors}
   }
 
-  modelClass () {
-    return this.constructor
-  }
+  modelClass = () => this.constructor
 
-  preloadRelationship (relationshipName, model) {
+  preloadRelationship(relationshipName, model) {
     this.relationshipsCache[BaseModel.snakeCase(relationshipName)] = model
+    this.relationships[BaseModel.snakeCase(relationshipName)] = model
   }
 
-  uniqueKey () {
+  markForDestruction() {
+    this._markedForDestruction = true
+  }
+
+  markedForDestruction = () => this._markedForDestruction
+
+  uniqueKey() {
     if (!this.uniqueKeyValue) {
       const min = 5000000000000000
       const max = 9007199254740991
@@ -631,25 +786,29 @@ class BaseModel {
     return this.uniqueKeyValue
   }
 
-  static async _callCollectionCommand (args, commandArgs) {
+  static async _callCollectionCommand(args, commandArgs) {
     const formOrDataObject = args.args
 
     try {
       return await CommandsPool.addCommand(args, commandArgs)
     } catch (error) {
-      if (formOrDataObject?.nodeName == "FORM") {
-        BaseModel.parseValidationErrors({error, options: {form: formOrDataObject}})
+      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) {
-    return CommandsPool.addCommand(args, commandArgs)
-  }
+  _callMemberCommand = (args, commandArgs) => CommandsPool.addCommand(args, commandArgs)
 
-  static _postDataFromArgs (args) {
+  static _postDataFromArgs(args) {
     let postData
 
     if (args) {
@@ -665,13 +824,13 @@ class BaseModel {
     return postData
   }
 
-  readAttribute (attributeName) {
+  readAttribute(attributeName) {
     const attributeNameUnderscore = inflection.underscore(attributeName)
 
     return this.readAttributeUnderscore(attributeNameUnderscore)
   }
 
-  readAttributeUnderscore (attributeName) {
+  readAttributeUnderscore(attributeName) {
     if (attributeName in this.changes) {
       return this.changes[attributeName]
     } else if (attributeName in this.modelData) {
@@ -688,7 +847,7 @@ class BaseModel {
     }
   }
 
-  isAttributeLoaded (attributeName) {
+  isAttributeLoaded(attributeName) {
     const attributeNameUnderscore = inflection.underscore(attributeName)
 
     if (attributeNameUnderscore in this.changes) return true
@@ -696,7 +855,7 @@ class BaseModel {
     return false
   }
 
-  _isPresent (value) {
+  _isPresent(value) {
     if (!value) {
       return false
     } else if (typeof value == "string" && value.match(/^\s*$/)) {
@@ -706,8 +865,10 @@ class BaseModel {
     return true
   }
 
-  async _loadBelongsToReflection (args, queryArgs = {}) {
-    if (args.reflectionName in this.relationshipsCache) {
+  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)
@@ -717,22 +878,25 @@ class BaseModel {
     }
   }
 
-  _readBelongsToReflection ({reflectionName}) {
-    if (!(reflectionName in this.relationshipsCache)) {
-      if (this.isNewRecord())
-        return null
+  _readBelongsToReflection({reflectionName}) {
+    if (reflectionName in this.relationships) {
+      return this.relationships[reflectionName]
+    } else if (reflectionName in this.relationshipsCache) {
+      return this.relationshipsCache[reflectionName]
+    }
 
-      const loadedRelationships = Object.keys(this.relationshipsCache)
-      const modelClassName = digg(this.modelClassData(), "name")
+    if (this.isNewRecord()) return null
 
-      throw new NotLoadedError(`${modelClassName}#${reflectionName} hasn't been loaded yet. Only these were loaded: ${loadedRelationships.join(", ")}`)
-    }
+    const loadedRelationships = Object.keys(this.relationshipsCache)
+    const modelClassName = digg(this.modelClassData(), "name")
 
-    return this.relationshipsCache[reflectionName]
+    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.relationshipsCache) {
+  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]
     }
 
@@ -744,8 +908,10 @@ class BaseModel {
     return models
   }
 
-  async _loadHasOneReflection (args, queryArgs = {}) {
-    if (args.reflectionName in this.relationshipsCache) {
+  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)
@@ -757,28 +923,31 @@ class BaseModel {
     }
   }
 
-  _readHasOneReflection ({reflectionName}) {
-    if (!(reflectionName in this.relationshipsCache)) {
-      if (this.isNewRecord())
-        return null
-
-      const loadedRelationships = Object.keys(this.relationshipsCache)
-      const modelClassName = digg(this.modelClassData(), "name")
+  _readHasOneReflection({reflectionName}) {
+    if (reflectionName in this.relationships) {
+      return this.relationships[reflectionName]
+    } else if (reflectionName in this.relationshipsCache) {
+      return this.relationshipsCache[reflectionName]
+    }
 
-      throw new NotLoadedError(`${modelClassName}#${reflectionName} hasn't been loaded yet. Only these were loaded: ${loadedRelationships.join(", ")}`)
+    if (this.isNewRecord()) {
+      return null
     }
 
-    return this.relationshipsCache[reflectionName]
+    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) {
+  _readModelDataFromArgs(args) {
     this.abilities = args.data.b || {}
     this.collection = args.collection
-    this.modelData = args.data.a
+    this.modelData = objectToUnderscore(args.data.a)
     this.preloadedRelationships = args.data.r
   }
 
-  _readPreloadedRelationships (preloaded) {
+  _readPreloadedRelationships(preloaded) {
     if (!this.preloadedRelationships) {
       return
     }
@@ -808,36 +977,25 @@ class BaseModel {
 
       if (!relationshipData) {
         this.relationshipsCache[relationshipName] = null
+        this.relationships[relationshipName] = null
       } else if (Array.isArray(relationshipData)) {
-        const result = []
+        this.relationshipsCache[relationshipName] = []
+        this.relationships[relationshipName] = []
 
         for (const relationshipId of relationshipData) {
           const model = preloaded.getModel(relationshipType, relationshipId)
 
-          result.push(model)
+          this.relationshipsCache[relationshipName].push(model)
+          this.relationships[relationshipName].push(model)
         }
-
-        this.relationshipsCache[relationshipName] = result
       } else {
         const model = preloaded.getModel(relationshipType, relationshipData)
+
         this.relationshipsCache[relationshipName] = model
+        this.relationships[relationshipName] = model
       }
     }
   }
 
-  primaryKey () {
-    return this.readAttributeUnderscore(digg(this.modelClassData(), "primaryKey"))
-  }
-
-  static _token () {
-    const csrfTokenElement = document.querySelector("meta[name='csrf-token']")
-
-    if (csrfTokenElement) {
-      return csrfTokenElement.getAttribute("content")
-    }
-  }
+  primaryKey = () => this.readAttributeUnderscore(this.constructor.primaryKey())
 }
-
-BaseModel.apiMakerType = "BaseModel"
-
-export default BaseModel