adminizer 4.6.0 → 4.7.0-build.222

package/lib/media-manager/AbstractMediaManager.d.ts

@@ -1,8 +1,9 @@
 import { Adminizer } from "../Adminizer";
+import { MediaManagerMetaAP } from "../../models/MediaManagerMetaAP";
 export interface MediaManagerItem {
-    id: string;
-    parent: string;
-    variants: MediaManagerItem[];
+    id?: string;
+    parent: string | null;
+    variants?: MediaManagerItem[];
     mimeType: string;
     path: string;
     size: number;
@@ -13,9 +14,9 @@ export interface MediaManagerItem {
     group?: string;
     url: string;
     filename: string;
-    meta: string[];
-    createdAt: number;
-    updatedAt: number;
+    meta?: MediaManagerMetaAP[];
+    createdAt?: number;
+    updatedAt?: number;
 }
 type NumericKeys<T> = {
     [K in keyof T]: T[K] extends number ? K : never;
@@ -121,7 +122,7 @@ export declare abstract class File<T extends MediaManagerItem> {
     }>;
     abstract search(s: string, group?: string): Promise<MediaManagerItem[]>;
     abstract getOrigin(id: string): Promise<string>;
-    abstract getFile(id: number): Promise<MediaManagerItem>;
+    abstract getFile(id: number | string): Promise<MediaManagerItem>;
 }
 /**
  *
@@ -250,7 +251,7 @@ export declare abstract class AbstractMediaManager {
         value: string;
     }[]>;
     getOrigin(id: string): Promise<string>;
-    getFile(mimeType: string, id: number): Promise<MediaManagerItem>;
+    getFile(mimeType: string, id: number | string): Promise<MediaManagerItem>;
     /**
      *  Set metadata of an item.
      * @param item

package/lib/media-manager/DefaultMediaManager.d.ts

@@ -7,6 +7,8 @@ export declare class DefaultMediaManager extends AbstractMediaManager {
     id: string;
     protected readonly adminizer: Adminizer;
     constructor(adminizer: Adminizer, id: string, urlPathPrefix: string, fileStoragePath: string);
+    private mediaModel;
+    private associationModel;
     getAll(limit: number, skip: number, sort: SortCriteria, group: string): Promise<{
         data: MediaManagerItem[];
         next: boolean;

package/lib/media-manager/DefaultMediaManager.js

@@ -18,15 +18,24 @@ export class DefaultMediaManager extends AbstractMediaManager {
         this.itemTypes.push(new VideoItem(adminizer, urlPathPrefix, fileStoragePath));
         this.adminizer = adminizer;
     }
+    mediaModel() {
+        return this.adminizer.modelHandler.internal("media-manager").get(this.model);
+    }
+    associationModel() {
+        return this.adminizer.modelHandler.internal("media-manager").get(this.modelAssoc);
+    }
     async getAll(limit, skip, sort, group) {
-        //TODO refactor CRUD functions for DataAccessor usage
-        let data = await this.adminizer.modelHandler.model.get(this.model)["_find"]({
+        let data = await this.mediaModel().find({
             where: { parent: null, group: group },
             limit: limit,
             skip: skip,
             sort: sort,
-        }, { populate: [["variants", { sort: sort }], ["meta", {}]] });
-        let next = await this.adminizer.modelHandler.model.get(this.model)["_find"]({
+            populate: {
+                variants: { sort: sort },
+                meta: true
+            }
+        });
+        let next = await this.mediaModel().find({
             where: { parent: null, group: group },
             limit: limit,
             skip: skip === 0 ? limit : skip + limit,
@@ -41,14 +50,15 @@ export class DefaultMediaManager extends AbstractMediaManager {
         };
     }
     async searchAll(s, group) {
-        //TODO refactor CRUD functions for DataAccessor usage
-        let data = await this.adminizer.modelHandler.model.get(this.model)["_find"]({
+        let data = await this.mediaModel().find({
             where: { filename: { contains: s }, parent: null, group: group },
             sort: "createdAt DESC",
-        }, {
-            populate: [["variants", { sort: "createdAt DESC" }], ["meta", {}]],
             // This limitation is made strictly, if your code solves this please make a PR
-            limit: 1000
+            limit: 1000,
+            populate: {
+                variants: { sort: "createdAt DESC" },
+                meta: true
+            }
         });
         for (let elem of data) {
             elem.variants = await populateVariants(this.adminizer, elem.variants, this.model);
@@ -61,7 +71,8 @@ export class DefaultMediaManager extends AbstractMediaManager {
             throw new Error("modelId must be a string or number");
         }
         const modelIdStr = String(modelId); //Normalize to string
-        let modelAssociations = await this.adminizer.modelHandler.model.get(this.modelAssoc)["_find"]({
+        const associationModel = this.associationModel();
+        let modelAssociations = await associationModel.find({
             where: {
                 modelId: modelIdStr,
                 model: model.toLowerCase(),
@@ -72,11 +83,11 @@ export class DefaultMediaManager extends AbstractMediaManager {
             const q = {};
             const pk = this.adminizer.modelHandler.model.get(this.modelAssoc).primaryKey;
             q[pk] = modelAssociation.id;
-            await this.adminizer.modelHandler.model.get(this.modelAssoc)["_destroy"](q);
+            await associationModel.destroy({ where: q });
         }
         const fieldName = this.adminizer.ormAdapters[0].ormType === 'sequelize' ? 'fileId' : 'file';
         for (const [key, widgetItem] of data.entries()) {
-            await this.adminizer.modelHandler.model.get(this.modelAssoc)["_create"]({
+            await associationModel.create({
                 mediaManagerId: this.id,
                 model: model.toLowerCase(),
                 modelId: modelIdStr, //Save as a string
@@ -93,14 +104,15 @@ export class DefaultMediaManager extends AbstractMediaManager {
         const modelIdStr = String(modelId); //Normalize to string
         let widgetItems = [];
         const fieldName = this.adminizer.ormAdapters[0].ormType === 'sequelize' ? 'fileRef' : 'file';
-        let files = await this.adminizer.modelHandler.model.get(this.modelAssoc)['_find']({
+        let files = await this.associationModel().find({
             where: {
                 model: model.toLowerCase(),
                 widgetName: widgetName,
                 modelId: modelIdStr, //Search by string
             },
-            sort: "sortOrder ASC"
-        }, { populate: [[fieldName, {}]] });
+            sort: "sortOrder ASC",
+            populate: { [fieldName]: true }
+        });
         for (const file of files) {
             widgetItems.push({
                 id: file[fieldName].id,

package/lib/media-manager/Items.d.ts

@@ -9,6 +9,9 @@ export declare class ImageItem extends File<MediaManagerItem> {
     imageSizes: any;
     protected readonly adminizer: Adminizer;
     constructor(adminizer: Adminizer, urlPathPrefix: string, fileStoragePath: string);
+    protected mediaModel(): import("../..").InternalModelRepository<MediaManagerItem>;
+    protected metaRepository(): import("../..").InternalModelRepository<any>;
+    protected associationModel(): import("../..").InternalModelRepository<any>;
     getItems(limit: number, skip: number, sort: SortCriteria, group: string): Promise<{
         data: MediaManagerItem[];
         next: boolean;
@@ -18,7 +21,7 @@ export declare class ImageItem extends File<MediaManagerItem> {
     getVariants(id: string): Promise<MediaManagerItem[]>;
     protected createVariants(file: UploaderFile, parent: MediaManagerItem, filename: string, group: string): Promise<void>;
     getOrigin(id: string): Promise<string>;
-    getFile(id: number): Promise<MediaManagerItem>;
+    getFile(id: number | string): Promise<MediaManagerItem>;
     protected createMeta(id: string): Promise<void>;
     protected addFileMeta(file: string, id: string): Promise<void>;
     getMeta(id: string): Promise<{

package/lib/media-manager/Items.js

@@ -17,15 +17,27 @@ export class ImageItem extends File {
         this.imageSizes = adminizer.config.mediamanager.imageSizes || {};
         this.adminizer = adminizer;
     }
+    mediaModel() {
+        return this.adminizer.modelHandler.internal("media-manager").get(this.model);
+    }
+    metaRepository() {
+        return this.adminizer.modelHandler.internal("media-manager").get(this.metaModel);
+    }
+    associationModel() {
+        return this.adminizer.modelHandler.internal("media-manager").get(this.modelAssoc);
+    }
     async getItems(limit, skip, sort, group) {
-        // TODO refactor CRUD functions for DataAccessor usage
-        let data = await this.adminizer.modelHandler.model.get(this.model)["_find"]({
+        let data = await this.mediaModel().find({
             where: { parent: null, mimeType: { contains: this.type }, group: group },
             limit: limit,
             skip: skip,
             sort: sort,
-        }, { populate: [["variants", { sort: sort }], ["meta", {}]] });
-        let next = await this.adminizer.modelHandler.model.get(this.model)['_find']({
+            populate: {
+                variants: { sort: sort },
+                meta: true
+            }
+        });
+        let next = await this.mediaModel().find({
             where: { parent: null, mimeType: { contains: this.type }, group: group },
             limit: limit,
             skip: skip === 0 ? limit : skip + limit,
@@ -40,19 +52,20 @@ export class ImageItem extends File {
         };
     }
     async search(s, group) {
-        // TODO refactor CRUD functions for DataAccessor usage
-        let data = await this.adminizer.modelHandler.model.get(this.model)["_find"]({
+        let data = await this.mediaModel().find({
             where: { filename: { contains: s }, mimeType: { contains: this.type }, parent: null, group: group },
             sort: "createdAt DESC",
-        }, { populate: [["variants", { sort: "createdAt DESC" }]] });
+            populate: {
+                variants: { sort: "createdAt DESC" }
+            }
+        });
         for (let elem of data) {
             elem.variants = await populateVariants(this.adminizer, elem.variants, this.model);
         }
         return data;
     }
     async upload(file, filename, origFileName, group) {
-        // TODO refactor CRUD functions for DataAccessor usage
-        let parent = await this.adminizer.modelHandler.model.get(this.model)["_create"]({
+        let parent = await this.mediaModel().create({
             parent: null,
             mimeType: file.mimetype,
             size: file.size,
@@ -68,16 +81,17 @@ export class ImageItem extends File {
         if (Object.keys(this.imageSizes).length && file.mimetype !== 'image/svg+xml') {
             await this.createVariants(file, parent, filename, group);
         }
-        // TODO refactor CRUD functions for DataAccessor usage
-        const item = await this.adminizer.modelHandler.model.get(this.model)["_findOne"]({ where: { id: parent.id } });
+        const item = await this.mediaModel().findOne({ where: { id: parent.id } });
         item.variants = await populateVariants(this.adminizer, item.variants, this.model);
         return [item];
     }
     async getVariants(id) {
-        // TODO refactor CRUD functions for DataAccessor usage
-        let items = ((await this.adminizer.modelHandler.model.get(this.model)["_find"]({
-            where: { id: id }
-        }, { populate: [["variants", { sort: "createdAt DESC" }]] }))[0]).variants;
+        let items = ((await this.mediaModel().find({
+            where: { id: id },
+            populate: {
+                variants: { sort: "createdAt DESC" }
+            }
+        }))[0]).variants;
         return (await populateVariants(this.adminizer, items, this.model));
     }
     async createVariants(file, parent, filename, group) {
@@ -90,8 +104,7 @@ export class ImageItem extends File {
                 continue;
             const output = `${this.fileStoragePath}/${this.urlPathPrefix}/${sizeName}`;
             let newFile = await this.resizeImage(file.path, output, width, height);
-            // TODO refactor CRUD functions for DataAccessor usage
-            let newSize = await this.adminizer.modelHandler.model.get(this.model)["_create"]({
+            let newSize = await this.mediaModel().create({
                 parent: parent.id,
                 mimeType: parent.mimeType,
                 size: newFile.size,
@@ -105,11 +118,10 @@ export class ImageItem extends File {
         }
     }
     async getOrigin(id) {
-        // TODO refactor CRUD functions for DataAccessor usage
-        return (await this.adminizer.modelHandler.model.get(this.model)["_findOne"]({ where: { id: id } })).path;
+        return (await this.mediaModel().findOne({ where: { id: id } })).path;
     }
     async getFile(id) {
-        let item = await this.adminizer.modelHandler.model.get(this.model)["_findOne"]({ where: { id: id } });
+        let item = await this.mediaModel().findOne({ where: { id: String(id) } });
         item.variants = await populateVariants(this.adminizer, item.variants, this.model);
         return item;
     }
@@ -121,8 +133,7 @@ export class ImageItem extends File {
             title: "",
         };
         for (const key of Object.keys(metaData)) {
-            // TODO refactor CRUD functions for DataAccessor usage
-            await this.adminizer.modelHandler.model.get(this.metaModel)["_create"]({
+            await this.metaRepository().create({
                 key: key,
                 value: metaData[key],
                 parent: id,
@@ -131,9 +142,8 @@ export class ImageItem extends File {
         }
     }
     async addFileMeta(file, id) {
-        // TODO refactor CRUD functions for DataAccessor usage
         const metaBuffer = fs.readFileSync(file);
-        await this.adminizer.modelHandler.model.get(this.metaModel)["_create"]({
+        await this.metaRepository().create({
             key: 'imageSizes',
             value: sizeOf(metaBuffer),
             parent: id,
@@ -142,15 +152,16 @@ export class ImageItem extends File {
     }
     // TODO  {where: {isPublic: true}, sort: "id ASC"} ???
     async getMeta(id) {
-        // TODO refactor CRUD functions for DataAccessor usage
-        return ((await this.adminizer.modelHandler.model.get(this.model)["_find"]({
-            id: id
-        }, { populate: [["meta", { where: { isPublic: true } }]] }))[0]).meta;
+        return ((await this.mediaModel().find({
+            where: { id: id },
+            populate: {
+                meta: { where: { isPublic: true } }
+            }
+        }))[0]).meta;
     }
     async setMeta(id, data) {
         for (const key of Object.keys(data)) {
-            // TODO refactor CRUD functions for DataAccessor usage
-            await this.adminizer.modelHandler.model.get(this.metaModel)["_update"]({ parent: id, key: key }, { value: data[key] });
+            await this.metaRepository().update({ where: { parent: id, key: key } }, { value: data[key] });
         }
     }
     async resizeImage(input, output, width, height) {
@@ -168,8 +179,7 @@ export class ImageItem extends File {
     async uploadVariant(parent, file, filename, group, localeId) {
         const variantBuffer = fs.readFileSync(file.path);
         const { width, height } = sizeOf(variantBuffer);
-        // TODO refactor CRUD functions for DataAccessor usage
-        let item = await this.adminizer.modelHandler.model.get(this.model)["_create"]({
+        let item = await this.mediaModel().create({
             parent: parent.id,
             mimeType: file.mimetype,
             size: file.size,
@@ -180,21 +190,18 @@ export class ImageItem extends File {
             url: `/${this.urlPathPrefix}/${filename}`,
         });
         await this.addFileMeta(file.path, item.id);
-        // TODO refactor CRUD functions for DataAccessor usage
-        return (await this.adminizer.modelHandler.model.get(this.model)["_findOne"]({ where: { id: item.id } }));
+        return (await this.mediaModel().findOne({ where: { id: item.id } }));
     }
     async delete(id) {
         const fieldName = this.adminizer.ormAdapters[0].ormType === 'sequelize' ? 'fileId' : 'file';
-        const assoc = await this.adminizer.modelHandler.model.get(this.modelAssoc)["_find"]({ where: { [fieldName]: id } });
+        const assoc = await this.associationModel().find({ where: { [fieldName]: id } });
         if (assoc.length) {
             return Promise.resolve(false);
         }
         const criteria = { where: { id: id } };
-        // TODO refactor CRUD functions for DataAccessor usage
-        let record = await this.adminizer.modelHandler.model.get(this.model)["_findOne"](criteria);
+        let record = await this.mediaModel().findOne(criteria);
         await beforeDestroy(this.adminizer, criteria);
-        // TODO refactor CRUD functions for DataAccessor usage
-        await this.adminizer.modelHandler.model.get(this.model)["_destroy"]({ id: id });
+        await this.mediaModel().destroy({ where: { id: id } });
         await deleteFile(record.path);
         // Delete all variants
         if (record.variants.length) {
@@ -211,8 +218,7 @@ export class ImageItem extends File {
 export class TextItem extends ImageItem {
     type = "text";
     async upload(file, filename, origFileName, group) {
-        // TODO refactor CRUD functions for DataAccessor usage
-        let parent = await this.adminizer.modelHandler.model.get(this.model)["_create"]({
+        let parent = await this.mediaModel().create({
             parent: null,
             mimeType: file.mimetype,
             size: file.size,
@@ -223,8 +229,7 @@ export class TextItem extends ImageItem {
             url: `/${this.urlPathPrefix}/${filename}`,
         });
         await this.createMeta(parent.id);
-        // TODO refactor CRUD functions for DataAccessor usage
-        const item = await this.adminizer.modelHandler.model.get(this.model)["_findOne"]({ where: { id: parent.id } });
+        const item = await this.mediaModel().findOne({ where: { id: parent.id } });
         item.variants = await populateVariants(this.adminizer, item.variants, this.model);
         return [item];
     }
@@ -233,8 +238,7 @@ export class TextItem extends ImageItem {
     }
     async uploadVariant(parent, file, filename, group, localeId) {
         let variants = parent.variants.filter(e => /^loc:/.test(e.tag) === false);
-        // TODO refactor CRUD functions for DataAccessor usage
-        let item = await this.adminizer.modelHandler.model.get(this.model)["_create"]({
+        let item = await this.mediaModel().create({
             parent: parent.id,
             mimeType: file.mimetype,
             size: file.size,
@@ -244,14 +248,15 @@ export class TextItem extends ImageItem {
             filename: parent.filename,
             url: `/${this.urlPathPrefix}/${filename}`,
         });
-        // TODO refactor CRUD functions for DataAccessor usage
-        return (await this.adminizer.modelHandler.model.get(this.model)["_findOne"]({ where: { id: item.id } }));
+        return (await this.mediaModel().findOne({ where: { id: item.id } }));
     }
     async getVariants(id) {
-        // TODO refactor CRUD functions for DataAccessor usage
-        let items = ((await this.adminizer.modelHandler.model.get(this.model)["_find"]({
-            where: { id: id }
-        }, { populate: [["variants", { sort: "createdAt DESC" }]] }))[0]).variants;
+        let items = ((await this.mediaModel().find({
+            where: { id: id },
+            populate: {
+                variants: { sort: "createdAt DESC" }
+            }
+        }))[0]).variants;
         return (await populateVariants(this.adminizer, items, this.model));
     }
 }
@@ -262,18 +267,16 @@ export class VideoItem extends TextItem {
     type = "video";
 }
 async function beforeDestroy(adminizer, criteria) {
-    // TODO refactor CRUD functions for DataAccessor usage
-    let parent = (await adminizer.modelHandler.model.get("MediaManagerAP")?.["_find"](criteria))[0];
+    const mediaModel = adminizer.modelHandler.internal("media-manager").get("MediaManagerAP");
+    const metaModel = adminizer.modelHandler.internal("media-manager").get("MediaManagerMetaAP");
+    let parent = (await mediaModel.find(criteria))[0];
     let meta = parent.meta;
     for (const metaElement of meta) {
-        // TODO refactor CRUD functions for DataAccessor usage
-        await adminizer.modelHandler.model.get("MediaManagerMetaAP")?.["_destroy"]({ id: metaElement.id });
+        await metaModel.destroy({ where: { id: metaElement.id } });
     }
-    // TODO refactor CRUD functions for DataAccessor usage
-    let variants = (await adminizer.modelHandler.model.get("MediaManagerAP")?.["_find"](criteria))[0].variants;
+    let variants = (await mediaModel.find(criteria))[0].variants;
     for (const child of variants) {
-        // TODO refactor CRUD functions for DataAccessor usage
-        await adminizer.modelHandler.model.get("MediaManagerAP")?.["_destroy"]({ id: child.id });
+        await mediaModel.destroy({ where: { id: child.id } });
     }
 }
 async function deleteFile(file) {

package/lib/media-manager/MediaManagerHandler.js

@@ -15,7 +15,7 @@ export class MediaManagerHandler {
         if (!instance) {
             Adminizer.log.debug(`MediaManager with id ${id} not found`);
         }
-        Adminizer.log.debug(`ins`, instance);
+        // Adminizer.log.debug(`ins`, instance)  // DEBUG: removed to reduce console noise
         return instance;
     }
 }

package/lib/media-manager/helpers/MediaManagerHelper.d.ts

@@ -1,7 +1,9 @@
 import { Fields } from "../../../helpers/fieldsHelper";
 import { MediaManagerWidgetData, MediaManagerItem, MediaManagerWidgetItem, MediaManagerWidgetJSON } from "../AbstractMediaManager";
+import { BaseFieldConfig } from "../../../interfaces/adminpanelConfig";
 import { Adminizer } from "../../Adminizer";
 type PostParams = Record<string, string | number | boolean | object | string[] | number[] | null>;
+export declare function isMediaManagerFieldConfig(fieldConfig: BaseFieldConfig): boolean;
 export declare function normalizeMediaManagerWidgetData(value: PostParams[string] | undefined, prop: string): MediaManagerWidgetData[];
 export declare function detachMediaManagerField(reqData: PostParams, rawReqData: PostParams, prop: string): void;
 /**
@@ -19,7 +21,9 @@ export declare function randomFileName(filenameOrig: string, type: string, prefi
  * @param model
  * @param recordId
  */
-export declare function saveRelationsMediaManager(adminizer: Adminizer, fields: Fields, reqData: PostParams, model: string, recordId: number): Promise<void>;
+export declare function saveRelationsMediaManager(adminizer: Adminizer, fields: Fields, reqData: PostParams, model: string, recordId: string | number): Promise<void>;
+export declare function collectMediaManagerHistoryData(fields: Fields, reqData: PostParams): Record<string, MediaManagerWidgetData[]>;
+export declare function updateCurrentHistoryMediaManagerData(adminizer: Adminizer, fields: Fields, reqData: PostParams, model: string, recordId: string | number): Promise<void>;
 /**
  * Get realtions
  * @param adminizer

package/lib/media-manager/helpers/MediaManagerHelper.js

@@ -1,3 +1,6 @@
+export function isMediaManagerFieldConfig(fieldConfig) {
+    return fieldConfig.type === 'mediamanager' || fieldConfig.type === 'single-file';
+}
 export function normalizeMediaManagerWidgetData(value, prop) {
     if (value === undefined || value === null || value === "") {
         return [];
@@ -51,13 +54,44 @@ export async function saveRelationsMediaManager(adminizer, fields, reqData, mode
     for (let prop in reqData) {
         let fieldConfigConfig = fields[prop].config;
         let options = fieldConfigConfig.options;
-        if (fieldConfigConfig.type === 'mediamanager') {
+        if (isMediaManagerFieldConfig(fieldConfigConfig)) {
             const data = normalizeMediaManagerWidgetData(reqData[prop], prop);
             let mediaManager = adminizer.mediaManagerHandler.get(options?.id ?? 'default');
             await mediaManager.setRelations(data, model, recordId, prop);
         }
     }
 }
+export function collectMediaManagerHistoryData(fields, reqData) {
+    const data = {};
+    for (let prop in reqData) {
+        const field = fields[prop];
+        if (!field)
+            continue;
+        const fieldConfigConfig = field.config;
+        if (!isMediaManagerFieldConfig(fieldConfigConfig))
+            continue;
+        data[prop] = normalizeMediaManagerWidgetData(reqData[prop], prop);
+    }
+    return data;
+}
+export async function updateCurrentHistoryMediaManagerData(adminizer, fields, reqData, model, recordId) {
+    if (!adminizer.config.history?.enabled)
+        return;
+    const mediaData = collectMediaManagerHistoryData(fields, reqData);
+    if (!Object.keys(mediaData).length)
+        return;
+    const historyModel = adminizer.modelHandler.internal("history").get("HistoryActionsAP");
+    const currentHistory = await historyModel.findOne({
+        where: {
+            modelId: String(recordId),
+            modelName: model.toLowerCase(),
+            isCurrent: true
+        }
+    });
+    if (!currentHistory)
+        return;
+    await historyModel.update({ where: { id: currentHistory.id } }, { data: { ...(currentHistory.data ?? {}), ...mediaData } });
+}
 /**
  * Get realtions
  * @param adminizer
@@ -79,7 +113,7 @@ export async function deleteRelationsMediaManager(adminizer, model, record) {
     let config = adminizer.config.models[model];
     for (const key of Object.keys(record[0])) {
         let field = config.fields[key];
-        if (field && field.type === 'mediamanager') {
+        if (field && isMediaManagerFieldConfig(field)) {
             const option = field.options;
             let mediaManager = adminizer.mediaManagerHandler.get(option?.id ?? 'default');
             let emptyData = [];
@@ -94,9 +128,9 @@ export async function deleteRelationsMediaManager(adminizer, model, record) {
  */
 export async function populateVariants(adminizer, variants, model) {
     let items = [];
+    const mediaModel = adminizer.modelHandler.internal("media-manager").get(model);
     for (let variant of variants) {
-        // TODO refactor CRUD functions for DataAccessor usage
-        variant = await adminizer.modelHandler.model.get(model)["_findOne"]({ where: { id: variant.id } });
+        variant = await mediaModel.findOne({ where: { id: variant.id } });
         items.push(variant);
     }
     return items;

package/lib/model/AbstractModel.d.ts

@@ -1,5 +1,6 @@
 import { DataAccessor } from "../DataAccessor";
-import Waterline from "waterline";
+import { QueryCriteria } from "../../interfaces/queryCriteria";
+import { InternalModelRepository } from "../../interfaces/internalModelAccess";
 export interface Attribute {
     type: 'association' | 'association-many' | 'number' | 'json' | 'string' | 'boolean' | 'ref';
     required?: boolean;
@@ -24,14 +25,6 @@ export type ModelAnyField = number | string | boolean | Date | Array<number | st
 export type ModelAnyInstance = {
     [key: string]: ModelAnyField;
 };
-type PopulateOption = [string, {
-    sort?: string;
-    where?: any;
-}];
-export interface FindOptions {
-    populate?: PopulateOption[];
-    limit?: number;
-}
 export declare abstract class AbstractModel<T> {
     readonly modelname: string;
     readonly attributes: ModelAttributes;
@@ -39,13 +32,14 @@ export declare abstract class AbstractModel<T> {
     readonly identity: string;
     protected constructor(modelname: string, attributes: ModelAttributes, primaryKey: string, identity: string);
     protected abstract _create(data: Partial<T>): Promise<T>;
-    protected abstract _findOne(criteria: Partial<T>): Promise<T | null>;
-    protected abstract _find(criteria: Partial<T>, options?: FindOptions): Promise<T[]>;
-    protected abstract _updateOne(criteria: Partial<T>, data: Partial<T>): Promise<T | null>;
-    protected abstract _update(criteria: Partial<T>, data: Partial<T>): Promise<T[]>;
-    protected abstract _destroyOne(criteria: Partial<T>): Promise<T | null>;
-    protected abstract _destroy(criteria: Partial<T>): Promise<T[]>;
-    protected abstract _count(criteria: Partial<T> | undefined): Promise<number>;
+    protected abstract _findOne(criteria: QueryCriteria<T>): Promise<T | null>;
+    protected abstract _find(criteria: QueryCriteria<T>): Promise<T[]>;
+    protected abstract _updateOne(criteria: QueryCriteria<T>, data: Partial<T>): Promise<T | null>;
+    protected abstract _update(criteria: QueryCriteria<T>, data: Partial<T>): Promise<T[]>;
+    protected abstract _destroyOne(criteria: QueryCriteria<T>): Promise<T | null>;
+    protected abstract _destroy(criteria: QueryCriteria<T>): Promise<T[]>;
+    protected abstract _count(criteria: QueryCriteria<T>): Promise<number>;
+    protected createInternalRepository(accessToken: symbol, modelName?: string): InternalModelRepository<T>;
     /**
      * Generate diff between old and new records
      */
@@ -60,13 +54,28 @@ export declare abstract class AbstractModel<T> {
      */
     private logSystemEvent;
     create(data: T, dataAccessor: DataAccessor): Promise<Partial<T>>;
-    findOne(criteria: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T> | null>;
-    find(criteria: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T>[]>;
-    updateOne(criteria: Partial<T>, data: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T> | null>;
-    update(criteria: Partial<T>, data: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T>[]>;
-    destroyOne(criteria: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T> | null>;
-    destroy(criteria: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T>[]>;
-    count(criteria: Partial<T> | undefined, dataAccessor: DataAccessor): Promise<number>;
+    findOne(criteria: QueryCriteria<T>, dataAccessor: DataAccessor): Promise<Partial<T> | null>;
+    find(criteria: QueryCriteria<T>, dataAccessor: DataAccessor): Promise<Partial<T>[]>;
+    /**
+     * Find with raw SQL where clause (Sequelize.literal support)
+     * Only available in Sequelize adapter
+     */
+    findWithRawWhere(where: any, options?: {
+        limit?: number;
+        offset?: number;
+        order?: any;
+        populate?: boolean;
+    }): Promise<any[]>;
+    /**
+     * Count with raw SQL where clause (Sequelize.literal support)
+     * Only available in Sequelize adapter
+     */
+    countWithRawWhere(where: any): Promise<number>;
+    updateOne(criteria: QueryCriteria<T>, data: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T> | null>;
+    update(criteria: QueryCriteria<T>, data: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T>[]>;
+    destroyOne(criteria: QueryCriteria<T>, dataAccessor: DataAccessor): Promise<Partial<T> | null>;
+    destroy(criteria: QueryCriteria<T>, dataAccessor: DataAccessor): Promise<Partial<T>[]>;
+    count(criteria: QueryCriteria<T>, dataAccessor: DataAccessor): Promise<number>;
 }
 export declare abstract class AbstractAdapter {
     abstract Model: any;
@@ -75,7 +84,7 @@ export declare abstract class AbstractAdapter {
     protected constructor(type: string, orm: any);
     abstract get models(): Record<string, any>;
     /** This function should return constant type from any adapter (for adminizer proper work) */
-    abstract getAttributes(modelName: string): Waterline.Attributes;
+    abstract getAttributes(modelName: string): ModelAttributes | undefined;
     /** Return full model object */
     abstract getModel(modelName: string): any;
     /**
@@ -83,4 +92,3 @@ export declare abstract class AbstractAdapter {
      */
     static registerSystemModels(orm: any): void;
 }
-export {};