adminizer 4.6.0 → 4.7.0-build.221

package/interfaces/listQueryBuilder.d.ts

@@ -0,0 +1,22 @@
+import { FilterCondition } from "../models/FilterAP";
+/**
+ * Input format for list/feed/export query builder.
+ * This is not the internal model query language.
+ */
+export interface ListQueryBuilderParams {
+    page: number;
+    limit: number;
+    sort?: string;
+    sortDirection?: "ASC" | "DESC";
+    filters?: FilterCondition[];
+    globalSearch?: string;
+    fields?: string[];
+}
+export interface ListQueryBuilderResult<T = any> {
+    data: T[];
+    total: number;
+    filtered: number;
+    page: number;
+    limit: number;
+    pages: number;
+}

package/interfaces/listQueryBuilder.js

@@ -0,0 +1 @@
+export {};

package/interfaces/queryCriteria.d.ts

@@ -0,0 +1,54 @@
+export type CriteriaPrimitive = string | number | boolean | Date | null;
+export type CriteriaSortDirection = "ASC" | "DESC" | "asc" | "desc";
+export type CriteriaSelect = string[] | Record<string, boolean>;
+export type CriteriaSort = string | Record<string, CriteriaSortDirection>;
+export interface CriteriaOperatorValue<TValue = unknown> {
+    eq?: TValue;
+    ne?: TValue;
+    gt?: TValue;
+    gte?: TValue;
+    lt?: TValue;
+    lte?: TValue;
+    contains?: TValue;
+    startsWith?: TValue;
+    endsWith?: TValue;
+    in?: TValue[];
+    notIn?: TValue[];
+    between?: [TValue, TValue];
+    isNull?: boolean;
+    isNotNull?: boolean;
+    regex?: unknown;
+    arrayContains?: unknown;
+    arrayOverlap?: unknown[];
+    jsonContains?: unknown;
+}
+export type CriteriaFieldInput<TValue = unknown> = TValue extends Array<infer Item> ? Item | Item[] | TValue : TValue;
+export type CriteriaFieldValue<TValue = unknown> = null | CriteriaFieldInput<TValue> | CriteriaOperatorValue<CriteriaFieldInput<TValue>>;
+export type CriteriaKnownFields<TModel = any> = {
+    [Field in Extract<keyof TModel, string>]?: CriteriaFieldValue<TModel[Field]>;
+};
+export interface CriteriaWhereLogic<TModel = any> {
+    and?: CriteriaWhere<TModel>[];
+    or?: CriteriaWhere<TModel>[];
+    not?: CriteriaWhere<TModel>;
+}
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type CriteriaWhere<TModel = any> = IsAny<TModel> extends true ? CriteriaWhereLogic<TModel> & {
+    [field: string]: unknown;
+} : CriteriaWhereLogic<TModel> & CriteriaKnownFields<TModel>;
+type PopulatableElement<T> = NonNullable<T> extends Array<infer Item> ? Item : NonNullable<T>;
+type PopulatableKeys<TModel> = {
+    [K in keyof TModel]-?: NonNullable<TModel[K]> extends string | number | boolean | Date ? never : K;
+}[keyof TModel];
+export type CriteriaPopulate<TModel = any> = IsAny<TModel> extends true ? Record<string, true | QueryCriteria<any>> : {
+    [K in Extract<PopulatableKeys<TModel>, string>]?: true | QueryCriteria<PopulatableElement<TModel[K]>>;
+};
+export interface QueryCriteria<TModel = any> {
+    where?: CriteriaWhere<TModel>;
+    select?: CriteriaSelect;
+    populate?: CriteriaPopulate<TModel>;
+    sort?: CriteriaSort;
+    limit?: number;
+    skip?: number;
+}
+export {};

package/interfaces/queryCriteria.js

@@ -0,0 +1 @@
+export {};

package/interfaces/types.d.ts

@@ -1,12 +1,10 @@
 import { AbstractModel } from "../lib/model/AbstractModel";
 import { ModelConfig } from "./adminpanelConfig";
-export type EntityType = "form" | "model";
-export interface Entity {
+export interface ModelResource {
     name: string;
     config?: ModelConfig;
     model?: AbstractModel<any>;
     uri: string;
-    type: EntityType;
 }
 export interface AccessRightsToken {
     name: string;
@@ -72,13 +70,3 @@ export interface AiAssistantModelInfo {
     name: string;
     description?: string;
 }
-export type Migration = {
-    name: string;
-    timestamp: number;
-    up: (args: {
-        context: any;
-    }) => Promise<unknown> | unknown;
-    down: (args: {
-        context: any;
-    }) => Promise<unknown> | unknown;
-};

package/lib/Adminizer.d.ts

@@ -2,7 +2,7 @@ import express, { Express } from "express";
 import winston from "winston";
 import EventEmitter from 'events';
 import { AdminpanelConfig } from "../interfaces/adminpanelConfig";
-import PolicyManager from "./PolicyManager";
+import MiddlewareManager from "./MiddlewareManager";
 import Router from "./../system/Router";
 import { ModelHandler } from "./model/ModelHandler";
 import { WidgetHandler } from "./widgets/widgetHandler";
@@ -20,6 +20,7 @@ import { INotification } from "../interfaces/types";
 import { MediaManagerHandler } from "./media-manager/MediaManagerHandler";
 import { StorageServices } from "./catalog/Navigation";
 import { HistoryHandler } from "./history-actions/HistoryHandler";
+import { CustomFilterHandler } from "./filters/CustomFilterHandler";
 import { FeedbackHandler } from "./feedback/FeedbackHandler";
 export declare class Adminizer {
     /**
@@ -31,7 +32,7 @@ export declare class Adminizer {
     config: AdminpanelConfig;
     private readonly _emitter;
     ormAdapters: AbstractAdapter[];
-    policyManager: PolicyManager;
+    middlewareManager: MiddlewareManager;
     accessRightsHelper: AccessRightsHelper;
     configHelper: ConfigHelper;
     menuHelper: MenuHelper;
@@ -41,6 +42,7 @@ export declare class Adminizer {
     aiAssistantHandler?: AiAssistantHandler;
     modelHandler: ModelHandler;
     widgetHandler: WidgetHandler;
+    customFilterHandler: CustomFilterHandler;
     vite: ViteDevServer;
     controlsHandler: ControlsHandler;
     catalogHandler: CatalogHandler;

package/lib/Adminizer.js

@@ -2,8 +2,9 @@ import express from "express";
 import cookieParser from 'cookie-parser';
 import * as path from "path";
 import winston from "winston";
+import chalk from "chalk";
 import EventEmitter from 'events';
-import PolicyManager from "./PolicyManager.js";
+import MiddlewareManager from "./MiddlewareManager.js";
 import Router from "./../system/Router.js";
 import bindAssets from "../system/bindAssets.js";
 import bindDev from "../system/bindDev.js";
@@ -13,7 +14,6 @@ import bindMediaManager from "../system/bindMediaManager.js";
 import bindAccessRights from "../system/bindAccessRights.js";
 import bindAuthorization from "../system/bindAuthorization.js";
 import bindModels from "../system/bindModels.js";
-import bindForms from "../system/bindForms.js";
 import bindTranslations from "../system/bindTranslations.js";
 import { ModelHandler } from "./model/ModelHandler.js";
 import { WidgetHandler } from "./widgets/widgetHandler.js";
@@ -34,8 +34,9 @@ import { bindAiAssistant } from "../system/bindAiAssistant.js";
 import { MediaManagerHandler } from "./media-manager/MediaManagerHandler.js";
 import { bindCors } from "../system/bindCors.js";
 import bindHistory from "../system/bindHistory.js";
-import { isAdminizerViteDevMode } from "../helpers/runtimeMode.js";
+import bindCustomFilterHandlers from "../system/bindCustomFilterHandlers.js";
 import { FeedbackHandler } from "./feedback/FeedbackHandler.js";
+import { buildInternalModelAccess } from "../system/buildInternalModelAccess.js";
 export class Adminizer {
     // Preconfigures
     /**
@@ -48,7 +49,7 @@ export class Adminizer {
     config;
     _emitter;
     ormAdapters;
-    policyManager;
+    middlewareManager;
     accessRightsHelper;
     configHelper;
     menuHelper;
@@ -58,6 +59,7 @@ export class Adminizer {
     aiAssistantHandler;
     modelHandler;
     widgetHandler;
+    customFilterHandler;
     vite;
     controlsHandler;
     catalogHandler;
@@ -73,7 +75,23 @@ export class Adminizer {
             return `[${timestamp}] ${level.toUpperCase()}: ${message} ${metaString}`;
         })),
         transports: [
-            new winston.transports.Console(),
+            new winston.transports.Console({
+                format: winston.format.combine(winston.format.timestamp(), winston.format.printf(({ timestamp, level, message, ...meta }) => {
+                    const metaString = Object.keys(meta).length ? JSON.stringify(meta) : "";
+                    const colors = {
+                        error: chalk.red,
+                        warn: chalk.yellow,
+                        info: chalk.green,
+                        http: chalk.magenta,
+                        verbose: chalk.cyan,
+                        debug: chalk.blue,
+                        silly: chalk.gray,
+                    };
+                    const colorize = colors[level] ?? chalk.white;
+                    const line = `[${timestamp}] ${level.toUpperCase()}: ${message} ${metaString}`;
+                    return colorize(line);
+                }))
+            }),
             new winston.transports.File({ filename: "logs/app.log" }),
         ],
     });
@@ -170,17 +188,18 @@ export class Adminizer {
         // set cookie parser
         this.app.use(cookieParser());
         // Set vite middleware
-        const isViteDev = isAdminizerViteDevMode();
+        const isViteDev = process.env.ADMINIZER_ENV === "dev";
         if (isViteDev)
             await this.viteMiddleware();
         this.emitter.emit('adminizer:init');
         this.modelHandler = new ModelHandler();
-        // TODO: 'hot reload' unbind models & unbind forms
+        // TODO: 'hot reload' unbind models
         await bindModels(this);
-        await bindForms(this);
+        this.modelHandler.configureInternalAccess(buildInternalModelAccess(this.config, this.modelHandler));
+        bindCustomFilterHandlers(this);
         this.config.rootPath = path.resolve(import.meta.dirname + "/..");
-        this.policyManager = new PolicyManager(this);
-        await this.policyManager.loadPolicies();
+        this.middlewareManager = new MiddlewareManager(this);
+        await this.middlewareManager.loadMiddlewares();
         // TODO: 'hot reload' problem with deleting access right tokens
         this.accessRightsHelper = new AccessRightsHelper(this);
         // Helpers go to construtor

package/lib/DataAccessor.d.ts

@@ -1,26 +1,29 @@
 /**
  * The class manages the interaction between the user and the database entry, taking into account user permissions and the main config file settings.
  */
-import { Entity } from "../interfaces/types";
+import { ModelResource } from "../interfaces/types";
 import { ActionType } from "../interfaces/adminpanelConfig";
 import { Fields } from "../helpers/fieldsHelper";
 import { Adminizer } from "./Adminizer";
 import { UserAP } from "../models/UserAP";
+import { QueryCriteria } from "../interfaces/queryCriteria";
 export declare class DataAccessor {
     readonly adminizer: Adminizer;
     user: UserAP;
-    entity: Entity;
+    modelResource: ModelResource;
     action: ActionType;
     private fields;
     private actionVerb;
-    constructor(adminizer: Adminizer, user: UserAP, entity: Entity, action: ActionType);
+    constructor(adminizer: Adminizer, user: UserAP, modelResource: ModelResource, action: ActionType);
     private getModelConfig;
+    private accessRelationModel;
     /**
-     * Retrieves the fields for the given entity based on action type,
+     * Retrieves the fields for the given ModelResource based on action type,
      * taking into account access rights and configuration settings.
      * @returns {Fields} An object with configured fields and their properties.
      */
     getFieldsConfig(): Fields;
+    private orderFieldsByConfig;
     private getAssociatedFieldsConfig;
     private checkFieldAccess;
     /**
@@ -31,6 +34,6 @@ export declare class DataAccessor {
     private filterAssociatedRecord;
     /** Process for an array of records */
     processMany<T>(records: T[]): Partial<T>[];
-    sanitizeUserRelationAccess<T>(criteria: T): Promise<Partial<T>>;
+    sanitizeUserRelationAccess(criteria?: QueryCriteria): Promise<QueryCriteria>;
     setUserRelationAccess<T>(record: T): Promise<Partial<T>>;
 }

package/lib/DataAccessor.js

@@ -1,17 +1,48 @@
 import { ControllerHelper } from "../helpers/controllerHelper.js";
 import { Adminizer } from "./Adminizer.js";
 import { isObject } from "../helpers/JsUtils.js";
+const MODEL_TOKEN_SUFFIX = "model";
+function hasCriteriaContent(criteria) {
+    return Object.keys(criteria).length > 0 || Object.getOwnPropertySymbols(criteria).length > 0;
+}
+function isPlainCriteriaWhere(where) {
+    if (!isObject(where)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(where);
+    return prototype === Object.prototype || prototype === null;
+}
+function mergeCriteriaWhere(criteriaWhere, sanitizedCriteria) {
+    if (!hasCriteriaContent(sanitizedCriteria)) {
+        return criteriaWhere;
+    }
+    if (!criteriaWhere) {
+        return sanitizedCriteria;
+    }
+    if (isPlainCriteriaWhere(criteriaWhere)) {
+        return {
+            ...criteriaWhere,
+            ...sanitizedCriteria
+        };
+    }
+    return {
+        and: [
+            criteriaWhere,
+            sanitizedCriteria
+        ]
+    };
+}
 export class DataAccessor {
     adminizer;
     user;
-    entity;
+    modelResource;
     action;
     fields = null;
     actionVerb;
-    constructor(adminizer, user, entity, action) {
+    constructor(adminizer, user, modelResource, action) {
         this.adminizer = adminizer;
         this.user = user;
-        this.entity = entity;
+        this.modelResource = modelResource;
         this.action = action;
         this.actionVerb = getTokenAction(this.action);
     }
@@ -21,8 +52,11 @@ export class DataAccessor {
         const config = entry ? entry[1] : undefined;
         return isObject(config) ? config : undefined;
     }
+    accessRelationModel(modelName) {
+        return this.adminizer.modelHandler.internal("data-accessor").get(modelName);
+    }
     /**
-     * Retrieves the fields for the given entity based on action type,
+     * Retrieves the fields for the given ModelResource based on action type,
      * taking into account access rights and configuration settings.
      * @returns {Fields} An object with configured fields and their properties.
      */
@@ -30,16 +64,16 @@ export class DataAccessor {
         if (this.fields !== null) {
             return this.fields;
         }
-        if (!this.entity.model || !this.entity.model.attributes) {
+        if (!this.modelResource.model || !this.modelResource.model.attributes) {
             return {};
         }
         // get action and field configs
-        const actionConfig = ControllerHelper.findActionConfig(this.entity, this.action);
-        const fieldsConfig = this.entity.config?.fields || {};
-        const modelAttributes = this.entity.model.attributes;
-        const tokenId = `${this.actionVerb}-${this.entity.model.modelname}-${this.entity.type}`;
+        const actionConfig = ControllerHelper.findActionConfig(this.modelResource, this.action);
+        const fieldsConfig = this.modelResource.config?.fields || {};
+        const modelAttributes = this.modelResource.model.attributes;
+        const tokenId = `${this.actionVerb}-${this.modelResource.model.modelname}-${MODEL_TOKEN_SUFFIX}`;
         if (!this.adminizer.accessRightsHelper.hasPermission(tokenId, this.user)) {
-            Adminizer.log.debug(`getFieldsConfig > No access rights to ${this.actionVerb} ${this.entity.type}: ${this.entity.model.modelname}`);
+            Adminizer.log.debug(`getFieldsConfig > No access rights to ${this.actionVerb} model: ${this.modelResource.model.modelname}`);
             return undefined;
         }
         const result = {};
@@ -48,7 +82,7 @@ export class DataAccessor {
             if (modelAttributes[key].primaryKeyForAssociation === true) {
                 return undefined;
             }
-            // Checks for short type in Waterline: fieldName: 'string'
+            // Supports shorthand model attributes: fieldName: 'string'
             if (typeof modelField === "string") {
                 modelField = { type: modelField };
             }
@@ -82,9 +116,9 @@ export class DataAccessor {
             let populatedModelFieldsConfig = {};
             if (modelField.type === "association" || modelField.type === "association-many") {
                 const modelName = modelField.model || modelField.collection;
-                const tokenId = `read-${modelName}-${this.entity.type}`;
+                const tokenId = `read-${modelName}-${MODEL_TOKEN_SUFFIX}`;
                 if (!this.adminizer.accessRightsHelper.hasPermission(tokenId, this.user)) {
-                    Adminizer.log.silly(`No access rights to ${this.entity.type}: ${this.entity.model.modelname}`);
+                    Adminizer.log.silly(`No access rights to model: ${this.modelResource.model.modelname}`);
                     return undefined;
                 }
                 if (modelName) {
@@ -106,15 +140,31 @@ export class DataAccessor {
             }
             // Set required and type attributes
             fldConfig.required = Boolean(fldConfig.required ?? modelField.required);
-            // Default type for field. Could be fetched form config file or file model if not defined in config file.
+            // Default type for field. Could be fetched from config file or model if not defined in config file.
             fldConfig.type = (fldConfig.type || modelField.type).toLowerCase();
             // Normalize final configuration (fldConfig is always an object here, normalize never returns undefined)
             fldConfig = this.adminizer.configHelper.normalizeFieldConfig(this.adminizer, fldConfig, key, modelField);
             // Add new field to result set
             result[key] = { config: fldConfig, model: modelField, populated: populatedModelFieldsConfig, modelConfig: associatedModelConfig };
         });
-        this.fields = result;
-        return result;
+        this.fields = this.orderFieldsByConfig(result, fieldsConfig, actionConfig.fields);
+        return this.fields;
+    }
+    orderFieldsByConfig(fields, globalFieldsConfig = {}, actionFieldsConfig = {}) {
+        const orderedFields = {};
+        const appendField = (fieldName) => {
+            if (!Object.prototype.hasOwnProperty.call(fields, fieldName)) {
+                return;
+            }
+            if (Object.prototype.hasOwnProperty.call(orderedFields, fieldName)) {
+                return;
+            }
+            orderedFields[fieldName] = fields[fieldName];
+        };
+        Object.keys(actionFieldsConfig || {}).forEach(appendField);
+        Object.keys(globalFieldsConfig || {}).forEach(appendField);
+        Object.keys(fields).forEach(appendField);
+        return orderedFields;
     }
     getAssociatedFieldsConfig(modelName) {
         const model = this.adminizer.modelHandler.model.get(modelName);
@@ -123,9 +173,9 @@ export class DataAccessor {
             return undefined;
         }
         // Check if user has access to the associated model
-        const tokenId = `read-${modelName}-${this.entity.type}`;
+        const tokenId = `read-${modelName}-${MODEL_TOKEN_SUFFIX}`;
         if (!this.adminizer.accessRightsHelper.hasPermission(tokenId, this.user)) {
-            Adminizer.log.debug(`getAssociatedFieldsConfig > No access rights to ${this.actionVerb} ${this.entity.type}: ${modelName}`);
+            Adminizer.log.debug(`getAssociatedFieldsConfig > No access rights to ${this.actionVerb} model: ${modelName}`);
             return undefined;
         }
         const associatedFields = {};
@@ -181,7 +231,7 @@ export class DataAccessor {
         return associatedFields;
     }
     checkFieldAccess(key, fieldConfig) {
-        if (this.entity.model.primaryKey === key) {
+        if (this.modelResource.model.primaryKey === key) {
             return true;
         }
         if (this.user.isAdministrator) {
@@ -208,7 +258,7 @@ export class DataAccessor {
         }
         const filteredRecord = {};
         // Set the primary key value
-        const primaryKey = (this.entity.model.primaryKey ?? 'id');
+        const primaryKey = (this.modelResource.model.primaryKey ?? 'id');
         filteredRecord[primaryKey] = record[primaryKey];
         for (const fieldKey in record) {
             const fieldConfig = this.fields[fieldKey];
@@ -278,19 +328,21 @@ export class DataAccessor {
     processMany(records) {
         return records.map(record => this.process(record));
     }
-    async sanitizeUserRelationAccess(criteria) {
+    async sanitizeUserRelationAccess(criteria = {}) {
         let sanitizedCriteria = {};
         // Retrieve model configuration from adminpanel config
-        const modelName = this.entity.model.modelname;
-        const modelConfig = this.entity.config;
+        const modelName = this.modelResource.model.modelname;
+        const modelConfig = this.modelResource.config;
         // Check if the model has `userAccessRelation` configured
         if (!this.user.isAdministrator && modelConfig && modelConfig.userAccessRelation) {
+            Adminizer.log.warn(`[userAccessRelation] Model "${modelName}" has userAccessRelation="${modelConfig.userAccessRelation}". ` +
+                `User "${this.user.login}" (id: ${this.user.id}) will only see records they own.`);
             // Get access field from userAccessRelation
             const userAccessRelation = modelConfig.userAccessRelation;
             if (typeof userAccessRelation === 'string') {
                 let accessField = userAccessRelation;
                 // Check if the relation points to `UserAP` or `GroupAP` in the model's attributes
-                const modelAttributes = this.entity.model.attributes;
+                const modelAttributes = this.modelResource.model.attributes;
                 const relation = modelAttributes[accessField];
                 if (!relation || !['userap', 'groupap'].includes(relation.model.toLowerCase() || relation.collection.toLowerCase())) {
                     throw new Error(`Invalid userAccessRelation configuration for model ${modelName}`);
@@ -307,7 +359,7 @@ export class DataAccessor {
                         sanitizedCriteria = { ...sanitizedCriteria, [accessField]: { in: userGroups } };
                     }
                 }
-                /** Warning: code was not tested, need further processing in waterline (intersects does not support in waterline) */
+                /** Warning: collection relation access is not supported and needs adapter-level processing */
                 if (relation.collection) {
                     Adminizer.log.warn(`Collection relation is not supported and was not tested. You may have an error here: ${JSON.stringify(relation, null, 2)}`);
                     if (relation.collection.toLowerCase() === 'userap') {
@@ -325,7 +377,7 @@ export class DataAccessor {
                 // If userAccessRelation is an object
                 const { field, via } = userAccessRelation;
                 // Get attributes of the current model and validate the intermediate relation
-                const modelAttributes = this.entity.model.attributes;
+                const modelAttributes = this.modelResource.model.attributes;
                 const intermediateRelation = modelAttributes[field];
                 if (!intermediateRelation || !intermediateRelation.model) {
                     throw new Error(`Invalid intermediate relation configuration for field "${field}" in model ${modelName}`);
@@ -343,28 +395,23 @@ export class DataAccessor {
                         `Currently, only relations to "userap" are supported`);
                 }
                 // Fetch all intermediate records associated with the user
-                const intermediateRecords = await intermediateModel["_find"]({ [via]: this.user.id });
+                const intermediateRecords = await this.accessRelationModel(intermediateRelation.model).find({ where: { [via]: this.user.id } });
                 const intermediateIds = (intermediateRecords || []).map((r) => r.id);
                 // Filter main model by all matching intermediate record IDs
                 sanitizedCriteria = { ...sanitizedCriteria, [field]: { in: intermediateIds } };
             }
         }
-        // TODO fix types when deleting waterline (temporary decision here)
-        let _criteria = criteria;
-        if (_criteria.where) {
-            _criteria.where = { ..._criteria.where, ...sanitizedCriteria };
-        }
-        else {
-            _criteria = { ..._criteria, ...sanitizedCriteria };
-        }
-        return _criteria;
+        return {
+            ...criteria,
+            where: mergeCriteriaWhere(criteria.where, sanitizedCriteria)
+        };
     }
     async setUserRelationAccess(record) {
         let updatedRecord = { ...record };
         // Check if model has `userAccessRelation` configured
-        if (this.entity.config && this.entity.config.userAccessRelation) {
+        if (this.modelResource.config && this.modelResource.config.userAccessRelation) {
             // Get access field from userAccessRelation
-            const userAccessRelation = this.entity.config.userAccessRelation;
+            const userAccessRelation = this.modelResource.config.userAccessRelation;
             if (typeof userAccessRelation === 'string') {
                 let accessField = userAccessRelation;
                 // only admin can set user access relation manually
@@ -372,7 +419,7 @@ export class DataAccessor {
                     delete updatedRecord[accessField];
                 }
                 // Check if the relation points to `UserAP` or `GroupAP` in the model's attributes
-                const modelAttributes = this.entity.model.attributes;
+                const modelAttributes = this.modelResource.model.attributes;
                 const relation = modelAttributes[accessField];
                 if (relation && ['userap', 'groupap'].includes(relation.model.toLowerCase())) {
                     if (relation.model.toLowerCase() === 'userap') {
@@ -399,10 +446,10 @@ export class DataAccessor {
                     if (!via) {
                         throw new Error(`Invalid userAccessRelation configuration: "via" is required`);
                     }
-                    const modelAttributes = this.entity.model.attributes;
+                    const modelAttributes = this.modelResource.model.attributes;
                     const intermediateRelation = modelAttributes[field];
                     if (!intermediateRelation || !intermediateRelation.model) {
-                        throw new Error(`Invalid intermediate relation configuration for field "${field}" in model ${this.entity.model.modelname}`);
+                        throw new Error(`Invalid intermediate relation configuration for field "${field}" in model ${this.modelResource.model.modelname}`);
                     }
                     const intermediateModel = this.adminizer.modelHandler.model.get(intermediateRelation.model.toLowerCase());
                     if (!intermediateModel) {
@@ -419,7 +466,7 @@ export class DataAccessor {
                     const chosenId = typeof updatedRecord[field] === 'object'
                         ? updatedRecord[field][intermediatePk]
                         : updatedRecord[field];
-                    const record = await intermediateModel["_findOne"]({ [intermediatePk]: chosenId, [via]: this.user.id });
+                    const record = await this.accessRelationModel(intermediateRelation.model).findOne({ where: { [intermediatePk]: chosenId, [via]: this.user.id } });
                     if (!record) {
                         throw new Error(`Access denied: "${field}" does not belong to the current user`);
                     }

package/lib/I18n.d.ts

@@ -5,6 +5,7 @@ type I18nOptions = {
     locales?: string[];
     defaultLocale?: string;
     directory?: string;
+    missingDirectory?: string;
     extension?: string;
     cookieName?: string;
     sessionVarName?: string;
@@ -19,7 +20,10 @@ export declare class I18n {
     private devMode;
     private static locales;
     private defaultLocale;
+    private defaultDirectory;
     private directory;
+    private customDirectory?;
+    private missingDirectory?;
     private extension;
     private cookieName;
     private sessionVarName;
@@ -37,8 +41,8 @@ export declare class I18n {
     isPreferredLocale(): boolean;
     translate(locale: string, singular: string, plural?: string): any;
     private readFile;
-    private writeFile;
     private locateFile;
+    private writeMissingTranslation;
     static appendLocale(locale: string, data: any): void;
     static getLocales(): Record<string, LocaleData>;
 }