@kaspernj/api-maker 1.0.2053 → 1.0.2055

package/src/collection.js

@@ -1,346 +0,0 @@
-import cloneDeep from "clone-deep"
-import CommandsPool from "./commands-pool"
-import {digg} from "diggerize"
-import * as inflection from "inflection"
-import {incorporate} from "incorporator"
-import modelClassRequire from "./model-class-require"
-import Result from "./result"
-import uniqunize from "uniqunize"
-
-export default class ApiMakerCollection {
-  static apiMakerType = "Collection"
-
-  constructor(args, queryArgs = {}) {
-    this.queryArgs = queryArgs
-    this.args = args
-  }
-
-  abilities(originalAbilities) {
-    const newAbilities = {}
-
-    for (const originalAbilityName in originalAbilities) {
-      const newModelName = inflection.underscore(originalAbilityName)
-      const newValues = []
-      const originalValues = originalAbilities[originalAbilityName]
-
-      for (const originalAbilityName of originalValues) {
-        const newAbilityName = inflection.underscore(originalAbilityName)
-        newValues.push(newAbilityName)
-      }
-
-      newAbilities[newModelName] = newValues
-    }
-
-    return this._merge({abilities: newAbilities})
-  }
-
-  accessibleBy(abilityName) {
-    return this._merge({accessibleBy: inflection.underscore(abilityName)})
-  }
-
-  async count() {
-    const response = await this.clone()._merge({count: true})._response()
-
-    return digg(response, "count")
-  }
-
-  distinct() {
-    return this._merge({distinct: true})
-  }
-
-  async each(callback) {
-    const array = await this.toArray()
-
-    for (const model in array) {
-      callback.call(model)
-    }
-  }
-
-  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) {
-    const arrayOfTablesAndColumnsWithLowercaseColumns = arrayOfTablesAndColumns.map((tableAndColumn) => {
-      if (Array.isArray(tableAndColumn)) {
-        return [tableAndColumn[0], tableAndColumn[1].toLowerCase()]
-      } else {
-        return tableAndColumn.toLowerCase()
-      }
-    })
-    const currentGroupBy = this.queryArgs.groupBy || []
-    const newGroupBy = currentGroupBy.concat(arrayOfTablesAndColumnsWithLowercaseColumns)
-
-    return this._merge({
-      groupBy: newGroupBy
-    })
-  }
-
-  async ensureLoaded() {
-    if (!this.isLoaded()) {
-      const models = await this.toArray()
-
-      this.set(models)
-    }
-
-    return this.loaded()
-  }
-
-  isLoaded() {
-    const {model, reflectionName} = this.args
-
-    if (reflectionName in model.relationshipsCache) {
-      return true
-    } else if (reflectionName in model.relationships) {
-      return true
-    }
-
-    return false
-  }
-
-  limit(amount) {
-    return this._merge({limit: amount})
-  }
-
-  preloaded() {
-    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]
-  }
-
-  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) {
-    const {model, reflectionName} = this.args
-
-    if (!(reflectionName in model.relationships)) {
-      model.relationships[reflectionName] = []
-    }
-
-    if (!model.relationships[reflectionName].includes(newModel)) {
-      model.relationships[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) {
-    if (!page) page = 1
-
-    return this._merge({page})
-  }
-
-  pageKey(pageKey) {
-    return this._merge({pageKey})
-  }
-
-  isFiltered() {
-    const {queryArgs} = this
-
-    if (
-      queryArgs.accessibleBy ||
-      queryArgs.count ||
-      queryArgs.limit ||
-      queryArgs.page ||
-      queryArgs.params ||
-      queryArgs.per ||
-      queryArgs.ransack ||
-      queryArgs.search
-    ) {
-      return true
-    }
-
-    return false
-  }
-
-  params() {
-    let params = {}
-
-    if (this.queryArgs.params) params = incorporate(params, this.queryArgs.params)
-    if (this.queryArgs.abilities) params.abilities = this.queryArgs.abilities
-    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.groupBy) params.group_by = this.queryArgs.groupBy
-    if (this.queryArgs.ransack) params.q = this.queryArgs.ransack
-    if (this.queryArgs.limit) params.limit = this.queryArgs.limit
-    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) {
-    return this._merge({per})
-  }
-
-  perKey(perKey) {
-    return this._merge({perKey})
-  }
-
-  ransack(params) {
-    if (params) this._merge({ransack: params})
-    return this
-  }
-
-  async result() {
-    const response = await this._response()
-    const models = digg(response, "collection")
-
-    this._addQueryToModels(models)
-
-    const result = new Result({collection: this, models, response})
-
-    return result
-  }
-
-  search(params) {
-    if (params) this._merge({search: params})
-    return this
-  }
-
-  searchKey(searchKey) {
-    return this._merge({searchKey})
-  }
-
-  select(originalSelect) {
-    const newSelect = {}
-
-    for (const originalModelName in originalSelect) {
-      const newModelName = inflection.underscore(originalModelName)
-      const newValues = []
-      const originalValues = originalSelect[originalModelName]
-
-      for (const originalAttributeName of originalValues) {
-        const newAttributeName = inflection.underscore(originalAttributeName)
-        newValues.push(newAttributeName)
-      }
-
-      newSelect[newModelName] = newValues
-    }
-
-    return this._merge({select: newSelect})
-  }
-
-  selectColumns(originalSelect) {
-    const newSelect = {}
-
-    for (const originalModelName in originalSelect) {
-      const newModelName = inflection.underscore(inflection.underscore(originalModelName))
-      const newValues = []
-      const originalValues = originalSelect[originalModelName]
-
-      for (const originalAttributeName of originalValues) {
-        const newAttributeName = inflection.underscore(originalAttributeName)
-        newValues.push(newAttributeName)
-      }
-
-      newSelect[newModelName] = newValues
-    }
-
-    return this._merge({selectColumns: newSelect})
-  }
-
-  sort(sortBy) {
-    return this._merge({ransack: {s: sortBy}})
-  }
-
-  async toArray() {
-    const response = await this._response()
-    const models = digg(response, "collection")
-
-    this._addQueryToModels(models)
-
-    return models
-  }
-
-  modelClass() {
-    const modelName = digg(this.args.modelClass.modelClassData(), "name")
-
-    return modelClassRequire(modelName)
-  }
-
-  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
-  _addQueryToModels(models) {
-    for (const model of models) {
-      model.collection = this
-    }
-  }
-
-  _merge(newQueryArgs) {
-    incorporate(this.queryArgs, newQueryArgs)
-
-    return this
-  }
-
-  _response() {
-    const modelClassData = this.args.modelClass.modelClassData()
-
-    return CommandsPool.addCommand(
-      {
-        args: this.params(),
-        command: `${modelClassData.collectionName}-index`,
-        collectionName: modelClassData.collectionName,
-        type: "index"
-      },
-      {}
-    )
-  }
-}

package/src/command-submit-data.js

@@ -1,103 +0,0 @@
-import objectToFormData from "object-to-formdata"
-
-export default class ApiMakerCommandSubmitData {
-  constructor (data) {
-    this.data = data
-    this.filesCount = 0
-    this.jsonData = this.traverseObject(this.data, "json")
-  }
-
-  getFilesCount = () => this.filesCount
-  getJsonData = () => this.jsonData
-
-  getRawData () {
-    if (!this.rawData) {
-      this.rawData = this.traverseObject(this.data, "raw")
-    }
-
-    return this.rawData
-  }
-
-  getFormData () {
-    const objectForFormData = this.getRawData() || {}
-
-    objectForFormData.json = JSON.stringify(this.getJsonData())
-
-    const formData = objectToFormData.serialize(objectForFormData)
-
-    return formData
-  }
-
-  convertDynamic (value, type) {
-    if (Array.isArray(value)) {
-      return this.traverseArray(value, type)
-    } else if (typeof value == "object" && value !== null && value.constructor.name == "Object") {
-      return this.traverseObject(value, type)
-    } else {
-      return value
-    }
-  }
-
-  shouldSkip (object, type) {
-    if (type == "json" && object instanceof File) {
-      this.filesCount += 1
-      return true
-    }
-
-    if (type == "raw" && !Array.isArray(object) && !this.isObject(object) && !(object instanceof File)) {
-      return true
-    }
-
-    return false
-  }
-
-  isObject (value) {
-    if (typeof value == "object" && value !== null && value.constructor.name == "Object") {
-      return true
-    }
-
-    return false
-  }
-
-  traverseArray (array, type) {
-    const newArray = []
-
-    for (const value of array) {
-      if (this.shouldSkip(value, type)) {
-        continue
-      }
-
-      if (Array.isArray(value)) {
-        newArray.push(this.convertDynamic(value, type))
-      } else if (this.isObject(value)) {
-        newArray.push(this.convertDynamic(value, type))
-      } else {
-        newArray.push(value)
-      }
-    }
-
-    return newArray
-  }
-
-  traverseObject (object, type) {
-    const newObject = {}
-
-    for (const key in object) {
-      const value = object[key]
-
-      if (this.shouldSkip(value, type)) {
-        continue
-      }
-
-      if (Array.isArray(value)) {
-        newObject[key] = this.convertDynamic(value, type)
-      } else if (this.isObject(value)) {
-        newObject[key] = this.convertDynamic(value, type)
-      } else {
-        newObject[key] = value
-      }
-    }
-
-    return newObject
-  }
-}

package/src/commands-pool.js

@@ -1,212 +0,0 @@
-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 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 = {}) {
-    let pool
-
-    if (args.instant) {
-      pool = new ApiMakerCommandsPool()
-    } else {
-      pool = ApiMakerCommandsPool.current()
-    }
-
-    const promiseResult = pool.addCommand(data)
-
-    if (args.instant) {
-      pool.flushRunLast.run()
-    } else {
-      pool.flushRunLast.queue()
-    }
-
-    return promiseResult
-  }
-
-  static current() {
-    if (!shared.currentApiMakerCommandsPool) shared.currentApiMakerCommandsPool = new ApiMakerCommandsPool()
-
-    return shared.currentApiMakerCommandsPool
-  }
-
-  static flush() {
-    ApiMakerCommandsPool.current().flush()
-  }
-
-  constructor() {
-    this.flushCount = 0
-    this.pool = {}
-    this.poolData = {}
-    this.currentId = 1
-    this.globalRequestData = {}
-  }
-
-  addCommand(data) {
-    const stack = Error().stack
-
-    return new Promise((resolve, reject) => {
-      const id = this.currentId
-      this.currentId += 1
-
-      const commandType = data.type
-      const commandName = data.command
-      const collectionName = data.collectionName
-
-      this.pool[id] = {resolve, reject, stack}
-
-      if (!this.poolData[commandType]) this.poolData[commandType] = {}
-      if (!this.poolData[commandType][collectionName]) this.poolData[commandType][collectionName] = {}
-      if (!this.poolData[commandType][collectionName][commandName]) this.poolData[commandType][collectionName][commandName] = {}
-
-      let args
-
-      if (data.args?.nodeName == "FORM") {
-        const formData = new FormData(data.args)
-
-        args = FormDataObjectizer.toObject(formData)
-      } else if (data.args instanceof FormData) {
-        args = FormDataObjectizer.toObject(data.args)
-      } else {
-        args = Serializer.serialize(data.args)
-      }
-
-      this.poolData[commandType][collectionName][commandName][id] = {
-        args,
-        primary_key: data.primaryKey,
-        id
-      }
-    })
-  }
-
-  commandsCount() {
-    return Object.keys(this.pool)
-  }
-
-  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
-    }
-
-    const currentPool = this.pool
-    const currentPoolData = this.poolData
-
-    this.pool = {}
-    this.poolData = {}
-    this.flushCount++
-
-    try {
-      const submitData = {pool: currentPoolData}
-
-      if (Object.keys(this.globalRequestData).length > 0)
-        submitData.global = this.globalRequestData
-
-      const commandSubmitData = new CommandSubmitData(submitData)
-      const url = "/api_maker/commands"
-      const response = await this.sendRequest({commandSubmitData, url})
-
-      for (const commandId in response.responses) {
-        const commandResponse = response.responses[commandId]
-        const commandResponseData = Deserializer.parse(commandResponse.data)
-        const commandData = currentPool[parseInt(commandId, 10)]
-        const responseType = commandResponse.type
-
-        if (commandResponseData && typeof commandResponseData == "object") {
-          const bugReportUrl = dig(commandResponseData, "bug_report_url")
-
-          if (bugReportUrl) {
-            console.log(`Bug report URL: ${bugReportUrl}`)
-          }
-        }
-
-        if (responseType == "success") {
-          commandData.resolve(commandResponseData)
-        } else if (responseType == "error") {
-          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 {
-          throw new Error(`Unhandled response type: ${responseType}`)
-        }
-      }
-    } finally {
-      this.flushCount--
-    }
-  }
-
-  handleFailedResponse(commandData, commandResponseData) {
-    let error
-
-    if (commandResponseData.error_type == "destroy_error") {
-      error = new DestroyError(`Destroy failed`, {response: commandResponseData})
-    } else if (commandResponseData.error_type == "validation_error") {
-      const validationErrors = new ValidationErrors({
-        model: digg(commandResponseData, "model"),
-        validationErrors: digg(commandResponseData, "validation_errors")
-      })
-      error = new ValidationError(validationErrors, {response: commandResponseData})
-
-      events.emit("onValidationErrors", validationErrors)
-    } else {
-      let errorMessage
-
-      if (!commandResponseData.errors) { errorMessage = "Command failed" }
-
-      error = new CustomError(errorMessage, {response: commandResponseData})
-    }
-
-    commandData.reject(error)
-  }
-
-  isActive() {
-    if (this.commandsCount() > 0) {
-      return true
-    }
-
-    if (this.flushCount > 0) {
-      return true
-    }
-
-    return false
-  }
-
-  flushRunLast = new RunLast(this.flush)
-}

package/src/compose.js

@@ -1,11 +0,0 @@
-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
-}