@kaspernj/api-maker 1.0.126 → 1.0.129

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,11 +152,11 @@ module.exports = class BaseModel {
     }
   }
 
-  static all() {
+  static all () {
     return this.ransack()
   }
 
-  async create(attributes, options) {
+  async create (attributes, options) {
     if (attributes) this.assignAttributes(attributes)
     const paramKey = this.modelClassData().paramKey
     const modelData = this.getAttributes()
@@ -190,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
@@ -204,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) {
@@ -220,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()},
@@ -240,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 = []
 
@@ -279,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
 
@@ -315,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)
 
@@ -355,7 +356,7 @@ module.exports = class BaseModel {
     return changedMethod(oldValue, newValue)
   }
 
-  isChanged() {
+  isChanged () {
     const keys = Object.keys(this.changes)
 
     if (keys.length > 0) {
@@ -365,7 +366,7 @@ module.exports = class BaseModel {
     }
   }
 
-  isNewRecord() {
+  isNewRecord () {
     if (this.newRecord === false) {
       return false
     } else if ("id" in this.modelData && this.modelData.id) {
@@ -375,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(", ")}`)
     }
 
@@ -409,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}`
 
@@ -437,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 = {}
@@ -468,7 +469,7 @@ module.exports = class BaseModel {
     this.changes = {}
   }
 
-  save() {
+  save () {
     if (this.isNewRecord()) {
       return this.create()
     } else {
@@ -476,7 +477,7 @@ module.exports = class BaseModel {
     }
   }
 
-  saveRaw(rawData, options = {}) {
+  saveRaw (rawData, options = {}) {
     if (this.isNewRecord()) {
       return this.createRaw(rawData, options)
     } else {
@@ -484,7 +485,7 @@ module.exports = class BaseModel {
     }
   }
 
-  async update(newAttributes, options) {
+  async update (newAttributes, options) {
     if (newAttributes)
       this.assignAttributes(newAttributes)
 
@@ -525,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)
 
@@ -549,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
@@ -581,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 = {}
@@ -607,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
     }
@@ -626,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) {
@@ -650,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) {
@@ -671,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
@@ -679,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*$/)) {
@@ -689,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 {
@@ -700,7 +701,7 @@ module.exports = class BaseModel {
     }
   }
 
-  _readBelongsToReflection({reflectionName}) {
+  _readBelongsToReflection ({reflectionName}) {
     if (!(reflectionName in this.relationshipsCache)) {
       if (this.isNewRecord())
         return null
@@ -714,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]
     }
@@ -727,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 {
@@ -740,7 +741,7 @@ module.exports = class BaseModel {
     }
   }
 
-  _readHasOneReflection({reflectionName}) {
+  _readHasOneReflection ({reflectionName}) {
     if (!(reflectionName in this.relationshipsCache)) {
       if (this.isNewRecord())
         return null
@@ -754,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
     }
@@ -791,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)
@@ -805,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)