adminizer 4.6.0 → 4.7.0-build.221

package/helpers/apiKeyHelper.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generates a unique API key for user authentication.
+ * @returns A UUID string representing the user's API key.
+ */
+export declare function generateUserApiKey(): string;

package/helpers/apiKeyHelper.js

@@ -0,0 +1,8 @@
+import { randomUUID } from "crypto";
+/**
+ * Generates a unique API key for user authentication.
+ * @returns A UUID string representing the user's API key.
+ */
+export function generateUserApiKey() {
+    return randomUUID();
+}

package/helpers/configHelper.js

@@ -36,12 +36,12 @@ export class ConfigHelper {
         }
         let config = this.adminizer.config;
         let modelConfig;
-        Object.keys(config.models).forEach((entityName) => {
-            const model = config.models[entityName];
+        Object.keys(config.models).forEach((modelResourceName) => {
+            const model = config.models[modelResourceName];
             if (typeof model !== "boolean") {
                 if (model.model === modelName.toLowerCase()) {
-                    if (typeof config.models[entityName] !== "boolean") {
-                        modelConfig = config.models[entityName];
+                    if (typeof config.models[modelResourceName] !== "boolean") {
+                        modelConfig = config.models[modelResourceName];
                     }
                 }
             }
@@ -119,23 +119,20 @@ export class ConfigHelper {
      */
     static normalizeConfig(config) {
         const defaultConfig = getDefaultConfig();
-        const { forms: configForms = {}, ...restConfig } = config;
-        const { forms: defaultForms = {}, } = defaultConfig;
         const mergedConfig = {
             ...defaultConfig,
-            ...restConfig,
+            ...config,
             models: {
                 ...defaultConfig.models,
                 ...config.models
             },
-            forms: {
-                path: configForms.path ?? defaultForms.path,
-                data: {
-                    ...defaultForms.data,
-                    ...configForms.data
-                },
-                get: configForms.get ?? defaultForms.get,
-                set: configForms.set ?? defaultForms.set
+            navbar: {
+                ...defaultConfig.navbar,
+                ...config.navbar,
+                additionalLinks: [
+                    ...(defaultConfig.navbar?.additionalLinks || []),
+                    ...(config.navbar?.additionalLinks || [])
+                ]
             }
         };
         // Normalize auth config if it's a boolean

package/helpers/controllerHelper.d.ts

@@ -1,4 +1,4 @@
-import { Entity, EntityType } from "../interfaces/types";
+import { ModelResource } from "../interfaces/types";
 import { ActionType, CreateUpdateConfig, ModelConfig } from "../interfaces/adminpanelConfig";
 /**
  * @deprecated need refactor actions
@@ -6,7 +6,7 @@ import { ActionType, CreateUpdateConfig, ModelConfig } from "../interfaces/admin
 type ActionConfig = CreateUpdateConfig;
 export declare class ControllerHelper {
     /**
-     * Default configuration for entity
+     * Default configuration for ModelResource
      *
      * @see ControllerHelper.findConfig
      */
@@ -18,7 +18,7 @@ export declare class ControllerHelper {
      */
     private static _defaultActionConfig;
     /**
-     * Check if given entity config has all required properties
+     * Check if given ModelResource config has all required properties
      *
      * @param {Object} config
      * @returns {boolean}
@@ -26,11 +26,11 @@ export declare class ControllerHelper {
      */
     private static _isValidModelConfig;
     /**
-     * Normalizing entity config.
+     * Normalizing ModelResource config.
      * Will return fulfilled configuration object.
      *
      * @see ControllerHelper._isValidModelConfig
-     * @param entityName
+     * @param modelResourceName
      * @param {Object} config
      * @returns {Object}
      * @private
@@ -45,27 +45,20 @@ export declare class ControllerHelper {
      */
     private static _normalizeActionConfig;
     /**
-     * Get entity type
+     * Get ModelResource name
      *
      * @param {Request} req
      * @returns {?string}
      */
-    static findEntityType(req: ReqType): EntityType;
-    /**
-     * Get entity name
-     *
-     * @param {Request} req
-     * @returns {?string}
-     */
-    static findEntityName(req: ReqType): string;
+    static findModelResourceName(req: ReqType): string;
     /**
      * Searches for config from admin panel
      *
      * @param {Request} req
-     * @param {String} entityName
+     * @param {String} modelResourceName
      * @returns {?Object}
      */
-    static findModelConfig(req: ReqType, entityName: string): ModelConfig;
+    static findModelConfig(req: ReqType, modelResourceName: string): ModelConfig;
     /**
      * Will get action config from configuration file depending to given action
      *
@@ -85,15 +78,15 @@ export declare class ControllerHelper {
      *  }
      *
      * @throws {Error} if req or actionType not passed
-     * @param {Object} entity Entity object with `name`, `config`, `model` {@link ControllerHelper.findEntityObject}
+     * @param {Object} ModelResource ModelResource object with `name`, `config`, `model` {@link ControllerHelper.findModelResource}
      * @param {string} actionType Type of action that config should be loaded for. Example: list, edit, add, remove, view.
      * @returns {Object} Will return object with configs or default configs.
      */
-    static findActionConfig(entity: Entity, actionType: ActionType): ActionConfig;
+    static findActionConfig(modelResource: ModelResource, actionType: ActionType): ActionConfig;
     /**
-     * Will create entity object from request.
+     * Will create ModelResource object from request.
      *
-     * Entity Object will have this format:
+     * ModelResource Object will have this format:
      *
      * @example
      * ```javascript
@@ -108,6 +101,6 @@ export declare class ControllerHelper {
      * @param req
      * @returns {Object}
      */
-    static findEntityObject(req: ReqType): Entity;
+    static findModelResource(req: ReqType): ModelResource;
 }
 export {};

package/helpers/controllerHelper.js

@@ -1,7 +1,7 @@
 import { Adminizer } from "../lib/Adminizer.js";
 export class ControllerHelper {
     /**
-     * Default configuration for entity
+     * Default configuration for ModelResource
      *
      * @see ControllerHelper.findConfig
      */
@@ -21,7 +21,7 @@ export class ControllerHelper {
         fields: {}
     };
     /**
-     * Check if given entity config has all required properties
+     * Check if given ModelResource config has all required properties
      *
      * @param {Object} config
      * @returns {boolean}
@@ -40,29 +40,29 @@ export class ControllerHelper {
     }
     ;
     /**
-     * Normalizing entity config.
+     * Normalizing ModelResource config.
      * Will return fulfilled configuration object.
      *
      * @see ControllerHelper._isValidModelConfig
-     * @param entityName
+     * @param modelResourceName
      * @param {Object} config
      * @returns {Object}
      * @private
      */
-    static _normalizeModelConfig(entityName, config) {
+    static _normalizeModelConfig(modelResourceName, config) {
         if (typeof config === "boolean") {
             config = {
-                model: entityName,
+                model: modelResourceName,
                 icon: 'description',
-                title: entityName
+                title: modelResourceName
             };
         }
         if (!this._isValidModelConfig(config)) {
-            Adminizer.log.error('Wrong entity configuration, using default');
+            Adminizer.log.error('Wrong ModelResource configuration, using default');
             config = {
-                model: entityName,
+                model: modelResourceName,
                 icon: 'description',
-                title: entityName
+                title: modelResourceName
             };
         }
         config = { ...this._defaultModelConfig, ...config };
@@ -83,70 +83,42 @@ export class ControllerHelper {
     }
     ;
     /**
-     * Get entity type
+     * Get ModelResource name
      *
      * @param {Request} req
      * @returns {?string}
      */
-    static findEntityType(req) {
-        const entityType = req.params.entityType;
-        if (!entityType) {
-            const extractedEntityType = req.originalUrl.split('/')[2];
-            if (["form", "model"].includes(extractedEntityType)) {
-                return extractedEntityType;
-            }
-            else {
-                return null;
-            }
+    static findModelResourceName(req) {
+        if (req.params.modelResourceName) {
+            return req.params.modelResourceName;
         }
-        return entityType;
-    }
-    ;
-    /**
-     * Get entity name
-     *
-     * @param {Request} req
-     * @returns {?string}
-     */
-    static findEntityName(req) {
-        if (req.params.entityName) {
-            return req.params.entityName;
+        if (req.params.model) {
+            return req.params.model;
         }
         const urlParts = req.originalUrl.split('/');
-        const entityType = urlParts[2];
-        const entityName = urlParts[3];
-        if (entityType === 'form') {
-            const forms = req.adminizer.config.forms?.data;
-            if (!forms || !Object.keys(forms).some(key => key.toLowerCase() === entityName.toLowerCase())) {
-                throw new Error(`Form "${entityName}" not found`);
-            }
-            return Object.keys(forms).find(key => key.toLowerCase() === entityName.toLowerCase());
-        }
-        if (entityType === 'model') {
-            const models = req.adminizer.config.models;
-            if (!models || !Object.keys(models).some(key => key.toLowerCase() === entityName.toLowerCase())) {
-                throw new Error(`Model "${entityName}" not found`);
-            }
-            return Object.keys(models).find(key => key.toLowerCase() === entityName.toLowerCase());
+        const modelResourceName = urlParts[3];
+        const models = req.adminizer.config.models;
+        if (!models || !Object.keys(models).some(key => key.toLowerCase() === modelResourceName.toLowerCase())) {
+            throw new Error(`Model "${modelResourceName}" not found`);
         }
-        throw new Error(`Unsupported entity type ${entityType} in URL`);
+        return Object.keys(models).find(key => key.toLowerCase() === modelResourceName.toLowerCase());
     }
     /**
      * Searches for config from admin panel
      *
      * @param {Request} req
-     * @param {String} entityName
+     * @param {String} modelResourceName
      * @returns {?Object}
      */
-    static findModelConfig(req, entityName) {
+    static findModelConfig(req, modelResourceName) {
         const models = req.adminizer.config.models;
         if (!models) {
             Adminizer.log.error('No models configuration found');
             return null;
         }
-        const foundKey = Object.keys(models).find(key => key.toLowerCase() === entityName.toLowerCase());
+        const foundKey = Object.keys(models).find(key => key.toLowerCase() === modelResourceName.toLowerCase());
         if (!foundKey) {
-            Adminizer.log.error(`No such route exists: ${entityName}`);
+            Adminizer.log.error(`No such route exists: ${modelResourceName}`);
             return null;
         }
         return this._normalizeModelConfig(foundKey, models[foundKey]);
@@ -170,31 +142,31 @@ export class ControllerHelper {
      *  }
      *
      * @throws {Error} if req or actionType not passed
-     * @param {Object} entity Entity object with `name`, `config`, `model` {@link ControllerHelper.findEntityObject}
+     * @param {Object} ModelResource ModelResource object with `name`, `config`, `model` {@link ControllerHelper.findModelResource}
      * @param {string} actionType Type of action that config should be loaded for. Example: list, edit, add, remove, view.
      * @returns {Object} Will return object with configs or default configs.
      */
-    static findActionConfig(entity, actionType) {
-        if (!entity || !actionType) {
-            throw new Error('No `entity` or `actionType` passed !');
+    static findActionConfig(modelResource, actionType) {
+        if (!modelResource || !actionType) {
+            throw new Error('No `ModelResource` or `actionType` passed !');
         }
         let result = { ...this._defaultActionConfig };
-        if (!entity.config || !entity.config[actionType]) {
+        if (!modelResource.config || !modelResource.config[actionType]) {
             return result;
         }
         /**
          * Here we could get true/false so need to update it to Object for later manipulations
          * In this function
          */
-        if (typeof entity.config[actionType] === "boolean") {
+        if (typeof modelResource.config[actionType] === "boolean") {
             return result;
         }
-        return this._normalizeActionConfig(entity.config[actionType]);
+        return this._normalizeActionConfig(modelResource.config[actionType]);
     }
     /**
-     * Will create entity object from request.
+     * Will create ModelResource object from request.
      *
-     * Entity Object will have this format:
+     * ModelResource Object will have this format:
      *
      * @example
      * ```javascript
@@ -209,30 +181,25 @@ export class ControllerHelper {
      * @param req
      * @returns {Object}
      */
-    static findEntityObject(req) {
-        // Retrieve entity name and type based on the request
-        const entityName = this.findEntityName(req);
-        const entityType = this.findEntityType(req);
-        // Construct the entity URI
-        const entityUri = `${req.adminizer.config.routePrefix}/${entityType}/${entityName}`;
-        // Initialize the Entity object
-        const entity = {
-            name: entityName,
-            uri: entityUri,
-            type: entityType,
+    static findModelResource(req) {
+        // Retrieve model name based on the request
+        const modelResourceName = this.findModelResourceName(req);
+        // Construct the ModelResource URI
+        const modelResourceUri = `${req.adminizer.config.routePrefix}/model/${modelResourceName}`;
+        // Initialize the ModelResource object
+        const modelResource = {
+            name: modelResourceName,
+            uri: modelResourceUri,
             model: null,
             config: null
         };
-        // If the entity type is "model", add additional properties
-        if (entityType === "model") {
-            // Find and add the model configuration to the entity
-            entity.config = this.findModelConfig(req, entityName);
-            // Find and add the model itself to the entity
-            if (this._isValidModelConfig(entity.config)) {
-                entity.model = req.adminizer.modelHandler.model.get(entity.config.model);
-            }
+        // Find and add the model configuration to the ModelResource
+        modelResource.config = this.findModelConfig(req, modelResourceName);
+        // Find and add the model itself to the ModelResource
+        if (this._isValidModelConfig(modelResource.config)) {
+            modelResource.model = req.adminizer.modelHandler.model.get(modelResource.config.model);
         }
-        // Return the completed entity object
-        return entity;
+        // Return the completed ModelResource object
+        return modelResource;
     }
 }

package/helpers/fieldsHelper.js

@@ -38,11 +38,11 @@ export class FieldsHelper {
                 // adding deprecated records array to config for association widget
                 Adminizer.log.warn("Warning: executing malicious job trying to add a huge amount of records in field config," +
                     " please rewrite this part of code in the nearest future");
-                let entity = {
+                let modelResource = {
                     name: modelName, config: req.adminizer.config.models[modelName],
-                    model: Model, uri: `${req.adminizer.config.routePrefix}/model/${modelName}`, type: "model"
+                    model: Model, uri: `${req.adminizer.config.routePrefix}/model/${modelName}`
                 };
-                let dataAccessor = new DataAccessor(req.adminizer, req.user, entity, "view");
+                let dataAccessor = new DataAccessor(req.adminizer, req.user, modelResource, "view");
                 list = await Model.find({}, dataAccessor);
             }
             catch (e) {

package/helpers/filterDatetimeHelper.d.ts

@@ -0,0 +1,5 @@
+import { FilterCondition } from "../models/FilterAP";
+export interface ConvertDatetimeConditionsOptions {
+    dropEmptyValues?: boolean;
+}
+export declare function convertDatetimeConditions(conditions: FilterCondition[] | undefined, options?: ConvertDatetimeConditionsOptions): FilterCondition[];

package/helpers/filterDatetimeHelper.js

@@ -0,0 +1,84 @@
+const DATETIME_LOCAL_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/;
+const OPERATORS_WITHOUT_VALUE = ['isNull', 'isNotNull', 'today'];
+function isOperatorWithoutValue(operator) {
+    return operator !== undefined && OPERATORS_WITHOUT_VALUE.includes(operator);
+}
+function parseDatetimeLocalToUtc(value) {
+    if (!DATETIME_LOCAL_REGEX.test(value)) {
+        return null;
+    }
+    const [datePart, timePart] = value.split('T');
+    const [year, month, day] = datePart.split('-').map(Number);
+    const [hours, minutes] = timePart.split(':').map(Number);
+    if ([year, month, day, hours, minutes].some(Number.isNaN)) {
+        return null;
+    }
+    return new Date(Date.UTC(year, month - 1, day, hours, minutes, 0, 0));
+}
+export function convertDatetimeConditions(conditions, options = {}) {
+    if (!conditions || !Array.isArray(conditions)) {
+        return [];
+    }
+    const { dropEmptyValues = false } = options;
+    return conditions
+        .filter(cond => {
+        if (!dropEmptyValues) {
+            return true;
+        }
+        if (isOperatorWithoutValue(cond.operator)) {
+            return true;
+        }
+        if (cond.value === undefined || cond.value === null || cond.value === '') {
+            return false;
+        }
+        if (Array.isArray(cond.value) && cond.value.length === 0) {
+            return false;
+        }
+        return true;
+    })
+        .map(cond => {
+        if (cond.children && cond.children.length > 0) {
+            return {
+                ...cond,
+                children: convertDatetimeConditions(cond.children, options)
+            };
+        }
+        if (!cond.field || cond.value === undefined || cond.value === null || cond.value === '') {
+            return cond;
+        }
+        if (isOperatorWithoutValue(cond.operator)) {
+            return cond;
+        }
+        if (typeof cond.value === 'string') {
+            const utcDate = parseDatetimeLocalToUtc(cond.value);
+            if (utcDate) {
+                if (cond.operator === 'eq') {
+                    const endOfMinute = new Date(utcDate.getTime() + 59_999);
+                    return {
+                        ...cond,
+                        operator: 'between',
+                        value: [utcDate, endOfMinute]
+                    };
+                }
+                return {
+                    ...cond,
+                    value: utcDate
+                };
+            }
+        }
+        if (Array.isArray(cond.value) && cond.value.length === 2) {
+            const [val1, val2] = cond.value;
+            if (typeof val1 === 'string' && typeof val2 === 'string') {
+                const utcDate1 = parseDatetimeLocalToUtc(val1);
+                const utcDate2 = parseDatetimeLocalToUtc(val2);
+                if (utcDate1 && utcDate2) {
+                    return {
+                        ...cond,
+                        value: [utcDate1, utcDate2]
+                    };
+                }
+            }
+        }
+        return cond;
+    });
+}

package/helpers/inertiaActionsHelper.d.ts

@@ -1,4 +1,4 @@
-import { Entity } from "../interfaces/types";
+import { ModelResource } from "../interfaces/types";
 import { ActionType } from "../interfaces/adminpanelConfig";
 export interface Actions {
     link: string;
@@ -7,4 +7,4 @@ export interface Actions {
     title: string;
     icon: string;
 }
-export default function inertiaActionsHelper(actionType: ActionType, entity: Entity, req: ReqType): Actions[];
+export default function inertiaActionsHelper(actionType: ActionType, modelResource: ModelResource, req: ReqType): Actions[];

package/helpers/inertiaActionsHelper.js

@@ -1,10 +1,11 @@
-export default function inertiaActionsHelper(actionType, entity, req) {
+export default function inertiaActionsHelper(actionType, modelResource, req) {
     let resActions = [];
-    if (req.adminizer.menuHelper.hasGlobalActions(entity.config, actionType)) {
-        const actions = req.adminizer.menuHelper.getGlobalActions(entity.config, actionType);
+    if (req.adminizer.menuHelper.hasGlobalActions(modelResource.config, actionType)) {
+        const actions = req.adminizer.menuHelper.getGlobalActions(modelResource.config, actionType);
         if (actions && actions.length > 0) {
             actions.forEach(function (action) {
-                if (req.adminizer.accessRightsHelper.hasPermission(action.accessRightsToken, req.user)) {
+                const context = `global action "${action.title}" (${action.id}) on model "${modelResource.name}"`;
+                if (req.adminizer.accessRightsHelper.hasPermission(action.accessRightsToken, req.user, context)) {
                     resActions.push({
                         link: action.link,
                         id: action.id,