adminizer 4.6.0 → 4.7.0-build.222

package/helpers/inertiaListHelper.js

@@ -1,6 +1,11 @@
 import inertiaActionsHelper from "./inertiaActionsHelper.js";
-export function inertiaListHelper(entity, req, fields) {
+export function inertiaListHelper(modelResource, req, fields, activeFilterName) {
     const actionType = 'list';
+    // Check if filters are enabled for this model
+    // Preferred: model-level `models.<Model>.filters`; fallback: legacy top-level `modelFilters.<Model>`
+    const modelFiltersConfig = modelResource.config?.filters ?? req.adminizer.config.modelFilters?.[modelResource.name];
+    const filtersEnabledGlobally = req.adminizer.config.filters?.enabled !== false;
+    const filtersEnabled = filtersEnabledGlobally && modelFiltersConfig?.enabled === true;
     let props = {
         thActionsTitle: req.i18n.__('Actions'),
         actions: [],
@@ -11,9 +16,9 @@ export function inertiaListHelper(entity, req, fields) {
             viewsTitle: '',
             deleteTitle: ''
         },
-        entity: {
-            name: entity.name,
-            uri: entity.uri
+        modelResource: {
+            name: modelResource.name,
+            uri: modelResource.uri
         },
         delModal: {
             yes: req.i18n.__('Yes'),
@@ -23,23 +28,26 @@ export function inertiaListHelper(entity, req, fields) {
         notFoundContent: req.i18n.__('No records found !'),
         searchBtn: req.i18n.__('Search'),
         resetBtn: req.i18n.__('Reset'),
+        defaultPageSize: req.adminizer.config.list?.defaultPageSize ?? 50,
+        pageSizeOptions: [5, 20, 50],
     };
-    if (entity.config.add && req.adminizer.accessRightsHelper.hasPermission(`create-${entity.name}-model`, req.user)) {
+    if (modelResource.config.add && req.adminizer.accessRightsHelper.hasPermission(`create-${modelResource.name}-model`, req.user, `CRUD create on model "${modelResource.name}"`)) {
         props.crudActions.createTitle = req.i18n.__('create');
     }
-    if (entity.config.edit && req.adminizer.accessRightsHelper.hasPermission(`update-${entity.name}-model`, req.user)) {
+    if (modelResource.config.edit && req.adminizer.accessRightsHelper.hasPermission(`update-${modelResource.name}-model`, req.user, `CRUD update on model "${modelResource.name}"`)) {
         props.crudActions.editTitle = req.i18n.__('Edit');
     }
-    if (entity.config.view && req.adminizer.accessRightsHelper.hasPermission(`read-${entity.name}-model`, req.user)) {
+    if (modelResource.config.view && req.adminizer.accessRightsHelper.hasPermission(`read-${modelResource.name}-model`, req.user, `CRUD read on model "${modelResource.name}"`)) {
         props.crudActions.viewsTitle = req.i18n.__('View');
     }
-    if (entity.config.remove && req.adminizer.accessRightsHelper.hasPermission(`delete-${entity.name}-model`, req.user)) {
+    if (modelResource.config.remove && req.adminizer.accessRightsHelper.hasPermission(`delete-${modelResource.name}-model`, req.user, `CRUD delete on model "${modelResource.name}"`)) {
         props.crudActions.deleteTitle = req.i18n.__('Delete');
     }
-    props.actions = inertiaActionsHelper(actionType, entity, req);
-    if (req.adminizer.menuHelper.hasInlineActions(entity.config, 'list')) {
-        for (const inlineAction of req.adminizer.menuHelper.getInlineActions(entity.config, 'list')) {
-            if (req.adminizer.accessRightsHelper.hasPermission(inlineAction.accessRightsToken, req.user)) {
+    props.actions = inertiaActionsHelper(actionType, modelResource, req);
+    if (req.adminizer.menuHelper.hasInlineActions(modelResource.config, 'list')) {
+        for (const inlineAction of req.adminizer.menuHelper.getInlineActions(modelResource.config, 'list')) {
+            const context = `inline action "${inlineAction.title}" (${inlineAction.id}) on model "${modelResource.name}"`;
+            if (req.adminizer.accessRightsHelper.hasPermission(inlineAction.accessRightsToken, req.user, context)) {
                 props.inlineActions.push({
                     icon: inlineAction.icon,
                     id: inlineAction.id,
@@ -50,5 +58,11 @@ export function inertiaListHelper(entity, req, fields) {
             }
         }
     }
+    // Add filtersEnabled flag
+    props.filtersEnabled = filtersEnabled;
+    // Add active filter name if filter is applied
+    if (activeFilterName) {
+        props.activeFilterName = activeFilterName;
+    }
     return props;
 }

package/helpers/inertiaMenuHelper.d.ts

@@ -4,6 +4,7 @@ export declare class InertiaMenuHelper {
     private adminizer;
     constructor(adminizer: Adminizer);
     getMenuItems(req: ReqType): MenuItem[];
+    private filterAccessibleItems;
     private translateMenuItem;
     private translateHrefItem;
     getBrandTitle(): string;

package/helpers/inertiaMenuHelper.js

@@ -6,19 +6,31 @@ export class InertiaMenuHelper {
     getMenuItems(req) {
         const menu = [];
         for (const menuItem of this.adminizer.menuHelper.getMenuItems(req.user)) {
-            const menuItemTokens = menuItem.actions ? menuItem.actions.map(item => {
+            const filteredActions = this.filterAccessibleItems(menuItem.actions ?? [], req);
+            const menuItemTokens = filteredActions.map(item => {
                 return item.accessRightsToken;
             }).filter(item => {
                 return item;
-            }) : [];
+            });
             if (menuItem.accessRightsToken)
                 menuItemTokens.push(menuItem.accessRightsToken);
             if (this.adminizer.accessRightsHelper.enoughPermissions(menuItemTokens, req.user)) {
-                menu.push(this.translateMenuItem(req, menuItem));
+                menu.push(this.translateMenuItem(req, {
+                    ...menuItem,
+                    actions: filteredActions
+                }));
             }
         }
         return menu;
     }
+    filterAccessibleItems(items, req) {
+        return items
+            .filter((item) => !item.accessRightsToken || this.adminizer.accessRightsHelper.hasPermission(item.accessRightsToken, req.user))
+            .map((item) => ({
+            ...item,
+            subItems: item.subItems ? this.filterAccessibleItems(item.subItems, req) : item.subItems
+        }));
+    }
     translateMenuItem(req, menuItem) {
         return {
             ...menuItem,

package/helpers/inertiaUserHelper.d.ts

@@ -1,6 +1,6 @@
 import { GroupAP } from "../models/GroupAP";
 import { UserAP } from "../models/UserAP";
-import { Entity, PropsField } from "../interfaces/types";
+import { ModelResource, PropsField } from "../interfaces/types";
 interface listProps extends Record<string | number | symbol, unknown> {
     edit: boolean;
     view: boolean;
@@ -22,6 +22,7 @@ interface listProps extends Record<string | number | symbol, unknown> {
         label: string;
         postLink: string;
     };
+    apiKey?: string;
 }
-export declare function inertiaUserHelper(entity: Entity, req: ReqType, groups: GroupAP[], user?: UserAP, view?: boolean): listProps;
+export declare function inertiaUserHelper(modelResource: ModelResource, req: ReqType, groups: GroupAP[], user?: UserAP, view?: boolean): listProps;
 export {};

package/helpers/inertiaUserHelper.js

@@ -1,10 +1,10 @@
-export function inertiaUserHelper(entity, req, groups, user, view = false) {
+export function inertiaUserHelper(modelResource, req, groups, user, view = false) {
     let props = {
         edit: !!user,
         view: view,
         btnBack: {
             title: req.i18n.__('Back'),
-            link: entity.uri
+            link: modelResource.uri
         },
         userPretend: {
             label: req.i18n.__('Pretend to be a user'),
@@ -14,7 +14,7 @@ export function inertiaUserHelper(entity, req, groups, user, view = false) {
         btnSave: {
             title: req.i18n.__('Save')
         },
-        postLink: user ? `${entity.uri}/edit/${user.id}` : `${entity.uri}/add`,
+        postLink: user ? `${modelResource.uri}/edit/${user.id}` : `${modelResource.uri}/add`,
         head: req.i18n.__('User settings'),
         groupHead: req.i18n.__('User groups'),
         fields: [
@@ -111,5 +111,9 @@ export function inertiaUserHelper(entity, req, groups, user, view = false) {
             });
         }
     }
+    // Include apiKey for edit mode
+    if (user?.apiKey) {
+        props.apiKey = user.apiKey;
+    }
     return props;
 }

package/helpers/menuHelper.d.ts

@@ -13,12 +13,15 @@ export type MenuItem = {
     actions: HrefConfig[] | null;
     icon: string | null;
     accessRightsToken: string | null;
-    entityName?: string;
+    modelResourceName?: string;
     section?: string;
 };
 export declare class MenuHelper {
     private config;
     constructor(config: AdminpanelConfig);
+    private normalizePath;
+    private inferCatalogAccessToken;
+    private enrichHrefAccessToken;
     /**
      * Get menu brand title
      *
@@ -58,7 +61,7 @@ export declare class MenuHelper {
      */
     getInlineActions(modelConfig: ModelConfig, action: ActionType): HrefConfig[];
     /**
-     * Get list of entity menus that was not bound to groups
+     * Get list of ModelResource menus that was not bound to groups
      *
      * @returns {Array}
      */

package/helpers/menuHelper.js

@@ -4,6 +4,48 @@ export class MenuHelper {
     constructor(config) {
         this.config = config;
     }
+    normalizePath(path) {
+        return path.replace(/[?#].*$/, "").replace(/\/+$/, "");
+    }
+    inferCatalogAccessToken(link) {
+        if (!link || typeof link !== "string") {
+            return undefined;
+        }
+        // Skip external links.
+        if (/^[a-z][a-z0-9+.-]*:/i.test(link) || link.startsWith("//")) {
+            return undefined;
+        }
+        const routePrefix = (this.config.routePrefix || "").replace(/\/+$/, "");
+        let normalized = this.normalizePath(link);
+        if (routePrefix && normalized.startsWith(`${routePrefix}/`)) {
+            normalized = normalized.slice(routePrefix.length);
+        }
+        else if (routePrefix && normalized === routePrefix) {
+            normalized = "";
+        }
+        if (!normalized.startsWith("/")) {
+            normalized = `/${normalized}`;
+        }
+        const match = normalized.match(/^\/catalog\/([^/]+)/i);
+        if (!match?.[1]) {
+            return undefined;
+        }
+        try {
+            return `catalog-${decodeURIComponent(match[1]).toLowerCase()}`;
+        }
+        catch {
+            return `catalog-${match[1].toLowerCase()}`;
+        }
+    }
+    enrichHrefAccessToken(item) {
+        const subItems = item.subItems?.map((subItem) => this.enrichHrefAccessToken(subItem));
+        const accessRightsToken = item.accessRightsToken || this.inferCatalogAccessToken(item.link);
+        return {
+            ...item,
+            accessRightsToken,
+            subItems
+        };
+    }
     /**
      * Get menu brand title
      *
@@ -95,26 +137,36 @@ export class MenuHelper {
         return [];
     }
     /**
-     * Get list of entity menus that was not bound to groups
+     * Get list of ModelResource menus that was not bound to groups
      *
      * @returns {Array}
      */
     getMenuItems(user) {
         let menus = [];
+        const filtersDisabledGlobally = this.config.filters?.enabled === false;
         const staticLinks = this.config.navbar?.additionalLinks ?? [];
-        staticLinks.forEach(function (additionalLink) {
+        staticLinks.forEach((additionalLink) => {
+            const additionalLinkPath = typeof additionalLink.link === "string"
+                ? additionalLink.link.replace(/\/+$/, "")
+                : "";
+            const isUserFiltersLink = additionalLink.id === "user-filters"
+                || additionalLinkPath.endsWith("/user-filters");
+            if (filtersDisabledGlobally && isUserFiltersLink) {
+                return;
+            }
             if (!additionalLink.link || !additionalLink.title || additionalLink.disabled) {
                 return;
             }
+            const resolvedLink = this.enrichHrefAccessToken(additionalLink);
             menus.push({
-                link: additionalLink.link,
-                title: additionalLink.title,
-                type: additionalLink.type,
-                id: additionalLink.id || additionalLink.title.replace(" ", "_"),
-                actions: additionalLink.subItems || null,
-                icon: additionalLink.icon || null,
-                accessRightsToken: additionalLink.accessRightsToken || null,
-                section: additionalLink.section || 'Platform',
+                link: resolvedLink.link,
+                title: resolvedLink.title,
+                type: resolvedLink.type,
+                id: resolvedLink.id || resolvedLink.title.replace(" ", "_"),
+                actions: resolvedLink.subItems || null,
+                icon: resolvedLink.icon || null,
+                accessRightsToken: resolvedLink.accessRightsToken || null,
+                section: resolvedLink.section || 'Platform',
             });
         });
         if (this.config.models) {
@@ -140,9 +192,9 @@ export class MenuHelper {
                         link: _this.config.routePrefix + '/model/' + key,
                         title: val.title || key,
                         icon: val.icon || null,
-                        actions: val.tools || null,
+                        actions: val.tools ? val.tools.map((tool) => _this.enrichHrefAccessToken(tool)) : null,
                         id: val.title ? val.title.replace(" ", "_") : key,
-                        entityName: key,
+                        modelResourceName: key,
                         accessRightsToken: `read-${key}-model`,
                         section: val.navbar?.section || 'Platform',
                     });

package/helpers/viteHelper.js

@@ -1,9 +1,8 @@
 import path from "path";
 import fs from "fs";
 import chalk from "chalk";
-import { isAdminizerViteDevMode } from "./runtimeMode.js";
 export function viteRender(routePrefix, assetName) {
-    const isViteDev = isAdminizerViteDevMode();
+    const isViteDev = process.env.ADMINIZER_ENV === "dev";
     if (isViteDev) {
         return `/${assetName}`;
     }

package/index.d.ts

@@ -14,10 +14,14 @@ export * from "./lib/media-manager/MediaManagerHandler";
 export * from "./controllers/media-manager/mediaManagerAdapter";
 export * from "./interfaces/adminpanelConfig";
 export * from "./interfaces/types";
+export * from "./interfaces/queryCriteria";
+export * from "./interfaces/listQueryBuilder";
+export * from "./interfaces/internalModelAccess";
 export * from "./interfaces/MaaterialIcons";
 export * from "./lib/model/AbstractModel";
-export * from "./lib/model/adapter/waterline";
+export * from "./lib/model/InternalModelAccessFactory";
 export * from "./lib/model/adapter/sequelize";
+export * from "./lib/model/adapter/typeorm";
 export * from "./lib/media-manager/AbstractMediaManager";
 export * from "./lib/controls/AbstractControls";
 export * from "./lib/controls/ControlsHandler";
@@ -29,7 +33,6 @@ export * from "./models/MediaManagerAP";
 export * from "./models/MediaManagerAssociationsAP";
 export * from "./models/MediaManagerMetaAP";
 export * from "./models/NavigationAP";
-export * from "./migrations/index";
 export * from "./system/bindNavigation";
 export * from "./lib/helper/jwt";
 export * from "./lib/notifications/AbstractNotificationService";
@@ -37,5 +40,6 @@ export * from "./lib/POWCaptcha";
 export * from "./lib/ai-assistant/AbstractAiModelService";
 export * from "./lib/DataAccessor";
 export * from "./lib/history-actions/AbstractHistoryAdapter";
+export * from "./lib/filters/CustomFilterHandler";
 export * from "./lib/feedback/AbstractFeedbackHandler";
 export * from "./lib/feedback/FeedbackHandler";

package/index.js

@@ -14,10 +14,14 @@ export * from "./lib/media-manager/MediaManagerHandler.js";
 export * from "./controllers/media-manager/mediaManagerAdapter.js";
 export * from "./interfaces/adminpanelConfig.js";
 export * from "./interfaces/types.js";
+export * from "./interfaces/queryCriteria.js";
+export * from "./interfaces/listQueryBuilder.js";
+export * from "./interfaces/internalModelAccess.js";
 export * from "./interfaces/MaaterialIcons.js";
 export * from "./lib/model/AbstractModel.js";
-export * from "./lib/model/adapter/waterline.js";
+export * from "./lib/model/InternalModelAccessFactory.js";
 export * from "./lib/model/adapter/sequelize.js";
+export * from "./lib/model/adapter/typeorm.js";
 export * from "./lib/media-manager/AbstractMediaManager.js";
 export * from "./lib/controls/AbstractControls.js";
 export * from "./lib/controls/ControlsHandler.js";
@@ -29,7 +33,6 @@ export * from "./models/MediaManagerAP.js";
 export * from "./models/MediaManagerAssociationsAP.js";
 export * from "./models/MediaManagerMetaAP.js";
 export * from "./models/NavigationAP.js";
-export * from "./migrations/index.js";
 export * from "./system/bindNavigation.js";
 export * from "./lib/helper/jwt.js";
 export * from "./lib/notifications/AbstractNotificationService.js";
@@ -37,5 +40,6 @@ export * from "./lib/POWCaptcha.js";
 export * from "./lib/ai-assistant/AbstractAiModelService.js";
 export * from "./lib/DataAccessor.js";
 export * from "./lib/history-actions/AbstractHistoryAdapter.js";
+export * from "./lib/filters/CustomFilterHandler.js";
 export * from "./lib/feedback/AbstractFeedbackHandler.js";
 export * from "./lib/feedback/FeedbackHandler.js";

package/interfaces/adminpanelConfig.d.ts

@@ -3,6 +3,7 @@ import { EditorOptions } from "@toast-ui/editor/types/editor";
 import { GridSettings as HandsontableSettings } from "handsontable/settings";
 import { GroupAP } from "../models/GroupAP";
 import { UserAP } from "../models/UserAP";
+import { InternalModelAccessMap } from "./internalModelAccess";
 /**
  * Controller function type - async function that handles requests and returns a response
  */
@@ -13,9 +14,8 @@ export type FieldsTypes = "string" | "password" | "date" | "datetime" | "time" |
  * it will be needed only for polygon data
  */
 "geo-polygon";
-type SetFunction = (slug: string, key: string, data: any) => Promise<void>;
-type GetFunction = (slug: string, key: string) => Promise<any>;
 export type ActionType = "list" | "edit" | "add" | "remove" | "view";
+export type ListPageSize = 5 | 20 | 50;
 interface DashboardConfig {
     autoloadWidgetsPath: string;
     /**
@@ -26,6 +26,13 @@ interface DashboardConfig {
 }
 export interface AdminpanelConfig {
     routePrefix: string;
+    list?: {
+        /**
+         * Default records count per list page.
+         * @default 50
+         */
+        defaultPageSize?: ListPageSize;
+    };
     /**
      * Custom favicon URL for admin pages.
      * - absolute URL is used as-is (`https://...`, `//...`, `data:...`)
@@ -103,7 +110,7 @@ export interface AdminpanelConfig {
     /**
      * Policies that will be executed before going to every page
      * */
-    policies?: MiddlewareType[];
+    middlewares?: MiddlewareType[];
     styles?: string[];
     scripts?: {
         header?: string[];
@@ -133,34 +140,17 @@ export interface AdminpanelConfig {
         /**
          * Relative path from project root to translations folder
          * */
-        path?: string;
-        defaultLocale: string;
-    } | false;
-    /**
-     * Forms
-     * */
-    forms?: {
+        directory?: string;
         /**
-         * You can add forms directly to adminpanel configuration or put them in files with
-         * `.json` extension which should be named as form slug. Put your forms in your
-         * directory and write down path to it in `path` field.
-         */
-        path?: string;
-        /**
-         * same for model (need entity config types)
-         * */
-        data: {
-            [key: string]: FieldsForms;
-        };
-        /**
-         * Custom getter
+         * Relative path from project root to directory where missing translation keys are written in dev mode
          * */
-        get?: GetFunction;
+        missingTranslationDirectory?: string;
         /**
-         * Custom setter
-         * */
-        set?: SetFunction;
-    };
+         * @deprecated use `directory`
+         */
+        path?: string;
+        defaultLocale: string;
+    } | false;
     /**
      * Prime administrator login credentials
      * */
@@ -217,6 +207,11 @@ export interface AdminpanelConfig {
     system?: {
         /** Default ORM adapter for system models */
         defaultORM: string;
+        /**
+         * Extra internal model access scopes for modules and project code.
+         * Built-in scopes are registered by Adminizer.
+         */
+        internalModelAccess?: InternalModelAccessMap;
     };
     bind?: {
         public: boolean;
@@ -244,6 +239,64 @@ export interface AdminpanelConfig {
         adapter?: string;
         excludeModels?: string[];
     };
+    /**
+     * Filter system configuration
+     */
+    filters?: {
+        /**
+         * Global enable/disable of the filter system
+         * @default true
+         */
+        enabled?: boolean;
+    };
+    /**
+     * Filter settings for specific models
+     * @deprecated Use model-level `models.<Model>.filters` instead
+     */
+    modelFilters?: {
+        [modelName: string]: ModelFiltersConfig;
+    };
+}
+/**
+ * Filter configuration for a specific model
+ */
+export interface ModelFiltersConfig {
+    /**
+     * Enable filters for this model
+     * Works only when global filters.enabled is not false
+     * @default undefined (use global setting)
+     */
+    enabled?: boolean;
+    /**
+     * Use legacy search instead of filters
+     * @default false
+     */
+    useLegacySearch?: boolean;
+    /**
+     * Fields to exclude from auto-generated filters
+     * @example ['password', 'apiKey', 'token']
+     */
+    excludeFields?: string[];
+    /**
+     * Fields to include in auto-generated filters (whitelist mode)
+     * If specified, only these fields will have filters generated
+     * Takes priority over excludeFields
+     */
+    includeFields?: string[];
+    /**
+     * Fields to exclude from filter fields API
+     * Use this to hide specific fields from the filter UI
+     * @example ['password', 'apiKey', 'token', 'createdAt']
+     */
+    excludeFromFilters?: string[];
+    /**
+     * Custom field type overrides for filters
+     * Use this to change how a field appears in the filter UI
+     * @example { my_field: 'select' }
+     */
+    fieldTypes?: {
+        [fieldName: string]: string;
+    };
 }
 export interface ModelConfig {
     adapter?: string;
@@ -275,9 +328,13 @@ export interface ModelConfig {
         section?: string;
     };
     /**
-     * Entity fields configuration
+     * Model resource fields configuration
      * */
     fields?: FieldsModels;
+    /**
+     * Filter settings for this model
+     */
+    filters?: ModelFiltersConfig;
     /**
      * List display configuration
      * */
@@ -321,11 +378,11 @@ export interface ModelConfig {
      * */
     view?: boolean;
     /**
-     * Entity actions displayed in left navbar for specific entity
+     * Model resource actions displayed in left navbar for specific model resource
      * */
     tools?: HrefConfig[];
     /**
-     * Entity icon
+     * Model resource icon
      * */
     icon?: MaterialIcon;
     /**
@@ -348,20 +405,12 @@ export interface ModelConfig {
 type UserWithGroups = UserAP & {
     groups: GroupAP[];
 };
-export interface FieldsForms {
-    [key: string]: FormFieldConfig;
-}
 export type ModelFieldConfig = (BaseFieldConfig | TuiEditorFieldConfig) & {
     groupsAccessRights?: string[];
 };
 export interface FieldsModels {
     [key: string]: ModelFieldConfig;
 }
-interface FormFieldConfig extends BaseFieldConfig {
-    value?: any;
-    required?: boolean;
-    description?: string;
-}
 export interface BaseFieldConfig {
     title?: string;
     type?: FieldsTypes;
@@ -396,6 +445,44 @@ export interface BaseFieldConfig {
     required?: boolean;
     /** show or hode element, default `true` */
     visible?: boolean;
+    /**
+     * Allow inline editing of this field in list view
+     * Inline editing is enabled by default for supported field types.
+     * Set to false to explicitly disable inline editing for this field.
+     */
+    inlineEditable?: boolean;
+    /**
+     * Validation rules for inline editing
+     * Applied when field is updated via inline edit
+     */
+    inlineValidation?: {
+        /** Minimum length for string fields */
+        minLength?: number;
+        /** Maximum length for string fields */
+        maxLength?: number;
+        /** Minimum value for number fields */
+        min?: number;
+        /** Maximum value for number fields */
+        max?: number;
+        /** Regex pattern for validation */
+        pattern?: string;
+        /** Custom validation function */
+        validate?: (value: any) => boolean | string;
+    };
+    /**
+     * Attach a custom filter handler to this field.
+     * Handler must be registered in Adminizer instance via `customFilterHandler`.
+     */
+    customFilter?: {
+        /**
+         * Handler ID in format "ModelName.fieldName"
+         */
+        handlerId: string;
+        /**
+         * @deprecated Condition label is taken from handler class `name`
+         */
+        label?: string;
+    };
 }
 export interface TuiEditorFieldConfig extends BaseFieldConfig {
     type: 'tui' | 'tuieditor' | 'toast-ui';

package/interfaces/internalModelAccess.d.ts

@@ -0,0 +1,37 @@
+import { IsAny, QueryCriteria } from "./queryCriteria";
+export type InternalModelAccessScope = string;
+export type InternalModelAccessMap = Record<InternalModelAccessScope, string[]>;
+export type InternalModelRelationId = string | number;
+export type InternalModelWriteFieldValue<TValue> = NonNullable<TValue> extends Array<infer Item> ? Item extends {
+    id?: unknown;
+} ? TValue | InternalModelRelationId[] : TValue : NonNullable<TValue> extends {
+    id?: unknown;
+} ? TValue | InternalModelRelationId : TValue;
+type RequiredFieldKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];
+type OptionalFieldKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
+}[keyof T];
+export type InternalModelCreateData<T = any> = IsAny<T> extends true ? Record<string, any> : {
+    [K in RequiredFieldKeys<T>]: InternalModelWriteFieldValue<T[K]>;
+} & {
+    [K in OptionalFieldKeys<T>]?: InternalModelWriteFieldValue<T[K]>;
+};
+export type InternalModelUpdateData<T = any> = IsAny<T> extends true ? Record<string, any> : {
+    [Field in keyof T]?: InternalModelWriteFieldValue<T[Field]>;
+};
+/** @deprecated Use `InternalModelCreateData` for create or `InternalModelUpdateData` for update. */
+export type InternalModelWriteData<T = any> = InternalModelUpdateData<T>;
+export interface InternalModelRepository<T = any> {
+    readonly name: string;
+    find(criteria?: QueryCriteria<T>): Promise<T[]>;
+    findOne(criteria?: QueryCriteria<T>): Promise<T | null>;
+    count(criteria?: QueryCriteria<T>): Promise<number>;
+    create(data: InternalModelCreateData<T>): Promise<T>;
+    update(criteria: QueryCriteria<T>, data: InternalModelUpdateData<T>): Promise<T[]>;
+    updateOne(criteria: QueryCriteria<T>, data: InternalModelUpdateData<T>): Promise<T | null>;
+    destroy(criteria: QueryCriteria<T>): Promise<T[]>;
+    destroyOne(criteria: QueryCriteria<T>): Promise<T | null>;
+}
+export {};

package/interfaces/internalModelAccess.js

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