adminizer 5.0.0-build.8 → 5.1.0-build.24

package/lib/model/adapter/sequelize.js

@@ -1,22 +1,16 @@
-let Sequelize;
-let Op;
-let HasMany;
 import { AbstractAdapter, AbstractModel } from "../AbstractModel.js";
-try {
-    const sequelize = require('sequelize');
-    Sequelize = sequelize.Sequelize;
-    Op = sequelize.Op;
-    HasMany = sequelize.HasMany;
-}
-catch (error) {
-    const stub = new Proxy({}, {
-        get: () => () => {
-            throw new Error('Sequelize is not installed. Run: npm install sequelize');
-        }
-    });
-    Sequelize = stub;
-    Op = stub;
-    HasMany = stub;
+import { Adminizer } from "../../Adminizer.js";
+let _Sequelize = null;
+let _Op = null;
+let _HasMany = null;
+async function ensureSequelize() {
+    if (_Sequelize)
+        return _Sequelize;
+    const sequelize = await import('sequelize');
+    _Sequelize = sequelize.Sequelize;
+    _Op = sequelize.Op;
+    _HasMany = sequelize.HasMany;
+    return _Sequelize;
 }
 function resolveType(type) {
     const sqlType = typeof type.toString === "function"
@@ -112,15 +106,129 @@ function capitalize(str) {
 }
 export class SequelizeModel extends AbstractModel {
     model;
+    _init = false;
+    async _ensure() {
+        if (!this._init) {
+            await ensureSequelize();
+            this._init = true;
+        }
+    }
     constructor(modelName, model) {
         super(modelName, mapSequelizeToAdminizerAttributes(model), model.primaryKeyAttribute, model.name);
         this.model = model;
     }
+    /**
+     * accessGraph pushdown: compiles the level chain into one nested-subquery literal for
+     * an `{in: ...}` criteria, so the DB planner optimizes the whole walk instead of the
+     * app materializing id lists. Returns undefined — falling back to materialization —
+     * when any level lives on another adapter or connection, an attribute is unknown, or a
+     * level carries a defaultScope we cannot reproduce.
+     *
+     * The materialized path queries through `model.find()`, so it inherits paranoid and
+     * defaultScope filtering; this raw SQL must match it exactly or the same config would
+     * yield two different record sets depending on `pushdown`.
+     *
+     * Every bail-out reports through `decline` before returning: a fallback is invisible in the
+     * result (the records are the same, only slower), so the reason is the only thing that tells
+     * an operator why `pushdown: true` changed nothing.
+     */
+    async compileGraphInSubquery(levels, decline) {
+        await this._ensure();
+        /** Reports the reason and bails out of the whole compilation. */
+        const no = (reason) => {
+            decline?.(reason);
+            return undefined;
+        };
+        const targets = [];
+        for (const level of levels) {
+            if (!(level.model instanceof SequelizeModel)) {
+                return no(`"${level.model.modelname}" is not a Sequelize model`);
+            }
+            const target = level.model.model;
+            if (!target.sequelize || target.sequelize !== this.model.sequelize) {
+                return no(`"${level.model.modelname}" lives on another Sequelize connection`);
+            }
+            targets.push(target);
+        }
+        const queryGenerator = this.model.sequelize.getQueryInterface().queryGenerator;
+        // Adminizer attribute (association alias or plain column) → quoted physical column
+        const columnFor = (levelModel, target, attributeName) => {
+            const attribute = levelModel.attributes?.[attributeName];
+            const rawName = (attribute?.type === "association" && attribute.via) ? attribute.via : attributeName;
+            const raw = target.rawAttributes?.[rawName];
+            if (!raw) {
+                return undefined;
+            }
+            return queryGenerator.quoteIdentifier(raw.field ?? rawName);
+        };
+        let sql;
+        for (let i = 0; i < levels.length; i++) {
+            const level = levels[i];
+            const target = targets[i];
+            const table = queryGenerator.quoteTable(target.getTableName());
+            const selectColumn = columnFor(level.model, target, level.select);
+            if (!selectColumn) {
+                return no(`"${level.model.modelname}.${level.select}" has no column to select`);
+            }
+            const modelOptions = target.options ?? {};
+            // A defaultScope silently narrows every findAll on the model; reproducing an
+            // arbitrary one in raw SQL is not possible, so this chain is not pushed down.
+            if (modelOptions.defaultScope && Object.keys(modelOptions.defaultScope).length) {
+                return no(`"${level.model.modelname}" declares a defaultScope, which raw SQL cannot reproduce `
+                    + `(pushing down would return a different record set than the materialized walk)`);
+            }
+            // Conditions that constrain the level (parent link / literal ids) versus guards that
+            // only exclude rows (paranoid). A level constrained by guards alone is NOT narrowed,
+            // so the emptiness check below must look at linkConditions only.
+            const linkConditions = [];
+            const guardConditions = [];
+            if (modelOptions.paranoid) {
+                const deletedAtAttribute = target._timestampAttributes?.deletedAt
+                    ?? modelOptions.deletedAt
+                    ?? "deletedAt";
+                const rawDeletedAt = target.rawAttributes?.[deletedAtAttribute];
+                if (!rawDeletedAt) {
+                    return no(`"${level.model.modelname}" is paranoid but its "${deletedAtAttribute}" column cannot be `
+                        + `resolved, so soft-deleted rows could not be excluded`);
+                }
+                const deletedAtColumn = queryGenerator.quoteIdentifier(rawDeletedAt.field ?? deletedAtAttribute);
+                guardConditions.push(`${table}.${deletedAtColumn} IS NULL`);
+            }
+            if (level.parentAttribute) {
+                if (!sql) {
+                    return no(`"${level.model.modelname}" links to an inner level that produced no subquery`);
+                }
+                const parentColumn = columnFor(level.model, target, level.parentAttribute);
+                if (!parentColumn) {
+                    return no(`"${level.model.modelname}.${level.parentAttribute}" has no column to link on`);
+                }
+                linkConditions.push(`${table}.${parentColumn} IN ${sql}`);
+            }
+            for (const condition of level.conditions ?? []) {
+                const column = columnFor(level.model, target, condition.attribute);
+                if (!column) {
+                    return no(`"${level.model.modelname}.${condition.attribute}" has no column to filter on`);
+                }
+                if (!condition.values.length) {
+                    linkConditions.push("1 = 0");
+                    continue;
+                }
+                const escaped = condition.values.map((value) => queryGenerator.escape(value)).join(", ");
+                linkConditions.push(`${table}.${column} IN (${escaped})`);
+            }
+            if (!linkConditions.length) {
+                return no(`"${level.model.modelname}" has nothing to narrow it — the level would select every row`);
+            }
+            const conditions = [...linkConditions, ...guardConditions];
+            sql = `(SELECT ${table}.${selectColumn} FROM ${table} WHERE ${conditions.join(" AND ")})`;
+        }
+        return sql ? _Sequelize.literal(sql) : undefined;
+    }
     _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 });
+        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
@@ -155,24 +263,24 @@ export class SequelizeModel extends AbstractModel {
             }
             // Special handling for null values (IS NULL condition)
             if (value === null) {
-                result[targetKey] = { [Op.is]: 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)
+            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)
+            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);
+            if (key === _Op.not || key === 'not' || key === '$not') {
+                result[_Op.not] = this._convertCriteriaToSequelize(value);
                 continue;
             }
             // Skip Symbol keys that are not handled above (should not happen, but safety check)
@@ -181,7 +289,7 @@ export class SequelizeModel extends AbstractModel {
             }
             if (Array.isArray(value)) {
                 // ✅ Array processing - use the IN operator
-                result[targetKey] = { [Op.in]: value };
+                result[targetKey] = { [_Op.in]: value };
             }
             else if (typeof value === "object" && !Array.isArray(value)) {
                 // Check if value already contains Sequelize Op operators
@@ -191,10 +299,10 @@ export class SequelizeModel extends AbstractModel {
                 // 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) {
+                    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)
@@ -220,26 +328,33 @@ export class SequelizeModel extends AbstractModel {
                 }
                 // Handle operator objects like {contains: 'val'} from Adminizer's criteria format
                 for (const [op, val] of Object.entries(value)) {
-                    if (val === undefined || val === null)
+                    if (val === undefined || val === null) {
+                        // Access scoping emits `in` lists, so an absent operand must fail
+                        // closed (match nothing) rather than silently widen the query.
+                        // Other operators keep the historical skip: filter builders rely on it.
+                        if (op === "in") {
+                            result[targetKey] = { [_Op.in]: [] };
+                        }
                         continue;
+                    }
                     switch (op) {
                         case "eq":
-                            result[targetKey] = { [Op.eq]: val };
+                            result[targetKey] = { [_Op.eq]: val };
                             break;
                         case "ne":
-                            result[targetKey] = { [Op.ne]: val };
+                            result[targetKey] = { [_Op.ne]: val };
                             break;
                         case "gt":
-                            result[targetKey] = { [Op.gt]: val };
+                            result[targetKey] = { [_Op.gt]: val };
                             break;
                         case "gte":
-                            result[targetKey] = { [Op.gte]: val };
+                            result[targetKey] = { [_Op.gte]: val };
                             break;
                         case "lt":
-                            result[targetKey] = { [Op.lt]: val };
+                            result[targetKey] = { [_Op.lt]: val };
                             break;
                         case "lte":
-                            result[targetKey] = { [Op.lte]: val };
+                            result[targetKey] = { [_Op.lte]: val };
                             break;
                         case "contains":
                             // Check if field is a date/datetime type
@@ -262,83 +377,88 @@ export class SequelizeModel extends AbstractModel {
                                 }
                                 else {
                                     // Valid date - use exact match
-                                    result[targetKey] = { [Op.eq]: dateValue };
+                                    result[targetKey] = { [_Op.eq]: dateValue };
                                 }
                             }
                             else {
                                 // For time fields and non-date fields - use Op.like with wildcards
-                                result[targetKey] = { [Op.like]: `%${val}%` };
+                                result[targetKey] = { [_Op.like]: `%${val}%` };
                             }
                             break;
                         case "startsWith":
-                            result[targetKey] = { [Op.startsWith]: val };
+                            result[targetKey] = { [_Op.startsWith]: val };
                             break;
                         case "endsWith":
-                            result[targetKey] = { [Op.endsWith]: val };
+                            result[targetKey] = { [_Op.endsWith]: val };
                             break;
                         case ">":
-                            result[targetKey] = { [Op.gt]: val };
+                            result[targetKey] = { [_Op.gt]: val };
                             break;
                         case ">=":
-                            result[targetKey] = { [Op.gte]: val };
+                            result[targetKey] = { [_Op.gte]: val };
                             break;
                         case "<":
-                            result[targetKey] = { [Op.lt]: val };
+                            result[targetKey] = { [_Op.lt]: val };
                             break;
                         case "<=":
-                            result[targetKey] = { [Op.lte]: val };
+                            result[targetKey] = { [_Op.lte]: val };
                             break;
                         case "!=":
-                            result[targetKey] = { [Op.ne]: val };
+                            result[targetKey] = { [_Op.ne]: val };
                             break;
                         case "in":
-                            result[targetKey] = { [Op.in]: val };
+                            result[targetKey] = { [_Op.in]: val };
                             break;
                         case "notIn":
-                            result[targetKey] = { [Op.notIn]: val };
+                            result[targetKey] = { [_Op.notIn]: val };
                             break;
                         case "nin":
-                            result[targetKey] = { [Op.notIn]: val };
+                            result[targetKey] = { [_Op.notIn]: val };
                             break;
                         case "between":
-                            result[targetKey] = { [Op.between]: val };
+                            result[targetKey] = { [_Op.between]: val };
                             break;
+                        case "intersects":
+                            // Emitted only by the (unsupported) collection form of
+                            // `userAccessRelation` — fail loudly instead of the default
+                            // Op.eq fallback silently producing a wrong query.
+                            throw new Error(`Sequelize adapter does not support the "intersects" operator (field "${String(targetKey)}")`);
                         case "isNull":
                             if (val) {
-                                result[targetKey] = { [Op.is]: null };
+                                result[targetKey] = { [_Op.is]: null };
                             }
                             break;
                         case "isNotNull":
                             if (val) {
-                                result[targetKey] = { [Op.not]: null };
+                                result[targetKey] = { [_Op.not]: null };
                             }
                             break;
                         case "regex":
-                            result[targetKey] = { [Op.regexp]: val };
+                            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] ?? []),
+                            result[_Op.and] = [
+                                ...(result[_Op.and] ?? []),
                                 ...clauses
                             ];
                             break;
                         }
                         case "$is":
-                            result[targetKey] = { [Op.is]: val };
+                            result[targetKey] = { [_Op.is]: val };
                             break;
                         case "$not":
-                            result[targetKey] = { [Op.not]: val };
+                            result[targetKey] = { [_Op.not]: val };
                             break;
                         case "$ne":
-                            result[targetKey] = { [Op.ne]: val };
+                            result[targetKey] = { [_Op.ne]: val };
                             break;
                         case "not":
-                            result[targetKey] = { [Op.not]: val };
+                            result[targetKey] = { [_Op.not]: val };
                             break;
                         default:
-                            result[targetKey] = { [Op.eq]: val };
+                            result[targetKey] = { [_Op.eq]: val };
                     }
                 }
             }
@@ -355,7 +475,7 @@ export class SequelizeModel extends AbstractModel {
         // '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;
+        const { where: nestedWhere, skip, limit, sort: criteriaSort, select, populate, populateOn: _populateOn, ...rest } = criteria;
         // If 'sort' is a model field (not an ordering string), put it back
         if (!isOrderingSort && criteriaSortValue !== undefined) {
             rest.sort = criteriaSortValue;
@@ -421,6 +541,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- CREATE ---
     async _create(data) {
+        await this._ensure();
         // console.clear()
         const assocNames = Object.keys(this.model.associations);
         const plainData = {};
@@ -492,16 +613,19 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- FIND ONE ---
     async _findOne(criteria) {
+        await this._ensure();
         // console.debug(">> _findOne: input criteria:", criteria);
         const { where, attributes } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
         const includes = criteria.populate
             ? this._buildCriteriaIncludes(criteria.populate)
             : this._buildIncludes();
+        this._applyPopulateOn(includes, criteria.populateOn);
+        const selectedAttributes = this._ensureForeignKeysSelected(attributes, criteria.populateOn);
         // console.debug(">> _findOne: converted where:", where);
         // console.debug(">> _findOne: includes:", includes);
         let instance = null;
         try {
-            instance = await this.model.findOne({ where, attributes, include: includes });
+            instance = await this.model.findOne({ where, attributes: selectedAttributes, include: includes });
             // console.debug(">> _findOne: raw instance:", instance ? instance.toJSON() : null);
         }
         catch (err) {
@@ -513,11 +637,13 @@ export class SequelizeModel extends AbstractModel {
             return null;
         }
         const plain = instance.get({ plain: true });
+        this._collapsePopulateOn([plain], criteria.populateOn);
         // console.debug(">> _findOne: plain result:", plain);
         return plain;
     }
     // --- FIND MANY ---
     async _find(criteria = {}) {
+        await this._ensure();
         const assocNames = Object.keys(this.model.associations);
         // console.debug(">> _find: input criteria:", criteria, "options:", options);
         const { where, limit, offset, order, attributes } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
@@ -528,6 +654,8 @@ export class SequelizeModel extends AbstractModel {
         const includes = criteria.populate
             ? this._buildCriteriaIncludes(criteria.populate)
             : assocNames.map((alias) => this._buildListInclude(alias, usedRelationAliases, hasRelationPathCondition));
+        this._applyPopulateOn(includes, criteria.populateOn);
+        const selectedAttributes = this._ensureForeignKeysSelected(attributes, criteria.populateOn);
         // console.debug(">> _find: where, limit, offset, order, includes:", {
         //   where,
         //   limit,
@@ -538,33 +666,18 @@ export class SequelizeModel extends AbstractModel {
         let instances;
         instances = await this.model.findAll({
             where,
-            attributes,
+            attributes: selectedAttributes,
             limit,
             offset,
             order,
             include: includes,
             subQuery: hasRelationPathCondition ? false : undefined
         });
-        for (const inst of instances) {
-            //For each association, we call getxxx () once again
-            for (const alias of assocNames) {
-                // @ts-ignore accessors is present
-                const getAccessor = this.model.associations[alias].accessors.get;
-                if (typeof inst[getAccessor] === "function") {
-                    try {
-                        const related = await inst[getAccessor]();
-                        const mapped = Array.isArray(related)
-                            ? related.map((r) => r.toJSON())
-                            : related?.toJSON();
-                        // console.debug(`---- get${alias}():`, mapped);
-                    }
-                    catch (e) {
-                        // console.error(`!! error when calling ${getAccessor}():`, e);
-                    }
-                }
-            }
-        }
+        // Associations come from the `include` above: sequelize getters never write into
+        // dataValues, so calling them here would only cost one query per association per
+        // row and change nothing in the result.
         const plain = instances.map(i => i.get({ plain: true }));
+        this._collapsePopulateOn(plain, criteria.populateOn);
         // console.debug(">> _find: plain results:", plain);
         return plain;
     }
@@ -573,6 +686,7 @@ export class SequelizeModel extends AbstractModel {
      * Bypasses Adminizer criteria conversion for direct Sequelize usage
      */
     async findWithRawWhere(where, options = {}) {
+        await this._ensure();
         const assocNames = Object.keys(this.model.associations);
         const includes = options.populate !== false
             ? assocNames.map(a => ({ association: a }))
@@ -590,6 +704,7 @@ export class SequelizeModel extends AbstractModel {
      * Public method for count with raw SQL where clauses
      */
     async countWithRawWhere(where) {
+        await this._ensure();
         const assocNames = Object.keys(this.model.associations);
         const include = assocNames.map((association) => ({ association }));
         return await this.model.count({
@@ -601,6 +716,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- UPDATE ONE ---
     async _updateOne(criteria, data) {
+        await this._ensure();
         const { where } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
         const record = await this.model.findOne({ where });
         if (!record)
@@ -632,6 +748,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- UPDATE MANY ---
     async _update(criteria, data) {
+        await this._ensure();
         const { where } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
         const assocNames = Object.keys(this.model.associations);
         const plainData = {};
@@ -664,74 +781,68 @@ export class SequelizeModel extends AbstractModel {
         });
         return reloaded.map((r) => r.get({ plain: true }));
     }
+    /**
+     * Application-level cascade for the records `ids` identifies, one statement per
+     * association instead of a getter plus a delete per related row:
+     *
+     * - `belongsTo` — the parent is never touched; deleting a task must not delete its project;
+     * - `belongsToMany` — only the link rows go, never the far side: those rows are shared
+     *   (deleting one post must not delete a tag another post still uses);
+     * - `hasOne` / `hasMany` — the children are deleted, which is the actual cascade.
+     *
+     * Row-level destroy hooks are preserved for targets that declare them.
+     */
+    async _cascadeDelete(ids) {
+        if (!ids.length) {
+            return;
+        }
+        for (const alias of Object.keys(this.model.associations)) {
+            const assoc = this.model.associations[alias];
+            if (assoc.associationType === "BelongsTo") {
+                continue;
+            }
+            const foreignKey = typeof assoc.foreignKey === "string" ? assoc.foreignKey : undefined;
+            if (!foreignKey) {
+                continue;
+            }
+            // Many-to-many: the link rows live in the through model, the targets are shared
+            const target = assoc.associationType === "BelongsToMany"
+                ? assoc.through?.model
+                : assoc.target;
+            if (!target?.destroy) {
+                continue;
+            }
+            try {
+                const hasRowHooks = typeof target.hasHook === "function"
+                    && (target.hasHook("beforeDestroy") || target.hasHook("afterDestroy"));
+                await target.destroy({
+                    where: { [foreignKey]: { [_Op.in]: ids } },
+                    individualHooks: hasRowHooks,
+                });
+            }
+            catch (e) {
+                Adminizer.log.error(`Failed to cascade the deletion of "${this.modelname}.${alias}"`, e);
+            }
+        }
+    }
     // --- DESTROY ONE ---
     async _destroyOne(criteria) {
+        await this._ensure();
         const { where } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
         const record = await this.model.findOne({ where });
         if (!record)
             return null;
-        const assocNames = Object.keys(this.model.associations);
-        for (const alias of assocNames) {
-            const assoc = this.model.associations[alias];
-            // @ts-ignore: accessors should exist
-            const getAccessor = assoc.accessors?.get;
-            if (typeof record[getAccessor] === "function") {
-                try {
-                    const related = await record[getAccessor]();
-                    // 🧹Deleting related posts
-                    if (Array.isArray(related)) {
-                        for (const r of related) {
-                            if (typeof r.destroy === "function") {
-                                await r.destroy();
-                            }
-                        }
-                    }
-                    else if (related && typeof related.destroy === "function") {
-                        await related.destroy();
-                    }
-                }
-                catch (e) {
-                    // console.warn(`Failed to fetch/delete relation "${alias}":`, e);
-                }
-            }
-        }
+        await this._cascadeDelete([record.get(this.model.primaryKeyAttribute)]);
         const raw = record.get({ plain: true });
         await record.destroy();
         return raw;
     }
     // --- DESTROY MANY ---
     async _destroy(criteria) {
+        await this._ensure();
         const { where } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
         const records = await this.model.findAll({ where });
-        const assocNames = Object.keys(this.model.associations);
-        for (const record of records) {
-            for (const alias of assocNames) {
-                const assoc = this.model.associations[alias];
-                // 🛑 We don’t touch parental ties
-                if (assoc.associationType === "BelongsTo")
-                    continue;
-                // @ts-ignore accessor exists
-                const getAccessor = assoc.accessors?.get;
-                if (typeof record[getAccessor] === "function") {
-                    try {
-                        const related = await record[getAccessor]();
-                        if (Array.isArray(related)) {
-                            for (const rel of related) {
-                                if (typeof rel.destroy === "function") {
-                                    await rel.destroy();
-                                }
-                            }
-                        }
-                        else if (related && typeof related.destroy === "function") {
-                            await related.destroy();
-                        }
-                    }
-                    catch (e) {
-                        // console.warn(`Failed to delete relation ${alias}:`, e);
-                    }
-                }
-            }
-        }
+        await this._cascadeDelete(records.map((r) => r.get(this.model.primaryKeyAttribute)));
         const raw = records.map((r) => r.get({ plain: true }));
         await this.model.destroy({ where });
         return raw;
@@ -805,7 +916,7 @@ export class SequelizeModel extends AbstractModel {
         }
         const association = this.model.associations[alias];
         const isUsedInWhere = usedRelationAliases.has(alias);
-        const isHasMany = association instanceof HasMany || association?.associationType === 'HasMany';
+        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) {
@@ -816,6 +927,70 @@ export class SequelizeModel extends AbstractModel {
     _buildIncludes() {
         return Object.keys(this.model.associations).map(key => ({ association: key }));
     }
+    /**
+     * `criteria.populateOn` support: BelongsTo only — the owning row keeps its FK
+     * column, so a record filtered out of the JOIN can be handed back as that bare value.
+     */
+    canPushdownPopulateAccess(association) {
+        const assoc = this.model.associations[association];
+        return Boolean(assoc
+            && assoc.associationType === "BelongsTo"
+            && typeof assoc.foreignKey === "string"
+            && this.model.rawAttributes[assoc.foreignKey]);
+    }
+    /** ANDs `criteria.populateOn` into the matching includes' ON clause (LEFT JOIN — owning rows stay). */
+    _applyPopulateOn(includes, populateOn) {
+        if (!populateOn) {
+            return;
+        }
+        for (const [association, on] of Object.entries(populateOn)) {
+            const include = includes.find((entry) => entry.association === association);
+            if (!include) {
+                continue;
+            }
+            const condition = this._convertCriteriaToSequelize(on);
+            if (include.where) {
+                // An explicit populate-where keeps filtering the owning rows (INNER JOIN),
+                // now matching only records inside the access confinement.
+                include.where = { [_Op.and]: [include.where, condition] };
+            }
+            else {
+                include.where = condition;
+                include.required = false;
+            }
+        }
+    }
+    /** A record filtered out of a `populateOn` JOIN comes back as its bare foreign key. */
+    _collapsePopulateOn(records, populateOn) {
+        if (!populateOn) {
+            return;
+        }
+        for (const association of Object.keys(populateOn)) {
+            const foreignKey = this.model.associations[association]?.foreignKey;
+            if (typeof foreignKey !== "string") {
+                continue;
+            }
+            for (const record of records) {
+                if (record[association] == null && record[foreignKey] != null) {
+                    record[association] = record[foreignKey];
+                }
+            }
+        }
+    }
+    /** The collapse above reads the FK columns — keep them selected under an explicit `select`. */
+    _ensureForeignKeysSelected(attributes, populateOn) {
+        if (!attributes || !populateOn) {
+            return attributes;
+        }
+        const result = [...attributes];
+        for (const association of Object.keys(populateOn)) {
+            const foreignKey = this.model.associations[association]?.foreignKey;
+            if (typeof foreignKey === "string" && !result.includes(foreignKey)) {
+                result.push(foreignKey);
+            }
+        }
+        return result;
+    }
     _buildAttributes(select, rawAttributes = this.model.rawAttributes) {
         if (!select) {
             return undefined;
@@ -861,10 +1036,14 @@ export class SequelizeAdapter extends AbstractAdapter {
     sequelize;
     Model = SequelizeModel;
     constructor(sequelize, options = {}) {
+        ensureSequelize();
         super("sequelize", sequelize, options);
+        // Note: ensureSequelize is fire-and-forget during construction
+        // Methods also call this._ensure() to guarantee initialization
         this.sequelize = sequelize;
     }
     get models() {
+        ``;
         return this.sequelize.models;
     }
     getModel(modelName) {