adminizer 5.0.0-build.11 → 5.0.0-build.13

package/lib/filters/FilterService.js

@@ -25,8 +25,9 @@ export class FilterService {
         if (!models) {
             return null;
         }
-        // Find config (case-insensitive)
-        const foundKey = Object.keys(models).find(key => key.toLowerCase() === modelName.toLowerCase());
+        const foundKey = Object.prototype.hasOwnProperty.call(models, modelName)
+            ? modelName
+            : Object.keys(models).find(key => key.toLowerCase() === modelName.toLowerCase());
         if (!foundKey) {
             return null;
         }
@@ -35,7 +36,7 @@ export class FilterService {
             return null;
         }
         // Get AbstractModel
-        const model = this.adminizer.modelHandler.model.get(config.model);
+        const model = this.adminizer.modelHandler.getResource(foundKey);
         if (!model) {
             return null;
         }

package/lib/history-actions/AbstractHistoryAdapter.js

@@ -86,9 +86,9 @@ export class AbstractHistoryAdapter {
      * @returns Array of model names (in lowercase) the user can access.
      */
     getModels(user) {
-        const models = this.adminizer.modelHandler.all
-            .filter(model => !this.excludedModels.has(model.modelname))
-            .map(model => model.modelname.toLowerCase());
+        const models = Array.from(this.adminizer.modelHandler.model.entries())
+            .filter(([, model]) => !this.excludedModels.has(model.modelname))
+            .map(([resourceName]) => resourceName);
         const accessModels = [];
         for (const model of models) {
             const access = this.adminizer.accessRightsHelper.enoughPermissions([
@@ -304,14 +304,15 @@ export class AbstractHistoryAdapter {
      * @protected
      */
     findModelResource(history) {
-        const modelResourceName = history.modelName;
+        const modelResourceName = this.adminizer.modelHandler.getResourceRecord(history.modelName)?.name
+            ?? history.modelName;
         const modelResourceUri = `${this.adminizer.config.routePrefix}/model/${modelResourceName}`;
         const models = this.adminizer.config.models;
         const foundKey = Object.keys(models).find(key => key.toLowerCase() === modelResourceName.toLowerCase());
         const modelResource = {
             name: modelResourceName,
             uri: modelResourceUri,
-            model: this.adminizer.modelHandler.model.get(history.modelName),
+            model: this.adminizer.modelHandler.getResource(modelResourceName),
             config: models[foundKey]
         };
         return modelResource;
@@ -341,8 +342,9 @@ export class AbstractHistoryAdapter {
                 Adminizer.log.error('No model found for field: ', fields[key]);
                 return;
             }
-            let Model = this.adminizer.modelHandler.model.get(modelName);
-            if (!Model) {
+            const resourceName = this.adminizer.modelHandler.resolveAssociationResource(modelName, fields[key].model.resourceName);
+            let Model = resourceName ? this.adminizer.modelHandler.getResource(resourceName) : undefined;
+            if (!Model || !resourceName) {
                 return;
             }
             let list;
@@ -351,8 +353,8 @@ export class AbstractHistoryAdapter {
                 Adminizer.log.warn("Warning: executing malicious job trying to add a huge amount of records in field config," +
                     " please rewrite this part of code in the nearest future");
                 let modelResource = {
-                    name: modelName, config: this.adminizer.config.models[modelName],
-                    model: Model, uri: `${this.adminizer.config.routePrefix}/model/${modelName}`
+                    name: resourceName, config: this.adminizer.config.models[resourceName],
+                    model: Model, uri: `${this.adminizer.config.routePrefix}/model/${resourceName}`
                 };
                 let dataAccessor = new DataAccessor(this.adminizer, user, modelResource, "view");
                 list = await Model.find({}, dataAccessor);

package/lib/model/AbstractModel.d.ts

@@ -14,6 +14,8 @@ export interface Attribute {
     columnName?: string;
     model?: string;
     collection?: string;
+    /** Canonical Adminizer resource target for a system-model association. */
+    resourceName?: string;
     via?: string;
     allowNull?: boolean;
     /**

package/lib/model/ModelHandler.d.ts

@@ -9,10 +9,26 @@ export interface AppModelAccessRecord {
 export interface ModelRecord {
     id: string;
     name: string;
+    hostModelName: string;
+    primaryHostModel: boolean;
     model: AbstractModel<any>;
     ownerApp?: string;
     enabled: boolean;
 }
+export interface ModelRegistrationOptions {
+    /** Physical ORM model name. It is intentionally independent from the Adminizer resource name. */
+    hostModelName?: string;
+    /**
+     * Selects this resource as the association target when multiple resources use the same host model.
+     * Exactly one resource must be primary for every shared host model.
+     */
+    primary?: boolean;
+    /**
+     * @deprecated Register and use the canonical Adminizer resource name instead.
+     * Kept only for compatibility with existing integrations. Host model names must not be used as aliases.
+     */
+    aliases?: string[];
+}
 export declare class AppModelAccess {
     private readonly getModel;
     private readonly appName;
@@ -33,9 +49,12 @@ export declare class AppModelAccess {
 export declare class ModelHandler {
     private models;
     private modelAliases;
+    private hostModelResources;
     private internalAccess?;
     private appAccessRecords;
-    add<T>(modelName: string, modelInstance: AbstractModel<T>, aliases?: string[]): void;
+    add<T>(resourceName: string, modelInstance: AbstractModel<T>, options?: ModelRegistrationOptions): void;
+    /** @deprecated Pass `{ aliases }` in ModelRegistrationOptions, or preferably use the canonical resource name. */
+    add<T>(resourceName: string, modelInstance: AbstractModel<T>, aliases?: string[]): void;
     register<T>(appName: string, modelName: string, modelInstance: AbstractModel<T>): string;
     unregister(id: string): void;
     disable(id: string): void;
@@ -45,7 +64,10 @@ export declare class ModelHandler {
     unregisterAppAccess(id: string): void;
     getAppAccessRecords(appName: string): AppModelAccessRecord[];
     createAppAccess(appName: string): AppModelAccess;
-    /** Improved model getter with case-insensitive lookup and configured alias support. */
+    /**
+     * Improved model getter with case-insensitive lookup and configured alias support.
+     * @deprecated New code should use getResource() and getByHostModel() explicitly.
+     */
     get model(): {
         get: (modelName: string) => AbstractModel<any>;
         has: (modelName: string) => boolean;
@@ -53,6 +75,26 @@ export declare class ModelHandler {
         keys: () => IterableIterator<string>;
         values: () => IterableIterator<AbstractModel<any>>;
     };
+    /**
+     * Returns a model by its Adminizer resource name or an explicit deprecated compatibility alias.
+     * New code must use canonical resource names.
+     */
+    getResource(resourceName: string): AbstractModel<any> | undefined;
+    getResourceRecord(resourceName: string): ModelRecord | undefined;
+    /**
+     * Resolves a physical ORM model name to its Adminizer resource.
+     * This lookup is deliberately separate from getResource(): a host model may have the
+     * same name as a system resource while being exposed under a project resource alias.
+     */
+    resolveResourceByHostModel(hostModelName: string): string | undefined;
+    getByHostModel(hostModelName: string): AbstractModel<any> | undefined;
+    /**
+     * Resolves an ORM association target. Adapter-provided host model names take precedence;
+     * system-model relations may pass their explicit canonical resource name instead.
+     */
+    resolveAssociationResource(targetName: string, resourceName?: string): string | undefined;
+    /** Validates that every host ORM model used by multiple resources has one primary resource. */
+    validateHostModelMappings(): void;
     resolveModelName(modelName: string): string;
     configureInternalAccess(accessMap?: InternalModelAccessMap): void;
     internal(scopeName: string): InternalModelScope;
@@ -63,6 +105,9 @@ export declare class ModelHandler {
     get all(): AbstractModel<any>[];
     private getAllowedAppModels;
     private registerAliases;
+    private registerHostModel;
+    private unregisterHostModel;
+    private getSharedHostModelError;
     private resolveName;
     private enabledModelEntries;
     private enabledModelKeys;

package/lib/model/ModelHandler.js

@@ -40,18 +40,27 @@ export class AppModelAccess {
 export class ModelHandler {
     models = new Map();
     modelAliases = new Map();
+    hostModelResources = new Map();
     internalAccess;
     appAccessRecords = new Map();
-    add(modelName, modelInstance, aliases = []) {
-        const modelname = modelName.toLowerCase();
-        this.models.set(modelname, {
-            id: modelname,
-            name: modelName,
+    add(resourceName, modelInstance, options = {}) {
+        const resourceId = normalizeName(resourceName);
+        if (this.models.has(resourceId)) {
+            throw new Error(`Model resource "${resourceName}" is already registered`);
+        }
+        const normalizedOptions = Array.isArray(options) ? { aliases: options } : options;
+        const hostModelName = normalizedOptions.hostModelName ?? resourceName;
+        this.registerHostModel(resourceName, hostModelName, true);
+        this.models.set(resourceId, {
+            id: resourceId,
+            name: resourceName,
+            hostModelName,
+            primaryHostModel: normalizedOptions.primary === true,
             model: modelInstance,
             enabled: true,
         });
-        this.registerAliases(modelName, aliases);
-        Adminizer.log.debug(`Model with name [${modelname}] was registered`);
+        this.registerAliases(resourceName, normalizedOptions.aliases ?? []);
+        Adminizer.log.debug(`Model resource [${resourceName}] was registered for host model [${hostModelName}]`);
     }
     register(appName, modelName, modelInstance) {
         const normalizedModelName = normalizeName(modelName);
@@ -61,10 +70,13 @@ export class ModelHandler {
         this.models.set(normalizedModelName, {
             id: normalizedModelName,
             name: modelName,
+            hostModelName: modelName,
+            primaryHostModel: true,
             model: modelInstance,
             ownerApp: appName,
             enabled: true,
         });
+        this.registerHostModel(modelName, modelName, false);
         Adminizer.log.debug(`Model with name [${normalizedModelName}] was registered by app [${appName}]`);
         return normalizedModelName;
     }
@@ -74,6 +86,7 @@ export class ModelHandler {
             return;
         }
         this.models.delete(normalizeName(id));
+        this.unregisterHostModel(record.hostModelName, record.name);
     }
     disable(id) {
         const record = this.models.get(normalizeName(id));
@@ -118,7 +131,10 @@ export class ModelHandler {
         return new AppModelAccess((modelName) => this.model.get(modelName), appName, () => this.getAllowedAppModels(appName));
     }
     // TODO: 'hot reload' need add method for delete model & unbind
-    /** Improved model getter with case-insensitive lookup and configured alias support. */
+    /**
+     * Improved model getter with case-insensitive lookup and configured alias support.
+     * @deprecated New code should use getResource() and getByHostModel() explicitly.
+     */
     get model() {
         return {
             get: (modelName) => this.models.get(this.resolveName(modelName))?.enabled
@@ -130,6 +146,65 @@ export class ModelHandler {
             values: () => this.enabledModelValues(),
         };
     }
+    /**
+     * Returns a model by its Adminizer resource name or an explicit deprecated compatibility alias.
+     * New code must use canonical resource names.
+     */
+    getResource(resourceName) {
+        return this.model.get(resourceName);
+    }
+    getResourceRecord(resourceName) {
+        const record = this.models.get(this.resolveName(resourceName));
+        return record?.enabled ? record : undefined;
+    }
+    /**
+     * Resolves a physical ORM model name to its Adminizer resource.
+     * This lookup is deliberately separate from getResource(): a host model may have the
+     * same name as a system resource while being exposed under a project resource alias.
+     */
+    resolveResourceByHostModel(hostModelName) {
+        const resourceIds = this.hostModelResources.get(normalizeName(hostModelName));
+        const records = Array.from(resourceIds ?? [])
+            .map((resourceId) => this.models.get(resourceId))
+            .filter((record) => Boolean(record?.enabled));
+        if (records.length === 1) {
+            return records[0].name;
+        }
+        const primaryRecords = records.filter((record) => record.primaryHostModel);
+        if (primaryRecords.length === 1) {
+            return primaryRecords[0].name;
+        }
+        if (records.length > 1) {
+            throw new Error(this.getSharedHostModelError(hostModelName, records));
+        }
+        return undefined;
+    }
+    getByHostModel(hostModelName) {
+        const resourceName = this.resolveResourceByHostModel(hostModelName);
+        return resourceName ? this.getResource(resourceName) : undefined;
+    }
+    /**
+     * Resolves an ORM association target. Adapter-provided host model names take precedence;
+     * system-model relations may pass their explicit canonical resource name instead.
+     */
+    resolveAssociationResource(targetName, resourceName) {
+        if (resourceName) {
+            return this.getResourceRecord(resourceName)?.name;
+        }
+        return this.resolveResourceByHostModel(targetName)
+            ?? this.getResourceRecord(targetName)?.name;
+    }
+    /** Validates that every host ORM model used by multiple resources has one primary resource. */
+    validateHostModelMappings() {
+        for (const [normalizedHostModelName, resourceIds] of this.hostModelResources) {
+            const records = Array.from(resourceIds)
+                .map((resourceId) => this.models.get(resourceId))
+                .filter((record) => Boolean(record?.enabled));
+            if (records.length > 1 && records.filter((record) => record.primaryHostModel).length !== 1) {
+                throw new Error(this.getSharedHostModelError(records[0]?.hostModelName ?? normalizedHostModelName, records));
+            }
+        }
+    }
     resolveModelName(modelName) {
         const resolvedName = this.resolveName(modelName);
         return this.models.get(resolvedName)?.name ?? modelName;
@@ -184,6 +259,30 @@ export class ModelHandler {
             this.modelAliases.set(normalizedAlias, normalizedModelName);
         }
     }
+    registerHostModel(resourceName, hostModelName, allowMultipleResources) {
+        const normalizedHostModelName = normalizeName(hostModelName);
+        const resourceId = normalizeName(resourceName);
+        const resourceIds = this.hostModelResources.get(normalizedHostModelName) ?? new Set();
+        if (!allowMultipleResources && resourceIds.size && !resourceIds.has(resourceId)) {
+            const existingResourceId = resourceIds.values().next().value;
+            const existingResource = this.models.get(existingResourceId)?.name ?? existingResourceId;
+            throw new Error(`Host model "${hostModelName}" is already registered for Adminizer resource "${existingResource}"`);
+        }
+        resourceIds.add(resourceId);
+        this.hostModelResources.set(normalizedHostModelName, resourceIds);
+    }
+    unregisterHostModel(hostModelName, resourceName) {
+        const normalizedHostModelName = normalizeName(hostModelName);
+        const resourceIds = this.hostModelResources.get(normalizedHostModelName);
+        resourceIds?.delete(normalizeName(resourceName));
+        if (!resourceIds?.size) {
+            this.hostModelResources.delete(normalizedHostModelName);
+        }
+    }
+    getSharedHostModelError(hostModelName, records) {
+        return (`Host model "${hostModelName}" is mapped to multiple Adminizer resources: ` +
+            `${records.map((record) => record.name).join(", ")}. Configure exactly one with primary: true.`);
+    }
     resolveName(modelName) {
         const normalizedModelName = normalizeName(modelName);
         return this.modelAliases.get(normalizedModelName) ?? normalizedModelName;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "adminizer",
   "type": "module",
-  "version": "5.0.0-build.11",
+  "version": "5.0.0-build.13",
   "main": "index.js",
   "exports": {
     ".": "./index.js",

package/system/bindAccessRights.js

@@ -2,10 +2,9 @@ import { GROUP_FILTER_VISIBILITY_TOKEN } from "../policies/permissionResolvers.j
 export default async function bindAccessRights(adminizer) {
     if (adminizer.config.models) {
         let models = adminizer.config.models;
-        for (let key of Object.keys(models)) {
-            const model = models[key];
+        for (const [resourceName, model] of Object.entries(models)) {
             if (typeof model !== "boolean") {
-                adminizer.accessRightsHelper.registerModelTokens(model.model);
+                adminizer.accessRightsHelper.registerModelTokens(resourceName);
             }
         }
     }

package/system/buildInternalModelAccess.js

@@ -30,10 +30,13 @@ function getDataAccessorInternalModels(config, modelHandler) {
         if (!userAccessRelation || typeof userAccessRelation !== "object" || Array.isArray(userAccessRelation)) {
             continue;
         }
-        const model = modelHandler.model.get(modelConfig.model ?? modelName);
+        const model = modelHandler.getResource(modelName);
         const intermediateModelName = model?.attributes?.[userAccessRelation.field]?.model;
         if (intermediateModelName) {
-            models.push(modelHandler.resolveModelName(intermediateModelName));
+            const resourceName = modelHandler.resolveAssociationResource(intermediateModelName, model?.attributes?.[userAccessRelation.field]?.resourceName);
+            if (resourceName) {
+                models.push(resourceName);
+            }
         }
     }
     return Array.from(new Set(models));

package/system/validateSystemModels.js

@@ -10,13 +10,11 @@ export function validateSystemModels(adminizer) {
     }
     const systemAdapter = getAdapter(adminizer, defaultOrmAdapter);
     const bindings = buildSystemModelBindings(systemAdapter);
-    const systemModels = new Set();
+    const systemResourceNames = new Set(SYSTEM_MODEL_CONTRACTS.map((contract) => contract.name));
     for (const contract of SYSTEM_MODEL_CONTRACTS) {
         const binding = bindings.get(contract.name.toLowerCase()) ?? {
             model: contract.name,
         };
-        systemModels.add(contract.name.toLowerCase());
-        systemModels.add(binding.model.toLowerCase());
         const registeredModel = systemAdapter.getModel(binding.model);
         if (!registeredModel) {
             throw new Error(`System model "${contract.name}" was not provided by adapter "${systemAdapter.ormType}" as host model "${binding.model}". ` +
@@ -27,7 +25,11 @@ export function validateSystemModels(adminizer) {
             resolveRelationTarget: (target) => resolveSystemRelationTarget(target, bindings),
         });
         normalizeSystemModelRelations(model, bindings);
-        adminizer.modelHandler.add(contract.name, model, [binding.model]);
+        adminizer.modelHandler.add(contract.name, model, {
+            hostModelName: binding.model,
+            // @deprecated Compatibility lookup for modules that still request UserAP/GroupAP.
+            aliases: [binding.model],
+        });
     }
     const modelsFromConfig = Object.entries(adminizer.config.models ?? {});
     Adminizer.log.debug(`Bind models > Models from config: ${modelsFromConfig.map(([name]) => name)}`);
@@ -35,7 +37,10 @@ export function validateSystemModels(adminizer) {
         const modelName = modelConfig && typeof modelConfig !== "boolean"
             ? modelConfig.model
             : configName;
-        if (systemModels.has(modelName.toLowerCase())) {
+        // System resources are already registered above. Do not compare host model names
+        // here: a project resource may intentionally map its own Adminizer name to a
+        // host model named "User" or "Group".
+        if (systemResourceNames.has(configName)) {
             continue;
         }
         const adapterName = modelConfig && typeof modelConfig !== "boolean"
@@ -46,8 +51,12 @@ export function validateSystemModels(adminizer) {
         if (!registeredModel) {
             throw new Error(`Bind models > Model not found: ${modelName}`);
         }
-        adminizer.modelHandler.add(modelName, new ormAdapter.Model(modelName, registeredModel));
+        adminizer.modelHandler.add(configName, new ormAdapter.Model(modelName, registeredModel), {
+            hostModelName: modelName,
+            primary: modelConfig && typeof modelConfig !== "boolean" && modelConfig.primary === true,
+        });
     }
+    adminizer.modelHandler.validateHostModelMappings();
     Adminizer.log.info("Models loaded");
 }
 function getAdapter(adminizer, adapterName) {
@@ -79,6 +88,9 @@ function normalizeSystemModelBinding(binding) {
     return binding;
 }
 function resolveSystemRelationTarget(target, bindings) {
+    return getSystemRelationResource(target, bindings) ?? target;
+}
+function getSystemRelationResource(target, bindings) {
     const normalizedTarget = target.toLowerCase();
     for (const contract of SYSTEM_MODEL_CONTRACTS) {
         const binding = bindings.get(contract.name.toLowerCase());
@@ -87,15 +99,23 @@ function resolveSystemRelationTarget(target, bindings) {
             return contract.name;
         }
     }
-    return target;
+    return undefined;
 }
 function normalizeSystemModelRelations(model, bindings) {
     for (const attribute of Object.values(model.attributes)) {
         if (attribute.model) {
-            attribute.model = resolveSystemRelationTarget(attribute.model, bindings);
+            const resourceName = getSystemRelationResource(attribute.model, bindings);
+            if (resourceName) {
+                attribute.resourceName = resourceName;
+                attribute.model = resourceName;
+            }
         }
         if (attribute.collection) {
-            attribute.collection = resolveSystemRelationTarget(attribute.collection, bindings);
+            const resourceName = getSystemRelationResource(attribute.collection, bindings);
+            if (resourceName) {
+                attribute.resourceName = resourceName;
+                attribute.collection = resourceName;
+            }
         }
     }
 }