adminizer 4.6.0 → 4.7.0-build.221

package/lib/model/adapter/sequelize.js

@@ -1,4 +1,4 @@
-import { DataTypes, Op } from "sequelize";
+import { Sequelize, DataTypes, Op, HasMany } from "sequelize";
 import { AbstractAdapter, AbstractModel } from "../AbstractModel.js";
 import path from "path";
 import fs from "fs";
@@ -64,10 +64,15 @@ function generateAssociationsFromSchema(models, schemas) {
                 if (model.rawAttributes[alias] || model.associations[alias]) {
                     asName = `${alias}Ref`;
                 }
-                model.belongsTo(targetModel, {
+                const belongsToOptions = {
                     as: asName,
                     foreignKey,
-                });
+                };
+                // Add onDelete constraint if specified
+                if (field.onDelete) {
+                    belongsToOptions.onDelete = field.onDelete;
+                }
+                model.belongsTo(targetModel, belongsToOptions);
             }
         }
     }
@@ -76,19 +81,24 @@ function resolveType(type) {
     const sqlType = typeof type.toString === "function"
         ? type.toString().toLowerCase()
         : "";
-    if (sqlType.includes("string") || sqlType.includes("uuid"))
+    if (sqlType.includes("string") ||
+        sqlType.includes("uuid") ||
+        sqlType.includes("char") ||
+        sqlType.includes("text")) {
         return "string";
+    }
+    // tinyint(1) is used by MySQL/MariaDB for BOOLEAN
+    if (sqlType.includes("bool") || sqlType === "tinyint(1)")
+        return "boolean";
     if (sqlType.includes("int") || sqlType.includes("float") || sqlType.includes("decimal"))
         return "number";
-    if (sqlType.includes("bool"))
-        return "boolean";
     if (sqlType.includes("json"))
         return "json";
     if (sqlType.includes("date"))
         return "string";
     return "ref";
 }
-export function mapSequelizeToWaterline(model) {
+export function mapSequelizeToAdminizerAttributes(model) {
     const result = {};
     const rawAttrs = model.getAttributes();
     for (const name in rawAttrs) {
@@ -155,61 +165,233 @@ function capitalize(str) {
 export class SequelizeModel extends AbstractModel {
     model;
     constructor(modelName, model) {
-        super(modelName, mapSequelizeToWaterline(model), model.primaryKeyAttribute, model.name);
+        super(modelName, mapSequelizeToAdminizerAttributes(model), model.primaryKeyAttribute, model.name);
         this.model = model;
     }
+    _buildJsonContainsCondition(targetKey, item) {
+        const pattern = `%${JSON.stringify(item).replace(/[%_]/g, "\\$&")}%`;
+        const attribute = this.model.rawAttributes?.[targetKey];
+        const columnName = typeof attribute?.field === "string" ? attribute.field : targetKey;
+        return Sequelize.where(Sequelize.cast(Sequelize.col(`${this.model.name}.${columnName}`), "TEXT"), { [Op.like]: pattern });
+    }
     _convertCriteriaToSequelize(criteria) {
+        // Special handling for Sequelize.literal() at the top level
+        if (criteria && typeof criteria === 'object' && 'val' in criteria && typeof criteria.val === 'string') {
+            // This is a Sequelize.literal object, return it as-is
+            return criteria;
+        }
         const result = {};
-        for (const key in criteria) {
+        // Handle both string keys and Symbol keys (Op.and, Op.or, etc.)
+        const allKeys = [
+            ...Object.keys(criteria),
+            ...Object.getOwnPropertySymbols(criteria)
+        ];
+        for (const key of allKeys) {
             const value = criteria[key];
-            if (value === undefined ||
-                (typeof value === "object" && value !== null && Object.keys(value).length === 0)) {
-                continue;
-            }
-            // 🧠 Replace the key with `via` if this is an association
-            const attr = this.attributes?.[key];
+            // 🧠 Replace the key with `via` if this is an association (MUST happen before null/other checks)
             let targetKey = key;
-            if (attr?.type === "association" && attr.via) {
-                targetKey = attr.via;
+            // Only process string keys for association replacement
+            if (typeof key === 'string') {
+                const attr = this.attributes?.[key];
+                // Check if this is an association attribute (either from attributes or model.associations)
+                if (attr?.type === "association" && attr.via) {
+                    targetKey = attr.via;
+                }
+                else if (this.model.associations[key]) {
+                    // Fallback: check associations directly
+                    const assoc = this.model.associations[key];
+                    if (assoc && 'foreignKey' in assoc) {
+                        targetKey = assoc.foreignKey;
+                    }
+                }
             }
+            // Special handling for null values (IS NULL condition)
             if (value === null) {
                 result[targetKey] = { [Op.is]: null };
+                continue;
+            }
+            // 🔹 Handle Sequelize Op operators (already in Sequelize format)
+            if (key === Op.and || key === 'and') {
+                result[Op.and] = Array.isArray(value)
+                    ? value.map((item) => this._convertCriteriaToSequelize(item))
+                    : [];
+                continue;
+            }
+            if (key === Op.or || key === 'or') {
+                result[Op.or] = Array.isArray(value)
+                    ? value.map((item) => this._convertCriteriaToSequelize(item))
+                    : [];
+                continue;
+            }
+            if (key === Op.not || key === 'not' || key === '$not') {
+                result[Op.not] = this._convertCriteriaToSequelize(value);
+                continue;
             }
-            else if (Array.isArray(value)) {
+            // Skip Symbol keys that are not handled above (should not happen, but safety check)
+            if (typeof key === 'symbol') {
+                continue;
+            }
+            if (Array.isArray(value)) {
                 // ✅ Array processing - use the IN operator
                 result[targetKey] = { [Op.in]: value };
             }
             else if (typeof value === "object" && !Array.isArray(value)) {
-                const operatorEntries = Object.entries(value)
-                    .filter(([_, v]) => v !== undefined && v !== null)
-                    .map(([op, val]) => {
+                // Check if value already contains Sequelize Op operators
+                // Need to check both string keys and Symbol keys
+                const valueKeys = Object.keys(value);
+                const valueSymbols = Object.getOwnPropertySymbols(value);
+                // Helper function to check if a symbol/op is a Sequelize operator
+                const isSequelizeOp = (op) => {
+                    // Check direct Symbol equality first
+                    if (op === Op.gt || op === Op.gte || op === Op.lt || op === Op.lte ||
+                        op === Op.eq || op === Op.ne || op === Op.in || op === Op.notIn ||
+                        op === Op.like || op === Op.iLike || op === Op.between ||
+                        op === Op.startsWith || op === Op.endsWith || op === Op.is || op === Op.not) {
+                        return true;
+                    }
+                    // Fallback: check by Symbol description (handles different Symbol instances)
+                    if (typeof op === 'symbol') {
+                        const desc = op.description || op.toString();
+                        return desc.includes('gt') || desc.includes('gte') || desc.includes('lt') || desc.includes('lte') ||
+                            desc.includes('eq') || desc.includes('ne') || desc.includes('in') || desc.includes('notIn') ||
+                            desc.includes('like') || desc.includes('iLike') || desc.includes('between') ||
+                            desc.includes('startsWith') || desc.includes('endsWith') || desc.includes('is') || desc.includes('not');
+                    }
+                    // Check string operators used by Adminizer's adapter-neutral criteria format
+                    return op === '$gt' || op === '$gte' || op === '$lt' || op === '$lte' ||
+                        op === '$eq' || op === '$ne' || op === '$in' || op === '$notIn' ||
+                        op === '$like' || op === '$iLike' || op === '$between' ||
+                        op === '$startsWith' || op === '$endsWith' || op === '$is' || op === '$not' ||
+                        op === 'not';
+                };
+                const hasSequelizeOp = [...valueKeys, ...valueSymbols].some(isSequelizeOp);
+                // If already Sequelize format, pass through
+                if (hasSequelizeOp) {
+                    result[targetKey] = value;
+                    continue;
+                }
+                // Handle operator objects like {contains: 'val'} from Adminizer's criteria format
+                for (const [op, val] of Object.entries(value)) {
+                    if (val === undefined || val === null)
+                        continue;
                     switch (op) {
+                        case "eq":
+                            result[targetKey] = { [Op.eq]: val };
+                            break;
+                        case "ne":
+                            result[targetKey] = { [Op.ne]: val };
+                            break;
+                        case "gt":
+                            result[targetKey] = { [Op.gt]: val };
+                            break;
+                        case "gte":
+                            result[targetKey] = { [Op.gte]: val };
+                            break;
+                        case "lt":
+                            result[targetKey] = { [Op.lt]: val };
+                            break;
+                        case "lte":
+                            result[targetKey] = { [Op.lte]: val };
+                            break;
                         case "contains":
-                            return [Op.like, `%${val}%`];
+                            // Check if field is a date/datetime type
+                            const attr = this.model.rawAttributes?.[targetKey];
+                            const typeName = attr?.type;
+                            // Check type name (works for DATE, DATEONLY, TIME, etc.)
+                            const typeStr = typeof typeName === 'function'
+                                ? typeName.name.toLowerCase()
+                                : String(typeName).toLowerCase();
+                            const isDateType = typeStr.includes('date') || typeStr.includes('time');
+                            // TIME type should use LIKE (it's stored as 'HH:MM' string)
+                            const isTimeType = typeStr === 'time';
+                            if (isDateType && !isTimeType) {
+                                // For date fields (not time), check if value is a valid date
+                                const dateValue = new Date(String(val));
+                                if (isNaN(dateValue.getTime())) {
+                                    // Invalid date string - skip this condition entirely
+                                    // This prevents moment.js warnings
+                                    // Don't add anything to result - field will be excluded from WHERE
+                                }
+                                else {
+                                    // Valid date - use exact match
+                                    result[targetKey] = { [Op.eq]: dateValue };
+                                }
+                            }
+                            else {
+                                // For time fields and non-date fields - use Op.like with wildcards
+                                result[targetKey] = { [Op.like]: `%${val}%` };
+                            }
+                            break;
                         case "startsWith":
-                            return [Op.startsWith, val];
+                            result[targetKey] = { [Op.startsWith]: val };
+                            break;
                         case "endsWith":
-                            return [Op.endsWith, val];
+                            result[targetKey] = { [Op.endsWith]: val };
+                            break;
                         case ">":
-                            return [Op.gt, val];
+                            result[targetKey] = { [Op.gt]: val };
+                            break;
                         case ">=":
-                            return [Op.gte, val];
+                            result[targetKey] = { [Op.gte]: val };
+                            break;
                         case "<":
-                            return [Op.lt, val];
+                            result[targetKey] = { [Op.lt]: val };
+                            break;
                         case "<=":
-                            return [Op.lte, val];
+                            result[targetKey] = { [Op.lte]: val };
+                            break;
                         case "!=":
-                            return [Op.ne, val];
+                            result[targetKey] = { [Op.ne]: val };
+                            break;
                         case "in":
-                            return [Op.in, val];
+                            result[targetKey] = { [Op.in]: val };
+                            break;
+                        case "notIn":
+                            result[targetKey] = { [Op.notIn]: val };
+                            break;
                         case "nin":
-                            return [Op.notIn, val];
+                            result[targetKey] = { [Op.notIn]: val };
+                            break;
+                        case "between":
+                            result[targetKey] = { [Op.between]: val };
+                            break;
+                        case "isNull":
+                            if (val) {
+                                result[targetKey] = { [Op.is]: null };
+                            }
+                            break;
+                        case "isNotNull":
+                            if (val) {
+                                result[targetKey] = { [Op.not]: null };
+                            }
+                            break;
+                        case "regex":
+                            result[targetKey] = { [Op.regexp]: val };
+                            break;
+                        case "jsonContains": {
+                            const values = Array.isArray(val) ? val : [val];
+                            const clauses = values.map((item) => this._buildJsonContainsCondition(targetKey, item));
+                            result[Op.and] = [
+                                ...(result[Op.and] ?? []),
+                                ...clauses
+                            ];
+                            break;
+                        }
+                        case "$is":
+                            result[targetKey] = { [Op.is]: val };
+                            break;
+                        case "$not":
+                            result[targetKey] = { [Op.not]: val };
+                            break;
+                        case "$ne":
+                            result[targetKey] = { [Op.ne]: val };
+                            break;
+                        case "not":
+                            result[targetKey] = { [Op.not]: val };
+                            break;
                         default:
-                            return [Op.eq, val];
+                            result[targetKey] = { [Op.eq]: val };
                     }
-                });
-                if (operatorEntries.length > 0) {
-                    result[targetKey] = Object.fromEntries(operatorEntries);
                 }
             }
             else {
@@ -218,13 +400,23 @@ export class SequelizeModel extends AbstractModel {
         }
         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);
+    _convertAdminizerCriteriaToSequelizeOptions(criteria) {
+        // For Sequelize: extract adapter-neutral pagination and ordering params.
+        // Everything else is WHERE criteria.
+        // 'sort' as string = ordering ("field direction") — goes to ORDER BY
+        // 'sort' as boolean/object = model field — goes to WHERE
+        const criteriaSortValue = 'sort' in criteria ? criteria.sort : undefined;
+        const isOrderingSort = typeof criteriaSortValue === 'string';
+        const { where: nestedWhere, skip, limit, sort: criteriaSort, select, populate, ...rest } = criteria;
+        // If 'sort' is a model field (not an ordering string), put it back
+        if (!isOrderingSort && criteriaSortValue !== undefined) {
+            rest.sort = criteriaSortValue;
+        }
+        // Check if nestedWhere has any keys (including Symbol keys like Op.and)
+        const hasNestedWhereKeys = nestedWhere && (Object.keys(nestedWhere).length > 0 ||
+            Object.getOwnPropertySymbols(nestedWhere).length > 0);
+        // If there's an explicit 'where' key, use it. Otherwise use rest (field conditions).
+        const rawWhere = hasNestedWhereKeys ? nestedWhere : rest;
         const where = this._convertCriteriaToSequelize(rawWhere);
         const result = { where };
         if (typeof skip === "number") {
@@ -235,11 +427,21 @@ export class SequelizeModel extends AbstractModel {
             result.limit = limit;
             // console.debug("→ limit =", limit);
         }
-        if (typeof sort === "string") {
-            const [field, dir] = sort.trim().split(/\s+/);
+        if (typeof criteriaSort === "string") {
+            const [field, dir] = criteriaSort.trim().split(/\s+/);
             result.order = [[field, dir?.toUpperCase() === "DESC" ? "DESC" : "ASC"]];
             // console.debug("→ order =", result.order);
         }
+        else if (criteriaSort && typeof criteriaSort === "object") {
+            result.order = Object.entries(criteriaSort).map(([field, dir]) => [
+                field,
+                String(dir).toUpperCase() === "DESC" ? "DESC" : "ASC"
+            ]);
+        }
+        const attributes = this._buildAttributes(select);
+        if (attributes) {
+            result.attributes = attributes;
+        }
         return result;
     }
     async _assignAssociations(instance, assocData) {
@@ -293,8 +495,6 @@ export class SequelizeModel extends AbstractModel {
                 plainData[key] = val;
             }
         }
-        console.debug(">> Normal fields for create():", JSON.stringify(plainData));
-        console.debug(">> Association data:", JSON.stringify(assocData));
         let instance;
         try {
             instance = await this.model.create(plainData);
@@ -345,13 +545,15 @@ export class SequelizeModel extends AbstractModel {
     // --- FIND ONE ---
     async _findOne(criteria) {
         // console.debug(">> _findOne: input criteria:", criteria);
-        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
-        const includes = this._buildIncludes();
+        const { where, attributes } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
+        const includes = criteria.populate
+            ? this._buildCriteriaIncludes(criteria.populate)
+            : this._buildIncludes();
         // console.debug(">> _findOne: converted where:", where);
         // console.debug(">> _findOne: includes:", includes);
         let instance = null;
         try {
-            instance = await this.model.findOne({ where, include: includes });
+            instance = await this.model.findOne({ where, attributes, include: includes });
             // console.debug(">> _findOne: raw instance:", instance ? instance.toJSON() : null);
         }
         catch (err) {
@@ -367,13 +569,17 @@ export class SequelizeModel extends AbstractModel {
         return plain;
     }
     // --- FIND MANY ---
-    async _find(criteria = {}, options = {}) {
+    async _find(criteria = {}) {
         const assocNames = Object.keys(this.model.associations);
         // console.debug(">> _find: input criteria:", criteria, "options:", options);
-        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 }));
+        const { where, limit, offset, order, attributes } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
+        const hasRelationPathCondition = this._hasRelationPathCondition(where);
+        const usedRelationAliases = hasRelationPathCondition
+            ? this._extractRelationAliasesFromWhere(where)
+            : new Set();
+        const includes = criteria.populate
+            ? this._buildCriteriaIncludes(criteria.populate)
+            : assocNames.map((alias) => this._buildListInclude(alias, usedRelationAliases, hasRelationPathCondition));
         // console.debug(">> _find: where, limit, offset, order, includes:", {
         //   where,
         //   limit,
@@ -384,10 +590,12 @@ export class SequelizeModel extends AbstractModel {
         let instances;
         instances = await this.model.findAll({
             where,
+            attributes,
             limit,
             offset,
             order,
-            include: includes
+            include: includes,
+            subQuery: hasRelationPathCondition ? false : undefined
         });
         for (const inst of instances) {
             //For each association, we call getxxx () once again
@@ -412,9 +620,40 @@ export class SequelizeModel extends AbstractModel {
         // console.debug(">> _find: plain results:", plain);
         return plain;
     }
+    /**
+     * Public method for raw SQL where clauses (Sequelize.literal support)
+     * Bypasses Adminizer criteria conversion for direct Sequelize usage
+     */
+    async findWithRawWhere(where, options = {}) {
+        const assocNames = Object.keys(this.model.associations);
+        const includes = options.populate !== false
+            ? assocNames.map(a => ({ association: a }))
+            : [];
+        const instances = await this.model.findAll({
+            where,
+            limit: options.limit,
+            offset: options.offset,
+            order: options.order,
+            include: includes
+        });
+        return instances.map(i => i.get({ plain: true }));
+    }
+    /**
+     * Public method for count with raw SQL where clauses
+     */
+    async countWithRawWhere(where) {
+        const assocNames = Object.keys(this.model.associations);
+        const include = assocNames.map((association) => ({ association }));
+        return await this.model.count({
+            where,
+            include,
+            distinct: true,
+            col: this.primaryKey || this.model.primaryKeyAttribute || 'id'
+        });
+    }
     // --- UPDATE ONE ---
     async _updateOne(criteria, data) {
-        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
         const record = await this.model.findOne({ where });
         if (!record)
             return null;
@@ -445,7 +684,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- UPDATE MANY ---
     async _update(criteria, data) {
-        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
         const assocNames = Object.keys(this.model.associations);
         const plainData = {};
         const assocData = {};
@@ -479,7 +718,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- DESTROY ONE ---
     async _destroyOne(criteria) {
-        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
         const record = await this.model.findOne({ where });
         if (!record)
             return null;
@@ -514,7 +753,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- DESTROY MANY ---
     async _destroy(criteria) {
-        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
         const records = await this.model.findAll({ where });
         const assocNames = Object.keys(this.model.associations);
         for (const record of records) {
@@ -551,14 +790,122 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- COUNT ---
     async _count(criteria = {}) {
-        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
-        const result = await this.model.count({ where });
+        const { where } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
+        const assocNames = Object.keys(this.model.associations);
+        const include = assocNames.map((association) => ({ association }));
+        const result = await this.model.count({
+            where,
+            include,
+            distinct: true,
+            col: this.primaryKey || this.model.primaryKeyAttribute || 'id'
+        });
         return result;
     }
     // --- HELPER ---
+    _hasRelationPathCondition(input) {
+        if (!input || typeof input !== 'object') {
+            return false;
+        }
+        if (Array.isArray(input)) {
+            return input.some((item) => this._hasRelationPathCondition(item));
+        }
+        const keys = [
+            ...Object.keys(input),
+            ...Object.getOwnPropertySymbols(input)
+        ];
+        for (const key of keys) {
+            if (typeof key === 'string' && /^\$[A-Za-z0-9_]+\.[A-Za-z0-9_]+\$$/.test(key)) {
+                return true;
+            }
+            const value = input[key];
+            if (value && typeof value === 'object' && this._hasRelationPathCondition(value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _extractRelationAliasesFromWhere(input, aliases = new Set()) {
+        if (!input || typeof input !== 'object') {
+            return aliases;
+        }
+        if (Array.isArray(input)) {
+            input.forEach((item) => this._extractRelationAliasesFromWhere(item, aliases));
+            return aliases;
+        }
+        const keys = [
+            ...Object.keys(input),
+            ...Object.getOwnPropertySymbols(input)
+        ];
+        for (const key of keys) {
+            if (typeof key === 'string') {
+                const match = key.match(/^\$([A-Za-z0-9_]+)\.[A-Za-z0-9_]+\$$/);
+                if (match?.[1]) {
+                    aliases.add(match[1]);
+                }
+            }
+            const value = input[key];
+            if (value && typeof value === 'object') {
+                this._extractRelationAliasesFromWhere(value, aliases);
+            }
+        }
+        return aliases;
+    }
+    _buildListInclude(alias, usedRelationAliases, hasRelationPathCondition) {
+        const include = { association: alias };
+        if (!hasRelationPathCondition) {
+            return include;
+        }
+        const association = this.model.associations[alias];
+        const isUsedInWhere = usedRelationAliases.has(alias);
+        const isHasMany = association instanceof HasMany || association?.associationType === 'HasMany';
+        // When filtering by relation path ($alias.field$), extra joined hasMany associations
+        // can duplicate base rows and break page size. Load such associations separately.
+        if (isHasMany && !isUsedInWhere) {
+            include.separate = true;
+        }
+        return include;
+    }
     _buildIncludes() {
         return Object.keys(this.model.associations).map(key => ({ association: key }));
     }
+    _buildAttributes(select) {
+        if (!select) {
+            return undefined;
+        }
+        if (Array.isArray(select)) {
+            const attributes = select.filter((field) => this.model.rawAttributes?.[field]);
+            return attributes.length ? attributes : undefined;
+        }
+        const attributes = Object.entries(select)
+            .filter(([field, enabled]) => enabled && this.model.rawAttributes?.[field])
+            .map(([field]) => field);
+        return attributes.length ? attributes : undefined;
+    }
+    _buildCriteriaIncludes(populate) {
+        return Object.entries(populate).map(([association, nestedCriteria]) => {
+            if (nestedCriteria === true) {
+                return { association };
+            }
+            const { where, attributes, order, limit, } = this._convertAdminizerCriteriaToSequelizeOptions(nestedCriteria);
+            const include = { association };
+            if (where && (Object.keys(where).length > 0 || Object.getOwnPropertySymbols(where).length > 0)) {
+                include.where = where;
+            }
+            if (attributes) {
+                include.attributes = attributes;
+            }
+            if (order) {
+                include.order = order;
+            }
+            if (typeof limit === "number") {
+                include.limit = limit;
+            }
+            if (nestedCriteria.populate) {
+                include.include = this._buildCriteriaIncludes(nestedCriteria.populate);
+            }
+            return include;
+        });
+    }
 }
 export class SequelizeAdapter extends AbstractAdapter {
     sequelize;
@@ -629,7 +976,7 @@ export class SequelizeAdapter extends AbstractAdapter {
         }
     }
 }
-/**Generation of the SEQUELIZE model from the definition, analogue of Waterinecollection.extenD*/
+/** Generation of the Sequelize model from Adminizer's model definition */
 function generateSequelizeModel(sequelize, modelName, rawAttributes) {
     const attributes = {};
     let primaryKey = null;