adminizer 4.1.0-commit.d8a06d3 → 4.1.1

package/lib/v4/model/adapter/sequelize.js

@@ -3,6 +3,64 @@ import { AbstractAdapter, AbstractModel } from "../AbstractModel";
 import path from "path";
 import fs from "fs";
 import { pathToFileURL } from "url";
+function generateAssociationsFromSchema(models, schemas) {
+    for (const modelName in schemas) {
+        const schema = schemas[modelName];
+        const model = models[modelName];
+        if (!model)
+            continue;
+        for (const fieldName in schema) {
+            const field = schema[fieldName];
+            if (field.collection && field.via) {
+                const targetModel = models[field.collection];
+                const targetSchema = schemas[field.collection];
+                const inverseField = targetSchema?.[field.via];
+                const throughTableName = [modelName, field.collection].sort().join("");
+                // 💡 M:N связь
+                if (inverseField && inverseField.collection === modelName) {
+                    model.belongsToMany(targetModel, {
+                        through: throughTableName,
+                        as: fieldName,
+                        foreignKey: `${modelName}Id`,
+                        otherKey: `${field.collection}Id`
+                    });
+                }
+                // 💡 O:M связь (один ко многим)
+                else {
+                    model.hasMany(targetModel, {
+                        as: fieldName,
+                        foreignKey: `${modelName}Id`,
+                    });
+                    targetModel.belongsTo(model, {
+                        as: field.via,
+                        foreignKey: `${modelName}Id`,
+                    });
+                }
+            }
+            // 💡 O:1 или 1:1 (belongsTo)
+            if (field.model) {
+                const targetModel = models[field.model];
+                if (!targetModel)
+                    continue;
+                // Avoid naming collision by making FK explicit: `${fieldName}Id`
+                const foreignKey = `${fieldName}Id`;
+                const alias = fieldName;
+                // Если поле уже существует — избегаем конфликта
+                if (model.rawAttributes[alias]) {
+                    model.belongsTo(targetModel, {
+                        as: alias,
+                        foreignKey,
+                    });
+                }
+                else {
+                    model.belongsTo(targetModel, {
+                        foreignKey: alias, // если нет конфликта, можно использовать alias как FK
+                    });
+                }
+            }
+        }
+    }
+}
 function resolveType(type) {
     const sqlType = typeof type.toString === "function"
         ? type.toString().toLowerCase()
@@ -38,18 +96,20 @@ export function mapSequelizeToWaterline(model) {
         switch (assoc.associationType) {
             case "BelongsTo": {
                 const a = assoc;
+                result[a.foreignKey]["primaryKeyForAssociation"] = true;
                 result[alias] = {
                     type: "association",
-                    model: a.target.name.toLowerCase(),
+                    model: a.target.name,
                     via: a.foreignKey,
                 };
                 break;
             }
             case "HasOne": {
                 const a = assoc;
+                result[a.foreignKey]["primaryKeyForAssociation"] = true;
                 result[alias] = {
                     type: "association",
-                    model: a.target.name.toLowerCase(),
+                    model: a.target.name,
                     via: a.foreignKey,
                 };
                 break;
@@ -58,7 +118,7 @@ export function mapSequelizeToWaterline(model) {
                 const a = assoc;
                 result[alias] = {
                     type: "association-many",
-                    collection: a.target.name.toLowerCase(),
+                    collection: a.target.name,
                     via: a.foreignKey,
                 };
                 break;
@@ -67,7 +127,7 @@ export function mapSequelizeToWaterline(model) {
                 const a = assoc;
                 result[alias] = {
                     type: "association-many",
-                    collection: a.target.name.toLowerCase(),
+                    collection: a.target.name,
                     via: a.otherKey,
                 };
                 break;
@@ -78,113 +138,109 @@ export function mapSequelizeToWaterline(model) {
     }
     return result;
 }
-// function resolveType(type: any): AbstractFieldType {
-//   try {
-//     const sqlType = typeof type.toString === "function"
-//       ? type.toString().toLowerCase()
-//       : "";
-//     if (sqlType.includes("string")) return "string";
-//     if (sqlType.includes("uuid")) return "string";
-//     if (sqlType.includes("int") || sqlType.includes("float") || sqlType.includes("decimal")) return "number";
-//     if (sqlType.includes("bool")) return "boolean";
-//     if (sqlType.includes("json")) return "json";
-//     if (sqlType.includes("date")) return "string"; 
-//     return "ref";
-//   } catch {
-//     return "ref";
-//   }
-// }
-/** SequelizeModel — реализация модели, совместимая с AbstractModel */
 function capitalize(str) {
     return str.charAt(0).toUpperCase() + str.slice(1);
 }
-function convertCriteriaToSequelize(criteria) {
-    // console.debug("waterline criteria", criteria)
-    const result = {};
-    for (const key in criteria) {
-        const value = criteria[key];
-        if (value === undefined ||
-            value === null ||
-            (typeof value === "object" && Object.keys(value).length === 0)) {
-            continue;
-        }
-        if (typeof value === "object" && !Array.isArray(value)) {
-            const operatorEntries = Object.entries(value)
-                .filter(([_, v]) => v !== undefined && v !== null)
-                .map(([op, val]) => {
-                switch (op) {
-                    case "contains": return [Op.like, `%${val}%`];
-                    case "startsWith": return [Op.startsWith, val];
-                    case "endsWith": return [Op.endsWith, val];
-                    case ">": return [Op.gt, val];
-                    case ">=": return [Op.gte, val];
-                    case "<": return [Op.lt, val];
-                    case "<=": return [Op.lte, val];
-                    case "!=": return [Op.ne, val];
-                    case "in": return [Op.in, val];
-                    case "nin": return [Op.notIn, val];
-                    default: return [Op.eq, val];
-                }
-            });
-            if (operatorEntries.length > 0) {
-                result[key] = Object.fromEntries(operatorEntries);
-            }
-        }
-        else {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-function convertWaterlineCriteriaToSequelizeOptions(criteria) {
-    // console.debug("WATERLINE CRITERIA (raw):", criteria);
-    const { where: nestedWhere, skip, limit, sort, ...rest } = criteria;
-    const rawWhere = (nestedWhere && Object.keys(nestedWhere).length > 0)
-        ? nestedWhere
-        : rest;
-    // console.debug("WATERLINE CRITERIA: using rawWhere =", rawWhere);
-    const where = convertCriteriaToSequelize(rawWhere);
-    // console.debug("convertCriteriaToSequelize →", where);
-    const result = { where };
-    if (typeof skip === "number") {
-        result.offset = skip;
-        // console.debug("→ offset =", skip);
-    }
-    if (typeof limit === "number") {
-        result.limit = limit;
-        // console.debug("→ limit =", limit);
-    }
-    if (typeof sort === "string") {
-        const [field, dir] = sort.trim().split(/\s+/);
-        result.order = [[field, dir?.toUpperCase() === "DESC" ? "DESC" : "ASC"]];
-        // console.debug("→ order =", result.order);
-    }
-    return result;
-}
-function convertWaterlineCriteriaToSequelizeOptions____OLD(criteria) {
-    // console.debug("WATERLINE CRITERIA", criteria)
-    const { where = {}, skip, limit, sort } = criteria;
-    const result = {
-        where: convertCriteriaToSequelize(where),
-    };
-    if (typeof skip === "number") {
-        result.offset = skip;
-    }
-    if (typeof limit === "number") {
-        result.limit = limit;
-    }
-    if (typeof sort === "string") {
-        const [field, direction] = sort.trim().split(/\s+/);
-        result.order = [[field, direction?.toUpperCase() === "DESC" ? "DESC" : "ASC"]];
-    }
-    return result;
-}
 export class SequelizeModel extends AbstractModel {
     model;
     constructor(modelName, model) {
         super(modelName, mapSequelizeToWaterline(model), model.primaryKeyAttribute, model.name);
         this.model = model;
     }
+    _convertCriteriaToSequelize(criteria) {
+        const result = {};
+        for (const key in criteria) {
+            const value = criteria[key];
+            if (value === undefined ||
+                value === null ||
+                (typeof value === "object" && Object.keys(value).length === 0)) {
+                continue;
+            }
+            // 🧠 Заменяем ключ на `via`, если это ассоциация
+            const attr = this.attributes?.[key];
+            let targetKey = key;
+            if (attr?.type === "association" && attr.via) {
+                targetKey = attr.via;
+            }
+            if (typeof value === "object" && !Array.isArray(value)) {
+                const operatorEntries = Object.entries(value)
+                    .filter(([_, v]) => v !== undefined && v !== null)
+                    .map(([op, val]) => {
+                    switch (op) {
+                        case "contains": return [Op.like, `%${val}%`];
+                        case "startsWith": return [Op.startsWith, val];
+                        case "endsWith": return [Op.endsWith, val];
+                        case ">": return [Op.gt, val];
+                        case ">=": return [Op.gte, val];
+                        case "<": return [Op.lt, val];
+                        case "<=": return [Op.lte, val];
+                        case "!=": return [Op.ne, val];
+                        case "in": return [Op.in, val];
+                        case "nin": return [Op.notIn, val];
+                        default: return [Op.eq, val];
+                    }
+                });
+                if (operatorEntries.length > 0) {
+                    result[targetKey] = Object.fromEntries(operatorEntries);
+                }
+            }
+            else {
+                result[targetKey] = value;
+            }
+        }
+        return result;
+    }
+    _convertWaterlineCriteriaToSequelizeOptions(criteria) {
+        // console.debug("WATERLINE CRITERIA (raw):", criteria);
+        const { where: nestedWhere, skip, limit, sort, ...rest } = criteria;
+        const rawWhere = (nestedWhere && Object.keys(nestedWhere).length > 0)
+            ? nestedWhere
+            : rest;
+        // console.debug("WATERLINE CRITERIA: using rawWhere =", rawWhere);
+        const where = this._convertCriteriaToSequelize(rawWhere);
+        const result = { where };
+        if (typeof skip === "number") {
+            result.offset = skip;
+            // console.debug("→ offset =", skip);
+        }
+        if (typeof limit === "number") {
+            result.limit = limit;
+            // console.debug("→ limit =", limit);
+        }
+        if (typeof sort === "string") {
+            const [field, dir] = sort.trim().split(/\s+/);
+            result.order = [[field, dir?.toUpperCase() === "DESC" ? "DESC" : "ASC"]];
+            // console.debug("→ order =", result.order);
+        }
+        return result;
+    }
+    async _assignAssociations(instance, assocData) {
+        for (const [alias, ids] of Object.entries(assocData)) {
+            const assoc = this.model.associations[alias];
+            if (!assoc)
+                continue;
+            //@ts-ignore
+            const { set: setAccessor, add: addAccessor } = assoc.accessors;
+            if (Array.isArray(ids)) {
+                if (typeof instance[setAccessor] === 'function') {
+                    await instance[setAccessor](ids);
+                    continue;
+                }
+                if (typeof instance[addAccessor] === 'function') {
+                    for (const id of ids) {
+                        await instance[addAccessor](id);
+                    }
+                    continue;
+                }
+            }
+            if (typeof instance[setAccessor] === 'function') {
+                await instance[setAccessor](ids);
+            }
+            else if (typeof instance[addAccessor] === 'function') {
+                await instance[addAccessor](ids);
+            }
+        }
+    }
     // --- CREATE ---
     async _create(data) {
         // console.clear()
@@ -253,7 +309,7 @@ export class SequelizeModel extends AbstractModel {
     // --- FIND ONE ---
     async _findOne(criteria) {
         // console.debug(">> _findOne: входные критерии:", criteria);
-        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
         const includes = this._buildIncludes();
         // console.debug(">> _findOne: преобразованные where:", where);
         // console.debug(">> _findOne: includes:", includes);
@@ -278,7 +334,7 @@ export class SequelizeModel extends AbstractModel {
     async _find(criteria = {}, options = {}) {
         const assocNames = Object.keys(this.model.associations);
         // console.debug(">> _find: входные criteria:", criteria, "options:", options);
-        const { where, limit, offset, order } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where, limit, offset, order } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
         const includes = options.populate
             ? options.populate.map(([field, opts]) => ({ association: field, ...opts }))
             : assocNames.map(a => ({ association: a }));
@@ -290,20 +346,13 @@ export class SequelizeModel extends AbstractModel {
         //   includes,
         // });
         let instances;
-        try {
-            instances = await this.model.findAll({
-                where,
-                limit,
-                offset,
-                order,
-                include: includes
-            });
-            // console.debug(">> _find: получено моделей:", instances.length);
-        }
-        catch (err) {
-            // console.error("!! _find: ошибка в findAll:", err);
-            throw err;
-        }
+        instances = await this.model.findAll({
+            where,
+            limit,
+            offset,
+            order,
+            include: includes
+        });
         for (const inst of instances) {
             //For each association, we call getxxx () once again    
             for (const alias of assocNames) {
@@ -329,28 +378,81 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- UPDATE ONE ---
     async _updateOne(criteria, data) {
-        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
         const record = await this.model.findOne({ where });
-        if (!record) {
+        if (!record)
             return null;
+        const assocNames = Object.keys(this.model.associations);
+        const plainData = {};
+        const assocData = {};
+        for (const [key, val] of Object.entries(data)) {
+            if (assocNames.includes(key)) {
+                assocData[key] = val;
+            }
+            else {
+                plainData[key] = val;
+            }
         }
-        await record.update(data);
-        const result = await this.model.findByPk(record.get(this.primaryKey), { raw: true });
-        return result;
+        await record.update(plainData);
+        await this._assignAssociations(record, assocData);
+        await record.reload({ include: Object.values(this.model.associations) });
+        return record.get({ plain: true });
     }
     // --- UPDATE MANY ---
     async _update(criteria, data) {
-        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
-        await this.model.update(data, { where });
-        const result = await this.model.findAll({ where, raw: true });
-        return result;
+        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const assocNames = Object.keys(this.model.associations);
+        const plainData = {};
+        const assocData = {};
+        for (const [key, val] of Object.entries(data)) {
+            if (assocNames.includes(key)) {
+                assocData[key] = val;
+            }
+            else {
+                plainData[key] = val;
+            }
+        }
+        const records = await this.model.findAll({ where });
+        for (const record of records) {
+            await record.update(plainData);
+            await this._assignAssociations(record, assocData);
+        }
+        const reloaded = await this.model.findAll({
+            where,
+            include: Object.values(this.model.associations)
+        });
+        return reloaded.map(r => r.get({ plain: true }));
     }
     // --- DESTROY ONE ---
     async _destroyOne(criteria) {
-        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
         const record = await this.model.findOne({ where });
-        if (!record) {
+        if (!record)
             return null;
+        const assocNames = Object.keys(this.model.associations);
+        for (const alias of assocNames) {
+            const assoc = this.model.associations[alias];
+            // @ts-ignore: accessors should exist
+            const getAccessor = assoc.accessors?.get;
+            if (typeof record[getAccessor] === "function") {
+                try {
+                    const related = await record[getAccessor]();
+                    // 🧹 Удаляем связанные записи
+                    if (Array.isArray(related)) {
+                        for (const r of related) {
+                            if (typeof r.destroy === "function") {
+                                await r.destroy();
+                            }
+                        }
+                    }
+                    else if (related && typeof related.destroy === "function") {
+                        await related.destroy();
+                    }
+                }
+                catch (e) {
+                    // console.warn(`Failed to fetch/delete relation "${alias}":`, e);
+                }
+            }
         }
         const raw = record.get({ plain: true });
         await record.destroy();
@@ -358,15 +460,44 @@ export class SequelizeModel extends AbstractModel {
     }
     // --- DESTROY MANY ---
     async _destroy(criteria) {
-        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
         const records = await this.model.findAll({ where });
+        const assocNames = Object.keys(this.model.associations);
+        for (const record of records) {
+            for (const alias of assocNames) {
+                const assoc = this.model.associations[alias];
+                // 🛑 Не трогаем родительские связи
+                if (assoc.associationType === "BelongsTo")
+                    continue;
+                // @ts-ignore accessor exists
+                const getAccessor = assoc.accessors?.get;
+                if (typeof record[getAccessor] === "function") {
+                    try {
+                        const related = await record[getAccessor]();
+                        if (Array.isArray(related)) {
+                            for (const rel of related) {
+                                if (typeof rel.destroy === "function") {
+                                    await rel.destroy();
+                                }
+                            }
+                        }
+                        else if (related && typeof related.destroy === "function") {
+                            await related.destroy();
+                        }
+                    }
+                    catch (e) {
+                        // console.warn(`Failed to delete relation ${alias}:`, e);
+                    }
+                }
+            }
+        }
         const raw = records.map(r => r.get({ plain: true }));
         await this.model.destroy({ where });
         return raw;
     }
     // --- COUNT ---
     async _count(criteria = {}) {
-        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
         const result = await this.model.count({ where });
         return result;
     }
@@ -400,13 +531,23 @@ export class SequelizeAdapter extends AbstractAdapter {
     /**Registration of system models*/
     static async registerSystemModels(sequelize) {
         const modelsDir = path.resolve(import.meta.dirname, "../../../../models");
-        const files = fs.readdirSync(modelsDir).filter(f => f.endsWith(".js"));
+        let files = fs.readdirSync(modelsDir).filter(f => f.endsWith(".js"));
+        if (!files.length) {
+            files = fs.readdirSync(modelsDir).filter(f => f.endsWith(".ts") && !f.endsWith(".d.ts"));
+        }
+        if (!files.length) {
+            throw `Model files not found in dir ${modelsDir}`;
+        }
+        const schemas = {};
         for (const file of files) {
             const modelName = path.basename(file, path.extname(file));
             const filePath = path.resolve(modelsDir, file);
-            const definition = (await import(pathToFileURL(filePath).href)).default;
+            const mod = await import(pathToFileURL(filePath).href);
+            const definition = mod.default;
+            schemas[modelName] = definition;
             generateSequelizeModel(sequelize, modelName, definition);
         }
+        generateAssociationsFromSchema(sequelize.models, schemas);
         await sequelize.sync();
     }
 }

package/lib/v4/model/adapter/waterline.js

@@ -90,10 +90,13 @@ export class WaterlineAdapter extends AbstractAdapter {
     /** Method that processes custom waterline model creation. Is used for system models. Replaces beforeCreate method in waterline */
     static async registerSystemModels(waterlineORM) {
         const systemModelsDir = path.resolve(import.meta.dirname, "../../../../models");
-        const systemModelsFiles = fs.readdirSync(systemModelsDir).filter(file => file.endsWith(".js"));
+        let systemModelsFiles = fs.readdirSync(systemModelsDir).filter(file => file.endsWith(".js"));
+        if (!systemModelsFiles.length) {
+            systemModelsFiles = fs.readdirSync(systemModelsDir).filter(file => file.endsWith(".ts") && !file.endsWith(".d.ts"));
+        }
         // Register adminizer system models
         await Promise.all(systemModelsFiles.map(async (file) => {
-            const modelName = path.basename(file, ".js");
+            const modelName = path.basename(file).replace(/\.(ts|js)$/, "");
             const systemModelPath = path.resolve(systemModelsDir, file);
             const adminizerModel = (await import(pathToFileURL(systemModelPath).href)).default;
             const waterlineLikeModel = generateWaterlineModel(modelName, adminizerModel);

package/lib/{widgets → v4/widgets}/abstractLink.d.ts

@@ -1,5 +1,5 @@
 import BaseWidget from "./abstractWidgetBase";
-import { MaterialIcon } from "../../interfaces/MaaterialIcons";
+import { MaterialIcon } from "../../../interfaces/MaaterialIcons";
 export interface Links {
     name: string;
     description: string;

package/lib/{widgets → v4/widgets}/abstractWidgetBase.d.ts

@@ -1,4 +1,4 @@
-import { MaterialIcon } from "../../interfaces/MaaterialIcons";
+import { MaterialIcon } from "../../../interfaces/MaaterialIcons";
 export default abstract class BaseWidget {
     /** Widget unique id */
     abstract readonly id: string;

package/lib/{widgets → v4/widgets}/widgetHandler.d.ts

@@ -3,10 +3,10 @@ import InfoBase from "./abstractInfo";
 import ActionBase from "./abstractAction";
 import LinkBase from "./abstractLink";
 import CustomBase from "./abstractCustom";
-import { AdminpanelIcon } from "../../interfaces/adminpanelConfig";
-import { Adminizer } from "../Adminizer";
+import { AdminpanelIcon } from "../../../interfaces/adminpanelConfig";
+import { Adminizer } from "../../Adminizer";
 import { UserAP } from "models/UserAP";
-import { I18n } from "../v4/I18n";
+import { I18n } from "../I18n";
 export type WidgetType = (SwitcherBase | InfoBase | ActionBase | LinkBase | CustomBase);
 export interface WidgetConfig {
     id: string;
@@ -36,6 +36,13 @@ export interface WidgetLayoutItem {
     i: string;
     id: string;
 }
+export interface WidgetsLayouts {
+    lg: WidgetLayoutItem[];
+    md: WidgetLayoutItem[];
+    sm: WidgetLayoutItem[];
+    xs: WidgetLayoutItem[];
+    xxs: WidgetLayoutItem[];
+}
 export declare class WidgetHandler {
     private widgets;
     adminizer: Adminizer;
@@ -46,7 +53,7 @@ export declare class WidgetHandler {
     getAll(user: UserAP, i18n: I18n): Promise<WidgetConfig[]>;
     getWidgetsDB(id: number, auth: boolean, i18n: I18n): Promise<{
         widgets: WidgetConfig[];
-        layout: WidgetLayoutItem[];
+        layout: WidgetsLayouts;
     }>;
     setWidgetsDB(id: number, body: {
         widgets: WidgetConfig[];

package/lib/{widgets → v4/widgets}/widgetHandler.js

@@ -124,7 +124,7 @@ export class WidgetHandler {
     }
     async getWidgetsDB(id, auth, i18n) {
         let user;
-        let result = { widgets: [], layout: [] };
+        let result = { widgets: [], layout: { lg: [], md: [], sm: [], xs: [], xxs: [] } };
         if (!auth) {
             // TODO refactor CRUD functions for DataAccessor usage
             user = await this.adminizer.modelHandler.model.get("UserAP")?.["_findOne"]({ login: this.adminizer.config.administrator?.login ?? 'admin' });

package/models/NavigationAP.d.ts

@@ -1,14 +1,13 @@
 declare const _default: {
     id: {
         type: string;
-        allowNull: boolean;
-        uuid: boolean;
+        autoIncrement: boolean;
         primaryKey: boolean;
-        required: boolean;
     };
     label: {
         type: string;
         required: boolean;
+        unique: boolean;
     };
     tree: {
         type: string;

package/models/NavigationAP.js

@@ -1,14 +1,13 @@
 export default {
     id: {
-        type: "string",
-        allowNull: false,
-        uuid: true,
-        primaryKey: true,
-        required: true
+        type: "number",
+        autoIncrement: true,
+        primaryKey: true
     },
     label: {
         type: "string",
-        required: true
+        required: true,
+        unique: true
     },
     tree: {
         type: "json",

package/models/UserAP.d.ts

@@ -1,6 +1,5 @@
-import { WidgetConfig } from "lib/widgets/widgetHandler";
+import { WidgetConfig, WidgetsLayouts } from "lib/v4/widgets/widgetHandler";
 import { GroupAP } from "./GroupAP";
-import { WidgetLayoutItem } from "../assets/js/types";
 declare const _default: {
     id: {
         type: string;
@@ -71,7 +70,7 @@ export interface UserAP {
     groups?: GroupAP[];
     widgets?: {
         widgets: WidgetConfig[];
-        layout: WidgetLayoutItem[];
+        layout: WidgetsLayouts;
     };
     isConfirmed?: boolean;
 }