adminizer 4.1.0-build.3 → 4.1.0-build.30

package/interfaces/types.d.ts

@@ -1,6 +1,6 @@
 import { AbstractModel } from "../lib/v4/model/AbstractModel";
 import { ModelConfig } from "./adminpanelConfig";
-export type EntityType = "form" | "model" | "wizard";
+export type EntityType = "form" | "model";
 export interface Entity {
     name: string;
     config?: ModelConfig;

package/lib/Adminizer.d.ts

@@ -4,13 +4,13 @@ import EventEmitter from 'events';
 import { AdminpanelConfig } from "../interfaces/adminpanelConfig";
 import PolicyManager from "./v4/PolicyManager";
 import { ModelHandler } from "./v4/model/ModelHandler";
-import { WidgetHandler } from "./widgets/widgetHandler";
+import { WidgetHandler } from "./v4/widgets/widgetHandler";
 import { AccessRightsHelper } from "../helpers/accessRightsHelper";
 import { ConfigHelper } from "../helpers/configHelper";
 import { AbstractAdapter } from "./v4/model/AbstractModel";
 import { ViteDevServer } from 'vite';
 import { MenuHelper } from "../helpers/menuHelper";
-import { ControlsHandler } from "./controls/ControlsHandler";
+import { ControlsHandler } from "./v4/controls/ControlsHandler";
 export declare class Adminizer {
     app: Express;
     config: AdminpanelConfig;
@@ -24,8 +24,10 @@ export declare class Adminizer {
     widgetHandler: WidgetHandler;
     vite: ViteDevServer;
     controlsHandler: ControlsHandler;
+    jwtSecret: string;
     static logger: winston.Logger;
     constructor(ormAdapters: AbstractAdapter[]);
+    getMiddleware(): (req: any, res: any) => void;
     /**
      * Vite middleware
      * @protected

package/lib/Adminizer.js

@@ -9,7 +9,7 @@ import Router from "./../system/Router";
 import bindAssets from "../system/bindAssets";
 import bindDev from "../system/bindDev";
 import bindDashboardWidgets from "../system/bindDashboardWidgets";
-// import bindNavigation from "../system/bindNavigation";
+import bindNavigation from "../system/bindNavigation";
 // import bindMediaManager from "../system/bindMediaManager";
 import bindAccessRights from "../system/bindAccessRights";
 import bindAuthorization from "../system/bindAuthorization";
@@ -17,7 +17,7 @@ import bindModels from "../system/bindModels";
 import bindForms from "../system/bindForms";
 import bindTranslations from "../system/bindTranslations";
 import { ModelHandler } from "./v4/model/ModelHandler";
-import { WidgetHandler } from "./widgets/widgetHandler";
+import { WidgetHandler } from "./v4/widgets/widgetHandler";
 import { AccessRightsHelper } from "../helpers/accessRightsHelper";
 import bindReqFunctions from "../system/bindReqFunctions";
 import { ConfigHelper } from "../helpers/configHelper";
@@ -28,7 +28,8 @@ import { createServer as createViteServer } from 'vite';
 import { bindInertia } from "../system/bindInertia";
 import { MenuHelper } from "../helpers/menuHelper";
 import { bindControls } from "../system/bindControls";
-import { ControlsHandler } from "./controls/ControlsHandler";
+import { ControlsHandler } from "./v4/controls/ControlsHandler";
+import { v4 as uuid } from "uuid";
 export class Adminizer {
     app;
     config;
@@ -42,8 +43,9 @@ export class Adminizer {
     widgetHandler;
     vite;
     controlsHandler;
+    jwtSecret = process.env.JWT_SECRET ?? uuid();
     static logger = winston.createLogger({
-        level: "info",
+        level: process.env.LOG_LEVEL ?? "debug",
         format: winston.format.combine(winston.format.timestamp(), winston.format.printf(({ timestamp, level, message, ...meta }) => {
             const metaString = Object.keys(meta).length ? JSON.stringify(meta) : "";
             return `[${timestamp}] ${level.toUpperCase()}: ${message} ${metaString}`;
@@ -58,6 +60,21 @@ export class Adminizer {
         this._emitter = new EventEmitter();
         this.ormAdapters = ormAdapters;
     }
+    getMiddleware() {
+        return (req, res) => {
+            this.app(req, res, (err) => {
+                if (err) {
+                    console.error("Error in Adminizer", err);
+                    res.writeHead(500, { 'Content-Type': 'text/plain' });
+                    res.end('Internal Server Error');
+                }
+                else {
+                    res.writeHead(404, { 'Content-Type': 'text/plain' });
+                    res.end('Route Not Found in Adminizer');
+                }
+            });
+        };
+    }
     /**
      * Vite middleware
      * @protected
@@ -76,6 +93,9 @@ export class Adminizer {
     async init(config) {
         // set cookie parser
         this.app.use(cookieParser());
+        if (!config || Object.keys(config).length === 0) {
+            Adminizer.log.warn(`Adminizer init > Adminizer config is emtpy`);
+        }
         // Set vite middleware
         const isViteDev = process.env.VITE_ENV === "dev";
         if (isViteDev)
@@ -105,28 +125,30 @@ export class Adminizer {
                 set: configForms.set ?? defaultForms.set
             }
         };
-        // console.log("CONFIG", this.config)
         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);
         this.menuHelper = new MenuHelper(this.config);
         this.widgetHandler = new WidgetHandler(this);
         bindExpressUtils(this.app);
         bindReqFunctions(this);
-        // add install stepper policy to check unfilled settings
-        // bindInstallStepper(this); // TODO It is necessary to provide an opportunity to be inserted by an intermediary after authorization, but before the admin panel, in order to block the user from managing the Installstepper's admin panel.
         // Bind assets
         bindAssets(this.app, this.config.routePrefix);
-        if ((process.env.DEV && process.env.NODE_ENV !== 'production') || process.env.ADMINPANEL_FORCE_BIND_DEV === "TRUE") {
-            bindDev(this);
+        if (!process.env.VITEST) {
+            if ((process.env.DEV && process.env.NODE_ENV !== 'production') || process.env.ADMINPANEL_FORCE_BIND_DEV === "TRUE") {
+                bindDev(this);
+            }
         }
         await bindDashboardWidgets(this);
-        // bindNavigation(this);
+        bindNavigation(this);
         // bindMediaManager(this);
         await bindAccessRights(this);
         if (I18n.appendLocale) {

package/lib/media-manager/AbstractMediaManager.d.ts

@@ -143,10 +143,10 @@ export declare abstract class AbstractMediaManager {
     uloadAllowedTypes: string[];
     dir: string;
     /**
-     * Разрешает или нет поиск по названию
+     
      */
     allowSearch: boolean;
-    /**  ⚠️ ВЫШЕ НАСТРОЙКИ КОТОРЫЕ НАДО РЕАЛИЗОВАТЬ */
+    /**⚠️ above the settings that need to be implemented*/
     /**
      * id for mediamanager instance
      */

package/lib/media-manager/AbstractMediaManager.js

@@ -34,7 +34,7 @@ export class AbstractMediaManager {
     uloadAllowedTypes;
     dir;
     /**
-     * Разрешает или нет поиск по названию
+     
      */
     allowSearch;
     itemTypes = [];

package/lib/media-manager/Items.js

@@ -324,12 +324,9 @@
 //   try {
 //     await fs.promises.access(file);
 //     await fs.promises.unlink(file);
-//     console.log('The file was successfully deleted');
 //   } catch (err) {
 //     if (err.code === 'ENOENT') {
-//       console.log('The file does not exist');
 //     } else if (err.code === 'EPERM') {
-//       console.log('You do not have permission to delete this file');
 //     } else {
 //       console.error(`An error occurred: ${err}`);
 //     }

package/lib/requestProcessor.js

@@ -1,3 +1,4 @@
+import { isObject } from "../helpers/JsUtils";
 import { Adminizer } from "./Adminizer";
 /**
  * Default helper that will contain all methods
@@ -29,11 +30,17 @@ export class RequestProcessor {
         }
         for (let key in postParams) {
             let field = fields[key];
-            if (field.model.type === 'boolean') {
-                postParams[key] = ['true', '1', 'yes', "TRUE", "on"].includes(postParams[key].toString().toLowerCase());
-                continue;
+            if (key === 'sort') {
+                console.log(fields[key], key, postParams[key]);
             }
+            // if (field.model.type === 'boolean') {
+            //     postParams[key] = ['true', '1', 'yes', "TRUE", "on"].includes(postParams[key].toString().toLowerCase());
+            //     continue;
+            // }
             if (field.model.type === 'number') {
+                if (isObject(field.config) && field.config.type === "boolean" && typeof postParams[key] === "boolean") {
+                    postParams[key] = postParams[key] ? 1 : 0;
+                }
                 postParams[key] = parseFloat(postParams[key]);
             }
             if (field.model.type === 'json') {

package/lib/v4/DataAccessor.d.ts

@@ -4,13 +4,16 @@
 import { Entity } from "../../interfaces/types";
 import { ActionType } from "../../interfaces/adminpanelConfig";
 import { Fields } from "../../helpers/fieldsHelper";
+import { Adminizer } from "../Adminizer";
+import { UserAP } from "models/UserAP";
 export declare class DataAccessor {
     private readonly adminizer;
-    user: ModelsAP["UserAP"];
+    user: UserAP;
     entity: Entity;
     action: ActionType;
     private fields;
-    constructor(req: ReqType, entity: Entity, action: ActionType);
+    private actionVerb;
+    constructor(adminizer: Adminizer, user: UserAP, entity: Entity, action: ActionType);
     /**
      * Retrieves the fields for the given entity based on action type,
      * taking into account access rights and configuration settings.

package/lib/v4/DataAccessor.js

@@ -1,16 +1,19 @@
 import { ControllerHelper } from "../../helpers/controllerHelper";
 import { Adminizer } from "../Adminizer";
+import { isObject } from "../../helpers/JsUtils";
 export class DataAccessor {
     adminizer;
     user;
     entity;
     action;
     fields = null;
-    constructor(req, entity, action) {
-        this.adminizer = req.adminizer;
-        this.user = req.session.UserAP;
+    actionVerb;
+    constructor(adminizer, user, entity, action) {
+        this.adminizer = adminizer;
+        this.user = user;
         this.entity = entity;
         this.action = action;
+        this.actionVerb = getTokenAction(this.action);
     }
     /**
      * Retrieves the fields for the given entity based on action type,
@@ -26,10 +29,19 @@ export class DataAccessor {
         }
         // get action and field configs
         const actionConfig = ControllerHelper.findActionConfig(this.entity, this.action);
-        const fieldsConfig = this.entity.config.fields || {};
+        const fieldsConfig = this.entity.config?.fields || {};
         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(`getFieldsConfig > No access rights to ${this.actionVerb} ${this.entity.type}: ${this.entity.model.modelname}`);
+            return undefined;
+        }
         const result = {};
         Object.entries(modelAttributes).forEach(([key, modelField]) => {
+            // 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;
+            }
             // Checks for short type in Waterline: fieldName: 'string'
             if (typeof modelField === "string") {
                 modelField = { type: modelField };
@@ -45,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 */
@@ -66,42 +79,52 @@ export class DataAccessor {
             let populatedModelFieldsConfig = {};
             if (modelField.type === "association" || modelField.type === "association-many") {
                 const modelName = modelField.model || modelField.collection;
+                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;
+                }
                 if (modelName) {
-                    const Model = this.adminizer.modelHandler.model.get(modelName);
-                    if (Model) {
+                    const model = this.adminizer.modelHandler.model.get(modelName);
+                    if (model) {
                         populatedModelFieldsConfig = this.getAssociatedFieldsConfig(modelName);
+                        let _modelConfig = this.adminizer.config.models[modelName];
+                        if (!isObject(_modelConfig))
+                            throw `type error: model config  of ${modelName} is ${typeof (this.adminizer.config.models[modelName])} expected object`;
+                        associatedModelConfig = _modelConfig;
                     }
                     else {
-                        Adminizer.log.error(`Model not found: ${modelName}`);
+                        Adminizer.log.error(`DataAccessor > getFieldsConfig > Model not found: ${modelName} when ${key}`);
                     }
                 }
             }
             // Set required and type attributes
-            fldConfig.required = Boolean(fldConfig.required || modelField.required);
+            fldConfig.required = Boolean(fldConfig.required ?? modelField.required);
             // Default type for field. Could be fetched form config file or file model if not defined in config file.
             fldConfig.type = (fldConfig.type || modelField.type).toLowerCase();
             // 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;
     }
     getAssociatedFieldsConfig(modelName) {
-        const Model = this.adminizer.modelHandler.model.get(modelName);
-        if (!Model || !this.adminizer.config.models[modelName] || typeof this.adminizer.config.models[modelName] === "boolean") {
+        const model = this.adminizer.modelHandler.model.get(modelName);
+        if (!model || !this.adminizer.config.models[modelName] || typeof this.adminizer.config.models[modelName] === "boolean") {
             return undefined;
         }
         // Check if user has access to the associated model
-        const actionVerb = getTokenAction(this.action);
-        const tokenId = `${actionVerb}-${modelName}-${this.entity.type}`;
+        const tokenId = `read-${modelName}-${this.entity.type}`;
         if (!this.adminizer.accessRightsHelper.hasPermission(tokenId, this.user)) {
-            Adminizer.log.warn(`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 = {};
         const modelConfig = this.adminizer.config.models[modelName];
+        if (!isObject(modelConfig))
+            throw `Type error ModelConfig should is object`;
         // Get the main fields configuration
         const fieldsConfig = modelConfig.fields || {};
         // Merge action-specific fields configuration if it exists
@@ -129,7 +152,7 @@ export class DataAccessor {
         }
         const mergedFieldsConfig = { ...fieldsConfig, ...actionSpecificConfig };
         // Loop through model attributes and apply access checks
-        Object.entries(Model.attributes).forEach(([key, modelField]) => {
+        Object.entries(model.attributes).forEach(([key, modelField]) => {
             const fieldConfig = mergedFieldsConfig[key];
             // Creating a basic config
             let fldConfig = { key: key, title: key };
@@ -146,6 +169,7 @@ export class DataAccessor {
                 config: fldConfig,
                 model: modelField,
                 populated: undefined, // set undefined for already populated fields
+                modelConfig: undefined
             };
         });
         return associatedFields;
@@ -327,7 +351,7 @@ export class DataAccessor {
                     throw new Error(`No intermediate record found in model "${intermediateRelation.model}" associated with user ID "${this.user.id}"`);
                 }
                 // Ensure there is only one associated intermediate record
-                const intermediateRecordCount = await intermediateModel.count({ [via]: this.user.id });
+                const intermediateRecordCount = await intermediateModel.count({ [via]: this.user.id }, this);
                 if (intermediateRecordCount > 1) {
                     throw new Error(`Multiple intermediate records found in model "${intermediateRelation.model}" associated with user ID "${this.user.id}". ` +
                         `Expected only one`);
@@ -363,10 +387,11 @@ export class DataAccessor {
                 const relation = modelAttributes[accessField];
                 if (relation && ['userap', 'groupap'].includes(relation.model.toLowerCase())) {
                     if (relation.model.toLowerCase() === 'userap') {
-                        updatedRecord[accessField] = this.user.id;
+                        if (!this.user.isAdministrator) {
+                            updatedRecord[accessField] = this.user.id;
+                        }
                     }
                     else if (relation.model.toLowerCase() === 'groupap') {
-                        // Works only for users with only one group, later it can be resolved with group weight
                         const userGroups = this.user.groups || [];
                         if (userGroups.length === 1) {
                             updatedRecord[accessField] = userGroups[0].id;
@@ -409,7 +434,7 @@ export class DataAccessor {
                     throw new Error(`No intermediate record found in model "${intermediateRelation.model}" linking user "${this.user.id}" to the main record`);
                 }
                 // Ensure there is only one associated intermediate record
-                const intermediateRecordCount = await intermediateModel.count({ [via]: this.user.id });
+                const intermediateRecordCount = await intermediateModel.count({ [via]: this.user.id }, this);
                 if (intermediateRecordCount > 1) {
                     throw new Error(`Multiple intermediate records found in model "${intermediateRelation.model}" associated with user ID "${this.user.id}". ` +
                         `Expected only one`);

package/lib/v4/I18n.js

@@ -104,7 +104,9 @@ export class I18n {
             return;
         const file = this.locateFile(locale);
         const tmpFile = `${file}.tmp`;
+        const dir = path.dirname(file);
         try {
+            fs.mkdirSync(dir, { recursive: true });
             fs.writeFileSync(tmpFile, JSON.stringify(I18n.locales[locale], null, this.indent), "utf8");
             fs.renameSync(tmpFile, file);
         }

package/lib/v4/POWCaptcha.js

@@ -54,7 +54,6 @@ export class POWCaptcha {
         if (!task || task.label !== label)
             return false;
         // Verify the solution (should be equal to puzzleOptions.message)
-        // console.log("QUESTION", `${taskId}:${label}`)
         if (`${taskId}:${label}` === captchaSolution) {
             this.deleteTask(taskId);
             return true;

package/lib/v4/PolicyManager.js

@@ -27,7 +27,6 @@ class PolicyManager {
             Adminizer.log.info("Adminizer policies loaded");
         }
         catch (e) {
-            console.log(e);
             Adminizer.log.error("Adminizer > Could not load policies", e);
         }
     }