adminizer 4.6.0 → 4.7.0-build.221

package/lib/model/AbstractModel.js

@@ -1,5 +1,6 @@
 import { formatChanges, sanitizeForDiff } from "../../helpers/diffHelpers.js";
 import { diff } from "deep-object-diff";
+import { INTERNAL_MODEL_ACCESS_TOKEN } from "./internalModelAccessToken.js";
 export class AbstractModel {
     modelname;
     attributes;
@@ -11,6 +12,41 @@ export class AbstractModel {
         this.primaryKey = primaryKey;
         this.identity = identity;
     }
+    createInternalRepository(accessToken, modelName = this.modelname) {
+        if (accessToken !== INTERNAL_MODEL_ACCESS_TOKEN) {
+            throw new Error("Internal model repository access denied");
+        }
+        const model = this;
+        return {
+            async find(criteria = {}) {
+                return model._find(criteria);
+            },
+            async findOne(criteria = {}) {
+                return model._findOne(criteria);
+            },
+            async count(criteria = {}) {
+                return model._count(criteria);
+            },
+            async create(data) {
+                return model._create(data);
+            },
+            async update(criteria, data) {
+                return model._update(criteria, data);
+            },
+            async updateOne(criteria, data) {
+                return model._updateOne(criteria, data);
+            },
+            async destroy(criteria) {
+                return model._destroy(criteria);
+            },
+            async destroyOne(criteria) {
+                return model._destroyOne(criteria);
+            },
+            get name() {
+                return modelName;
+            }
+        };
+    }
     /**
      * Generate diff between old and new records
      */
@@ -74,7 +110,7 @@ export class AbstractModel {
         const record = eventType === 'Deleted' ? oldRecord : newRecord;
         this.setHistory(dataAccessor, {
             modelId: record[this.primaryKey],
-            modelName: dataAccessor.entity.name.toLocaleLowerCase(),
+            modelName: dataAccessor.modelResource.name.toLocaleLowerCase(),
             action: eventType.toLocaleLowerCase(),
             data: record,
             diff: formattedChanges,
@@ -99,6 +135,22 @@ export class AbstractModel {
         let records = await this._find(criteria);
         return records.map(record => dataAccessor.process(record));
     }
+    /**
+     * Find with raw SQL where clause (Sequelize.literal support)
+     * Only available in Sequelize adapter
+     */
+    async findWithRawWhere(where, options) {
+        // Default implementation - will be overridden by Sequelize adapter
+        throw new Error('findWithRawWhere is only supported in Sequelize adapter');
+    }
+    /**
+     * Count with raw SQL where clause (Sequelize.literal support)
+     * Only available in Sequelize adapter
+     */
+    async countWithRawWhere(where) {
+        // Default implementation - will be overridden by Sequelize adapter
+        throw new Error('countWithRawWhere is only supported in Sequelize adapter');
+    }
     async updateOne(criteria, data, dataAccessor) {
         let _data = dataAccessor.process(data);
         // Get the old record first for diff
@@ -161,7 +213,7 @@ export class AbstractModel {
         }
         return records.map(record => dataAccessor.process(record));
     }
-    async count(criteria, dataAccessor) {
+    async count(criteria = {}, dataAccessor) {
         criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
         return this._count(criteria);
     }

package/lib/model/InternalModelAccessFactory.d.ts

@@ -0,0 +1,18 @@
+import { InternalModelAccessMap, InternalModelRepository } from "../../interfaces/internalModelAccess";
+import { AbstractModel } from "./AbstractModel";
+export declare const DEFAULT_INTERNAL_MODEL_ACCESS: InternalModelAccessMap;
+export declare class InternalModelScope {
+    private readonly getModel;
+    private readonly scopeName;
+    private readonly allowedModels;
+    constructor(getModel: (modelName: string) => AbstractModel<any> | undefined, scopeName: string, allowedModels: Set<string>);
+    get<T = any>(modelName: string): InternalModelRepository<T>;
+    has(modelName: string): boolean;
+}
+export declare class InternalModelAccessFactory {
+    private readonly getModel;
+    private readonly accessMap;
+    constructor(getModel: (modelName: string) => AbstractModel<any> | undefined, accessMap?: InternalModelAccessMap);
+    scope(scopeName: string): InternalModelScope;
+    canUse(scopeName: string, modelName: string): boolean;
+}

package/lib/model/InternalModelAccessFactory.js

@@ -0,0 +1,82 @@
+import { createInternalModelRepository } from "./internalModelRepository.js";
+export const DEFAULT_INTERNAL_MODEL_ACCESS = {
+    auth: ["UserAP", "GroupAP"],
+    "access-rights": ["UserAP", "GroupAP"],
+    users: ["UserAP", "GroupAP"],
+    filters: ["FilterAP", "FilterColumnAP", "UserAP", "GroupAP"],
+    "media-manager": [
+        "MediaManagerAP",
+        "MediaManagerMetaAP",
+        "MediaManagerAssociationsAP",
+        "HistoryActionsAP"
+    ],
+    history: ["HistoryActionsAP", "UserAP"],
+    "data-accessor": [],
+    notifications: ["NotificationAP", "UserNotificationAP", "UserAP"],
+    navigation: ["NavigationAP"],
+    feed: ["FilterAP", "UserAP"],
+    widgets: ["UserAP", "FilterAP"]
+};
+function normalizeName(name) {
+    return name.toLowerCase();
+}
+function normalizeAccessMap(accessMap) {
+    const result = new Map();
+    for (const [scope, models] of Object.entries(accessMap)) {
+        result.set(normalizeName(scope), new Set(models.map(normalizeName)));
+    }
+    return result;
+}
+function mergeAccessMaps(base, extra) {
+    const merged = { ...base };
+    if (!extra) {
+        return merged;
+    }
+    for (const [scope, models] of Object.entries(extra)) {
+        merged[scope] = [...(merged[scope] ?? []), ...models];
+    }
+    return merged;
+}
+export class InternalModelScope {
+    getModel;
+    scopeName;
+    allowedModels;
+    constructor(getModel, scopeName, allowedModels) {
+        this.getModel = getModel;
+        this.scopeName = scopeName;
+        this.allowedModels = allowedModels;
+    }
+    get(modelName) {
+        const normalizedModelName = normalizeName(modelName);
+        if (!this.allowedModels.has(normalizedModelName)) {
+            throw new Error(`Internal model access denied: scope "${this.scopeName}" cannot use model "${modelName}"`);
+        }
+        const model = this.getModel(modelName);
+        if (!model) {
+            throw new Error(`Internal model access failed: model "${modelName}" was not found`);
+        }
+        return createInternalModelRepository(modelName, model);
+    }
+    has(modelName) {
+        return this.allowedModels.has(normalizeName(modelName));
+    }
+}
+export class InternalModelAccessFactory {
+    getModel;
+    accessMap;
+    constructor(getModel, accessMap) {
+        this.getModel = getModel;
+        this.accessMap = normalizeAccessMap(mergeAccessMaps(DEFAULT_INTERNAL_MODEL_ACCESS, accessMap));
+    }
+    scope(scopeName) {
+        const normalizedScopeName = normalizeName(scopeName);
+        const allowedModels = this.accessMap.get(normalizedScopeName);
+        if (!allowedModels) {
+            throw new Error(`Internal model access scope "${scopeName}" is not registered`);
+        }
+        return new InternalModelScope(this.getModel, scopeName, allowedModels);
+    }
+    canUse(scopeName, modelName) {
+        return this.accessMap.get(normalizeName(scopeName))?.has(normalizeName(modelName)) ?? false;
+    }
+}

package/lib/model/ModelHandler.d.ts

@@ -1,4 +1,6 @@
 import { AbstractModel } from "./AbstractModel";
+import { InternalModelAccessMap } from "../../interfaces/internalModelAccess";
+import { InternalModelScope } from "./InternalModelAccessFactory";
 /**
  * Central registry (service locator) for all AbstractModel instances in the application.
  * A single instance is created in Adminizer and shared across the entire app via `req.adminizer.modelHandler`.
@@ -10,6 +12,7 @@ import { AbstractModel } from "./AbstractModel";
  */
 export declare class ModelHandler {
     private models;
+    private internalAccess?;
     add<T>(modelName: string, modelInstance: AbstractModel<T>): void;
     /** Improved model getter, so you can write both model.get("UserAP") and model.get("userap") */
     get model(): {
@@ -19,6 +22,9 @@ export declare class ModelHandler {
         keys: () => MapIterator<string>;
         values: () => MapIterator<AbstractModel<any>>;
     };
+    configureInternalAccess(accessMap?: InternalModelAccessMap): void;
+    internal(scopeName: string): InternalModelScope;
+    private getInternalAccess;
     /**
      * Get all models
      */

package/lib/model/ModelHandler.js

@@ -1,4 +1,5 @@
 import { Adminizer } from "../Adminizer.js";
+import { InternalModelAccessFactory } from "./InternalModelAccessFactory.js";
 /**
  * Central registry (service locator) for all AbstractModel instances in the application.
  * A single instance is created in Adminizer and shared across the entire app via `req.adminizer.modelHandler`.
@@ -10,6 +11,7 @@ import { Adminizer } from "../Adminizer.js";
  */
 export class ModelHandler {
     models = new Map();
+    internalAccess;
     add(modelName, modelInstance) {
         const modelname = modelName.toLowerCase();
         this.models.set(modelname, modelInstance);
@@ -26,6 +28,18 @@ export class ModelHandler {
             values: () => this.models.values(),
         };
     }
+    configureInternalAccess(accessMap) {
+        this.internalAccess = new InternalModelAccessFactory((modelName) => this.model.get(modelName), accessMap);
+    }
+    internal(scopeName) {
+        return this.getInternalAccess().scope(scopeName);
+    }
+    getInternalAccess() {
+        if (!this.internalAccess) {
+            throw new Error("Internal model access is not configured");
+        }
+        return this.internalAccess;
+    }
     /**
      * Get all models
      */

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

@@ -1,26 +1,48 @@
 import { Sequelize, ModelStatic } from "sequelize";
-import { AbstractAdapter, AbstractModel, Attribute, FindOptions } from "../AbstractModel";
-export declare function mapSequelizeToWaterline(model: ModelStatic<any>): Record<string, Attribute>;
+import { AbstractAdapter, AbstractModel, Attribute } from "../AbstractModel";
+import { QueryCriteria } from "../../../interfaces/queryCriteria";
+export declare function mapSequelizeToAdminizerAttributes(model: ModelStatic<any>): Record<string, Attribute>;
 export declare class SequelizeModel<T> extends AbstractModel<T> {
     private model;
     constructor(modelName: string, model: ModelStatic<any>);
+    private _buildJsonContainsCondition;
     _convertCriteriaToSequelize(criteria: any): any;
-    _convertWaterlineCriteriaToSequelizeOptions(criteria: any): {
+    _convertAdminizerCriteriaToSequelizeOptions(criteria: any): {
         where?: any;
         limit?: number;
         offset?: number;
         order?: any[];
+        attributes?: string[];
     };
     _assignAssociations(instance: any, assocData: Record<string, any>): Promise<void>;
     protected _create(data: Record<string, any>): Promise<T>;
-    protected _findOne(criteria: Partial<T>): Promise<T | null>;
-    protected _find(criteria?: Partial<T>, options?: FindOptions): Promise<T[]>;
-    protected _updateOne(criteria: Partial<T>, data: Partial<T>): Promise<T | null>;
-    protected _update(criteria: Partial<T>, data: Partial<T>): Promise<T[]>;
-    protected _destroyOne(criteria: Partial<T>): Promise<T | null>;
-    protected _destroy(criteria: Partial<T>): Promise<T[]>;
-    protected _count(criteria?: Partial<T>): Promise<number>;
+    protected _findOne(criteria: QueryCriteria): Promise<T | null>;
+    protected _find(criteria?: QueryCriteria): Promise<T[]>;
+    /**
+     * Public method for raw SQL where clauses (Sequelize.literal support)
+     * Bypasses Adminizer criteria conversion for direct Sequelize usage
+     */
+    findWithRawWhere(where: any, options?: {
+        limit?: number;
+        offset?: number;
+        order?: any;
+        populate?: boolean;
+    }): Promise<T[]>;
+    /**
+     * Public method for count with raw SQL where clauses
+     */
+    countWithRawWhere(where: any): Promise<number>;
+    protected _updateOne(criteria: QueryCriteria, data: Partial<T>): Promise<T | null>;
+    protected _update(criteria: QueryCriteria, data: Partial<T>): Promise<T[]>;
+    protected _destroyOne(criteria: QueryCriteria): Promise<T | null>;
+    protected _destroy(criteria: QueryCriteria): Promise<T[]>;
+    protected _count(criteria?: QueryCriteria): Promise<number>;
+    private _hasRelationPathCondition;
+    private _extractRelationAliasesFromWhere;
+    private _buildListInclude;
     private _buildIncludes;
+    private _buildAttributes;
+    private _buildCriteriaIncludes;
 }
 export declare class SequelizeAdapter extends AbstractAdapter {
     sequelize: Sequelize;