adminizer 4.1.0-build.21 → 4.1.0-build.23

package/helpers/JsUtils.d.ts

@@ -0,0 +1 @@
+export declare function isObject(obj: unknown): obj is object;

package/helpers/JsUtils.js

@@ -0,0 +1,3 @@
+export function isObject(obj) {
+    return typeof obj === "object" && obj !== null;
+}

package/helpers/fieldsHelper.d.ts

@@ -1,9 +1,9 @@
-import { ActionType, BaseFieldConfig, FieldsTypes } from "../interfaces/adminpanelConfig";
+import { ActionType, BaseFieldConfig, FieldsTypes, ModelConfig } from "../interfaces/adminpanelConfig";
 import { Attribute } from "../lib/v4/model/AbstractModel";
 export type Field = {
     config: BaseFieldConfig & {
         /** @deprecated record should not be in config anymore */
-        records?: object[];
+        records?: Record<string, any>[];
         file?: string;
         key?: string;
         required?: boolean;
@@ -15,6 +15,7 @@ export type Field = {
         [key: string]: Field;
     } | undefined;
     model: Attribute;
+    modelConfig: ModelConfig;
 };
 export type Fields = {
     [key: string]: Field;

package/helpers/fieldsHelper.js

@@ -1,5 +1,6 @@
 import { DataAccessor } from "../lib/v4/DataAccessor";
 import { Adminizer } from "../lib/Adminizer";
+import { isObject } from "./JsUtils";
 export class FieldsHelper {
     /**
      * Load list of records for all associations into `fields`
@@ -20,6 +21,9 @@ export class FieldsHelper {
          */
         let loadAssoc = async function (key, action) {
             let fieldConfigConfig = fields[key].config;
+            if (!isObject(fieldConfigConfig)) {
+                throw 'type error: fieldConfigConfig should be normalized';
+            }
             if (fieldConfigConfig.type !== 'association' && fieldConfigConfig.type !== 'association-many') {
                 return;
             }
@@ -42,7 +46,7 @@ export class FieldsHelper {
                     name: modelName, config: req.adminizer.config.models[modelName],
                     model: Model, uri: `${req.adminizer.config.routePrefix}/model/${modelName}`, type: "model"
                 };
-                let dataAccessor = new DataAccessor(req.adminizer, req.user, entity, action);
+                let dataAccessor = new DataAccessor(req.adminizer, req.user, entity, "view");
                 list = await Model.find({}, dataAccessor);
             }
             catch (e) {

package/helpers/inertiaAddHelper.d.ts

@@ -1,7 +1,6 @@
 import { Entity, PropsField } from "../interfaces/types";
 import { Actions } from "./inertiaActionsHelper";
-import { Fields } from "./fieldsHelper";
-import { BaseFieldConfig } from "../interfaces/adminpanelConfig";
+import { Fields, Field } from "./fieldsHelper";
 import { AbstractControls, ControlType } from "../lib/controls/AbstractControls";
 export type PropsFieldType = 'text' | 'number' | 'range' | 'week' | 'month' | 'email' | 'color' | 'time' | 'date' | 'datetime-local' | 'password' | 'select' | 'select-many' | 'association-many' | 'association' | 'textarea' | 'checkbox' | ControlType;
 interface FieldProps extends Record<string | number | symbol, unknown> {
@@ -21,7 +20,7 @@ interface FieldProps extends Record<string | number | symbol, unknown> {
     postLink: string;
 }
 export default function inertiaAddHelper(req: ReqType, entity: Entity, fields: Fields, record?: Record<string, string | boolean | number | string[]>, view?: boolean): FieldProps;
-export declare function getControlsOptions(fieldConfig: BaseFieldConfig, req: ReqType, type: ControlType, defaultControlName: string): {
+export declare function getControlsOptions(fieldConfig: Field["config"], req: ReqType, type: ControlType, defaultControlName: string): {
     name: string;
     config: {
         el?: HTMLElement;

package/helpers/inertiaAddHelper.js

@@ -1,5 +1,6 @@
 import inertiaActionsHelper from "./inertiaActionsHelper";
 import chalk from "chalk";
+import { isObject } from "lodash-es";
 export default function inertiaAddHelper(req, entity, fields, record, view = false) {
     const actionType = 'add';
     let props = {
@@ -25,6 +26,8 @@ export default function inertiaAddHelper(req, entity, fields, record, view = fal
             continue;
         let field = fields[key];
         let fieldConfig = field.config;
+        if (!isObject(fieldConfig))
+            throw `Type error: fieldConfig is object`;
         if (!!fieldConfig.visible === false)
             continue;
         const type = (fieldConfig.type || fieldConfig.type).toLowerCase();
@@ -115,6 +118,8 @@ export default function inertiaAddHelper(req, entity, fields, record, view = fal
     return props;
 }
 export function getControlsOptions(fieldConfig, req, type, defaultControlName) {
+    if (!isObject(fieldConfig))
+        throw `Type error: fieldConfig is object`;
     const fieldOptions = fieldConfig?.options;
     let control = getControl(req, type, fieldOptions?.name, defaultControlName);
     let editorName = control.getName();
@@ -192,6 +197,8 @@ function setAssociationValues(field, value) {
     let options = [];
     let initValue = [];
     const config = field.config;
+    if (!isObject(config))
+        throw `Type error: config is object`;
     const isOptionSelected = (option, value) => {
         if (Array.isArray(value)) {
             return value.includes(option);
@@ -200,8 +207,8 @@ function setAssociationValues(field, value) {
             return (option == value);
         }
     };
-    const getAssociationValue = (value, config) => {
-        const displayField = config.displayField || 'id';
+    const getAssociationValue = (value, field) => {
+        const displayField = field.modelConfig?.titleField || 'id';
         if (value === null)
             return [];
         if (Array.isArray(value)) {
@@ -214,13 +221,24 @@ function setAssociationValues(field, value) {
         return String(value);
     };
     for (let opt of config.records) {
+        const optAny = opt;
+        const displayField = typeof field.modelConfig.titleField !== 'undefined'
+            ? field.modelConfig.titleField
+            : typeof optAny.title !== 'undefined'
+                ? 'title'
+                : typeof optAny.name !== 'undefined'
+                    ? 'name'
+                    : config.identifierField;
+        const label = typeof config.displayModifier === 'function'
+            ? config.displayModifier(opt)
+            : optAny[displayField];
         options.push({
-            label: config.displayModifier && typeof config.displayModifier === 'function'
-                ? config.displayModifier(opt)
-                : (config.displayField ? opt[config.displayField] : opt[config.identifierField]),
-            value: opt[config.identifierField],
+            label,
+            value: optAny[config.identifierField],
         });
-        if (isOptionSelected(opt[config.identifierField], getAssociationValue(value, config))) {
+        if (!isObject(config))
+            throw `Type error: config is object`;
+        if (config.identifierField && isOptionSelected(opt[config.identifierField], getAssociationValue(value, field))) {
             initValue.push(opt[config.identifierField]);
         }
     }

package/interfaces/adminpanelConfig.d.ts

@@ -192,6 +192,7 @@ export interface ModelConfig {
          */
         visible?: boolean;
         /**
+         * User groups who will see the menu item
          * For which it will be shown if not established will be shown to all groups who have the rights to read
          */
         groupsAccessRights?: string[];
@@ -222,7 +223,7 @@ export interface ModelConfig {
         filter?: {
             [key: string]: {
                 name: string;
-                criteria: any;
+                criteria: Record<string, any>;
             };
         };
     } | boolean;
@@ -250,6 +251,11 @@ export interface ModelConfig {
      * Entity icon
      * */
     icon?: MaterialIcon;
+    /**
+     * The field that will be shown for communication
+     * @default `title` or `name`
+     */
+    titleField?: string;
     /**
      * Force set primary key
      * */
@@ -300,6 +306,7 @@ export interface BaseFieldConfig {
     identifierField?: string;
     /**
      * Label for associations
+     * @deprecated use model labelField prop
      * */
     displayField?: string;
     /**

package/lib/Adminizer.js

@@ -126,11 +126,13 @@ export class Adminizer {
             }
         };
         this.modelHandler = new ModelHandler();
+        // TODO: 'hot reload' unbind models & unbind forms
         await bindModels(this);
         await bindForms(this);
         this.config.rootPath = path.resolve(import.meta.dirname + "/..");
         this.policyManager = new PolicyManager(this);
         await this.policyManager.loadPolicies();
+        // TODO: 'hot reload' problem with deleting access right tokens
         this.accessRightsHelper = new AccessRightsHelper(this);
         // Helpers go to construtor
         this.configHelper = new ConfigHelper(this);

package/lib/datatable/NodeTable.js

@@ -160,6 +160,9 @@ export class NodeTable {
             Object.keys(this.fields).forEach((key) => {
                 let fieldConfigConfig = this.fields[key].config;
                 let fieldName = key;
+                let displayField = this.fields[key].modelConfig?.titleField ?? typeof row["title"] !== "undefined" ? 'title'
+                    : typeof row["name"] !== "undefined" ? 'name'
+                        : typeof row[this.fields[key].modelConfig?.identifierField] !== "undefined" ? this.fields[key].modelConfig?.identifierField : this.fields[key].modelConfig?.identifierField;
                 if (fieldConfigConfig.displayModifier) {
                     row[fieldName] = fieldConfigConfig.displayModifier(elem[key]);
                 }
@@ -169,7 +172,7 @@ export class NodeTable {
                         row[fieldName] = null;
                     }
                     else {
-                        row[fieldName] = elem[key][fieldConfigConfig.displayField];
+                        row[fieldName] = elem[key][displayField];
                     }
                 }
                 else if (this.fields[key].model.type === "association-many" || this.fields[key].model.type === "association") {
@@ -179,8 +182,8 @@ export class NodeTable {
                     else {
                         let displayValues = [];
                         elem[key].forEach((item) => {
-                            if (item[fieldConfigConfig.displayField]) {
-                                displayValues.push(item[fieldConfigConfig.displayField]);
+                            if (item[displayField]) {
+                                displayValues.push(item[displayField]);
                             }
                             else {
                                 displayValues.push(item[fieldConfigConfig.identifierField]);

package/lib/v4/DataAccessor.js

@@ -1,5 +1,6 @@
 import { ControllerHelper } from "../../helpers/controllerHelper";
 import { Adminizer } from "../Adminizer";
+import { isObject } from "helpers/JsUtils";
 export class DataAccessor {
     adminizer;
     user;
@@ -32,12 +33,11 @@ export class DataAccessor {
         const modelAttributes = this.entity.model.attributes;
         const tokenId = `${this.actionVerb}-${this.entity.model.modelname}-${this.entity.type}`;
         if (!this.adminizer.accessRightsHelper.hasPermission(tokenId, this.user)) {
-            Adminizer.log.debug(`No access rights to ${this.entity.type}: ${this.entity.model.modelname}`);
+            Adminizer.log.debug(`getFieldsConfig > No access rights to ${this.actionVerb} ${this.entity.type}: ${this.entity.model.modelname}`);
             return undefined;
         }
         const result = {};
         Object.entries(modelAttributes).forEach(([key, modelField]) => {
-            console.log(key);
             // The fields that are recorded separately from the connection in some ORMs, because they are processed at the level above them.
             if (modelAttributes[key].primaryKeyForAssociation === true) {
                 return undefined;
@@ -57,6 +57,7 @@ export class DataAccessor {
             }
             // Getting base field config
             let fldConfig = { key: key, title: key };
+            let associatedModelConfig = undefined;
             /** Combine the field configuration from global and action-specific configs
              *  (now combine it before check, earlier was opposite).
              *  Action-specific config should overwrite the global one */
@@ -87,6 +88,9 @@ export class DataAccessor {
                     const model = this.adminizer.modelHandler.model.get(modelName);
                     if (model) {
                         populatedModelFieldsConfig = this.getAssociatedFieldsConfig(modelName);
+                        if (!isObject(this.adminizer.config.models[modelName]))
+                            throw `type error: model config  of ${modelName} is ${typeof (this.adminizer.config.models[modelName])} expected object`;
+                        associatedModelConfig = this.adminizer.config.models[modelName];
                     }
                     else {
                         Adminizer.log.error(`DataAccessor > getFieldsConfig > Model not found: ${modelName} when ${key}`);
@@ -100,7 +104,7 @@ export class DataAccessor {
             // Normalize final configuration
             fldConfig = this.adminizer.configHelper.normalizeFieldConfig(this.adminizer, fldConfig, key, modelField);
             // Add new field to result set
-            result[key] = { config: fldConfig, model: modelField, populated: populatedModelFieldsConfig };
+            result[key] = { config: fldConfig, model: modelField, populated: populatedModelFieldsConfig, modelConfig: associatedModelConfig };
         });
         this.fields = result;
         return result;
@@ -111,9 +115,9 @@ export class DataAccessor {
             return undefined;
         }
         // Check if user has access to the associated model
-        const tokenId = `${this.actionVerb}-${modelName}-${this.entity.type}`;
+        const tokenId = `read-${modelName}-${this.entity.type}`;
         if (!this.adminizer.accessRightsHelper.hasPermission(tokenId, this.user)) {
-            Adminizer.log.debug(`No access rights to ${this.entity.type}: ${modelName}`);
+            Adminizer.log.debug(`getAssociatedFieldsConfig > No access rights to ${this.actionVerb} ${this.entity.type}: ${modelName}`);
             return undefined;
         }
         const associatedFields = {};
@@ -162,6 +166,7 @@ export class DataAccessor {
                 config: fldConfig,
                 model: modelField,
                 populated: undefined, // set undefined for already populated fields
+                modelConfig: undefined
             };
         });
         return associatedFields;

package/lib/v4/model/ModelHandler.js

@@ -9,6 +9,7 @@ export class ModelHandler {
         this.models.set(modelname, modelInstance);
         Adminizer.log.debug(`Model with name [${modelname}] was registered`);
     }
+    // TODO: 'hot reload' need add method for delete model
     /** Improved model getter, so you can write both model.get("UserAP") and model.get("userap") */
     get model() {
         return {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "adminizer",
   "type": "module",
-  "version": "4.1.0-build.21",
+  "version": "4.1.0-build.23",
   "main": "index.js",
   "scripts": {
     "test": "vitest --reporter verbose",