@kaspernj/api-maker 1.0.226 → 1.0.228

package/package.json

@@ -16,7 +16,7 @@
     ]
   },
   "name": "@kaspernj/api-maker",
-  "version": "1.0.226",
+  "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"
@@ -9,40 +10,21 @@ import inflection from "inflection"
 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 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)
     }
@@ -65,10 +47,10 @@ class BaseModel {
     }
   }
 
-  static async find (id) {
-    const primaryKeyName = this.modelClassData().primaryKey
+  static async find(id) {
     const query = {}
-    query[`${primaryKeyName}_eq`] = id
+
+    query[`${this.primaryKey()}_eq`] = id
 
     const model = await this.ransack(query).first()
 
@@ -79,7 +61,7 @@ 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,
@@ -90,7 +72,7 @@ class BaseModel {
     return model
   }
 
-  static modelName () {
+  static modelName() {
     return new ModelName({modelClassData: this.modelClassData()})
   }
 
@@ -98,10 +80,23 @@ class BaseModel {
     return digg(this.modelClassData(), "primaryKey")
   }
 
-  static ransack (query = {}) {
+  static ransack(query = {}) {
     return new Collection({modelClass: this}, {ransack: query})
   }
 
+  static reflections() {
+    const relationships = digg(this.modelClassData(), "relationships")
+    const reflections = []
+
+    for (const relationshipData of relationships) {
+      const reflection = new Reflection(relationshipData)
+
+      reflections.push(reflection)
+    }
+
+    return reflections
+  }
+
   constructor (args = {}) {
     this.changes = {}
     this.newRecord = args.isNewRecord
@@ -302,7 +297,7 @@ class BaseModel {
 
     // Load the missing abilities if any
     if (abilitiesToLoad.length > 0) {
-      const primaryKeyName = this.modelClassData().primaryKey
+      const primaryKeyName = this.constructor.primaryKey()
       const ransackParams = {}
       ransackParams[`${primaryKeyName}_eq`] = this.primaryKey()
 
@@ -483,9 +478,8 @@ class BaseModel {
 
   async reload () {
     const params = this.collection && this.collection.params()
-    const primaryKeyName = this.modelClassData().primaryKey
     const ransackParams = {}
-    ransackParams[`${primaryKeyName}_eq`] = this.primaryKey()
+    ransackParams[`${this.constructor.primaryKey()}_eq`] = this.primaryKey()
 
     let query = this.constructor.ransack(ransackParams)
 
@@ -866,7 +860,7 @@ class BaseModel {
   }
 
   primaryKey () {
-    return this.readAttributeUnderscore(digg(this.modelClassData(), "primaryKey"))
+    return this.readAttributeUnderscore(this.constructor.primaryKey())
   }
 
   static _token () {
@@ -877,7 +871,3 @@ class BaseModel {
     }
   }
 }
-
-BaseModel.apiMakerType = "BaseModel"
-
-export default BaseModel

package/src/collection-loader.jsx

@@ -24,10 +24,7 @@ export default class CollectionLoader extends React.PureComponent {
     abilities: PropTypes.object,
     appHistory: PropTypes.object,
     className: PropTypes.string,
-    collection: PropTypes.oneOfType([
-      instanceOfClassName("ApiMakerCollection"),
-      PropTypes.instanceOf(Collection)
-    ]),
+    collection: PropTypes.instanceOf(Collection),
     component: PropTypes.object,
     defaultParams: PropTypes.object,
     groupBy: PropTypes.array,

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/models.mjs.erb

@@ -10,7 +10,10 @@ const result = loader.load()
 <% model_class_names = [] %>
 <% ApiMaker::ModelClassesJavaScriptGeneratorService.new.resources.each do |resource| %>
   <% model_class_names << resource.short_name %>
-  const <%= resource.short_name %> = digg(result, "<%= resource.short_name %>")
+
+  const <%= resource.short_name %>ModelClass = digg(result, "<%= resource.short_name %>")
+
+  class <%= resource.short_name %> extends <%= resource.short_name %>ModelClass {}
 <% end %>
 
 export {<%= model_class_names.join(", ") %>}

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

@@ -0,0 +1,24 @@
+import {digs} from "diggerize"
+import ModelClassTable from "./model-class-table"
+import PropTypes from "prop-types"
+import React from "react"
+
+export default class ApiMakerSuperAdminIndexPage extends React.PureComponent {
+  static propTypes = {
+    currentUser: PropTypes.object,
+    modelClass: PropTypes.func.isRequired,
+    queryParams: PropTypes.object.isRequired
+  }
+
+  render() {
+    const {currentUser, modelClass, queryParams} = digs(this.props, "currentUser", "modelClass", "queryParams")
+
+    return (
+      <ModelClassTable
+        currentUser={currentUser}
+        modelClass={modelClass}
+        queryParams={queryParams}
+      />
+    )
+  }
+}

package/src/super-admin/index.jsx

@@ -4,11 +4,13 @@ import Layout from "./layout"
 import * as modelsModule from "@kaspernj/api-maker/src/models.mjs.erb"
 import PropTypes from "prop-types"
 import ShowPage from "./show-page"
+import ShowReflectionPage from "./show-reflection-page"
 import withQueryParams from "on-location-changed/src/with-query-params"
 
 class ApiMakerSuperAdmin extends React.PureComponent {
   static propTypes = {
-    currentUser: PropTypes.object
+    currentUser: PropTypes.object,
+    queryParams: PropTypes.object.isRequired
   }
 
   render() {
@@ -31,9 +33,19 @@ class ApiMakerSuperAdmin extends React.PureComponent {
         }
         {pageToShow == "show" &&
           <ShowPage
-            key={`show-page-${digg(modelClass.modelClassData(), "name")}`}
+            key={`show-page-${digg(modelClass.modelClassData(), "name")}-${queryParams.modelId}`}
             modelClass={modelClass}
             modelId={queryParams.modelId}
+            queryParams={queryParams}
+          />
+        }
+        {pageToShow == "show_reflection" &&
+          <ShowReflectionPage
+            currentUser={currentUser}
+            key={`show-reflection-page-${digg(modelClass.modelClassData(), "name")}-${queryParams.modelId}`}
+            modelClass={modelClass}
+            modelId={queryParams.modelId}
+            queryParams={queryParams}
           />
         }
       </Layout>
@@ -43,7 +55,9 @@ class ApiMakerSuperAdmin extends React.PureComponent {
   pageToShow() {
     const {queryParams} = digs(this.props, "queryParams")
 
-    if (queryParams.model && queryParams.model_id) {
+    if (queryParams.model && queryParams.model_id && queryParams.model_reflection) {
+      return "show_reflection"
+    } else if (queryParams.model && queryParams.model_id) {
       return "show"
     } else if (queryParams.model) {
       return "index"

package/src/super-admin/{index-page/index.jsx → model-class-table.jsx}

@@ -1,11 +1,11 @@
-import ConfigReader from "../config-reader"
+import ConfigReader from "./config-reader"
 import {digg, digs} from "diggerize"
-import Params from "../../params"
+import Params from "../params"
 import PropTypes from "prop-types"
 import React from "react"
-import Table from "../../table/table"
+import Table from "../table/table"
 
-export default class ApiMakerSuperAdminIndexPage extends React.PureComponent {
+export default class ApiMakerSuperAdminModelClassTable extends React.PureComponent {
   static propTypes = {
     currentUser: PropTypes.object,
     modelClass: PropTypes.func.isRequired,
@@ -13,7 +13,7 @@ export default class ApiMakerSuperAdminIndexPage extends React.PureComponent {
   }
 
   render() {
-    const {currentUser, modelClass} = digs(this.props, "currentUser", "modelClass")
+    const {currentUser, modelClass, queryParams, ...restProps} = this.props
 
     return (
       <Table
@@ -21,6 +21,7 @@ export default class ApiMakerSuperAdminIndexPage extends React.PureComponent {
         currentUser={currentUser}
         modelClass={modelClass}
         viewModelPath={digg(this, "viewModelPath")}
+        {...restProps}
       />
     )
   }

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

@@ -0,0 +1,35 @@
+import {digg, digs} from "diggerize"
+import Link from "../link"
+import PropTypes from "prop-types"
+import PropTypesExact from "prop-types-exact"
+import React from "react"
+
+export default class ApiMakerSuperAdminShowNav extends React.PureComponent {
+  static propTypes = PropTypesExact({
+    model: PropTypes.object.isRequired,
+    modelClass: PropTypes.func.isRequired,
+    queryParams: PropTypes.object.isRequired
+  })
+
+  render() {
+    const {model, modelClass, queryParams} = digs(this.props, "model", "modelClass", "queryParams")
+    const reflections = modelClass.reflections()
+
+    return (
+      <div>
+        <div>
+          <Link to={Params.withParams({model: modelClass.modelClassData().name, model_id: queryParams.model_id})}>
+            {I18n.t("js.api_maker.suprt_admin.show_reflection_page.general", {defaultValue: "General"})}
+          </Link>
+        </div>
+        {model && reflections.filter((reflection) => reflection.macro() == "has_many").map((reflection) =>
+          <div key={reflection.name()}>
+            <Link to={Params.withParams({model: digg(modelClass.modelClassData(), "name"), model_id: model.primaryKey(), model_reflection: reflection.name()})}>
+              {modelClass.humanAttributeName(reflection.name())}
+            </Link>
+          </div>
+        )}
+      </div>
+    )
+  }
+}

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-reflection-page.jsx

@@ -0,0 +1,64 @@
+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"
+
+class ApiMakerSuperAdminShowReflectionPage extends React.PureComponent {
+  static propTypes = {
+    currentUser: PropTypes.object,
+    modelClass: PropTypes.func.isRequired,
+    queryParams: PropTypes.object.isRequired
+  }
+
+  render() {
+    const {currentUser, modelClass, queryParams} = digs(this.props, "currentUser", "modelClass", "queryParams")
+    const model = this.model()
+    const reflections = modelClass.reflections()
+    const reflection = reflections.find((reflectionI) => reflectionI.name() == queryParams.model_reflection)
+    const reflectionModelClass = reflection.modelClass()
+    let collection
+
+    if (model) collection = model[reflection.name()]()
+
+    return (
+      <div className="super-admin--show-page">
+        {model &&
+          <ShowNav model={model} modelClass={modelClass} queryParams={queryParams} />
+        }
+        {collection &&
+          <ModelClassTable
+            collection={collection}
+            currentUser={currentUser}
+            key={reflectionModelClass.modelName().human()}
+            modelClass={reflectionModelClass}
+            queryParams={queryParams}
+          />
+        }
+      </div>
+    )
+  }
+
+  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(
+  ApiMakerSuperAdminShowReflectionPage,
+  modelClassResolver,
+  {
+    loadByQueryParam: ({props}) => props.queryParams.model_id
+  }
+)

package/src/table/table.jsx

@@ -39,10 +39,7 @@ class ApiMakerTable extends React.PureComponent {
     appHistory: PropTypes.object,
     card: PropTypes.bool.isRequired,
     className: PropTypes.string,
-    collection: PropTypes.oneOfType([
-      instanceOfClassName("ApiMakerCollection"),
-      PropTypes.instanceOf(Collection)
-    ]),
+    collection: PropTypes.instanceOf(Collection),
     columns: PropTypes.oneOfType([PropTypes.array, PropTypes.func]),
     columnsContent: PropTypes.func,
     controls: PropTypes.func,
@@ -134,7 +131,7 @@ class ApiMakerTable extends React.PureComponent {
 
   render () {
     const {modelClass, noRecordsAvailableContent, noRecordsFoundContent} = digs(this.props, "modelClass", "noRecordsAvailableContent", "noRecordsFoundContent")
-    const {collection, defaultParams, select, selectColumns} = this.props
+    const {collection, defaultParams, selectColumns} = this.props
     const {
       overallCount,
       preload,

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

@@ -1,49 +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 React from "react"
-
-class ApiMakerSuperAdminShowPage extends React.PureComponent {
-  render() {
-    const attributes = this.attributes()
-    const model = this.model()
-
-    return (
-      <div className="super-admin--show-page">
-        {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
-  }
-)