adminizer 4.1.0-commit.ad1476a → 4.1.1

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

@@ -3,162 +3,456 @@ import { AbstractAdapter, AbstractModel } from "../AbstractModel";
 import path from "path";
 import fs from "fs";
 import { pathToFileURL } from "url";
-function mapSequelizeAttributesToAbstract(attrs) {
-    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,
-        };
+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
+                    });
+                }
+            }
+        }
     }
-    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";
-    }
+    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";
 }
-/** SequelizeModel — реализация модели, совместимая с AbstractModel */
-function convertCriteriaToSequelize(criteria) {
-    console.log("waterline criteria", criteria);
+export function mapSequelizeToWaterline(model) {
     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);
+    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,
+        };
+    }
+    for (const alias in model.associations) {
+        const assoc = model.associations[alias];
+        switch (assoc.associationType) {
+            case "BelongsTo": {
+                const a = assoc;
+                result[a.foreignKey]["primaryKeyForAssociation"] = true;
+                result[alias] = {
+                    type: "association",
+                    model: a.target.name,
+                    via: a.foreignKey,
+                };
+                break;
             }
-        }
-        else {
-            result[key] = value;
+            case "HasOne": {
+                const a = assoc;
+                result[a.foreignKey]["primaryKeyForAssociation"] = true;
+                result[alias] = {
+                    type: "association",
+                    model: a.target.name,
+                    via: a.foreignKey,
+                };
+                break;
+            }
+            case "HasMany": {
+                const a = assoc;
+                result[alias] = {
+                    type: "association-many",
+                    collection: a.target.name,
+                    via: a.foreignKey,
+                };
+                break;
+            }
+            case "BelongsToMany": {
+                const a = assoc;
+                result[alias] = {
+                    type: "association-many",
+                    collection: a.target.name,
+                    via: a.otherKey,
+                };
+                break;
+            }
+            default:
+                break;
         }
     }
     return result;
 }
-function convertWaterlineCriteriaToSequelizeOptions(criteria) {
-    console.log("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;
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
 }
 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;
     }
+    _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) {
-        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) {
-        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
-        const result = await this.model.findOne({
-            where,
-            include: this._buildIncludes(),
-            raw: true,
-        });
-        return result;
+        // console.debug(">> _findOne: входные критерии:", criteria);
+        const { where } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
+        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 { where, limit, offset, order } = convertWaterlineCriteriaToSequelizeOptions(criteria);
-        const include = options.populate
+        const assocNames = Object.keys(this.model.associations);
+        // console.debug(">> _find: входные criteria:", criteria, "options:", options);
+        const { where, limit, offset, order } = this._convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const includes = options.populate
             ? options.populate.map(([field, opts]) => ({ association: field, ...opts }))
-            : this._buildIncludes();
-        const result = await this.model.findAll({
+            : assocNames.map(a => ({ association: a }));
+        // console.debug(">> _find: where, limit, offset, order, includes:", {
+        //   where,
+        //   limit,
+        //   offset,
+        //   order,
+        //   includes,
+        // });
+        let instances;
+        instances = await this.model.findAll({
             where,
             limit,
             offset,
             order,
-            include,
-            raw: true,
+            include: includes
         });
-        return result;
+        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) {
-        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();
@@ -166,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;
     }
@@ -205,20 +528,30 @@ 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"));
+        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();
     }
 }
-/** Генерация модели 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;