@kaspernj/api-maker 1.0.227 → 1.0.228

package/package.json

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

package/src/base-error.mjs

@@ -1,7 +1,9 @@
 import {dig, digg} from "diggerize"
 import errorMessages from "./error-messages.mjs"
 
-class BaseError extends Error {
+export default class BaseError extends Error {
+  static apiMakerType = "BaseError"
+
   constructor (message, args = {}) {
     let messageToUse = message
 
@@ -34,7 +36,3 @@ class BaseError extends Error {
     }
   }
 }
-
-BaseError.apiMakerType = "BaseError"
-
-export default BaseError

package/src/base-model/attribute.mjs

@@ -0,0 +1,23 @@
+import {digg} from "diggerize"
+
+export default class ApiMakerBaseModelAttribute {
+  constructor(attributeData) {
+    this.attributeData = attributeData
+  }
+
+  isColumn() {
+    return Boolean(digg(this, "attributeData", "column"))
+  }
+
+  isSelectedByDefault() {
+    const isSelectedByDefault = digg(this, "attributeData", "selected_by_default")
+
+    if (isSelectedByDefault || isSelectedByDefault === null) return true
+
+    return false
+  }
+
+  name() {
+    return digg(this, "attributeData", "name")
+  }
+}

package/src/base-model/reflection.mjs

@@ -0,0 +1,23 @@
+import {digg} from "diggerize"
+import inflection from "inflection"
+import modelClassRequire from "../model-class-require.mjs"
+
+export default class ApiMakerBaseModelReflection {
+  constructor(reflectionData) {
+    this.reflectionData = reflectionData
+  }
+
+  macro() {
+    return digg(this, "reflectionData", "macro")
+  }
+
+  modelClass() {
+    const modelClass = modelClassRequire(inflection.singularize(inflection.camelize(digg(this, "reflectionData", "name"))))
+
+    return modelClass
+  }
+
+  name() {
+    return inflection.camelize(digg(this, "reflectionData", "name"), true)
+  }
+}

package/src/base-model.mjs

@@ -1,3 +1,4 @@
+import Attribute from "./base-model/attribute.mjs"
 import AttributeNotLoadedError from "./attribute-not-loaded-error.mjs"
 import Collection from "./collection.mjs"
 import CommandsPool from "./commands-pool.mjs"
@@ -6,64 +7,24 @@ import CustomError from "./custom-error.mjs"
 import {digg} from "diggerize"
 import FormDataObjectizer from "form-data-objectizer"
 import inflection from "inflection"
-import modelClassRequire from "./model-class-require.mjs"
 import ModelName from "./model-name.mjs"
 import NotLoadedError from "./not-loaded-error.mjs"
 import objectToFormData from "object-to-formdata"
+import Reflection from "./base-model/reflection.mjs"
 import Services from "./services.mjs"
 import ValidationError from "./validation-error.mjs"
 import {ValidationErrors} from "./validation-errors.mjs"
 
-class ApiMakerAttribute {
-  constructor(attributeData) {
-    this.attributeData = attributeData
-  }
-
-  isColumn() {
-    return Boolean(digg(this, "attributeData", "column"))
-  }
-
-  isSelectedByDefault() {
-    const isSelectedByDefault = digg(this, "attributeData", "selected_by_default")
-
-    if (isSelectedByDefault || isSelectedByDefault === null) return true
-
-    return false
-  }
-
-  name() {
-    return digg(this, "attributeData", "name")
-  }
-}
+export default class BaseModel {
+  static apiMakerType = "BaseModel"
 
-class ApiMakerReflection {
-  constructor(reflectionData) {
-    this.reflectionData = reflectionData
-  }
-
-  macro() {
-    return digg(this, "reflectionData", "macro")
-  }
-
-  modelClass() {
-    const modelClass = modelClassRequire(inflection.singularize(inflection.camelize(digg(this, "reflectionData", "name"))))
-
-    return modelClass
-  }
-
-  name() {
-    return inflection.camelize(digg(this, "reflectionData", "name"), true)
-  }
-}
-
-class BaseModel {
   static attributes() {
     const attributes = digg(this.modelClassData(), "attributes")
     const result = []
 
     for (const attributeKey in attributes) {
       const attributeData = attributes[attributeKey]
-      const attribute = new ApiMakerAttribute(attributeData)
+      const attribute = new Attribute(attributeData)
 
       result.push(attribute)
     }
@@ -128,7 +89,7 @@ class BaseModel {
     const reflections = []
 
     for (const relationshipData of relationships) {
-      const reflection = new ApiMakerReflection(relationshipData)
+      const reflection = new Reflection(relationshipData)
 
       reflections.push(reflection)
     }
@@ -910,7 +871,3 @@ class BaseModel {
     }
   }
 }
-
-BaseModel.apiMakerType = "BaseModel"
-
-export default BaseModel

package/src/model-load-wrapper.jsx

@@ -5,13 +5,14 @@ import PropTypes from "prop-types"
 import React from "react"
 import withQueryParams from "on-location-changed/src/with-query-params"
 
-export default (WrappedComponent, mdelClassArg, args = {}) => {
+export default (WrappedComponent, modelClassArg, argsArg = {}) => {
   class ModelLoadWrapper extends React.PureComponent {
     static propTypes = {
       queryParams: PropTypes.object
     }
 
-    modelClass = this.resolveModelClass(mdelClassArg)
+    modelClass = this.resolveModelClass(modelClassArg)
+    args = this.resolveArgs()
     camelizedLower = this.modelClass.modelName().camelizedLower()
     paramsVariableName = `${this.modelClass.modelName().paramKey()}_id`
 
@@ -21,6 +22,16 @@ export default (WrappedComponent, mdelClassArg, args = {}) => {
       notFound: undefined
     }
 
+    resolveArgs() {
+      if (typeof argsArg == "function") {
+        return argsArg({
+          modelClass: this.modelClass
+        })
+      }
+
+      return argsArg
+    }
+
     resolveModelClass(modelClassArg) {
       if (typeof modelClassArg == "object") {
         const {queryParams} = digs(this.props, "queryParams")
@@ -46,16 +57,16 @@ export default (WrappedComponent, mdelClassArg, args = {}) => {
     }
 
     loadModel = async () => {
-      if (args.newIfNoId && !this.getModelId()) {
+      if (this.args.newIfNoId && !this.getModelId()) {
         return await this.loadNewModel()
-      } else if (!args.optional || this.getModelId()) {
+      } else if (!this.args.optional || this.getModelId()) {
         return await this.loadExistingModel()
       }
     }
 
     getModelId() {
-      if (args.loadByQueryParam)
-        return args.loadByQueryParam({props: this.props})
+      if (this.args.loadByQueryParam)
+        return this.args.loadByQueryParam({props: this.props})
 
       return this.props.match.params[this.paramsVariableName] || this.props.match.params.id
     }
@@ -65,9 +76,9 @@ export default (WrappedComponent, mdelClassArg, args = {}) => {
       const ModelClass = digg(this, "modelClass")
       const query = await ModelClass.ransack({id_eq: modelId})
 
-      if (args.abilities) query.abilities(args.abilities)
-      if (args.preload) query.preload(args.preload)
-      if (args.select) query.select(args.select)
+      if (this.args.abilities) query.abilities(this.args.abilities)
+      if (this.args.preload) query.preload(this.args.preload)
+      if (this.args.select) query.select(this.args.select)
 
       const model = await query.first()
 
@@ -85,11 +96,11 @@ export default (WrappedComponent, mdelClassArg, args = {}) => {
 
       let defaults = {}
 
-      if (args.newIfNoId?.defaults) {
-        defaults = await args.newIfNoId.defaults()
+      if (this.args.newIfNoId?.defaults) {
+        defaults = await this.args.newIfNoId.defaults()
       }
 
-      const modelData = Object.assign(defaults, args.newAttributes, modelDataFromParams)
+      const modelData = Object.assign(defaults, this.args.newAttributes, modelDataFromParams)
       const model = new ModelClass({
         isNewRecord: true,
         data: {a: modelData}
@@ -109,10 +120,10 @@ export default (WrappedComponent, mdelClassArg, args = {}) => {
 
       return (
         <>
-          {args.events &&
-            <EventEmitterListener event="reloadModel" events={args.events} onCalled={reloadModel} />
+          {this.args.events &&
+            <EventEmitterListener event="reloadModel" events={this.args.events} onCalled={reloadModel} />
           }
-          {model && args.eventUpdated &&
+          {model && this.args.eventUpdated &&
             <EventUpdated model={model} onUpdated={onUpdated} />
           }
           <WrappedComponent {...wrappedComponentProps} {...this.props} />
@@ -124,7 +135,5 @@ export default (WrappedComponent, mdelClassArg, args = {}) => {
     onUpdated = this.loadExistingModel
   }
 
-  if (args.loadByQueryParam) return withQueryParams(ModelLoadWrapper)
-
-  return ModelLoadWrapper
+  return withQueryParams(ModelLoadWrapper)
 }

package/src/super-admin/show-page/belongs-to-attribute-row.jsx

@@ -0,0 +1,25 @@
+import AttributeRow from "../../bootstrap/attribute-row"
+import {digs} from "diggerize"
+import inflection from "inflection"
+import Link from "../../link"
+import Params from "../../params"
+import React from "react"
+
+export default class ApiMakerSuperAdminShowPageBelongsToAttributeRow extends React.PureComponent {
+  render() {
+    const {model, modelClass, reflection} = digs(this.props, "model", "modelClass", "reflection")
+    const reflectionMethodName = inflection.camelize(reflection.name(), true)
+    const subModel = model[reflectionMethodName]()
+
+    return (
+      <AttributeRow label={modelClass.humanAttributeName(inflection.camelize(reflection.name(), true))}>
+        {subModel &&
+          <Link to={Params.withParams({model: subModel.modelClassData().name, model_id: subModel.primaryKey()})}>
+            {subModel && "name" in subModel && subModel.name()}
+            {subModel && !("name" in subModel) && subModel?.id()}
+          </Link>
+        }
+      </AttributeRow>
+    )
+  }
+}

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

@@ -0,0 +1,86 @@
+import AttributeRows from "../../bootstrap/attribute-rows"
+import BelongsToAttributeRow from "./belongs-to-attribute-row"
+import ConfigReader from "../config-reader"
+import {digg, digs} from "diggerize"
+import modelLoadWrapper from "../../model-load-wrapper"
+import PropTypes from "prop-types"
+import React from "react"
+import ShowNav from "../show-nav"
+
+class ApiMakerSuperAdminShowPage extends React.PureComponent {
+  static propTypes = {
+    modelClass: PropTypes.func.isRequired,
+    queryParams: PropTypes.object.isRequired
+  }
+
+  render() {
+    const {modelClass, queryParams} = digs(this.props, "modelClass", "queryParams")
+    const attributes = this.attributes()
+    const model = this.model()
+
+    return (
+      <div className="super-admin--show-page">
+        {model &&
+          <ShowNav model={model} modelClass={modelClass} queryParams={queryParams} />
+        }
+        {attributes && model &&
+          <AttributeRows attributes={attributes} model={model} />
+        }
+        {model && modelClass.reflections().filter((reflection) => reflection.macro() == "belongs_to").map((reflection) =>
+          <BelongsToAttributeRow key={reflection.name()} model={model} modelClass={modelClass} reflection={reflection} />
+        )}
+      </div>
+    )
+  }
+
+  attributes() {
+    const {modelClass} = digs(this.props, "modelClass")
+    const configReader = ConfigReader.forModel(modelClass)
+
+    return configReader.attributesToShow()
+  }
+
+  model() {
+    const {modelClass} = digs(this.props, "modelClass")
+    const camelizedLower = digg(modelClass.modelClassData(), "camelizedLower")
+
+    return digg(this, "props", camelizedLower)
+  }
+}
+
+const modelClassResolver = {callback: ({queryParams}) => {
+  const modelClassName = digg(queryParams, "model")
+  const modelClass = digg(require("../../models.mjs.erb"), modelClassName)
+
+  return modelClass
+}}
+
+export default modelLoadWrapper(
+  ApiMakerSuperAdminShowPage,
+  modelClassResolver,
+  ({modelClass}) => {
+    const preload = []
+    const select = {}
+
+    for (const reflection of modelClass.reflections()) {
+      if (reflection.macro() != "belongs_to") continue
+
+      const reflectionModelClass = reflection.modelClass()
+      const reflectionModelClassName = reflectionModelClass.modelClassData().name
+      const reflectionModelClassAttributes = reflectionModelClass.attributes()
+      const nameAttribute = reflectionModelClassAttributes.find((attribute) => attribute.name() == "name")
+
+      preload.push(reflection.name())
+
+      if (!(reflectionModelClassName in select)) select[reflectionModelClassName] = []
+      if (!select[reflectionModelClassName].includes("id")) select[reflectionModelClassName].push("id")
+      if (nameAttribute && !select[reflectionModelClassName].includes("name")) select[reflectionModelClassName].push("name")
+    }
+
+    return {
+      loadByQueryParam: ({props}) => props.queryParams.model_id,
+      preload,
+      select
+    }
+  }
+)

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

@@ -1,60 +0,0 @@
-import AttributeRows from "../bootstrap/attribute-rows"
-import ConfigReader from "./config-reader"
-import {digg, digs} from "diggerize"
-import modelLoadWrapper from "../model-load-wrapper"
-import PropTypes from "prop-types"
-import React from "react"
-import ShowNav from "./show-nav"
-
-class ApiMakerSuperAdminShowPage extends React.PureComponent {
-  static propTypes = {
-    modelClass: PropTypes.func.isRequired,
-    queryParams: PropTypes.object.isRequired
-  }
-
-  render() {
-    const {modelClass, queryParams} = digs(this.props, "modelClass", "queryParams")
-    const attributes = this.attributes()
-    const model = this.model()
-
-    return (
-      <div className="super-admin--show-page">
-        {model &&
-          <ShowNav model={model} modelClass={modelClass} queryParams={queryParams} />
-        }
-        {attributes && model &&
-          <AttributeRows attributes={attributes} model={model} />
-        }
-      </div>
-    )
-  }
-
-  attributes() {
-    const {modelClass} = digs(this.props, "modelClass")
-    const configReader = ConfigReader.forModel(modelClass)
-
-    return configReader.attributesToShow()
-  }
-
-  model() {
-    const {modelClass} = digs(this.props, "modelClass")
-    const camelizedLower = digg(modelClass.modelClassData(), "camelizedLower")
-
-    return digg(this, "props", camelizedLower)
-  }
-}
-
-const modelClassResolver = {callback: ({queryParams}) => {
-  const modelClassName = digg(queryParams, "model")
-  const modelClass = digg(require("../models.mjs.erb"), modelClassName)
-
-  return modelClass
-}}
-
-export default modelLoadWrapper(
-  ApiMakerSuperAdminShowPage,
-  modelClassResolver,
-  {
-    loadByQueryParam: ({props}) => props.queryParams.model_id
-  }
-)