adminizer 4.1.0-commit.ad1476a → 4.1.0-commit.d8a06d3

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

@@ -3,53 +3,110 @@ import { AbstractAdapter, AbstractModel } from "../AbstractModel";
 import path from "path";
 import fs from "fs";
 import { pathToFileURL } from "url";
-function mapSequelizeAttributesToAbstract(attrs) {
+function resolveType(type) {
+    const sqlType = typeof type.toString === "function"
+        ? type.toString().toLowerCase()
+        : "";
+    if (sqlType.includes("string") || 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";
+}
+export function mapSequelizeToWaterline(model) {
     const result = {};
-    for (const key in attrs) {
-        const attr = attrs[key];
-        const resolvedType = resolveType(attr.type);
-        result[key] = {
-            type: resolvedType,
-            required: !attr.allowNull,
-            primaryKey: !!attr.primaryKey,
-            unique: !!attr.unique,
+    const rawAttrs = model.getAttributes();
+    for (const name in rawAttrs) {
+        const meta = rawAttrs[name];
+        result[name] = {
+            type: resolveType(meta.type),
+            required: meta.allowNull !== undefined ? !meta.allowNull : false,
+            allowNull: meta.allowNull,
+            unique: !!meta.unique,
+            defaultsTo: meta.defaultValue,
+            columnName: meta.field || name,
         };
     }
-    return result;
-}
-function resolveType(type) {
-    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";
+    for (const alias in model.associations) {
+        const assoc = model.associations[alias];
+        switch (assoc.associationType) {
+            case "BelongsTo": {
+                const a = assoc;
+                result[alias] = {
+                    type: "association",
+                    model: a.target.name.toLowerCase(),
+                    via: a.foreignKey,
+                };
+                break;
+            }
+            case "HasOne": {
+                const a = assoc;
+                result[alias] = {
+                    type: "association",
+                    model: a.target.name.toLowerCase(),
+                    via: a.foreignKey,
+                };
+                break;
+            }
+            case "HasMany": {
+                const a = assoc;
+                result[alias] = {
+                    type: "association-many",
+                    collection: a.target.name.toLowerCase(),
+                    via: a.foreignKey,
+                };
+                break;
+            }
+            case "BelongsToMany": {
+                const a = assoc;
+                result[alias] = {
+                    type: "association-many",
+                    collection: a.target.name.toLowerCase(),
+                    via: a.otherKey,
+                };
+                break;
+            }
+            default:
+                break;
+        }
     }
+    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.log("waterline criteria", 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; // ⛔ пропускаем пустые условия
+            continue;
         }
         if (typeof value === "object" && !Array.isArray(value)) {
             const operatorEntries = Object.entries(value)
@@ -80,7 +137,32 @@ function convertCriteriaToSequelize(criteria) {
     return result;
 }
 function convertWaterlineCriteriaToSequelizeOptions(criteria) {
-    console.log("WATERLINE CRITERIA", 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),
@@ -100,40 +182,150 @@ function convertWaterlineCriteriaToSequelizeOptions(criteria) {
 export class SequelizeModel extends AbstractModel {
     model;
     constructor(modelName, model) {
-        super(modelName, mapSequelizeAttributesToAbstract(model.getAttributes()), model.primaryKeyAttribute, model.name);
+        super(modelName, mapSequelizeToWaterline(model), model.primaryKeyAttribute, model.name);
         this.model = model;
     }
     // --- CREATE ---
     async _create(data) {
-        const created = await this.model.create(data);
-        const result = await this.model.findByPk(created.get(this.primaryKey), { raw: true });
-        return result;
+        // console.clear()
+        const assocNames = Object.keys(this.model.associations);
+        const plainData = {};
+        const assocData = {};
+        // console.debug(">> _create: входные данные:", data);
+        // console.debug(">> Доступные ассоциации:", assocNames);
+        for (const [key, val] of Object.entries(data)) {
+            if (assocNames.includes(key)) {
+                assocData[key] = val;
+            }
+            else {
+                plainData[key] = val;
+            }
+        }
+        // console.debug(">> Обычные поля для create():", plainData);
+        // console.debug(">> Данные ассоциаций:", assocData);
+        let instance;
+        try {
+            instance = await this.model.create(plainData);
+            // console.debug(">> Создан экземпляр (без ассоциаций):", instance.toJSON());
+        }
+        catch (err) {
+            // console.error("!! Ошибка при create(plainData):", err);
+            throw err;
+        }
+        // assocData = { example: 5, userAPs: [1,2,3], category: 7, tags: [11,22] }
+        // this.model.associations — ваш объект ассоциаций
+        for (const [alias, ids] of Object.entries(assocData)) {
+            const assoc = this.model.associations[alias];
+            if (!assoc) {
+                // console.warn(`Association "${alias}" not defined on model`);
+                continue;
+            }
+            // @ts-ignore accessors is present
+            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);
+            }
+            else {
+                // console.warn(`No suitable accessor for "${alias}": tried set=${setAccessor}, add=${addAccessor}`);
+            }
+        }
+        await instance.reload({ include: Object.values(this.model.associations) });
+        const pk = this.primaryKey;
+        const fresh = await this.model.findByPk(instance.get(pk), { include: assocNames.map(a => ({ association: a })) });
+        // console.debug(">> Результат после reload:", fresh?.toJSON());
+        return fresh;
     }
     // --- FIND ONE ---
     async _findOne(criteria) {
+        // console.debug(">> _findOne: входные критерии:", criteria);
         const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
-        const result = await this.model.findOne({
-            where,
-            include: this._buildIncludes(),
-            raw: true,
-        });
-        return result;
+        const includes = this._buildIncludes();
+        // console.debug(">> _findOne: преобразованные where:", where);
+        // console.debug(">> _findOne: includes:", includes);
+        let instance = null;
+        try {
+            instance = await this.model.findOne({ where, include: includes });
+            // console.debug(">> _findOne: сырое instance:", instance ? instance.toJSON() : null);
+        }
+        catch (err) {
+            // console.error("!! _findOne: ошибка при вызове findOne:", err);
+            throw err;
+        }
+        if (!instance) {
+            // console.debug(">> _findOne: ничего не найдено");
+            return null;
+        }
+        const plain = instance.get({ plain: true });
+        // console.debug(">> _findOne: plain результат:", plain);
+        return plain;
     }
     // --- FIND MANY ---
     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 include = options.populate
+        const includes = options.populate
             ? options.populate.map(([field, opts]) => ({ association: field, ...opts }))
-            : this._buildIncludes();
-        const result = await this.model.findAll({
-            where,
-            limit,
-            offset,
-            order,
-            include,
-            raw: true,
-        });
-        return result;
+            : assocNames.map(a => ({ association: a }));
+        // console.debug(">> _find: where, limit, offset, order, includes:", {
+        //   where,
+        //   limit,
+        //   offset,
+        //   order,
+        //   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;
+        }
+        for (const inst of instances) {
+            //For each association, we call getxxx () once again    
+            for (const alias of assocNames) {
+                // @ts-ignore accessors is present
+                const getAccessor = this.model.associations[alias].accessors.get;
+                if (typeof inst[getAccessor] === "function") {
+                    try {
+                        const related = await inst[getAccessor]();
+                        const mapped = Array.isArray(related)
+                            ? related.map((r) => r.toJSON())
+                            : related?.toJSON();
+                        // console.debug(`---- get${alias}():`, mapped);
+                    }
+                    catch (e) {
+                        // console.error(`!! ошибка при вызове ${getAccessor}():`, e);
+                    }
+                }
+            }
+        }
+        const plain = instances.map(i => i.get({ plain: true }));
+        // console.debug(">> _find: plain результаты:", plain);
+        return plain;
     }
     // --- UPDATE ONE ---
     async _updateOne(criteria, data) {
@@ -205,7 +397,7 @@ export class SequelizeAdapter extends AbstractAdapter {
         const model = this.getModel(modelName);
         return model?.getAttributes();
     }
-    /** Регистрация системных моделей */
+    /**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"));
@@ -218,7 +410,7 @@ export class SequelizeAdapter extends AbstractAdapter {
         await sequelize.sync();
     }
 }
-/** Генерация модели Sequelize из определения, аналог WaterlineCollection.extend */
+/**Generation of the SEQUELIZE model from the definition, analogue of Waterinecollection.extenD*/
 function generateSequelizeModel(sequelize, modelName, rawAttributes) {
     const attributes = {};
     let primaryKey = null;

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

@@ -48,7 +48,6 @@ export class WaterlineModel extends AbstractModel {
             query = query.limit(options.limit);
         }
         let result = await query;
-        console.log(result, "result");
         return result;
     }
     async _updateOne(criteria, data) {

package/lib/widgets/abstractAction.d.ts

@@ -1,7 +1,7 @@
 import BaseWidget from "./abstractWidgetBase";
 export default abstract class ActionBase extends BaseWidget {
     readonly widgetType = "action";
-    /** Widget background css (color, Image) */
+    /** Widget background css color */
     abstract readonly backgroundCSS: string | null;
     abstract action(): Promise<any>;
 }

package/lib/widgets/abstractCustom.d.ts

@@ -1,13 +1,28 @@
-import BaseWidget from "./abstractWidgetBase";
-export default abstract class CustomBase extends BaseWidget {
-    /** Widget background css (color, Image) */
-    abstract readonly backgroundCSS: string | null;
-    /** Fullpath script for loading in dashboard in browser */
-    abstract readonly scriptUrl: string;
-    /** How widgets processor can call constructor of this widget */
-    abstract readonly constructorName: string;
-    /** Options to constuctor */
-    abstract readonly constructorOption: any;
-    /** Hide title, icon, description */
-    abstract readonly hideAdminPanelUI: boolean;
+import { MaterialIcon } from "material-icons";
+export default abstract class CustomBase {
+    /** Widget unique id */
+    abstract readonly id: string;
+    /** Widget Name */
+    abstract readonly name: string;
+    /** JS module file path */
+    abstract readonly jsPath: {
+        dev: string;
+        production: string;
+    };
+    /** For group access rights by department */
+    abstract readonly department: string;
+    /** Widget background css color */
+    readonly backgroundCSS: string;
+    /** Widget size */
+    abstract readonly size: {
+        h: number;
+        w: number;
+    } | null;
+    /** Widget description */
+    abstract readonly description: string;
+    /** Widget icon */
+    abstract readonly icon?: MaterialIcon | string;
+    readonly widgetType: 'custom';
+    routePrefix: string;
+    protected constructor(routePrefix: string);
 }

package/lib/widgets/abstractCustom.js

@@ -1,3 +1,9 @@
-import BaseWidget from "./abstractWidgetBase";
-export default class CustomBase extends BaseWidget {
+export default class CustomBase {
+    /** Widget background css color */
+    backgroundCSS;
+    widgetType = 'custom';
+    routePrefix;
+    constructor(routePrefix) {
+        this.routePrefix = routePrefix;
+    }
 }

package/lib/widgets/abstractInfo.d.ts

@@ -1,7 +1,7 @@
 import BaseWidget from "./abstractWidgetBase";
 export default abstract class InfoBase extends BaseWidget {
     readonly widgetType = "info";
-    /** Widget background css (color, Image) */
+    /** Widget background css color */
     readonly backgroundCSS: string;
     /** Widget size */
     readonly size: {

package/lib/widgets/abstractInfo.js

@@ -1,7 +1,7 @@
 import BaseWidget from "./abstractWidgetBase";
 export default class InfoBase extends BaseWidget {
     widgetType = "info";
-    /** Widget background css (color, Image) */
+    /** Widget background css color */
     backgroundCSS;
     /** Widget size */
     size = null;

package/lib/widgets/abstractLink.d.ts

@@ -5,6 +5,7 @@ export interface Links {
     description: string;
     icon?: MaterialIcon;
     link: string;
+    linkType: 'self' | 'blank';
     backgroundCSS: string | null;
 }
 export default abstract class LinkBase extends BaseWidget {

package/lib/widgets/abstractSwitch.d.ts

@@ -1,7 +1,7 @@
 import BaseWidget from "./abstractWidgetBase";
 export default abstract class SwitchBase extends BaseWidget {
     readonly widgetType = "switcher";
-    /** Widget background css (color, Image) */
+    /** Widget background css color */
     abstract readonly backgroundCSS: string | null;
     /** Get current state */
     abstract getState(): Promise<boolean>;

package/lib/widgets/abstractWidgetBase.d.ts

@@ -23,5 +23,5 @@ export default abstract class BaseWidget {
     /** Run task */
     "action" | 
     /** Change location, or open in new tab */
-    "link" | "custom";
+    "link";
 }

package/lib/widgets/widgetHandler.d.ts

@@ -5,6 +5,8 @@ import LinkBase from "./abstractLink";
 import CustomBase from "./abstractCustom";
 import { AdminpanelIcon } from "../../interfaces/adminpanelConfig";
 import { Adminizer } from "../Adminizer";
+import { UserAP } from "models/UserAP";
+import { I18n } from "../v4/I18n";
 export type WidgetType = (SwitcherBase | InfoBase | ActionBase | LinkBase | CustomBase);
 export interface WidgetConfig {
     id: string;
@@ -16,6 +18,7 @@ export interface WidgetConfig {
     name: string;
     backgroundCSS: string;
     scriptUrl?: string;
+    linkType?: 'self' | 'blank';
     constructorName?: string;
     constructorOption?: any;
     size?: {
@@ -25,6 +28,14 @@ export interface WidgetConfig {
     added?: boolean;
     hideAdminPanelUI?: boolean;
 }
+export interface WidgetLayoutItem {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    i: string;
+    id: string;
+}
 export declare class WidgetHandler {
     private widgets;
     adminizer: Adminizer;
@@ -32,7 +43,13 @@ export declare class WidgetHandler {
     add(widget: WidgetType): void;
     getById(id: string): WidgetType | undefined;
     removeById(id: string): void;
-    getAll(user: ModelsAP["UserAP"]): Promise<WidgetConfig[]>;
-    getWidgetsDB(id: number, auth: boolean): Promise<WidgetConfig[]>;
-    setWidgetsDB(id: number, widgets: WidgetConfig[], auth: boolean): Promise<number>;
+    getAll(user: UserAP, i18n: I18n): Promise<WidgetConfig[]>;
+    getWidgetsDB(id: number, auth: boolean, i18n: I18n): Promise<{
+        widgets: WidgetConfig[];
+        layout: WidgetLayoutItem[];
+    }>;
+    setWidgetsDB(id: number, body: {
+        widgets: WidgetConfig[];
+        layout: WidgetLayoutItem[];
+    }, auth: boolean): Promise<number>;
 }