adminizer 5.0.0-build.12 → 5.0.0-build.13

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.12",
+  "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;
+            }
         }
     }
 }