@kaspernj/api-maker 1.0.2052 → 1.0.2054

package/src/cable-connection-pool.js

@@ -1,127 +0,0 @@
-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
-  }
-
-  connectEventToExistingSubscription ({path, subscription, value}) {
-    for (const cableSubscriptionPool of this.cableSubscriptionPools) {
-      if (!cableSubscriptionPool.isConnected()) {
-        continue
-      }
-
-      let existingSubscriptions
-
-      if (value === true) {
-        existingSubscriptions = dig(cableSubscriptionPool.subscriptions, ...path)
-      } else {
-        existingSubscriptions = dig(cableSubscriptionPool.subscriptions, ...path, value)
-      }
-
-      if (existingSubscriptions !== undefined) {
-        if (!Array.isArray(existingSubscriptions)) {
-          throw new Error(`existingSubscriptions wasn't an array: ${typeof existingSubscriptions} (${dig(existingSubscriptions, "constructor", "name")})`)
-        }
-
-        existingSubscriptions.push(subscription)
-        cableSubscriptionPool.connectUnsubscriptionForSubscription(subscription)
-
-        return true
-      }
-    }
-
-    return false
-  }
-
-  connectModelEvent ({callback, path, value}) {
-    const subscription = new CableSubscription()
-
-    subscription.events.addListener("received", callback)
-
-    if (this.connectEventToExistingSubscription({path, subscription, value})) {
-      // Managed to connect to existing connection
-      return subscription
-    }
-
-    let currentSubscriptionData = this.upcomingSubscriptionData
-    let currentSubscription = this.upcomingSubscriptions
-
-    for (let i = 0; i < path.length; i++) {
-      const pathPart = path[i]
-
-      if (!(pathPart in currentSubscriptionData)) {
-        if (i == path.length - 1) {
-          currentSubscriptionData[pathPart] = []
-        } else {
-          currentSubscriptionData[pathPart] = {}
-        }
-      }
-
-      currentSubscriptionData = currentSubscriptionData[pathPart]
-
-      if (!(pathPart in currentSubscription)) {
-        if (value === true && i == path.length - 1) {
-          currentSubscription[pathPart] = []
-        } else {
-          currentSubscription[pathPart] = {}
-        }
-      }
-
-      currentSubscription = currentSubscription[pathPart]
-    }
-
-    if (!currentSubscriptionData.includes(value)) {
-      currentSubscriptionData.push(value)
-    }
-
-    if (value === true) {
-      currentSubscription.push(subscription)
-    } else {
-      if (!(value in currentSubscription)) {
-        currentSubscription[value] = []
-      }
-
-      currentSubscription[value].push(subscription)
-    }
-
-    this.scheduleConnectUpcomingRunLast.queue()
-
-    return subscription
-  }
-
-  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 = () => {
-    const subscriptionData = this.upcomingSubscriptionData
-    const subscriptions = this.upcomingSubscriptions
-
-    this.upcomingSubscriptionData = {}
-    this.upcomingSubscriptions = {}
-
-    const cableSubscriptionPool = new CableSubscriptionPool()
-
-    cableSubscriptionPool.registerSubscriptions(subscriptions)
-    cableSubscriptionPool.connect(subscriptionData)
-
-    this.cableSubscriptionPools.push(cableSubscriptionPool)
-  }
-
-  scheduleConnectUpcomingRunLast = new RunLast(this.connectUpcoming)
-}

package/src/cable-subscription-pool.js

@@ -1,189 +0,0 @@
-import getChannelsConsumer from "./channels-consumer"
-import CommandsPool from "./commands-pool"
-import Deserializer from "./deserializer"
-import {digg} from "diggerize"
-import * as inflection from "inflection"
-import Logger from "./logger"
-
-const logger = new Logger({name: "ApiMaker / CableSubscriptionPool"})
-
-export default class ApiMakerCableSubscriptionPool {
-  constructor () {
-    this.activeSubscriptions = 0
-    this.connected = false
-  }
-
-  connect (subscriptionData) {
-    const globalData = CommandsPool.current().globalRequestData
-
-    logger.debug(() => ["Creating subscription", {subscriptionData}])
-
-    this.subscription = getChannelsConsumer().subscriptions.create(
-      {
-        channel: "ApiMaker::SubscriptionsChannel",
-        global: globalData,
-        subscription_data: subscriptionData
-      },
-      {
-        connected: this.onConnected,
-        received: this.onReceived,
-        subscribed: this.onSubscribed
-      }
-    )
-    this.connected = true
-  }
-
-  forEachSubscription (callback) {
-    const modelIdModes = ["destroys", "updates"]
-    const subscriptions = digg(this, "subscriptions")
-
-    for (const modelName in subscriptions) {
-      for (const modelIdMode of modelIdModes) {
-        if (subscriptions[modelName][modelIdMode]) {
-          for (const modelId in subscriptions[modelName][modelIdMode]) {
-            for (const subscription of subscriptions[modelName][modelIdMode][modelId]) {
-              callback({mode: modelIdMode, modelId, modelName, subscription})
-            }
-          }
-        }
-      }
-
-      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]) {
-            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]) {
-              callback({eventName, mode: "updates", modelId, modelName, subscription})
-            }
-          }
-        }
-      }
-    }
-  }
-
-  isConnected = () => digg(this, "connected")
-
-  onConnected = () => {
-    this.forEachSubscription(({subscription}) => {
-      subscription.events.emit("connected")
-    })
-  }
-
-  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")
-
-    let modelName
-
-    // This is more effective if it is an option
-    if (model) {
-      modelName = digg(model.modelClassData(), "name")
-    } else {
-      modelName = inflection.camelize(inflection.singularize(modelType))
-    }
-
-    if (type == "u") {
-      for (const subscription of subscriptions[modelName].updates[modelId]) {
-        subscription.events.emit("received", {model})
-      }
-    } else if (type == "c") {
-      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) {
-        subscription.events.emit("received", {model})
-      }
-    } else if (type == "e") {
-      const eventSubscriptions = digg(subscriptions, modelName, "events", eventName, modelId)
-
-      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) {
-        subscription.events.emit("received", {args, eventName})
-      }
-    } else {
-      throw new Error(`Unknown type: ${data.type}`)
-    }
-  }
-
-  onSubscribed = () => {
-    logger.debug("onSubscribed")
-  }
-
-  onUnsubscribe () {
-    logger.debug(() => `activeSubscriptions before unsub: ${this.activeSubscriptions}`)
-    this.activeSubscriptions -= 1
-    logger.debug(() => `activeSubscriptions after unsub: ${this.activeSubscriptions}`)
-
-    if (this.activeSubscriptions <= 0) {
-      logger.debug("Unsubscribe from ActionCable subscription")
-      this.subscription.unsubscribe()
-      this.connected = false
-    }
-  }
-
-  registerSubscriptions (subscriptions) {
-    this.subscriptions = subscriptions
-
-    logger.debug(() => ["registerSubscriptions", {subscriptions}])
-
-    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]) {
-              this.connectUnsubscriptionForSubscription(subscription)
-            }
-          }
-        }
-      }
-
-      if (subscriptions[modelName].updates) {
-        for (const modelId in subscriptions[modelName].updates) {
-          for (const subscription of subscriptions[modelName].updates[modelId]) {
-            this.connectUnsubscriptionForSubscription(subscription)
-          }
-        }
-      }
-    }
-  }
-
-  connectUnsubscriptionForSubscription (subscription) {
-    logger.debug(() => ["Connecting to unsubscribe on subscription", {subscription}])
-
-    this.activeSubscriptions += 1
-
-    subscription.events.addListener("unsubscribed", () => {
-      logger.debug("Call onUnsubscribe on self")
-
-      this.onUnsubscribe(subscription)
-    })
-  }
-}

package/src/cable-subscription.js

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

package/src/cache-key-generator.js

@@ -1,100 +0,0 @@
-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.js

@@ -1,158 +0,0 @@
-import {digg} from "diggerize"
-import EventEmitter from "events"
-import * as inflection from "inflection"
-import {ReadersWriterLock} from "epic-locks"
-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
-  }
-
-  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) {
-        subjectLabel = digg(subject.modelClassData(), "name")
-      }
-
-      console.error(`Ability not loaded ${subjectLabel}#${abilityToUse}`, {abilities: this.abilities, ability, subject})
-
-      return false
-    } else {
-      return digg(foundAbility, "can")
-    }
-  }
-
-  findAbility (ability, subject) {
-    return this.abilities.find((abilityData) => {
-      const abilityDataSubject = digg(abilityData, "subject")
-      const abilityDataAbility = digg(abilityData, "ability")
-
-      if (abilityDataAbility == ability) {
-        // If actually same class
-        if (abilityDataSubject == subject) return true
-
-        // Sometimes in dev when using linking it will actually be two different but identical resource classes
-        if (
-          typeof subject == "function" &&
-          subject.modelClassData &&
-          typeof abilityDataSubject == "function" &&
-          abilityDataSubject.modelClassData &&
-          digg(subject.modelClassData(), "name") == digg(abilityDataSubject.modelClassData(), "name")
-        ) {
-          return true
-        }
-      }
-
-      return false
-    })
-  }
-
-  isAbilityLoaded (ability, subject) {
-    const foundAbility = this.findAbility(ability, subject)
-
-    if (foundAbility !== undefined) {
-      return true
-    }
-
-    return false
-  }
-
-  async loadAbilities (abilities) {
-    await this.lock.read(async () => {
-      const promises = []
-
-      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)
-
-          promises.push(promise)
-        }
-      }
-
-      await Promise.all(promises)
-    })
-  }
-
-  loadAbility (ability, subject) {
-    return new Promise((resolve) => {
-      ability = inflection.underscore(ability)
-
-      if (this.isAbilityLoaded(ability, subject)) {
-        resolve()
-        return
-      }
-
-      const foundAbility = this.abilitiesToLoad.find((abilityToLoad) => digg(abilityToLoad, "ability") == ability && digg(abilityToLoad, "subject") == subject)
-
-      if (foundAbility) {
-        foundAbility.callbacks.push(resolve)
-      } else {
-        this.abilitiesToLoad.push({ability, callbacks: [resolve], subject})
-        this.abilitiesToLoadData.push({ability, subject})
-
-        this.queueAbilitiesRequest()
-      }
-    })
-  }
-
-  queueAbilitiesRequest () {
-    if (this.queueAbilitiesRequestTimeout) {
-      clearTimeout(this.queueAbilitiesRequestTimeout)
-    }
-
-    this.queueAbilitiesRequestTimeout = setTimeout(this.sendAbilitiesRequest, 0)
-  }
-
-  async resetAbilities () {
-    await this.lock.write(() => {
-      this.abilities = []
-    })
-    this.events.emit("onResetAbilities")
-  }
-
-  sendAbilitiesRequest = async () => {
-    const abilitiesToLoad = this.abilitiesToLoad
-    const abilitiesToLoadData = this.abilitiesToLoadData
-
-    this.abilitiesToLoad = []
-    this.abilitiesToLoadData = []
-
-    // Load abilities from backend
-    const result = await Services.current().sendRequest("CanCan::LoadAbilities", {
-      request: abilitiesToLoadData
-    })
-    const abilities = digg(result, "abilities")
-
-    // Set the loaded abilities
-    this.abilities = this.abilities.concat(abilities)
-
-    // Call the callbacks that are waiting for the ability to have been loaded
-    for (const abilityData of abilitiesToLoad) {
-      for (const callback of abilityData.callbacks) {
-        callback()
-      }
-    }
-  }
-}

package/src/channels-consumer.js

@@ -1,10 +0,0 @@
-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,60 +0,0 @@
-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 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)