@clairejs/server 3.15.2 → 3.16.1

package/dist/http/repository/ModelRepository.js

@@ -0,0 +1,696 @@
+import { DataType, getModelById, getServiceProvider, RangeQueryDto, uniqueReducer, leanData, getSystemLocale, Errors, omitData, } from "@clairejs/core";
+import { getDirectFields } from "@clairejs/orm";
+import { AbstractFileUploadHandler } from "../file-upload/AbstractFileUploadHandler";
+import { AbstractRepository } from "./AbstractRepository";
+import { LocaleTranslation } from "../../system/locale/LocaleTranslation";
+import { LocaleEntry } from "../../system/locale/LocaleEntry";
+export class ModelRepository extends AbstractRepository {
+    model;
+    fileUploadHandler;
+    constructor(model) {
+        super(model);
+        this.model = model;
+    }
+    getNestedQueries(queries) {
+        return this.modelMetadata.fields
+            .filter((f) => f.hasMany)
+            .filter((f) => queries?.fields && queries.fields[f.name])
+            .map((f) => {
+            const dto = f.hasMany.relationDto;
+            const nestedConditions = this.getRequestQueryConditionFromQuery((queries?.fields)[f.name], {
+                ...dto,
+                fields: dto.fields.filter((df) => df.name !== f.hasMany?.column),
+            });
+            return {
+                modelId: f.hasMany.relationDto.id,
+                targetField: f.hasMany.column,
+                queries: nestedConditions.length ? { _and: nestedConditions } : {},
+            };
+        });
+    }
+    async getUploadHandler() {
+        if (this.fileUploadHandler === undefined) {
+            const injector = getServiceProvider().getInjector();
+            this.fileUploadHandler = injector.resolveOptional(AbstractFileUploadHandler) || null;
+            await injector.initInstances();
+        }
+        return this.fileUploadHandler;
+    }
+    getRequestQueryConditionFromQuery(queries, modelMetadata) {
+        const result = [];
+        for (const fieldMetadata of getDirectFields(modelMetadata)) {
+            const fieldName = `${modelMetadata.id}.${fieldMetadata.name}`;
+            const queryValue = queries[fieldMetadata.name];
+            if (queryValue === undefined) {
+                continue;
+            }
+            if (fieldMetadata.pk || fieldMetadata.fk || fieldMetadata.isSymbol) {
+                //-- belongs to array of ids
+                result.push({ _in: { [fieldName]: queryValue } });
+            }
+            else {
+                if (fieldMetadata.enum) {
+                    result.push({ _in: { [fieldName]: queryValue } });
+                }
+                else {
+                    switch (fieldMetadata.dataType) {
+                        case DataType.STRING:
+                            if (!fieldMetadata.searchable) {
+                                result.push({
+                                    _eq: { [fieldName]: queryValue },
+                                });
+                            }
+                            else {
+                                const op = fieldMetadata?.searchable.caseSensitive
+                                    ? fieldMetadata?.searchable.accentSensitive
+                                        ? "_sub"
+                                        : "_usub"
+                                    : fieldMetadata?.searchable?.accentSensitive
+                                        ? "_isub"
+                                        : "_iusub";
+                                const cond = {
+                                    [op]: {
+                                        [fieldName]: queryValue,
+                                    },
+                                };
+                                result.push(cond);
+                            }
+                            break;
+                        case DataType.NUMBER:
+                            const rangeQuery = new RangeQueryDto();
+                            Object.assign(rangeQuery, queryValue);
+                            if (rangeQuery.min) {
+                                if (rangeQuery.minExclusive) {
+                                    result.push({
+                                        _gt: { [fieldName]: rangeQuery.min },
+                                    });
+                                }
+                                else {
+                                    result.push({
+                                        _gte: { [fieldName]: rangeQuery.min },
+                                    });
+                                }
+                            }
+                            if (rangeQuery.max) {
+                                if (rangeQuery.maxExclusive) {
+                                    result.push({
+                                        _lt: { [fieldName]: rangeQuery.max },
+                                    });
+                                }
+                                else {
+                                    result.push({
+                                        _lte: { [fieldName]: rangeQuery.max },
+                                    });
+                                }
+                            }
+                            break;
+                        case DataType.BOOLEAN:
+                            result.push({
+                                _eq: { [fieldName]: queryValue },
+                            });
+                            break;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    async uriHandling(records) {
+        const modified = [];
+        const fileUploadHandler = await this.getUploadHandler();
+        const operations = [];
+        const uriHandler = async (tmpUri, uriMapper, locale, newUriCb) => {
+            const newUri = uriMapper(tmpUri, locale);
+            if (!newUri) {
+                return;
+            }
+            //-- move from currentUri to newUri
+            await fileUploadHandler.copyFile(tmpUri, newUri);
+            //-- update record value and not persist yet
+            newUriCb(newUri);
+        };
+        if (fileUploadHandler) {
+            for (const field of this.modelMetadata.fields) {
+                for (const record of records) {
+                    if (field.uriMapper) {
+                        const tmpUri = record[field.name];
+                        if (!tmpUri) {
+                            continue;
+                        }
+                        if (!field.mimeProps?.keepOnRemove) {
+                            modified.push(tmpUri);
+                        }
+                        operations.push(uriHandler(tmpUri, field.uriMapper, getSystemLocale(), (newUri) => (record[field.name] = newUri)));
+                    }
+                    else if (field.multiLocaleColumn) {
+                        const targetField = this.modelMetadata.fields.find((f) => f.name === field.multiLocaleColumn);
+                        if (targetField?.uriMapper && record[field.name]) {
+                            //-- this field is locale for targetField, which has uri mapper
+                            const localeUris = Object.keys(record[field.name]).map((lang) => [
+                                lang,
+                                record[field.name][lang],
+                            ]);
+                            //-- for each pair or locale and tmp uri, invoke handle logic
+                            for (const localeUri of localeUris) {
+                                if (!targetField.mimeProps?.keepOnRemove) {
+                                    modified.push(localeUri[1]);
+                                }
+                                operations.push(uriHandler(localeUri[1], targetField.uriMapper, localeUri[0], (newUri) => (record[field.name][localeUri[0]] = newUri)));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        //-- await all operations once to save time
+        await Promise.all(operations);
+        return async () => {
+            if (fileUploadHandler) {
+                await Promise.all(modified.map((uri) => fileUploadHandler.removeFile(uri)));
+            }
+        };
+    }
+    async beforeReturning(records) {
+        //-- resolve url
+        const fileUploadHandler = await this.getUploadHandler();
+        if (!fileUploadHandler) {
+            return;
+        }
+        const mappingOperations = [];
+        for (const record of records) {
+            for (const field of this.modelMetadata.fields) {
+                if (field.uriMapper) {
+                    if (!record[field.name]) {
+                        continue;
+                    }
+                    mappingOperations.push((async () => {
+                        record[field.name] = field.mimeProps?.public
+                            ? await fileUploadHandler.resolvePublicUrl(record[field.name])
+                            : await fileUploadHandler.resolvePrivateUrl(record[field.name]);
+                    })());
+                }
+                else if (field.multiLocaleColumn) {
+                    const targetField = this.modelMetadata.fields.find((f) => f.name === field.multiLocaleColumn);
+                    if (targetField?.uriMapper) {
+                        const localeObject = record[field.name];
+                        if (!localeObject) {
+                            continue;
+                        }
+                        for (const locale of Object.keys(localeObject)) {
+                            mappingOperations.push((async () => {
+                                localeObject[locale] = targetField.mimeProps?.public
+                                    ? await fileUploadHandler.resolvePublicUrl(localeObject[locale])
+                                    : await fileUploadHandler.resolvePrivateUrl(localeObject[locale]);
+                            })());
+                        }
+                    }
+                }
+            }
+        }
+        await Promise.all(mappingOperations);
+    }
+    async createMany({ principal, body, tx, }) {
+        const originalRecords = body.records;
+        if (!originalRecords.length) {
+            return { records: [] };
+        }
+        const directFields = getDirectFields(this.modelMetadata);
+        const localeFields = directFields.filter((f) => !!f.multiLocaleColumn);
+        const cleanUp = await this.uriHandling(originalRecords);
+        const systemLocale = getSystemLocale();
+        if (systemLocale) {
+            //-- override values in record
+            for (const record of originalRecords) {
+                for (const field of localeFields) {
+                    if (record[field.name]) {
+                        record[field.multiLocaleColumn] = record[field.name][systemLocale];
+                    }
+                }
+            }
+        }
+        //-- create locale entries
+        const translationEntryData = originalRecords
+            .map((record, index) => {
+            return localeFields
+                .filter((f) => !!record[f.name])
+                .map((f) => ({
+                recordIndex: index,
+                field: f.name,
+                entryObject: {},
+            }));
+        })
+            .flatMap((arr) => arr);
+        const translationEntries = await tx
+            .use(LocaleEntry)
+            .createMany(translationEntryData.map((data) => data.entryObject));
+        //-- translation data will have same length as translationEntries
+        const translationData = originalRecords
+            .map((record) => {
+            return localeFields.filter((f) => !!record[f.name]).map((f) => record[f.name]);
+        })
+            .flatMap((arr) => arr);
+        //-- mapping supplied data with entry ids
+        const translations = translationData
+            .map((data, index) => {
+            return Object.keys(data).map((localeCode) => ({
+                localeCode,
+                entryId: translationEntries[index].id,
+                translation: data[localeCode],
+            }));
+        })
+            .flatMap((arr) => arr);
+        //-- create translation records
+        await tx.use(LocaleTranslation).createMany(translations);
+        //-- first create records for direct fields
+        body.records = originalRecords.map((record, index) => {
+            const data = directFields.reduce((collector, field) => {
+                let fieldValue = record[field.name];
+                //-- check if this field is locale of then get the correct locale entry id
+                if (field.multiLocaleColumn) {
+                    //-- find the translationEntryData
+                    const entryDataIndex = translationEntryData.findIndex((data) => data.recordIndex === index && data.field === field.name);
+                    if (entryDataIndex >= 0) {
+                        fieldValue = translationEntries[entryDataIndex].id;
+                    }
+                }
+                return Object.assign(collector, fieldValue !== undefined
+                    ? {
+                        [field.name]: fieldValue,
+                    }
+                    : {});
+            }, {});
+            return data;
+        });
+        await this.beforeCreating(principal, body.records);
+        let records = body.records.length ? await tx.use(this.model).createMany(body.records) : [];
+        await this.beforeReturning(records);
+        const projection = this.modelMetadata.fields
+            .filter((field) => !field.multiLocaleColumn && (field.pk || field.serverValue || field.mimeProps))
+            .map((field) => field.name);
+        records = this.project(records, projection);
+        //-- then create records for has many fields
+        const hasManyFields = this.modelMetadata.fields.filter((f) => !!f.hasMany);
+        for (const field of hasManyFields) {
+            //-- collect info
+            const hasManyRecords = records.flatMap((record, index) => {
+                //-- insert the id of the just-created-record to innerRecord at field designated by hasMany.column
+                const nestedRecords = originalRecords[index][field.name];
+                if (!nestedRecords) {
+                    return [];
+                }
+                return (field.hasMany?.single ? [nestedRecords] : nestedRecords).map((innerRecord) => ({
+                    ...innerRecord,
+                    [field.hasMany.column]: record.id,
+                }));
+            });
+            if (hasManyRecords.length) {
+                //-- insert to db
+                const innerService = new ModelRepository(getModelById(field.hasMany.relationDto.id));
+                body.records = hasManyRecords;
+                const persistedInnerRecords = await innerService.createMany({ principal, body, tx });
+                //-- map back ids to hasManyRecords
+                for (let i = 0; i < persistedInnerRecords.records.length; i++) {
+                    hasManyRecords[i] = { ...hasManyRecords[i], ...persistedInnerRecords.records[i] };
+                }
+                //-- assign back to records
+                for (let i = 0; i < records.length; i++) {
+                    //-- only assign back persistedInnerRecords to avoid return redundant data
+                    const filteredPersistedRecords = [];
+                    for (let j = 0; j < hasManyRecords.length; j++) {
+                        if (hasManyRecords[j][field.hasMany.column] === records[i].id) {
+                            filteredPersistedRecords.push(persistedInnerRecords.records[j]);
+                        }
+                    }
+                    records[i] = {
+                        ...records[i],
+                        [field.name]: field.hasMany?.single ? filteredPersistedRecords[0] : filteredPersistedRecords,
+                    };
+                }
+            }
+        }
+        //-- everything is ok, remove original Uris
+        await cleanUp();
+        return { records };
+    }
+    async updateMany({ principal, ops, queries, body, tx, }) {
+        const allConditions = ops || [];
+        const hasManyFields = this.modelMetadata.fields.filter((f) => !!f.hasMany);
+        const systemLocale = getSystemLocale();
+        //-- does not update multi locale columns
+        const directUpdateFields = getDirectFields(this.modelMetadata).filter((f) => !f.multiLocaleColumn &&
+            (body.update[f.name] !== undefined || (f.isMultiLocale && !!systemLocale)));
+        const updatedFields = Object.keys(body.update);
+        const localeOfFields = this.modelMetadata.fields.filter((f) => updatedFields.includes(f.name) && f.multiLocaleColumn);
+        const cleanUp = await this.uriHandling([body.update]);
+        //-- calculate direct update after uri handling
+        const directUpdate = leanData(directUpdateFields.reduce((collector, field) => Object.assign(collector, { [field.name]: body.update[field.name] }), {})) || {};
+        if (systemLocale) {
+            //-- override values in record
+            for (const field of localeOfFields) {
+                if (body.update[field.name]) {
+                    const translation = body.update[field.name][systemLocale];
+                    if (translation !== undefined) {
+                        directUpdate[field.multiLocaleColumn] = translation;
+                    }
+                }
+            }
+        }
+        if (queries?.fields) {
+            const fieldOps = this.getRequestQueryConditionFromQuery(queries.fields, this.modelMetadata);
+            if (fieldOps.length) {
+                allConditions.push(...fieldOps);
+            }
+        }
+        const condition = allConditions.length ? { _and: [...allConditions] } : {};
+        const nestedQueries = this.getNestedQueries(queries);
+        let modified = [];
+        let updatedRecords = [];
+        if (nestedQueries.length) {
+            const tobeUpdated = await tx.use(this.model).getMany(condition, { projection: ["id"] }, nestedQueries);
+            modified = tobeUpdated.records.map((r) => r.id);
+            if (modified.length) {
+                if (directUpdateFields.length) {
+                    updatedRecords = await tx
+                        .use(this.model)
+                        .updateMany({ _in: { id: modified } }, directUpdate, true);
+                }
+                else {
+                    updatedRecords = modified.map((id) => ({ id }));
+                }
+            }
+        }
+        else {
+            if (directUpdateFields.length) {
+                updatedRecords = await tx.use(this.model).updateMany(condition, directUpdate, true);
+                modified = updatedRecords.map((re) => re.id);
+            }
+            else {
+                const tobeUpdated = await tx.use(this.model).getMany(condition, { projection: ["id"] });
+                modified = tobeUpdated.records.map((r) => r.id);
+                updatedRecords = modified.map((id) => ({ id }));
+            }
+        }
+        //-- body.update here had been modified by uri handling
+        const records = updatedRecords.map((re) => ({ ...body.update, ...re }));
+        //-- update translations
+        if (localeOfFields.length) {
+            //-- check if there is missing locale entry for localeFields
+            const records = await tx.use(this.model).getRecords({
+                _in: { id: modified },
+            }, { projection: ["id", ...localeOfFields.map((f) => f.name)] });
+            //-- check missing
+            const missing = records
+                .map((record) => localeOfFields
+                .filter((field) => !record[field.name])
+                .map((field) => ({
+                recordId: record.id,
+                field: field.name,
+            })))
+                .flatMap((arr) => arr);
+            const missingEntries = !missing.length ? [] : await tx.use(LocaleEntry).createMany(missing.map(() => ({})));
+            const updateEntryRecords = [];
+            missingEntries.forEach((entry, index) => {
+                const missingData = missing[index];
+                const record = records.find((re) => re.id === missingData.recordId);
+                if (record) {
+                    record[missingData.field] = entry.id;
+                    //-- add to updateEntryRecords
+                    let updateRecord = updateEntryRecords.find((re) => re.id === record.id);
+                    if (!updateRecord) {
+                        updateRecord = { id: record.id };
+                        updateEntryRecords.push(updateRecord);
+                    }
+                    updateRecord[missingData.field] = entry.id;
+                }
+            });
+            //-- update records
+            await Promise.all(updateEntryRecords.map((re) => tx.use(this.model).updateById(re.id, omitData(re, ["id"]))));
+            const tobeModified = [];
+            for (const field of localeOfFields) {
+                const localOfData = body.update[field.name];
+                //-- do not add record for system locale, it is stored directly in the model record
+                const locales = Object.keys(localOfData || {}).filter((key) => key !== systemLocale);
+                if (locales.length) {
+                    tobeModified.push(...records
+                        .map((re) => locales.map((locale) => ({
+                        entryId: re[field.name],
+                        langCode: locale,
+                        translation: localOfData[locale],
+                    })))
+                        .flatMap((arr) => arr));
+                }
+            }
+            if (tobeModified.length) {
+                //-- remove old translations
+                await tx.use(LocaleTranslation).deleteMany({
+                    _or: tobeModified.map((rem) => ({
+                        _eq: { entryId: rem.entryId, localeCode: rem.langCode },
+                    })),
+                });
+                //-- add new translations
+                await tx.use(LocaleTranslation).createMany(tobeModified.map((rem) => ({
+                    entryId: rem.entryId,
+                    localeCode: rem.langCode,
+                    translation: rem.translation,
+                })));
+            }
+        }
+        //-- update hasMany
+        for (const field of hasManyFields) {
+            const innerUpdates = body.update[field.name];
+            if (innerUpdates === undefined || !modified.length) {
+                continue;
+            }
+            if (modified.length > 1) {
+                throw Errors.SYSTEM_ERROR(`Multiple records found while updating @HasMany field: ${field.name}`);
+            }
+            const theRecord = records.find((r) => r.id === modified[0]);
+            //-- get all inner records and compare
+            const model = getModelById(field.hasMany.relationDto.id);
+            const adapter = tx.use(model);
+            const allInnerRecords = await adapter.getRecords({ _eq: { [field.hasMany.column]: theRecord.id } }, { limit: field.hasMany?.single ? 1 : undefined });
+            const currentIds = allInnerRecords.map((r) => r.id);
+            const newIds = innerUpdates.map((r) => r.id).filter((id) => !!id);
+            const tobeRemovedIds = currentIds.filter((id) => !newIds.includes(id));
+            const tobeAdded = innerUpdates
+                .filter((r) => !r.id)
+                .map((r) => ({ ...r, [field.hasMany.column]: theRecord.id }));
+            const tobeKept = innerUpdates.filter((r) => !!r.id);
+            if (tobeRemovedIds.length) {
+                await adapter.deleteMany({ _in: { id: tobeRemovedIds } });
+            }
+            const modelService = new ModelRepository(model);
+            const added = await modelService.createMany({
+                principal,
+                body: { records: tobeAdded },
+                tx,
+            });
+            const updatedToBeKept = await Promise.all(tobeKept
+                .filter((r) => Object.keys(r).length > 1)
+                .map((r) => modelService.updateMany({
+                queries: { returning: true },
+                principal,
+                ops: [{ _eq: { id: r.id } }],
+                tx,
+                body: { update: leanData({ ...r, id: undefined }) },
+            })));
+            //-- return the new inners records
+            const finalInnerRecords = tobeAdded
+                .map((toAdd, index) => ({ ...toAdd, ...added.records[index] }))
+                .concat(updatedToBeKept.map((r) => r.modified[0]));
+            theRecord[field.name] = (field.hasMany?.single ? finalInnerRecords[0] : finalInnerRecords);
+        }
+        let projection = ["id"];
+        if (queries?.returning) {
+            //-- return result
+            projection = [
+                ...projection,
+                ...Object.keys(body.update).filter((key) => body.update[key] !== undefined),
+                "lastModified",
+            ];
+        }
+        //-- ok clean up
+        await cleanUp();
+        await this.beforeReturning(records);
+        return { modified: this.project(records, projection) };
+    }
+    async getMany({ queries, ops, queryProvider, }) {
+        const conditions = ops || [];
+        if (queries?.fields) {
+            conditions.push(...this.getRequestQueryConditionFromQuery(queries.fields, this.modelMetadata));
+        }
+        if (queries?.search) {
+            //-- text search on fields that were masked with @Searchable decorator
+            const searchOps = this.modelMetadata.fields
+                .filter((field) => field.searchable)
+                .map((field) => ({
+                _iusub: { [field.name]: queries.search },
+            }));
+            if (searchOps.length) {
+                conditions.push({ _or: searchOps });
+            }
+        }
+        //-- check if there is any multi-local fields in projection
+        const multiLocaleFields = this.modelMetadata.fields.filter((f) => f.isMultiLocale && (!queries?.projection || queries.projection.includes(f.name)));
+        const localeOfFields = this.modelMetadata.fields.filter((f) => multiLocaleFields.find((locale) => locale.name === f.multiLocaleColumn));
+        const finalProjection = queries?.projection && [
+            ...queries.projection.filter((fieldName) => !this.modelMetadata.fields.find((f) => f.name === fieldName && !!f.hasMany)),
+            ...localeOfFields.map((f) => f.name),
+        ];
+        const result = await queryProvider.use(this.model).getMany(conditions.length ? { _and: conditions } : {}, {
+            limit: queries?.limit,
+            page: queries?.page,
+            projection: finalProjection,
+            order: queries?.order === "random"
+                ? queries.order
+                : queries?.order?.map((o) => {
+                    const key = Object.keys(o).find((k) => !!o[k]);
+                    return [key, o[key]];
+                }),
+        }, 
+        //-- page and limit does not affect nested queries
+        this.getNestedQueries(queries));
+        const recordIds = result.records.map((r) => r.id);
+        const allLocaleEntries = result.records
+            .map((record) => localeOfFields.map((field) => record[field.name]))
+            .flatMap((ids) => ids)
+            .filter((id) => id);
+        const systemLocale = getSystemLocale();
+        const translations = !allLocaleEntries.length
+            ? []
+            : !queries?.locale
+                ? //-- if locale is not specified then get translation for all locales
+                    await queryProvider.use(LocaleTranslation).getRecords({
+                        _in: { entryId: allLocaleEntries },
+                    }, { projection: ["entryId", "localeCode", "translation"] })
+                : //-- if locale is specified then get only the translation of that locale
+                    queries.locale.toLowerCase() !== systemLocale
+                        ? await queryProvider.use(LocaleTranslation).getRecords({
+                            _in: { entryId: allLocaleEntries },
+                            _eq: { localeCode: queries.locale },
+                        }, { projection: ["entryId", "localeCode", "translation"] })
+                        : //-- locale is system locale, no need to fetch translation
+                            [];
+        for (const record of result.records) {
+            for (const field of localeOfFields) {
+                //-- map back translation
+                if (!queries?.locale) {
+                    //-- map as object
+                    const fieldTranslations = translations.filter((t) => t.entryId === record[field.name]);
+                    if (!fieldTranslations.length) {
+                        record[field.name] = {};
+                    }
+                    else {
+                        record[field.name] = fieldTranslations.reduce((collector, t) => Object.assign(collector, { [t.localeCode]: t.translation }), {});
+                    }
+                }
+                else {
+                    //-- replace value
+                    const translation = translations.find((t) => t.localeCode === queries.locale && t.entryId === record[field.name]);
+                    if (translation) {
+                        record[field.multiLocaleColumn] = translation.translation;
+                    }
+                }
+            }
+        }
+        //-- get has many fields
+        for (const field of this.modelMetadata.fields) {
+            if (!field.hasMany || (queries?.projection && !queries.projection.includes(field.name))) {
+                continue;
+            }
+            const model = getModelById(field.hasMany.relationDto.id);
+            const service = new ModelRepository(model);
+            const innerRecords = !recordIds.length
+                ? { records: [] }
+                : await service.getMany({
+                    queries: { fields: { [field.hasMany.column]: recordIds }, limit: field.hasMany.single ? 1 : 0 },
+                    queryProvider,
+                });
+            //-- filter corresponding inner records for each master record
+            for (const record of result.records) {
+                const finalRecords = innerRecords.records.filter((r) => r[field.hasMany.column] === record.id);
+                record[field.name] = (field.hasMany.single ? finalRecords[0] : finalRecords);
+            }
+        }
+        await this.beforeReturning(result.records);
+        return {
+            total: result.total,
+            records: this.project(result.records, queries?.projection &&
+                [...queries.projection, ...(queries.locale ? [] : finalProjection || [])].reduce(uniqueReducer, [])),
+        };
+    }
+    async deleteMany({ queries, ops, tx, }) {
+        let allConditions = ops || [];
+        if (queries?.fields) {
+            const fieldOps = this.getRequestQueryConditionFromQuery(queries.fields, this.modelMetadata);
+            if (fieldOps.length) {
+                allConditions.push(...fieldOps);
+            }
+        }
+        const condition = allConditions.length ? { _and: [...allConditions, ...(ops || [])] } : {};
+        const nestedQueries = this.getNestedQueries(queries);
+        let returning = [];
+        const uriMapperFields = this.modelMetadata.fields.filter((f) => f.uriMapper);
+        const localeOfFields = this.modelMetadata.fields.filter((f) => f.multiLocaleColumn);
+        if (nestedQueries.length || localeOfFields.length || uriMapperFields.length) {
+            const tobeRemoved = await tx
+                .use(this.model)
+                .getRecords(condition, { projection: ["id", ...[...localeOfFields, ...uriMapperFields].map((f) => f.name)] }, nestedQueries);
+            await tx.use(this.model).deleteMany({
+                _in: { id: tobeRemoved.map((r) => r.id) },
+            });
+            //-- collect uri to remove
+            const toBeRemovedUris = [];
+            for (const record of tobeRemoved) {
+                for (const field of uriMapperFields) {
+                    if (record[field.name] && !field.mimeProps?.keepOnRemove) {
+                        toBeRemovedUris.push(record[field.name]);
+                    }
+                }
+            }
+            const localeUriLocalEntryIds = [];
+            for (const record of tobeRemoved) {
+                for (const field of localeOfFields) {
+                    const targetField = this.modelMetadata.fields.find((f) => f.name === field.name);
+                    if (targetField?.uriMapper &&
+                        !targetField.mimeProps?.keepOnRemove &&
+                        record[targetField.name]) {
+                        localeUriLocalEntryIds.push(record[targetField.name]);
+                    }
+                }
+            }
+            if (localeUriLocalEntryIds.length) {
+                //-- get all uris and add to remove list
+                const records = await tx
+                    .use(LocaleTranslation)
+                    .getRecords({ _in: { entryId: localeUriLocalEntryIds } }, { projection: ["translation"] });
+                for (const record of records) {
+                    if (record.translation) {
+                        toBeRemovedUris.push(record.translation);
+                    }
+                }
+            }
+            //-- remove translations
+            const localeEntryIds = tobeRemoved
+                .map((record) => localeOfFields.map((field) => record[field.name]))
+                .flatMap((ids) => ids)
+                .filter((id) => !!id);
+            //-- remove locale entry, will cascade locale translations
+            if (localeEntryIds.length) {
+                await tx.use(LocaleEntry).deleteMany({ _in: { id: localeEntryIds } });
+            }
+            //-- remove uris
+            if (toBeRemovedUris.length) {
+                const fileUploadHandler = await this.getUploadHandler();
+                if (fileUploadHandler) {
+                    await Promise.all(toBeRemovedUris.map((uri) => fileUploadHandler.removeFile(uri)));
+                }
+            }
+            returning = tobeRemoved;
+        }
+        else {
+            returning = await tx.use(this.model).deleteMany(condition, queries?.returning);
+        }
+        return { modified: returning };
+    }
+}