@kaspernj/api-maker 1.0.301 → 1.0.303

package/package.json

@@ -16,7 +16,7 @@
     ]
   },
   "name": "@kaspernj/api-maker",
-  "version": "1.0.301",
+  "version": "1.0.303",
   "type": "module",
   "description": "",
   "main": "index.js",
@@ -49,7 +49,7 @@
     "js-money": ">= 0.6.3",
     "numberable": ">= 1.0.0",
     "object-to-formdata": ">= 4.1.0",
-    "on-location-changed": ">= 1.0.7",
+    "on-location-changed": ">= 1.0.8",
     "qs": ">= 6.9.3",
     "replaceall": ">= 0.1.6",
     "spark-md5": "^3.0.2",

package/src/model-name.mjs

@@ -6,9 +6,7 @@ export default class ModelName {
     this.data = data
   }
 
-  camelizedLower() {
-    return this.data.modelClassData.camelizedLower
-  }
+  camelizedLower = () => this.data.modelClassData.camelizedLower
 
   human(args) {
     let argsToUse = args
@@ -31,7 +29,5 @@ export default class ModelName {
     return Config.getI18n().t(key, {defaultValue: defaultModelName})
   }
 
-  paramKey() {
-    return this.data.modelClassData.paramKey
-  }
+  paramKey = () => this.data.modelClassData.paramKey
 }

package/src/use-current-user.mjs

@@ -0,0 +1,29 @@
+import {useCallback, useEffect} from "react"
+import Devise from "./devise.mjs"
+
+const useCurrentUser = () => {
+  const [currentUser, setCurrentUser] = useState(Devise.currentUser())
+  const updateCurrentUser = useCallback(() => {
+    setCurrentUser(Devise.currentUser())
+  })
+
+  useEffect(() => {
+    Devise.events().addListener("onDeviseSignIn", updateCurrentUser)
+
+    return () => {
+      Devise.events().removeListener("onDeviseSignIn", updateCurrentUser)
+    }
+  })
+
+  useEffect(() => {
+    Devise.events().addListener("onDeviseSignOut", updateCurrentUser)
+
+    return () => {
+      Devise.events().removeListener("onDeviseSignOut", updateCurrentUser)
+    }
+  })
+
+  return currentUser
+}
+
+export default useCurrentUser

package/src/use-model.mjs

@@ -0,0 +1,131 @@
+import ModelEvents from "./model-events.mjs"
+import useQueryParams from "on-location-changed/src/use-query-params.js"
+
+const useModel = (match, modelClassArg, argsArg) => {
+  const queryParams = useQueryParams()
+  let args, modelClass
+
+  if (typeof argsArg == "function") {
+    args = argsArg({modelClass})
+  } else {
+    args  = argsArg
+  }
+
+  if (typeof modelClassArg == "object") {
+    modelClass = modelClassArg.callback({queryParams})
+  } else {
+    modelClass = modelClassArg
+  }
+
+  const paramsVariableName = `${modelClass.modelName().paramKey()}_id`
+
+  const getModelId = () => {
+    if (args.loadByQueryParam) {
+      return args.loadByQueryParam({queryParams})
+    }
+
+    return match.params[paramsVariableName] || match.params.id
+  }
+
+  const modelId = getModelId()
+  const modelVariableName = inflection.camelize(modelClass.modelClassData().name, true)
+  const cacheArgs = [modelId, ...args.cacheArgs]
+  const [model, setModel] = useState(undefined)
+  const [notFound, setNotFound] = useState(undefined)
+
+  const loadExistingModel = async () => {
+    const query = await modelClass.ransack({id_eq: modelId})
+
+    if (!modelId) throw new Error(`No model ID was given: ${modelId} by '${paramsVariableName}' in query params: ${Object.keys(match.params).join(", ")}`)
+    if (args.abilities) query.abilities(args.abilities)
+    if (args.preload) query.preload(args.preload)
+    if (args.select) query.select(args.select)
+
+    const model = await query.first()
+
+    setModel(model)
+    setNotFound(!model)
+  }
+
+  const loadNewModel = async () => {
+    const params = Params.parse()
+    const ModelClass = digg(this, "modelClass")
+    const paramKey = ModelClass.modelName().paramKey()
+    const modelDataFromParams = params[paramKey] || {}
+
+    let defaults = {}
+
+    if (this.args.newIfNoId?.defaults) {
+      defaults = await this.args.newIfNoId.defaults()
+    }
+
+    const modelData = Object.assign(defaults, this.args.newAttributes, modelDataFromParams)
+    const model = new ModelClass({
+      isNewRecord: true,
+      data: {a: modelData}
+    })
+
+    setModel(model)
+  }
+
+  const loadModel = async () => {
+    if (args.newIfNoId && !modelId) {
+      return await loadNewModel()
+    } else if (!args.optional || modelId) {
+      return await loadExistingModel()
+    }
+  }
+
+  useEffect(
+    () => { loadModel() },
+    cacheArgs
+  )
+
+  useEffect(() => {
+    let reloadModelCallback
+
+    if (args.events) {
+      reloadModelCallback = args.events.addListener("reloadModel", loadModel)
+    }
+
+    return () => {
+      if (reloadModelCallback) {
+        args.events.removeListener("reloadModel", loadModel)
+      }
+    }
+  }, [args.events])
+
+  useEffect(() => {
+    let connectUpdated
+
+    if (model && args.eventUpdated) {
+      connectUpdated = ModelEvents.connectUpdated(model, loadModel)
+    }
+
+    return () => {
+      connectUpdated?.unsubscribe()
+    }
+  }, [args.eventUpdated, model?.id()])
+
+  useEffect(() => {
+    let connectDestroyed
+
+    if (model && args.onDestroyed) {
+      connectDestroyed = ModelEvents.connectDestroyed(model, loadModel)
+    }
+
+    return () => {
+      connectDestroyed?.unsubscribe()
+    }
+  }, [args.onDestroyed, model?.id()])
+
+  const result = {}
+
+  result[modelVariableName] = model
+  result[`${modelVariableName}Id`] = modelId
+  result[`${modelVariableName}NotFound`] = notFound
+
+  return result
+}
+
+export default useModel

package/src/with-model.jsx

@@ -1,5 +1,6 @@
 import {digg, digs} from "diggerize"
 import EventUpdated from "./event-updated"
+import * as inflection from "inflection"
 import Params from "./params.mjs"
 import PropTypes from "prop-types"
 import React from "react"
@@ -13,7 +14,7 @@ export default (WrappedComponent, modelClassArg, argsArg = {}) => {
 
     modelClass = this.resolveModelClass(modelClassArg)
     args = this.resolveArgs()
-    paramKey = this.modelClass.modelName().paramKey()
+    modelVariableName = inflection.camelize(this.modelClass.modelClassData().name, true)
     paramsVariableName = `${this.modelClass.modelName().paramKey()}_id`
 
     state = {
@@ -115,9 +116,9 @@ export default (WrappedComponent, modelClassArg, argsArg = {}) => {
       const {model, modelId, notFound} = digs(this.state, "model", "modelId", "notFound")
       const wrappedComponentProps = {}
 
-      wrappedComponentProps[this.paramKey] = model
-      wrappedComponentProps[`${this.paramKey}Id`] = modelId
-      wrappedComponentProps[`${this.paramKey}NotFound`] = notFound
+      wrappedComponentProps[this.modelVariableName] = model
+      wrappedComponentProps[`${this.modelVariableName}Id`] = modelId
+      wrappedComponentProps[`${this.modelVariableName}NotFound`] = notFound
 
       return (
         <>