@kaspernj/api-maker 1.0.123 → 1.0.127

package/src/api.cjs

@@ -3,23 +3,23 @@ const FormDataObjectizer = require("form-data-objectizer")
 const qs = require("qs")
 
 module.exports = class Api {
-  static get(path, pathParams = null) {
+  static get (path, pathParams = null) {
     return this.requestLocal({path, pathParams, method: "GET"})
   }
 
-  static delete(path, pathParams = null) {
+  static delete (path, pathParams = null) {
     return this.requestLocal({path, pathParams, method: "DELETE"})
   }
 
-  static patch(path, data = {}) {
+  static patch (path, data = {}) {
     return this.requestLocal({path, data, method: "PATCH"})
   }
 
-  static post(path, data = {}) {
+  static post (path, data = {}) {
     return this.requestLocal({path, data, method: "POST"})
   }
 
-  static request(args) {
+  static request (args) {
     let path = args.path
 
     if (args.pathParams) {
@@ -32,7 +32,7 @@ module.exports = class Api {
       xhr.open(args.method, path, true)
 
       if (args.headers) {
-        for(const headerName in args.headers) {
+        for (const headerName in args.headers) {
           xhr.setRequestHeader(headerName, args.headers[headerName])
         }
       }
@@ -59,41 +59,41 @@ module.exports = class Api {
     })
   }
 
-  static requestLocal(args) {
+  static requestLocal (args) {
     if (!args.headers) {
-      args["headers"] = {}
+      args.headers = {}
     }
 
     const token = this._token()
 
     if (token) {
-      args["headers"]["X-CSRF-Token"] = token
+      args.headers["X-CSRF-Token"] = token
     }
 
     if (args.data) {
-      args["headers"]["Content-Type"] = "application/json"
-      args["data"] = JSON.stringify(args.data)
+      args.headers["Content-Type"] = "application/json"
+      args.data = JSON.stringify(args.data)
     }
 
     if (args.rawData) {
-      args["data"] = args.rawData
+      args.data = args.rawData
     }
 
     return this.request(args)
   }
 
-  static put(path, data = {}) {
+  static put (path, data = {}) {
     return this.requestLocal({path, data, method: "PUT"})
   }
 
-  static _token() {
+  static _token () {
     const tokenElement = document.querySelector("meta[name='csrf-token']")
 
     if (tokenElement)
       return tokenElement.getAttribute("content")
   }
 
-  static _parseResponse(xhr) {
+  static _parseResponse (xhr) {
     const responseType = xhr.getResponseHeader("content-type")
 
     if (responseType && responseType.startsWith("application/json")) {

package/src/base-model.cjs

@@ -16,11 +16,11 @@ const {ValidationErrors} = require("./validation-errors.cjs")
 const shared = {}
 
 module.exports = class BaseModel {
-  static modelClassData() {
+  static modelClassData () {
     throw new Error("modelClassData should be overriden by child")
   }
 
-  static async find(id) {
+  static async find (id) {
     const primaryKeyName = this.modelClassData().primaryKey
     const query = {}
     query[`${primaryKeyName}_eq`] = id
@@ -34,30 +34,30 @@ module.exports = class BaseModel {
     }
   }
 
-  static async findOrCreateBy(findOrCreateByArgs, args = {}) {
+  static async findOrCreateBy (findOrCreateByArgs, args = {}) {
     const result = await Services.current().sendRequest("Models::FindOrCreateBy", {
       additional_data: args.additionalData,
       find_or_create_by_args: findOrCreateByArgs,
-      resource_name: digg(this.modelClassData(), "name"),
+      resource_name: digg(this.modelClassData(), "name")
     })
     const model = digg(result, "model")
 
     return model
   }
 
-  static modelName() {
+  static modelName () {
     return new ModelName({i18n: shared.i18n, modelClassData: this.modelClassData()})
   }
 
-  static ransack(query = {}) {
+  static ransack (query = {}) {
     return new Collection({modelClass: this}, {ransack: query})
   }
 
-  static setI18n(i18n) {
+  static setI18n (i18n) {
     shared.i18n = i18n
   }
 
-  constructor(args = {}) {
+  constructor (args = {}) {
     this.changes = {}
     this.newRecord = args.isNewRecord
     this.relationshipsCache = {}
@@ -76,8 +76,8 @@ module.exports = class BaseModel {
     }
   }
 
-  assignAttributes(newAttributes) {
-    for(const key in newAttributes) {
+  assignAttributes (newAttributes) {
+    for (const key in newAttributes) {
       const newValue = newAttributes[key]
 
       let applyChange = true
@@ -103,11 +103,11 @@ module.exports = class BaseModel {
     }
   }
 
-  attributes() {
+  attributes () {
     return digg(this, "modelData")
   }
 
-  can(givenAbilityName) {
+  can (givenAbilityName) {
     const abilityName = inflection.underscore(givenAbilityName)
 
     if (!(abilityName in this.abilities)) {
@@ -117,17 +117,17 @@ module.exports = class BaseModel {
     return this.abilities[abilityName]
   }
 
-  clone() {
-    const clone = new this.constructor
+  clone () {
+    const clone = new this.constructor()
 
-    clone.abilities = Object.assign({}, this.abilities)
-    clone.modelData = Object.assign({}, this.modelData)
-    clone.relationshipsCache = Object.assign({}, this.relationshipsCache)
+    clone.abilities = {...this.abilities}
+    clone.modelData = {...this.modelData}
+    clone.relationshipsCache = {...this.relationshipsCache}
 
     return clone
   }
 
-  cacheKey() {
+  cacheKey () {
     if (this.isPersisted()) {
       const keyParts = [
         this.modelClassData().paramKey,
@@ -152,7 +152,11 @@ module.exports = class BaseModel {
     }
   }
 
-  async create(attributes, options) {
+  static all () {
+    return this.ransack()
+  }
+
+  async create (attributes, options) {
     if (attributes) this.assignAttributes(attributes)
     const paramKey = this.modelClassData().paramKey
     const modelData = this.getAttributes()
@@ -186,7 +190,7 @@ module.exports = class BaseModel {
     return {model: this, response}
   }
 
-  async createRaw(rawData, options = {}) {
+  async createRaw (rawData, options = {}) {
     const objectData = this._objectDataFromGivenRawData(rawData, options)
 
     let response
@@ -200,7 +204,8 @@ module.exports = class BaseModel {
           command: `${this.modelClassData().collectionName}-create`,
           collectionName: this.modelClassData().collectionName,
           primaryKey: this.primaryKey(),
-          type: "create"},
+          type: "create"
+        },
         {}
       )
     } catch (error) {
@@ -216,7 +221,7 @@ module.exports = class BaseModel {
     return {model: this, response}
   }
 
-  async destroy() {
+  async destroy () {
     const response = await CommandsPool.addCommand(
       {
         args: {query_params: this.collection && this.collection.params()},
@@ -236,11 +241,11 @@ module.exports = class BaseModel {
 
       return {model: this, response}
     } else {
-      handleResponseError(response)
+      this.handleResponseError(response)
     }
   }
 
-  async ensureAbilities(listOfAbilities) {
+  async ensureAbilities (listOfAbilities) {
     // Populate an array with a list of abilities currently not loaded
     const abilitiesToLoad = []
 
@@ -275,27 +280,27 @@ module.exports = class BaseModel {
     }
   }
 
-  getAttributes() {
+  getAttributes () {
     return Object.assign(this.modelData, this.changes)
   }
 
-  handleResponseError(response) {
+  handleResponseError (response) {
     this.parseValidationErrors(response)
     throw new new CustomError("Response wasn't successful", {model: this, response})
   }
 
-  identifierKey() {
+  identifierKey () {
     if (!this._identifierKey) this._identifierKey = this.isPersisted() ? this.primaryKey() : this.uniqueKey()
 
     return this._identifierKey
   }
 
-  isAssociationLoaded(associationName) {
+  isAssociationLoaded (associationName) {
     if (associationName in this.relationshipsCache) return true
     return false
   }
 
-  parseValidationErrors(error, options) {
+  parseValidationErrors (error, options) {
     if (!(error instanceof CustomError)) return
     if (!error.args.response.validation_errors) return
 
@@ -311,24 +316,24 @@ module.exports = class BaseModel {
     }
   }
 
-  sendValidationErrorsEvent(validationErrors, options) {
+  sendValidationErrorsEvent (validationErrors, options) {
     if (options && options.form) {
       const event = this.newCustomEvent(validationErrors)
       options.form.dispatchEvent(event)
     }
   }
 
-  newCustomEvent(validationErrors) {
+  newCustomEvent (validationErrors) {
     return new CustomEvent("validation-errors", {detail: validationErrors})
   }
 
-  static humanAttributeName(attributeName) {
+  static humanAttributeName (attributeName) {
     const keyName = digg(this.modelClassData(), "i18nKey")
 
     return shared.i18n.t(`activerecord.attributes.${keyName}.${BaseModel.snakeCase(attributeName)}`, {defaultValue: attributeName})
   }
 
-  isAttributeChanged(attributeName) {
+  isAttributeChanged (attributeName) {
     const attributeNameUnderscore = inflection.underscore(attributeName)
     const attributeData = this.modelClassData().attributes.find((attribute) => digg(attribute, "name") == attributeNameUnderscore)
 
@@ -351,7 +356,7 @@ module.exports = class BaseModel {
     return changedMethod(oldValue, newValue)
   }
 
-  isChanged() {
+  isChanged () {
     const keys = Object.keys(this.changes)
 
     if (keys.length > 0) {
@@ -361,7 +366,7 @@ module.exports = class BaseModel {
     }
   }
 
-  isNewRecord() {
+  isNewRecord () {
     if (this.newRecord === false) {
       return false
     } else if ("id" in this.modelData && this.modelData.id) {
@@ -371,23 +376,23 @@ module.exports = class BaseModel {
     }
   }
 
-  isPersisted() {
+  isPersisted () {
     return !this.isNewRecord()
   }
 
-  static snakeCase(string) {
+  static snakeCase (string) {
     return inflection.underscore(string)
   }
 
-  savedChangeToAttribute(attributeName) {
+  savedChangeToAttribute (attributeName) {
     if (!this.previousModelData)
       return false
 
     const attributeNameUnderscore = inflection.underscore(attributeName)
-    const attributeData = this.modelClassData().attributes.find(attribute => attribute.name == attributeNameUnderscore)
+    const attributeData = this.modelClassData().attributes.find((attribute) => attribute.name == attributeNameUnderscore)
 
     if (!attributeData) {
-      const attributeNames = this.modelClassData().attributes.map(attribute => attribute.name)
+      const attributeNames = this.modelClassData().attributes.map((attribute) => attribute.name)
       throw new Error(`Couldn't find an attribute by that name: "${attributeName}" in: ${attributeNames.join(", ")}`)
     }
 
@@ -405,27 +410,27 @@ module.exports = class BaseModel {
     return changedMethod(oldValue, newValue)
   }
 
-  setNewModel(model) {
+  setNewModel (model) {
     this.setNewModelData(model)
     this.relationshipsCache = digg(model, "relationshipsCache")
   }
 
-  setNewModelData(model) {
+  setNewModelData (model) {
     this.previousModelData = digg(this, "modelData")
     this.modelData = digg(model, "modelData")
   }
 
-  _isDateChanged(oldValue, newValue) {
+  _isDateChanged (oldValue, newValue) {
     if (Date.parse(oldValue) != Date.parse(newValue))
       return true
   }
 
-  _isIntegerChanged(oldValue, newValue) {
-    if (parseInt(oldValue) != parseInt(newValue))
+  _isIntegerChanged (oldValue, newValue) {
+    if (parseInt(oldValue, 10) != parseInt(newValue, 10))
       return true
   }
 
-  _isStringChanged(oldValue, newValue) {
+  _isStringChanged (oldValue, newValue) {
     const oldConvertedValue = `${oldValue}`
     const newConvertedValue = `${newValue}`
 
@@ -433,11 +438,11 @@ module.exports = class BaseModel {
       return true
   }
 
-  modelClassData() {
+  modelClassData () {
     return this.constructor.modelClassData()
   }
 
-  async reload() {
+  async reload () {
     const params = this.collection && this.collection.params()
     const primaryKeyName = this.modelClassData().primaryKey
     const ransackParams = {}
@@ -464,7 +469,7 @@ module.exports = class BaseModel {
     this.changes = {}
   }
 
-  save() {
+  save () {
     if (this.isNewRecord()) {
       return this.create()
     } else {
@@ -472,7 +477,7 @@ module.exports = class BaseModel {
     }
   }
 
-  saveRaw(rawData, options = {}) {
+  saveRaw (rawData, options = {}) {
     if (this.isNewRecord()) {
       return this.createRaw(rawData, options)
     } else {
@@ -480,7 +485,7 @@ module.exports = class BaseModel {
     }
   }
 
-  async update(newAttributes, options) {
+  async update (newAttributes, options) {
     if (newAttributes)
       this.assignAttributes(newAttributes)
 
@@ -521,21 +526,21 @@ module.exports = class BaseModel {
 
       return {response, model: this}
     } else {
-      handleResponseError(response)
+      this.handleResponseError(response)
     }
   }
 
-  _refreshModelFromResponse(response) {
+  _refreshModelFromResponse (response) {
     const newModel = ModelsResponseReader.first(digg(response, "model"))
     this.setNewModel(newModel)
   }
 
-  _refreshModelDataFromResponse(response) {
+  _refreshModelDataFromResponse (response) {
     const newModel = ModelsResponseReader.first(digg(response, "model"))
     this.setNewModelData(newModel)
   }
 
-  _objectDataFromGivenRawData(rawData, options) {
+  _objectDataFromGivenRawData (rawData, options) {
     if (rawData instanceof FormData || rawData.nodeName == "FORM") {
       const formData = FormDataObjectizer.formDataFromObject(rawData, options)
 
@@ -545,7 +550,7 @@ module.exports = class BaseModel {
     return rawData
   }
 
-  async updateRaw(rawData, options = {}) {
+  async updateRaw (rawData, options = {}) {
     const objectData = this._objectDataFromGivenRawData(rawData, options)
 
     let response
@@ -577,11 +582,11 @@ module.exports = class BaseModel {
     return {response, model: this}
   }
 
-  isValid() {
+  isValid () {
     throw new Error("Not implemented yet")
   }
 
-  async isValidOnServer() {
+  async isValidOnServer () {
     const modelData = this.getAttributes()
     const paramKey = this.modelClassData().paramKey
     const dataToUse = {}
@@ -603,18 +608,18 @@ module.exports = class BaseModel {
     return {valid: response.valid, errors: response.errors}
   }
 
-  modelClass() {
+  modelClass () {
     return this.constructor
   }
 
-  preloadRelationship(relationshipName, model) {
+  preloadRelationship (relationshipName, model) {
     this.relationshipsCache[BaseModel.snakeCase(relationshipName)] = model
   }
 
-  uniqueKey() {
+  uniqueKey () {
     if (!this.uniqueKeyValue) {
-      const min = 500000000000000000
-      const max = 999999999999999999
+      const min = 5000000000000000
+      const max = 9007199254740991
       const randomBetween = Math.floor(Math.random() * (max - min + 1) + min)
       this.uniqueKeyValue = randomBetween
     }
@@ -622,15 +627,15 @@ module.exports = class BaseModel {
     return this.uniqueKeyValue
   }
 
-  static _callCollectionCommand(args, commandArgs) {
+  static _callCollectionCommand (args, commandArgs) {
     return CommandsPool.addCommand(args, commandArgs)
   }
 
-  _callMemberCommand(args, commandArgs) {
+  _callMemberCommand (args, commandArgs) {
     return CommandsPool.addCommand(args, commandArgs)
   }
 
-  static _postDataFromArgs(args) {
+  static _postDataFromArgs (args) {
     let postData
 
     if (args) {
@@ -646,13 +651,13 @@ module.exports = class BaseModel {
     return postData
   }
 
-  readAttribute(attributeName) {
+  readAttribute (attributeName) {
     const attributeNameUnderscore = inflection.underscore(attributeName)
 
     return this.readAttributeUnderscore(attributeNameUnderscore)
   }
 
-  readAttributeUnderscore(attributeName) {
+  readAttributeUnderscore (attributeName) {
     if (attributeName in this.changes) {
       return this.changes[attributeName]
     } else if (attributeName in this.modelData) {
@@ -667,7 +672,7 @@ module.exports = class BaseModel {
     throw new AttributeNotLoadedError(`No such attribute: ${digg(this.modelClassData(), "name")}#${attributeName}`)
   }
 
-  isAttributeLoaded(attributeName) {
+  isAttributeLoaded (attributeName) {
     const attributeNameUnderscore = inflection.underscore(attributeName)
 
     if (attributeNameUnderscore in this.changes) return true
@@ -675,7 +680,7 @@ module.exports = class BaseModel {
     return false
   }
 
-  _isPresent(value) {
+  _isPresent (value) {
     if (!value) {
       return false
     } else if (typeof value == "string" && value.match(/^\s*$/)) {
@@ -685,7 +690,7 @@ module.exports = class BaseModel {
     return true
   }
 
-  async _loadBelongsToReflection(args, queryArgs = {}) {
+  async _loadBelongsToReflection (args, queryArgs = {}) {
     if (args.reflectionName in this.relationshipsCache) {
       return this.relationshipsCache[args.reflectionName]
     } else {
@@ -696,7 +701,7 @@ module.exports = class BaseModel {
     }
   }
 
-  _readBelongsToReflection({reflectionName}) {
+  _readBelongsToReflection ({reflectionName}) {
     if (!(reflectionName in this.relationshipsCache)) {
       if (this.isNewRecord())
         return null
@@ -710,7 +715,7 @@ module.exports = class BaseModel {
     return this.relationshipsCache[reflectionName]
   }
 
-  async _loadHasManyReflection(args, queryArgs = {}) {
+  async _loadHasManyReflection (args, queryArgs = {}) {
     if (args.reflectionName in this.relationshipsCache) {
       return this.relationshipsCache[args.reflectionName]
     }
@@ -723,7 +728,7 @@ module.exports = class BaseModel {
     return models
   }
 
-  async _loadHasOneReflection(args, queryArgs = {}) {
+  async _loadHasOneReflection (args, queryArgs = {}) {
     if (args.reflectionName in this.relationshipsCache) {
       return this.relationshipsCache[args.reflectionName]
     } else {
@@ -736,7 +741,7 @@ module.exports = class BaseModel {
     }
   }
 
-  _readHasOneReflection({reflectionName}) {
+  _readHasOneReflection ({reflectionName}) {
     if (!(reflectionName in this.relationshipsCache)) {
       if (this.isNewRecord())
         return null
@@ -750,14 +755,14 @@ module.exports = class BaseModel {
     return this.relationshipsCache[reflectionName]
   }
 
-  _readModelDataFromArgs(args) {
+  _readModelDataFromArgs (args) {
     this.abilities = args.data.b || {}
     this.collection = args.collection
     this.modelData = args.data.a
     this.preloadedRelationships = args.data.r
   }
 
-  _readPreloadedRelationships(preloaded) {
+  _readPreloadedRelationships (preloaded) {
     if (!this.preloadedRelationships) {
       return
     }
@@ -787,7 +792,7 @@ module.exports = class BaseModel {
       } else if (Array.isArray(relationshipData)) {
         const result = []
 
-        for(const relationshipId of relationshipData) {
+        for (const relationshipId of relationshipData) {
           const model = preloaded.getModel(relationshipType, relationshipId)
 
           result.push(model)
@@ -801,11 +806,11 @@ module.exports = class BaseModel {
     }
   }
 
-  primaryKey() {
+  primaryKey () {
     return this.readAttributeUnderscore(digg(this.modelClassData(), "primaryKey"))
   }
 
-  static _token() {
+  static _token () {
     const csrfTokenElement = document.querySelector("meta[name='csrf-token']")
 
     if (csrfTokenElement) {

package/src/cable-connection-pool.cjs

@@ -3,21 +3,21 @@ const CableSubscription = require("./cable-subscription.cjs")
 const {dig} = require("diggerize")
 
 module.exports = class ApiMakerCableConnectionPool {
-  static current() {
+  static current () {
     if (!global.apiMakerCableConnectionPool)
       global.apiMakerCableConnectionPool = new ApiMakerCableConnectionPool()
 
     return global.apiMakerCableConnectionPool
   }
 
-  constructor() {
+  constructor () {
     this.cableSubscriptionPools = []
     this.connections = {}
     this.upcomingSubscriptionData = {}
     this.upcomingSubscriptions = {}
   }
 
-  connectEventToExistingSubscription({path, subscription, value}) {
+  connectEventToExistingSubscription ({path, subscription, value}) {
     for (const cableSubscriptionPool of this.cableSubscriptionPools) {
       if (!cableSubscriptionPool.isConnected()) {
         continue
@@ -46,7 +46,7 @@ module.exports = class ApiMakerCableConnectionPool {
     return false
   }
 
-  connectModelEvent({callback, path, value}) {
+  connectModelEvent ({callback, path, value}) {
     const subscription = new CableSubscription()
 
     subscription.events.addListener("received", callback)
@@ -102,27 +102,27 @@ module.exports = class ApiMakerCableConnectionPool {
     return subscription
   }
 
-  connectCreated(modelName, callback) {
+  connectCreated (modelName, callback) {
     return this.connectModelEvent({callback, value: true, path: [modelName, "creates"]})
   }
 
-  connectEvent(modelName, modelId, eventName, callback) {
+  connectEvent (modelName, modelId, eventName, callback) {
     return this.connectModelEvent({callback, value: modelId, path: [modelName, "events", eventName]})
   }
 
-  connectDestroyed(modelName, modelId, callback) {
+  connectDestroyed (modelName, modelId, callback) {
     return this.connectModelEvent({callback, value: modelId, path: [modelName, "destroys"]})
   }
 
-  connectModelClassEvent(modelName, eventName, callback) {
+  connectModelClassEvent (modelName, eventName, callback) {
     return this.connectModelEvent({callback, value: eventName, path: [modelName, "model_class_events"]})
   }
 
-  connectUpdate(modelName, modelId, callback) {
+  connectUpdate (modelName, modelId, callback) {
     return this.connectModelEvent({callback, value: modelId, path: [modelName, "updates"]})
   }
 
-  connectUpcoming() {
+  connectUpcoming () {
     const subscriptionData = this.upcomingSubscriptionData
     const subscriptions = this.upcomingSubscriptions
 
@@ -137,7 +137,7 @@ module.exports = class ApiMakerCableConnectionPool {
     this.cableSubscriptionPools.push(cableSubscriptionPool)
   }
 
-  scheduleConnectUpcoming() {
+  scheduleConnectUpcoming () {
     if (this.scheduleConnectUpcomingTimeout)
       clearTimeout(this.scheduleConnectUpcomingTimeout)