@kaspernj/api-maker 1.0.125 → 1.0.128

package/src/cable-connection-pool.cjs

@@ -3,21 +3,21 @@ const CableSubscription = require("./cable-subscription.cjs")
 const {dig} = require("diggerize")
 
 module.exports = class ApiMakerCableConnectionPool {
-  static current() {
+  static current () {
     if (!global.apiMakerCableConnectionPool)
       global.apiMakerCableConnectionPool = new ApiMakerCableConnectionPool()
 
     return global.apiMakerCableConnectionPool
   }
 
-  constructor() {
+  constructor () {
     this.cableSubscriptionPools = []
     this.connections = {}
     this.upcomingSubscriptionData = {}
     this.upcomingSubscriptions = {}
   }
 
-  connectEventToExistingSubscription({path, subscription, value}) {
+  connectEventToExistingSubscription ({path, subscription, value}) {
     for (const cableSubscriptionPool of this.cableSubscriptionPools) {
       if (!cableSubscriptionPool.isConnected()) {
         continue
@@ -46,7 +46,7 @@ module.exports = class ApiMakerCableConnectionPool {
     return false
   }
 
-  connectModelEvent({callback, path, value}) {
+  connectModelEvent ({callback, path, value}) {
     const subscription = new CableSubscription()
 
     subscription.events.addListener("received", callback)
@@ -102,27 +102,27 @@ module.exports = class ApiMakerCableConnectionPool {
     return subscription
   }
 
-  connectCreated(modelName, callback) {
+  connectCreated (modelName, callback) {
     return this.connectModelEvent({callback, value: true, path: [modelName, "creates"]})
   }
 
-  connectEvent(modelName, modelId, eventName, callback) {
+  connectEvent (modelName, modelId, eventName, callback) {
     return this.connectModelEvent({callback, value: modelId, path: [modelName, "events", eventName]})
   }
 
-  connectDestroyed(modelName, modelId, callback) {
+  connectDestroyed (modelName, modelId, callback) {
     return this.connectModelEvent({callback, value: modelId, path: [modelName, "destroys"]})
   }
 
-  connectModelClassEvent(modelName, eventName, callback) {
+  connectModelClassEvent (modelName, eventName, callback) {
     return this.connectModelEvent({callback, value: eventName, path: [modelName, "model_class_events"]})
   }
 
-  connectUpdate(modelName, modelId, callback) {
+  connectUpdate (modelName, modelId, callback) {
     return this.connectModelEvent({callback, value: modelId, path: [modelName, "updates"]})
   }
 
-  connectUpcoming() {
+  connectUpcoming () {
     const subscriptionData = this.upcomingSubscriptionData
     const subscriptions = this.upcomingSubscriptions
 
@@ -137,7 +137,7 @@ module.exports = class ApiMakerCableConnectionPool {
     this.cableSubscriptionPools.push(cableSubscriptionPool)
   }
 
-  scheduleConnectUpcoming() {
+  scheduleConnectUpcoming () {
     if (this.scheduleConnectUpcomingTimeout)
       clearTimeout(this.scheduleConnectUpcomingTimeout)
 

package/src/cable-subscription-pool.cjs

@@ -6,12 +6,12 @@ const inflection = require("inflection")
 const Logger = require("./logger.cjs")
 
 module.exports = class ApiMakerCableSubscriptionPool {
-  constructor() {
+  constructor () {
     this.activeSubscriptions = 0
     this.connected = false
   }
 
-  connect(subscriptionData) {
+  connect (subscriptionData) {
     const globalData = CommandsPool.current().globalRequestData
 
     this.subscription = ChannelsConsumer.subscriptions.create(
@@ -28,7 +28,7 @@ module.exports = class ApiMakerCableSubscriptionPool {
     this.connected = true
   }
 
-  forEachSubscription(callback) {
+  forEachSubscription (callback) {
     const modelIdModes = ["destroys", "updates"]
     const subscriptions = digg(this, "subscriptions")
 
@@ -43,24 +43,24 @@ module.exports = class ApiMakerCableSubscriptionPool {
         }
       }
 
-      if (subscriptions[modelName]["creates"]) {
-        for (const subscription of subscriptions[modelName]["creates"]) {
+      if (subscriptions[modelName].creates) {
+        for (const subscription of subscriptions[modelName].creates) {
           callback({mode: "creates", modelName, subscription})
         }
       }
 
-      if (subscriptions[modelName]["model_class_events"]) {
-        for (const eventName in subscriptions[modelName]["model_class_events"]) {
-          for (const subscription of subscriptions[modelName]["model_class_events"][eventName]) {
+      if (subscriptions[modelName].model_class_events) {
+        for (const eventName in subscriptions[modelName].model_class_events) {
+          for (const subscription of subscriptions[modelName].model_class_events[eventName]) {
             callback({eventName, mode: "model_class_events", modelName, subscription})
           }
         }
       }
 
-      if (subscriptions[modelName]["events"]) {
-        for (const modelId in subscriptions[modelName]["events"]) {
-          for (const eventName in subscriptions[modelName]["events"][modelId]) {
-            for (const subscription of subscriptions[modelName]["events"][modelId][eventName]) {
+      if (subscriptions[modelName].events) {
+        for (const modelId in subscriptions[modelName].events) {
+          for (const eventName in subscriptions[modelName].events[modelId]) {
+            for (const subscription of subscriptions[modelName].events[modelId][eventName]) {
               callback({eventName, mode: "updates", modelId, modelName, subscription})
             }
           }
@@ -69,17 +69,17 @@ module.exports = class ApiMakerCableSubscriptionPool {
     }
   }
 
-  isConnected() {
+  isConnected () {
     return digg(this, "connected")
   }
 
-  onConnected() {
+  onConnected () {
     this.forEachSubscription(({subscription}) => {
       subscription.events.emit("connected")
     })
   }
 
-  onReceived(rawData) {
+  onReceived (rawData) {
     const data = Deserializer.parse(rawData)
     const {a: args, e: eventName, m: model, mi: modelId, mt: modelType, t: type} = data
     const subscriptions = digg(this, "subscriptions")
@@ -94,29 +94,29 @@ module.exports = class ApiMakerCableSubscriptionPool {
     }
 
     if (type == "u") {
-      for(const subscription of subscriptions[modelName]["updates"][modelId]) {
+      for (const subscription of subscriptions[modelName].updates[modelId]) {
         subscription.events.emit("received", {model})
       }
     } else if (type == "c") {
-      for(const subscription of subscriptions[modelName]["creates"]) {
+      for (const subscription of subscriptions[modelName].creates) {
         subscription.events.emit("received", {model})
       }
     } else if (type == "d") {
       const destroySubscriptions = digg(subscriptions, modelName, "destroys", modelId)
 
-      for(const subscription of destroySubscriptions) {
+      for (const subscription of destroySubscriptions) {
         subscription.events.emit("received", {model})
       }
     } else if (type == "e") {
       const eventSubscriptions = digg(subscriptions, modelName, "events", eventName, modelId)
 
-      for(const subscription of eventSubscriptions) {
+      for (const subscription of eventSubscriptions) {
         subscription.events.emit("received", {args, eventName, model})
       }
     } else if (type == "mce") {
       const modelClassEventSubscriptions = digg(subscriptions, modelName, "model_class_events", eventName)
 
-      for(const subscription of modelClassEventSubscriptions) {
+      for (const subscription of modelClassEventSubscriptions) {
         subscription.events.emit("received", {args, eventName})
       }
     } else {
@@ -124,7 +124,7 @@ module.exports = class ApiMakerCableSubscriptionPool {
     }
   }
 
-  onUnsubscribe() {
+  onUnsubscribe () {
     Logger.log(`activeSubscriptions before unsub: ${this.activeSubscriptions}`)
     this.activeSubscriptions -= 1
     Logger.log(`activeSubscriptions after unsub: ${this.activeSubscriptions}`)
@@ -136,32 +136,32 @@ module.exports = class ApiMakerCableSubscriptionPool {
     }
   }
 
-  registerSubscriptions(subscriptions) {
+  registerSubscriptions (subscriptions) {
     this.subscriptions = subscriptions
 
     Logger.log(`registerSubscriptions: ${subscriptions.length}`)
     Logger.log(subscriptions)
 
-    for(const modelName in subscriptions) {
-      if (subscriptions[modelName]["creates"]) {
-        for(const subscription of subscriptions[modelName]["creates"]) {
+    for (const modelName in subscriptions) {
+      if (subscriptions[modelName].creates) {
+        for (const subscription of subscriptions[modelName].creates) {
           this.connectUnsubscriptionForSubscription(subscription)
         }
       }
 
-      if (subscriptions[modelName]["events"]) {
-        for(const eventName in subscriptions[modelName]["events"]) {
-          for(const modelId in subscriptions[modelName]["events"][eventName]) {
-            for(const subscription of subscriptions[modelName]["events"][eventName][modelId]) {
+      if (subscriptions[modelName].events) {
+        for (const eventName in subscriptions[modelName].events) {
+          for (const modelId in subscriptions[modelName].events[eventName]) {
+            for (const subscription of subscriptions[modelName].events[eventName][modelId]) {
               this.connectUnsubscriptionForSubscription(subscription)
             }
           }
         }
       }
 
-      if (subscriptions[modelName]["updates"]) {
-        for(const modelId in subscriptions[modelName]["updates"]) {
-          for(const subscription of subscriptions[modelName]["updates"][modelId]) {
+      if (subscriptions[modelName].updates) {
+        for (const modelId in subscriptions[modelName].updates) {
+          for (const subscription of subscriptions[modelName].updates[modelId]) {
             this.connectUnsubscriptionForSubscription(subscription)
           }
         }
@@ -169,9 +169,9 @@ module.exports = class ApiMakerCableSubscriptionPool {
     }
   }
 
-  connectUnsubscriptionForSubscription(subscription) {
+  connectUnsubscriptionForSubscription (subscription) {
     Logger.log("Connecting to unsubscribe on subscription")
-    Logger.log({ subscription })
+    Logger.log({subscription})
 
     this.activeSubscriptions += 1
 

package/src/cable-subscription.cjs

@@ -2,12 +2,12 @@ const EventEmitter = require("events")
 const Logger = require("./logger.cjs")
 
 module.exports = class ApiMakerCableSubscription {
-  constructor() {
+  constructor () {
     this.events = new EventEmitter()
     this.subscribed = true
   }
 
-  unsubscribe() {
+  unsubscribe () {
     if (!this.subscribed) {
       Logger.log("Unsubscribed already called")
       return

package/src/can-can-loader.jsx

@@ -2,20 +2,20 @@ import ApiMakerEventEmitterListener from "./event-emitter-listener"
 import {digg, digs} from "diggerize"
 const CanCan = require("./can-can.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 ApiMakerCanCanLoader extends React.PureComponent {
-  static propTypes = PropTypesExact({
+  static propTypes = propTypesExact({
     abilities: PropTypes.array.isRequired,
     component: PropTypes.object.isRequired
   })
 
-  componentDidMount() {
+  componentDidMount () {
     this.loadAbilities()
   }
 
-  async loadAbilities() {
+  async loadAbilities () {
     const canCan = CanCan.current()
     const {abilities} = digs(this.props, "abilities")
 
@@ -24,14 +24,14 @@ export default class ApiMakerCanCanLoader extends React.PureComponent {
     this.updateComponent({canCan})
   }
 
-  render() {
+  render () {
     const canCan = CanCan.current()
     const events = digg(canCan, "events")
 
     return (
       <ApiMakerEventEmitterListener
-        events={events}
         event="onResetAbilities"
+        events={events}
         onCalled={this.onResetAbilities}
       />
     )
@@ -42,7 +42,7 @@ export default class ApiMakerCanCanLoader extends React.PureComponent {
     this.loadAbilities()
   }
 
-  updateComponent(updatedState) {
+  updateComponent (updatedState) {
     const {component} = digs(this.props, "component")
 
     if (component.shape) {

package/src/can-can.cjs

@@ -5,7 +5,7 @@ const {ReadersWriterLock} = require("epic-locks")
 const Services = require("./services.cjs")
 
 module.exports = class ApiMakerCanCan {
-  static current() {
+  static current () {
     if (!global.currentApiMakerCanCan) {
       global.currentApiMakerCanCan = new ApiMakerCanCan()
     }
@@ -13,7 +13,7 @@ module.exports = class ApiMakerCanCan {
     return global.currentApiMakerCanCan
   }
 
-  constructor() {
+  constructor () {
     this.abilities = []
     this.abilitiesToLoad = []
     this.abilitiesToLoadData = []
@@ -21,19 +21,19 @@ module.exports = class ApiMakerCanCan {
     this.lock = new ReadersWriterLock()
   }
 
-  can(ability, subject) {
-    ability = inflection.underscore(ability)
-    const foundAbility = this.findAbility(ability, subject)
+  can (ability, subject) {
+    let abilityToUse = inflection.underscore(ability)
+    const foundAbility = this.findAbility(abilityToUse, subject)
 
     if (foundAbility === undefined) {
       let subjectLabel = subject
 
       // Translate resource-models into class name strings
-      if (typeof subject == "function" && subject["modelClassData"]) {
+      if (typeof subject == "function" && subject.modelClassData) {
         subjectLabel = digg(subject.modelClassData(), "name")
       }
 
-      console.error(`Ability not loaded ${subjectLabel}#${ability}`)
+      console.error(`Ability not loaded ${subjectLabel}#${abilityToUse}`)
 
       return false
     } else {
@@ -41,11 +41,11 @@ module.exports = class ApiMakerCanCan {
     }
   }
 
-  findAbility(ability, subject) {
+  findAbility (ability, subject) {
     return this.abilities.find((abilityData) => digg(abilityData, "subject") == subject && digg(abilityData, "ability") == ability)
   }
 
-  isAbilityLoaded(ability, subject) {
+  isAbilityLoaded (ability, subject) {
     const foundAbility = this.findAbility(ability, subject)
 
     if (foundAbility !== undefined) {
@@ -55,8 +55,8 @@ module.exports = class ApiMakerCanCan {
     return false
   }
 
-  async loadAbilities(abilities) {
-    await this.lock.read(async() => {
+  async loadAbilities (abilities) {
+    await this.lock.read(async () => {
       const promises = []
 
       for (const abilityData of abilities) {
@@ -73,12 +73,13 @@ module.exports = class ApiMakerCanCan {
     })
   }
 
-  loadAbility(ability, subject) {
+  loadAbility (ability, subject) {
     return new Promise((resolve) => {
       ability = inflection.underscore(ability)
 
       if (this.isAbilityLoaded(ability, subject)) {
-        return resolve()
+        resolve()
+        return
       }
 
       const foundAbility = this.abilitiesToLoad.find((abilityToLoad) => digg(abilityToLoad, "ability") == ability && digg(abilityToLoad, "subject") == subject)
@@ -94,7 +95,7 @@ module.exports = class ApiMakerCanCan {
     })
   }
 
-  queueAbilitiesRequest() {
+  queueAbilitiesRequest () {
     if (this.queueAbilitiesRequestTimeout) {
       clearTimeout(this.queueAbilitiesRequestTimeout)
     }
@@ -102,14 +103,14 @@ module.exports = class ApiMakerCanCan {
     this.queueAbilitiesRequestTimeout = setTimeout(() => this.sendAbilitiesRequest(), 0)
   }
 
-  async resetAbilities() {
+  async resetAbilities () {
     await this.lock.write(() => {
       this.abilities = []
     })
     this.events.emit("onResetAbilities")
   }
 
-  async sendAbilitiesRequest() {
+  async sendAbilitiesRequest () {
     const abilitiesToLoad = this.abilitiesToLoad
     const abilitiesToLoadData = this.abilitiesToLoadData
 

package/src/collection.cjs

@@ -7,20 +7,20 @@ const ModelsResponseReader = require("./models-response-reader.cjs")
 const Result = require("./result.cjs")
 
 module.exports = class ApiMakerCollection {
-  constructor(args, queryArgs = {}) {
+  constructor (args, queryArgs = {}) {
     this.queryArgs = queryArgs
     this.args = args
   }
 
-  abilities(originalAbilities) {
+  abilities (originalAbilities) {
     const newAbilities = {}
 
-    for(const originalAbilityName in originalAbilities) {
+    for (const originalAbilityName in originalAbilities) {
       const newModelName = inflection.underscore(originalAbilityName)
       const newValues = []
       const originalValues = originalAbilities[originalAbilityName]
 
-      for(const originalAbilityName of originalValues) {
+      for (const originalAbilityName of originalValues) {
         const newAbilityName = inflection.underscore(originalAbilityName)
         newValues.push(newAbilityName)
       }
@@ -31,34 +31,34 @@ module.exports = class ApiMakerCollection {
     return this._merge({abilities: newAbilities})
   }
 
-  accessibleBy(abilityName) {
+  accessibleBy (abilityName) {
     return this._merge({accessibleBy: inflection.underscore(abilityName)})
   }
 
-  async count() {
+  async count () {
     const response = await this.clone()._merge({count: true})._response()
 
     return response.count
   }
 
-  distinct() {
+  distinct () {
     return this._merge({distinct: true})
   }
 
-  async each(callback) {
+  async each (callback) {
     const array = await this.toArray()
 
-    for(const model in array) {
+    for (const model in array) {
       callback.call(model)
     }
   }
 
-  async first() {
+  async first () {
     const models = await this.toArray()
     return models[0]
   }
 
-  groupBy(...arrayOfTablesAndColumns) {
+  groupBy (...arrayOfTablesAndColumns) {
     const arrayOfTablesAndColumnsWithLowercaseColumns = arrayOfTablesAndColumns.map((tableAndColumn) => {
       if (Array.isArray(tableAndColumn)) {
         return [tableAndColumn[0], tableAndColumn[1].toLowerCase()]
@@ -74,18 +74,18 @@ module.exports = class ApiMakerCollection {
     })
   }
 
-  isLoaded() {
+  isLoaded () {
     if (this.args.reflectionName in this.args.model.relationshipsCache)
       return true
 
     return false
   }
 
-  limit(amount) {
+  limit (amount) {
     return this._merge({limit: amount})
   }
 
-  loaded() {
+  loaded () {
     if (!(this.args.reflectionName in this.args.model.relationshipsCache)) {
       throw new Error(`${this.args.reflectionName} hasnt been loaded yet`)
     }
@@ -93,22 +93,22 @@ module.exports = class ApiMakerCollection {
     return this.args.model.relationshipsCache[this.args.reflectionName]
   }
 
-  preload(preloadValue) {
+  preload (preloadValue) {
     return this._merge({preload: preloadValue})
   }
 
-  page(page) {
+  page (page) {
     if (!page)
       page = 1
 
     return this._merge({page})
   }
 
-  pageKey(pageKey) {
+  pageKey (pageKey) {
     return this._merge({pageKey})
   }
 
-  params() {
+  params () {
     let params = {}
 
     if (this.queryArgs.params) params = merge(params, this.queryArgs.params)
@@ -128,15 +128,15 @@ module.exports = class ApiMakerCollection {
     return params
   }
 
-  per(per) {
+  per (per) {
     return this._merge({per})
   }
 
-  perKey(perKey) {
+  perKey (perKey) {
     return this._merge({perKey})
   }
 
-  ransack(params) {
+  ransack (params) {
     if (params) {
       this._merge({ransack: params})
     }
@@ -144,26 +144,26 @@ module.exports = class ApiMakerCollection {
     return this
   }
 
-  async result() {
+  async result () {
     const response = await this._response()
     const models = this._responseToModels(response)
     const result = new Result({collection: this, models, response})
     return result
   }
 
-  searchKey(searchKey) {
-    return this._merge({searchKey: searchKey})
+  searchKey (searchKey) {
+    return this._merge({searchKey})
   }
 
-  select(originalSelect) {
+  select (originalSelect) {
     const newSelect = {}
 
-    for(const originalModelName in originalSelect) {
+    for (const originalModelName in originalSelect) {
       const newModelName = inflection.underscore(originalModelName)
       const newValues = []
       const originalValues = originalSelect[originalModelName]
 
-      for(const originalAttributeName of originalValues) {
+      for (const originalAttributeName of originalValues) {
         const newAttributeName = inflection.underscore(originalAttributeName)
         newValues.push(newAttributeName)
       }
@@ -174,10 +174,10 @@ module.exports = class ApiMakerCollection {
     return this._merge({select: newSelect})
   }
 
-  selectColumns(originalSelect) {
+  selectColumns (originalSelect) {
     const newSelect = {}
 
-    for(const originalModelName in originalSelect) {
+    for (const originalModelName in originalSelect) {
       const newModelName = inflection.underscore(inflection.underscore(originalModelName))
       const newValues = []
       const originalValues = originalSelect[originalModelName]
@@ -193,34 +193,34 @@ module.exports = class ApiMakerCollection {
     return this._merge({selectColumns: newSelect})
   }
 
-  sort(sortBy) {
+  sort (sortBy) {
     return this._merge({ransack: {s: sortBy}})
   }
 
-  async toArray() {
+  async toArray () {
     const response = await this._response()
     return this._responseToModels(response)
   }
 
-  modelClass() {
+  modelClass () {
     const modelName = digg(this.args.modelClass.modelClassData(), "name")
 
     return digg(require("@kaspernj/api-maker/src/models"), modelName)
   }
 
-  clone() {
+  clone () {
     const clonedQueryArgs = cloneDeep(this.queryArgs)
 
     return new ApiMakerCollection(this.args, clonedQueryArgs)
   }
 
-  _merge(newQueryArgs) {
+  _merge (newQueryArgs) {
     merge(this.queryArgs, newQueryArgs)
 
     return this
   }
 
-  _response() {
+  _response () {
     const modelClassData = this.args.modelClass.modelClassData()
 
     return CommandsPool.addCommand(
@@ -234,7 +234,7 @@ module.exports = class ApiMakerCollection {
     )
   }
 
-  _responseToModels(response) {
+  _responseToModels (response) {
     const modelsResponseReader = new ModelsResponseReader({
       collection: this,
       response