adminizer 5.0.0-build.9 → 5.1.0-build.25

package/lib/model/adapter/sequelize.js

@@ -1,4 +1,5 @@
 import { AbstractAdapter, AbstractModel } from "../AbstractModel.js";
+import { Adminizer } from "../../Adminizer.js";
 let _Sequelize = null;
 let _Op = null;
 let _HasMany = null;
@@ -116,6 +117,113 @@ export class SequelizeModel extends AbstractModel {
         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];
@@ -220,8 +328,15 @@ 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 };
@@ -303,6 +418,11 @@ export class SequelizeModel extends AbstractModel {
                         case "between":
                             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 };
@@ -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;
@@ -499,11 +619,13 @@ export class SequelizeModel extends AbstractModel {
         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) {
@@ -515,6 +637,7 @@ 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;
     }
@@ -531,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,
@@ -541,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;
     }
@@ -671,6 +781,50 @@ 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();
@@ -678,31 +832,7 @@ export class SequelizeModel extends AbstractModel {
         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;
@@ -712,35 +842,7 @@ export class SequelizeModel extends AbstractModel {
         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;
@@ -825,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;

package/lib/model/adapter/typeorm.d.ts

@@ -28,6 +28,22 @@ export declare class TypeOrmModel<T extends ObjectLiteral> extends AbstractModel
     private normalizeCriteria;
     private addRequestedRelations;
     private addAllRelationJoins;
+    /**
+     * `criteria.populateOn` support: many-to-one with its FK declared as a real column
+     * property — the hydrated entity then carries the value the filtered association
+     * collapses to. (An undeclared FK leaves `joinColumns[0].propertyName` equal to the
+     * relation's own property name.)
+     */
+    canPushdownPopulateAccess(association: string): boolean;
+    /**
+     * Renders a `populateOn` entry into the JOIN's ON clause. Only the shapes the
+     * record-access layer marks pushdown-safe (primitive equality, `{in: [...]}`) are
+     * supported; anything else fails closed to a never-matching condition — the
+     * association then collapses to its foreign key rather than leaking.
+     */
+    private buildJoinCondition;
+    /** A record filtered out of a `populateOn` JOIN comes back as its bare foreign key. */
+    private collapsePopulateOn;
     private isNativeWhere;
     private applyFindOptions;
     private applyWhere;

package/lib/model/adapter/typeorm.js

@@ -1,7 +1,11 @@
 import { Brackets, EntitySchema, NotBrackets, } from "typeorm";
 import { v4 as uuid } from "uuid";
 import { AbstractAdapter, AbstractModel } from "../AbstractModel.js";
+import { Adminizer } from "../../Adminizer.js";
 const ROOT_ALIAS = "record";
+/** Always-false / always-true predicates: an empty IN-list must not depend on driver quirks. */
+const MATCH_NOTHING = "1 = 0";
+const MATCH_EVERYTHING = "1 = 1";
 function normalizeModelName(modelName) {
     return modelName.toLowerCase();
 }
@@ -295,7 +299,7 @@ export class TypeOrmModel extends AbstractModel {
     normalizeCriteria(criteria = {}) {
         const criteriaSortValue = "sort" in criteria ? criteria.sort : undefined;
         const isOrderingSort = typeof criteriaSortValue === "string";
-        const { where: nestedWhere, skip, limit, sort, select, populate, ...rest } = criteria;
+        const { where: nestedWhere, skip, limit, sort, select, populate, populateOn: _populateOn, ...rest } = criteria;
         if (!isOrderingSort && criteriaSortValue !== undefined) {
             rest.sort = criteriaSortValue;
         }
@@ -308,7 +312,7 @@ export class TypeOrmModel extends AbstractModel {
             select: this.buildAttributes(select),
         };
     }
-    addRequestedRelations(qb, populate) {
+    addRequestedRelations(qb, populate, populateOn) {
         const aliases = new Map();
         const relations = populate ? Object.keys(populate) : this.relationNames;
         for (const relationName of relations) {
@@ -316,7 +320,15 @@ export class TypeOrmModel extends AbstractModel {
                 continue;
             }
             const alias = `${ROOT_ALIAS}_${relationName}`;
-            qb.leftJoinAndSelect(`${ROOT_ALIAS}.${relationName}`, alias);
+            const joinCondition = populateOn?.[relationName]
+                ? this.buildJoinCondition(populateOn[relationName], alias)
+                : undefined;
+            if (joinCondition) {
+                qb.leftJoinAndSelect(`${ROOT_ALIAS}.${relationName}`, alias, joinCondition.sql, joinCondition.params);
+            }
+            else {
+                qb.leftJoinAndSelect(`${ROOT_ALIAS}.${relationName}`, alias);
+            }
             aliases.set(relationName, alias);
         }
         if (populate) {
@@ -353,17 +365,93 @@ export class TypeOrmModel extends AbstractModel {
         }
         return aliases;
     }
+    /**
+     * `criteria.populateOn` support: many-to-one with its FK declared as a real column
+     * property — the hydrated entity then carries the value the filtered association
+     * collapses to. (An undeclared FK leaves `joinColumns[0].propertyName` equal to the
+     * relation's own property name.)
+     */
+    canPushdownPopulateAccess(association) {
+        const relation = this.getRelation(association);
+        const joinColumn = relation?.joinColumns[0];
+        return Boolean(relation?.isManyToOne
+            && joinColumn?.propertyName
+            && joinColumn.propertyName !== relation.propertyName
+            && this.metadata.columns.some((column) => column.propertyName === joinColumn.propertyName));
+    }
+    /**
+     * Renders a `populateOn` entry into the JOIN's ON clause. Only the shapes the
+     * record-access layer marks pushdown-safe (primitive equality, `{in: [...]}`) are
+     * supported; anything else fails closed to a never-matching condition — the
+     * association then collapses to its foreign key rather than leaking.
+     */
+    buildJoinCondition(on, alias) {
+        const expressions = [];
+        const params = {};
+        for (const [field, value] of Object.entries(on)) {
+            if (value === null) {
+                expressions.push(`${alias}.${field} IS NULL`);
+                continue;
+            }
+            if (["string", "number", "boolean"].includes(typeof value)) {
+                const param = this.nextParamName();
+                expressions.push(`${alias}.${field} = :${param}`);
+                params[param] = value;
+                continue;
+            }
+            const inList = value && typeof value === "object" && Object.keys(value).length === 1
+                ? value.in
+                : undefined;
+            if (Array.isArray(inList)) {
+                if (!inList.length) {
+                    expressions.push(MATCH_NOTHING);
+                    continue;
+                }
+                const param = this.nextParamName();
+                expressions.push(`${alias}.${field} IN (:...${param})`);
+                params[param] = inList;
+                continue;
+            }
+            expressions.push(MATCH_NOTHING);
+        }
+        return { sql: expressions.join(" AND ") || MATCH_NOTHING, params };
+    }
+    /** A record filtered out of a `populateOn` JOIN comes back as its bare foreign key. */
+    collapsePopulateOn(entities, populateOn) {
+        if (!populateOn) {
+            return;
+        }
+        for (const association of Object.keys(populateOn)) {
+            const fkProperty = this.getRelation(association)?.joinColumns[0]?.propertyName;
+            if (!fkProperty || fkProperty === association) {
+                continue;
+            }
+            for (const entity of entities) {
+                if (entity[association] == null && entity[fkProperty] != null) {
+                    entity[association] = entity[fkProperty];
+                }
+            }
+        }
+    }
     isNativeWhere(where) {
         return where instanceof Brackets || where instanceof NotBrackets;
     }
     applyFindOptions(qb, criteria) {
         const options = this.normalizeCriteria(criteria);
-        const aliases = this.addRequestedRelations(qb, criteria.populate);
+        const aliases = this.addRequestedRelations(qb, criteria.populate, criteria.populateOn);
         if (this.isNativeWhere(options.where) || Object.keys(options.where).length > 0) {
             this.applyWhere(qb, options.where, ROOT_ALIAS, aliases);
         }
         if (options.select) {
-            qb.select(options.select.map((field) => `${ROOT_ALIAS}.${field}`));
+            // The populateOn collapse reads the FK properties — keep them selected.
+            const selected = [...options.select];
+            for (const association of Object.keys(criteria.populateOn ?? {})) {
+                const fkProperty = this.getRelation(association)?.joinColumns[0]?.propertyName;
+                if (fkProperty && fkProperty !== association && !selected.includes(fkProperty)) {
+                    selected.push(fkProperty);
+                }
+            }
+            qb.select(selected.map((field) => `${ROOT_ALIAS}.${field}`));
         }
         for (const [field, direction] of options.order) {
             const orderColumn = this.getOrderColumn(ROOT_ALIAS, field);
@@ -389,7 +477,16 @@ export class TypeOrmModel extends AbstractModel {
         }
     }
     buildWhereBrackets(where, alias, relationAliases) {
-        const entries = Object.entries(where).filter(([, value]) => value !== undefined);
+        const entries = Object.entries(where).filter(([key, value]) => {
+            if (value === undefined) {
+                // Historical behaviour: an undefined value drops the condition. Record-access
+                // filters never emit one, so this only fires for hand-built criteria — but a
+                // dropped condition widens the query, so it must not stay silent.
+                Adminizer.log.warn(`TypeORM adapter: criteria field "${key}" has an undefined value and was dropped`);
+                return false;
+            }
+            return true;
+        });
         if (!entries.length) {
             return undefined;
         }
@@ -467,6 +564,9 @@ export class TypeOrmModel extends AbstractModel {
             return { sql: `${column} IS NULL` };
         }
         if (Array.isArray(value)) {
+            if (!value.length) {
+                return { sql: MATCH_NOTHING };
+            }
             const param = this.nextParamName();
             return { sql: `${column} IN (:...${param})`, params: { [param]: value } };
         }
@@ -474,8 +574,15 @@ export class TypeOrmModel extends AbstractModel {
             const expressions = [];
             const params = {};
             for (const [operator, raw] of Object.entries(value)) {
-                if (raw === undefined)
+                if (raw === undefined || raw === 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 (operator === "in" || operator === "$in") {
+                        expressions.push(MATCH_NOTHING);
+                    }
                     continue;
+                }
                 const built = this.buildOperatorCondition(column, operator, raw);
                 if (!built)
                     continue;
@@ -528,10 +635,18 @@ export class TypeOrmModel extends AbstractModel {
                 return { sql: `CAST(${column} AS TEXT) LIKE :${param}`, params: { [param]: `%${value}` } };
             case "in":
             case "$in":
+                // An empty list matches nothing on every driver; the spread placeholder
+                // would depend on TypeORM's empty-array handling.
+                if (Array.isArray(value) && !value.length) {
+                    return { sql: MATCH_NOTHING };
+                }
                 return { sql: `${column} IN (:...${param})`, params };
             case "notIn":
             case "nin":
             case "$notIn":
+                if (Array.isArray(value) && !value.length) {
+                    return { sql: MATCH_EVERYTHING };
+                }
                 return { sql: `${column} NOT IN (:...${param})`, params };
             case "between":
             case "$between": {
@@ -551,7 +666,13 @@ export class TypeOrmModel extends AbstractModel {
                 const serialized = JSON.stringify(value).replace(/[%_]/g, "\\$&");
                 return { sql: `CAST(${column} AS TEXT) LIKE :${param}`, params: { [param]: `%${serialized}%` } };
             }
+            case "intersects":
+                // Emitted only by the (unsupported) collection form of
+                // `userAccessRelation` — fail loudly instead of silently dropping the
+                // condition, which would widen the query (sequelize adapter parity).
+                throw new Error(`TypeORM adapter does not support the "intersects" operator (column "${column}")`);
             default:
+                Adminizer.log.warn(`TypeORM adapter: unsupported criteria operator "${operator}" was dropped for column "${column}"`);
                 return undefined;
         }
     }
@@ -660,12 +781,18 @@ export class TypeOrmModel extends AbstractModel {
     async _findOne(criteria = {}) {
         const qb = this.createQueryBuilder();
         this.applyFindOptions(qb, criteria);
-        return await qb.getOne();
+        const record = await qb.getOne();
+        if (record) {
+            this.collapsePopulateOn([record], criteria.populateOn);
+        }
+        return record;
     }
     async _find(criteria = {}) {
         const qb = this.createQueryBuilder();
         this.applyFindOptions(qb, criteria);
-        return await qb.getMany();
+        const records = await qb.getMany();
+        this.collapsePopulateOn(records, criteria.populateOn);
+        return records;
     }
     async _updateOne(criteria, data) {
         const record = await this._findOne(criteria);