adminizer 4.7.0-build.224 → 5.0.0-build.1

package/lib/app-manager/ConfigLayerHandler.js

@@ -0,0 +1,119 @@
+function cloneConfigValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => cloneConfigValue(item));
+    }
+    if (isPlainObject(value)) {
+        const cloned = {};
+        for (const [key, nestedValue] of Object.entries(value)) {
+            cloned[key] = cloneConfigValue(nestedValue);
+        }
+        return cloned;
+    }
+    return value;
+}
+function isPlainObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function hasStringId(value) {
+    return isPlainObject(value) && typeof value.id === "string";
+}
+function mergeArrays(base, patch) {
+    if (!patch.length) {
+        return cloneConfigValue(base);
+    }
+    const shouldMergeById = patch.every(hasStringId);
+    if (!shouldMergeById) {
+        return [...cloneConfigValue(base), ...cloneConfigValue(patch)];
+    }
+    const merged = cloneConfigValue(base);
+    for (const patchItem of patch) {
+        const index = merged.findIndex((item) => hasStringId(item) && item.id === patchItem.id);
+        if (index === -1) {
+            merged.push(cloneConfigValue(patchItem));
+        }
+        else {
+            merged[index] = mergeConfigValues(merged[index], patchItem);
+        }
+    }
+    return merged;
+}
+function mergeConfigValues(base, patch) {
+    if (patch === undefined) {
+        return cloneConfigValue(base);
+    }
+    if (Array.isArray(patch)) {
+        return mergeArrays(Array.isArray(base) ? base : [], patch);
+    }
+    if (isPlainObject(patch)) {
+        const merged = isPlainObject(base) ? cloneConfigValue(base) : {};
+        for (const [key, value] of Object.entries(patch)) {
+            merged[key] = mergeConfigValues(merged[key], value);
+        }
+        return merged;
+    }
+    return patch;
+}
+export class ConfigLayerHandler {
+    adminizer;
+    baseConfig;
+    layers = new Map();
+    constructor(adminizer) {
+        this.adminizer = adminizer;
+    }
+    register(appName, layerId, patch) {
+        const id = this.getLayerId(appName, layerId);
+        if (this.layers.has(id)) {
+            throw new Error(`Config layer "${id}" is already registered`);
+        }
+        if (!this.adminizer.config) {
+            throw new Error("Adminizer config must be initialized before registering app config layers");
+        }
+        if (!this.baseConfig) {
+            this.baseConfig = cloneConfigValue(this.adminizer.config);
+        }
+        this.layers.set(id, {
+            id,
+            appName,
+            patch: cloneConfigValue(patch),
+        });
+        this.rebuildConfig();
+        this.adminizer.emitter.emit("app:config:registered", {
+            appName,
+            resourceId: id,
+        });
+        return id;
+    }
+    unregister(id) {
+        const layer = this.layers.get(id);
+        if (!layer) {
+            return;
+        }
+        this.layers.delete(id);
+        this.rebuildConfig();
+        this.adminizer.emitter.emit("app:config:unregistered", {
+            appName: layer.appName,
+            resourceId: id,
+        });
+    }
+    getByApp(appName) {
+        return Array.from(this.layers.values()).filter((layer) => layer.appName === appName);
+    }
+    rebuildConfig() {
+        if (!this.baseConfig) {
+            return;
+        }
+        const rebuilt = Array.from(this.layers.values()).reduce((config, layer) => mergeConfigValues(config, layer.patch), cloneConfigValue(this.baseConfig));
+        const targetConfig = this.adminizer.config;
+        for (const key of Object.keys(targetConfig)) {
+            delete targetConfig[key];
+        }
+        Object.assign(this.adminizer.config, rebuilt);
+    }
+    getLayerId(appName, layerId) {
+        return `${appName}:${layerId}`;
+    }
+}

package/lib/app-manager/ControllerHandler.d.ts

@@ -0,0 +1,25 @@
+import type { Adminizer } from "../Adminizer";
+import type { AppController, AppControllerMethod } from "./AdminizerApp";
+interface ControllerRecord {
+    id: string;
+    appName: string;
+    method: AppControllerMethod;
+    path: string;
+    enabled: boolean;
+}
+export declare class ControllerHandler {
+    private adminizer;
+    private controllers;
+    constructor(adminizer: Adminizer);
+    register(appName: string, controller: AppController): string;
+    disable(id: string): void;
+    enable(id: string): void;
+    unregister(id: string): void;
+    getByApp(appName: string): ControllerRecord[];
+    private getControllerId;
+    private resolveRoute;
+    private resolvePolicies;
+    private bindRoute;
+    private removeRoute;
+}
+export {};

package/lib/app-manager/ControllerHandler.js

@@ -0,0 +1,140 @@
+import { bindWithMiddlewares } from "../../system/routePolicies.js";
+import { requireAdmin, requireAnyPermission, requireAuthAPI, requireAuthEnabled, requireAuthUI, requirePermission, } from "../../policies/authPolicies.js";
+export class ControllerHandler {
+    adminizer;
+    controllers = new Map();
+    constructor(adminizer) {
+        this.adminizer = adminizer;
+    }
+    register(appName, controller) {
+        const id = this.getControllerId(appName, controller);
+        if (this.controllers.has(id)) {
+            throw new Error(`Controller "${id}" is already registered`);
+        }
+        const fullPath = this.resolveRoute(controller.route);
+        const record = {
+            id,
+            appName,
+            method: controller.method,
+            path: fullPath,
+            enabled: true,
+        };
+        const middleware = bindWithMiddlewares(this.adminizer, this.adminizer.config.middlewares ?? [], (req, res, next) => {
+            if (!record.enabled) {
+                return next();
+            }
+            req.runtime = this.adminizer.appManager.createRuntime(appName);
+            return controller.middleware(req, res, next);
+        }, this.resolvePolicies(controller.policies));
+        this.bindRoute(controller.method, fullPath, middleware);
+        this.controllers.set(id, record);
+        this.adminizer.emitter.emit("app:controller:registered", {
+            appName,
+            resourceId: id,
+            route: fullPath,
+            method: controller.method,
+            policies: controller.policies ?? [],
+        });
+        return fullPath;
+    }
+    disable(id) {
+        const record = this.controllers.get(id);
+        if (!record) {
+            return;
+        }
+        record.enabled = false;
+        this.adminizer.emitter.emit("app:controller:disabled", {
+            appName: record.appName,
+            resourceId: id,
+            route: record.path,
+            method: record.method,
+        });
+    }
+    enable(id) {
+        const record = this.controllers.get(id);
+        if (!record) {
+            return;
+        }
+        record.enabled = true;
+        this.adminizer.emitter.emit("app:controller:enabled", {
+            appName: record.appName,
+            resourceId: id,
+            route: record.path,
+            method: record.method,
+        });
+    }
+    unregister(id) {
+        const record = this.controllers.get(id);
+        if (!record) {
+            return;
+        }
+        this.removeRoute(record.path, record.method);
+        this.controllers.delete(id);
+        this.adminizer.emitter.emit("app:controller:unregistered", {
+            appName: record.appName,
+            resourceId: id,
+            route: record.path,
+            method: record.method,
+        });
+    }
+    getByApp(appName) {
+        return Array.from(this.controllers.values()).filter((record) => record.appName === appName);
+    }
+    getControllerId(appName, controller) {
+        return `${appName}:${controller.id ?? `${controller.method}:${controller.route}`}`;
+    }
+    resolveRoute(route) {
+        const routePrefix = this.adminizer.config.routePrefix.replace(/\/+$/, "");
+        const routePath = route.startsWith("/") ? route : `/${route}`;
+        return `${routePrefix}${routePath}`;
+    }
+    resolvePolicies(policies = []) {
+        return policies.map((policy) => {
+            switch (policy.type) {
+                case "auth":
+                    return policy.mode === "api" ? requireAuthAPI() : requireAuthUI();
+                case "auth-enabled":
+                    return requireAuthEnabled();
+                case "admin":
+                    return requireAdmin({ mode: policy.mode });
+                case "permission":
+                    return requirePermission(policy.token, { mode: policy.mode });
+                case "any-permission":
+                    return requireAnyPermission(policy.tokens, { mode: policy.mode });
+            }
+        });
+    }
+    bindRoute(method, route, middleware) {
+        switch (method) {
+            case "get":
+                this.adminizer.app.get(route, middleware);
+                break;
+            case "post":
+                this.adminizer.app.post(route, middleware);
+                break;
+            case "put":
+                this.adminizer.app.put(route, middleware);
+                break;
+            case "patch":
+                this.adminizer.app.patch(route, middleware);
+                break;
+            case "delete":
+                this.adminizer.app.delete(route, middleware);
+                break;
+            case "all":
+                this.adminizer.app.all(route, middleware);
+                break;
+        }
+    }
+    removeRoute(path, method) {
+        const app = this.adminizer.app;
+        const router = app.router ?? app._router;
+        if (!Array.isArray(router?.stack)) {
+            return;
+        }
+        const index = router.stack.findIndex((layer) => layer.route?.path === path && layer.route?.methods?.[method]);
+        if (index !== -1) {
+            router.stack.splice(index, 1);
+        }
+    }
+}

package/lib/catalog/AbstractCatalog.d.ts

@@ -1,5 +1,6 @@
 import { Adminizer } from "../Adminizer";
-import { StorageServices } from "./Navigation";
+export interface CatalogStorageServices {
+}
 /**
  * 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
@@ -8,7 +9,7 @@ import { StorageServices } from "./Navigation";
 export interface Item {
     id: string | number;
     name: string;
-    parentId: string | number;
+    parentId: string | number | null;
     /**
      *
      */
@@ -21,11 +22,15 @@ export interface Item {
 export type _Item_ = {
     [key: string]: boolean | string | number | object;
 };
+export interface CatalogTemplate<TData = any> {
+    type: string;
+    data: TData;
+}
 /**
  * General Item structure that will be available for all elements, including groups
  */
 export declare abstract class BaseItem<T extends Item> {
-    storageServices?: StorageServices;
+    storageServices?: CatalogStorageServices;
     abstract readonly type: string;
     /**
      * Used for infer T
@@ -91,10 +96,7 @@ export declare abstract class BaseItem<T extends Item> {
      * get add template
      * @param req
      */
-    abstract getAddTemplate(req: ReqType): Promise<{
-        type: 'component' | 'navigation.group' | 'navigation.link' | 'model' | 'model.link';
-        data: any;
-    }>;
+    abstract getAddTemplate(req: ReqType): Promise<CatalogTemplate>;
     /**
      * get edit template
      * @param id
@@ -102,10 +104,7 @@ export declare abstract class BaseItem<T extends Item> {
      * @param req
      * @param modelId
      */
-    abstract getEditTemplate(id: string | number, catalogId: string, req: ReqType, modelId?: string | number): Promise<{
-        type: 'component' | 'navigation.group' | 'navigation.link' | 'model' | 'model.link';
-        data: any;
-    }>;
+    abstract getEditTemplate(id: string | number, catalogId: string, req: ReqType, modelId?: string | number): Promise<CatalogTemplate>;
     _getChilds(parentId: string | number, catalogId: string, req?: ReqType): Promise<Item[]>;
     abstract getChilds(parentId: string | number, catalogId: string, req?: ReqType): Promise<Item[]>;
     abstract search(s: string, catalogId: string, req?: ReqType): Promise<T[]>;
@@ -205,7 +204,22 @@ export declare abstract class AbstractCatalog {
      * if pass null as parentId this root
      */
     getChilds(parentId: string | number, byItemType?: string, req?: ReqType): Promise<Item[]>;
+    /**
+     * Registers the catalog access right through the legacy Adminizer API.
+     *
+     * @deprecated Starting with Adminizer v6, register access rights through
+     * `ctx.accessRight(...)` in the app's `setup` method.
+     * @param adminizer Adminizer instance used for legacy access-right registration.
+     */
     private _bindAccessRight;
+    /**
+     * @deprecated The `adminizer` parameter is deprecated and will be removed in
+     * Adminizer v6. Register the catalog through `AppManager` using
+     * `ctx.catalog(...)`, and register its access rights using
+     * `ctx.accessRight(...)`.
+     * @param adminizer Adminizer instance used by the legacy registration flow.
+     * @param items Catalog item types.
+     */
     protected constructor(adminizer: Adminizer, items: BaseItem<any>[]);
     setId(id: string): void;
     /**
@@ -214,6 +228,7 @@ export declare abstract class AbstractCatalog {
      */
     getIdList(): Promise<string[]>;
     getItemType(type: string): BaseItem<Item>;
+    private requireItemType;
     getGroupType(): BaseItem<Item>;
     additemTypes<T extends BaseItem<any>>(itemType: T): void;
     /**
@@ -231,19 +246,13 @@ export declare abstract class AbstractCatalog {
      * @param req
      * @param modelId
      */
-    getEditTemplate(item: Item, id: string | number, req: ReqType, modelId?: string | number): Promise<{
-        type: "component" | "navigation.group" | "navigation.link" | "model" | "model.link";
-        data: any;
-    }>;
+    getEditTemplate(item: Item, id: string | number, req: ReqType, modelId?: string | number): Promise<CatalogTemplate<any>>;
     /**
      * Get add template from an item type
      * @param item
      * @param req
      */
-    getAddTemplate(item: Item, req: ReqType): Promise<{
-        type: "component" | "navigation.group" | "navigation.link" | "model" | "model.link";
-        data: any;
-    }>;
+    getAddTemplate(item: Item, req: ReqType): Promise<CatalogTemplate<any>>;
     addActionHandler(actionHandler: ActionHandler): void;
     /**
      * Method for getting group elements

package/lib/catalog/AbstractCatalog.js

@@ -98,6 +98,13 @@ export class AbstractCatalog {
             return result.sort((a, b) => a.sortOrder - b.sortOrder);
         }
     }
+    /**
+     * Registers the catalog access right through the legacy Adminizer API.
+     *
+     * @deprecated Starting with Adminizer v6, register access rights through
+     * `ctx.accessRight(...)` in the app's `setup` method.
+     * @param adminizer Adminizer instance used for legacy access-right registration.
+     */
     _bindAccessRight(adminizer) {
         setTimeout(() => {
             const postfix = this.id ? `${this.slug}-${this.id}` : `${this.slug}`;
@@ -109,6 +116,14 @@ export class AbstractCatalog {
             });
         }, 100);
     }
+    /**
+     * @deprecated The `adminizer` parameter is deprecated and will be removed in
+     * Adminizer v6. Register the catalog through `AppManager` using
+     * `ctx.catalog(...)`, and register its access rights using
+     * `ctx.accessRight(...)`.
+     * @param adminizer Adminizer instance used by the legacy registration flow.
+     * @param items Catalog item types.
+     */
     constructor(adminizer, items) {
         for (const item of items) {
             this.additemTypes(item);
@@ -128,6 +143,13 @@ export class AbstractCatalog {
     getItemType(type) {
         return this.itemTypes.find((it) => it.type === type);
     }
+    requireItemType(type) {
+        const itemType = this.getItemType(type);
+        if (!itemType) {
+            throw new Error(`Catalog item type \`${String(type)}\` was not found in catalog \`${this.slug}\``);
+        }
+        return itemType;
+    }
     getGroupType() {
         return this.itemTypes.find((it) => it.isGroup === true);
     }
@@ -142,13 +164,13 @@ export class AbstractCatalog {
      *  Get an element
      */
     async find(item, req) {
-        return await this.getItemType(item.type)?._find(item.id, this.id, req);
+        return await this.requireItemType(item.type)._find(item.id, this.id, req);
     }
     /**
      *  Removing an element
      */
     async deleteItem(type, id, req) {
-        await this.getItemType(type)?.deleteItem(id, this.id, req);
+        await this.requireItemType(type).deleteItem(id, this.id, req);
     }
     /**
      * Get edit template from an item type
@@ -158,7 +180,7 @@ export class AbstractCatalog {
      * @param modelId
      */
     getEditTemplate(item, id, req, modelId) {
-        return this.getItemType(item.type)?.getEditTemplate(id, this.id, req, modelId);
+        return this.requireItemType(item.type).getEditTemplate(id, this.id, req, modelId);
     }
     /**
      * Get add template from an item type
@@ -166,7 +188,7 @@ export class AbstractCatalog {
      * @param req
      */
     getAddTemplate(item, req) {
-        return this.getItemType(item.type)?.getAddTemplate(req);
+        return this.requireItemType(item.type).getAddTemplate(req);
     }
     addActionHandler(actionHandler) {
         if (actionHandler.selectedItemTypes.length > 0) {
@@ -232,12 +254,18 @@ export class AbstractCatalog {
      * @param req
      */
     async createItem(data, req) {
-        const promise = this.getItemType(data.type)?.create(data, this.id, req);
-        return await promise;
+        const result = await this.requireItemType(data.type).create(data, this.id, req);
+        if (!result) {
+            throw new Error(`Catalog item type \`${data.type}\` did not return created item`);
+        }
+        return result;
     }
     async updateItem(id, type, data, req) {
-        const promise = this.getItemType(type)?.update(id, data, this.id, req);
-        return await promise;
+        const result = await this.requireItemType(type).update(id, data, this.id, req);
+        if (!result) {
+            throw new Error(`Catalog item type \`${type}\` did not return updated item`);
+        }
+        return result;
     }
     /**
      * To update all items in the tree after updating the model
@@ -247,8 +275,11 @@ export class AbstractCatalog {
      * @param req
      */
     async updateModelItems(modelId, type, data, req) {
-        const promise = this.getItemType(type)?.updateModelItems(modelId, data, this.id, req);
-        return await promise;
+        const result = await this.requireItemType(type).updateModelItems(modelId, data, this.id, req);
+        if (!result) {
+            throw new Error(`Catalog item type \`${type}\` did not return updated model item`);
+        }
+        return result;
     }
     /**
      * Method for getting group elements

package/lib/catalog/CatalogHandler.d.ts

@@ -1,7 +1,20 @@
 import { AbstractCatalog } from "./AbstractCatalog";
+export interface CatalogRecord {
+    id: string;
+    appName: string;
+    catalog: AbstractCatalog;
+    enabled: boolean;
+}
 export declare class CatalogHandler {
     private catalog;
+    private records;
     add(catalog: AbstractCatalog): AbstractCatalog;
     getAll(): AbstractCatalog[];
     getCatalog(slug: string): AbstractCatalog;
+    register(appName: string, catalog: AbstractCatalog): string;
+    unregister(id: string): void;
+    disable(id: string): void;
+    enable(id: string): void;
+    getByApp(appName: string): CatalogRecord[];
+    private getRecordId;
 }

package/lib/catalog/CatalogHandler.js

@@ -1,13 +1,59 @@
 export class CatalogHandler {
     catalog = [];
+    records = new Map();
     add(catalog) {
         this.catalog.push(catalog);
         return catalog;
     }
     getAll() {
-        return this.catalog;
+        return [
+            ...this.catalog,
+            ...Array.from(this.records.values())
+                .filter((record) => record.enabled)
+                .map((record) => record.catalog)
+        ];
     }
     getCatalog(slug) {
-        return this.catalog.find((catalog) => catalog.slug === slug);
+        return this.getAll().find((catalog) => catalog.slug === slug);
+    }
+    register(appName, catalog) {
+        const id = this.getRecordId(appName, catalog);
+        if (this.records.has(id)) {
+            throw new Error(`Catalog "${id}" is already registered`);
+        }
+        const existingCatalog = this.getCatalog(catalog.slug);
+        if (existingCatalog) {
+            throw new Error(`Catalog with slug "${catalog.slug}" is already registered`);
+        }
+        this.records.set(id, {
+            id,
+            appName,
+            catalog,
+            enabled: true,
+        });
+        return id;
+    }
+    unregister(id) {
+        this.records.delete(id);
+    }
+    disable(id) {
+        const record = this.records.get(id);
+        if (!record) {
+            return;
+        }
+        record.enabled = false;
+    }
+    enable(id) {
+        const record = this.records.get(id);
+        if (!record) {
+            return;
+        }
+        record.enabled = true;
+    }
+    getByApp(appName) {
+        return Array.from(this.records.values()).filter((record) => record.appName === appName);
+    }
+    getRecordId(appName, catalog) {
+        return `${appName}:${catalog.slug}`;
     }
 }

package/lib/catalog/CatalogTemplateComponentHandler.d.ts

@@ -0,0 +1,23 @@
+export interface CatalogTemplateComponentResource {
+    id: string;
+    type: string;
+    component: string;
+    exportName?: string;
+}
+export interface CatalogTemplateComponentRecord extends CatalogTemplateComponentResource {
+    id: string;
+    appName: string;
+    catalog: string;
+    enabled: boolean;
+}
+export declare class CatalogTemplateComponentHandler {
+    private records;
+    register(appName: string, catalog: string, resource: CatalogTemplateComponentResource): string;
+    unregister(id: string): void;
+    disable(id: string): void;
+    enable(id: string): void;
+    getAll(): CatalogTemplateComponentRecord[];
+    getByApp(appName: string): CatalogTemplateComponentRecord[];
+    getByCatalog(catalog: string): CatalogTemplateComponentRecord[];
+    getByType(type: string, catalog: string): CatalogTemplateComponentRecord | undefined;
+}

package/lib/catalog/CatalogTemplateComponentHandler.js

@@ -0,0 +1,59 @@
+function normalizeType(type) {
+    return type.toLowerCase();
+}
+function normalizeCatalog(catalog) {
+    return catalog.toLowerCase();
+}
+export class CatalogTemplateComponentHandler {
+    records = new Map();
+    register(appName, catalog, resource) {
+        const normalizedCatalog = normalizeCatalog(catalog);
+        const id = `${appName}:${normalizedCatalog}:${resource.id}`;
+        if (this.records.has(id)) {
+            throw new Error(`Catalog template component "${id}" is already registered`);
+        }
+        const existing = this.getByType(resource.type, normalizedCatalog);
+        if (existing) {
+            throw new Error(`Catalog template component for type "${resource.type}" is already registered in catalog "${normalizedCatalog}"`);
+        }
+        this.records.set(id, {
+            ...resource,
+            id,
+            appName,
+            type: normalizeType(resource.type),
+            catalog: normalizedCatalog,
+            enabled: true,
+        });
+        return id;
+    }
+    unregister(id) {
+        this.records.delete(id);
+    }
+    disable(id) {
+        const record = this.records.get(id);
+        if (record) {
+            record.enabled = false;
+        }
+    }
+    enable(id) {
+        const record = this.records.get(id);
+        if (record) {
+            record.enabled = true;
+        }
+    }
+    getAll() {
+        return Array.from(this.records.values()).filter((record) => record.enabled);
+    }
+    getByApp(appName) {
+        return Array.from(this.records.values()).filter((record) => record.appName === appName);
+    }
+    getByCatalog(catalog) {
+        const normalizedCatalog = normalizeCatalog(catalog);
+        return this.getAll().filter((record) => record.catalog === normalizedCatalog);
+    }
+    getByType(type, catalog) {
+        const normalizedType = normalizeType(type);
+        const normalizedCatalog = normalizeCatalog(catalog);
+        return this.getAll().find((record) => record.type === normalizedType && record.catalog === normalizedCatalog);
+    }
+}

package/lib/controls/Control.d.ts

@@ -0,0 +1,17 @@
+export type ControlType = 'wysiwyg' | 'jsonEditor' | 'geoJson' | 'markdown' | 'table' | 'codeEditor';
+export interface Path {
+    jsPath: {
+        dev: string;
+        production: string;
+    };
+    cssPath: string;
+}
+export type Config = Record<string, string | string[] | object | number | boolean>;
+export interface Control {
+    readonly name: string;
+    readonly type: ControlType;
+    getConfig(): Config | undefined;
+    getJsPath(): string | undefined;
+    getCssPath(): string | undefined;
+    getName(): string;
+}