adminizer 4.6.0 → 4.7.0-build.221

package/lib/filters/CustomFilterHandler.js

@@ -0,0 +1,131 @@
+/**
+ * Base custom filter handler contract.
+ * Stores model and field separately and builds a full handler ID as "Model.field".
+ */
+export class AbstractCustomFilter {
+    modelName;
+    fieldName;
+    constructor(modelName, fieldName) {
+        if (!modelName?.trim()) {
+            throw new Error("Custom filter handler requires non-empty model name.");
+        }
+        if (!fieldName?.trim()) {
+            throw new Error("Custom filter handler requires non-empty field name.");
+        }
+        this.modelName = modelName;
+        this.fieldName = fieldName;
+    }
+    get id() {
+        return `${this.modelName}.${this.fieldName}`;
+    }
+    /**
+     * Handler description
+     */
+    description;
+    /**
+     * Optional input config for UI (up to 3 inputs).
+     * Example:
+     * {
+     *   from: { placeholder: "From", type: "number" },
+     *   to: { placeholder: "To", type: "number" }
+     * }
+     */
+    inputConfig;
+    getInputDefinitions() {
+        if (!this.inputConfig) {
+            return [];
+        }
+        return Object.entries(this.inputConfig).map(([id, config]) => ({
+            id,
+            placeholder: config?.placeholder || id,
+            type: config?.type === "number" ? "number" : "text",
+        }));
+    }
+}
+/**
+ * CustomFilterHandler - registry for custom field handlers
+ */
+export class CustomFilterHandler {
+    handlers = new Map();
+    validateInputConfig(handler) {
+        const definitions = handler.getInputDefinitions();
+        if (definitions.length > 3) {
+            throw new Error(`Custom filter handler '${handler.id}' supports at most 3 inputs.`);
+        }
+        for (const definition of definitions) {
+            if (!definition.id.trim()) {
+                throw new Error(`Custom filter handler '${handler.id}' has an input with empty id.`);
+            }
+        }
+    }
+    /**
+     * Register a custom handler
+     * @param handler - Handler instance
+     * @param options - Registration options
+     */
+    add(handler, options) {
+        this.validateInputConfig(handler);
+        if (this.handlers.has(handler.id) && !options?.force) {
+            throw new Error(`Handler '${handler.id}' is already registered. Use force: true to overwrite.`);
+        }
+        this.handlers.set(handler.id, handler);
+    }
+    /**
+     * Alias for add()
+     */
+    register(handler, options) {
+        this.add(handler, options);
+    }
+    /**
+     * Get handler by ID
+     */
+    get(id) {
+        return this.handlers.get(id);
+    }
+    /**
+     * Check if handler exists
+     */
+    has(id) {
+        return this.handlers.has(id);
+    }
+    /**
+     * Get all handlers
+     */
+    getAll() {
+        return new Map(this.handlers);
+    }
+    /**
+     * Get handlers for a specific model
+     * @param modelName - Model name (e.g., "Order")
+     * @returns Map of field handlers for the model
+     */
+    getForModel(modelName) {
+        const modelHandlers = new Map();
+        const prefix = `${modelName}.`;
+        for (const [id, handler] of this.handlers.entries()) {
+            if (id.startsWith(prefix)) {
+                modelHandlers.set(id, handler);
+            }
+        }
+        return modelHandlers;
+    }
+    /**
+     * Unregister a handler
+     */
+    unregister(id) {
+        return this.handlers.delete(id);
+    }
+    /**
+     * Clear all handlers (useful for testing)
+     */
+    clear() {
+        this.handlers.clear();
+    }
+    /**
+     * Get count of registered handlers
+     */
+    count() {
+        return this.handlers.size;
+    }
+}
+export default CustomFilterHandler;

package/lib/filters/FilterCustomFieldHandler.d.ts

@@ -0,0 +1,2 @@
+export * from './CustomFilterHandler';
+export { default } from './CustomFilterHandler';

package/lib/filters/FilterCustomFieldHandler.js

@@ -0,0 +1,2 @@
+export * from './CustomFilterHandler.js';
+export { default } from './CustomFilterHandler.js';

package/lib/filters/FilterService.d.ts

@@ -0,0 +1,82 @@
+import { Adminizer } from '../Adminizer';
+import { FilterAP } from '../../models/FilterAP';
+import { FilterColumnAP } from '../../models/FilterColumnAP';
+import { UserAP } from '../../models/UserAP';
+/**
+ * FilterService - manages filter operations
+ *
+ * Key responsibilities:
+ * - Check if filters are enabled for a model
+ * - Apply saved filters to queries
+ * - Integrate with ListQueryBuilder
+ * - Handle filter access control
+ */
+export declare class FilterService {
+    private adminizer;
+    constructor(adminizer: Adminizer);
+    /**
+     * Get ModelResource object by model name
+     * Similar to ControllerHelper.findModelResource but without req dependency
+     */
+    private getModelResourceByModelName;
+    /**
+     * Get filter by ID with access control
+     * Returns null when filter is not found or user has no access.
+     */
+    getFilterById(filterId: string, user: UserAP): Promise<FilterAP | null>;
+    /**
+     * Get filters for a model accessible by user
+     */
+    getFiltersForModel(modelName: string, user: UserAP, options?: {
+        includePublic?: boolean;
+        includeSystem?: boolean;
+    }): Promise<FilterAP[]>;
+    /**
+     * Check if user can view a filter
+     */
+    canViewFilter(filter: FilterAP, user: UserAP): boolean;
+    /**
+     * Check if user can edit a filter
+     */
+    canEditFilter(filter: FilterAP, user: UserAP): boolean;
+    /**
+     * Check if user can delete a filter
+     */
+    canDeleteFilter(filter: FilterAP, user: UserAP): boolean;
+    /**
+     * Count records matching a filter's conditions
+     *
+     * @param filter - Filter to count results for
+     * @param user - User requesting the count (for access control)
+     * @returns Number of matching records, or -1 on error
+     */
+    countFilterResults(filter: FilterAP, user: UserAP): Promise<number>;
+    /**
+     * Create a new filter
+     */
+    createFilter(data: Partial<FilterAP>, user: UserAP): Promise<FilterAP>;
+    /**
+     * Update a filter
+     */
+    updateFilter(filterId: string, data: Partial<FilterAP>, user: UserAP): Promise<FilterAP>;
+    /**
+     * Delete a filter
+     */
+    deleteFilter(filterId: string, user: UserAP): Promise<void>;
+    /**
+     * Get columns for a filter
+     */
+    getFilterColumns(filterId: string): Promise<FilterColumnAP[]>;
+    /**
+     * Update columns for a filter (replace all)
+     */
+    updateFilterColumns(filterId: string, columns: Partial<FilterColumnAP>[], user: UserAP): Promise<FilterColumnAP[]>;
+    /**
+     * Get filter with columns loaded
+     */
+    getFilterWithColumns(filterId: string, user: UserAP): Promise<{
+        filter: FilterAP | null;
+        columns: FilterColumnAP[];
+    }>;
+}
+export default FilterService;

package/lib/filters/FilterService.js

@@ -0,0 +1,323 @@
+import { Adminizer } from '../Adminizer.js';
+import { DataAccessor } from '../DataAccessor.js';
+import { ListQueryBuilder } from '../list-query-builder/ListQueryBuilder.js';
+import { convertDatetimeConditions } from '../../helpers/filterDatetimeHelper.js';
+/**
+ * FilterService - manages filter operations
+ *
+ * Key responsibilities:
+ * - Check if filters are enabled for a model
+ * - Apply saved filters to queries
+ * - Integrate with ListQueryBuilder
+ * - Handle filter access control
+ */
+export class FilterService {
+    adminizer;
+    constructor(adminizer) {
+        this.adminizer = adminizer;
+    }
+    /**
+     * Get ModelResource object by model name
+     * Similar to ControllerHelper.findModelResource but without req dependency
+     */
+    getModelResourceByModelName(modelName) {
+        const models = this.adminizer.config.models;
+        if (!models) {
+            return null;
+        }
+        // Find config (case-insensitive)
+        const foundKey = Object.keys(models).find(key => key.toLowerCase() === modelName.toLowerCase());
+        if (!foundKey) {
+            return null;
+        }
+        const config = models[foundKey];
+        if (!config || typeof config === 'boolean') {
+            return null;
+        }
+        // Get AbstractModel
+        const model = this.adminizer.modelHandler.model.get(config.model);
+        if (!model) {
+            return null;
+        }
+        return {
+            name: foundKey,
+            config,
+            model,
+            uri: `${this.adminizer.config.routePrefix}/model/${foundKey}`
+        };
+    }
+    /**
+     * Get filter by ID with access control
+     * Returns null when filter is not found or user has no access.
+     */
+    async getFilterById(filterId, user) {
+        const filterModel = this.adminizer.modelHandler.internal('filters').get('FilterAP');
+        const filter = await filterModel.findOne({ where: { id: filterId } });
+        if (!filter) {
+            return null;
+        }
+        const filterAP = filter;
+        if (!this.canViewFilter(filterAP, user)) {
+            return null;
+        }
+        return filterAP;
+    }
+    /**
+     * Get filters for a model accessible by user
+     */
+    async getFiltersForModel(modelName, user, options) {
+        const filterModel = this.adminizer.modelHandler.internal('filters').get('FilterAP');
+        const filters = [];
+        // Build base criteria
+        const baseCriteria = { modelName };
+        // 1. Get user's own filters
+        const ownFilters = await filterModel.find({
+            where: {
+                ...baseCriteria,
+                ownerId: user.id
+            }
+        });
+        filters.push(...ownFilters);
+        // 2. Get public filters (if requested)
+        if (options?.includePublic !== false) {
+            const publicFilters = await filterModel.find({
+                where: {
+                    ...baseCriteria,
+                    visibility: 'public'
+                }
+            });
+            // Deduplicate
+            for (const filter of publicFilters) {
+                if (!filters.find(f => f.id === filter.id)) {
+                    filters.push(filter);
+                }
+            }
+        }
+        // 3. Get group filters if user has groups
+        if (user.groups && user.groups.length > 0) {
+            const groupIds = user.groups.map(g => g.id);
+            const groupFilters = await filterModel.find({
+                where: {
+                    ...baseCriteria,
+                    visibility: 'groups'
+                }
+            });
+            // Check if user's groups intersect with filter's groups
+            for (const filter of groupFilters) {
+                if (filter.groupIds && filter.groupIds.some(gid => groupIds.includes(gid))) {
+                    if (!filters.find(f => f.id === filter.id)) {
+                        filters.push(filter);
+                    }
+                }
+            }
+        }
+        // 4. Admin sees all filters
+        if (user.isAdministrator) {
+            const allFilters = await filterModel.find({ where: baseCriteria });
+            for (const filter of allFilters) {
+                if (!filters.find(f => f.id === filter.id)) {
+                    filters.push(filter);
+                }
+            }
+        }
+        if (!options?.includeSystem) {
+            return filters.filter(f => f.visibility !== 'system');
+        }
+        return filters;
+    }
+    /**
+     * Check if user can view a filter
+     */
+    canViewFilter(filter, user) {
+        // Admin can view all
+        if (user.isAdministrator) {
+            return true;
+        }
+        // Owner can view
+        if (filter.ownerId === user.id) {
+            return true;
+        }
+        // Public filters
+        if (filter.visibility === 'public') {
+            return true;
+        }
+        // System filters (accessible via API)
+        if (filter.visibility === 'system') {
+            return true;
+        }
+        // Group filters
+        if (filter.visibility === 'groups' && filter.groupIds && user.groups) {
+            const userGroupIds = user.groups.map(g => g.id);
+            return filter.groupIds.some(gid => userGroupIds.includes(gid));
+        }
+        return false;
+    }
+    /**
+     * Check if user can edit a filter
+     */
+    canEditFilter(filter, user) {
+        // Admin can edit all
+        if (user.isAdministrator) {
+            return true;
+        }
+        // Only owner can edit
+        return filter.ownerId === user.id;
+    }
+    /**
+     * Check if user can delete a filter
+     */
+    canDeleteFilter(filter, user) {
+        return this.canEditFilter(filter, user);
+    }
+    /**
+     * Count records matching a filter's conditions
+     *
+     * @param filter - Filter to count results for
+     * @param user - User requesting the count (for access control)
+     * @returns Number of matching records, or -1 on error
+     */
+    async countFilterResults(filter, user) {
+        try {
+            const modelResource = this.getModelResourceByModelName(filter.modelName);
+            if (!modelResource || !modelResource.model) {
+                Adminizer.log.warn(`FilterService.countFilterResults: Model '${filter.modelName}' not found`);
+                return -1;
+            }
+            const dataAccessor = new DataAccessor(this.adminizer, user, modelResource, 'list');
+            const fields = dataAccessor.getFieldsConfig();
+            // Convert datetime conditions to date ranges
+            const convertedConditions = convertDatetimeConditions(filter.conditions || []);
+            const queryParams = {
+                page: 1,
+                limit: 1, // We only need count
+                filters: convertedConditions
+            };
+            const listQueryBuilder = new ListQueryBuilder(modelResource.model, fields, dataAccessor, this.adminizer.customFilterHandler);
+            const result = await listQueryBuilder.execute(queryParams);
+            return result.filtered;
+        }
+        catch (error) {
+            Adminizer.log.error(`FilterService.countFilterResults error for filter '${filter.id}':`, error);
+            return -1;
+        }
+    }
+    /**
+     * Create a new filter
+     */
+    async createFilter(data, user) {
+        const filterModel = this.adminizer.modelHandler.internal('filters').get('FilterAP');
+        // Generate UUID if not provided
+        if (!data.id) {
+            data.id = crypto.randomUUID();
+        }
+        // Set owner
+        data.ownerId = user.id;
+        // Set defaults
+        data.visibility = data.visibility || 'private';
+        data.version = data.version || 1;
+        data.apiEnabled = data.apiEnabled || false;
+        data.conditions = data.conditions || [];
+        return await filterModel.create(data);
+    }
+    /**
+     * Update a filter
+     */
+    async updateFilter(filterId, data, user) {
+        const filter = await this.getFilterById(filterId, user);
+        if (!filter) {
+            throw new Error(`Filter '${filterId}' not found`);
+        }
+        if (!this.canEditFilter(filter, user)) {
+            throw new Error('Access denied');
+        }
+        const filterModel = this.adminizer.modelHandler.internal('filters').get('FilterAP');
+        // Don't allow changing owner
+        delete data.ownerId;
+        delete data.id;
+        await filterModel.updateOne({ where: { id: filterId } }, data);
+        const updated = await this.getFilterById(filterId, user);
+        if (!updated) {
+            throw new Error(`Filter '${filterId}' not found after update`);
+        }
+        return updated;
+    }
+    /**
+     * Delete a filter
+     */
+    async deleteFilter(filterId, user) {
+        const filter = await this.getFilterById(filterId, user);
+        if (!filter) {
+            throw new Error(`Filter '${filterId}' not found`);
+        }
+        if (!this.canDeleteFilter(filter, user)) {
+            throw new Error('Access denied');
+        }
+        // Delete columns first - find by filter association and delete by ID
+        const columnModel = this.adminizer.modelHandler.internal('filters').get('FilterColumnAP');
+        if (columnModel) {
+            // Find columns for this filter
+            const columns = await columnModel.find({ where: { filter: filterId } });
+            // Delete each column by ID to avoid cascade issues
+            for (const column of columns) {
+                await columnModel.destroyOne({ where: { id: column.id } });
+            }
+        }
+        // Delete filter by ID only
+        const filterModel = this.adminizer.modelHandler.internal('filters').get('FilterAP');
+        if (filterModel) {
+            // Use destroyOne with explicit ID to avoid cascade
+            await filterModel.destroyOne({ where: { id: filterId } });
+        }
+    }
+    /**
+     * Get columns for a filter
+     */
+    async getFilterColumns(filterId) {
+        const columnModel = this.adminizer.modelHandler.internal('filters').get('FilterColumnAP');
+        const columns = await columnModel.find({ where: { filter: filterId } });
+        // Sort by order
+        return columns.sort((a, b) => (a.order || 0) - (b.order || 0));
+    }
+    /**
+     * Update columns for a filter (replace all)
+     */
+    async updateFilterColumns(filterId, columns, user) {
+        const filter = await this.getFilterById(filterId, user);
+        if (!filter) {
+            throw new Error(`Filter '${filterId}' not found`);
+        }
+        if (!this.canEditFilter(filter, user)) {
+            throw new Error('Access denied');
+        }
+        const columnModel = this.adminizer.modelHandler.internal('filters').get('FilterColumnAP');
+        // Delete existing columns
+        await columnModel.destroy({ where: { filter: filterId } });
+        // Create new columns
+        if (columns.length > 0) {
+            for (let i = 0; i < columns.length; i++) {
+                const col = columns[i];
+                await columnModel.create({
+                    filter: filterId,
+                    fieldName: col.fieldName,
+                    order: col.order ?? i
+                });
+            }
+        }
+        return this.getFilterColumns(filterId);
+    }
+    /**
+     * Get filter with columns loaded
+     */
+    async getFilterWithColumns(filterId, user) {
+        const filter = await this.getFilterById(filterId, user);
+        if (!filter) {
+            return { filter: null, columns: [] };
+        }
+        if (!this.canViewFilter(filter, user)) {
+            return { filter: null, columns: [] };
+        }
+        const columns = await this.getFilterColumns(filterId);
+        return { filter, columns };
+    }
+}
+export default FilterService;

package/lib/filters/index.d.ts

@@ -0,0 +1,6 @@
+export { FilterService, default as FilterServiceDefault } from './FilterService';
+export { CustomFilterHandler, default as CustomFilterHandlerDefault } from './CustomFilterHandler';
+export { AbstractCustomFilter } from './CustomFilterHandler';
+export type { FilterCustomFieldCondition, RegisterOptions, FilterCustomFieldInputConfig, FilterCustomFieldInputDefinition, FilterCustomFieldInputType } from './CustomFilterHandler';
+export { ConditionValidator, default as ConditionValidatorDefault } from './ConditionValidator';
+export type { ValidationResult, ValidationError, FieldConfig, SecurityEvent, SecurityEventType } from './ConditionValidator';

package/lib/filters/index.js

@@ -0,0 +1,4 @@
+export { FilterService, default as FilterServiceDefault } from './FilterService.js';
+export { CustomFilterHandler, default as CustomFilterHandlerDefault } from './CustomFilterHandler.js';
+export { AbstractCustomFilter } from './CustomFilterHandler.js';
+export { ConditionValidator, default as ConditionValidatorDefault } from './ConditionValidator.js';

package/lib/history-actions/AbstractHistoryAdapter.d.ts

@@ -3,7 +3,7 @@ import { UserAP } from "../../models/UserAP";
 import { Adminizer } from "../Adminizer";
 import { Fields } from "../../helpers/fieldsHelper";
 import { ActionType } from "../../interfaces/adminpanelConfig";
-import { Entity } from "../../interfaces/types";
+import { ModelResource } from "../../interfaces/types";
 /**
  * Abstract base class for handling history operations in the AdminPanel.
  * Provides common methods and structure for retrieving, filtering, and formatting historical data.
@@ -33,6 +33,7 @@ export declare abstract class AbstractHistoryAdapter {
      * @param adminizer - The main Adminizer instance.
      */
     protected constructor(adminizer: Adminizer);
+    private internalModel;
     /**
      * Registers access rights for this history adapter.
      * Called during construction with a slight delay to ensure Adminizer is ready.
@@ -139,14 +140,14 @@ export declare abstract class AbstractHistoryAdapter {
      */
     protected getModelRelationsHistory<T extends string | number>(model: string, ids: T[]): Promise<T[]>;
     /**
-     * Constructs an Entity object from a history record.
+     * Constructs an ModelResource object from a history record.
      * Used to access model configuration and instance.
      *
      * @param history - The history record.
-     * @returns Entity object with name, URI, type, model instance, and config.
+     * @returns ModelResource object with name, URI, model instance, and config.
      * @protected
      */
-    protected findEntityObject(history: HistoryActionsAP): Entity;
+    protected findModelResource(history: HistoryActionsAP): ModelResource;
     /**
      * Loads associated records for association-type fields.
      * Populates `records` array in field config for widget rendering.