adminizer 5.0.0-build.0 → 5.0.0-build.10

package/lib/feedback/FeedbackHandler.d.ts

@@ -1,5 +1,5 @@
-import { Adminizer } from '../Adminizer';
-import { AbstractFeedbackHandler } from './AbstractFeedbackHandler';
+import { Adminizer } from '../Adminizer.js';
+import { AbstractFeedbackHandler } from './AbstractFeedbackHandler.js';
 export declare class FeedbackHandler {
     private handler;
     private adminizer;

package/lib/filters/ConditionValidator.d.ts

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

package/lib/filters/FilterCustomFieldHandler.d.ts

@@ -1,2 +1,2 @@
-export * from './CustomFilterHandler';
-export { default } from './CustomFilterHandler';
+export * from './CustomFilterHandler.js';
+export { default } from './CustomFilterHandler.js';

package/lib/filters/FilterService.d.ts

@@ -1,7 +1,7 @@
-import { Adminizer } from '../Adminizer';
-import { Filter } from '../../models/Filter';
-import { FilterColumn } from '../../models/FilterColumn';
-import { User } from '../../models/User';
+import { Adminizer } from '../Adminizer.js';
+import { Filter } from '../../models/Filter.js';
+import { FilterColumn } from '../../models/FilterColumn.js';
+import { User } from '../../models/User.js';
 /**
  * FilterService - manages filter operations
  *

package/lib/filters/index.d.ts

@@ -1,6 +1,6 @@
-export { FilterService, default as FilterServiceDefault } from './FilterService';
-export { CustomFilterHandler, default as CustomFilterHandlerDefault } from './CustomFilterHandler';
-export { AbstractCustomFilter } from './CustomFilterHandler';
-export type { FilterCustomFieldCondition, RegisterOptions, FilterCustomFieldInputConfig, FilterCustomFieldInputDefinition, FilterCustomFieldInputType } from './CustomFilterHandler';
-export { ConditionValidator, default as ConditionValidatorDefault } from './ConditionValidator';
-export type { ValidationResult, ValidationError, FieldConfig, SecurityEvent, SecurityEventType } from './ConditionValidator';
+export { FilterService, default as FilterServiceDefault } from './FilterService.js';
+export { CustomFilterHandler, default as CustomFilterHandlerDefault } from './CustomFilterHandler.js';
+export { AbstractCustomFilter } from './CustomFilterHandler.js';
+export type { FilterCustomFieldCondition, RegisterOptions, FilterCustomFieldInputConfig, FilterCustomFieldInputDefinition, FilterCustomFieldInputType } from './CustomFilterHandler.js';
+export { ConditionValidator, default as ConditionValidatorDefault } from './ConditionValidator.js';
+export type { ValidationResult, ValidationError, FieldConfig, SecurityEvent, SecurityEventType } from './ConditionValidator.js';

package/lib/history-actions/AbstractHistoryAdapter.d.ts

@@ -1,9 +1,9 @@
-import { HistoryActions } from "../../models/HistoryActions";
-import { User } from "../../models/User";
-import { Adminizer } from "../Adminizer";
-import { Fields } from "../../helpers/fieldsHelper";
-import { ActionType } from "../../interfaces/adminpanelConfig";
-import { ModelResource } from "../../interfaces/types";
+import { HistoryActions } from "../../models/HistoryActions.js";
+import { User } from "../../models/User.js";
+import { Adminizer } from "../Adminizer.js";
+import { Fields } from "../../helpers/fieldsHelper.js";
+import { ActionType } from "../../interfaces/adminpanelConfig.js";
+import { ModelResource } from "../../interfaces/types.js";
 /**
  * Abstract base class for handling history operations in the AdminPanel.
  * Provides common methods and structure for retrieving, filtering, and formatting historical data.

package/lib/history-actions/DefaultHistoryAdapter.d.ts

@@ -1,7 +1,7 @@
-import { HistoryActions } from "../../models/HistoryActions";
-import { User } from "../../models/User";
-import { Adminizer } from "../Adminizer";
-import { AbstractHistoryAdapter } from "./AbstractHistoryAdapter";
+import { HistoryActions } from "../../models/HistoryActions.js";
+import { User } from "../../models/User.js";
+import { Adminizer } from "../Adminizer.js";
+import { AbstractHistoryAdapter } from "./AbstractHistoryAdapter.js";
 export declare class DefaultHistoryAdapter extends AbstractHistoryAdapter {
     id: string;
     model: string;

package/lib/history-actions/HistoryHandler.d.ts

@@ -1,4 +1,4 @@
-import { AbstractHistoryAdapter } from "./AbstractHistoryAdapter";
+import { AbstractHistoryAdapter } from "./AbstractHistoryAdapter.js";
 export declare class HistoryHandler {
     private adapters;
     add(adapter: AbstractHistoryAdapter): void;

package/lib/list-query-builder/ListQueryBuilder.d.ts

@@ -1,10 +1,10 @@
-import { Fields } from '../../helpers/fieldsHelper';
-import { AbstractModel } from '../model/AbstractModel';
-import { DataAccessor } from '../DataAccessor';
-import { FilterOperator } from '../../models/Filter';
-import { CustomFilterHandler } from '../filters/CustomFilterHandler';
-import { ListQueryBuilderParams, ListQueryBuilderResult } from '../../interfaces/listQueryBuilder';
-import { CriteriaWhere } from '../../interfaces/queryCriteria';
+import { Fields } from '../../helpers/fieldsHelper.js';
+import { AbstractModel } from '../model/AbstractModel.js';
+import { DataAccessor } from '../DataAccessor.js';
+import { FilterOperator } from '../../models/Filter.js';
+import { CustomFilterHandler } from '../filters/CustomFilterHandler.js';
+import { ListQueryBuilderParams, ListQueryBuilderResult } from '../../interfaces/listQueryBuilder.js';
+import { CriteriaWhere } from '../../interfaces/queryCriteria.js';
 /**
  * Security limits for filter conditions
  */

package/lib/media-manager/AbstractMediaManager.d.ts

@@ -1,5 +1,5 @@
-import type { MediaManagerMetaAP } from "../../models/MediaManagerMetaAP";
-import { Adminizer } from "../Adminizer";
+import type { MediaManagerMetaAP } from "../../models/MediaManagerMetaAP.js";
+import { Adminizer } from "../Adminizer.js";
 export interface MediaManagerItem {
     id?: string;
     parent: string | null;

package/lib/media-manager/MediaManagerHandler.d.ts

@@ -1,4 +1,4 @@
-import { AbstractMediaManager } from "./AbstractMediaManager";
+import { AbstractMediaManager } from "./AbstractMediaManager.js";
 export declare class MediaManagerHandler {
     private managers;
     add(manager: AbstractMediaManager): void;

package/lib/media-manager/Thumb.d.ts

@@ -1,4 +1,4 @@
-import { Adminizer } from "../Adminizer";
+import { Adminizer } from "../Adminizer.js";
 export declare class MediaManagerThumb {
     static getThumb(id: string, managerId: string, adminizer: Adminizer): Promise<NonSharedBuffer>;
 }

package/lib/media-manager/helpers/MediaManagerHelper.d.ts

@@ -1,8 +1,8 @@
-import { Fields } from "../../../helpers/fieldsHelper";
-import { MediaManagerWidgetData, MediaManagerItem, MediaManagerWidgetItem, MediaManagerWidgetJSON } from "../AbstractMediaManager";
-import { BaseFieldConfig } from "../../../interfaces/adminpanelConfig";
-import { Adminizer } from "../../Adminizer";
-import type { AppRuntime } from "../../app-manager/AdminizerApp";
+import { Fields } from "../../../helpers/fieldsHelper.js";
+import { MediaManagerWidgetData, MediaManagerItem, MediaManagerWidgetItem, MediaManagerWidgetJSON } from "../AbstractMediaManager.js";
+import { BaseFieldConfig } from "../../../interfaces/adminpanelConfig.js";
+import { Adminizer } from "../../Adminizer.js";
+import type { AppRuntime } from "../../app-manager/AdminizerApp.js";
 type PostParams = Record<string, string | number | boolean | object | string[] | number[] | null>;
 export declare function isMediaManagerFieldConfig(fieldConfig: BaseFieldConfig): boolean;
 export declare function normalizeMediaManagerWidgetData(value: PostParams[string] | undefined, prop: string): MediaManagerWidgetData[];

package/lib/model/AbstractModel.d.ts

@@ -1,8 +1,13 @@
-import { DataAccessor } from "../DataAccessor";
-import { QueryCriteria } from "../../interfaces/queryCriteria";
-import { InternalModelRepository } from "../../interfaces/internalModelAccess";
+import { DataAccessor } from "../DataAccessor.js";
+import { QueryCriteria } from "../../interfaces/queryCriteria.js";
+import { InternalModelRepository } from "../../interfaces/internalModelAccess.js";
 export interface Attribute {
-    type: 'association' | 'association-many' | 'number' | 'json' | 'string' | 'boolean' | 'ref';
+    /**
+     * `date` covers every temporal column (date, time, timestamp). It is deliberately
+     * separate from `string`: dates must not take part in LIKE search, and the UI
+     * renders them with date controls.
+     */
+    type: 'association' | 'association-many' | 'number' | 'json' | 'string' | 'boolean' | 'date' | 'ref';
     required?: boolean;
     unique?: boolean;
     defaultsTo?: any;

package/lib/model/InternalModelAccessFactory.d.ts

@@ -1,5 +1,5 @@
-import { InternalModelAccessMap, InternalModelRepository } from "../../interfaces/internalModelAccess";
-import { AbstractModel } from "./AbstractModel";
+import { InternalModelAccessMap, InternalModelRepository } from "../../interfaces/internalModelAccess.js";
+import { AbstractModel } from "./AbstractModel.js";
 export declare const DEFAULT_INTERNAL_MODEL_ACCESS: InternalModelAccessMap;
 export declare class InternalModelScope {
     private readonly getModel;

package/lib/model/ModelHandler.d.ts

@@ -1,6 +1,6 @@
-import { AbstractModel } from "./AbstractModel";
-import { InternalModelAccessMap, InternalModelRepository } from "../../interfaces/internalModelAccess";
-import { InternalModelScope } from "./InternalModelAccessFactory";
+import { AbstractModel } from "./AbstractModel.js";
+import { InternalModelAccessMap, InternalModelRepository } from "../../interfaces/internalModelAccess.js";
+import { InternalModelScope } from "./InternalModelAccessFactory.js";
 export interface AppModelAccessRecord {
     id: string;
     appName: string;

package/lib/model/adapter/sequelize.d.ts

@@ -1,9 +1,11 @@
-import { Sequelize, ModelStatic } from "sequelize";
-import { AbstractAdapter, AbstractAdapterOptions, AbstractModel, Attribute } from "../AbstractModel";
-import { QueryCriteria } from "../../../interfaces/queryCriteria";
+import type { ModelStatic, Sequelize as SequelizeType } from "sequelize";
+import { AbstractAdapter, AbstractAdapterOptions, AbstractModel, Attribute } from "../AbstractModel.js";
+import { QueryCriteria } from "../../../interfaces/queryCriteria.js";
 export declare function mapSequelizeToAdminizerAttributes(model: ModelStatic<any>): Record<string, Attribute>;
 export declare class SequelizeModel<T> extends AbstractModel<T> {
     private model;
+    private _init;
+    private _ensure;
     constructor(modelName: string, model: ModelStatic<any>);
     private _buildJsonContainsCondition;
     _convertCriteriaToSequelize(criteria: any): any;
@@ -45,9 +47,9 @@ export declare class SequelizeModel<T> extends AbstractModel<T> {
     private _buildCriteriaIncludes;
 }
 export declare class SequelizeAdapter extends AbstractAdapter {
-    sequelize: Sequelize;
+    sequelize: SequelizeType;
     Model: typeof SequelizeModel;
-    constructor(sequelize: Sequelize, options?: AbstractAdapterOptions);
+    constructor(sequelize: SequelizeType, options?: AbstractAdapterOptions);
     get models(): Record<string, any>;
     getModel(modelName: string): any;
     getAttributes(modelName: string): any;

package/lib/model/adapter/sequelize.js

@@ -1,5 +1,16 @@
-import { Sequelize, Op, HasMany } from "sequelize";
 import { AbstractAdapter, AbstractModel } from "../AbstractModel.js";
+let _Sequelize = null;
+let _Op = null;
+let _HasMany = null;
+async function ensureSequelize() {
+    if (_Sequelize)
+        return _Sequelize;
+    const sequelize = await import('sequelize');
+    _Sequelize = sequelize.Sequelize;
+    _Op = sequelize.Op;
+    _HasMany = sequelize.HasMany;
+    return _Sequelize;
+}
 function resolveType(type) {
     const sqlType = typeof type.toString === "function"
         ? type.toString().toLowerCase()
@@ -17,8 +28,10 @@ function resolveType(type) {
         return "number";
     if (sqlType.includes("json"))
         return "json";
-    if (sqlType.includes("date"))
-        return "string";
+    // Sequelize renders temporal types per dialect: sqlite gives DATETIME/DATE,
+    // postgres TIMESTAMP WITH TIME ZONE, mysql DATETIME/TIMESTAMP. Match all of them.
+    if (sqlType.includes("date") || sqlType.includes("time"))
+        return "date";
     return "ref";
 }
 export function mapSequelizeToAdminizerAttributes(model) {
@@ -92,6 +105,13 @@ function capitalize(str) {
 }
 export class SequelizeModel extends AbstractModel {
     model;
+    _init = false;
+    async _ensure() {
+        if (!this._init) {
+            await ensureSequelize();
+            this._init = true;
+        }
+    }
     constructor(modelName, model) {
         super(modelName, mapSequelizeToAdminizerAttributes(model), model.primaryKeyAttribute, model.name);
         this.model = model;
@@ -100,7 +120,7 @@ export class SequelizeModel extends AbstractModel {
         const pattern = `%${JSON.stringify(item).replace(/[%_]/g, "\\$&")}%`;
         const attribute = this.model.rawAttributes?.[targetKey];
         const columnName = typeof attribute?.field === "string" ? attribute.field : targetKey;
-        return Sequelize.where(Sequelize.cast(Sequelize.col(`${this.model.name}.${columnName}`), "TEXT"), { [Op.like]: pattern });
+        return _Sequelize.where(_Sequelize.cast(_Sequelize.col(`${this.model.name}.${columnName}`), "TEXT"), { [_Op.like]: pattern });
     }
     _convertCriteriaToSequelize(criteria) {
         // Special handling for Sequelize.literal() at the top level
@@ -135,24 +155,24 @@ export class SequelizeModel extends AbstractModel {
             }
             // Special handling for null values (IS NULL condition)
             if (value === null) {
-                result[targetKey] = { [Op.is]: null };
+                result[targetKey] = { [_Op.is]: null };
                 continue;
             }
             // 🔹 Handle Sequelize Op operators (already in Sequelize format)
-            if (key === Op.and || key === 'and') {
-                result[Op.and] = Array.isArray(value)
+            if (key === _Op.and || key === 'and') {
+                result[_Op.and] = Array.isArray(value)
                     ? value.map((item) => this._convertCriteriaToSequelize(item))
                     : [];
                 continue;
             }
-            if (key === Op.or || key === 'or') {
-                result[Op.or] = Array.isArray(value)
+            if (key === _Op.or || key === 'or') {
+                result[_Op.or] = Array.isArray(value)
                     ? value.map((item) => this._convertCriteriaToSequelize(item))
                     : [];
                 continue;
             }
-            if (key === Op.not || key === 'not' || key === '$not') {
-                result[Op.not] = this._convertCriteriaToSequelize(value);
+            if (key === _Op.not || key === 'not' || key === '$not') {
+                result[_Op.not] = this._convertCriteriaToSequelize(value);
                 continue;
             }
             // Skip Symbol keys that are not handled above (should not happen, but safety check)
@@ -161,7 +181,7 @@ export class SequelizeModel extends AbstractModel {
             }
             if (Array.isArray(value)) {
                 // ✅ Array processing - use the IN operator
-                result[targetKey] = { [Op.in]: value };
+                result[targetKey] = { [_Op.in]: value };
             }
             else if (typeof value === "object" && !Array.isArray(value)) {
                 // Check if value already contains Sequelize Op operators
@@ -171,10 +191,10 @@ export class SequelizeModel extends AbstractModel {
                 // Helper function to check if a symbol/op is a Sequelize operator
                 const isSequelizeOp = (op) => {
                     // Check direct Symbol equality first
-                    if (op === Op.gt || op === Op.gte || op === Op.lt || op === Op.lte ||
-                        op === Op.eq || op === Op.ne || op === Op.in || op === Op.notIn ||
-                        op === Op.like || op === Op.iLike || op === Op.between ||
-                        op === Op.startsWith || op === Op.endsWith || op === Op.is || op === Op.not) {
+                    if (op === _Op.gt || op === _Op.gte || op === _Op.lt || op === _Op.lte ||
+                        op === _Op.eq || op === _Op.ne || op === _Op.in || op === _Op.notIn ||
+                        op === _Op.like || op === _Op.iLike || op === _Op.between ||
+                        op === _Op.startsWith || op === _Op.endsWith || op === _Op.is || op === _Op.not) {
                         return true;
                     }
                     // Fallback: check by Symbol description (handles different Symbol instances)
@@ -204,22 +224,22 @@ export class SequelizeModel extends AbstractModel {
                         continue;
                     switch (op) {
                         case "eq":
-                            result[targetKey] = { [Op.eq]: val };
+                            result[targetKey] = { [_Op.eq]: val };
                             break;
                         case "ne":
-                            result[targetKey] = { [Op.ne]: val };
+                            result[targetKey] = { [_Op.ne]: val };
                             break;
                         case "gt":
-                            result[targetKey] = { [Op.gt]: val };
+                            result[targetKey] = { [_Op.gt]: val };
                             break;
                         case "gte":
-                            result[targetKey] = { [Op.gte]: val };
+                            result[targetKey] = { [_Op.gte]: val };
                             break;
                         case "lt":
-                            result[targetKey] = { [Op.lt]: val };
+                            result[targetKey] = { [_Op.lt]: val };
                             break;
                         case "lte":
-                            result[targetKey] = { [Op.lte]: val };
+                            result[targetKey] = { [_Op.lte]: val };
                             break;
                         case "contains":
                             // Check if field is a date/datetime type
@@ -242,83 +262,83 @@ export class SequelizeModel extends AbstractModel {
                                 }
                                 else {
                                     // Valid date - use exact match
-                                    result[targetKey] = { [Op.eq]: dateValue };
+                                    result[targetKey] = { [_Op.eq]: dateValue };
                                 }
                             }
                             else {
                                 // For time fields and non-date fields - use Op.like with wildcards
-                                result[targetKey] = { [Op.like]: `%${val}%` };
+                                result[targetKey] = { [_Op.like]: `%${val}%` };
                             }
                             break;
                         case "startsWith":
-                            result[targetKey] = { [Op.startsWith]: val };
+                            result[targetKey] = { [_Op.startsWith]: val };
                             break;
                         case "endsWith":
-                            result[targetKey] = { [Op.endsWith]: val };
+                            result[targetKey] = { [_Op.endsWith]: val };
                             break;
                         case ">":
-                            result[targetKey] = { [Op.gt]: val };
+                            result[targetKey] = { [_Op.gt]: val };
                             break;
                         case ">=":
-                            result[targetKey] = { [Op.gte]: val };
+                            result[targetKey] = { [_Op.gte]: val };
                             break;
                         case "<":
-                            result[targetKey] = { [Op.lt]: val };
+                            result[targetKey] = { [_Op.lt]: val };
                             break;
                         case "<=":
-                            result[targetKey] = { [Op.lte]: val };
+                            result[targetKey] = { [_Op.lte]: val };
                             break;
                         case "!=":
-                            result[targetKey] = { [Op.ne]: val };
+                            result[targetKey] = { [_Op.ne]: val };
                             break;
                         case "in":
-                            result[targetKey] = { [Op.in]: val };
+                            result[targetKey] = { [_Op.in]: val };
                             break;
                         case "notIn":
-                            result[targetKey] = { [Op.notIn]: val };
+                            result[targetKey] = { [_Op.notIn]: val };
                             break;
                         case "nin":
-                            result[targetKey] = { [Op.notIn]: val };
+                            result[targetKey] = { [_Op.notIn]: val };
                             break;
                         case "between":
-                            result[targetKey] = { [Op.between]: val };
+                            result[targetKey] = { [_Op.between]: val };
                             break;
                         case "isNull":
                             if (val) {
-                                result[targetKey] = { [Op.is]: null };
+                                result[targetKey] = { [_Op.is]: null };
                             }
                             break;
                         case "isNotNull":
                             if (val) {
-                                result[targetKey] = { [Op.not]: null };
+                                result[targetKey] = { [_Op.not]: null };
                             }
                             break;
                         case "regex":
-                            result[targetKey] = { [Op.regexp]: val };
+                            result[targetKey] = { [_Op.regexp]: val };
                             break;
                         case "jsonContains": {
                             const values = Array.isArray(val) ? val : [val];
                             const clauses = values.map((item) => this._buildJsonContainsCondition(targetKey, item));
-                            result[Op.and] = [
-                                ...(result[Op.and] ?? []),
+                            result[_Op.and] = [
+                                ...(result[_Op.and] ?? []),
                                 ...clauses
                             ];
                             break;
                         }
                         case "$is":
-                            result[targetKey] = { [Op.is]: val };
+                            result[targetKey] = { [_Op.is]: val };
                             break;
                         case "$not":
-                            result[targetKey] = { [Op.not]: val };
+                            result[targetKey] = { [_Op.not]: val };
                             break;
                         case "$ne":
-                            result[targetKey] = { [Op.ne]: val };
+                            result[targetKey] = { [_Op.ne]: val };
                             break;
                         case "not":
-                            result[targetKey] = { [Op.not]: val };
+                            result[targetKey] = { [_Op.not]: val };
                             break;
                         default:
-                            result[targetKey] = { [Op.eq]: val };
+                            result[targetKey] = { [_Op.eq]: val };
                     }
                 }
             }
@@ -401,6 +421,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- CREATE ---
     async _create(data) {
+        await this._ensure();
         // console.clear()
         const assocNames = Object.keys(this.model.associations);
         const plainData = {};
@@ -472,6 +493,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- FIND ONE ---
     async _findOne(criteria) {
+        await this._ensure();
         // console.debug(">> _findOne: input criteria:", criteria);
         const { where, attributes } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
         const includes = criteria.populate
@@ -498,6 +520,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- FIND MANY ---
     async _find(criteria = {}) {
+        await this._ensure();
         const assocNames = Object.keys(this.model.associations);
         // console.debug(">> _find: input criteria:", criteria, "options:", options);
         const { where, limit, offset, order, attributes } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
@@ -553,6 +576,7 @@ export class SequelizeModel extends AbstractModel {
      * Bypasses Adminizer criteria conversion for direct Sequelize usage
      */
     async findWithRawWhere(where, options = {}) {
+        await this._ensure();
         const assocNames = Object.keys(this.model.associations);
         const includes = options.populate !== false
             ? assocNames.map(a => ({ association: a }))
@@ -570,6 +594,7 @@ export class SequelizeModel extends AbstractModel {
      * Public method for count with raw SQL where clauses
      */
     async countWithRawWhere(where) {
+        await this._ensure();
         const assocNames = Object.keys(this.model.associations);
         const include = assocNames.map((association) => ({ association }));
         return await this.model.count({
@@ -581,6 +606,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- UPDATE ONE ---
     async _updateOne(criteria, data) {
+        await this._ensure();
         const { where } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
         const record = await this.model.findOne({ where });
         if (!record)
@@ -612,6 +638,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- UPDATE MANY ---
     async _update(criteria, data) {
+        await this._ensure();
         const { where } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
         const assocNames = Object.keys(this.model.associations);
         const plainData = {};
@@ -646,6 +673,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- DESTROY ONE ---
     async _destroyOne(criteria) {
+        await this._ensure();
         const { where } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
         const record = await this.model.findOne({ where });
         if (!record)
@@ -681,6 +709,7 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- DESTROY MANY ---
     async _destroy(criteria) {
+        await this._ensure();
         const { where } = this._convertAdminizerCriteriaToSequelizeOptions(criteria);
         const records = await this.model.findAll({ where });
         const assocNames = Object.keys(this.model.associations);
@@ -785,7 +814,7 @@ export class SequelizeModel extends AbstractModel {
         }
         const association = this.model.associations[alias];
         const isUsedInWhere = usedRelationAliases.has(alias);
-        const isHasMany = association instanceof HasMany || association?.associationType === 'HasMany';
+        const isHasMany = association instanceof _HasMany || association?.associationType === 'HasMany';
         // When filtering by relation path ($alias.field$), extra joined hasMany associations
         // can duplicate base rows and break page size. Load such associations separately.
         if (isHasMany && !isUsedInWhere) {
@@ -841,10 +870,14 @@ export class SequelizeAdapter extends AbstractAdapter {
     sequelize;
     Model = SequelizeModel;
     constructor(sequelize, options = {}) {
+        ensureSequelize();
         super("sequelize", sequelize, options);
+        // Note: ensureSequelize is fire-and-forget during construction
+        // Methods also call this._ensure() to guarantee initialization
         this.sequelize = sequelize;
     }
     get models() {
+        ``;
         return this.sequelize.models;
     }
     getModel(modelName) {

package/lib/model/adapter/typeorm.d.ts

@@ -1,6 +1,6 @@
 import { DataSource, EntityMetadata, EntitySchema, ObjectLiteral } from "typeorm";
-import { AbstractAdapter, AbstractAdapterOptions, AbstractModel, ModelAttributes } from "../AbstractModel";
-import { QueryCriteria } from "../../../interfaces/queryCriteria";
+import { AbstractAdapter, AbstractAdapterOptions, AbstractModel, ModelAttributes } from "../AbstractModel.js";
+import { QueryCriteria } from "../../../interfaces/queryCriteria.js";
 /**
  * Experimental TypeORM adapter.
  *

package/lib/model/adapter/typeorm.js

@@ -24,7 +24,7 @@ function resolveAdminizerTypeFromColumn(column) {
     if (type.includes("json"))
         return "json";
     if (type.includes("date") || type.includes("time"))
-        return "string";
+        return "date";
     if (type.includes("char") || type.includes("text") || type.includes("uuid") || type.includes("string")) {
         return "string";
     }

package/lib/model/internalModelRepository.d.ts

@@ -1,3 +1,3 @@
-import { InternalModelRepository } from "../../interfaces/internalModelAccess";
-import { AbstractModel } from "./AbstractModel";
+import { InternalModelRepository } from "../../interfaces/internalModelAccess.js";
+import { AbstractModel } from "./AbstractModel.js";
 export declare function createInternalModelRepository<T>(modelName: string, model: AbstractModel<T>): InternalModelRepository<T>;

package/lib/notifications/AbstractNotificationService.d.ts

@@ -1,8 +1,8 @@
 import { EventEmitter } from 'events';
-import { Adminizer } from '../Adminizer';
-import { INotification, INotificationEvent } from '../../interfaces/types';
-import { NotificationModel } from "../../models/Notification";
-import { User } from "../../models/User";
+import { Adminizer } from '../Adminizer.js';
+import { INotification, INotificationEvent } from '../../interfaces/types.js';
+import { NotificationModel } from "../../models/Notification.js";
+import { User } from "../../models/User.js";
 /**
  * ░█████╗░██████╗░░██████╗████████╗██████╗░░█████╗░░█████╗░████████╗
  * ██╔══██╗██╔══██╗██╔════╝╚══██╔══╝██╔══██╗██╔══██╗██╔══██╗╚══██╔══╝

package/lib/notifications/GeneralNotificationService.d.ts

@@ -1,5 +1,5 @@
-import { AbstractNotificationService } from './AbstractNotificationService';
-import { INotification } from '../../interfaces/types';
+import { AbstractNotificationService } from './AbstractNotificationService.js';
+import { INotification } from '../../interfaces/types.js';
 export declare class GeneralNotificationService extends AbstractNotificationService {
     readonly notificationClass = "general";
     readonly displayName: string;

package/lib/notifications/GeneralNotificationService.js

@@ -6,16 +6,17 @@ export class GeneralNotificationService extends AbstractNotificationService {
     icon = 'info';
     iconColor = '#5987de';
     async dispatchNotification(notification) {
+        const { userId, ...notificationData } = notification;
         const fullNotification = {
-            ...notification,
+            ...notificationData,
             notificationClass: this.notificationClass
         };
         let notificationDB;
         try {
             notificationDB = await this.notificationModel().create(fullNotification);
-            if (notification.userId) {
+            if (userId) {
                 // For specific user
-                await this.createUserNotification(notificationDB.id, notification.userId);
+                await this.createUserNotification(notificationDB.id, userId);
             }
             else {
                 // For all users
@@ -45,7 +46,7 @@ export class GeneralNotificationService extends AbstractNotificationService {
                     },
                 },
                 notificationClass: this.notificationClass,
-                userId: notification.userId ?? null
+                userId: userId ?? null
             };
             this.broadcast(event);
             Adminizer.log.info(`[General] Notification dispatched: ${fullNotification.title}`);