adminizer 4.6.0 → 4.7.0-build.221

package/lib/history-actions/AbstractHistoryAdapter.js

@@ -2,6 +2,7 @@ import { Adminizer } from "../Adminizer.js";
 import { isObject } from "../../helpers/JsUtils.js";
 import { DataAccessor } from "../DataAccessor.js";
 import { setAssociationValues } from "../../helpers/inertiaAddHelper.js";
+import { isMediaManagerFieldConfig, normalizeMediaManagerWidgetData } from "../media-manager/helpers/MediaManagerHelper.js";
 /**
  * Set of model names excluded from history tracking.
  * These models are internal or administrative and should not appear in user-accessible history.
@@ -49,6 +50,9 @@ export class AbstractHistoryAdapter {
             });
         }
     }
+    internalModel(modelName) {
+        return this.adminizer.modelHandler.internal("history").get(modelName);
+    }
     /**
      * Registers access rights for this history adapter.
      * Called during construction with a slight delay to ensure Adminizer is ready.
@@ -134,8 +138,6 @@ export class AbstractHistoryAdapter {
             let accessHistory = [];
             if (!accessToUsersHistory) {
                 history = history.filter((historyRecord) => {
-                    console.log(historyRecord.user.id === user.id);
-                    console.log(historyRecord.user.id, user.id);
                     return historyRecord.user.id === user.id;
                 });
             }
@@ -147,11 +149,11 @@ export class AbstractHistoryAdapter {
             // Grouping records by model for optimization
             const fieldsCache = new Map();
             for (const historyRecord of accessHistory) {
-                const entity = this.findEntityObject(historyRecord);
+                const modelResource = this.findModelResource(historyRecord);
                 const modelKey = historyRecord.modelName;
                 // We use a cache so as not to create a DataAccessor for each record
                 if (!fieldsCache.has(modelKey)) {
-                    const dataAccessor = new DataAccessor(this.adminizer, user, entity, "edit");
+                    const dataAccessor = new DataAccessor(this.adminizer, user, modelResource, "edit");
                     let fields = dataAccessor.getFieldsConfig();
                     fields = await this.loadAssociations(fields, user, "edit");
                     fieldsCache.set(modelKey, fields);
@@ -176,19 +178,32 @@ export class AbstractHistoryAdapter {
      * @protected
      */
     async _getModelFieldsHistory(history, user) {
-        const entity = this.findEntityObject(history);
-        const dataAccessor = new DataAccessor(this.adminizer, user, entity, "edit");
+        const modelResource = this.findModelResource(history);
+        const dataAccessor = new DataAccessor(this.adminizer, user, modelResource, "edit");
         let fields = dataAccessor.getFieldsConfig();
         fields = await this.loadAssociations(fields, user, "edit");
         let data = {};
         for (const field of Object.keys(fields)) {
             const fieldConfigConfig = fields[field].config;
-            if (fieldConfigConfig.type === 'mediamanager') {
+            if (isMediaManagerFieldConfig(fieldConfigConfig)) {
+                if (!Object.prototype.hasOwnProperty.call(history.data ?? {}, field)) {
+                    continue;
+                }
                 const mediaManager = this.adminizer.mediaManagerHandler.get(fieldConfigConfig.options?.id ?? "default");
                 data[field] = [];
-                if (history.data[field]) {
-                    for (const file of history.data[field]) {
-                        const media = await mediaManager.getFile(file.mimeType, file.id);
+                const files = normalizeMediaManagerWidgetData(history.data[field], field);
+                for (const file of files) {
+                    const fileData = file;
+                    if (!fileData?.id)
+                        continue;
+                    try {
+                        const media = fileData.mimeType
+                            ? await mediaManager.getFile(fileData.mimeType, fileData.id)
+                            : null;
+                        if (!media) {
+                            data[field].push(fileData);
+                            continue;
+                        }
                         data[field].push({
                             id: media.id,
                             mimeType: media.mimeType,
@@ -197,6 +212,9 @@ export class AbstractHistoryAdapter {
                             variants: []
                         });
                     }
+                    catch (_e) {
+                        data[field].push(fileData);
+                    }
                 }
             }
             else if (fieldConfigConfig.type === 'color') {
@@ -223,8 +241,8 @@ export class AbstractHistoryAdapter {
     async setModelsDisplayName(history) {
         const modifiedHistory = [];
         for (const historyRecord of history) {
-            const entity = this.findEntityObject(historyRecord);
-            const { displayName } = entity.config;
+            const modelResource = this.findModelResource(historyRecord);
+            const { displayName } = modelResource.config;
             if (!displayName) {
                 modifiedHistory.push({
                     ...historyRecord,
@@ -233,8 +251,7 @@ export class AbstractHistoryAdapter {
                 continue;
             }
             try {
-                const model = this.adminizer.modelHandler.model.get(entity.name);
-                const record = await model["_findOne"]({ id: historyRecord.modelId });
+                const record = await this.internalModel(modelResource.name).findOne({ where: { id: historyRecord.modelId } });
                 let displayValue;
                 if (typeof displayName === 'string') {
                     displayValue = record ? (record[displayName] ?? historyRecord.modelId.toString()) : historyRecord.modelId.toString();
@@ -272,7 +289,7 @@ export class AbstractHistoryAdapter {
     async getModelRelationsHistory(model, ids) {
         const data = [];
         for (const id of ids) {
-            const record = await this.adminizer.modelHandler.model.get(model.toLowerCase())["_findOne"]({ id });
+            const record = await this.internalModel(model).findOne({ where: { id } });
             if (record) {
                 data.push(id);
             }
@@ -280,27 +297,25 @@ export class AbstractHistoryAdapter {
         return data;
     }
     /**
-     * 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
      */
-    findEntityObject(history) {
-        const entityName = history.modelName;
-        const entityType = "model";
-        const entityUri = `${this.adminizer.config.routePrefix}/${entityType}/${entityName}`;
+    findModelResource(history) {
+        const modelResourceName = history.modelName;
+        const modelResourceUri = `${this.adminizer.config.routePrefix}/model/${modelResourceName}`;
         const models = this.adminizer.config.models;
-        const foundKey = Object.keys(models).find(key => key.toLowerCase() === entityName.toLowerCase());
-        const entity = {
-            name: entityName,
-            uri: entityUri,
-            type: entityType,
+        const foundKey = Object.keys(models).find(key => key.toLowerCase() === modelResourceName.toLowerCase());
+        const modelResource = {
+            name: modelResourceName,
+            uri: modelResourceUri,
             model: this.adminizer.modelHandler.model.get(history.modelName),
             config: models[foundKey]
         };
-        return entity;
+        return modelResource;
     }
     /**
      * Loads associated records for association-type fields.
@@ -336,11 +351,11 @@ export class AbstractHistoryAdapter {
                 // 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: this.adminizer.config.models[modelName],
-                    model: Model, uri: `${this.adminizer.config.routePrefix}/model/${modelName}`, type: "model"
+                    model: Model, uri: `${this.adminizer.config.routePrefix}/model/${modelName}`
                 };
-                let dataAccessor = new DataAccessor(this.adminizer, user, entity, "view");
+                let dataAccessor = new DataAccessor(this.adminizer, user, modelResource, "view");
                 list = await Model.find({}, dataAccessor);
             }
             catch (e) {

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

@@ -6,6 +6,8 @@ export declare class DefaultHistoryAdapter extends AbstractHistoryAdapter {
     id: string;
     model: string;
     constructor(adminizer: Adminizer);
+    private historyModel;
+    private userModel;
     getAllHistory(user: UserAP, forUserName: string, modelName: string, limit?: number, skip?: number, from?: Date, to?: Date): Promise<{
         data: HistoryActionsAP[];
     }>;

package/lib/history-actions/DefaultHistoryAdapter.js

@@ -6,10 +6,16 @@ export class DefaultHistoryAdapter extends AbstractHistoryAdapter {
     constructor(adminizer) {
         super(adminizer);
     }
+    historyModel() {
+        return this.adminizer.modelHandler.internal("history").get(this.model);
+    }
+    userModel() {
+        return this.adminizer.modelHandler.internal("history").get("UserAP");
+    }
     async getAllHistory(user, forUserName, modelName, limit = 15, skip = 0, from, to) {
         let userId = null;
         if (forUserName !== 'all') {
-            const foundUser = await this.adminizer.modelHandler.model.get('userap')["_findOne"]({ login: forUserName });
+            const foundUser = await this.userModel().findOne({ where: { login: forUserName } });
             if (!foundUser) {
                 throw new Error("User not found");
             }
@@ -33,7 +39,7 @@ export class DefaultHistoryAdapter extends AbstractHistoryAdapter {
         while (resultItems.length < limit) {
             // We request with a reserve to reduce the number of requests to the database
             const fetchLimit = Math.min(limit * 2, 50);
-            const history = await this.adminizer.modelHandler.model.get(this.model)["_find"]({
+            const history = await this.historyModel().find({
                 where: query,
                 sort: "createdAt DESC",
                 limit: fetchLimit,
@@ -62,7 +68,7 @@ export class DefaultHistoryAdapter extends AbstractHistoryAdapter {
     }
     async getAllModelHistory(modelId, modelName, user) {
         try {
-            const history = await this.adminizer.modelHandler.model.get(this.model)["_find"]({
+            const history = await this.historyModel().find({
                 where: { modelName: modelName, modelId: String(modelId) },
                 sort: "createdAt DESC"
             });
@@ -74,19 +80,19 @@ export class DefaultHistoryAdapter extends AbstractHistoryAdapter {
         }
     }
     async getModelFieldsHistory(historyId, user) {
-        const history = await this.adminizer.modelHandler.model.get(this.model)["_findOne"]({ id: historyId });
+        const history = await this.historyModel().findOne({ where: { id: historyId } });
         return await this._getModelFieldsHistory(history, user);
     }
     async setHistory(data) {
         try {
-            await this.adminizer.modelHandler.model.get(this.model)["_update"]({
+            await this.historyModel().update({
                 where: {
                     modelId: String(data.modelId),
                     modelName: data.modelName,
                     isCurrent: true
                 }
             }, { isCurrent: false });
-            await this.adminizer.modelHandler.model.get(this.model)["_create"]({
+            await this.historyModel().create({
                 ...data,
                 modelId: String(data.modelId),
                 isCurrent: true

package/lib/history-actions/HistoryHandler.js

@@ -13,7 +13,7 @@ export class HistoryHandler {
         if (!instance) {
             Adminizer.log.debug(`HistoryAdapter with id ${id} not found`);
         }
-        Adminizer.log.debug(`ins`, instance);
+        // Adminizer.log.debug(`ins`, instance)  // DEBUG: removed to reduce console noise
         return instance;
     }
 }

package/lib/list-query-builder/ListQueryBuilder.d.ts

@@ -0,0 +1,117 @@
+import { Fields } from '../../helpers/fieldsHelper';
+import { AbstractModel } from '../model/AbstractModel';
+import { DataAccessor } from '../DataAccessor';
+import { FilterOperator } from '../../models/FilterAP';
+import { CustomFilterHandler } from '../filters/CustomFilterHandler';
+import { ListQueryBuilderParams, ListQueryBuilderResult } from '../../interfaces/listQueryBuilder';
+import { CriteriaWhere } from '../../interfaces/queryCriteria';
+/**
+ * Security limits for filter conditions
+ */
+export declare const FILTER_SECURITY_LIMITS: {
+    MAX_DEPTH: number;
+    MAX_IN_VALUES: number;
+    MAX_CONDITIONS_PER_GROUP: number;
+    MAX_TOTAL_CONDITIONS: number;
+    MAX_STRING_LENGTH: number;
+};
+/**
+ * Custom field condition result
+ */
+export interface CustomFieldCondition {
+    rawSQL?: string;
+    params?: any[];
+    inMemory?: (record: any) => boolean;
+    criteria?: Record<string, any>;
+}
+/**
+ * ListQueryBuilder - replaces legacy NodeTable
+ *
+ * Key improvements:
+ * - Promise-based API (no callbacks)
+ * - Clean interface without DataTables.js format
+ * - Direct integration with FilterCondition
+ * - Support for CustomFilterHandler
+ * - TypeScript type safety
+ * - Full operator support (eq, neq, gt, gte, lt, lte, like, ilike, in, between, isNull, regex, custom)
+ * - Nested AND/OR/NOT groups
+ */
+export declare class ListQueryBuilder {
+    private model;
+    private fields;
+    private dataAccessor;
+    private customFilterHandler?;
+    private fieldsArray;
+    constructor(model: AbstractModel<any>, fields: Fields, dataAccessor: DataAccessor, customFilterHandler?: CustomFilterHandler);
+    /**
+     * Public method to build WHERE clause without executing query
+     * Useful for external execution (e.g., direct adapter calls)
+     */
+    buildWhereClause(params: ListQueryBuilderParams): CriteriaWhere;
+    /**
+     * Execute query with Promise API
+     */
+    execute(params: ListQueryBuilderParams): Promise<ListQueryBuilderResult>;
+    /**
+     * Build WHERE clause from FilterCondition[]
+     * Supports nested AND/OR/NOT groups
+     */
+    private buildWhere;
+    /**
+     * Recursive condition group builder
+     * Key method for complex filter support
+     */
+    private buildConditionGroup;
+    /**
+     * Validate condition
+     */
+    private isValidCondition;
+    /**
+     * Build single condition
+     */
+    private buildSingleCondition;
+    /**
+     * Map filter operators to adapter-neutral criteria operators.
+     */
+    private mapOperatorToCondition;
+    /**
+     * Validate operator-value combination
+     */
+    private validateOperatorValue;
+    private getDayRange;
+    private getMonthRangeByValue;
+    private getYearRangeByValue;
+    private getMonthRangeBetween;
+    private getYearRangeBetween;
+    private isYearValue;
+    private parseYearValue;
+    /**
+     * Build relation condition
+     */
+    private buildRelationCondition;
+    /**
+     * Handle custom condition
+     */
+    private handleCustomCondition;
+    /**
+     * Build global search condition
+     * Searches in string/text/ref fields (same behavior as NodeTable)
+     * Date/time fields are excluded from global search to avoid moment.js warnings
+     */
+    private buildGlobalSearch;
+    /**
+     * Build ORDER clause
+     */
+    private buildOrder;
+    private sanitizeSortDirection;
+    /**
+     * Map data for output
+     */
+    private mapData;
+    private buildSelect;
+    /**
+     * Get allowed operators for field type
+     */
+    static getOperatorsForFieldType(fieldType: string): FilterOperator[];
+}
+export { ListQueryBuilder as ModernListQueryBuilder };