adminizer 4.1.0-build.17 → 4.1.0-build.19

package/index.d.ts

@@ -11,7 +11,4 @@ export * from "./lib/v4/model/adapter/sequelize";
 export * from "./lib/Adminizer";
 export * from "./models/GroupAP";
 export * from "./models/UserAP";
-export * from "./models/MediaManagerAP";
-export * from "./models/MediaManagerAssociationsAP";
-export * from "./models/MediaManagerMetaAP";
 export * from "./models/NavigationAP";

package/index.js

@@ -11,7 +11,7 @@ export * from "./lib/v4/model/adapter/sequelize";
 export * from "./lib/Adminizer";
 export * from "./models/GroupAP";
 export * from "./models/UserAP";
-export * from "./models/MediaManagerAP";
-export * from "./models/MediaManagerAssociationsAP";
-export * from "./models/MediaManagerMetaAP";
+// export * from "./models/MediaManagerAP"
+// export * from "./models/MediaManagerAssociationsAP"
+// export * from "./models/MediaManagerMetaAP"
 export * from "./models/NavigationAP";

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.17",
+  "version": "4.1.0-build.19",
   "main": "index.js",
   "scripts": {
     "test": "vitest --reporter verbose",

package/models/MediaManagerAP.d.ts

@@ -1,62 +0,0 @@
-import { MediaManagerAssociationsAP } from "./MediaManagerAssociationsAP";
-import { MediaManagerMetaAP } from "./MediaManagerMetaAP";
-declare const _default: {
-    id: {
-        type: string;
-        allowNull: boolean;
-        uuid: boolean;
-        primaryKey: boolean;
-        required: boolean;
-    };
-    parentMedia: {
-        model: string;
-    };
-    variants: {
-        collection: string;
-        via: string;
-    };
-    mimeType: {
-        type: string;
-    };
-    path: {
-        type: string;
-    };
-    size: {
-        type: string;
-    };
-    group: {
-        type: string;
-    };
-    tag: {
-        type: string;
-    };
-    url: {
-        type: string;
-    };
-    filename: {
-        type: string;
-    };
-    meta: {
-        collection: string;
-        via: string;
-    };
-    modelAssociation: {
-        collection: string;
-        via: string;
-    };
-};
-export default _default;
-export interface MediaManagerAP {
-    id: string;
-    parent?: MediaManagerAP;
-    variants?: MediaManagerAP[];
-    mimeType?: string;
-    path?: string;
-    size?: number;
-    group?: string;
-    tag?: string;
-    url?: string;
-    filename?: string;
-    meta?: MediaManagerMetaAP[];
-    modelAssociation?: MediaManagerAssociationsAP[];
-}

package/models/MediaManagerAP.js

@@ -1,46 +0,0 @@
-export default {
-    id: {
-        type: "string",
-        allowNull: false,
-        uuid: true,
-        primaryKey: true,
-        required: true
-    },
-    // WARN!!!  renamed from parent is confict
-    parentMedia: {
-        model: "MediaManagerAP"
-    },
-    variants: {
-        collection: "MediaManagerAP",
-        via: "parent"
-    },
-    mimeType: {
-        type: "string"
-    },
-    path: {
-        type: "string"
-    },
-    size: {
-        type: "number"
-    },
-    group: {
-        type: "string"
-    },
-    tag: {
-        type: "string"
-    },
-    url: {
-        type: "string"
-    },
-    filename: {
-        type: "string"
-    },
-    meta: {
-        collection: "MediaManagerMetaAP",
-        via: "parent"
-    },
-    modelAssociation: {
-        collection: "MediaManagerAssociationsAP",
-        via: "file"
-    }
-};

package/models/MediaManagerAssociationsAP.d.ts

@@ -1,38 +0,0 @@
-import { MediaManagerAP } from "./MediaManagerAP";
-declare const _default: {
-    id: {
-        type: string;
-        allowNull: boolean;
-        uuid: boolean;
-        primaryKey: boolean;
-        required: boolean;
-    };
-    mediaManagerId: {
-        type: string;
-    };
-    model: {
-        type: string;
-    };
-    modelId: {
-        type: string;
-    };
-    widgetName: {
-        type: string;
-    };
-    sortOrder: {
-        type: string;
-    };
-    file: {
-        model: string;
-    };
-};
-export default _default;
-export interface MediaManagerAssociationsAP {
-    id: string;
-    mediaManagerId?: string;
-    model?: Record<string, unknown>;
-    modelId?: Record<string, unknown>;
-    widgetName?: string;
-    sortOrder?: number;
-    file?: MediaManagerAP;
-}

package/models/MediaManagerAssociationsAP.js

@@ -1,27 +0,0 @@
-export default {
-    id: {
-        type: "string",
-        allowNull: false,
-        uuid: true,
-        primaryKey: true,
-        required: true
-    },
-    mediaManagerId: {
-        type: "string"
-    },
-    model: {
-        type: "json"
-    },
-    modelId: {
-        type: "json"
-    },
-    widgetName: {
-        type: "string"
-    },
-    sortOrder: {
-        type: "number"
-    },
-    file: {
-        model: "MediaManagerAP"
-    }
-};

package/models/MediaManagerMetaAP.d.ts

@@ -1,30 +0,0 @@
-import { MediaManagerAP } from "./MediaManagerAP";
-declare const _default: {
-    id: {
-        type: string;
-        allowNull: boolean;
-        uuid: boolean;
-        primaryKey: boolean;
-        required: boolean;
-    };
-    key: {
-        type: string;
-    };
-    value: {
-        type: string;
-    };
-    isPublic: {
-        type: string;
-    };
-    parent: {
-        model: string;
-    };
-};
-export default _default;
-export interface MediaManagerMetaAP {
-    id: string;
-    key?: string;
-    value?: Record<string, unknown>;
-    isPublic?: boolean;
-    parent?: MediaManagerAP;
-}

package/models/MediaManagerMetaAP.js

@@ -1,21 +0,0 @@
-export default {
-    id: {
-        type: "string",
-        allowNull: false,
-        uuid: true,
-        primaryKey: true,
-        required: true
-    },
-    key: {
-        type: "string"
-    },
-    value: {
-        type: "json"
-    },
-    isPublic: {
-        type: "boolean"
-    },
-    parent: {
-        model: "MediaManagerAP"
-    }
-};