adminizer 4.1.0-build.20 → 4.1.0-build.22

package/helpers/accessRightsHelper.d.ts

@@ -13,3 +13,6 @@ export declare class AccessRightsHelper {
     enoughPermissions(tokens: string[], user: UserAP): boolean;
     hasPermission(tokenId: string, user: UserAP): boolean;
 }
+export declare class GroupsAccessRightsHelper {
+    static hasAccess(user: UserAP, groupsAccessRights?: string[]): boolean;
+}

package/helpers/accessRightsHelper.js

@@ -62,3 +62,15 @@ export class AccessRightsHelper {
         return user.groups.some((group) => group.tokens?.includes(tokenId));
     }
 }
+export class GroupsAccessRightsHelper {
+    static hasAccess(user, groupsAccessRights) {
+        const userGroups = user.groups?.map(group => group.name.toLowerCase());
+        if (groupsAccessRights) {
+            const allowedGroups = groupsAccessRights.map(item => item.toLowerCase());
+            return userGroups?.some(group => allowedGroups.includes(group)) ?? false;
+        }
+        else {
+            return true;
+        }
+    }
+}

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 "lodash-es";
 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/helpers/inertiaMenuHelper.js

@@ -5,7 +5,7 @@ export class InertiaMenuHelper {
     }
     getMenuItems(req) {
         let menu = [];
-        for (const menuItem of this.adminizer.menuHelper.getMenuItems()) {
+        for (const menuItem of this.adminizer.menuHelper.getMenuItems(req.user)) {
             const menuItemTokens = menuItem.actions ? menuItem.actions.map(item => {
                 return item.accessRightsToken;
             }).filter(item => {

package/helpers/menuHelper.d.ts

@@ -3,6 +3,7 @@
  *
  * @constructor
  */
+import { UserAP } from "models/UserAP";
 import { ActionType, AdminpanelConfig, HrefConfig, ModelConfig } from "../interfaces/adminpanelConfig";
 export type MenuItem = {
     link: string;
@@ -60,5 +61,5 @@ export declare class MenuHelper {
      *
      * @returns {Array}
      */
-    getMenuItems(): MenuItem[];
+    getMenuItems(user: UserAP): MenuItem[];
 }

package/helpers/menuHelper.js

@@ -1,3 +1,4 @@
+import { GroupsAccessRightsHelper } from "./accessRightsHelper";
 export class MenuHelper {
     static config;
     constructor(config) {
@@ -98,7 +99,7 @@ export class MenuHelper {
      *
      * @returns {Array}
      */
-    getMenuItems() {
+    getMenuItems(user) {
         let menus = [];
         if (MenuHelper.config.navbar.additionalLinks && MenuHelper.config.navbar.additionalLinks.length > 0) {
             MenuHelper.config.navbar.additionalLinks.forEach(function (additionalLink) {
@@ -118,7 +119,12 @@ export class MenuHelper {
         }
         if (MenuHelper.config.models) {
             Object.entries(MenuHelper.config.models).forEach(function ([key, val]) {
-                if (!val.hide) {
+                const hide = typeof val.navbar?.visible === 'boolean'
+                    ? !val.navbar.visible
+                    : val.navbar?.groupsAccessRights
+                        ? !GroupsAccessRightsHelper.hasAccess(user, val.navbar.groupsAccessRights)
+                        : false;
+                if (!hide) {
                     if (val.tools && val.tools.length > 0 && val.tools[0].id !== "overview") {
                         val.tools.unshift({
                             id: "overview",

package/interfaces/adminpanelConfig.d.ts

@@ -184,9 +184,19 @@ export interface ModelConfig {
      * */
     model: string;
     /**
-     * Hide entity in left navbar
+     * If the field is not definitely, then it will appear in Navbar
      * */
-    hide?: boolean;
+    navbar?: {
+        /**
+         * @default true
+         */
+        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[];
+    };
     /**
      * Entity fields configuration
      * */
@@ -213,7 +223,7 @@ export interface ModelConfig {
         filter?: {
             [key: string]: {
                 name: string;
-                criteria: any;
+                criteria: Record<string, any>;
             };
         };
     } | boolean;
@@ -241,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
      * */
@@ -291,6 +306,7 @@ export interface BaseFieldConfig {
     identifierField?: string;
     /**
      * Label for associations
+     * @deprecated use model labelField prop
      * */
     displayField?: string;
     /**

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 "lodash-es";
 export class DataAccessor {
     adminizer;
     user;
@@ -32,7 +33,7 @@ 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 = {};
@@ -56,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 */
@@ -77,7 +79,7 @@ export class DataAccessor {
             let populatedModelFieldsConfig = {};
             if (modelField.type === "association" || modelField.type === "association-many") {
                 const modelName = modelField.model || modelField.collection;
-                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.silly(`No access rights to ${this.entity.type}: ${this.entity.model.modelname}`);
                     return undefined;
@@ -86,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}`);
@@ -99,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;
@@ -110,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 = {};
@@ -161,6 +166,7 @@ export class DataAccessor {
                 config: fldConfig,
                 model: modelField,
                 populated: undefined, // set undefined for already populated fields
+                modelConfig: undefined
             };
         });
         return associatedFields;

package/package.json

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