adminizer 4.1.0-commit.d8a06d3 → 4.1.1

package/lib/Adminizer.js

@@ -3,13 +3,12 @@ import cookieParser from 'cookie-parser';
 import * as path from "path";
 import winston from "winston";
 import EventEmitter from 'events';
-import chalk from 'chalk';
 import PolicyManager from "./v4/PolicyManager";
 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,20 +16,26 @@ 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";
 import { I18n } from "./v4/I18n";
 import { getDefaultConfig } from "../system/defaults";
 import bindExpressUtils from "../system/bindExpressUtils";
-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 {
+    // Preconfigures
+    /**
+     * If you convey this default Middleware, it will add it to the very top of the router,
+     * and will contact each request
+     */
+    defaultMiddleware;
+    // Instances
     app;
     config;
     _emitter;
@@ -43,9 +48,10 @@ export class Adminizer {
     widgetHandler;
     vite;
     controlsHandler;
+    // Constants
     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}`;
@@ -80,19 +86,23 @@ export class Adminizer {
      * @protected
      */
     async viteMiddleware() {
-        // Create a Vite server in middleware mode
+        const { createServer: createViteServer } = await import('vite');
+        const chalk = (await import('chalk')).default;
         this.vite = await createViteServer({
-            server: { middlewareMode: true }, // Enable middleware mode
-            appType: 'custom', // Specify the application type
+            server: { middlewareMode: true },
+            appType: 'custom',
         });
-        // Use Vite Middleware
         this.app.use(this.vite.middlewares);
+        // eslint-disable-next-line no-console
         console.log(chalk.green.bold('Vite is running in development mode!') +
             chalk.blue('\nAccess your app at http://localhost:3000'));
     }
     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)
@@ -123,26 +133,29 @@ 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);
         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) {
@@ -180,7 +193,7 @@ export class Adminizer {
                     this.logger.error(`${error.message}\nStack: ${error.stack}`);
                 }
                 else {
-                    this.logger.error(args.join(" "));
+                    this.logger.error(args.join(" ") + "\n" + new Error().stack);
                 }
             },
             debug: (...args) => this.logger.debug(args.join(" ")),
@@ -188,4 +201,7 @@ export class Adminizer {
             silly: (...args) => this.logger.silly(args.join(" ")),
         };
     }
+    get defaultConfig() {
+        return getDefaultConfig();
+    }
 }

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,6 +4,7 @@
 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;
@@ -11,7 +12,8 @@ export declare class DataAccessor {
     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.user;
+    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,
@@ -28,8 +31,17 @@ export class DataAccessor {
         const actionConfig = ControllerHelper.findActionConfig(this.entity, this.action);
         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/{catalog → v4/catalog}/AbstractCatalog.d.ts

@@ -1,5 +1,4 @@
-import { JSONSchema4 } from "json-schema";
-import { Adminizer } from "../Adminizer";
+import { Adminizer } from "../../Adminizer";
 /**
  * Interface `Item` describes the data that the UI will operate on
  * This is a common interface for all data that is linked to the catalog
@@ -8,7 +7,10 @@ import { Adminizer } from "../Adminizer";
 export interface Item {
     id: string | number;
     name: string;
-    parentId: string | number | null;
+    parentId: string | number;
+    /**
+     *
+     */
     childs?: Item[];
     sortOrder: number;
     icon: string;
@@ -20,8 +22,6 @@ export type _Item_ = {
 };
 /**
  * General Item structure that will be available for all elements, including groups
- *
- *
  */
 export declare abstract class BaseItem<T extends Item> {
     abstract readonly type: string;
@@ -30,6 +30,7 @@ export declare abstract class BaseItem<T extends Item> {
      * I haven't found an easier way to extract this type that goes into generic
      * If you know how to open PR
      * */
+    abstract adminizer: Adminizer;
     /**
      * Catalog name
      */
@@ -50,46 +51,62 @@ export declare abstract class BaseItem<T extends Item> {
      * Array of all global contexts, which will appear for all elements
      */
     readonly actionHandlers: ActionHandler[];
+    /**
+     * Adds the context menu processor
+     */
     addActionHandler(contextHandler: ActionHandler): void;
     /**
      * Adds the required fields
      * @param item
      */
     _enrich(item: T): void;
-    _find(itemId: string | number, catalogId: string): Promise<T>;
-    abstract find(itemId: string | number, catalogId: string): Promise<T>;
+    _find(itemId: string | number, catalogId: string, req?: ReqType): Promise<T>;
+    abstract find(itemId: string | number, catalogId: string, req?: ReqType): Promise<T>;
     /**
      * Is false because default value Group is added
      */
-    abstract update(itemId: string | number, data: T, catalogId: string): Promise<T>;
+    abstract update(itemId: string | number, data: T, catalogId: string, req?: ReqType): Promise<T>;
     /**
      *
-     * @param itemId
+     * @param modelId
      * @param data
      * @param catalogId
+     * @param req
      */
-    abstract updateModelItems(modelId: string | number, data: any, catalogId: string): Promise<T>;
+    abstract updateModelItems(modelId: string | number, data: any, catalogId: string, req?: ReqType): Promise<T>;
     /**
-     * For custom HTML
-     * @param itemId
+     * Create catalog
      * @param data
+     * @param catalogId
+     * @param req
      */
-    abstract create(data: T, catalogId: string): Promise<T>;
+    abstract create(data: T, catalogId: string, req?: ReqType): Promise<T>;
     /**
      *  delete element
      */
-    abstract deleteItem(itemId: string | number, catalogId: string): Promise<void>;
-    abstract getAddHTML(req: ReqType): Promise<{
-        type: 'link' | 'html' | 'jsonForm';
-        data: string;
+    abstract deleteItem(itemId: string | number, catalogId: string, req?: ReqType): Promise<void>;
+    /**
+     * get add template
+     * @param req
+     */
+    abstract getAddTemplate(req: ReqType): Promise<{
+        type: 'component' | 'navigation.group' | 'navigation.link' | 'model';
+        data: any;
     }>;
-    abstract getEditHTML(id: string | number, catalogId: string, req: ReqType, modelId?: string | number): Promise<{
-        type: 'link' | 'html' | 'jsonForm';
-        data: string;
+    /**
+     * get edit template
+     * @param id
+     * @param catalogId
+     * @param req
+     * @param modelId
+     */
+    abstract getEditTemplate(id: string | number, catalogId: string, req: ReqType, modelId?: string | number): Promise<{
+        type: 'component' | 'navigation.group' | 'navigation.link' | 'model';
+        data: any;
     }>;
-    _getChilds(parentId: string | number | null, catalogId: string): Promise<Item[]>;
-    abstract getChilds(parentId: string | number | null, catalogId: string): Promise<Item[]>;
-    abstract search(s: string, catalogId: string): Promise<T[]>;
+    _getChilds(parentId: string | number, catalogId: string, req?: ReqType): Promise<Item[]>;
+    abstract getChilds(parentId: string | number, catalogId: string, req?: ReqType): Promise<Item[]>;
+    abstract search(s: string, catalogId: string, req?: ReqType): Promise<T[]>;
 }
 export declare abstract class AbstractGroup<T extends Item> extends BaseItem<T> {
     readonly type: string;
@@ -104,7 +121,7 @@ export declare abstract class ActionHandler {
      * Three actions are possible, without configuration, configuration via pop-up, and just external action
      * For the first two, a handler is provided, but the third type of action simply calls the HTML in the popup; the controller will be implemented externally
      * */
-    abstract readonly type: "basic" | "json-forms" | "external" | "link" | "partial";
+    abstract readonly type: "basic" | "external" | "link";
     /**
      * Will be shown in the context menu section
      */
@@ -113,16 +130,10 @@ export declare abstract class ActionHandler {
      * Will be shown in the toolbox section
      */
     abstract readonly displayTool: boolean;
-    /** (!*1)
-     * Only for json-forms
-     * ref: https://jsonforms.io/docs
-     */
-    abstract readonly uiSchema: any;
-    abstract readonly jsonSchema: JSONSchema4;
     /**
-     * For "json-forms" | "external"
+     * For "external"
      */
-    abstract getPopUpHTML(data?: any): Promise<string>;
+    abstract getPopUpTemplate(req?: ReqType): Promise<string>;
     /**
      * Only for link type
      */
@@ -141,18 +152,19 @@ export declare abstract class ActionHandler {
      * Implementation of a method that will do something with elements.
      * there's really not much you can do with the context menu
      * @param items
-     * @param config
+     * @param data
+     * @param req
      */
-    abstract handler(items: Item[], data?: any): Promise<void>;
+    abstract handler(items: Item[], data?: any, req?: ReqType): Promise<void | string>;
 }
 /**
  *
-    Abstract
-   ____    _  _____  _    _     ___   ____
-  / ___|  / \|_   _|/ \  | |   / _ \ / ___|
+ Abstract
+ ____    _  _____  _    _     ___   ____
+ / ___|  / \|_   _|/ \  | |   / _ \ / ___|
  | |     / _ \ | | / _ \ | |  | | | | |  _
  | |___ / ___ \| |/ ___ \| |__| |_| | |_| |
-  \____/_/   \_|_/_/   \_|_____\___/ \____|
+ \____/_/   \_|_/_/   \_|_____\___/ \____|
 
 
  */
@@ -190,12 +202,13 @@ export declare abstract class AbstractCatalog {
      * Method for getting childs elements
      * if pass null as parentId this root
      */
-    getChilds(parentId: string | number | null, byItemType?: string): Promise<Item[]>;
+    getChilds(parentId: string | number, byItemType?: string, req?: ReqType): Promise<Item[]>;
     private _bindAccessRight;
     protected constructor(adminizer: Adminizer, items: BaseItem<any>[]);
     setId(id: string): void;
     /**
      * Gettind id list method
+     * @info This is a dummy method, please make realization in sub class
      */
     getIdList(): Promise<string[]>;
     getItemType(type: string): BaseItem<Item>;
@@ -204,62 +217,78 @@ export declare abstract class AbstractCatalog {
     /**
      *  Get an element
      */
-    find(item: Item): Promise<Item>;
+    find(item: Item, req?: ReqType): Promise<Item>;
     /**
      *  Removing an element
      */
-    deleteItem(type: string, id: string | number): void;
+    deleteItem(type: string, id: string | number, req?: ReqType): Promise<void>;
     /**
-     * Receives HTML to update an element for projection into a popup
+     * Get edit template from an item type
+     * @param item
+     * @param id
+     * @param req
+     * @param modelId
      */
-    getEditHTML(item: Item, id: string | number, req: ReqType, modelId?: string | number): Promise<{
-        type: "link" | "html" | "jsonForm";
-        data: string;
+    getEditTemplate(item: Item, id: string | number, req: ReqType, modelId?: string | number): Promise<{
+        type: "component" | "navigation.group" | "navigation.link" | "model";
+        data: any;
     }>;
     /**
-     * Receives HTML to create an element for projection into a popup
+     * Get add template from an item type
+     * @param item
+     * @param req
      */
-    getAddHTML(item: Item, req: ReqType): Promise<{
-        type: "link" | "html" | "jsonForm";
-        data: string;
+    getAddTemplate(item: Item, req: ReqType): Promise<{
+        type: "component" | "navigation.group" | "navigation.link" | "model";
+        data: any;
     }>;
     addActionHandler(actionHandler: ActionHandler): void;
     /**
      * Method for getting group elements
      * If there are several Items, then the global ones will be obtained
      */
-    getActions(items?: Item[]): Promise<ActionHandler[]>;
+    getActions(items?: Item[]): ActionHandler[];
     /**
-     * Implements search and execution of a specific action.handler
+     * Implements search and execution of a specific action handler
      */
-    handleAction(actionId: string, items?: Item[], config?: any): Promise<void>;
+    handleAction(actionId: string, items?: Item[], data?: any, req?: ReqType): Promise<void | string>;
     /**
      * Only For a Link action
      * @param actionId
      */
     getLink(actionId: string): Promise<string>;
     /**
-     * For Extermal and JsonForms actions
+     * For Extermal and actions
      * @param actionId
+     * @param req
      */
-    getPopUpHTML(actionId: string): Promise<string>;
+    getPopUpTemplate(actionId: string, req?: ReqType): Promise<string>;
     /**
      *
      * @param data
+     * @param req
      */
-    createItem<T extends Item>(data: T): Promise<T>;
-    updateItem<T extends Item>(id: string | number, type: string, data: T): Promise<T>;
+    createItem<T extends Item>(data: T, req?: ReqType): Promise<T>;
+    updateItem<T extends Item>(id: string | number, type: string, data: T, req?: ReqType): Promise<T>;
     /**
      * To update all items in the tree after updating the model
-     * @param id
+     * @param modelId
      * @param type
      * @param data
+     * @param req
      */
-    updateModelItems<T extends Item>(modelId: string | number, type: string, data: T): Promise<T>;
+    updateModelItems<T extends Item>(modelId: string | number, type: string, data: T, req?: ReqType): Promise<T>;
     /**
      * Method for getting group elements
      */
-    getitemTypes(): BaseItem<Item>[];
-    search<T extends Item>(s: string, hasExtras?: boolean): Promise<T[]>;
+    getitemTypes(): {
+        type: string;
+        name: string;
+        isGroup: boolean;
+        allowedRoot: boolean;
+        icon: string;
+        actionHandlers: ActionHandler[];
+    }[];
+    search<T extends Item>(s: string, hasExtras?: boolean, req?: ReqType): Promise<T[]>;
     static buildTree(items: Item[]): Item[];
 }