api_maker 0.0.1

data/lib/api_maker/javascript/cable-connection-pool.js

@@ -0,0 +1,169 @@
+import CableSubscriptionPool from "./cable-subscription-pool"
+import CableSubscription from "./cable-subscription"
+
+export default class ApiMakerCableConnectionPool {
+  static current() {
+    if (!window.apiMakerCableConnectionPool)
+      window.apiMakerCableConnectionPool = new ApiMakerCableConnectionPool()
+
+    return window.apiMakerCableConnectionPool
+  }
+
+  constructor() {
+    this.connections = {}
+    this.upcomingSubscriptionData = {}
+    this.upcomingSubscriptions = []
+  }
+
+  connectCreated(modelName, callback) {
+    if (!this.upcomingSubscriptionData[modelName])
+      this.upcomingSubscriptionData[modelName] = {}
+
+    if (!this.upcomingSubscriptionData[modelName]["creates"])
+      this.upcomingSubscriptionData[modelName]["creates"] = true
+
+    if (!this.upcomingSubscriptions[modelName])
+      this.upcomingSubscriptions[modelName] = {}
+
+    if (!this.upcomingSubscriptions[modelName]["creates"])
+      this.upcomingSubscriptions[modelName]["creates"] = []
+
+    var subscription = new CableSubscription({
+      callback: callback,
+      modelName: modelName
+    })
+
+    this.upcomingSubscriptions[modelName]["creates"].push(subscription)
+
+    this.scheduleConnectUpcoming()
+
+    return subscription
+  }
+
+  connectDestroyed(modelName, modelId, callback) {
+    if (!this.upcomingSubscriptionData[modelName])
+      this.upcomingSubscriptionData[modelName] = {}
+
+    if (!this.upcomingSubscriptionData[modelName]["destroys"])
+      this.upcomingSubscriptionData[modelName]["destroys"] = []
+
+    if (!this.upcomingSubscriptionData[modelName]["destroys"].includes(modelId))
+      this.upcomingSubscriptionData[modelName]["destroys"].push(modelId)
+
+    if (!this.upcomingSubscriptions[modelName])
+      this.upcomingSubscriptions[modelName] = {}
+
+    if (!this.upcomingSubscriptions[modelName]["destroys"])
+      this.upcomingSubscriptions[modelName]["destroys"] = {}
+
+    if (!this.upcomingSubscriptions[modelName]["destroys"][modelId])
+      this.upcomingSubscriptions[modelName]["destroys"][modelId] = []
+
+    var subscription = new CableSubscription({
+      callback: callback,
+      modelName: modelName,
+      modelId: modelId
+    })
+
+    this.upcomingSubscriptions[modelName]["destroys"][modelId].push(subscription)
+
+    this.scheduleConnectUpcoming()
+
+    return subscription
+  }
+
+  connectEvent(modelName, modelId, eventName, callback) {
+    if (!this.upcomingSubscriptionData[modelName])
+      this.upcomingSubscriptionData[modelName] = {}
+
+    if (!this.upcomingSubscriptionData[modelName]["events"])
+      this.upcomingSubscriptionData[modelName]["events"] = {}
+
+    if (!this.upcomingSubscriptionData[modelName]["events"][eventName])
+      this.upcomingSubscriptionData[modelName]["events"][eventName] = []
+
+    if (!this.upcomingSubscriptionData[modelName]["events"][eventName].includes(modelId))
+      this.upcomingSubscriptionData[modelName]["events"][eventName].push(modelId)
+
+    if (!this.upcomingSubscriptions[modelName])
+      this.upcomingSubscriptions[modelName] = {}
+
+    if (!this.upcomingSubscriptions[modelName]["events"])
+      this.upcomingSubscriptions[modelName]["events"] = {}
+
+    if (!this.upcomingSubscriptions[modelName]["events"])
+      this.upcomingSubscriptions[modelName]["events"] = {}
+
+    if (!this.upcomingSubscriptions[modelName]["events"][modelId])
+      this.upcomingSubscriptions[modelName]["events"][modelId] = {}
+
+    if (!this.upcomingSubscriptions[modelName]["events"][modelId][eventName])
+      this.upcomingSubscriptions[modelName]["events"][modelId][eventName] = []
+
+    var subscription = new CableSubscription({
+      callback: callback,
+      modelName: modelName,
+      modelId: modelId
+    })
+
+    this.upcomingSubscriptions[modelName]["events"][modelId][eventName].push(subscription)
+
+    this.scheduleConnectUpcoming()
+
+    return subscription
+  }
+
+  connectUpdate(modelName, modelId, callback) {
+    if (!this.upcomingSubscriptionData[modelName])
+      this.upcomingSubscriptionData[modelName] = {}
+
+    if (!this.upcomingSubscriptionData[modelName]["updates"])
+      this.upcomingSubscriptionData[modelName]["updates"] = []
+
+    if (!this.upcomingSubscriptionData[modelName]["updates"].includes(modelId))
+      this.upcomingSubscriptionData[modelName]["updates"].push(modelId)
+
+    if (!this.upcomingSubscriptions[modelName])
+      this.upcomingSubscriptions[modelName] = {}
+
+    if (!this.upcomingSubscriptions[modelName]["updates"])
+      this.upcomingSubscriptions[modelName]["updates"] = {}
+
+    if (!this.upcomingSubscriptions[modelName]["updates"][modelId])
+      this.upcomingSubscriptions[modelName]["updates"][modelId] = []
+
+    var subscription = new CableSubscription({
+      callback: callback,
+      modelName: modelName,
+      modelId: modelId
+    })
+
+    this.upcomingSubscriptions[modelName]["updates"][modelId].push(subscription)
+
+    this.scheduleConnectUpcoming()
+
+    return subscription
+  }
+
+  connectUpcoming() {
+    var subscriptionData = this.upcomingSubscriptionData
+    var subscriptions = this.upcomingSubscriptions
+
+    this.upcomingSubscriptionData = {}
+    this.upcomingSubscriptions = {}
+
+    var cableSubscriptionPool = new CableSubscriptionPool({
+      subscriptionData: subscriptionData,
+      subscriptions: subscriptions
+    })
+
+    return cableSubscriptionPool
+  }
+
+  scheduleConnectUpcoming() {
+    if (this.scheduleConnectUpcomingTimeout)
+      clearTimeout(this.scheduleConnectUpcomingTimeout)
+
+    this.scheduleConnectUpcomingTimeout = setTimeout(() => this.connectUpcoming(), 50)
+  }
+}

data/lib/api_maker/javascript/cable-subscription-pool.js

@@ -0,0 +1,111 @@
+import CommandsPool from "./commands-pool"
+import Deserializer from "./deserializer"
+import Logger from "./logger"
+
+const inflection = require("inflection")
+
+export default class ApiMakerCableSubscriptionPool {
+  constructor(props) {
+    this.props = props
+    this.activeSubscriptions = 0
+    this.registerSubscriptions()
+    this.connect()
+  }
+
+  connect() {
+    var globalData = CommandsPool.current().globalRequestData
+
+    this.subscription = App.cable.subscriptions.create(
+      {channel: "ApiMaker::SubscriptionsChannel", global: globalData, subscription_data: this.props.subscriptionData},
+      {received: (data) => this.onReceived(data)}
+    )
+  }
+
+  onReceived(rawData) {
+    var data = Deserializer.parse(rawData)
+    var modelType = data.model_type
+    var modelName = inflection.camelize(inflection.singularize(modelType.replace(/-/g, "_")))
+    var modelId = data.model_id
+    var modelInstance = data.model
+    var subscriptions = this.props.subscriptions
+
+    if (data.type == "update") {
+      for(var subscription of subscriptions[modelName]["updates"][modelId]) {
+        subscription.onReceived({model: modelInstance})
+      }
+    } else if (data.type == "create") {
+      for(var subscription of subscriptions[modelName]["creates"]) {
+        subscription.onReceived({model: modelInstance})
+      }
+    } else if (data.type == "destroy") {
+      for(var subscription of subscriptions[modelName]["destroys"][modelId]) {
+        subscription.onReceived({model: modelInstance})
+      }
+    } else if (data.type == "event") {
+      for(var subscription of subscriptions[modelName]["events"][modelId][data.event_name]) {
+        subscription.onReceived({
+          args: data.args,
+          eventName: data.event_name,
+          model: modelInstance
+        })
+      }
+    } else {
+      throw new Error(`Unknown type: ${data.type}`)
+    }
+  }
+
+  onUnsubscribe() {
+    Logger.log(`activeSubscriptions before unsub: ${this.activeSubscriptions}`)
+    this.activeSubscriptions -= 1
+    Logger.log(`activeSubscriptions after unsub: ${this.activeSubscriptions}`)
+
+    if (this.activeSubscriptions <= 0) {
+      Logger.log("Unsubscribe from ActionCable subscription")
+      this.subscription.unsubscribe()
+    }
+  }
+
+  registerSubscriptions() {
+    Logger.log(`registerSubscriptions: ${this.props.subscriptions.length}`)
+    Logger.log(this.props.subscriptions)
+
+    for(var modelName in this.props.subscriptions) {
+      if (this.props.subscriptions[modelName]["creates"]) {
+        for(var subscription of this.props.subscriptions[modelName]["creates"]) {
+          this.connectUnsubscriptionForSubscription(subscription)
+        }
+      }
+
+      if (this.props.subscriptions[modelName]["events"]) {
+        for(var eventName in this.props.subscriptions[modelName]["events"]) {
+          for(var modelId in this.props.subscriptions[modelName]["events"][eventName]) {
+            for(var subscription of this.props.subscriptions[modelName]["events"][eventName][modelId]) {
+              this.connectUnsubscriptionForSubscription(subscription)
+            }
+          }
+        }
+      }
+
+      if (this.props.subscriptions[modelName]["updates"]) {
+        for(var modelId in this.props.subscriptions[modelName]["updates"]) {
+          for(var subscription of this.props.subscriptions[modelName]["updates"][modelId]) {
+            this.connectUnsubscriptionForSubscription(subscription)
+          }
+        }
+      }
+    }
+  }
+
+  connectUnsubscriptionForSubscription(subscription) {
+    Logger.log("Connecting to unsubscribe on subscription")
+    Logger.log({ subscription })
+
+    this.activeSubscriptions += 1
+
+    subscription.onUnsubscribe(() => {
+      Logger.log("Call onUnsubscribe on self")
+
+      this.onUnsubscribe(subscription)
+    })
+  }
+}

data/lib/api_maker/javascript/cable-subscription.js

@@ -0,0 +1,33 @@
+import Logger from "./logger"
+
+export default class ApiMakerCableSubscription {
+  constructor(props) {
+    this.props = props
+    this.onUnsubscribeCallbacks = []
+    this.subscribed = true
+  }
+
+  onReceived(data) {
+    this.props.callback.apply(null, [data])
+  }
+
+  onUnsubscribe(callback) {
+    this.onUnsubscribeCallbacks.push(callback)
+  }
+
+  unsubscribe() {
+    if (!this.subscribed) {
+      Logger.log("Unsubscribed already called")
+      return
+    }
+
+    Logger.log(`Unsubscribe called: ${this.onUnsubscribeCallbacks.length}`)
+
+    for(var onUnsubscribeCallback of this.onUnsubscribeCallbacks) {
+      Logger.log("onUnsubscribe called for a callback")
+      onUnsubscribeCallback.call()
+    }
+
+    this.subscribed = false
+  }
+}

data/lib/api_maker/javascript/collection.js

@@ -0,0 +1,186 @@
+import CommandsPool from "./commands-pool"
+import merge from "merge"
+import ModelsResponseReader from "./models-response-reader"
+import Result from "./result"
+
+const inflection = require("inflection")
+
+export default class Collection {
+  constructor(args, queryArgs = {}) {
+    this.queryArgs = queryArgs
+    this.args = args
+  }
+
+  accessibleBy(abilityName) {
+    return this._clone({accessibleBy: abilityName})
+  }
+
+  distinct() {
+    return this._clone({distinct: true})
+  }
+
+  async each(callback) {
+    var array = await this.toArray()
+
+    for(var model in array) {
+      callback.call(model)
+    }
+  }
+
+  async first() {
+    var models = await this.toArray()
+    return models[0]
+  }
+
+  async count() {
+    var response = await this._clone({count: true})._response()
+    return response.count
+  }
+
+  isLoaded() {
+    if (this.args.reflectionName in this.args.model.relationshipsCache)
+      return true
+
+    return false
+  }
+
+  limit(amount) {
+    return this._clone({limit: amount})
+  }
+
+  loaded() {
+    if (!(this.args.reflectionName in this.args.model.relationshipsCache)) {
+      throw new Error(`${this.args.reflectionName} hasnt been loaded yet`)
+    }
+
+    return this.args.model.relationshipsCache[this.args.reflectionName]
+  }
+
+  preload(preloadValue) {
+    return this._clone({preload: preloadValue})
+  }
+
+  page(pageNumber) {
+    if (!pageNumber)
+      pageNumber = 1
+
+    var changes = {page: pageNumber}
+
+    if (!this.queryArgs.ransack || !this.queryArgs.ransack.s)
+      changes.ransack = {s: `${this.args.modelClass.modelClassData().primaryKey} asc`}
+
+    return this._clone(changes)
+  }
+
+  pageKey(pageKeyValue) {
+    return this._clone({pageKey: pageKeyValue})
+  }
+
+  ransack(params) {
+    return this._clone({ransack: params})
+  }
+
+  async result() {
+    var response = await this._response()
+    var models = this._responseToModels(response)
+    var result = new Result({collection: this, models, response})
+    return result
+  }
+
+  searchKey(searchKey) {
+    return this._clone({searchKey: searchKey})
+  }
+
+  select(originalSelect) {
+    var newSelect = {}
+
+    for(var originalModelName in originalSelect) {
+      var newModalName = inflection.dasherize(inflection.underscore(originalModelName))
+      var newValues = []
+      var originalValues = originalSelect[originalModelName]
+
+      for(var originalAttributeName of originalValues) {
+        var newAttributeName = inflection.underscore(originalAttributeName)
+        newValues.push(newAttributeName)
+      }
+
+      newSelect[newModalName] = newValues
+    }
+
+    return this._clone({select: newSelect})
+  }
+
+  sort(sortBy) {
+    return this._clone({ransack: {s: sortBy}})
+  }
+
+  async toArray() {
+    var response = await this._response()
+    return this._responseToModels(response)
+  }
+
+  modelClass() {
+    return require(`api-maker/models/${inflection.dasherize(inflection.singularize(this.args.modelClass.modelClassData().collectionName))}`).default
+  }
+
+  _clone(args) {
+    return new Collection(this.args, this._merge(this.queryArgs, args))
+  }
+
+  _merge(object1, object2) {
+    return merge.recursive(true, object1, object2)
+  }
+
+  _response() {
+    var modelClassData = this.args.modelClass.modelClassData()
+
+    return CommandsPool.addCommand(
+      {
+        args: this._params(),
+        command: `${modelClassData.collectionName}-index`,
+        collectionName: modelClassData.collectionName,
+        type: "index"
+      },
+      {}
+    )
+  }
+
+  _responseToModels(response) {
+    var modelsResponseReader = new ModelsResponseReader({response: response})
+    return modelsResponseReader.models()
+  }
+
+  _params() {
+    var params = {}
+
+    if (this.queryArgs.params)
+      params = this._merge(params, this.queryArgs.params)
+
+    if (this.queryArgs.accessibleBy) {
+      params.accessible_by = inflection.underscore(this.queryArgs.accessibleBy)
+    }
+
+    if (this.queryArgs.count)
+      params.count = this.queryArgs.count
+
+    if (this.queryArgs.distinct)
+      params.distinct = this.queryArgs.distinct
+
+    if (this.queryArgs.ransack)
+      params.q = this.queryArgs.ransack
+
+    if (this.queryArgs.limit)
+      params.limit = this.queryArgs.limit
+
+    if (this.queryArgs.preload)
+      params.include = this.queryArgs.preload
+
+    if (this.queryArgs.page)
+      params.page = this.queryArgs.page
+
+    if (this.queryArgs.select)
+      params.select = this.queryArgs.select
+
+    return params
+  }
+}