@kaspernj/api-maker 1.0.120 → 1.0.124

package/package.json

@@ -16,7 +16,7 @@
     ]
   },
   "name": "@kaspernj/api-maker",
-  "version": "1.0.120",
+  "version": "1.0.124",
   "description": "",
   "main": "index.js",
   "repository": {
@@ -48,7 +48,7 @@
     "@babel/preset-react": "^7.12.10",
     "babel-jest": "^27.0.6",
     "eslint": "^7.26.0",
-    "eslint-find-rules": "^3.6.1",
+    "eslint-find-rules": "^4.0.0",
     "eslint-plugin-jest": "^24.3.6",
     "eslint-plugin-react": "^7.23.2",
     "i18n-on-steroids": "^1.0.2",

package/src/base-model.cjs

@@ -659,11 +659,9 @@ module.exports = class BaseModel {
       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 = this.modelClassData().attributes
-      for(const attribute of attributes) {
-        if (attribute.name == attributeName)
-          return null
-      }
+      const attributes = digg(this.modelClassData(), "attributes")
+
+      if (attributeName in attributes) return null
     }
 
     throw new AttributeNotLoadedError(`No such attribute: ${digg(this.modelClassData(), "name")}#${attributeName}`)
@@ -698,26 +696,31 @@ module.exports = class BaseModel {
     }
   }
 
-  _readBelongsToReflection(args) {
-    if (!(args.reflectionName in this.relationshipsCache)) {
+  _readBelongsToReflection({reflectionName}) {
+    if (!(reflectionName in this.relationshipsCache)) {
       if (this.isNewRecord())
         return null
 
-      throw new NotLoadedError(`${digg(this.modelClassData(), "name")}#${args.reflectionName} hasn't been loaded yet`)
+      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(", ")}`)
     }
 
-    return this.relationshipsCache[args.reflectionName]
+    return this.relationshipsCache[reflectionName]
   }
 
   async _loadHasManyReflection(args, queryArgs = {}) {
     if (args.reflectionName in this.relationshipsCache) {
       return this.relationshipsCache[args.reflectionName]
-    } else {
-      const collection = new Collection(args, queryArgs)
-      const model = await collection.toArray()
-      this.relationshipsCache[args.reflectionName] = model
-      return model
     }
+
+    const collection = new Collection(args, queryArgs)
+    const models = await collection.toArray()
+
+    this.relationshipsCache[args.reflectionName] = models
+
+    return models
   }
 
   async _loadHasOneReflection(args, queryArgs = {}) {
@@ -726,20 +729,25 @@ module.exports = class BaseModel {
     } else {
       const collection = new Collection(args, queryArgs)
       const model = await collection.first()
+
       this.relationshipsCache[args.reflectionName] = model
+
       return model
     }
   }
 
-  _readHasOneReflection(args) {
-    if (!(args.reflectionName in this.relationshipsCache)) {
+  _readHasOneReflection({reflectionName}) {
+    if (!(reflectionName in this.relationshipsCache)) {
       if (this.isNewRecord())
         return null
 
-      throw new NotLoadedError(`${digg(this.modelClassData(), "name")}#${args.reflectionName} hasn't been loaded yet`)
+      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(", ")}`)
     }
 
-    return this.relationshipsCache[args.reflectionName]
+    return this.relationshipsCache[reflectionName]
   }
 
   _readModelDataFromArgs(args) {
@@ -754,9 +762,11 @@ module.exports = class BaseModel {
       return
     }
 
+    const relationships = digg(this.modelClassData(), "relationships")
+
     for (const relationshipName in this.preloadedRelationships) {
       const relationshipData = this.preloadedRelationships[relationshipName]
-      const relationshipClassData = this.modelClassData().relationships.find((relationship) => digg(relationship, "name") == relationshipName)
+      const relationshipClassData = relationships.find((relationship) => digg(relationship, "name") == relationshipName)
 
       if (!relationshipClassData) {
         throw new Error(`Could not find the relation ${relationshipName} on the ${digg(this.modelClassData(), "name")} model`)

package/src/model-recipes-loader.cjs

@@ -0,0 +1,28 @@
+const {digs} = require("diggerize")
+const ModelRecipesModelLoader = require("./model-recipes-model-loader.cjs")
+
+module.exports = class ModelRecipesLoader {
+  constructor({recipes}) {
+    this.modelClasses = {}
+    this.recipes = recipes
+  }
+
+  getModelClass(name) {
+    return digg(this, "modelClasses", name)
+  }
+
+  load() {
+    const {recipes} = digs(this, "recipes")
+    const {models} = digs(recipes, "models")
+
+    for (const modelName in models) {
+      const modelRecipe = models[modelName]
+      const modelClassLoader = new ModelRecipesModelLoader({modelRecipe, modelRecipesLoader: this})
+      const modelClass = modelClassLoader.createClass()
+
+      this.modelClasses[modelName] = modelClass
+    }
+
+    return this.modelClasses
+  }
+}

package/src/model-recipes-model-loader.cjs

@@ -0,0 +1,325 @@
+const BaseModel = require("./base-model.cjs")
+const Collection = require("./collection.cjs")
+const {digg} = require("diggerize")
+const inflection = require("inflection")
+
+module.exports = class ApiMakerModelRecipesModelLoader {
+  constructor({modelRecipe, modelRecipesLoader}) {
+    if (!modelRecipe) throw new Error("No 'modelRecipe' was given")
+
+    this.modelRecipesLoader = modelRecipesLoader
+    this.modelRecipe = modelRecipe
+  }
+
+  createClass() {
+    const {modelRecipe} = digs(this, "modelRecipe")
+    const {
+      attributes,
+      collection_commands: collectionCommands,
+      member_commands: memberCommands,
+      model_class_data: modelClassData,
+      relationships
+    } = digs(
+      modelRecipe,
+      "attributes",
+      "collection_commands",
+      "member_commands",
+      "model_class_data",
+      "relationships"
+    )
+    const {name: modelClassName} = digs(modelClassData, "name")
+    const ModelClass = class ApiMakerModel extends BaseModel { }
+
+    Object.defineProperty(ModelClass, "name", {writable: false, value: modelClassName})
+
+    ModelClass.prototype.constructor.modelClassData = () => modelClassData
+
+    this.addAttributeMethodsToModelClass(ModelClass, attributes)
+    this.addRelationshipsToModelClass(ModelClass, modelClassData, relationships)
+    this.addCollectionCommandsToModelClass(ModelClass, collectionCommands)
+    this.addMemberCommandsToModelClass(ModelClass, memberCommands)
+
+    return ModelClass
+  }
+
+  addAttributeMethodsToModelClass(ModelClass, attributes) {
+    for (const attributeName in attributes) {
+      const attribute = attributes[attributeName]
+      const {name} = digs(attribute, "name")
+      const methodName = inflection.camelize(name, true)
+      const hasMethodName = inflection.camelize(`has_${name}`, true)
+
+      ModelClass.prototype[methodName] = function () { return this.readAttributeUnderscore(attributeName) }
+      ModelClass.prototype[hasMethodName] = function () {
+        const value = this[methodName]()
+
+        return this._isPresent(value)
+      }
+    }
+  }
+
+  addCollectionCommandsToModelClass(ModelClass, collectionCommands) {
+    for (const collectionCommandName in collectionCommands) {
+      const methodName = inflection.camelize(collectionCommandName, true)
+
+      ModelClass[methodName] = function (args, commandArgs = {}) {
+        return this._callCollectionCommand(
+          {
+            args,
+            command: collectionCommandName,
+            collectionName: digg(this.modelClassData(), "collectionName"),
+            type: "collection"
+          },
+          commandArgs
+        )
+      }
+    }
+  }
+
+  addMemberCommandsToModelClass(ModelClass, memberCommands) {
+    for (const memberCommandName in memberCommands) {
+      const methodName = inflection.camelize(memberCommandName, true)
+
+      ModelClass.prototype[methodName] = function (args, commandArgs = {}) {
+        return this._callMemberCommand(
+          {
+            args,
+            command: memberCommandName,
+            primaryKey: this.primaryKey(),
+            collectionName: this.modelClassData().collectionName,
+            type: "member"
+          },
+          commandArgs
+        )
+      }
+    }
+  }
+
+  addRelationshipsToModelClass(ModelClass, modelClassData, relationships) {
+    const {modelRecipesLoader} = digs(this, "modelRecipesLoader")
+
+    for (const relationshipName in relationships) {
+      const relationship = relationships[relationshipName]
+      const {
+        active_record: {
+          name: activeRecordName,
+          primary_key: activeRecordPrimaryKey
+        },
+        class_name: className,
+        foreign_key: foreignKey,
+        klass: {primary_key: klassPrimaryKey},
+        options: {as: optionsAs, primary_key: optionsPrimaryKey, through: optionsThrough},
+        resource_name: resourceName,
+        type
+      } = digs(
+        relationship,
+        "active_record",
+        "class_name",
+        "foreign_key",
+        "klass",
+        "options",
+        "resource_name",
+        "type"
+      )
+      const loadMethodName = inflection.camelize(`load_${relationshipName}`, true)
+      const modelMethodName = inflection.camelize(relationshipName, true)
+
+      if (type == "belongs_to") {
+        this.defineBelongsToGetMethod({ModelClass, modelMethodName, relationshipName})
+        this.defineBelongsToLoadMethod({
+          foreignKey,
+          klassPrimaryKey,
+          loadMethodName,
+          ModelClass,
+          modelRecipesLoader,
+          optionsPrimaryKey,
+          relationshipName,
+          resourceName
+        })
+      } else if (type == "has_many") {
+        this.defineHasManyGetMethod({
+          activeRecordName,
+          className,
+          foreignKey,
+          ModelClass,
+          modelMethodName,
+          modelRecipesLoader,
+          optionsAs,
+          optionsPrimaryKey,
+          optionsThrough,
+          relationshipName,
+          resourceName
+        })
+        this.defineHasManyLoadMethod({foreignKey, loadMethodName, ModelClass, modelClassData, modelRecipesLoader, relationshipName, resourceName})
+      } else if (type == "has_one") {
+        this.defineHasOneGetMethd({ModelClass, modelMethodName, relationshipName})
+        this.defineHasOneLoadMethod({
+          activeRecordPrimaryKey,
+          foreignKey,
+          loadMethodName,
+          ModelClass,
+          modelClassData,
+          modelRecipesLoader,
+          optionsThrough,
+          relationshipName,
+          resourceName
+        })
+      } else {
+        throw new Error(`Unknown relationship type: ${type}`)
+      }
+    }
+  }
+
+  defineBelongsToGetMethod({ModelClass, modelMethodName, relationshipName}) {
+    ModelClass.prototype[modelMethodName] = function () {
+      return this._readBelongsToReflection({reflectionName: relationshipName})
+    }
+  }
+
+  defineBelongsToLoadMethod({foreignKey, klassPrimaryKey, ModelClass, modelRecipesLoader, loadMethodName, optionsPrimaryKey, relationshipName, resourceName}) {
+    ModelClass.prototype[loadMethodName] = function () {
+      const foreignKeyMethodName = inflection.camelize(foreignKey, true)
+
+      if (!(foreignKeyMethodName in this)) throw new Error(`Foreign key method wasn't defined: ${foreignKeyMethodName}`)
+
+      const id = this[foreignKeyMethodName]()
+      const modelClass = modelRecipesLoader.getModelClass(resourceName)
+      const ransack = {}
+      const ransackIdSearchKey = `${optionsPrimaryKey || klassPrimaryKey}_eq`
+
+      ransack[ransackIdSearchKey] = id
+
+      return this._loadBelongsToReflection(
+        {reflectionName: relationshipName, model: this, modelClass},
+        {ransack}
+      )
+    }
+  }
+
+  defineHasManyGetMethod({activeRecordName, className, foreignKey, ModelClass, modelMethodName, modelRecipesLoader, optionsAs, optionsPrimaryKey, optionsThrough, relationshipName, resourceName}) {
+    ModelClass.prototype[modelMethodName] = function () {
+      const id = this.primaryKey()
+      const modelClass = modelRecipesLoader.getModelClass(resourceName)
+      const ransack = {}
+
+      ransack[`${foreignKey}_eq`] = id
+
+      const hasManyParameters = {
+        reflectionName: relationshipName,
+        model: this,
+        modelName: className,
+        modelClass
+      }
+
+      let queryParameters
+
+      if (optionsThrough) {
+        queryParameters = {
+          params: {
+            through: {
+              model: activeRecordName,
+              id: this.primaryKey(),
+              reflection: relationshipName
+            }
+          }
+        }
+      } else {
+        const ransack = {}
+        const primaryKeyColumnName = optionsPrimaryKey || digg(ModelClass.modelClassData(), "primaryKey")
+        const primaryKeyMethodName = inflection.camelize(primaryKeyColumnName, true)
+
+        if (!(primaryKeyMethodName in this)) throw new Error(`No such primary key method: ${primaryKeyMethodName}`)
+
+        ransack[`${foreignKey}_eq`] = this[primaryKeyMethodName]()
+
+        if (optionsAs) {
+          ransack[`${optionsAs}_type_eq`] = activeRecordName
+        }
+
+        queryParameters = {ransack}
+      }
+
+      return new Collection(hasManyParameters, queryParameters)
+    }
+  }
+
+  defineHasManyLoadMethod({foreignKey, loadMethodName, ModelClass, modelClassData, modelRecipesLoader, optionsThrough, relationshipName, resourceName}) {
+    ModelClass.prototype[loadMethodName] = function () {
+      const id = this.primaryKey()
+      const modelClass = modelRecipesLoader.getModelClass(resourceName)
+
+      if (optionsThrough) {
+        const modelClassName = digg(modelClassData, "className")
+
+        return this._loadHasManyReflection(
+          {
+            reflectionName: relationshipName,
+            model: this,
+            modelClass
+          },
+          {
+            params: {
+              through: {
+                model: modelClassName,
+                id,
+                reflection: relationshipName
+              }
+            }
+          }
+        )
+      } else {
+        const ransack = {}
+
+        ransack[`${foreignKey}_eq`] = id
+
+        return this._loadHasManyReflection(
+          {
+            reflectionName: relationshipName,
+            model: this,
+            modelClass
+          },
+          {ransack}
+        )
+      }
+    }
+  }
+
+  defineHasOneGetMethd({ModelClass, modelMethodName, relationshipName}) {
+    ModelClass.prototype[modelMethodName] = function () {
+      return this._readHasOneReflection({reflectionName: relationshipName})
+    }
+  }
+
+  defineHasOneLoadMethod({activeRecordPrimaryKey, foreignKey, loadMethodName, ModelClass, modelClassData, modelRecipesLoader, optionsThrough, relationshipName, resourceName}) {
+    ModelClass.prototype[loadMethodName] = function () {
+      const primaryKeyMethodName = inflection.camelize(activeRecordPrimaryKey, true)
+
+      if (!(primaryKeyMethodName in this)) throw new Error(`Primary key method wasn't defined: ${primaryKeyMethodName}`)
+
+      const id = this[primaryKeyMethodName]()
+      const modelClass = modelRecipesLoader.getModelClass(resourceName)
+
+      if (optionsThrough) {
+        const modelClassName = digg(modelClassData, "className")
+
+        return this._loadHasOneReflection(
+          {reflectionName: relationshipName, model: this, modelClass},
+          {params: {through: {model: modelClassName, id, reflection: relationshipName}}}
+        )
+      } else {
+        const ransack = {}
+
+        ransack[`${foreignKey}_eq`] = id
+
+        return this._loadHasOneReflection(
+          {
+            reflectionName: relationshipName,
+            model: this,
+            modelClass
+          },
+          {ransack}
+        )
+      }
+    }
+  }
+}

package/src/model-recipes.cjs.erb

@@ -0,0 +1 @@
+module.exports = <%= ApiMaker::ModelClassesJavaScriptGeneratorService.execute!.to_json %>

package/src/models.cjs

@@ -0,0 +1,9 @@
+/* rails-erb-loader-dependencies api_maker/resources/ */
+
+const modelRecipes = require("./model-recipes.cjs.erb")
+const ModelRecipesLoader = require("./model-recipes-loader.cjs")
+
+const loader = new ModelRecipesLoader({recipes: modelRecipes})
+const result = loader.load()
+
+module.exports = result

package/src/models.js.erb

@@ -1,6 +0,0 @@
-/* rails-erb-loader-dependencies api_maker/resources/ */
-
-import {BaseModel, Collection} from "@kaspernj/api-maker"
-import {digg} from "diggerize"
-
-<%= ApiMaker::ModelClassesJavaScriptGeneratorService.execute! %>