@kaspernj/api-maker 1.0.268 → 1.0.270

package/package.json

@@ -16,7 +16,7 @@
     ]
   },
   "name": "@kaspernj/api-maker",
-  "version": "1.0.268",
+  "version": "1.0.270",
   "type": "module",
   "description": "",
   "main": "index.js",
@@ -52,6 +52,7 @@
     "on-location-changed": ">= 1.0.7",
     "qs": ">= 6.9.3",
     "replaceall": ">= 0.1.6",
+    "spark-md5": "^3.0.2",
     "strftime": ">= 0.10.0",
     "uniqunize": "^1.0.1",
     "wake-event": ">= 0.0.1"

package/src/base-model.mjs

@@ -1,5 +1,6 @@
 import Attribute from "./base-model/attribute.mjs"
 import AttributeNotLoadedError from "./attribute-not-loaded-error.mjs"
+import CacheKeyGenerator from "./cache-key-generator.mjs"
 import Collection from "./collection.mjs"
 import CommandsPool from "./commands-pool.mjs"
 import Config from "./config.mjs"
@@ -142,10 +143,21 @@ export default class BaseModel {
     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
+  }
+
   constructor (args = {}) {
     this.changes = {}
     this.newRecord = args.isNewRecord
     this.relationshipsCache = {}
+    this.relationships = {}
 
     if (args && args.data && args.data.a) {
       this._readModelDataFromArgs(args)
@@ -207,6 +219,7 @@ export default class BaseModel {
 
     clone.abilities = {...this.abilities}
     clone.modelData = {...this.modelData}
+    clone.relationships = {...this.relationships}
     clone.relationshipsCache = {...this.relationshipsCache}
 
     return clone
@@ -237,6 +250,12 @@ export default class BaseModel {
     }
   }
 
+  fullCacheKey() {
+    const cacheKeyGenerator = new CacheKeyGenerator(this)
+
+    return cacheKeyGenerator.cacheKey()
+  }
+
   static all () {
     return this.ransack()
   }
@@ -385,6 +404,12 @@ export default class BaseModel {
     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
@@ -489,6 +514,7 @@ export default class BaseModel {
 
   setNewModel (model) {
     this.setNewModelData(model)
+    this.relationships = digg(model, "relationships")
     this.relationshipsCache = digg(model, "relationshipsCache")
   }
 
@@ -643,7 +669,8 @@ export default 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,
@@ -697,6 +724,7 @@ export default class BaseModel {
 
   preloadRelationship (relationshipName, model) {
     this.relationshipsCache[BaseModel.snakeCase(relationshipName)] = model
+    this.relationships[BaseModel.snakeCase(relationshipName)] = model
   }
 
   uniqueKey () {
@@ -792,7 +820,9 @@ export default class BaseModel {
   }
 
   async _loadBelongsToReflection (args, queryArgs = {}) {
-    if (args.reflectionName in this.relationshipsCache) {
+    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)
@@ -803,21 +833,24 @@ export default class BaseModel {
   }
 
   _readBelongsToReflection ({reflectionName}) {
-    if (!(reflectionName in this.relationshipsCache)) {
-      if (this.isNewRecord())
-        return null
+    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) {
+    if (args.reflectionName in this.relationships) {
+      return this.relationships[args.reflectionName]
+    } else if (args.reflectionName in this.relationshipsCache) {
       return this.relationshipsCache[args.reflectionName]
     }
 
@@ -830,7 +863,9 @@ export default class BaseModel {
   }
 
   async _loadHasOneReflection (args, queryArgs = {}) {
-    if (args.reflectionName in this.relationshipsCache) {
+    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)
@@ -843,17 +878,20 @@ export default 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")
+    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) {
@@ -893,19 +931,22 @@ export default 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
       }
     }
   }

package/src/cache-key-generator.mjs

@@ -0,0 +1,65 @@
+import SparkMD5 from "spark-md5"
+
+export default class CacheKeyGenerator {
+  constructor(model) {
+    this.allModels = [model]
+    this.readModels = {}
+    this.recordModelType(model.modelClassData().name)
+    this.recordModel(model.modelClassData().name, model)
+    this.fillModels(model)
+  }
+
+  recordModelType(relationshipType) {
+    if (!(relationshipType in this.readModels)) {
+      this.readModels[relationshipType] = {}
+    }
+  }
+
+  recordModel(relationshipType, model) {
+    this.allModels.push(model)
+    this.readModels[relationshipType][model.id() || model.uniqueKey()] = true
+  }
+
+  isModelRecorded(relationshipType, model) {
+    if (model.id() in this.readModels[relationshipType]) {
+      return true
+    }
+  }
+
+  fillModels(model) {
+    for (const relationshipType in model.relationships) {
+      this.recordModelType(relationshipType)
+
+      for (const anotherModel of model.relationships[relationshipType]) {
+        if (this.isModelRecorded(relationshipType, anotherModel)) {
+          continue
+        }
+
+        this.recordModel(relationshipType, anotherModel)
+        this.fillModels(anotherModel)
+      }
+    }
+  }
+
+  cacheKey() {
+    const md5 = new SparkMD5()
+
+    for (const model of this.allModels) {
+      md5.append("-model-")
+      md5.append(model.modelClassData().name)
+      md5.append("-unique-key-")
+      md5.append(model.id() || model.uniqueKey())
+      md5.append("-attributes-")
+
+      const attributes = model.attributes()
+
+      for (const attributeName in attributes) {
+        md5.append(attributeName)
+        md5.append("-attribute-")
+        md5.append(`${model.readAttributeUnderscore(attributeName)}`)
+      }
+    }
+
+    return md5.end()
+  }
+}

package/src/collection.mjs

@@ -87,7 +87,7 @@ export default class ApiMakerCollection {
     return this._merge({limit: amount})
   }
 
-  loaded () {
+  preloaded () {
     if (!(this.args.reflectionName in this.args.model.relationshipsCache)) {
       throw new Error(`${this.args.reflectionName} hasnt been loaded yet`)
     }
@@ -95,6 +95,44 @@ export default class ApiMakerCollection {
     return this.args.model.relationshipsCache[this.args.reflectionName]
   }
 
+  loaded () {
+    const {model, reflectionName} = this.args
+
+    if (reflectionName in model.relationships) {
+      return model.relationships[reflectionName]
+    } else if (reflectionName in model.relationshipsCache) {
+      return model.relationshipsCache[reflectionName]
+    } else if (model.isNewRecord()) {
+      const reflectionNameUnderscore = inflection.underscore(reflectionName)
+
+      // Initialize as empty and try again to return the empty result
+      this.set([])
+
+      return digg(model.relationships, reflectionNameUnderscore)
+    } else {
+      throw new Error(`${reflectionName} hasnt been loaded yet`)
+    }
+  }
+
+  // Replaces the relationships with the given new collection.
+  set(newCollection) {
+    this.args.model.relationships[this.args.reflectionName] = newCollection
+  }
+
+  // Pushes another model onto the given collection.
+  push(newModel) {
+    if (!(this.args.reflectionName in this.args.model.relationships)) {
+      this.args.model.relationships[this.args.reflectionName] = []
+    }
+
+    this.args.model.relationships[this.args.reflectionName].push(newModel)
+  }
+
+  // Array shortcuts
+  find = (...args) => this.loaded().find(...args)
+  forEach = (...args) => this.loaded().forEach(...args)
+  map = (...args) => this.loaded().map(...args)
+
   preload (preloadValue) {
     return this._merge({preload: preloadValue})
   }