adminizer 4.2.0-build.50 → 4.2.0-build.52

package/lib/media-manager/Thumb.js

@@ -7,8 +7,7 @@ export class MediaManagerThumb {
         const manager = MediaManagerHandler.get(managerId);
         const path = await manager.getOrigin(id);
         const baseThumbPath = `${process.cwd()}/.tmp/thumbs`;
-        if (!await fileExists(baseThumbPath))
-            await fs.mkdir(baseThumbPath);
+        await fs.mkdir(baseThumbPath, { recursive: true });
         const thumb = `${baseThumbPath}/${id}_thumb.webp`;
         if (await fileExists(thumb)) {
             return await fs.readFile(thumb);

package/lib/media-manager/helpers/MediaManagerHelper.js

@@ -21,9 +21,10 @@ export function randomFileName(filenameOrig, type, prefix) {
 export async function saveRelationsMediaManager(fields, reqData, model, recordId) {
     for (let prop in reqData) {
         let fieldConfigConfig = fields[prop].config;
+        let options = fieldConfigConfig.options;
         if (fieldConfigConfig.type === 'mediamanager') {
             let data = reqData[prop];
-            let mediaManager = MediaManagerHandler.get(data.mediaManagerId);
+            let mediaManager = MediaManagerHandler.get(options?.id ?? 'default');
             await mediaManager.setRelations(data, model, recordId, prop);
         }
     }
@@ -34,7 +35,7 @@ export async function saveRelationsMediaManager(fields, reqData, model, recordId
 */
 export async function getRelationsMediaManager(data) {
     let mediaManager = MediaManagerHandler.get(data.mediaManagerId);
-    return await mediaManager.getRelations(data.list);
+    return await mediaManager.getRelations(data.list ?? []);
 }
 /*
 * Delate Ralations
@@ -48,10 +49,7 @@ export async function deleteRelationsMediaManager(adminizer, model, record) {
         if (field && field.type === 'mediamanager') {
             const option = field.options;
             let mediaManager = MediaManagerHandler.get(option?.id ?? 'default');
-            let emptyData = {
-                list: [],
-                mediaManagerId: ''
-            };
+            let emptyData = [];
             await mediaManager.setRelations(emptyData, model, record[0].id, key);
         }
     }

package/lib/v4/DataAccessor.d.ts

@@ -14,6 +14,7 @@ export declare class DataAccessor {
     private fields;
     private actionVerb;
     constructor(adminizer: Adminizer, user: UserAP, entity: Entity, action: ActionType);
+    private getModelConfig;
     /**
      * Retrieves the fields for the given entity based on action type,
      * taking into account access rights and configuration settings.

package/lib/v4/DataAccessor.js

@@ -15,6 +15,12 @@ export class DataAccessor {
         this.action = action;
         this.actionVerb = getTokenAction(this.action);
     }
+    getModelConfig(modelName) {
+        const entry = Object.entries(this.adminizer.config.models)
+            .find(([key]) => key.toLowerCase() === modelName.toLowerCase());
+        const config = entry ? entry[1] : undefined;
+        return isObject(config) ? config : undefined;
+    }
     /**
      * Retrieves the fields for the given entity based on action type,
      * taking into account access rights and configuration settings.
@@ -88,10 +94,13 @@ export class DataAccessor {
                     const model = this.adminizer.modelHandler.model.get(modelName);
                     if (model) {
                         populatedModelFieldsConfig = this.getAssociatedFieldsConfig(modelName);
-                        let _modelConfig = this.adminizer.config.models[modelName];
-                        if (!isObject(_modelConfig))
-                            throw `type error: model config  of ${modelName} is ${typeof (this.adminizer.config.models[modelName])} expected object`;
-                        associatedModelConfig = _modelConfig;
+                        const modelCfg = this.getModelConfig(modelName);
+                        if (modelCfg) {
+                            associatedModelConfig = modelCfg;
+                        }
+                        else {
+                            Adminizer.log.error(`DataAccessor > getFieldsConfig > Model config not found: ${modelName}`);
+                        }
                     }
                     else {
                         Adminizer.log.error(`DataAccessor > getFieldsConfig > Model not found: ${modelName} when ${key}`);
@@ -112,7 +121,8 @@ export class DataAccessor {
     }
     getAssociatedFieldsConfig(modelName) {
         const model = this.adminizer.modelHandler.model.get(modelName);
-        if (!model || !this.adminizer.config.models[modelName] || typeof this.adminizer.config.models[modelName] === "boolean") {
+        const modelConfig = this.getModelConfig(modelName);
+        if (!model || !modelConfig) {
             return undefined;
         }
         // Check if user has access to the associated model
@@ -122,9 +132,6 @@ export class DataAccessor {
             return undefined;
         }
         const associatedFields = {};
-        const modelConfig = this.adminizer.config.models[modelName];
-        if (!isObject(modelConfig))
-            throw `Type error ModelConfig should is object`;
         // Get the main fields configuration
         const fieldsConfig = modelConfig.fields || {};
         // Merge action-specific fields configuration if it exists

package/lib/v4/model/adapter/sequelize.js

@@ -27,14 +27,23 @@ function generateAssociationsFromSchema(models, schemas) {
                 }
                 // 💡 O:M связь (один ко многим)
                 else {
+                    let foreignKey = `${modelName}Id`;
+                    if (field.collection === modelName) {
+                        foreignKey = `${field.via}Id`;
+                    }
                     model.hasMany(targetModel, {
                         as: fieldName,
-                        foreignKey: `${modelName}Id`,
-                    });
-                    targetModel.belongsTo(model, {
-                        as: field.via,
-                        foreignKey: `${modelName}Id`,
+                        foreignKey,
                     });
+                    const alias = field.via;
+                    const belongsToOptions = { foreignKey };
+                    if (targetModel.rawAttributes[alias] || targetModel.associations[alias]) {
+                        belongsToOptions.as = `${alias}Ref`;
+                    }
+                    else {
+                        belongsToOptions.as = alias;
+                    }
+                    targetModel.belongsTo(model, belongsToOptions);
                 }
             }
             // 💡 O:1 или 1:1 (belongsTo)
@@ -42,21 +51,18 @@ function generateAssociationsFromSchema(models, schemas) {
                 const targetModel = models[field.model];
                 if (!targetModel)
                     continue;
-                // Avoid naming collision by making FK explicit: `${fieldName}Id`
-                const foreignKey = `${fieldName}Id`;
+                // Avoid naming collisions by using an explicit foreign key
                 const alias = fieldName;
-                // Если поле уже существует — избегаем конфликта
-                if (model.rawAttributes[alias]) {
-                    model.belongsTo(targetModel, {
-                        as: alias,
-                        foreignKey,
-                    });
-                }
-                else {
-                    model.belongsTo(targetModel, {
-                        foreignKey: alias, // если нет конфликта, можно использовать alias как FK
-                    });
+                const foreignKey = `${alias}Id`;
+                // Reuse the attribute name unless it already exists on the model or association
+                let asName = alias;
+                if (model.rawAttributes[alias] || model.associations[alias]) {
+                    asName = `${alias}Ref`;
                 }
+                model.belongsTo(targetModel, {
+                    as: asName,
+                    foreignKey,
+                });
             }
         }
     }
@@ -152,8 +158,7 @@ export class SequelizeModel extends AbstractModel {
         for (const key in criteria) {
             const value = criteria[key];
             if (value === undefined ||
-                value === null ||
-                (typeof value === "object" && Object.keys(value).length === 0)) {
+                (typeof value === "object" && value !== null && Object.keys(value).length === 0)) {
                 continue;
             }
             // 🧠 Заменяем ключ на `via`, если это ассоциация
@@ -162,22 +167,36 @@ export class SequelizeModel extends AbstractModel {
             if (attr?.type === "association" && attr.via) {
                 targetKey = attr.via;
             }
-            if (typeof value === "object" && !Array.isArray(value)) {
+            if (value === null) {
+                result[targetKey] = { [Op.is]: null };
+            }
+            else if (typeof value === "object" && !Array.isArray(value)) {
                 const operatorEntries = Object.entries(value)
                     .filter(([_, v]) => v !== undefined && v !== null)
                     .map(([op, val]) => {
                     switch (op) {
-                        case "contains": return [Op.like, `%${val}%`];
-                        case "startsWith": return [Op.startsWith, val];
-                        case "endsWith": return [Op.endsWith, val];
-                        case ">": return [Op.gt, val];
-                        case ">=": return [Op.gte, val];
-                        case "<": return [Op.lt, val];
-                        case "<=": return [Op.lte, val];
-                        case "!=": return [Op.ne, val];
-                        case "in": return [Op.in, val];
-                        case "nin": return [Op.notIn, val];
-                        default: return [Op.eq, val];
+                        case "contains":
+                            return [Op.like, `%${val}%`];
+                        case "startsWith":
+                            return [Op.startsWith, val];
+                        case "endsWith":
+                            return [Op.endsWith, val];
+                        case ">":
+                            return [Op.gt, val];
+                        case ">=":
+                            return [Op.gte, val];
+                        case "<":
+                            return [Op.lt, val];
+                        case "<=":
+                            return [Op.lte, val];
+                        case "!=":
+                            return [Op.ne, val];
+                        case "in":
+                            return [Op.in, val];
+                        case "nin":
+                            return [Op.notIn, val];
+                        default:
+                            return [Op.eq, val];
                     }
                 });
                 if (operatorEntries.length > 0) {
@@ -354,7 +373,7 @@ export class SequelizeModel extends AbstractModel {
             include: includes
         });
         for (const inst of instances) {
-            //For each association, we call getxxx () once again    
+            //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;
@@ -530,7 +549,10 @@ export class SequelizeAdapter extends AbstractAdapter {
     }
     /**Registration of system models*/
     static async registerSystemModels(sequelize) {
-        const modelsDir = path.resolve(import.meta.dirname, "../../../../models");
+        let modelsDir = path.resolve(import.meta.dirname, "../../../../models");
+        if (!fs.existsSync(modelsDir)) {
+            modelsDir = path.resolve(import.meta.dirname, "../../../../src/models");
+        }
         let files = fs.readdirSync(modelsDir).filter(f => f.endsWith(".js"));
         if (!files.length) {
             files = fs.readdirSync(modelsDir).filter(f => f.endsWith(".ts") && !f.endsWith(".d.ts"));

package/lib/v4/model/adapter/waterline.js

@@ -78,10 +78,14 @@ export class WaterlineAdapter extends AbstractAdapter {
         return this.orm.ontology.collections;
     }
     getModel(modelName) {
-        return this.orm.ontology.collections[modelName];
+        const matchedKey = Object.keys(this.orm.ontology.collections).find(key => key.toLowerCase() === modelName.toLowerCase());
+        if (!matchedKey) {
+            return undefined;
+        }
+        return this.orm.ontology.collections[matchedKey];
     }
     getAttributes(modelName) {
-        const model = this.orm.ontology.collections[modelName];
+        const model = this.getModel(modelName);
         if (!model) {
             throw new Error(`Model "${modelName}" was not found`);
         }
@@ -89,7 +93,10 @@ export class WaterlineAdapter extends AbstractAdapter {
     }
     /** Method that processes custom waterline model creation. Is used for system models. Replaces beforeCreate method in waterline */
     static async registerSystemModels(waterlineORM) {
-        const systemModelsDir = path.resolve(import.meta.dirname, "../../../../models");
+        let systemModelsDir = path.resolve(import.meta.dirname, "../../../../models");
+        if (!fs.existsSync(systemModelsDir)) {
+            systemModelsDir = path.resolve(import.meta.dirname, "../../../../src/models");
+        }
         let systemModelsFiles = fs.readdirSync(systemModelsDir).filter(file => file.endsWith(".js"));
         if (!systemModelsFiles.length) {
             systemModelsFiles = fs.readdirSync(systemModelsDir).filter(file => file.endsWith(".ts") && !file.endsWith(".d.ts"));
@@ -99,11 +106,12 @@ export class WaterlineAdapter extends AbstractAdapter {
             const modelName = path.basename(file).replace(/\.(ts|js)$/, "");
             const systemModelPath = path.resolve(systemModelsDir, file);
             const adminizerModel = (await import(pathToFileURL(systemModelPath).href)).default;
-            const waterlineLikeModel = generateWaterlineModel(modelName, adminizerModel);
+            const waterlineLikeModel = generateWaterlineModel(modelName, structuredClone(adminizerModel));
             // Register model in Waterline ORM
             waterlineORM.registerModel(waterlineLikeModel);
         }));
         function generateWaterlineModel(modelName, attributes) {
+            attributes = JSON.parse(JSON.stringify(attributes));
             const primaryKey = Object.keys(attributes).find(fieldName => attributes[fieldName]?.primaryKey === true);
             if (!primaryKey) {
                 throw new Error(`Model "${modelName}" must have a primary key.`);

package/lib/v4/widgets/abstractCustom.d.ts

@@ -1,4 +1,4 @@
-import { MaterialIcon } from "material-icons";
+import { MaterialIcon } from "../../../interfaces/MaaterialIcons";
 export default abstract class CustomBase {
     /** Widget unique id */
     abstract readonly id: string;

package/models/MediaManagerAP.d.ts

@@ -0,0 +1,62 @@
+import { MediaManagerAssociationsAP } from "./MediaManagerAssociationsAP";
+import { MediaManagerMetaAP } from "./MediaManagerMetaAP";
+declare const _default: {
+    id: {
+        type: string;
+        allowNull: boolean;
+        uuid: boolean;
+        primaryKey: boolean;
+        required: boolean;
+    };
+    parent: {
+        model: string;
+    };
+    variants: {
+        collection: string;
+        via: string;
+    };
+    mimeType: {
+        type: string;
+    };
+    path: {
+        type: string;
+    };
+    size: {
+        type: string;
+    };
+    group: {
+        type: string;
+    };
+    tag: {
+        type: string;
+    };
+    url: {
+        type: string;
+    };
+    filename: {
+        type: string;
+    };
+    meta: {
+        collection: string;
+        via: string;
+    };
+    modelAssociation: {
+        collection: string;
+        via: string;
+    };
+};
+export default _default;
+export interface MediaManagerAP {
+    id: string;
+    parent?: MediaManagerAP;
+    variants?: MediaManagerAP[];
+    mimeType?: string;
+    path?: string;
+    size?: number;
+    group?: string;
+    tag?: string;
+    url?: string;
+    filename?: string;
+    meta?: MediaManagerMetaAP[];
+    modelAssociation?: MediaManagerAssociationsAP[];
+}

package/models/MediaManagerAP.js

@@ -0,0 +1,45 @@
+export default {
+    id: {
+        type: "string",
+        allowNull: false,
+        uuid: true,
+        primaryKey: true,
+        required: true
+    },
+    parent: {
+        model: "MediaManagerAP"
+    },
+    variants: {
+        collection: "MediaManagerAP",
+        via: "parent"
+    },
+    mimeType: {
+        type: "string"
+    },
+    path: {
+        type: "string"
+    },
+    size: {
+        type: "number"
+    },
+    group: {
+        type: "string"
+    },
+    tag: {
+        type: "string"
+    },
+    url: {
+        type: "string"
+    },
+    filename: {
+        type: "string"
+    },
+    meta: {
+        collection: "MediaManagerMetaAP",
+        via: "parent"
+    },
+    modelAssociation: {
+        collection: "MediaManagerAssociationsAP",
+        via: "file"
+    }
+};

package/models/MediaManagerAssociationsAP.d.ts

@@ -0,0 +1,38 @@
+import { MediaManagerAP } from "./MediaManagerAP";
+declare const _default: {
+    id: {
+        type: string;
+        allowNull: boolean;
+        uuid: boolean;
+        primaryKey: boolean;
+        required: boolean;
+    };
+    mediaManagerId: {
+        type: string;
+    };
+    model: {
+        type: string;
+    };
+    modelId: {
+        type: string;
+    };
+    widgetName: {
+        type: string;
+    };
+    sortOrder: {
+        type: string;
+    };
+    file: {
+        model: string;
+    };
+};
+export default _default;
+export interface MediaManagerAssociationsAP {
+    id: string;
+    mediaManagerId?: string;
+    model?: Record<string, unknown>;
+    modelId?: Record<string, unknown>;
+    widgetName?: string;
+    sortOrder?: number;
+    file?: MediaManagerAP;
+}

package/models/MediaManagerAssociationsAP.js

@@ -0,0 +1,27 @@
+export default {
+    id: {
+        type: "string",
+        allowNull: false,
+        uuid: true,
+        primaryKey: true,
+        required: true
+    },
+    mediaManagerId: {
+        type: "string"
+    },
+    model: {
+        type: "json"
+    },
+    modelId: {
+        type: "json"
+    },
+    widgetName: {
+        type: "string"
+    },
+    sortOrder: {
+        type: "number"
+    },
+    file: {
+        model: "MediaManagerAP"
+    }
+};

package/models/MediaManagerMetaAP.d.ts

@@ -0,0 +1,30 @@
+import { MediaManagerAP } from "./MediaManagerAP";
+declare const _default: {
+    id: {
+        type: string;
+        allowNull: boolean;
+        uuid: boolean;
+        primaryKey: boolean;
+        required: boolean;
+    };
+    key: {
+        type: string;
+    };
+    value: {
+        type: string;
+    };
+    isPublic: {
+        type: string;
+    };
+    parent: {
+        model: string;
+    };
+};
+export default _default;
+export interface MediaManagerMetaAP {
+    id: string;
+    key?: string;
+    value?: Record<string, unknown>;
+    isPublic?: boolean;
+    parent?: MediaManagerAP;
+}

package/models/MediaManagerMetaAP.js

@@ -0,0 +1,21 @@
+export default {
+    id: {
+        type: "string",
+        allowNull: false,
+        uuid: true,
+        primaryKey: true,
+        required: true
+    },
+    key: {
+        type: "string"
+    },
+    value: {
+        type: "json"
+    },
+    isPublic: {
+        type: "boolean"
+    },
+    parent: {
+        model: "MediaManagerAP"
+    }
+};

package/package.json

@@ -1,17 +1,20 @@
 {
   "name": "adminizer",
   "type": "module",
-  "version": "4.2.0-build.50",
+  "version": "4.2.0-build.52",
   "main": "index.js",
   "exports": {
     ".": "./index.js",
     "./ui/*": "./dist/ui/components/ui/*.js"
   },
   "scripts": {
-    "test": "vitest --reporter verbose",
+    "test": "vitest --watch=false",
+    "test:watch": "vitest --reporter verbose",
     "start": "cross-env NO_SEED_DATA=true ORM=sequelize tsx --tsconfig ./fixture/tsconfig.json ./fixture/index.ts",
-    "dev": "cross-env VITE_ENV=dev tsx watch --tsconfig ./fixture/tsconfig.json ./fixture/index.ts",
-    "dev:sequelize": "cross-env VITE_ENV=dev NO_SEED_DATA=true ORM=sequelize tsx watch --tsconfig ./fixture/tsconfig.json ./fixture/index.ts",
+    "dev": "cross-env VITE_ENV=dev ORM=sequelize tsx watch --tsconfig ./fixture/tsconfig.json ./fixture/index.ts",
+    "dev:no-seed": "cross-env VITE_ENV=dev NO_SEED_DATA=true ORM=sequelize tsx watch --tsconfig ./fixture/tsconfig.json ./fixture/index.ts",
+    "dev:no-seed-clean": "cross-env VITE_ENV=dev NO_SEED_DATA=true CLEAN_TMP=true ORM=sequelize tsx watch --tsconfig ./fixture/tsconfig.json ./fixture/index.ts",
+    "dev:waterline": "cross-env VITE_ENV=dev ORM=waterline tsx watch --tsconfig ./fixture/tsconfig.json ./fixture/index.ts",
     "build:assets": "vite build",
     "compile:backend": "tsc -p src/tsconfig.json",
     "compile:ui": "tsc -p tsconfig.ui.json",
@@ -35,6 +38,7 @@
   "dependencies": {
     "@minoru/react-dnd-treeview": "^3.5.2",
     "@radix-ui/react-context-menu": "^2.2.15",
+    "@radix-ui/react-tabs": "^1.1.12",
     "body-parser": "^1.20.3",
     "chalk": "^5.4.1",
     "cmdk": "^1.1.1",
@@ -46,10 +50,13 @@
     "express": "^4.21.2",
     "express-session": "^1.18.1",
     "jsonwebtoken": "^9.0.2",
+    "material-icons": "^1.13.14",
     "multer": "^1.4.5-lts.1",
     "next-themes": "^0.4.6",
     "password-hash": "^1.2.2",
+    "react-cropper": "^2.3.3",
     "react-dnd": "^16.0.1",
+    "reflect-metadata": "^0.2.2",
     "sharp": "^0.33.5",
     "typeorm": "^0.3.20",
     "uuid": "^11.0.5",
@@ -59,6 +66,8 @@
   "devDependencies": {
     "@babel/plugin-proposal-decorators": "^7.27.1",
     "@ckeditor/ckeditor5-react": "^9.5.0",
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/sortable": "^10.0.0",
     "@eslint/compat": "^1.2.9",
     "@faker-js/faker": "^9.7.0",
     "@handsontable/react": "^15.2.0",
@@ -110,13 +119,13 @@
     "cross-env": "^7.0.3",
     "eslint": "^9.26.0",
     "handsontable": "^15.2.0",
+    "image-size": "^2.0.2",
     "isomorphic-webcrypto": "^2.3.8",
     "json-schema": "^0.4.0",
     "leaflet": "^1.9.4",
     "leaflet-draw": "^1.0.4",
     "lodash-es": "^4.17.21",
     "lucide-react": "^0.485.0",
-    "material-icons": "^1.13.14",
     "react": "^19.0.0",
     "react-day-picker": "^8.10.1",
     "react-dom": "^19.0.0",

package/system/Router.js

@@ -76,8 +76,10 @@ export default class Router {
         /**
          * Media Manager
          */
-        adminizer.app.all(`/media-manager-uploader/:id`, adminizer.policyManager.bindPolicies(policies, mediaManagerController));
-        adminizer.app.all(`/get-thumbs`, adminizer.policyManager.bindPolicies(policies, thumbController));
+        adminizer.app.post(`${adminizer.config.routePrefix}/media-manager-uploader/:id/upload`, adminizer.policyManager.bindPolicies(policies, mediaManagerController));
+        adminizer.app.post(`${adminizer.config.routePrefix}/media-manager-uploader/:id/upload-variant`, adminizer.policyManager.bindPolicies(policies, mediaManagerController));
+        adminizer.app.all(`${adminizer.config.routePrefix}/media-manager-uploader/:id`, adminizer.policyManager.bindPolicies(policies, mediaManagerController));
+        adminizer.app.all(`${adminizer.config.routePrefix}/get-thumbs`, adminizer.policyManager.bindPolicies(policies, thumbController));
         /**
          * List of records
          */

package/system/bindExpressUtils.js

@@ -14,7 +14,7 @@ export default function bindExpressUtils(app) {
         },
     }));
     /** Bind multer (important: before body-parser) */
-    app.use(upload.none()); // Processes form-data without files
+    // app.use(upload.none()); // Processes form-data without files
     /** Bind body-parser */
     app.use(bodyParser.urlencoded({ extended: true })); // To process application/x-www-form-urlencoded
     app.use(bodyParser.json()); // To process JSON

package/system/bindMediaManager.d.ts

@@ -0,0 +1,2 @@
+import { Adminizer } from "../lib/Adminizer";
+export default function bindMediaManager(adminizer: Adminizer): void;

package/system/bindMediaManager.js

@@ -1,20 +1,19 @@
-"use strict";
-// import { DefaultMediaManager } from "../lib/media-manager/DefaultMediaManager";
-// import { MediaManagerHandler } from "../lib/media-manager/MediaManagerHandler";
-// import {Adminizer} from "../lib/Adminizer";
-//
-// export default function bindMediaManager(adminizer: Adminizer) {
-// 	adminizer.emitter.on("orm:loaded", async () => {
-// 		try {
-// 			// TODO paths problem, default media manager path should be get by config
-// 			let mediaManager = new DefaultMediaManager(
-// 				adminizer,
-// 				'default',
-// 				'media-manager',
-// 				`${process.cwd()}/.tmp/public/media-manager/`)
-//
-// 			MediaManagerHandler.add(mediaManager)
-// 		} catch (e) {
-// 		}
-// 	})
-// }
+import { DefaultMediaManager } from "../lib/media-manager/DefaultMediaManager";
+import { MediaManagerHandler } from "../lib/media-manager/MediaManagerHandler";
+import serveStatic from "serve-static";
+import path from "path";
+export default function bindMediaManager(adminizer) {
+    adminizer.emitter.on("adminizer:loaded", async () => {
+        try {
+            let mediaManager = new DefaultMediaManager(adminizer, 'default', 'media-manager', adminizer.config.mediamanager.fileStoragePath);
+            MediaManagerHandler.add(mediaManager);
+        }
+        catch (e) {
+            console.log(e);
+        }
+    });
+    // Bind media manager public folder
+    adminizer.app.use(`/public`, serveStatic(adminizer.config.mediamanager.fileStoragePath));
+    // Bind file icons
+    adminizer.app.use(`${adminizer.config.routePrefix}/fileicons`, serveStatic(path.join(import.meta.dirname, '../fileicons')));
+}