adminizer 4.1.0-build.19 → 4.1.0-build.20

package/lib/datatable/NodeTable.js

@@ -131,8 +131,8 @@ export class NodeTable {
     async output(callback, dataAccessor) {
         try {
             const queryOptions = await this.buildQuery();
-            const totalRecords = await this.model.count({});
-            const filteredRecords = await this.model.count(queryOptions.where);
+            const totalRecords = await this.model.count({}, dataAccessor);
+            const filteredRecords = await this.model.count(queryOptions.where, dataAccessor);
             const data = await this.model.find(queryOptions, dataAccessor);
             const output = {
                 draw: this.request.draw !== "" ? this.request.draw : 0,

package/lib/v4/DataAccessor.js

@@ -7,7 +7,6 @@ export class DataAccessor {
     action;
     fields = null;
     actionVerb;
-    // TODO: change req to adminizr + user
     constructor(adminizer, user, entity, action) {
         this.adminizer = adminizer;
         this.user = user;
@@ -38,6 +37,10 @@ export class DataAccessor {
         }
         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 };
@@ -74,7 +77,6 @@ export class DataAccessor {
             let populatedModelFieldsConfig = {};
             if (modelField.type === "association" || modelField.type === "association-many") {
                 const modelName = modelField.model || modelField.collection;
-                // Todo: test > hide relation without model token
                 const tokenId = `${this.actionVerb}-${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}`);
@@ -340,7 +342,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`);
@@ -423,7 +425,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`);
@@ -432,7 +434,6 @@ export class DataAccessor {
                 updatedRecord[field] = intermediateRecord.id;
             }
         }
-        console.log(updatedRecord, "<<<<<<<<<<<<<<<<<<<,");
         return updatedRecord;
     }
 }

package/lib/v4/model/AbstractModel.d.ts

@@ -10,6 +10,10 @@ export interface Attribute {
     collection?: string;
     via?: string;
     allowNull?: boolean;
+    /**
+     * This is a field that indicates that it refers to keep the bond key 1: 1
+     */
+    primaryKeyForAssociation?: boolean;
 }
 export interface ModelAttributes {
     [key: string]: Attribute;
@@ -49,7 +53,7 @@ export declare abstract class AbstractModel<T> {
     update(criteria: Partial<T>, data: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T>[]>;
     destroyOne(criteria: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T> | null>;
     destroy(criteria: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T>[]>;
-    count(criteria: Partial<T> | undefined): Promise<number>;
+    count(criteria: Partial<T> | undefined, dataAccessor: DataAccessor): Promise<number>;
 }
 export declare abstract class AbstractAdapter {
     abstract Model: any;

package/lib/v4/model/AbstractModel.js

@@ -46,7 +46,8 @@ export class AbstractModel {
         let records = await this._destroy(criteria);
         return records.map(record => dataAccessor.process(record));
     }
-    async count(criteria) {
+    async count(criteria, dataAccessor) {
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
         return this._count(criteria);
     }
 }

package/lib/v4/model/adapter/sequelize.d.ts

@@ -4,6 +4,13 @@ export declare function mapSequelizeToWaterline(model: ModelStatic<any>): Record
 export declare class SequelizeModel<T> extends AbstractModel<T> {
     private model;
     constructor(modelName: string, model: ModelStatic<any>);
+    _convertCriteriaToSequelize(criteria: any): any;
+    _convertWaterlineCriteriaToSequelizeOptions(criteria: any): {
+        where?: any;
+        limit?: number;
+        offset?: number;
+        order?: any[];
+    };
     _assignAssociations(instance: any, assocData: Record<string, any>): Promise<void>;
     protected _create(data: Record<string, any>): Promise<T>;
     protected _findOne(criteria: Partial<T>): Promise<T | null>;

package/lib/v4/model/adapter/sequelize.js

@@ -96,6 +96,7 @@ export function mapSequelizeToWaterline(model) {
         switch (assoc.associationType) {
             case "BelongsTo": {
                 const a = assoc;
+                result[a.foreignKey]["primaryKeyForAssociation"] = true;
                 result[alias] = {
                     type: "association",
                     model: a.target.name.toLowerCase(),
@@ -105,6 +106,7 @@ export function mapSequelizeToWaterline(model) {
             }
             case "HasOne": {
                 const a = assoc;
+                result[a.foreignKey]["primaryKeyForAssociation"] = true;
                 result[alias] = {
                     type: "association",
                     model: a.target.name.toLowerCase(),
@@ -139,93 +141,79 @@ export function mapSequelizeToWaterline(model) {
 function capitalize(str) {
     return str.charAt(0).toUpperCase() + str.slice(1);
 }
-function convertCriteriaToSequelize(criteria) {
-    // console.debug("waterline criteria", criteria)
-    const result = {};
-    for (const key in criteria) {
-        const value = criteria[key];
-        if (value === undefined ||
-            value === null ||
-            (typeof value === "object" && Object.keys(value).length === 0)) {
-            continue;
-        }
-        if (typeof value === "object" && !Array.isArray(value)) {
-            const operatorEntries = Object.entries(value)
-                .filter(([_, v]) => v !== undefined && v !== null)
-                .map(([op, val]) => {
-                switch (op) {
-                    case "contains": return [Op.like, `%${val}%`];
-                    case "startsWith": return [Op.startsWith, val];
-                    case "endsWith": return [Op.endsWith, val];
-                    case ">": return [Op.gt, val];
-                    case ">=": return [Op.gte, val];
-                    case "<": return [Op.lt, val];
-                    case "<=": return [Op.lte, val];
-                    case "!=": return [Op.ne, val];
-                    case "in": return [Op.in, val];
-                    case "nin": return [Op.notIn, val];
-                    default: return [Op.eq, val];
-                }
-            });
-            if (operatorEntries.length > 0) {
-                result[key] = Object.fromEntries(operatorEntries);
-            }
-        }
-        else {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-function convertWaterlineCriteriaToSequelizeOptions(criteria) {
-    // console.debug("WATERLINE CRITERIA (raw):", criteria);
-    const { where: nestedWhere, skip, limit, sort, ...rest } = criteria;
-    const rawWhere = (nestedWhere && Object.keys(nestedWhere).length > 0)
-        ? nestedWhere
-        : rest;
-    // console.debug("WATERLINE CRITERIA: using rawWhere =", rawWhere);
-    const where = convertCriteriaToSequelize(rawWhere);
-    // console.debug("convertCriteriaToSequelize →", where);
-    const result = { where };
-    if (typeof skip === "number") {
-        result.offset = skip;
-        // console.debug("→ offset =", skip);
-    }
-    if (typeof limit === "number") {
-        result.limit = limit;
-        // console.debug("→ limit =", limit);
-    }
-    if (typeof sort === "string") {
-        const [field, dir] = sort.trim().split(/\s+/);
-        result.order = [[field, dir?.toUpperCase() === "DESC" ? "DESC" : "ASC"]];
-        // console.debug("→ order =", result.order);
-    }
-    return result;
-}
-function convertWaterlineCriteriaToSequelizeOptions____OLD(criteria) {
-    // console.debug("WATERLINE CRITERIA", criteria)
-    const { where = {}, skip, limit, sort } = criteria;
-    const result = {
-        where: convertCriteriaToSequelize(where),
-    };
-    if (typeof skip === "number") {
-        result.offset = skip;
-    }
-    if (typeof limit === "number") {
-        result.limit = limit;
-    }
-    if (typeof sort === "string") {
-        const [field, direction] = sort.trim().split(/\s+/);
-        result.order = [[field, direction?.toUpperCase() === "DESC" ? "DESC" : "ASC"]];
-    }
-    return result;
-}
 export class SequelizeModel extends AbstractModel {
     model;
     constructor(modelName, model) {
         super(modelName, mapSequelizeToWaterline(model), model.primaryKeyAttribute, model.name);
         this.model = model;
     }
+    _convertCriteriaToSequelize(criteria) {
+        const result = {};
+        for (const key in criteria) {
+            const value = criteria[key];
+            if (value === undefined ||
+                value === null ||
+                (typeof value === "object" && Object.keys(value).length === 0)) {
+                continue;
+            }
+            // 🧠 Заменяем ключ на `via`, если это ассоциация
+            const attr = this.attributes?.[key];
+            let targetKey = key;
+            if (attr?.type === "association" && attr.via) {
+                targetKey = attr.via;
+            }
+            if (typeof value === "object" && !Array.isArray(value)) {
+                const operatorEntries = Object.entries(value)
+                    .filter(([_, v]) => v !== undefined && v !== null)
+                    .map(([op, val]) => {
+                    switch (op) {
+                        case "contains": return [Op.like, `%${val}%`];
+                        case "startsWith": return [Op.startsWith, val];
+                        case "endsWith": return [Op.endsWith, val];
+                        case ">": return [Op.gt, val];
+                        case ">=": return [Op.gte, val];
+                        case "<": return [Op.lt, val];
+                        case "<=": return [Op.lte, val];
+                        case "!=": return [Op.ne, val];
+                        case "in": return [Op.in, val];
+                        case "nin": return [Op.notIn, val];
+                        default: return [Op.eq, val];
+                    }
+                });
+                if (operatorEntries.length > 0) {
+                    result[targetKey] = Object.fromEntries(operatorEntries);
+                }
+            }
+            else {
+                result[targetKey] = value;
+            }
+        }
+        return result;
+    }
+    _convertWaterlineCriteriaToSequelizeOptions(criteria) {
+        // console.debug("WATERLINE CRITERIA (raw):", criteria);
+        const { where: nestedWhere, skip, limit, sort, ...rest } = criteria;
+        const rawWhere = (nestedWhere && Object.keys(nestedWhere).length > 0)
+            ? nestedWhere
+            : rest;
+        // console.debug("WATERLINE CRITERIA: using rawWhere =", rawWhere);
+        const where = this._convertCriteriaToSequelize(rawWhere);
+        const result = { where };
+        if (typeof skip === "number") {
+            result.offset = skip;
+            // console.debug("→ offset =", skip);
+        }
+        if (typeof limit === "number") {
+            result.limit = limit;
+            // console.debug("→ limit =", limit);
+        }
+        if (typeof sort === "string") {
+            const [field, dir] = sort.trim().split(/\s+/);
+            result.order = [[field, dir?.toUpperCase() === "DESC" ? "DESC" : "ASC"]];
+            // console.debug("→ order =", result.order);
+        }
+        return result;
+    }
     async _assignAssociations(instance, assocData) {
         for (const [alias, ids] of Object.entries(assocData)) {
             const assoc = this.model.associations[alias];
@@ -321,7 +309,7 @@ export class SequelizeModel extends AbstractModel {
     // --- FIND ONE ---
     async _findOne(criteria) {
         // console.debug(">> _findOne: входные критерии:", criteria);
-        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
         const includes = this._buildIncludes();
         // console.debug(">> _findOne: преобразованные where:", where);
         // console.debug(">> _findOne: includes:", includes);
@@ -346,7 +334,7 @@ export class SequelizeModel extends AbstractModel {
     async _find(criteria = {}, options = {}) {
         const assocNames = Object.keys(this.model.associations);
         // console.debug(">> _find: входные criteria:", criteria, "options:", options);
-        const { where, limit, offset, order } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where, limit, offset, order } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
         const includes = options.populate
             ? options.populate.map(([field, opts]) => ({ association: field, ...opts }))
             : assocNames.map(a => ({ association: a }));
@@ -358,20 +346,13 @@ export class SequelizeModel extends AbstractModel {
         //   includes,
         // });
         let instances;
-        try {
-            instances = await this.model.findAll({
-                where,
-                limit,
-                offset,
-                order,
-                include: includes
-            });
-            // console.debug(">> _find: получено моделей:", instances.length);
-        }
-        catch (err) {
-            // console.error("!! _find: ошибка в findAll:", err);
-            throw err;
-        }
+        instances = await this.model.findAll({
+            where,
+            limit,
+            offset,
+            order,
+            include: includes
+        });
         for (const inst of instances) {
             //For each association, we call getxxx () once again    
             for (const alias of assocNames) {
@@ -397,7 +378,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- UPDATE ONE ---
     async _updateOne(criteria, data) {
-        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
         const record = await this.model.findOne({ where });
         if (!record)
             return null;
@@ -419,7 +400,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- UPDATE MANY ---
     async _update(criteria, data) {
-        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
         const assocNames = Object.keys(this.model.associations);
         const plainData = {};
         const assocData = {};
@@ -444,7 +425,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- DESTROY ONE ---
     async _destroyOne(criteria) {
-        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
         const record = await this.model.findOne({ where });
         if (!record)
             return null;
@@ -479,7 +460,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- DESTROY MANY ---
     async _destroy(criteria) {
-        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
         const records = await this.model.findAll({ where });
         const assocNames = Object.keys(this.model.associations);
         for (const record of records) {
@@ -516,7 +497,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- COUNT ---
     async _count(criteria = {}) {
-        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
         const result = await this.model.count({ where });
         return result;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "adminizer",
   "type": "module",
-  "version": "4.1.0-build.19",
+  "version": "4.1.0-build.20",
   "main": "index.js",
   "scripts": {
     "test": "vitest --reporter verbose",