adminizer 4.3.0-build.118 → 4.3.0-build.120

package/controllers/catalog/Catalog.js

@@ -1,4 +1,4 @@
-import { VueCatalog } from "./FrontentCatalogAdapter";
+import { FrontendCatalog, FrontendCatalogUtils } from "./FrontendCatalogAdapter";
 import { Adminizer } from "../../lib/Adminizer";
 export async function catalogController(req, res) {
     const slug = req.params.slug;
@@ -34,7 +34,7 @@ export async function catalogController(req, res) {
     }
     if (method === 'POST' || method === 'PUT' || method === 'DELETE') {
         const data = req.body;
-        const frontendCatalog = new VueCatalog(_catalog);
+        const frontendCatalog = new FrontendCatalog(_catalog);
         if (!frontendCatalog)
             return res.status(404);
         frontendCatalog.setId(id);
@@ -46,24 +46,24 @@ export async function catalogController(req, res) {
                         return res.json(await frontendCatalog.getAddTemplate(item, req));
                     case 'getEditTemplate':
                         return res.json(await frontendCatalog.getEditTemplate(item, data.id, req, data.modelId));
-                    case 'getCatalog':
-                        {
-                            const __catalog = await frontendCatalog.getCatalog();
-                            return res.json({
-                                items: frontendCatalog.getitemTypes(),
-                                catalog: {
-                                    nodes: __catalog,
-                                    movingGroupsRootOnly: _catalog.movingGroupsRootOnly ?? false,
-                                    catalogName: _catalog.name,
-                                    catalogId: _catalog.id,
-                                    catalogSlug: _catalog.slug,
-                                    idList: idList
-                                },
-                                toolsActions: await frontendCatalog.getActions([], 'tools')
-                            });
-                        }
+                    case 'getCatalog': {
+                        const __catalog = await frontendCatalog.getCatalog();
+                        return res.json({
+                            items: frontendCatalog.getitemTypes(),
+                            catalog: {
+                                nodes: __catalog,
+                                movingGroupsRootOnly: _catalog.movingGroupsRootOnly ?? false,
+                                catalogName: _catalog.name,
+                                catalogId: _catalog.id,
+                                catalogSlug: _catalog.slug,
+                                idList: idList
+                            },
+                            toolsActions: await frontendCatalog.getActions([], 'tools')
+                        });
+                    }
                     case 'createItem':
-                        return res.json({ 'data': await frontendCatalog.createItem(data.data, req) });
+                        const createdItem = await frontendCatalog.createItem(data.data, req);
+                        return res.json({ 'data': FrontendCatalogUtils.normalizeForFrontend(createdItem) });
                     case 'getChilds':
                         return res.json({ data: await frontendCatalog.getChilds(data.data, req) });
                     case 'getActions':
@@ -85,7 +85,8 @@ export async function catalogController(req, res) {
                     case 'getPopUpTemplate':
                         return res.json({ data: await frontendCatalog.getPopUpTemplate(data.actionId, req) });
                     case 'updateItem':
-                        return res.json({ data: await frontendCatalog.updateItem(item, data.modelId, data.data, req) });
+                        const updatedItem = await frontendCatalog.updateItem(item, data.modelId, data.data, req);
+                        return res.json({ data: FrontendCatalogUtils.normalizeForFrontend(updatedItem) });
                 }
                 break;
             case 'DELETE':

package/controllers/catalog/FrontendCatalogAdapter.d.ts

@@ -0,0 +1,82 @@
+import { AbstractCatalog, Item } from "../../lib/catalog/AbstractCatalog";
+interface NodeModel<TDataType> {
+    text: string;
+    droppable: boolean;
+    id: string;
+    parent: number;
+    data?: TDataType;
+    children?: NodeModel<TDataType>[];
+    isSelected?: boolean;
+    isVisible?: boolean;
+    isDraggable?: boolean;
+    isSelectable?: boolean;
+    path?: number[];
+    pathStr?: string;
+    level?: number;
+    isFirstChild?: boolean;
+    isLastChild?: boolean;
+}
+interface NodeData extends Item {
+}
+interface RequestData {
+    reqNode: NodeModel<NodeData>[];
+    reqParent: NodeModel<NodeData>;
+    _method: string;
+}
+/**
+ * @deprecated Now is React
+ * // TODO: refactor for react name
+ */
+export declare class FrontendCatalog {
+    catalog: AbstractCatalog;
+    constructor(_catalog: AbstractCatalog);
+    setId(id: string): void;
+    getItemType(type: string): import("../../lib/catalog/AbstractCatalog").BaseItem<Item>;
+    getAddTemplate(item: any, req: ReqType): Promise<{
+        type: "component" | "navigation.group" | "navigation.link" | "model";
+        data: any;
+    }>;
+    getEditTemplate(item: any, id: string | number, req: ReqType, modelId: string | number): Promise<{
+        type: "component" | "navigation.group" | "navigation.link" | "model";
+        data: any;
+    }>;
+    getitemTypes(): {
+        type: string;
+        name: string;
+        isGroup: boolean;
+        allowedRoot: boolean;
+        icon: string;
+        actionHandlers: import("../../lib/catalog/AbstractCatalog").ActionHandler[];
+    }[];
+    getLocales(req: ReqType): {
+        [key: string]: string;
+    };
+    getActions(items: NodeModel<any>[], type: string): Promise<import("../../lib/catalog/AbstractCatalog").ActionHandler[]>;
+    handleAction(actionId: string, items: any[], data: any, req: ReqType): Promise<string | void>;
+    getPopUpTemplate(actionId: string, req: ReqType): Promise<string>;
+    getLink(actionId: string): Promise<string>;
+    getCatalog(): Promise<NodeModel<Item>[]>;
+    createItem(data: any, req: ReqType): Promise<any>;
+    getChilds(data: any, req: ReqType): Promise<NodeModel<Item>[]>;
+    search(s: string, req: ReqType): Promise<NodeModel<Item>[]>;
+    updateTree(data: RequestData, req: ReqType): Promise<any>;
+    updateItem(item: any, modelId: string, data: any, req: ReqType): Promise<any>;
+    deleteItem(item: Item, req: ReqType): Promise<{
+        ok: boolean;
+    }>;
+}
+export declare class FrontendCatalogUtils {
+    /**
+     * Removes unnecessary data from the front
+     */
+    static refinement<T extends NodeModel<any>>(nodeModel: T): any;
+    /**
+     * Normalizes data for frontend: replaces null parentId with 0
+     */
+    static normalizeForFrontend<T extends Item>(item: T): T;
+    static arrayToNode<T extends Item>(items: T[], groupTypeName: string): NodeModel<T>[];
+    static toNode<T extends NodeData>(data: T, groupTypeName: string): NodeModel<T>;
+    static expandTo<T extends NodeData>(frontendCatalogData: NodeModel<T>, theseItemIdsNeedToBeOpened: (string | number)[]): NodeModel<T>;
+    static treeToNode(tree: Item[], groupTypeName: string): NodeModel<Item>[];
+}
+export {};

package/controllers/catalog/FrontendCatalogAdapter.js

@@ -0,0 +1,228 @@
+/**
+ * @deprecated Now is React
+ * // TODO: refactor for react name
+ */
+export class FrontendCatalog {
+    catalog;
+    constructor(_catalog) {
+        this.catalog = _catalog;
+    }
+    setId(id) {
+        this.catalog.setId(id);
+    }
+    getItemType(type) {
+        return this.catalog.getItemType(type);
+    }
+    getAddTemplate(item, req) {
+        return this.catalog.getAddTemplate(item, req);
+    }
+    getEditTemplate(item, id, req, modelId) {
+        return this.catalog.getEditTemplate(item, id, req, modelId);
+    }
+    getitemTypes() {
+        return this.catalog.getitemTypes();
+    }
+    getLocales(req) {
+        let obj = {
+            "Delete": "",
+            "Edit": "",
+            "create": "",
+            "Search": "",
+            "Select Item type": "",
+            "Select Items": "",
+            "Save": "",
+            "No": "",
+            "Are you sure?": "",
+            "Yes": "",
+            "Select Ids": "",
+            "OR": "",
+            "Open in a new window": "",
+            "Visible": "",
+            "Clean": "",
+            "Performing an action...": "",
+            "Action completed": "",
+        };
+        obj[this.catalog.name] = "";
+        for (const actionHandler of this.catalog.actionHandlers) {
+            obj[actionHandler.name] = "";
+        }
+        let messages = obj;
+        let outMessages = {};
+        for (const mess of Object.keys(messages)) {
+            outMessages[mess] = req.i18n.__(mess);
+        }
+        return {
+            ...outMessages,
+        };
+    }
+    async getActions(items, type) {
+        let arrItems = [];
+        for (const item of items) {
+            if (item.data.id === 0)
+                item.data.id = null;
+            arrItems.push(await this.catalog.find(item.data));
+        }
+        console.log(arrItems);
+        if (type === 'tools') {
+            return (await this.catalog.getActions(arrItems))?.filter(e => e.displayTool);
+        }
+        else {
+            return (await this.catalog.getActions(arrItems))?.filter(e => e.displayContext);
+        }
+    }
+    async handleAction(actionId, items, data, req) {
+        let arrItems = [];
+        for (const item of items) {
+            if (item.data.id === 0)
+                item.data.id = null;
+            arrItems.push(await this.catalog.find(item.data));
+        }
+        console.log(arrItems);
+        return this.catalog.handleAction(actionId, arrItems, data, req);
+    }
+    async getPopUpTemplate(actionId, req) {
+        return this.catalog.getPopUpTemplate(actionId, req);
+    }
+    async getLink(actionId) {
+        return this.catalog.getLink(actionId);
+    }
+    //Below are the methods that require action
+    async getCatalog() {
+        let rootItems = await this.catalog.getChilds(null);
+        return FrontendCatalogUtils.arrayToNode(rootItems, this.catalog.getGroupType().type);
+    }
+    async createItem(data, req) {
+        // TODO It's not clear why it's here.
+        //data = VueCatalogUtils.refinement(data);
+        // if (this.catalog.slug !== "navigation") {
+        //     let item = data.record;
+        //     item.parenId = data.parenId;
+        //     return await this.catalog.createItem(item, req);
+        // } else {
+        if (data.parentId === 0)
+            data.parentId = null;
+        return await this.catalog.createItem(data, req);
+        // }
+    }
+    async getChilds(data, req) {
+        data = FrontendCatalogUtils.refinement(data);
+        if (!data || data.id === 0 || data.id === undefined) {
+            data = { id: null };
+        }
+        if (data.id === 0)
+            data.id = null;
+        return FrontendCatalogUtils.arrayToNode(await this.catalog.getChilds(data.id, undefined, req), this.catalog.getGroupType().type);
+    }
+    // Moved into actions
+    // getCreatedItems(data: any) {
+    //   data = VueCatalogUtils.refinement(data);
+    //   return this.catalog.getChilds(data.id);
+    // }
+    async search(s, req) {
+        let searchResult = await this.catalog.search(s, undefined, req);
+        // let itemsTree = AbstractCatalog.buildTree(searchResult);
+        // console.log(itemsTree)
+        return FrontendCatalogUtils.treeToNode(searchResult, this.catalog.getGroupType().type);
+    }
+    async updateTree(data, req) {
+        // console.dir(data, {depth: null})
+        // return
+        let reqParent = data.reqParent;
+        if (reqParent.data.id === 0)
+            reqParent.data.id = null;
+        // Update all items into parent (for two reason: update parent, updare sorting order)
+        let sortCount = 0;
+        for (const childNode of reqParent.children) {
+            childNode.data.sortOrder = sortCount;
+            childNode.data.parentId = reqParent.data.id;
+            if (childNode.data.id === 0)
+                childNode.data.id = null;
+            await this.catalog.updateItem(childNode.data.id, childNode.data.type, childNode.data, req);
+            sortCount++;
+        }
+        return Promise.resolve('ok');
+    }
+    async updateItem(item, modelId, data, req) {
+        //TODO It's not clear why it's here.
+        //data = VueCatalogUtils.refinement(data);
+        // if (this.catalog.slug !== "navigation") {
+        //     return await this.catalog.updateModelItems(data.modelId, data.type, data.record, req);
+        // } else {
+        let normalizedModelId = modelId;
+        if (normalizedModelId === '0')
+            normalizedModelId = null;
+        return await this.catalog.updateModelItems(normalizedModelId, item.type, data, req);
+        // }
+    }
+    async deleteItem(item, req) {
+        if (item.id === 0)
+            item.id = null;
+        // Получаем всех непосредственных потомков текущего элемента
+        const children = await this.catalog.getChilds(item.id, undefined, req);
+        // Рекурсивно удаляем всех потомков
+        for (const child of children) {
+            await this.deleteItem(child, req);
+        }
+        // После удаления всех потомков удаляем сам элемент
+        await this.catalog.deleteItem(item.type, item.id, req);
+        return { ok: true };
+    }
+}
+export class FrontendCatalogUtils {
+    /**
+     * Removes unnecessary data from the front
+     */
+    static refinement(nodeModel) {
+        return nodeModel.data;
+    }
+    /**
+     * Normalizes data for frontend: replaces null parentId with 0
+     */
+    static normalizeForFrontend(item) {
+        return { ...item, parentId: item.parentId === null ? 0 : item.parentId };
+    }
+    static arrayToNode(items, groupTypeName) {
+        return items.map(node => FrontendCatalogUtils.toNode(node, groupTypeName));
+    }
+    static toNode(data, groupTypeName) {
+        const normalizedData = FrontendCatalogUtils.normalizeForFrontend(data);
+        return {
+            data: normalizedData,
+            droppable: data.type === groupTypeName,
+            id: data.id,
+            text: data.name,
+            parent: (data.parentId === null ? 0 : data.parentId),
+        };
+    }
+    static expandTo(frontendCatalogData, theseItemIdsNeedToBeOpened) {
+        function expand(node) {
+            if (theseItemIdsNeedToBeOpened.includes(node.data.id)) {
+                // node.isExpanded = true;
+            }
+            if (node.children) {
+                for (const child of node.children) {
+                    expand(child);
+                }
+            }
+        }
+        theseItemIdsNeedToBeOpened.forEach(id => {
+            expand(frontendCatalogData);
+        });
+        return frontendCatalogData;
+    }
+    static treeToNode(tree, groupTypeName) {
+        function buildNodes(items) {
+            return items.map(item => {
+                const node = FrontendCatalogUtils.toNode(item, groupTypeName);
+                if (item.childs && item.childs.length > 0) {
+                    // Sort the children before building their nodes
+                    item.childs.sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0));
+                    node.children = buildNodes(item.childs);
+                    // node.isExpanded = !node.droppable;
+                }
+                return node;
+            });
+        }
+        return buildNodes(tree);
+    }
+}

package/controllers/catalog/FrontentCatalogAdapter.d.ts

@@ -27,7 +27,7 @@ interface RequestData {
  * @deprecated Now is React
  * // TODO: refactor for react name
  */
-export declare class VueCatalog {
+export declare class FrontendCatalog {
     catalog: AbstractCatalog;
     constructor(_catalog: AbstractCatalog);
     setId(id: string): void;
@@ -65,7 +65,7 @@ export declare class VueCatalog {
         ok: boolean;
     }>;
 }
-export declare class VueCatalogUtils {
+export declare class FrontendCatalogUtils {
     /**
      * Removes unnecessary data from the front
      */

package/controllers/catalog/FrontentCatalogAdapter.js

@@ -2,7 +2,7 @@
  * @deprecated Now is React
  * // TODO: refactor for react name
  */
-export class VueCatalog {
+export class FrontendCatalog {
     catalog;
     constructor(_catalog) {
         this.catalog = _catalog;
@@ -58,6 +58,8 @@ export class VueCatalog {
     async getActions(items, type) {
         let arrItems = [];
         for (const item of items) {
+            if (item.data.id === 0)
+                item.data.id = null;
             arrItems.push(await this.catalog.find(item.data));
         }
         console.log(arrItems);
@@ -71,6 +73,8 @@ export class VueCatalog {
     async handleAction(actionId, items, data, req) {
         let arrItems = [];
         for (const item of items) {
+            if (item.data.id === 0)
+                item.data.id = null;
             arrItems.push(await this.catalog.find(item.data));
         }
         console.log(arrItems);
@@ -84,8 +88,8 @@ export class VueCatalog {
     }
     //Below are the methods that require action
     async getCatalog() {
-        let rootItems = await this.catalog.getChilds(0);
-        return VueCatalogUtils.arrayToNode(rootItems, this.catalog.getGroupType().type);
+        let rootItems = await this.catalog.getChilds(null);
+        return FrontendCatalogUtils.arrayToNode(rootItems, this.catalog.getGroupType().type);
     }
     async createItem(data, req) {
         // TODO It's not clear why it's here.
@@ -95,12 +99,16 @@ export class VueCatalog {
         //     item.parenId = data.parenId;
         //     return await this.catalog.createItem(item, req);
         // } else {
+        if (data.parentId === 0)
+            data.parentId = null;
         return await this.catalog.createItem(data, req);
         // }
     }
     async getChilds(data, req) {
-        data = VueCatalogUtils.refinement(data);
-        return VueCatalogUtils.arrayToNode(await this.catalog.getChilds(data.id, undefined, req), this.catalog.getGroupType().type);
+        data = FrontendCatalogUtils.refinement(data);
+        if (data.id === 0)
+            data.id = null;
+        return FrontendCatalogUtils.arrayToNode(await this.catalog.getChilds(data.id, undefined, req), this.catalog.getGroupType().type);
     }
     // Moved into actions
     // getCreatedItems(data: any) {
@@ -111,17 +119,21 @@ export class VueCatalog {
         let searchResult = await this.catalog.search(s, undefined, req);
         // let itemsTree = AbstractCatalog.buildTree(searchResult);
         // console.log(itemsTree)
-        return VueCatalogUtils.treeToNode(searchResult, this.catalog.getGroupType().type);
+        return FrontendCatalogUtils.treeToNode(searchResult, this.catalog.getGroupType().type);
     }
     async updateTree(data, req) {
         // console.dir(data, {depth: null})
         // return
         let reqParent = data.reqParent;
+        if (reqParent.data.id === 0)
+            reqParent.data.id = null;
         // Update all items into parent (for two reason: update parent, updare sorting order)
         let sortCount = 0;
         for (const childNode of reqParent.children) {
             childNode.data.sortOrder = sortCount;
             childNode.data.parentId = reqParent.data.id;
+            if (childNode.data.id === 0)
+                childNode.data.id = null;
             await this.catalog.updateItem(childNode.data.id, childNode.data.type, childNode.data, req);
             sortCount++;
         }
@@ -133,10 +145,15 @@ export class VueCatalog {
         // if (this.catalog.slug !== "navigation") {
         //     return await this.catalog.updateModelItems(data.modelId, data.type, data.record, req);
         // } else {
-        return await this.catalog.updateModelItems(modelId, item.type, data, req);
+        let normalizedModelId = modelId;
+        if (normalizedModelId === '0')
+            normalizedModelId = null;
+        return await this.catalog.updateModelItems(normalizedModelId, item.type, data, req);
         // }
     }
     async deleteItem(item, req) {
+        if (item.id === 0)
+            item.id = null;
         // Получаем всех непосредственных потомков текущего элемента
         const children = await this.catalog.getChilds(item.id, undefined, req);
         // Рекурсивно удаляем всех потомков
@@ -148,7 +165,7 @@ export class VueCatalog {
         return { ok: true };
     }
 }
-export class VueCatalogUtils {
+export class FrontendCatalogUtils {
     /**
      * Removes unnecessary data from the front
      */
@@ -156,7 +173,7 @@ export class VueCatalogUtils {
         return nodeModel.data;
     }
     static arrayToNode(items, groupTypeName) {
-        return items.map(node => VueCatalogUtils.toNode(node, groupTypeName));
+        return items.map(node => FrontendCatalogUtils.toNode(node, groupTypeName));
     }
     static toNode(data, groupTypeName) {
         return {
@@ -186,7 +203,7 @@ export class VueCatalogUtils {
     static treeToNode(tree, groupTypeName) {
         function buildNodes(items) {
             return items.map(item => {
-                const node = VueCatalogUtils.toNode(item, groupTypeName);
+                const node = FrontendCatalogUtils.toNode(item, groupTypeName);
                 if (item.childs && item.childs.length > 0) {
                     // Sort the children before building their nodes
                     item.childs.sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0));

package/interfaces/adminpanelConfig.d.ts

@@ -457,7 +457,6 @@ export interface NavigationConfig {
     allowContentInGroup?: boolean;
     items: NavigationItemTypeConfig[];
     movingGroupsRootOnly?: boolean;
-    bindAfter: boolean;
 }
 export interface MediaManagerConfig {
     fileStoragePath: string;

package/lib/Adminizer.d.ts

@@ -15,6 +15,7 @@ import { CatalogHandler } from "./catalog/CatalogHandler";
 import { NotificationHandler } from './notifications/NotificationHandler';
 import { INotification } from "../interfaces/types";
 import { MediaManagerHandler } from "./media-manager/MediaManagerHandler";
+import { StorageServices } from "./catalog/Navigation";
 export declare class Adminizer {
     /**
      * If you convey this default Middleware, it will add it to the very top of the router,
@@ -36,6 +37,7 @@ export declare class Adminizer {
     controlsHandler: ControlsHandler;
     catalogHandler: CatalogHandler;
     mediaManagerHandler: MediaManagerHandler;
+    storageServices: StorageServices;
     jwtSecret: string;
     static logger: winston.Logger;
     constructor(ormAdapters: AbstractAdapter[]);

package/lib/Adminizer.js

@@ -54,6 +54,7 @@ export class Adminizer {
     controlsHandler;
     catalogHandler;
     mediaManagerHandler;
+    storageServices;
     // Constants
     jwtSecret = process.env.JWT_SECRET ?? uuid();
     static logger = winston.createLogger({
@@ -208,14 +209,7 @@ export class Adminizer {
             }
         }
         await bindDashboardWidgets(this);
-        if (this.config.navigation?.bindAfter) {
-            this._emitter.on('isSeeding', async () => {
-                await bindNavigation(this);
-            });
-        }
-        else {
-            await bindNavigation(this);
-        }
+        await bindNavigation(this);
         bindMediaManager(this);
         await bindAccessRights(this);
         if (I18n.appendLocale) {

package/lib/catalog/AbstractCatalog.d.ts

@@ -1,4 +1,5 @@
 import { Adminizer } from "../Adminizer";
+import { StorageServices } from "./Navigation";
 /**
  * Interface `Item` describes the data that the UI will operate on
  * This is a common interface for all data that is linked to the catalog
@@ -24,6 +25,7 @@ export type _Item_ = {
  * General Item structure that will be available for all elements, including groups
  */
 export declare abstract class BaseItem<T extends Item> {
+    storageServices?: StorageServices;
     abstract readonly type: string;
     /**
      * Used for infer T

package/lib/catalog/AbstractCatalog.js

@@ -2,6 +2,7 @@
  * General Item structure that will be available for all elements, including groups
  */
 export class BaseItem {
+    storageServices;
     /**
      * Array of all global contexts, which will appear for all elements
      */
@@ -253,7 +254,7 @@ export class AbstractCatalog {
      * Method for getting group elements
      */
     getitemTypes() {
-        return this.itemTypes.map(({ adminizer, ...rest }) => rest);
+        return this.itemTypes.map(({ adminizer, storageServices, ...rest }) => rest);
     }
     ;
     async search(s, hasExtras = true, req) {
@@ -268,7 +269,7 @@ export class AbstractCatalog {
                 const extras = await this.getChilds(item.id, undefined, req);
                 accumulator.push(...extras);
             }
-            if (item.parentId === 0)
+            if (item.parentId === null)
                 return item;
             const parentItem = await groupType._find(item.parentId, this.id);
             if (parentItem) {
@@ -284,7 +285,7 @@ export class AbstractCatalog {
             foundItems = foundItems.concat(items);
         }
         for (const item of foundItems) {
-            if (item.parentId !== 0) { // changed from null to 0
+            if (item.parentId !== null) { // changed from 0 to null
                 await buildTreeUpwards(item, hasExtras);
             }
         }
@@ -310,7 +311,7 @@ export class AbstractCatalog {
             itemMap[item.id] = item;
         });
         items.forEach(item => {
-            if (item.parentId === 0) { // changed from null to 0
+            if (item.parentId === null) {
                 tree.push(item);
             }
             else {

package/lib/catalog/Navigation.d.ts

@@ -1,7 +1,7 @@
 import { AbstractCatalog, ActionHandler, Item } from "./AbstractCatalog";
 import { NavigationConfig } from "../../interfaces/adminpanelConfig";
 import { Adminizer } from "../Adminizer";
-export interface NavItem extends Item {
+interface NavItem extends Item {
     urlPath?: string;
     modelId?: string | number;
     targetBlank?: boolean;
@@ -27,10 +27,11 @@ export declare class StorageService {
     search(s: string, type: string): Promise<NavItem[]>;
 }
 export declare class StorageServices {
-    protected static storages: StorageService[];
-    static add(storage: StorageService): void;
-    static get(id: string): StorageService;
-    static getAll(): StorageService[];
+    protected storages: StorageService[];
+    constructor();
+    add(storage: StorageService): void;
+    get(id: string): StorageService;
+    getAll(): StorageService[];
 }
 export declare class Navigation extends AbstractCatalog {
     readonly name: string;
@@ -38,6 +39,8 @@ export declare class Navigation extends AbstractCatalog {
     readonly icon: string;
     readonly actionHandlers: ActionHandler[];
     idList: string[];
+    storageServices: StorageServices;
     constructor(adminizer: Adminizer, config: NavigationConfig);
     getIdList(): Promise<string[]>;
 }
+export {};

package/lib/catalog/Navigation.js

@@ -30,7 +30,7 @@ export class StorageService {
         return this.id;
     }
     async buildTree() {
-        const rootElements = await this.findElementsByParentId(0, null);
+        const rootElements = await this.findElementsByParentId(null, null);
         const buildSubTree = async (elements) => {
             const tree = [];
             for (const element of elements) {
@@ -56,9 +56,9 @@ export class StorageService {
         return tree;
     }
     async populateFromTree(tree) {
-        const traverseTree = async (node, parentId = 0) => {
+        const traverseTree = async (node, parentId = null) => {
             const { children, ...itemData } = node;
-            const item = { ...itemData, parentId };
+            const item = { ...itemData, parentId: itemData.parentId === 0 ? null : itemData.parentId };
             await this.setElement(item.id, item, true);
             if (children && children.length > 0) {
                 for (const child of children) {
@@ -109,6 +109,8 @@ export class StorageService {
     async findElementsByParentId(parentId, type) {
         const elements = [];
         for (const item of this.storageMap.values()) {
+            if (parentId === 0)
+                parentId = null;
             if (type === null && item.parentId === parentId) {
                 elements.push(item);
                 continue;
@@ -138,14 +140,16 @@ export class StorageService {
     }
 }
 export class StorageServices {
-    static storages = [];
-    static add(storage) {
+    storages = [];
+    constructor() {
+    }
+    add(storage) {
         this.storages.push(storage);
     }
-    static get(id) {
+    get(id) {
         return this.storages.find(storage => storage.getId() === id);
     }
-    static getAll() {
+    getAll() {
         return this.storages;
     }
 }
@@ -155,17 +159,21 @@ export class Navigation extends AbstractCatalog {
     icon = "box";
     actionHandlers = [];
     idList = [];
+    storageServices;
     constructor(adminizer, config) {
         let items = [];
+        const storageServices = new StorageServices();
         for (const configElement of config.items) {
-            items.push(new NavigationItem(adminizer, configElement.title, configElement.model, config.model, configElement.urlPath));
+            items.push(new NavigationItem(adminizer, configElement.title, configElement.model, config.model, configElement.urlPath, storageServices));
         }
-        items.push(new NavigationGroup(adminizer, config.groupField));
-        items.push(new LinkItem(adminizer));
+        items.push(new NavigationGroup(adminizer, config.groupField, storageServices));
+        items.push(new LinkItem(adminizer, storageServices));
+        super(adminizer, items);
+        this.storageServices = storageServices;
+        adminizer.storageServices = storageServices;
         for (const section of config.sections) {
-            StorageServices.add(new StorageService(adminizer, section, config.model));
+            this.storageServices.add(new StorageService(adminizer, section, config.model));
         }
-        super(adminizer, items);
         this.movingGroupsRootOnly = config.movingGroupsRootOnly;
         this.idList = config.sections ?? [];
     }
@@ -183,7 +191,7 @@ class NavigationItem extends AbstractItem {
     actionHandlers = [];
     urlPath;
     adminizer;
-    constructor(adminizer, name, model, navigationModel, urlPath) {
+    constructor(adminizer, name, model, navigationModel, urlPath, storageServices) {
         super();
         this.name = name;
         this.navigationModel = navigationModel;
@@ -193,9 +201,10 @@ class NavigationItem extends AbstractItem {
         let configModel = adminizer.config.models[this.model];
         this.icon = configModel?.icon ?? 'file_present';
         this.adminizer = adminizer;
+        this.storageServices = storageServices;
     }
     async create(data, catalogId) {
-        let storage = StorageServices.get(catalogId);
+        let storage = this.storageServices.get(catalogId);
         let storageData = null;
         if (data._method === 'select') {
             // Direct call by model adapter
@@ -213,9 +222,11 @@ class NavigationItem extends AbstractItem {
         return await storage.setElement(data.id, storageData);
     }
     async dataPreparation(data, catalogId, sortOrder) {
-        let storage = StorageServices.get(catalogId);
+        let storage = this.storageServices.get(catalogId);
         let urlPath = eval('`' + this.urlPath + '`');
-        let parentId = data.parentId ? data.parentId : 0; // changed from null to 0
+        let parentId = data.parentId ? data.parentId : null; // changed from 0 to null
+        if (parentId === 0)
+            parentId = null;
         return {
             id: uuid(),
             modelId: data.record.id,
@@ -231,7 +242,7 @@ class NavigationItem extends AbstractItem {
         };
     }
     async updateModelItems(modelId, data, catalogId) {
-        let storage = StorageServices.get(catalogId);
+        let storage = this.storageServices.get(catalogId);
         let items = await storage.findElementByModelId(modelId);
         let urlPath = eval('`' + this.urlPath + '`');
         let response = [];
@@ -247,15 +258,15 @@ class NavigationItem extends AbstractItem {
         return response[0];
     }
     async update(itemId, data, catalogId) {
-        let storage = StorageServices.get(catalogId);
+        let storage = this.storageServices.get(catalogId);
         return await storage.setElement(itemId, data);
     }
     async deleteItem(itemId, catalogId) {
-        let storage = StorageServices.get(catalogId);
+        let storage = this.storageServices.get(catalogId);
         return await storage.removeElementById(itemId);
     }
     async find(itemId, catalogId) {
-        let storage = StorageServices.get(catalogId);
+        let storage = this.storageServices.get(catalogId);
         return await storage.findElementById(itemId);
     }
     /**
@@ -288,7 +299,7 @@ class NavigationItem extends AbstractItem {
         };
     }
     async getChilds(parentId, catalogId) {
-        let storage = StorageServices.get(catalogId);
+        let storage = this.storageServices.get(catalogId);
         return await storage.findElementsByParentId(parentId, this.type);
     }
     async getEditTemplate(id, catalogId, req, modelId) {
@@ -300,7 +311,7 @@ class NavigationItem extends AbstractItem {
         });
     }
     async search(s, catalogId) {
-        let storage = StorageServices.get(catalogId);
+        let storage = this.storageServices.get(catalogId);
         return await storage.search(s, this.type);
     }
 }
@@ -309,13 +320,14 @@ class NavigationGroup extends AbstractGroup {
     name = "Group";
     groupField;
     adminizer;
-    constructor(adminizer, groupField) {
+    constructor(adminizer, groupField, storageServices) {
         super();
         this.groupField = groupField;
         this.adminizer = adminizer;
+        this.storageServices = storageServices;
     }
     async create(data, catalogId) {
-        let storage = StorageServices.get(catalogId);
+        let storage = this.storageServices.get(catalogId);
         let storageData = await this.dataPreparation(data, catalogId);
         delete data.name;
         delete data.parentId;
@@ -323,8 +335,10 @@ class NavigationGroup extends AbstractGroup {
         return await storage.setElement(storageData.id, storageData);
     }
     async dataPreparation(data, catalogId, sortOrder) {
-        let storage = StorageServices.get(catalogId);
-        let parentId = data.parentId ? data.parentId : 0; // changed from null to 0
+        let storage = this.storageServices.get(catalogId);
+        let parentId = data.parentId ? data.parentId : null; // changed from 0 to null
+        if (parentId === 0)
+            parentId = null;
         return {
             id: uuid(),
             name: data.name,
@@ -338,19 +352,19 @@ class NavigationGroup extends AbstractGroup {
         };
     }
     async deleteItem(itemId, catalogId) {
-        let storage = StorageServices.get(catalogId);
+        let storage = this.storageServices.get(catalogId);
         return await storage.removeElementById(itemId);
     }
     async find(itemId, catalogId) {
-        let storage = StorageServices.get(catalogId);
+        let storage = this.storageServices.get(catalogId);
         return await storage.findElementById(itemId);
     }
     async update(itemId, data, catalogId) {
-        let storage = StorageServices.get(catalogId);
+        let storage = this.storageServices.get(catalogId);
         return await storage.setElement(itemId, data);
     }
     async updateModelItems(modelId, data, catalogId) {
-        let storage = StorageServices.get(catalogId);
+        let storage = this.storageServices.get(catalogId);
         return await storage.setElement(modelId, data);
     }
     getAddTemplate(req) {
@@ -404,11 +418,11 @@ class NavigationGroup extends AbstractGroup {
         });
     }
     async getChilds(parentId, catalogId) {
-        let storage = StorageServices.get(catalogId);
+        let storage = this.storageServices.get(catalogId);
         return await storage.findElementsByParentId(parentId, this.type);
     }
     async search(s, catalogId) {
-        let storage = StorageServices.get(catalogId);
+        let storage = this.storageServices.get(catalogId);
         return await storage.search(s, this.type);
     }
 }
@@ -418,8 +432,8 @@ class LinkItem extends NavigationGroup {
     name = 'Link';
     type = 'link';
     isGroup = false;
-    constructor(adminizer) {
-        super(adminizer, []);
+    constructor(adminizer, storageServices) {
+        super(adminizer, [], storageServices);
     }
     getAddTemplate(req) {
         let type = 'navigation.link';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "adminizer",
   "type": "module",
-  "version": "4.3.0-build.118",
+  "version": "4.3.0-build.120",
   "main": "index.js",
   "exports": {
     ".": "./index.js",