@kaspernj/api-maker 1.0.2011 → 1.0.2013

package/src/{collection.mjs → collection.js}

@@ -1,18 +1,21 @@
 import cloneDeep from "clone-deep"
-import CommandsPool from "./commands-pool.mjs"
+import CommandsPool from "./commands-pool"
 import {digg} from "diggerize"
-import inflection from "inflection"
+import * as inflection from "inflection"
 import {incorporate} from "incorporator"
-import modelClassRequire from "./model-class-require.mjs"
-import Result from "./result.mjs"
+import modelClassRequire from "./model-class-require"
+import Result from "./result"
+import uniqunize from "uniqunize"
 
-class ApiMakerCollection {
-  constructor (args, queryArgs = {}) {
+export default class ApiMakerCollection {
+  static apiMakerType = "Collection"
+
+  constructor(args, queryArgs = {}) {
     this.queryArgs = queryArgs
     this.args = args
   }
 
-  abilities (originalAbilities) {
+  abilities(originalAbilities) {
     const newAbilities = {}
 
     for (const originalAbilityName in originalAbilities) {
@@ -31,21 +34,21 @@ 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 digg(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) {
@@ -53,12 +56,24 @@ class ApiMakerCollection {
     }
   }
 
-  async first () {
+  except(...keys) {
+    for (const key of keys) {
+      if (key == "page") {
+        delete this.queryArgs[key]
+      } else {
+        throw new Error(`Unhandled key: ${key}`)
+      }
+    }
+
+    return this
+  }
+
+  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 +89,18 @@ 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 () {
+  preloaded() {
     if (!(this.args.reflectionName in this.args.model.relationshipsCache)) {
       throw new Error(`${this.args.reflectionName} hasnt been loaded yet`)
     }
@@ -93,22 +108,62 @@ class ApiMakerCollection {
     return this.args.model.relationshipsCache[this.args.reflectionName]
   }
 
-  preload (preloadValue) {
+  loaded() {
+    const {model, reflectionName} = this.args
+
+    if (reflectionName in model.relationships) {
+      return model.relationships[reflectionName]
+    } else if (reflectionName in model.relationshipsCache) {
+      return model.relationshipsCache[reflectionName]
+    } else if (model.isNewRecord()) {
+      const reflectionNameUnderscore = inflection.underscore(reflectionName)
+
+      // Initialize as empty and try again to return the empty result
+      this.set([])
+
+      return digg(model.relationships, reflectionNameUnderscore)
+    } else {
+      const relationshipsLoaded = uniqunize(Object.keys(model.relationships).concat(Object.keys(model.relationshipsCache)))
+
+      throw new Error(`${reflectionName} hasnt been loaded yet on ${model.modelClassData().name}. Loaded was: ${relationshipsLoaded.join(", ")}`)
+    }
+  }
+
+  // Replaces the relationships with the given new collection.
+  set(newCollection) {
+    this.args.model.relationships[this.args.reflectionName] = newCollection
+  }
+
+  // Pushes another model onto the given collection.
+  push(newModel) {
+    if (!(this.args.reflectionName in this.args.model.relationships)) {
+      this.args.model.relationships[this.args.reflectionName] = []
+    }
+
+    this.args.model.relationships[this.args.reflectionName].push(newModel)
+  }
+
+  // Array shortcuts
+  find = (...args) => this.loaded().find(...args)
+  forEach = (...args) => this.loaded().forEach(...args)
+  map = (...args) => this.loaded().map(...args)
+
+  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 = incorporate(params, this.queryArgs.params)
@@ -122,44 +177,47 @@ class ApiMakerCollection {
     if (this.queryArgs.preload) params.preload = this.queryArgs.preload
     if (this.queryArgs.page) params.page = this.queryArgs.page
     if (this.queryArgs.per) params.per = this.queryArgs.per
+    if (this.queryArgs.search) params.search = this.queryArgs.search
     if (this.queryArgs.select) params.select = this.queryArgs.select
     if (this.queryArgs.selectColumns) params.select_columns = this.queryArgs.selectColumns
 
     return params
   }
 
-  per (per) {
+  per(per) {
     return this._merge({per})
   }
 
-  perKey (perKey) {
+  perKey(perKey) {
     return this._merge({perKey})
   }
 
-  ransack (params) {
-    if (params) {
-      this._merge({ransack: params})
-    }
-
+  ransack(params) {
+    if (params) this._merge({ransack: params})
     return this
   }
 
-  async result () {
+  async result() {
     const response = await this._response()
     const models = digg(response, "collection")
 
-    this._addCollectionToModels(models)
+    this._addQueryToModels(models)
 
     const result = new Result({collection: this, models, response})
 
     return result
   }
 
-  searchKey (searchKey) {
+  search(params) {
+    if (params) this._merge({search: params})
+    return this
+  }
+
+  searchKey(searchKey) {
     return this._merge({searchKey})
   }
 
-  select (originalSelect) {
+  select(originalSelect) {
     const newSelect = {}
 
     for (const originalModelName in originalSelect) {
@@ -178,7 +236,7 @@ class ApiMakerCollection {
     return this._merge({select: newSelect})
   }
 
-  selectColumns (originalSelect) {
+  selectColumns(originalSelect) {
     const newSelect = {}
 
     for (const originalModelName in originalSelect) {
@@ -197,45 +255,45 @@ 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()
     const models = digg(response, "collection")
 
-    this._addCollectionToModels(models)
+    this._addQueryToModels(models)
 
     return models
   }
 
-  modelClass () {
+  modelClass() {
     const modelName = digg(this.args.modelClass.modelClassData(), "name")
 
     return modelClassRequire(modelName)
   }
 
-  clone () {
+  clone() {
     const clonedQueryArgs = cloneDeep(this.queryArgs)
 
     return new ApiMakerCollection(this.args, clonedQueryArgs)
   }
 
   // This is needed when reloading a version of the model with the same selected attributes and preloads
-  _addCollectionToModels(models) {
+  _addQueryToModels(models) {
     for(const model of models) {
       model.collection = this
     }
   }
 
-  _merge (newQueryArgs) {
+  _merge(newQueryArgs) {
     incorporate(this.queryArgs, newQueryArgs)
 
     return this
   }
 
-  _response () {
+  _response() {
     const modelClassData = this.args.modelClass.modelClassData()
 
     return CommandsPool.addCommand(
@@ -249,7 +307,3 @@ class ApiMakerCollection {
     )
   }
 }
-
-ApiMakerCollection.apiMakerType = "Collection"
-
-export default ApiMakerCollection

package/src/{command-submit-data.mjs → command-submit-data.js}

@@ -7,13 +7,8 @@ export default class ApiMakerCommandSubmitData {
     this.jsonData = this.traverseObject(this.data, "json")
   }
 
-  getFilesCount () {
-    return this.filesCount
-  }
-
-  getJsonData () {
-    return this.jsonData
-  }
+  getFilesCount = () => this.filesCount
+  getJsonData = () => this.jsonData
 
   getRawData () {
     if (!this.rawData) {

package/src/{commands-pool.mjs → commands-pool.js}

@@ -1,18 +1,21 @@
-import Api from "./api.mjs"
-import CommandSubmitData from "./command-submit-data.mjs"
-import CustomError from "./custom-error.mjs"
-import DestroyError from "./destroy-error.mjs"
-import Deserializer from "./deserializer.mjs"
+import Api from "./api"
+import CommandSubmitData from "./command-submit-data"
+import CustomError from "./custom-error"
+import DestroyError from "./destroy-error"
+import Deserializer from "./deserializer"
 import {dig, digg} from "diggerize"
+import events from "./events"
 import FormDataObjectizer from "form-data-objectizer"
-import Serializer from "./serializer.mjs"
-import ValidationError from "./validation-error.mjs"
-import {ValidationErrors} from "./validation-errors.mjs"
+import RunLast from "./run-last"
+import Serializer from "./serializer"
+import SessionStatusUpdater from "./session-status-updater"
+import ValidationError from "./validation-error"
+import {ValidationErrors} from "./validation-errors"
 
 const shared = {}
 
 export default class ApiMakerCommandsPool {
-  static addCommand (data, args = {}) {
+  static addCommand(data, args = {}) {
     let pool
 
     if (args.instant) {
@@ -24,25 +27,25 @@ export default class ApiMakerCommandsPool {
     const promiseResult = pool.addCommand(data)
 
     if (args.instant) {
-      pool.flush()
+      pool.flushRunLast.run()
     } else {
-      pool.setFlushTimeout()
+      pool.flushRunLast.queue()
     }
 
     return promiseResult
   }
 
-  static current () {
+  static current() {
     if (!shared.currentApiMakerCommandsPool) shared.currentApiMakerCommandsPool = new ApiMakerCommandsPool()
 
     return shared.currentApiMakerCommandsPool
   }
 
-  static flush () {
+  static flush() {
     ApiMakerCommandsPool.current().flush()
   }
 
-  constructor () {
+  constructor() {
     this.flushCount = 0
     this.pool = {}
     this.poolData = {}
@@ -50,7 +53,9 @@ export default class ApiMakerCommandsPool {
     this.globalRequestData = {}
   }
 
-  addCommand (data) {
+  addCommand(data) {
+    const stack = Error().stack
+
     return new Promise((resolve, reject) => {
       const id = this.currentId
       this.currentId += 1
@@ -59,7 +64,7 @@ export default class ApiMakerCommandsPool {
       const commandName = data.command
       const collectionName = data.collectionName
 
-      this.pool[id] = {resolve, reject}
+      this.pool[id] = {resolve, reject, stack}
 
       if (!this.poolData[commandType]) this.poolData[commandType] = {}
       if (!this.poolData[commandType][collectionName]) this.poolData[commandType][collectionName] = {}
@@ -85,17 +90,37 @@ export default class ApiMakerCommandsPool {
     })
   }
 
-  commandsCount () {
+  commandsCount() {
     return Object.keys(this.pool)
   }
 
-  async flush () {
+  async sendRequest({commandSubmitData, url}) {
+    let response
+
+    for (let i = 0; i < 3; i++) {
+      if (commandSubmitData.getFilesCount() > 0) {
+        response = await Api.requestLocal({path: url, method: "POST", rawData: commandSubmitData.getFormData()})
+      } else {
+        response = await Api.requestLocal({path: url, method: "POST", data: commandSubmitData.getJsonData()})
+      }
+
+      if (response.success === false && response.type == "invalid_authenticity_token") {
+        console.log("Invalid authenticity token - try again")
+        await SessionStatusUpdater.current().updateSessionStatus()
+        continue
+      }
+
+      return response
+    }
+
+    throw new Error("Couldnt successfully execute request")
+  }
+
+  flush = async () => {
     if (this.commandsCount() == 0) {
       return
     }
 
-    this.clearTimeout()
-
     const currentPool = this.pool
     const currentPoolData = this.poolData
 
@@ -111,14 +136,7 @@ export default class ApiMakerCommandsPool {
 
       const commandSubmitData = new CommandSubmitData(submitData)
       const url = "/api_maker/commands"
-
-      let response
-
-      if (commandSubmitData.getFilesCount() > 0) {
-        response = await Api.requestLocal({path: url, method: "POST", rawData: commandSubmitData.getFormData()})
-      } else {
-        response = await Api.requestLocal({path: url, method: "POST", data: commandSubmitData.getJsonData()})
-      }
+      const response = await this.sendRequest({commandSubmitData, url})
 
       for (const commandId in response.responses) {
         const commandResponse = response.responses[commandId]
@@ -137,7 +155,12 @@ export default class ApiMakerCommandsPool {
         if (responseType == "success") {
           commandData.resolve(commandResponseData)
         } else if (responseType == "error") {
-          commandData.reject(new CustomError("Command error", {response: commandResponseData}))
+          const error = new CustomError("Command error", {response: commandResponseData})
+
+          error.stack += "\n"
+          error.stack += commandData.stack.split("\n").slice(1).join("\n")
+
+          commandData.reject(error)
         } else if (responseType == "failed") {
           this.handleFailedResponse(commandData, commandResponseData)
         } else {
@@ -149,7 +172,7 @@ export default class ApiMakerCommandsPool {
     }
   }
 
-  handleFailedResponse (commandData, commandResponseData) {
+  handleFailedResponse(commandData, commandResponseData) {
     let error
 
     if (commandResponseData.error_type == "destroy_error") {
@@ -160,6 +183,8 @@ export default class ApiMakerCommandsPool {
         validationErrors: digg(commandResponseData, "validation_errors")
       })
       error = new ValidationError(validationErrors, {response: commandResponseData})
+
+      events.emit("onValidationErrors", validationErrors)
     } else {
       let errorMessage
 
@@ -171,13 +196,7 @@ export default class ApiMakerCommandsPool {
     commandData.reject(error)
   }
 
-  clearTimeout () {
-    if (this.flushTimeout) {
-      clearTimeout(this.flushTimeout)
-    }
-  }
-
-  isActive () {
+  isActive() {
     if (this.commandsCount() > 0) {
       return true
     }
@@ -189,8 +208,5 @@ export default class ApiMakerCommandsPool {
     return false
   }
 
-  setFlushTimeout () {
-    this.clearTimeout()
-    this.flushTimeout = setTimeout(() => this.flush(), 0)
-  }
+  flushRunLast = new RunLast(this.flush)
 }

package/src/compose.js

@@ -0,0 +1,11 @@
+export default function apiMakerCompose(wrappedComponentClass, ...funcs) {
+  if (!wrappedComponentClass) throw new Error("No 'wrappedComponentClass' given")
+
+  let currentComponentClass = wrappedComponentClass
+
+  for (const func of funcs) {
+    currentComponentClass = func(currentComponentClass)
+  }
+
+  return currentComponentClass
+}

package/src/{config.mjs → config.js}

@@ -1,4 +1,4 @@
-import inflection from "inflection"
+import * as inflection from "inflection"
 
 const accessors = {
   breakPoints: {
@@ -12,10 +12,14 @@ const accessors = {
     ],
     required: true
   },
+  cableUrl: {require: false},
   currenciesCollection: {required: true},
-  history: {required: false},
+  history: {required: true},
   host: {required: false},
   i18n: {required: false},
+  linkTo: {required: true},
+  modal: {required: false},
+  navigation: {required: true},
   routes: {required: false},
   routeDefinitions: {required: false}
 }

package/src/{custom-error.mjs → custom-error.js}

@@ -1,4 +1,4 @@
-import BaseError from "./base-error.mjs"
+import BaseError from "./base-error"
 
 class CustomError extends BaseError {}
 

package/src/data-set-to-attributes.js

@@ -0,0 +1,13 @@
+import * as inflection from "inflection"
+
+export default function dataSetToAttributes(dataSet) {
+  const result = {}
+
+  for (const key in dataSet) {
+    const dasherizedKey = `data-${inflection.dasherize(inflection.underscore(key))}`
+
+    result[dasherizedKey] = dataSet[key]
+  }
+
+  return result
+}

package/src/{deserializer.mjs → deserializer.js}

@@ -1,7 +1,7 @@
 import {digg} from "diggerize"
-import inflection from "inflection"
-import modelClassRequire from "./model-class-require.mjs"
-import ModelsResponseReader from "./models-response-reader.mjs"
+import * as inflection from "inflection"
+import modelClassRequire from "./model-class-require"
+import ModelsResponseReader from "./models-response-reader"
 import Money from "js-money"
 
 export default class ApiMakerDeserializer {

package/src/destroy-error.js

@@ -0,0 +1,7 @@
+import CustomError from "./custom-error"
+
+class DestroyError extends CustomError {}
+
+DestroyError.apiMakerType = "DestroyError"
+
+export default DestroyError