@kaspernj/api-maker 1.0.2011 → 1.0.2013

package/src/{cable-connection-pool.mjs → cable-connection-pool.js}

@@ -1,23 +1,22 @@
-import CableSubscriptionPool from "./cable-subscription-pool.mjs"
-import CableSubscription from "./cable-subscription.mjs"
+import CableSubscriptionPool from "./cable-subscription-pool"
+import CableSubscription from "./cable-subscription"
 import {dig} from "diggerize"
+import RunLast from "./run-last"
 
 const shared = {}
 
 export default class ApiMakerCableConnectionPool {
+  cableSubscriptionPools = []
+  connections = {}
+  upcomingSubscriptionData = {}
+  upcomingSubscriptions = {}
+
   static current () {
     if (!shared.apiMakerCableConnectionPool) shared.apiMakerCableConnectionPool = new ApiMakerCableConnectionPool()
 
     return shared.apiMakerCableConnectionPool
   }
 
-  constructor () {
-    this.cableSubscriptionPools = []
-    this.connections = {}
-    this.upcomingSubscriptionData = {}
-    this.upcomingSubscriptions = {}
-  }
-
   connectEventToExistingSubscription ({path, subscription, value}) {
     for (const cableSubscriptionPool of this.cableSubscriptionPools) {
       if (!cableSubscriptionPool.isConnected()) {
@@ -98,32 +97,18 @@ export default class ApiMakerCableConnectionPool {
       currentSubscription[value].push(subscription)
     }
 
-    this.scheduleConnectUpcoming()
+    this.scheduleConnectUpcomingRunLast.queue()
 
     return subscription
   }
 
-  connectCreated (modelName, callback) {
-    return this.connectModelEvent({callback, value: true, path: [modelName, "creates"]})
-  }
-
-  connectEvent (modelName, modelId, eventName, callback) {
-    return this.connectModelEvent({callback, value: modelId, path: [modelName, "events", eventName]})
-  }
-
-  connectDestroyed (modelName, modelId, callback) {
-    return this.connectModelEvent({callback, value: modelId, path: [modelName, "destroys"]})
-  }
-
-  connectModelClassEvent (modelName, eventName, callback) {
-    return this.connectModelEvent({callback, value: eventName, path: [modelName, "model_class_events"]})
-  }
-
-  connectUpdate (modelName, modelId, callback) {
-    return this.connectModelEvent({callback, value: modelId, path: [modelName, "updates"]})
-  }
+  connectCreated = (modelName, callback) => this.connectModelEvent({callback, value: true, path: [modelName, "creates"]})
+  connectEvent = (modelName, modelId, eventName, callback) => this.connectModelEvent({callback, value: modelId, path: [modelName, "events", eventName]})
+  connectDestroyed = (modelName, modelId, callback) => this.connectModelEvent({callback, value: modelId, path: [modelName, "destroys"]})
+  connectModelClassEvent = (modelName, eventName, callback) => this.connectModelEvent({callback, value: eventName, path: [modelName, "model_class_events"]})
+  connectUpdate = (modelName, modelId, callback) => this.connectModelEvent({callback, value: modelId, path: [modelName, "updates"]})
 
-  connectUpcoming () {
+  connectUpcoming = () => {
     const subscriptionData = this.upcomingSubscriptionData
     const subscriptions = this.upcomingSubscriptions
 
@@ -138,10 +123,5 @@ export default class ApiMakerCableConnectionPool {
     this.cableSubscriptionPools.push(cableSubscriptionPool)
   }
 
-  scheduleConnectUpcoming () {
-    if (this.scheduleConnectUpcomingTimeout)
-      clearTimeout(this.scheduleConnectUpcomingTimeout)
-
-    this.scheduleConnectUpcomingTimeout = setTimeout(() => this.connectUpcoming(), 0)
-  }
+  scheduleConnectUpcomingRunLast = new RunLast(this.connectUpcoming)
 }

package/src/{cable-subscription-pool.mjs → cable-subscription-pool.js}

@@ -1,9 +1,11 @@
-import ChannelsConsumer from "./channels-consumer.mjs"
-import CommandsPool from "./commands-pool.mjs"
-import Deserializer from "./deserializer.mjs"
+import getChannelsConsumer from "./channels-consumer"
+import CommandsPool from "./commands-pool"
+import Deserializer from "./deserializer"
 import {digg} from "diggerize"
-import inflection from "inflection"
-import Logger from "./logger.mjs"
+import * as inflection from "inflection"
+import Logger from "./logger"
+
+const logger = new Logger({name: "ApiMaker / CableSubscriptionPool"})
 
 export default class ApiMakerCableSubscriptionPool {
   constructor () {
@@ -14,15 +16,18 @@ export default class ApiMakerCableSubscriptionPool {
   connect (subscriptionData) {
     const globalData = CommandsPool.current().globalRequestData
 
-    this.subscription = ChannelsConsumer.subscriptions.create(
+    logger.debug(() => ["Creating subscription", {subscriptionData}])
+
+    this.subscription = getChannelsConsumer().subscriptions.create(
       {
         channel: "ApiMaker::SubscriptionsChannel",
         global: globalData,
         subscription_data: subscriptionData
       },
       {
-        connected: () => this.onConnected(),
-        received: (data) => this.onReceived(data)
+        connected: this.onConnected,
+        received: this.onReceived,
+        subscribed: this.onSubscribed
       }
     )
     this.connected = true
@@ -69,17 +74,15 @@ export default class ApiMakerCableSubscriptionPool {
     }
   }
 
-  isConnected () {
-    return digg(this, "connected")
-  }
+  isConnected = () => 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")
@@ -124,13 +127,17 @@ export default class ApiMakerCableSubscriptionPool {
     }
   }
 
+  onSubscribed = () => {
+    logger.debug("onSubscribed")
+  }
+
   onUnsubscribe () {
-    Logger.log(`activeSubscriptions before unsub: ${this.activeSubscriptions}`)
+    logger.debug(() => `activeSubscriptions before unsub: ${this.activeSubscriptions}`)
     this.activeSubscriptions -= 1
-    Logger.log(`activeSubscriptions after unsub: ${this.activeSubscriptions}`)
+    logger.debug(() => `activeSubscriptions after unsub: ${this.activeSubscriptions}`)
 
     if (this.activeSubscriptions <= 0) {
-      Logger.log("Unsubscribe from ActionCable subscription")
+      logger.debug("Unsubscribe from ActionCable subscription")
       this.subscription.unsubscribe()
       this.connected = false
     }
@@ -139,8 +146,7 @@ export default class ApiMakerCableSubscriptionPool {
   registerSubscriptions (subscriptions) {
     this.subscriptions = subscriptions
 
-    Logger.log(`registerSubscriptions: ${subscriptions.length}`)
-    Logger.log(subscriptions)
+    logger.debug(() => ["registerSubscriptions", {subscriptions}])
 
     for (const modelName in subscriptions) {
       if (subscriptions[modelName].creates) {
@@ -170,13 +176,12 @@ export default class ApiMakerCableSubscriptionPool {
   }
 
   connectUnsubscriptionForSubscription (subscription) {
-    Logger.log("Connecting to unsubscribe on subscription")
-    Logger.log({subscription})
+    logger.debug(() => ["Connecting to unsubscribe on subscription", {subscription}])
 
     this.activeSubscriptions += 1
 
     subscription.events.addListener("unsubscribed", () => {
-      Logger.log("Call onUnsubscribe on self")
+      logger.debug("Call onUnsubscribe on self")
 
       this.onUnsubscribe(subscription)
     })

package/src/{cable-subscription.mjs → cable-subscription.js}

@@ -1,5 +1,7 @@
 import EventEmitter from "events"
-import Logger from "./logger.mjs"
+import Logger from "./logger"
+
+const logger = new Logger({name: "ApiMaker / CableSubscription"})
 
 export default class ApiMakerCableSubscription {
   constructor () {
@@ -9,13 +11,13 @@ export default class ApiMakerCableSubscription {
 
   unsubscribe () {
     if (!this.subscribed) {
-      Logger.log("Unsubscribed already called")
+      logger.debug("Unsubscribed already called")
       return
     }
 
-    Logger.log("Unsubscribe called for subscription")
+    logger.debug("Unsubscribe called for subscription")
 
-    this.events.emit("unsubscribed")
     this.subscribed = false
+    this.events.emit("unsubscribed")
   }
 }

package/src/cache-key-generator.js

@@ -0,0 +1,100 @@
+import SparkMD5 from "spark-md5"
+
+export default class CacheKeyGenerator {
+  constructor(model) {
+    this.model = model
+    this.allModels = [model]
+    this.readModels = {}
+    this.recordModelType(model.modelClassData().name)
+    this.recordModel(model.modelClassData().name, model)
+    this.filledModels = false
+  }
+
+  local() {
+    const md5 = new SparkMD5()
+
+    this.feedModel(this.model, md5)
+
+    return md5.end()
+  }
+
+  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)
+
+      const loadedRelationship = model.relationships[relationshipType]
+
+      if (Array.isArray(loadedRelationship)) { // has_many
+        for (const anotherModel of loadedRelationship) {
+          if (this.isModelRecorded(relationshipType, anotherModel)) {
+            continue
+          }
+
+          this.recordModel(relationshipType, anotherModel)
+          this.fillModels(anotherModel)
+        }
+      } else if (loadedRelationship) { // belongs_to, has_one
+        if (this.isModelRecorded(relationshipType, loadedRelationship)) {
+          continue
+        }
+
+        this.recordModel(relationshipType, loadedRelationship)
+        this.fillModels(loadedRelationship)
+      }
+    }
+
+    this.filledModels = true
+  }
+
+  cacheKey() {
+    if (!this.filledModels) {
+      this.fillModels(this.model)
+    }
+
+    const md5 = new SparkMD5()
+
+    for (const model of this.allModels) {
+      this.feedModel(model, md5)
+    }
+
+    return md5.end()
+  }
+
+  feedModel(model, md5) {
+    md5.append("--model--")
+    md5.append(model.modelClassData().name)
+    md5.append("--unique-key--")
+    md5.append(model.id() || model.uniqueKey())
+
+    if (model.markedForDestruction()) {
+      md5.append("--marked-for-destruction--")
+    }
+
+    md5.append("-attributes-")
+
+    const attributes = model.attributes()
+
+    for (const attributeName in attributes) {
+      md5.append(attributeName)
+      md5.append("--attribute--")
+      md5.append(`${model.readAttributeUnderscore(attributeName)}`)
+    }
+  }
+}

package/src/{can-can.mjs → can-can.js}

@@ -1,26 +1,24 @@
 import {digg} from "diggerize"
 import EventEmitter from "events"
-import inflection from "inflection"
+import * as inflection from "inflection"
 import {ReadersWriterLock} from "epic-locks"
-import Services from "./services.mjs"
+import Services from "./services"
 
 const shared = {}
 
 export default class ApiMakerCanCan {
+  abilities = []
+  abilitiesToLoad = []
+  abilitiesToLoadData = []
+  events = new EventEmitter()
+  lock = new ReadersWriterLock()
+
   static current () {
     if (!shared.currentApiMakerCanCan) shared.currentApiMakerCanCan = new ApiMakerCanCan()
 
     return shared.currentApiMakerCanCan
   }
 
-  constructor () {
-    this.abilities = []
-    this.abilitiesToLoad = []
-    this.abilitiesToLoadData = []
-    this.events = new EventEmitter()
-    this.lock = new ReadersWriterLock()
-  }
-
   can (ability, subject) {
     let abilityToUse = inflection.underscore(ability)
     const foundAbility = this.findAbility(abilityToUse, subject)
@@ -83,6 +81,9 @@ export default class ApiMakerCanCan {
       for (const abilityData of abilities) {
         const subject = abilityData[0]
 
+        if (!subject) throw new Error(`Invalid subject given in abilities: ${subject} - ${JSON.stringify(abilities)}`)
+        if (!Array.isArray(abilityData[1])) throw new Error(`Expected an array of abilities but got: ${typeof abilityData[1]}: ${abilityData[1]}`)
+
         for (const ability of abilityData[1]) {
           const promise = this.loadAbility(ability, subject)
 
@@ -121,7 +122,7 @@ export default class ApiMakerCanCan {
       clearTimeout(this.queueAbilitiesRequestTimeout)
     }
 
-    this.queueAbilitiesRequestTimeout = setTimeout(() => this.sendAbilitiesRequest(), 0)
+    this.queueAbilitiesRequestTimeout = setTimeout(this.sendAbilitiesRequest, 0)
   }
 
   async resetAbilities () {
@@ -131,7 +132,7 @@ export default class ApiMakerCanCan {
     this.events.emit("onResetAbilities")
   }
 
-  async sendAbilitiesRequest () {
+  sendAbilitiesRequest = async () => {
     const abilitiesToLoad = this.abilitiesToLoad
     const abilitiesToLoadData = this.abilitiesToLoadData
 

package/src/channels-consumer.js

@@ -0,0 +1,10 @@
+import Config from "./config"
+import {createConsumer} from "@rails/actioncable"
+
+export default () => {
+  if (!globalThis.apiMakerChannelsConsumer) {
+    globalThis.apiMakerChannelsConsumer = createConsumer(Config.getCableUrl())
+  }
+
+  return globalThis.apiMakerChannelsConsumer
+}

package/src/collection-loader.jsx

@@ -1,226 +1,60 @@
-import Collection from "@kaspernj/api-maker/src/collection"
-import {debounce} from "debounce"
-import {digg, digs} from "diggerize"
-import EventCreated from "@kaspernj/api-maker/src/event-created"
-import EventDestroyed from "@kaspernj/api-maker/src/event-destroyed"
-import EventUpdated from "@kaspernj/api-maker/src/event-updated"
-import instanceOfClassName from "@kaspernj/api-maker/src/instance-of-class-name"
-import Params from "@kaspernj/api-maker/src/params"
+import Collection from "./collection"
+import {digg} from "diggerize"
+import memo from "set-state-compare/src/memo"
+import {useMemo} from "react"
 import PropTypes from "prop-types"
-import React from "react"
-
-import {LocationChanged} from "on-location-changed/src/location-changed-component"
-
-export default class CollectionLoader extends React.PureComponent {
-  static defaultProps = {
-    destroyEnabled: true,
-    groupBy: ["id"],
-    noRecordsAvailableContent: undefined,
-    noRecordsFoundContent: undefined,
-    preloads: [],
-    select: {}
-  }
-
-  static propTypes = {
-    abilities: PropTypes.object,
-    appHistory: PropTypes.object,
-    className: PropTypes.string,
-    collection: PropTypes.oneOfType([
-      instanceOfClassName("ApiMakerCollection"),
-      PropTypes.instanceOf(Collection)
-    ]),
-    component: PropTypes.object,
-    defaultParams: PropTypes.object,
-    groupBy: PropTypes.array,
-    modelClass: PropTypes.func.isRequired,
-    noRecordsAvailableContent: PropTypes.func,
-    noRecordsFoundContent: PropTypes.func,
-    onModelsLoaded: PropTypes.func,
-    paginateContent: PropTypes.func,
-    preloads: PropTypes.array.isRequired,
-    queryName: PropTypes.string,
-    select: PropTypes.object,
-    selectColumns: PropTypes.object
-  }
-
-  shape = digg(this, "props", "component", "shape")
-
-  constructor (props) {
-    super(props)
-
-    let queryName = props.queryName
-
-    if (!queryName) queryName = digg(props.modelClass.modelClassData(), "collectionKey")
-
-    this.shape.set({
-      models: undefined,
-      overallCount: undefined,
-      query: undefined,
-      queryName,
-      queryQName: `${queryName}_q`,
-      queryPageName: `${queryName}_page`,
-      qParams: undefined,
-      result: undefined,
-      showNoRecordsAvailableContent: false,
-      showNoRecordsFoundContent: false
-    })
-  }
-
-  componentDidMount () {
-    this.loadQParams()
-    this.loadModels()
-
-    const {noRecordsAvailableContent} = digs(this.props, "noRecordsAvailableContent")
-
-    if (noRecordsAvailableContent) this.loadOverallCount()
-  }
-
-  async loadOverallCount () {
-    const baseQuery = this.props.collection || this.props.modelClass.all()
-    const overallCount = await baseQuery.count()
-
-    this.shape.set({
-      overallCount,
-      showNoRecordsAvailableContent: this.showNoRecordsAvailableContent({overallCount}),
-      showNoRecordsFoundContent: this.showNoRecordsFoundContent({overallCount})
-    })
-  }
-
-  loadQParams () {
-    const {queryQName} = digs(this.shape, "queryQName")
-    const params = Params.parse()
-    const qParams = Object.assign({}, this.props.defaultParams, params[queryQName])
-
-    this.shape.set({qParams})
-  }
-
-  loadModels = async () => {
-    const params = Params.parse()
-    const {abilities, collection, groupBy, modelClass, onModelsLoaded, preloads, select, selectColumns} = this.props
-    const {qParams, queryPageName, queryQName} = digs(this.shape, "qParams", "queryPageName", "queryQName")
-
-    let query = collection?.clone() || modelClass.ransack()
-
-    if (groupBy) query = query.groupBy(...groupBy)
-
-    query = query
-      .ransack(qParams)
-      .searchKey(queryQName)
-      .page(params[queryPageName])
-      .pageKey(queryPageName)
-      .preload(preloads)
-      .select(select)
-
-    if (abilities) query = query.abilities(abilities)
-    if (selectColumns) query = query.selectColumns(selectColumns)
-
-    const result = await query.result()
-    const models = result.models()
-
-    if (onModelsLoaded) {
-      onModelsLoaded({
-        models,
-        qParams,
-        query,
-        result
-      })
-    }
-
-    this.shape.set({
-      query,
-      result,
-      models: result.models(),
-      showNoRecordsAvailableContent: this.showNoRecordsAvailableContent({models}),
-      showNoRecordsFoundContent: this.showNoRecordsFoundContent({models})
-    })
-  }
-
-  loadModelsDebounce = debounce(digg(this, "loadModels"))
-  onModelCreated = digg(this, "loadModels")
-
-  onModelDestroyed = (args) => {
-    const {models} = digs(this.shape, "models")
-
-    this.shape.set({
-      models: models.filter((model) => model.id() != args.model.id())
-    })
-  }
-
-  onModelUpdated = (args) => {
-    const {models} = digs(this.shape, "models")
-    const updatedModel = digg(args, "model")
-    const foundModel = models.find((model) => model.id() == updatedModel.id())
-
-    if (foundModel) this.loadModelsDebounce()
-  }
-
-  onLocationChanged = () => {
-    const {queryQName} = digs(this.shape, "queryQName")
-    const params = Params.parse()
-    const qParams = Object.assign({}, this.props.defaultParams, params[queryQName])
-
-    this.shape.set({qParams})
-    this.loadModels()
-  }
-
-  showNoRecordsAvailableContent (args) {
-    const {noRecordsAvailableContent} = digs(this.props, "noRecordsAvailableContent")
-    let models, overallCount
-
-    if (args.models !== undefined) {
-      models = args.models
-    } else if (this.shape.models !== undefined) {
-      models = this.shape.models
-    }
-
-    if (args.overallCount !== undefined) {
-      overallCount = args.overallCount
-    } else if (this.shape.overallCount !== undefined) {
-      overallCount = this.shape.overallCount
-    }
-
-    if (models === undefined || overallCount === undefined || noRecordsAvailableContent === undefined) return false
-    if (models.length === 0 && overallCount === 0 && noRecordsAvailableContent) return true
-  }
-
-  showNoRecordsFoundContent (args) {
-    const {noRecordsAvailableContent, noRecordsFoundContent} = digs(this.props, "noRecordsAvailableContent", "noRecordsFoundContent")
-    let models, overallCount
-
-    if (args.models !== undefined) {
-      models = args.models
-    } else if (this.shape.models !== undefined) {
-      models = this.shape.models
-    }
-
-    if (args.overallCount !== undefined) {
-      overallCount = args.overallCount
-    } else if (this.shape.overallCount !== undefined) {
-      overallCount = this.shape.overallCount
-    }
-
-    if (models === undefined || noRecordsFoundContent === undefined) return false
-
-    // Dont show noRecordsAvailableContent together with noRecordsAvailableContent
-    if (models.length === 0 && overallCount === 0 && noRecordsAvailableContent) return false
-    if (models.length === 0 && noRecordsFoundContent) return true
-  }
-
-  render() {
-    const {modelClass} = digs(this.props, "modelClass")
-    const {models} = digs(this.shape, "models")
-
-    return (
-      <>
-        <EventCreated modelClass={modelClass} onCreated={digg(this, "onModelCreated")} />
-        <LocationChanged onChanged={digg(this, "onLocationChanged")} />
-        {models && models.map((model) =>
-          <React.Fragment key={model.id()}>
-            <EventDestroyed model={model} onDestroyed={digg(this, "onModelDestroyed")} />
-            <EventUpdated model={model} onUpdated={digg(this, "onModelUpdated")} />
-          </React.Fragment>
-        )}
-      </>
-    )
-  }
+import PropTypesExact from "prop-types-exact"
+import useCollection from "./use-collection"
+import useShape from "set-state-compare/src/use-shape"
+
+const CollectionLoader = ({component, ...restProps}) => {
+  const s = useShape(restProps)
+  const useCollectionResult = useCollection(restProps)
+  const cachePartsKeys = [
+    "modelIdsCacheString",
+    "overallCount",
+    "qParams",
+    "queryName",
+    "queryPerKey",
+    "queryQName",
+    "querySName",
+    "queryPageName",
+    "searchParams",
+    "showNoRecordsAvailableContent",
+    "showNoRecordsFoundContent"
+  ]
+  const cacheParts = []
+
+  for(const cachePartsKey of cachePartsKeys) {
+    cacheParts.push(digg(useCollectionResult, cachePartsKey))
+  }
+
+  s.updateMeta({component, useCollectionResult})
+
+  useMemo(() => {
+    s.m.component.setState(s.m.useCollectionResult)
+  }, cacheParts)
+
+  return null
 }
+
+CollectionLoader.propTypes = PropTypesExact({
+  abilities: PropTypes.object,
+  collection: PropTypes.instanceOf(Collection),
+  component: PropTypes.object.isRequired,
+  defaultParams: PropTypes.object,
+  groupBy: PropTypes.array,
+  modelClass: PropTypes.func.isRequired,
+  noRecordsAvailableContent: PropTypes.func,
+  noRecordsFoundContent: PropTypes.func,
+  onModelsLoaded: PropTypes.func,
+  pagination: PropTypes.bool,
+  preloads: PropTypes.array,
+  queryMethod: PropTypes.func,
+  queryName: PropTypes.string,
+  ransack: PropTypes.object,
+  select: PropTypes.object,
+  selectColumns: PropTypes.object
+})
+
+export default memo(CollectionLoader)