@kaspernj/api-maker 1.0.125 → 1.0.128

package/src/event-model-class.jsx

@@ -1,30 +1,30 @@
 const ModelEvents = require("./model-events.cjs")
 const PropTypes = require("prop-types")
-const PropTypesExact = require("prop-types-exact")
+const propTypesExact = require("prop-types-exact")
 const React = require("react")
 
 export default class ApiMakerEventModelClass extends React.PureComponent {
-  static propTypes = PropTypesExact({
+  static propTypes = propTypesExact({
     event: PropTypes.string.isRequired,
     modelClass: PropTypes.func.isRequired,
     onCall: PropTypes.func.isRequired
   })
 
-  componentDidMount() {
+  componentDidMount () {
     this.connect()
   }
 
-  componentWillUnmount() {
+  componentWillUnmount () {
     if (this.connection) {
       this.connection.unsubscribe()
     }
   }
 
-  connect() {
+  connect () {
     this.connection = ModelEvents.connectModelClass(this.props.modelClass, this.props.event, this.props.onCall)
   }
 
-  render() {
+  render () {
     return null
   }
 }

package/src/event-updated.jsx

@@ -1,7 +1,7 @@
 const debounce = require("debounce")
 const ModelEvents = require("./model-events.cjs")
 const PropTypes = require("prop-types")
-const PropTypesExact = require("prop-types-exact")
+const propTypesExact = require("prop-types-exact")
 const React = require("react")
 
 export default class ApiMakerEventUpdated extends React.PureComponent {
@@ -9,7 +9,7 @@ export default class ApiMakerEventUpdated extends React.PureComponent {
     active: true
   }
 
-  static propTypes = PropTypesExact({
+  static propTypes = propTypesExact({
     active: PropTypes.bool.isRequired,
     debounce: PropTypes.oneOfType([
       PropTypes.bool,
@@ -20,16 +20,16 @@ export default class ApiMakerEventUpdated extends React.PureComponent {
     onUpdated: PropTypes.func.isRequired
   })
 
-  constructor(props) {
+  constructor (props) {
     super(props)
     this.onConnected = this.onConnected.bind(this)
   }
 
-  componentDidMount() {
+  componentDidMount () {
     this.connect()
   }
 
-  componentWillUnmount() {
+  componentWillUnmount () {
     if (this.connectUpdated) {
       this.connectUpdated.unsubscribe()
     }
@@ -39,7 +39,7 @@ export default class ApiMakerEventUpdated extends React.PureComponent {
     }
   }
 
-  connect() {
+  connect () {
     const {model, onConnected} = this.props
 
     this.connectUpdated = ModelEvents.connectUpdated(model, (...args) => this.onUpdated(...args))
@@ -49,7 +49,7 @@ export default class ApiMakerEventUpdated extends React.PureComponent {
     }
   }
 
-  debounce() {
+  debounce () {
     if (!this.debounceInstance) {
       if (typeof this.props.debounce == "number") {
         this.debounceInstance = debounce(this.props.onUpdated, this.props.debounce)
@@ -61,11 +61,11 @@ export default class ApiMakerEventUpdated extends React.PureComponent {
     return this.debounceInstance
   }
 
-  onConnected() {
+  onConnected () {
     this.props.onConnected()
   }
 
-  onUpdated(...args) {
+  onUpdated (...args) {
     if (!this.props.active) {
       return
     }
@@ -77,7 +77,7 @@ export default class ApiMakerEventUpdated extends React.PureComponent {
     }
   }
 
-  render() {
+  render () {
     return null
   }
 }

package/src/instance-of-class-name.cjs

@@ -1,13 +1,11 @@
 const {digg} = require("diggerize")
 
-const instanceOfClassName = (expectedClassName) => {
-  return (props, propName, componentName) => {
-    const prop = digg(props, propName)
-    const className = digg(prop, "constructor", "name")
+const instanceOfClassName = (expectedClassName) => (props, propName, componentName) => {
+  const prop = digg(props, propName)
+  const className = digg(prop, "constructor", "name")
 
-    if (className != expectedClassName) {
-      return new Error(`Invalid prop '${propName}' passed to '${componentName}'. Expected a class name of '${expectedClassName}' but got '${className}'.`)
-    }
+  if (className != expectedClassName) {
+    return new Error(`Invalid prop '${propName}' passed to '${componentName}'. Expected a class name of '${expectedClassName}' but got '${className}'.`)
   }
 }
 

package/src/key-value-store.cjs

@@ -1,22 +1,22 @@
 const Params = require("./params.cjs")
 
 module.exports = class KeyValueStore {
-  static current() {
+  static current () {
     if (!global.currentKeyValueStore)
       global.currentKeyValueStore = new KeyValueStore()
 
     return global.currentKeyValueStore
   }
 
-  static async get(key) {
-    return await KeyValueStore.current().get(key)
+  static get (key) {
+    return KeyValueStore.current().get(key)
   }
 
-  static async set(key, value) {
-    return await KeyValueStore.current().set(key, value)
+  static set (key, value) {
+    return KeyValueStore.current().set(key, value)
   }
 
-  static async getCachedParams(paramName, args = {}) {
+  static async getCachedParams (paramName, args = {}) {
     const oldQuery = await KeyValueStore.get(paramName)
     const params = Params.parse()
 
@@ -29,34 +29,37 @@ module.exports = class KeyValueStore {
     }
   }
 
-  static async setCachedParams(paramName, qParams) {
-    return await KeyValueStore.set(paramName, qParams)
+  static setCachedParams (paramName, qParams) {
+    return KeyValueStore.set(paramName, qParams)
   }
 
-  constructor() {
+  constructor () {
     this.database = new Dexie("KeyValueStoreDatabase")
     this.database.version(1).stores({
       keyValues: "++id, key, value"
     })
   }
 
-  async get(key) {
-    const row = await this.database.keyValues.where("key").equals(key).first()
+  async get (key) {
+    const row = await this.database.keyValues
+      .where("key")
+      .equals(key)
+      .first()
 
     if (row)
       return row.value
   }
 
-  async set(key, value) {
-    const row = await this.database.keyValues.where("key").equals(key).first()
+  async set (key, value) {
+    const row = await this.database.keyValues
+      .where("key")
+      .equals(key)
+      .first()
 
     if (row) {
-      await this.database.keyValues.update(row.id, {value: value})
+      await this.database.keyValues.update(row.id, {value})
     } else {
-      await this.database.keyValues.add({
-        key: key,
-        value: value
-      })
+      await this.database.keyValues.add({key, value})
     }
 
     return true

package/src/logger.cjs

@@ -1,5 +1,5 @@
 module.exports = class ApiMakerLogger {
-  static current() {
+  static current () {
     if (!global.apiMakerLogger) {
       global.apiMakerLogger = new ApiMakerLogger()
       // global.apiMakerLogger.setDebug(true)
@@ -8,16 +8,16 @@ module.exports = class ApiMakerLogger {
     return global.apiMakerLogger
   }
 
-  static log(message) {
+  static log (message) {
     ApiMakerLogger.current().log(message)
   }
 
-  log(message) {
+  log (message) {
     if (this.debug)
       console.log("ApiMaker", message)
   }
 
-  setDebug(value) {
+  setDebug (value) {
     this.debug = value
   }
 }

package/src/merge.cjs

@@ -1,4 +1,4 @@
-function isPlainObject(input) {
+const isPlainObject = (input) => {
   if (input && typeof input === "object" && !Array.isArray(input)) {
     return true
   }
@@ -6,7 +6,7 @@ function isPlainObject(input) {
   return false
 }
 
-function merge(firstObject, ...objects) {
+const merge = (firstObject, ...objects) => {
   for (const object of objects) {
     mergeObjectsInto(firstObject, object)
   }
@@ -14,7 +14,7 @@ function merge(firstObject, ...objects) {
   return firstObject
 }
 
-function mergeArraysInto(mergeIntoValue, ...arrays) {
+const mergeArraysInto = (mergeIntoValue, ...arrays) => {
   for (const array of arrays) {
     for (const value of array) {
       if (!mergeIntoValue.includes(value)) {
@@ -24,7 +24,7 @@ function mergeArraysInto(mergeIntoValue, ...arrays) {
   }
 }
 
-function mergeObjectsInto(mergeInto, object) {
+const mergeObjectsInto = (mergeInto, object) => {
   for (const key in object) {
     const value = object[key]
 

package/src/model-events.cjs

@@ -1,35 +1,36 @@
 const CableConnectionPool = require("./cable-connection-pool.cjs")
+const {digg} = require("diggerize")
 
 module.exports = class ModelEvents {
-  static connect(model, eventName, callback) {
+  static connect (model, eventName, callback) {
     const modelClassName = digg(model.modelClassData(), "name")
     const cableSubscription = CableConnectionPool.current().connectEvent(modelClassName, model.primaryKey(), eventName, callback)
 
     return cableSubscription
   }
 
-  static connectModelClass(modelClass, eventName, callback) {
+  static connectModelClass (modelClass, eventName, callback) {
     const modelClassName = digg(modelClass.modelClassData(), "name")
     const cableSubscription = CableConnectionPool.current().connectModelClassEvent(modelClassName, eventName, callback)
 
     return cableSubscription
   }
 
-  static connectCreated(modelClass, callback) {
+  static connectCreated (modelClass, callback) {
     const modelClassName = digg(modelClass.modelClassData(), "name")
     const cableSubscription = CableConnectionPool.current().connectCreated(modelClassName, callback)
 
     return cableSubscription
   }
 
-  static connectDestroyed(model, callback) {
+  static connectDestroyed (model, callback) {
     const modelClassName = digg(model.modelClassData(), "name")
     const cableSubscription = CableConnectionPool.current().connectDestroyed(modelClassName, model.primaryKey(), callback)
 
     return cableSubscription
   }
 
-  static connectUpdated(model, callback) {
+  static connectUpdated (model, callback) {
     const modelClassName = digg(model.modelClassData(), "name")
     const cableSubscription = CableConnectionPool.current().connectUpdate(modelClassName, model.primaryKey(), callback)
 

package/src/model-name.cjs

@@ -1,15 +1,16 @@
 module.exports = class ModelName {
-  constructor(data) {
+  constructor (data) {
     this.data = data
   }
 
-  human(args) {
-    if (!args)
-      args = {count: 1}
+  human (args) {
+    let argsToUse = args
+
+    if (!argsToUse) argsToUse = {count: 1}
 
     let countKey
 
-    if (args.count > 1 || args.count < 0) {
+    if (argsToUse.count > 1 || argsToUse.count < 0) {
       countKey = "other"
     } else {
       countKey = "one"

package/src/model-prop-type.cjs

@@ -2,7 +2,7 @@ const {digg} = require("diggerize")
 const Inflection = require("inflection")
 
 module.exports = class ApiMakerModelPropType {
-  static ofModel(modelClass) {
+  static ofModel (modelClass) {
     const modelPropTypeInstance = new ApiMakerModelPropType()
 
     modelPropTypeInstance.withModelType(modelClass)
@@ -10,13 +10,13 @@ module.exports = class ApiMakerModelPropType {
     return modelPropTypeInstance
   }
 
-  constructor() {
+  constructor () {
     this.isNotRequired = this.isNotRequired.bind(this)
     this.isRequired = this.isRequired.bind(this)
     this._withLoadedAssociations = {}
   }
 
-  isNotRequired(props, propName, _componentName) {
+  isNotRequired (props, propName, _componentName) {
     const model = props[propName]
 
     if (model) {
@@ -24,7 +24,7 @@ module.exports = class ApiMakerModelPropType {
     }
   }
 
-  isRequired(props, propName, _componentName) {
+  isRequired (props, propName, _componentName) {
     const model = props[propName]
 
     if (!model) return new Error(`${propName} was required but not given`)
@@ -32,21 +32,21 @@ module.exports = class ApiMakerModelPropType {
     return this.validate({model, propName})
   }
 
-  previous() {
+  previous () {
     if (!this._previousModelPropType) throw new Error("No previous model prop type set")
 
     return this._previousModelPropType
   }
 
-  setPreviousModelPropType(previousModelPropType) {
+  setPreviousModelPropType (previousModelPropType) {
     this._previousModelPropType = previousModelPropType
   }
 
-  withModelType(modelClass) {
+  withModelType (modelClass) {
     this._withModelType = modelClass
   }
 
-  validate({model, propName}) {
+  validate ({model, propName}) {
     if (this._withModelType && this._withModelType.name != model.constructor.name)
       return new Error(`Expected ${propName} to be of type ${this._withModelType.name} but it wasn't: ${model.constructor.name}`)
 
@@ -69,8 +69,6 @@ module.exports = class ApiMakerModelPropType {
 
         const associationCache = digg(model.relationshipsCache, underscoreAssociationName)
 
-        let associationModel
-
         // Find a model to run sub-model-prop-type-validations on
         if (Array.isArray(associationCache)) {
           for (const preloadedModel of associationCache) {
@@ -103,13 +101,13 @@ module.exports = class ApiMakerModelPropType {
     }
   }
 
-  withLoadedAbilities(arrayOfAbilities) {
+  withLoadedAbilities (arrayOfAbilities) {
     this._withLoadedAbilities = arrayOfAbilities
 
     return this
   }
 
-  withLoadedAssociation(associationName) {
+  withLoadedAssociation (associationName) {
     const associationModelPropType = new ApiMakerModelPropType()
 
     associationModelPropType.setPreviousModelPropType(this)
@@ -118,7 +116,7 @@ module.exports = class ApiMakerModelPropType {
     return associationModelPropType
   }
 
-  withLoadedAttributes(arrayOfAttributes) {
+  withLoadedAttributes (arrayOfAttributes) {
     this._withLoadedAttributes = arrayOfAttributes
 
     return this

package/src/model-recipes-loader.cjs

@@ -1,17 +1,17 @@
-const {digs} = require("diggerize")
+const {digg, digs} = require("diggerize")
 const ModelRecipesModelLoader = require("./model-recipes-model-loader.cjs")
 
 module.exports = class ModelRecipesLoader {
-  constructor({recipes}) {
+  constructor ({recipes}) {
     this.modelClasses = {}
     this.recipes = recipes
   }
 
-  getModelClass(name) {
+  getModelClass (name) {
     return digg(this, "modelClasses", name)
   }
 
-  load() {
+  load () {
     const {recipes} = digs(this, "recipes")
     const {models} = digs(recipes, "models")
 

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

@@ -1,17 +1,17 @@
 const BaseModel = require("./base-model.cjs")
 const Collection = require("./collection.cjs")
-const {digg} = require("diggerize")
+const {digg, digs} = require("diggerize")
 const inflection = require("inflection")
 
 module.exports = class ApiMakerModelRecipesModelLoader {
-  constructor({modelRecipe, modelRecipesLoader}) {
+  constructor ({modelRecipe, modelRecipesLoader}) {
     if (!modelRecipe) throw new Error("No 'modelRecipe' was given")
 
     this.modelRecipesLoader = modelRecipesLoader
     this.modelRecipe = modelRecipe
   }
 
-  createClass() {
+  createClass () {
     const {modelRecipe} = digs(this, "modelRecipe")
     const {
       attributes,
@@ -42,14 +42,17 @@ module.exports = class ApiMakerModelRecipesModelLoader {
     return ModelClass
   }
 
-  addAttributeMethodsToModelClass(ModelClass, attributes) {
+  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[methodName] = function () {
+        return this.readAttributeUnderscore(attributeName)
+      }
+
       ModelClass.prototype[hasMethodName] = function () {
         const value = this[methodName]()
 
@@ -58,7 +61,7 @@ module.exports = class ApiMakerModelRecipesModelLoader {
     }
   }
 
-  addCollectionCommandsToModelClass(ModelClass, collectionCommands) {
+  addCollectionCommandsToModelClass (ModelClass, collectionCommands) {
     for (const collectionCommandName in collectionCommands) {
       const methodName = inflection.camelize(collectionCommandName, true)
 
@@ -76,7 +79,7 @@ module.exports = class ApiMakerModelRecipesModelLoader {
     }
   }
 
-  addMemberCommandsToModelClass(ModelClass, memberCommands) {
+  addMemberCommandsToModelClass (ModelClass, memberCommands) {
     for (const memberCommandName in memberCommands) {
       const methodName = inflection.camelize(memberCommandName, true)
 
@@ -95,7 +98,7 @@ module.exports = class ApiMakerModelRecipesModelLoader {
     }
   }
 
-  addRelationshipsToModelClass(ModelClass, modelClassData, relationships) {
+  addRelationshipsToModelClass (ModelClass, modelClassData, relationships) {
     const {modelRecipesLoader} = digs(this, "modelRecipesLoader")
 
     for (const relationshipName in relationships) {
@@ -170,13 +173,13 @@ module.exports = class ApiMakerModelRecipesModelLoader {
     }
   }
 
-  defineBelongsToGetMethod({ModelClass, modelMethodName, relationshipName}) {
+  defineBelongsToGetMethod ({ModelClass, modelMethodName, relationshipName}) {
     ModelClass.prototype[modelMethodName] = function () {
       return this._readBelongsToReflection({reflectionName: relationshipName})
     }
   }
 
-  defineBelongsToLoadMethod({foreignKey, klassPrimaryKey, ModelClass, modelRecipesLoader, loadMethodName, optionsPrimaryKey, relationshipName, resourceName}) {
+  defineBelongsToLoadMethod ({foreignKey, klassPrimaryKey, ModelClass, modelRecipesLoader, loadMethodName, optionsPrimaryKey, relationshipName, resourceName}) {
     ModelClass.prototype[loadMethodName] = function () {
       const foreignKeyMethodName = inflection.camelize(foreignKey, true)
 
@@ -196,7 +199,19 @@ module.exports = class ApiMakerModelRecipesModelLoader {
     }
   }
 
-  defineHasManyGetMethod({activeRecordName, className, foreignKey, ModelClass, modelMethodName, modelRecipesLoader, optionsAs, optionsPrimaryKey, optionsThrough, relationshipName, resourceName}) {
+  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)
@@ -243,7 +258,7 @@ module.exports = class ApiMakerModelRecipesModelLoader {
     }
   }
 
-  defineHasManyLoadMethod({foreignKey, loadMethodName, ModelClass, modelClassData, modelRecipesLoader, optionsThrough, relationshipName, resourceName}) {
+  defineHasManyLoadMethod ({foreignKey, loadMethodName, ModelClass, modelClassData, modelRecipesLoader, optionsThrough, relationshipName, resourceName}) {
     ModelClass.prototype[loadMethodName] = function () {
       const id = this.primaryKey()
       const modelClass = modelRecipesLoader.getModelClass(resourceName)
@@ -284,13 +299,23 @@ module.exports = class ApiMakerModelRecipesModelLoader {
     }
   }
 
-  defineHasOneGetMethd({ModelClass, modelMethodName, relationshipName}) {
+  defineHasOneGetMethd ({ModelClass, modelMethodName, relationshipName}) {
     ModelClass.prototype[modelMethodName] = function () {
       return this._readHasOneReflection({reflectionName: relationshipName})
     }
   }
 
-  defineHasOneLoadMethod({activeRecordPrimaryKey, foreignKey, loadMethodName, ModelClass, modelClassData, modelRecipesLoader, optionsThrough, relationshipName, resourceName}) {
+  defineHasOneLoadMethod ({
+    activeRecordPrimaryKey,
+    foreignKey,
+    loadMethodName,
+    ModelClass,
+    modelClassData,
+    modelRecipesLoader,
+    optionsThrough,
+    relationshipName,
+    resourceName
+  }) {
     ModelClass.prototype[loadMethodName] = function () {
       const primaryKeyMethodName = inflection.camelize(activeRecordPrimaryKey, true)
 

package/src/models-response-reader.cjs

@@ -3,36 +3,36 @@ const inflection = require("inflection")
 const Preloaded = require("./preloaded.cjs")
 
 module.exports = class ModelsResponseReader {
-  static first(response) {
+  static first (response) {
     return ModelsResponseReader.collection(response)[0]
   }
 
-  static collection(response) {
-    const reader = new ModelsResponseReader({response: response})
+  static collection (response) {
+    const reader = new ModelsResponseReader({response})
     return reader.models()
   }
 
-  constructor(args) {
+  constructor (args) {
     this.collection = args.collection
     this.response = args.response
   }
 
-  models() {
+  models () {
     const preloaded = new Preloaded(this.response)
     const models = []
 
-    for(const modelType in this.response.data) {
+    for (const modelType in this.response.data) {
       const modelClassName = inflection.classify(modelType)
-      const modelClass = digg(require("@kaspernj/api-maker/src/models"), modelClassName)
-      const collectionName = modelClass.modelClassData().collectionName
+      const ModelClass = digg(require("@kaspernj/api-maker/src/models"), modelClassName)
+      const collectionName = ModelClass.modelClassData().collectionName
 
-      for(const modelId of this.response.data[modelType]) {
+      for (const modelId of this.response.data[modelType]) {
         const modelData = this.response.preloaded[collectionName][modelId]
 
         if (!modelData)
           throw new Error(`Couldn't find model data for ${collectionName}(${modelId})`)
 
-        const model = new modelClass({
+        const model = new ModelClass({
           collection: this.collection,
           data: modelData,
           isNewRecord: false