adminizer 4.1.0-build.18 → 4.1.0-build.19

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

@@ -4,6 +4,7 @@ export declare function mapSequelizeToWaterline(model: ModelStatic<any>): Record
 export declare class SequelizeModel<T> extends AbstractModel<T> {
     private model;
     constructor(modelName: string, model: ModelStatic<any>);
+    _assignAssociations(instance: any, assocData: Record<string, any>): Promise<void>;
     protected _create(data: Record<string, any>): Promise<T>;
     protected _findOne(criteria: Partial<T>): Promise<T | null>;
     protected _find(criteria?: Partial<T>, options?: FindOptions): Promise<T[]>;

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

@@ -136,23 +136,6 @@ 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);
 }
@@ -243,6 +226,33 @@ export class SequelizeModel extends AbstractModel {
         super(modelName, mapSequelizeToWaterline(model), model.primaryKeyAttribute, model.name);
         this.model = model;
     }
+    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()
@@ -389,26 +399,79 @@ export class SequelizeModel extends AbstractModel {
     async _updateOne(criteria, data) {
         const { where } = 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 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 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();
@@ -418,6 +481,35 @@ export class SequelizeModel extends AbstractModel {
     async _destroy(criteria) {
         const { where } = 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;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "adminizer",
   "type": "module",
-  "version": "4.1.0-build.18",
+  "version": "4.1.0-build.19",
   "main": "index.js",
   "scripts": {
     "test": "vitest --reporter verbose",