@kaspernj/api-maker 1.0.246 → 1.0.248

package/package.json

@@ -16,7 +16,7 @@
     ]
   },
   "name": "@kaspernj/api-maker",
-  "version": "1.0.246",
+  "version": "1.0.248",
   "type": "module",
   "description": "",
   "main": "index.js",

package/src/commands-pool.mjs

@@ -6,6 +6,7 @@ import Deserializer from "./deserializer.mjs"
 import {dig, digg} from "diggerize"
 import FormDataObjectizer from "form-data-objectizer"
 import Serializer from "./serializer.mjs"
+import SessionStatusUpdater from "./session-status-updater.mjs"
 import ValidationError from "./validation-error.mjs"
 import {ValidationErrors} from "./validation-errors.mjs"
 
@@ -89,6 +90,27 @@ export default class ApiMakerCommandsPool {
     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.error("invalid_authenticity_token - try again")
+        await SessionStatusUpdater.current().updateSessionStatus()
+        continue;
+      }
+
+      console.error(`Request succeeded after ${i} tries`)
+      return response
+    }
+  }
+
   async flush () {
     if (this.commandsCount() == 0) {
       return
@@ -111,14 +133,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]

package/src/destroy-error.mjs

@@ -1,6 +1,6 @@
-import BaseError from "./base-error.mjs"
+import CustomError from "./custom-error.mjs"
 
-class DestroyError extends BaseError {}
+class DestroyError extends CustomError {}
 
 DestroyError.apiMakerType = "DestroyError"
 

package/src/logger.mjs

@@ -1,7 +1,7 @@
 const shared = {}
 
 export default class ApiMakerLogger {
-  static current () {
+  static current() {
     if (!shared.apiMakerLogger) {
       shared.apiMakerLogger = new ApiMakerLogger()
       // shared.apiMakerLogger.setDebug(true)
@@ -10,16 +10,20 @@ export default class ApiMakerLogger {
     return shared.apiMakerLogger
   }
 
-  static log (message) {
+  static log(message) {
     ApiMakerLogger.current().log(message)
   }
 
-  log (message) {
+  log(message) {
     if (this.debug)
       console.log("ApiMaker", message)
   }
 
-  setDebug (value) {
+  getDebug() {
+    return this.debug
+  }
+
+  setDebug(value) {
     this.debug = value
   }
 }

package/src/session-status-updater.mjs

@@ -1,5 +1,6 @@
 import Devise from "./devise.mjs"
 import inflection from "inflection"
+import Logger from "./logger.mjs"
 import wakeEvent from "wake-event"
 
 export default class ApiMakerSessionStatusUpdater {
@@ -11,7 +12,6 @@ export default class ApiMakerSessionStatusUpdater {
   }
 
   constructor (args = {}) {
-    this.debugging = args.debug || false
     this.events = {}
     this.timeout = args.timeout || 600000
 
@@ -28,8 +28,7 @@ export default class ApiMakerSessionStatusUpdater {
   }
 
   debug (message) {
-    if (this.debugging)
-      console.log(`ApiMakerSessionStatusUpdater: ${message}`)
+    Logger.log(`API maker / SessionStatusUpdater: ${message}`)
   }
 
   async sessionStatus () {

package/src/source-maps-loader.mjs

@@ -1,4 +1,5 @@
 import * as stackTraceParser from "stacktrace-parser"
+import Logger from "./logger.mjs"
 import {SourceMapConsumer} from "source-map"
 import uniqunize from "uniqunize"
 
@@ -11,14 +12,13 @@ if (SourceMapConsumer.initialize) {
 
 export default class SourceMapsLoader {
   constructor () {
-    this.debugging = false
     this.isLoadingSourceMaps = false
     this.sourceMaps = []
     this.srcLoaded = {}
   }
 
   debug(messageCallback) {
-    if (this.debugging) console.log(`API maker / Source maps loader:`, messageCallback.call())
+    if (Logger.current().getDebug()) Logger.log(`API maker / SourceMapsLoader: ${messageCallback.call()}`)
   }
 
   loadSourceMapsForScriptTags (callback) {

package/src/super-admin/show-page/index.jsx

@@ -3,10 +3,10 @@ import BelongsToAttributeRow from "./belongs-to-attribute-row"
 import ConfigReader from "../config-reader"
 import {digg, digs} from "diggerize"
 import inflection from "inflection"
-import modelLoadWrapper from "../../model-load-wrapper"
 import PropTypes from "prop-types"
 import React from "react"
 import ShowNav from "../show-nav"
+import withModel from "../../with-model"
 
 class ApiMakerSuperAdminShowPage extends React.PureComponent {
   static propTypes = {
@@ -58,7 +58,7 @@ const modelClassResolver = {callback: ({queryParams}) => {
   return modelClass
 }}
 
-export default modelLoadWrapper(
+export default withModel(
   ApiMakerSuperAdminShowPage,
   modelClassResolver,
   ({modelClass}) => {

package/src/super-admin/show-reflection-page.jsx

@@ -1,9 +1,9 @@
 import {digg, digs} from "diggerize"
-import modelLoadWrapper from "../model-load-wrapper"
 import PropTypes from "prop-types"
 import React from "react"
 import ModelClassTable from "./model-class-table"
 import ShowNav from "./show-nav"
+import withModel from "../with-model"
 
 class ApiMakerSuperAdminShowReflectionPage extends React.PureComponent {
   static propTypes = {
@@ -55,7 +55,7 @@ const modelClassResolver = {callback: ({queryParams}) => {
   return modelClass
 }}
 
-export default modelLoadWrapper(
+export default withModel(
   ApiMakerSuperAdminShowReflectionPage,
   modelClassResolver,
   {

package/src/table/table.jsx

@@ -206,17 +206,9 @@ class ApiMakerTable extends React.PureComponent {
     const {abilities, modelClass} = this.props
     const ownAbilities = []
 
-    if (this.props.destroyEnabled) {
-      ownAbilities.push("destroy")
-    }
-
-    if (this.props.editModelPath) {
-      ownAbilities.push("edit")
-    }
-
-    if (this.props.viewModelPath) {
-      ownAbilities.push("show")
-    }
+    if (this.props.destroyEnabled) ownAbilities.push("destroy")
+    if (this.props.editModelPath) ownAbilities.push("edit")
+    if (this.props.viewModelPath) ownAbilities.push("show")
 
     if (ownAbilities.length > 0) {
       const modelClassName = digg(modelClass.modelClassData(), "name")

package/src/with-collection.jsx

@@ -0,0 +1,259 @@
+import {debounce} from "debounce"
+import {digg, digs} from "diggerize"
+import EventCreated from "./event-created"
+import EventDestroyed from "./event-destroyed"
+import EventUpdated from "./event-updated"
+import React from "react"
+import Shape from "set-state-compare/src/shape"
+import withQueryParams from "on-location-changed/src/with-query-params"
+
+export default (WrappedComponent, withCollectionArgs) => withQueryParams(class ApiMakerWithCollection extends React.PureComponent {
+  constructor (props) {
+    super(props)
+
+    let queryName = withCollectionArgs.queryName
+
+    if (!queryName) queryName = digg(withCollectionArgs.modelClass.modelClassData(), "collectionKey")
+
+    this.shape = new Shape(this, {
+      models: undefined,
+      overallCount: undefined,
+      query: undefined,
+      queryName,
+      queryPerKey: `${queryName}_per`,
+      queryQName: `${queryName}_q`,
+      querySName: `${queryName}_s`,
+      queryPageName: `${queryName}_page`,
+      qParams: undefined,
+      result: undefined,
+      searchParams: undefined,
+      showNoRecordsAvailableContent: false,
+      showNoRecordsFoundContent: false
+    })
+  }
+
+  componentDidMount () {
+    this.loadQParams()
+    this.loadModels()
+
+    const {noRecordsAvailableContent} = digs(withCollectionArgs)
+
+    if (noRecordsAvailableContent) this.loadOverallCount()
+  }
+
+  componentDidUpdate(prevProps) {
+    const {queryPageName, queryPerKey, queryQName, querySName} = digs(this.shape, "queryPageName", "queryPerKey", "queryQName", "querySName")
+    let changed = false
+
+    // Only load models again if certain things in the URL changes
+    if (prevProps.queryParams[queryQName] != this.props.queryParams[queryQName]) {
+      changed = true
+    } else if (prevProps.queryParams[queryPageName] != this.props.queryParams[queryPageName]) {
+      changed = true
+    } else if (prevProps.queryParams[queryPerKey] != this.props.queryParams[queryPerKey]) {
+      changed = true
+    } else if (prevProps.queryParams[querySName] != this.props.queryParams[querySName]) {
+      changed = true
+    }
+
+    if (changed) {
+      this.loadQParams()
+      this.loadModels()
+    }
+  }
+
+  async loadOverallCount () {
+    const baseQuery = withCollectionArgs.collection || withCollectionArgs.modelClass.all()
+    const overallCount = await baseQuery.count()
+
+    this.shape.set({
+      overallCount,
+      showNoRecordsAvailableContent: this.showNoRecordsAvailableContent({overallCount}),
+      showNoRecordsFoundContent: this.showNoRecordsFoundContent({overallCount})
+    })
+  }
+
+  hasQParams() {
+    const {queryParams} = digs(this.props, "queryParams")
+    const {queryQName} = digs(this.shape, "queryQName")
+
+    if (queryQName in queryParams) return true
+
+    return false
+  }
+
+  qParams() {
+    const {queryParams} = digs(this.props, "queryParams")
+    const {queryQName} = digs(this.shape, "queryQName")
+
+    if (this.hasQParams()) return JSON.parse(digg(queryParams, queryQName))
+
+    return {}
+  }
+
+  loadQParams () {
+    const {queryParams} = digs(this.props, "queryParams")
+    const {querySName} = digs(this.shape, "querySName")
+    const qParams = this.hasQParams() ? this.qParams() : Object.assign({}, withCollectionArgs.defaultParams)
+    const searchParams = []
+
+    if (queryParams[querySName]) {
+      for (const rawSearchParam of queryParams[querySName]) {
+        const parsedSearchParam = JSON.parse(rawSearchParam)
+
+        searchParams.push(parsedSearchParam)
+      }
+    }
+
+    this.shape.set({qParams, searchParams})
+  }
+
+  loadModels = async () => {
+    const {queryParams} = digs(this.props, "queryParams")
+    const {abilities, collection, groupBy, modelClass, onModelsLoaded, preloads, select, selectColumns} = withCollectionArgs
+    const {
+      qParams,
+      queryPageName,
+      queryPerKey,
+      queryQName,
+      searchParams
+    } = digs(
+      this.shape,
+      "qParams",
+      "queryPageName",
+      "queryPerKey",
+      "queryQName",
+      "searchParams"
+    )
+    const page = queryParams[queryPageName] || 1
+    let per = queryParams[queryPerKey] || 30
+
+    if (per == "all") {
+      per = 999_999_999
+    } else {
+      per = Number(per)
+    }
+
+    let query = collection?.clone() || modelClass.ransack()
+
+    if (groupBy) query = query.groupBy(...groupBy)
+
+    query = query
+      .ransack(qParams)
+      .search(searchParams)
+      .searchKey(queryQName)
+      .page(page)
+      .pageKey(queryPageName)
+      .per(per)
+      .perKey(queryPerKey)
+      .preload(preloads)
+      .select(select)
+
+    if (abilities) query = query.abilities(abilities)
+    if (selectColumns) query = query.selectColumns(selectColumns)
+
+    const result = await query.result()
+    const models = result.models()
+
+    if (onModelsLoaded) {
+      onModelsLoaded({
+        models,
+        qParams,
+        query,
+        result
+      })
+    }
+
+    this.shape.set({
+      query,
+      result,
+      models: result.models(),
+      showNoRecordsAvailableContent: this.showNoRecordsAvailableContent({models}),
+      showNoRecordsFoundContent: this.showNoRecordsFoundContent({models})
+    })
+  }
+
+  loadModelsDebounce = debounce(digg(this, "loadModels"))
+  onModelCreated = digg(this, "loadModels")
+
+  onModelDestroyed = ({destroyedModel}) => {
+    const {models} = digs(this.shape, "models")
+
+    this.shape.set({
+      models: models.filter((model) => model.id() != destroyedModel.id())
+    })
+  }
+
+  onModelUpdated = ({model: updatedModel}) => {
+    const {models} = digs(this.shape, "models")
+    const foundModel = models.find((model) => model.id() == updatedModel.id())
+
+    if (foundModel) this.loadModelsDebounce()
+  }
+
+  showNoRecordsAvailableContent (args) {
+    const {noRecordsAvailableContent} = withCollectionArgs
+    let models, overallCount
+
+    if (args.models !== undefined) {
+      models = args.models
+    } else if (this.shape.models !== undefined) {
+      models = this.shape.models
+    }
+
+    if (args.overallCount !== undefined) {
+      overallCount = args.overallCount
+    } else if (this.shape.overallCount !== undefined) {
+      overallCount = this.shape.overallCount
+    }
+
+    if (models === undefined || overallCount === undefined || noRecordsAvailableContent === undefined) return false
+    if (models.length === 0 && overallCount === 0 && noRecordsAvailableContent) return true
+  }
+
+  showNoRecordsFoundContent (args) {
+    const {noRecordsAvailableContent, noRecordsFoundContent} = withCollectionArgs
+    let models, overallCount
+
+    if (args.models !== undefined) {
+      models = args.models
+    } else if (this.shape.models !== undefined) {
+      models = this.shape.models
+    }
+
+    if (args.overallCount !== undefined) {
+      overallCount = args.overallCount
+    } else if (this.shape.overallCount !== undefined) {
+      overallCount = this.shape.overallCount
+    }
+
+    if (models === undefined || noRecordsFoundContent === undefined) return false
+
+    // Dont show noRecordsAvailableContent together with noRecordsAvailableContent
+    if (models.length === 0 && overallCount === 0 && noRecordsAvailableContent) return false
+    if (models.length === 0 && noRecordsFoundContent) return true
+  }
+
+  render() {
+    const {modelClass} = digs(withCollectionArgs, "modelClass")
+    const {onModelCreated, onModelDestroyed, onModelUpdated} = digs(this, "onModelCreated", "onModelDestroyed", "onModelUpdated")
+    const {models} = digs(this.shape, "models")
+    const modelsArgName = inflection.camelize(digg(withCollectionArgs.modelClass.modelClassData(), "pluralName"), true)
+    const forwardArgs = {}
+
+    forwardArgs[modelsArgName] = models
+
+    return (
+      <>
+        <EventCreated modelClass={modelClass} onCreated={onModelCreated} />
+        {models && models.map((model) =>
+          <React.Fragment key={model.id()}>
+            <EventDestroyed model={model} onDestroyed={onModelDestroyed} />
+            <EventUpdated model={model} onUpdated={onModelUpdated} />
+          </React.Fragment>
+        )}
+        <WrappedComponent {...forwardArgs} {...this.props} />
+      </>
+    )
+  }
+})

package/src/{model-load-wrapper.jsx → with-model.jsx}

@@ -6,7 +6,7 @@ import React from "react"
 import withQueryParams from "on-location-changed/src/with-query-params"
 
 export default (WrappedComponent, modelClassArg, argsArg = {}) => {
-  class ModelLoadWrapper extends React.PureComponent {
+  class ApiMakerWithModel extends React.PureComponent {
     static propTypes = {
       queryParams: PropTypes.object
     }
@@ -135,5 +135,5 @@ export default (WrappedComponent, modelClassArg, argsArg = {}) => {
     onUpdated = this.loadExistingModel
   }
 
-  return withQueryParams(ModelLoadWrapper)
+  return withQueryParams(ApiMakerWithModel)
 }