adminizer 4.7.0-build.222 → 5.0.0-build.0

package/lib/controls/Control.js

@@ -0,0 +1 @@
+export {};

package/lib/controls/ControlsHandler.d.ts

@@ -1,10 +1,9 @@
-import { AbstractControls, ControlType } from "./AbstractControls";
+import { Control, ControlType } from "./Control";
 export declare class ControlsHandler {
     private controls;
-    add(control: AbstractControls): void;
-    get<T extends ControlType>(type: T, name: string): AbstractControls | undefined;
-    getByType<T extends ControlType>(type: T): AbstractControls[];
+    add(control: Control): void;
+    get<T extends ControlType>(type: T, name: string): Control | undefined;
+    getByType<T extends ControlType>(type: T): Control[];
     remove(type: ControlType, name: string): boolean;
-    getAll(): Record<ControlType, AbstractControls[]>;
-    collectAndGenerateStyleLinks(): string[];
+    getAll(): Record<ControlType, Control[]>;
 }

package/lib/controls/ControlsHandler.js

@@ -33,17 +33,4 @@ export class ControlsHandler {
             Array.from(group.values())
         ]));
     }
-    collectAndGenerateStyleLinks() {
-        const stylesheets = [];
-        const allControls = this.getAll();
-        Object.values(allControls).forEach(controls => {
-            controls.forEach(control => {
-                const cssPath = control.getCssPath();
-                if (cssPath) {
-                    stylesheets.push(cssPath);
-                }
-            });
-        });
-        return stylesheets;
-    }
 }

package/lib/controls/codeEditor/MonacoEditor.d.ts

@@ -1,11 +1,10 @@
-import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../Adminizer";
-export declare class MonacoEditor extends AbstractControls {
+import { Control, ControlType, Config, Path } from "../Control";
+export declare class MonacoEditor implements Control {
     readonly config: Config;
     readonly name: string;
     readonly path: Path;
     readonly type: ControlType;
-    constructor(adminizer: Adminizer);
+    constructor(routePrefix: string);
     getConfig(): Config;
     getCssPath(): string | undefined;
     getJsPath(): string | undefined;

package/lib/controls/codeEditor/MonacoEditor.js

@@ -1,15 +1,18 @@
-import { AbstractControls } from "../AbstractControls.js";
-export class MonacoEditor extends AbstractControls {
+export class MonacoEditor {
     config = {
         language: "javascript",
     };
     name = 'monaco';
-    path = {
-        cssPath: "", jsPath: { dev: "", production: "" }
-    };
+    path;
     type = 'codeEditor';
-    constructor(adminizer) {
-        super(adminizer);
+    constructor(routePrefix) {
+        this.path = {
+            cssPath: "",
+            jsPath: {
+                dev: "/src/assets/js/controls/monaco.tsx",
+                production: `${routePrefix}/assets/controls/monaco.es.js`
+            }
+        };
     }
     getConfig() {
         return this.config;
@@ -18,7 +21,9 @@ export class MonacoEditor extends AbstractControls {
         return undefined;
     }
     getJsPath() {
-        return undefined;
+        return process.env.ADMINIZER_ENV === 'dev'
+            ? this.path.jsPath.dev
+            : this.path.jsPath.production;
     }
     getName() {
         return this.name;

package/lib/controls/geojsoneditor/GeoEditor.d.ts

@@ -1,11 +1,10 @@
-import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../Adminizer";
-export declare class GeoEditor extends AbstractControls {
+import { Control, ControlType, Config, Path } from "../Control";
+export declare class GeoEditor implements Control {
     readonly config: Config;
     readonly name: string;
     readonly path: Path;
     readonly type: ControlType;
-    constructor(adminizer: Adminizer);
+    constructor(routePrefix: string);
     getConfig(): Config | undefined;
     getCssPath(): string | undefined;
     getJsPath(): string | undefined;

package/lib/controls/geojsoneditor/GeoEditor.js

@@ -1,24 +1,29 @@
-import { AbstractControls } from "../AbstractControls.js";
-export class GeoEditor extends AbstractControls {
+export class GeoEditor {
     config = {
         mode: "all"
     };
     name = "leaflet";
-    path = {
-        cssPath: "", jsPath: { dev: "", production: "" }
-    };
+    path;
     type = 'geoJson';
-    constructor(adminizer) {
-        super(adminizer);
+    constructor(routePrefix) {
+        this.path = {
+            cssPath: `${routePrefix}/assets/controls/leaflet.css`,
+            jsPath: {
+                dev: "/src/assets/js/controls/leaflet.tsx",
+                production: `${routePrefix}/assets/controls/leaflet.es.js`
+            }
+        };
     }
     getConfig() {
         return this.config;
     }
     getCssPath() {
-        return undefined;
+        return process.env.ADMINIZER_ENV === 'dev' ? undefined : this.path.cssPath;
     }
     getJsPath() {
-        return undefined;
+        return process.env.ADMINIZER_ENV === 'dev'
+            ? this.path.jsPath.dev
+            : this.path.jsPath.production;
     }
     getName() {
         return this.name;

package/lib/controls/jsoneditor/JsonEditor.d.ts

@@ -1,13 +1,12 @@
-import { AbstractControls, ControlType, Path, Config } from "../AbstractControls";
-import { Adminizer } from "../../Adminizer";
-export declare class JsonEditor extends AbstractControls {
+import { Control, ControlType, Path, Config } from "../Control";
+export declare class JsonEditor implements Control {
     readonly config: Record<string, string | string[] | object | number | boolean>;
     readonly name: string;
     readonly path: Path;
     readonly type: ControlType;
-    constructor(adminizer: Adminizer);
+    constructor(routePrefix: string);
     getConfig(): Config | undefined;
-    getJsPath(): undefined;
-    getCssPath(): undefined;
+    getJsPath(): string;
+    getCssPath(): string | undefined;
     getName(): string;
 }

package/lib/controls/jsoneditor/JsonEditor.js

@@ -1,26 +1,27 @@
-import { AbstractControls } from "../AbstractControls.js";
-export class JsonEditor extends AbstractControls {
+export class JsonEditor {
     config = {};
     name = 'jsoneditor';
-    path = {
-        cssPath: "",
-        jsPath: {
-            dev: "",
-            production: ""
-        }
-    };
+    path;
     type = 'jsonEditor';
-    constructor(adminizer) {
-        super(adminizer);
+    constructor(routePrefix) {
+        this.path = {
+            cssPath: `${routePrefix}/assets/controls/jsoneditor.css`,
+            jsPath: {
+                dev: "/src/assets/js/controls/jsoneditor.tsx",
+                production: `${routePrefix}/assets/controls/jsoneditor.es.js`
+            }
+        };
     }
     getConfig() {
         return this.config;
     }
     getJsPath() {
-        return undefined;
+        return process.env.ADMINIZER_ENV === 'dev'
+            ? this.path.jsPath.dev
+            : this.path.jsPath.production;
     }
     getCssPath() {
-        return undefined;
+        return process.env.ADMINIZER_ENV === 'dev' ? undefined : this.path.cssPath;
     }
     getName() {
         return this.name;

package/lib/controls/markdown/ToastUiEditor.d.ts

@@ -1,13 +1,12 @@
-import { AbstractControls, ControlType, Path, Config } from "../AbstractControls";
-import { Adminizer } from "../../Adminizer";
-export declare class ToastUiEditor extends AbstractControls {
+import { Control, ControlType, Path, Config } from "../Control";
+export declare class ToastUiEditor implements Control {
     readonly config: Record<string, string | string[] | object | number | boolean>;
     readonly name: string;
     readonly path: Path;
     readonly type: ControlType;
-    constructor(adminizer: Adminizer);
+    constructor(routePrefix: string);
     getConfig(): Config | undefined;
-    getJsPath(): undefined;
-    getCssPath(): undefined;
+    getJsPath(): string;
+    getCssPath(): string | undefined;
     getName(): string;
 }

package/lib/controls/markdown/ToastUiEditor.js

@@ -1,5 +1,4 @@
-import { AbstractControls } from "../AbstractControls.js";
-export class ToastUiEditor extends AbstractControls {
+export class ToastUiEditor {
     config = {
         hideModeSwitch: true,
         height: '400px',
@@ -7,25 +6,27 @@ export class ToastUiEditor extends AbstractControls {
         previewStyle: 'vertical',
     };
     name = 'toast-ui';
-    path = {
-        cssPath: "",
-        jsPath: {
-            dev: "",
-            production: ""
-        }
-    };
+    path;
     type = 'markdown';
-    constructor(adminizer) {
-        super(adminizer);
+    constructor(routePrefix) {
+        this.path = {
+            cssPath: `${routePrefix}/assets/controls/toast-ui.css`,
+            jsPath: {
+                dev: "/src/assets/js/controls/toast-ui.tsx",
+                production: `${routePrefix}/assets/controls/toast-ui.es.js`
+            }
+        };
     }
     getConfig() {
         return this.config;
     }
     getJsPath() {
-        return undefined;
+        return process.env.ADMINIZER_ENV === 'dev'
+            ? this.path.jsPath.dev
+            : this.path.jsPath.production;
     }
     getCssPath() {
-        return undefined;
+        return process.env.ADMINIZER_ENV === 'dev' ? undefined : this.path.cssPath;
     }
     getName() {
         return this.name;

package/lib/controls/table/Handsontable.d.ts

@@ -1,13 +1,12 @@
-import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../Adminizer";
-export declare class Handsontable extends AbstractControls {
+import { Control, ControlType, Config, Path } from "../Control";
+export declare class Handsontable implements Control {
     readonly config: Config;
     readonly name: string;
     readonly path: Path;
     readonly type: ControlType;
-    constructor(adminizer: Adminizer);
+    constructor(routePrefix: string);
     getConfig(): Config | undefined;
     getName(): string;
-    getJsPath(): undefined;
-    getCssPath(): undefined;
+    getJsPath(): string;
+    getCssPath(): string | undefined;
 }

package/lib/controls/table/Handsontable.js

@@ -1,5 +1,4 @@
-import { AbstractControls } from "../AbstractControls.js";
-export class Handsontable extends AbstractControls {
+export class Handsontable {
     config = {
         rowHeaders: true,
         height: 'auto',
@@ -9,16 +8,16 @@ export class Handsontable extends AbstractControls {
         licenseKey: 'non-commercial-and-evaluation', // for non-commercial use only
     };
     name = "handsontable";
-    path = {
-        cssPath: "",
-        jsPath: {
-            dev: "",
-            production: ""
-        }
-    };
+    path;
     type = 'table';
-    constructor(adminizer) {
-        super(adminizer);
+    constructor(routePrefix) {
+        this.path = {
+            cssPath: `${routePrefix}/assets/controls/handsontable.css`,
+            jsPath: {
+                dev: "/src/assets/js/controls/handsontable.tsx",
+                production: `${routePrefix}/assets/controls/handsontable.es.js`
+            }
+        };
     }
     getConfig() {
         return this.config;
@@ -27,9 +26,11 @@ export class Handsontable extends AbstractControls {
         return this.name;
     }
     getJsPath() {
-        return undefined;
+        return process.env.ADMINIZER_ENV === 'dev'
+            ? this.path.jsPath.dev
+            : this.path.jsPath.production;
     }
     getCssPath() {
-        return undefined;
+        return process.env.ADMINIZER_ENV === 'dev' ? undefined : this.path.cssPath;
     }
 }

package/lib/controls/wysiwyg/CKeditor.d.ts

@@ -1,13 +1,12 @@
-import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../Adminizer";
-export declare class CKeditor extends AbstractControls {
+import { Control, ControlType, Config, Path } from "../Control";
+export declare class CKeditor implements Control {
     readonly name: string;
     readonly type: ControlType;
     readonly path: Path;
     readonly config: Config;
-    constructor(adminizer: Adminizer);
+    constructor(routePrefix: string);
     getConfig(): Config;
-    getJsPath(): undefined;
-    getCssPath(): undefined;
+    getJsPath(): string;
+    getCssPath(): string | undefined;
     getName(): string;
 }

package/lib/controls/wysiwyg/CKeditor.js

@@ -1,14 +1,7 @@
-import { AbstractControls } from "../AbstractControls.js";
-export class CKeditor extends AbstractControls {
+export class CKeditor {
     name = 'ckeditor';
     type = 'wysiwyg';
-    path = {
-        cssPath: "",
-        jsPath: {
-            dev: "",
-            production: ""
-        }
-    };
+    path;
     config = {
         items: [
             'sourceEditing',
@@ -34,17 +27,25 @@ export class CKeditor extends AbstractControls {
             'indent',
         ],
     };
-    constructor(adminizer) {
-        super(adminizer);
+    constructor(routePrefix) {
+        this.path = {
+            cssPath: `${routePrefix}/assets/controls/ckeditor.css`,
+            jsPath: {
+                dev: "/src/assets/js/controls/ckeditor.tsx",
+                production: `${routePrefix}/assets/controls/ckeditor.es.js`
+            }
+        };
     }
     getConfig() {
         return this.config;
     }
     getJsPath() {
-        return undefined;
+        return process.env.ADMINIZER_ENV === 'dev'
+            ? this.path.jsPath.dev
+            : this.path.jsPath.production;
     }
     getCssPath() {
-        return undefined;
+        return process.env.ADMINIZER_ENV === 'dev' ? undefined : this.path.cssPath;
     }
     getName() {
         return this.name;

package/lib/filters/ConditionValidator.d.ts

@@ -1,4 +1,4 @@
-import { FilterCondition, FilterOperator } from '../../models/FilterAP';
+import { FilterCondition, FilterOperator } from '../../models/Filter';
 /**
  * Security event types for logging suspicious filter attempts
  */

package/lib/filters/FilterService.d.ts

@@ -1,7 +1,7 @@
 import { Adminizer } from '../Adminizer';
-import { FilterAP } from '../../models/FilterAP';
-import { FilterColumnAP } from '../../models/FilterColumnAP';
-import { UserAP } from '../../models/UserAP';
+import { Filter } from '../../models/Filter';
+import { FilterColumn } from '../../models/FilterColumn';
+import { User } from '../../models/User';
 /**
  * FilterService - manages filter operations
  *
@@ -23,26 +23,26 @@ export declare class FilterService {
      * Get filter by ID with access control
      * Returns null when filter is not found or user has no access.
      */
-    getFilterById(filterId: string, user: UserAP): Promise<FilterAP | null>;
+    getFilterById(filterId: string, user: User): Promise<Filter | null>;
     /**
      * Get filters for a model accessible by user
      */
-    getFiltersForModel(modelName: string, user: UserAP, options?: {
+    getFiltersForModel(modelName: string, user: User, options?: {
         includePublic?: boolean;
         includeSystem?: boolean;
-    }): Promise<FilterAP[]>;
+    }): Promise<Filter[]>;
     /**
      * Check if user can view a filter
      */
-    canViewFilter(filter: FilterAP, user: UserAP): boolean;
+    canViewFilter(filter: Filter, user: User): boolean;
     /**
      * Check if user can edit a filter
      */
-    canEditFilter(filter: FilterAP, user: UserAP): boolean;
+    canEditFilter(filter: Filter, user: User): boolean;
     /**
      * Check if user can delete a filter
      */
-    canDeleteFilter(filter: FilterAP, user: UserAP): boolean;
+    canDeleteFilter(filter: Filter, user: User): boolean;
     /**
      * Count records matching a filter's conditions
      *
@@ -50,33 +50,33 @@ export declare class FilterService {
      * @param user - User requesting the count (for access control)
      * @returns Number of matching records, or -1 on error
      */
-    countFilterResults(filter: FilterAP, user: UserAP): Promise<number>;
+    countFilterResults(filter: Filter, user: User): Promise<number>;
     /**
      * Create a new filter
      */
-    createFilter(data: Partial<FilterAP>, user: UserAP): Promise<FilterAP>;
+    createFilter(data: Partial<Filter>, user: User): Promise<Filter>;
     /**
      * Update a filter
      */
-    updateFilter(filterId: string, data: Partial<FilterAP>, user: UserAP): Promise<FilterAP>;
+    updateFilter(filterId: string, data: Partial<Filter>, user: User): Promise<Filter>;
     /**
      * Delete a filter
      */
-    deleteFilter(filterId: string, user: UserAP): Promise<void>;
+    deleteFilter(filterId: string, user: User): Promise<void>;
     /**
      * Get columns for a filter
      */
-    getFilterColumns(filterId: string): Promise<FilterColumnAP[]>;
+    getFilterColumns(filterId: string): Promise<FilterColumn[]>;
     /**
      * Update columns for a filter (replace all)
      */
-    updateFilterColumns(filterId: string, columns: Partial<FilterColumnAP>[], user: UserAP): Promise<FilterColumnAP[]>;
+    updateFilterColumns(filterId: string, columns: Partial<FilterColumn>[], user: User): Promise<FilterColumn[]>;
     /**
      * Get filter with columns loaded
      */
-    getFilterWithColumns(filterId: string, user: UserAP): Promise<{
-        filter: FilterAP | null;
-        columns: FilterColumnAP[];
+    getFilterWithColumns(filterId: string, user: User): Promise<{
+        filter: Filter | null;
+        columns: FilterColumn[];
     }>;
 }
 export default FilterService;

package/lib/filters/FilterService.js

@@ -51,22 +51,22 @@ export class FilterService {
      * Returns null when filter is not found or user has no access.
      */
     async getFilterById(filterId, user) {
-        const filterModel = this.adminizer.modelHandler.internal('filters').get('FilterAP');
+        const filterModel = this.adminizer.modelHandler.internal('filters').get('Filter');
         const filter = await filterModel.findOne({ where: { id: filterId } });
         if (!filter) {
             return null;
         }
-        const filterAP = filter;
-        if (!this.canViewFilter(filterAP, user)) {
+        const savedFilter = filter;
+        if (!this.canViewFilter(savedFilter, user)) {
             return null;
         }
-        return filterAP;
+        return savedFilter;
     }
     /**
      * Get filters for a model accessible by user
      */
     async getFiltersForModel(modelName, user, options) {
-        const filterModel = this.adminizer.modelHandler.internal('filters').get('FilterAP');
+        const filterModel = this.adminizer.modelHandler.internal('filters').get('Filter');
         const filters = [];
         // Build base criteria
         const baseCriteria = { modelName };
@@ -205,7 +205,7 @@ export class FilterService {
      * Create a new filter
      */
     async createFilter(data, user) {
-        const filterModel = this.adminizer.modelHandler.internal('filters').get('FilterAP');
+        const filterModel = this.adminizer.modelHandler.internal('filters').get('Filter');
         // Generate UUID if not provided
         if (!data.id) {
             data.id = crypto.randomUUID();
@@ -230,7 +230,7 @@ export class FilterService {
         if (!this.canEditFilter(filter, user)) {
             throw new Error('Access denied');
         }
-        const filterModel = this.adminizer.modelHandler.internal('filters').get('FilterAP');
+        const filterModel = this.adminizer.modelHandler.internal('filters').get('Filter');
         // Don't allow changing owner
         delete data.ownerId;
         delete data.id;
@@ -253,7 +253,7 @@ export class FilterService {
             throw new Error('Access denied');
         }
         // Delete columns first - find by filter association and delete by ID
-        const columnModel = this.adminizer.modelHandler.internal('filters').get('FilterColumnAP');
+        const columnModel = this.adminizer.modelHandler.internal('filters').get('FilterColumn');
         if (columnModel) {
             // Find columns for this filter
             const columns = await columnModel.find({ where: { filter: filterId } });
@@ -263,7 +263,7 @@ export class FilterService {
             }
         }
         // Delete filter by ID only
-        const filterModel = this.adminizer.modelHandler.internal('filters').get('FilterAP');
+        const filterModel = this.adminizer.modelHandler.internal('filters').get('Filter');
         if (filterModel) {
             // Use destroyOne with explicit ID to avoid cascade
             await filterModel.destroyOne({ where: { id: filterId } });
@@ -273,7 +273,7 @@ export class FilterService {
      * Get columns for a filter
      */
     async getFilterColumns(filterId) {
-        const columnModel = this.adminizer.modelHandler.internal('filters').get('FilterColumnAP');
+        const columnModel = this.adminizer.modelHandler.internal('filters').get('FilterColumn');
         const columns = await columnModel.find({ where: { filter: filterId } });
         // Sort by order
         return columns.sort((a, b) => (a.order || 0) - (b.order || 0));
@@ -289,7 +289,7 @@ export class FilterService {
         if (!this.canEditFilter(filter, user)) {
             throw new Error('Access denied');
         }
-        const columnModel = this.adminizer.modelHandler.internal('filters').get('FilterColumnAP');
+        const columnModel = this.adminizer.modelHandler.internal('filters').get('FilterColumn');
         // Delete existing columns
         await columnModel.destroy({ where: { filter: filterId } });
         // Create new columns