@tstdl/base 0.85.13 → 0.86.0-beta1

package/database/mongo/mongo-entity-repository.js

@@ -1,304 +1,278 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var mongo_entity_repository_exports = {};
-__export(mongo_entity_repository_exports, {
-  MongoEntityRepository: () => MongoEntityRepository,
-  getNoopTransformer: () => getNoopTransformer,
-  mapTo: () => mapTo,
-  noopTransformer: () => noopTransformer,
-  noopTransformerFunction: () => noopTransformerFunction
-});
-module.exports = __toCommonJS(mongo_entity_repository_exports);
-var import_container = require("../../container/index.js");
-var import_database = require("../../database/index.js");
-var import_equals = require("../../utils/equals.js");
-var import_object = require("../../utils/object/object.js");
-var import_throw = require("../../utils/throw.js");
-var import_type_guards = require("../../utils/type-guards.js");
-var import_mongo_base_repository = require("./mongo-base.repository.js");
-var import_query_converter = require("./query-converter.js");
-function mapTo(key, transform) {
-  return { key, transform };
+import { afterResolve } from '../../container/index.js';
+import { EntityRepository } from '../../database/index.js';
+import { equals } from '../../utils/equals.js';
+import { filterUndefinedFromRecord, objectEntries, objectKeys } from '../../utils/object/object.js';
+import { _throw } from '../../utils/throw.js';
+import { isDefined, isUndefined } from '../../utils/type-guards.js';
+import { MongoBaseRepository } from './mongo-base.repository.js';
+import { convertQuery, convertSort } from './query-converter.js';
+export function mapTo(key, transform) {
+    return { key, transform };
 }
-const noopTransformerFunction = (item) => item;
-const noopTransformer = {
-  transform: noopTransformerFunction,
-  untransform: noopTransformerFunction
+export const noopTransformerFunction = (item) => item;
+export const noopTransformer = {
+    transform: noopTransformerFunction,
+    untransform: noopTransformerFunction
 };
-function getNoopTransformer() {
-  return noopTransformer;
+export function getNoopTransformer() {
+    return noopTransformer;
 }
-class MongoEntityRepository extends import_database.EntityRepository {
-  collection;
-  transformer;
-  logger;
-  indexes;
-  baseRepository;
-  transformerMappingMap;
-  constructor(collection, transformer, { logger, indexes }) {
-    super();
-    this.collection = collection;
-    this.transformer = transformer;
-    this.logger = logger.prefix(`${collection.collectionName}: `);
-    this.indexes = indexes?.map(normalizeIndex);
-    this.baseRepository = new import_mongo_base_repository.MongoBaseRepository(collection);
-    this.transformerMappingMap = new Map((0, import_object.objectEntries)(transformer.mapping ?? {}));
-  }
-  async [import_container.afterResolve]() {
-    await this.initialize();
-  }
-  async initialize() {
-    const indexes = this.indexes?.map((index) => ({ index, normalizedIndex: normalizeIndex(index) }));
-    if ((0, import_type_guards.isUndefined)(indexes)) {
-      return;
-    }
-    const existingRawIndexes = await this.collection.indexes();
-    const existingIndexes = existingRawIndexes.map(normalizeIndex).filter((index) => index.name != "_id_");
-    const unwantedIndexes = existingIndexes.filter((existingIndex) => !indexes.some(({ normalizedIndex }) => (0, import_equals.equals)(existingIndex, normalizedIndex, { deep: true, sortArray: false })));
-    const requiredIndexes = indexes.filter(({ normalizedIndex: wantedNormalizedIndex }) => !existingIndexes.some((index) => (0, import_equals.equals)(wantedNormalizedIndex, index, { deep: true, sortArray: false })));
-    for (const unwantedIndex of unwantedIndexes) {
-      this.logger.warn(`dropping index ${unwantedIndex.name}`);
-      await this.collection.dropIndex(unwantedIndex.name);
-    }
-    if (requiredIndexes.length > 0) {
-      const indexexToCreate = requiredIndexes.map(({ index }) => index);
-      const indexNames = indexexToCreate.map((index) => index.name ?? (0, import_throw._throw)(new Error("index name missing")));
-      this.logger.warn(`creating indexes ${indexNames.join(", ")}`);
-      await this.baseRepository.createIndexes(indexexToCreate);
-    }
-  }
-  async load(id) {
-    return this.loadByFilter({ id });
-  }
-  async tryLoad(id) {
-    return this.tryLoadByFilter({ id });
-  }
-  async loadMany(ids, options) {
-    return this.loadManyByFilter({ id: { $in: ids } }, options);
-  }
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async *loadManyCursor(ids, options) {
-    yield* this.loadManyByFilterCursor({ id: { $in: ids } }, options);
-  }
-  async loadByFilter(filter, options) {
-    const transformedFilter = this.transformFilter(filter);
-    const entity = await this.baseRepository.loadByFilter(transformedFilter, convertOptions(options, this.transformerMappingMap));
-    return this.transformer.untransform(entity);
-  }
-  async tryLoadByFilter(filter, options) {
-    const transformedFilter = this.transformFilter(filter);
-    const entity = await this.baseRepository.tryLoadByFilter(transformedFilter, convertOptions(options, this.transformerMappingMap));
-    return entity == void 0 ? void 0 : this.transformer.untransform(entity);
-  }
-  async loadManyByFilter(filter, options) {
-    const transformedFilter = this.transformFilter(filter);
-    const entities = await this.baseRepository.loadManyByFilter(transformedFilter, convertOptions(options, this.transformerMappingMap));
-    return entities.map(this.transformer.untransform);
-  }
-  async *loadManyByFilterCursor(filter, options) {
-    const transformedFilter = this.transformFilter(filter);
-    for await (const entity of this.baseRepository.loadManyByFilterWithCursor(transformedFilter, convertOptions(options, this.transformerMappingMap))) {
-      yield this.transformer.untransform(entity);
-    }
-  }
-  async loadAll(options) {
-    const entities = await this.baseRepository.loadManyByFilter({}, convertOptions(options, this.transformerMappingMap));
-    return entities.map((entity) => this.transformer.untransform(entity));
-  }
-  async *loadAllCursor(options) {
-    for await (const entity of this.baseRepository.loadManyByFilterWithCursor({}, convertOptions(options, this.transformerMappingMap))) {
-      yield this.transformer.untransform(entity);
-    }
-  }
-  async loadAndDelete(id) {
-    return this.loadByFilterAndDelete({ id });
-  }
-  async tryLoadAndDelete(id) {
-    return this.tryLoadByFilterAndDelete({ id });
-  }
-  async loadByFilterAndDelete(filter, options) {
-    const transformedFilter = this.transformFilter(filter);
-    const entity = await this.baseRepository.loadByFilterAndDelete(transformedFilter, convertOptions(options, this.transformerMappingMap));
-    return this.transformer.untransform(entity);
-  }
-  async tryLoadByFilterAndDelete(filter, options) {
-    const transformedFilter = this.transformFilter(filter);
-    const entity = await this.baseRepository.tryLoadByFilterAndDelete(transformedFilter, convertOptions(options, this.transformerMappingMap));
-    return entity == void 0 ? void 0 : this.transformer.untransform(entity);
-  }
-  async loadAndPatch(id, patch, includePatch) {
-    return this.loadByFilterAndPatch({ id }, patch, includePatch);
-  }
-  async tryLoadAndPatch(id, patch, includePatch) {
-    return this.tryLoadByFilterAndPatch({ id }, patch, includePatch);
-  }
-  async loadByFilterAndPatch(filter, patch, includePatch, options) {
-    const transformedFilter = this.transformFilter(filter);
-    const update = this.transformPatch(patch);
-    const loadOptions = convertOptions(options, this.transformerMappingMap) ?? {};
-    const entity = await this.baseRepository.loadByFilterAndUpdate(transformedFilter, update, { ...loadOptions, returnDocument: includePatch ? "after" : "before" });
-    return this.transformer.untransform(entity);
-  }
-  async tryLoadByFilterAndPatch(filter, patch, includePatch, options) {
-    const transformedFilter = this.transformFilter(filter);
-    const update = this.transformPatch(patch);
-    const loadOptions = convertOptions(options, this.transformerMappingMap) ?? {};
-    const entity = await this.baseRepository.tryLoadByFilterAndUpdate(transformedFilter, update, { ...loadOptions, returnDocument: includePatch ? "after" : "before" });
-    return entity == void 0 ? void 0 : this.transformer.untransform(entity);
-  }
-  async has(id) {
-    return this.hasByFilter({ id });
-  }
-  async hasByFilter(filter) {
-    const transformedFilter = this.transformFilter(filter);
-    return this.baseRepository.hasByFilter(transformedFilter);
-  }
-  async hasMany(ids) {
-    const transformedFilter = this.transformFilter({ id: { $in: ids } });
-    return this.baseRepository.getIdsByFilter(transformedFilter);
-  }
-  async hasAll(ids) {
-    const transformedFilter = this.transformFilter({ id: { $in: ids } });
-    const count = await this.baseRepository.countByFilter(transformedFilter);
-    return count == ids.length;
-  }
-  async count(allowEstimation = false) {
-    if (allowEstimation) {
-      return this.baseRepository.countByFilterEstimated();
-    }
-    return this.baseRepository.countByFilter({});
-  }
-  async countByFilter(filter, _allowEstimation = false) {
-    const transformedFilter = this.transformFilter(filter);
-    return this.baseRepository.countByFilter(transformedFilter);
-  }
-  async patch(entity, patch) {
-    return this.patchByFilter({ _id: entity.id }, patch);
-  }
-  async patchMany(entities, patch) {
-    const ids = entities.map((entity) => entity.id);
-    return this.patchManyByFilter({ _id: { $in: ids } }, patch);
-  }
-  async patchByFilter(filter, patch) {
-    const transformedFilter = this.transformFilter(filter);
-    const transformedPatch = this.transformPatch(patch);
-    const { matchedCount } = await this.baseRepository.update(transformedFilter, transformedPatch);
-    return matchedCount > 0;
-  }
-  async patchManyByFilter(filter, patch) {
-    const transformedFilter = this.transformFilter(filter);
-    const transformedPatch = this.transformPatch(patch);
-    const { matchedCount } = await this.baseRepository.updateMany(transformedFilter, transformedPatch);
-    return matchedCount;
-  }
-  async insert(entity) {
-    const transformed = this.transformer.transform(entity);
-    const insertedEntity = await this.baseRepository.insert(transformed);
-    return this.transformer.untransform(insertedEntity);
-  }
-  async insertMany(entities) {
-    const transformed = entities.map((entity) => this.transformer.transform(entity));
-    const insertedEntities = await this.baseRepository.insertMany(transformed);
-    return insertedEntities.map((insertedEntity) => this.transformer.untransform(insertedEntity));
-  }
-  async insertIfNotExists(entity) {
-    const transformed = this.transformer.transform(entity);
-    const insertedEntity = await this.baseRepository.insertIfNotExists(transformed);
-    return (0, import_type_guards.isUndefined)(insertedEntity) ? void 0 : this.transformer.untransform(insertedEntity);
-  }
-  async insertManyIfNotExists(entities) {
-    const transformed = entities.map((entity) => this.transformer.transform(entity));
-    const insertedEntities = await this.baseRepository.insertManyIfNotExists(transformed);
-    return insertedEntities.map((insertedEntity) => this.transformer.untransform(insertedEntity));
-  }
-  async insertIfNotExistsByFilter(query, entity) {
-    const transformedFilter = this.transformFilter(query);
-    const transformed = this.transformer.transform(entity);
-    const document = await this.baseRepository.insertIfNotExistsByFilter(transformedFilter, transformed);
-    return (0, import_type_guards.isUndefined)(document) ? void 0 : this.transformer.untransform(document);
-  }
-  async insertManyIfNotExistsByFilter(items) {
-    const transformedItems = items.map((item) => ({
-      filter: this.transformFilter(item.query),
-      entity: this.transformer.transform(item.entity)
-    }));
-    const insertedEntities = await this.baseRepository.insertManyIfNotExistsByFilter(transformedItems);
-    return insertedEntities.map((insertedEntity) => this.transformer.untransform(insertedEntity));
-  }
-  async update(entity, options) {
-    const transformed = this.transformer.transform(entity);
-    return this.baseRepository.replace(transformed, options);
-  }
-  async updateMany(entities, options) {
-    const transformed = entities.map((entity) => this.transformer.transform(entity));
-    return this.baseRepository.replaceMany(transformed, options);
-  }
-  async delete(entity) {
-    return this.deleteById(entity.id);
-  }
-  async deleteMany(entities) {
-    const ids = entities.map((entity) => entity.id);
-    return this.deleteManyByFilter({ id: { $in: ids } });
-  }
-  async deleteById(id) {
-    return this.deleteByFilter({ id });
-  }
-  async deleteManyById(ids) {
-    return this.deleteManyByFilter({ id: { $in: ids } });
-  }
-  async deleteByFilter(filter) {
-    const transformedFilter = this.transformFilter(filter);
-    return this.baseRepository.deleteByFilter(transformedFilter);
-  }
-  async deleteManyByFilter(filter) {
-    const transformedFilter = this.transformFilter(filter);
-    return this.baseRepository.deleteManyByFilter(transformedFilter);
-  }
-  transformFilter(filter) {
-    return (0, import_query_converter.convertQuery)(filter, this.transformerMappingMap);
-  }
-  transformPatch(patch) {
-    const transformedPatch = {};
-    for (const [property, value] of (0, import_object.objectEntries)(patch)) {
-      const mapping = this.transformerMappingMap.get(property);
-      if ((0, import_type_guards.isDefined)(mapping)) {
-        transformedPatch[mapping.key] = mapping.transform(value);
-      } else {
-        transformedPatch[property] = value;
-      }
-    }
-    return { $set: { ...transformedPatch } };
-  }
+export class MongoEntityRepository extends EntityRepository {
+    collection;
+    transformer;
+    logger;
+    indexes;
+    baseRepository;
+    transformerMappingMap;
+    constructor(collection, transformer, { logger, indexes }) {
+        super();
+        this.collection = collection;
+        this.transformer = transformer;
+        this.logger = logger.prefix(`${collection.collectionName}: `);
+        this.indexes = indexes?.map(normalizeIndex);
+        this.baseRepository = new MongoBaseRepository(collection);
+        this.transformerMappingMap = new Map(objectEntries(transformer.mapping ?? {}));
+    }
+    async [afterResolve]() {
+        await this.initialize();
+    }
+    async initialize() {
+        const indexes = this.indexes?.map((index) => ({ index, normalizedIndex: normalizeIndex(index) }));
+        if (isUndefined(indexes)) {
+            return;
+        }
+        const existingRawIndexes = await this.collection.indexes();
+        const existingIndexes = existingRawIndexes.map(normalizeIndex).filter((index) => index.name != '_id_');
+        const unwantedIndexes = existingIndexes.filter((existingIndex) => !indexes.some(({ normalizedIndex }) => equals(existingIndex, normalizedIndex, { deep: true, sortArray: false })));
+        const requiredIndexes = indexes.filter(({ normalizedIndex: wantedNormalizedIndex }) => !existingIndexes.some((index) => equals(wantedNormalizedIndex, index, { deep: true, sortArray: false })));
+        for (const unwantedIndex of unwantedIndexes) {
+            this.logger.warn(`dropping index ${unwantedIndex.name}`);
+            await this.collection.dropIndex(unwantedIndex.name);
+        }
+        if (requiredIndexes.length > 0) {
+            const indexexToCreate = requiredIndexes.map(({ index }) => index);
+            const indexNames = indexexToCreate.map((index) => index.name ?? _throw(new Error('index name missing')));
+            this.logger.warn(`creating indexes ${indexNames.join(', ')}`);
+            await this.baseRepository.createIndexes(indexexToCreate);
+        }
+    }
+    async load(id) {
+        return this.loadByFilter({ id });
+    }
+    async tryLoad(id) {
+        return this.tryLoadByFilter({ id });
+    }
+    async loadMany(ids, options) {
+        return this.loadManyByFilter({ id: { $in: ids } }, options);
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async *loadManyCursor(ids, options) {
+        yield* this.loadManyByFilterCursor({ id: { $in: ids } }, options);
+    }
+    async loadByFilter(filter, options) {
+        const transformedFilter = this.transformFilter(filter);
+        const entity = await this.baseRepository.loadByFilter(transformedFilter, convertOptions(options, this.transformerMappingMap));
+        return this.transformer.untransform(entity);
+    }
+    async tryLoadByFilter(filter, options) {
+        const transformedFilter = this.transformFilter(filter);
+        const entity = await this.baseRepository.tryLoadByFilter(transformedFilter, convertOptions(options, this.transformerMappingMap));
+        return entity == undefined ? undefined : this.transformer.untransform(entity);
+    }
+    async loadManyByFilter(filter, options) {
+        const transformedFilter = this.transformFilter(filter);
+        const entities = await this.baseRepository.loadManyByFilter(transformedFilter, convertOptions(options, this.transformerMappingMap));
+        return entities.map(this.transformer.untransform);
+    }
+    async *loadManyByFilterCursor(filter, options) {
+        const transformedFilter = this.transformFilter(filter);
+        for await (const entity of this.baseRepository.loadManyByFilterWithCursor(transformedFilter, convertOptions(options, this.transformerMappingMap))) {
+            yield this.transformer.untransform(entity);
+        }
+    }
+    async loadAll(options) {
+        const entities = await this.baseRepository.loadManyByFilter({}, convertOptions(options, this.transformerMappingMap));
+        return entities.map((entity) => this.transformer.untransform(entity));
+    }
+    async *loadAllCursor(options) {
+        for await (const entity of this.baseRepository.loadManyByFilterWithCursor({}, convertOptions(options, this.transformerMappingMap))) {
+            yield this.transformer.untransform(entity);
+        }
+    }
+    async loadAndDelete(id) {
+        return this.loadByFilterAndDelete({ id });
+    }
+    async tryLoadAndDelete(id) {
+        return this.tryLoadByFilterAndDelete({ id });
+    }
+    async loadByFilterAndDelete(filter, options) {
+        const transformedFilter = this.transformFilter(filter);
+        const entity = await this.baseRepository.loadByFilterAndDelete(transformedFilter, convertOptions(options, this.transformerMappingMap));
+        return this.transformer.untransform(entity);
+    }
+    async tryLoadByFilterAndDelete(filter, options) {
+        const transformedFilter = this.transformFilter(filter);
+        const entity = await this.baseRepository.tryLoadByFilterAndDelete(transformedFilter, convertOptions(options, this.transformerMappingMap));
+        return entity == undefined ? undefined : this.transformer.untransform(entity);
+    }
+    async loadAndPatch(id, patch, includePatch) {
+        return this.loadByFilterAndPatch({ id }, patch, includePatch);
+    }
+    async tryLoadAndPatch(id, patch, includePatch) {
+        return this.tryLoadByFilterAndPatch({ id }, patch, includePatch);
+    }
+    async loadByFilterAndPatch(filter, patch, includePatch, options) {
+        const transformedFilter = this.transformFilter(filter);
+        const update = this.transformPatch(patch);
+        const loadOptions = convertOptions(options, this.transformerMappingMap) ?? {};
+        const entity = await this.baseRepository.loadByFilterAndUpdate(transformedFilter, update, { ...loadOptions, returnDocument: includePatch ? 'after' : 'before' });
+        return this.transformer.untransform(entity);
+    }
+    async tryLoadByFilterAndPatch(filter, patch, includePatch, options) {
+        const transformedFilter = this.transformFilter(filter);
+        const update = this.transformPatch(patch);
+        const loadOptions = convertOptions(options, this.transformerMappingMap) ?? {};
+        const entity = await this.baseRepository.tryLoadByFilterAndUpdate(transformedFilter, update, { ...loadOptions, returnDocument: includePatch ? 'after' : 'before' });
+        return entity == undefined ? undefined : this.transformer.untransform(entity);
+    }
+    async has(id) {
+        return this.hasByFilter({ id });
+    }
+    async hasByFilter(filter) {
+        const transformedFilter = this.transformFilter(filter);
+        return this.baseRepository.hasByFilter(transformedFilter);
+    }
+    async hasMany(ids) {
+        const transformedFilter = this.transformFilter({ id: { $in: ids } });
+        return this.baseRepository.getIdsByFilter(transformedFilter);
+    }
+    async hasAll(ids) {
+        const transformedFilter = this.transformFilter({ id: { $in: ids } });
+        const count = await this.baseRepository.countByFilter(transformedFilter);
+        return count == ids.length;
+    }
+    async count(allowEstimation = false) {
+        if (allowEstimation) {
+            return this.baseRepository.countByFilterEstimated();
+        }
+        return this.baseRepository.countByFilter({});
+    }
+    async countByFilter(filter, _allowEstimation = false) {
+        const transformedFilter = this.transformFilter(filter);
+        return this.baseRepository.countByFilter(transformedFilter);
+    }
+    async patch(entity, patch) {
+        return this.patchByFilter({ _id: entity.id }, patch);
+    }
+    async patchMany(entities, patch) {
+        const ids = entities.map((entity) => entity.id);
+        return this.patchManyByFilter({ _id: { $in: ids } }, patch);
+    }
+    async patchByFilter(filter, patch) {
+        const transformedFilter = this.transformFilter(filter);
+        const transformedPatch = this.transformPatch(patch);
+        const { matchedCount } = await this.baseRepository.update(transformedFilter, transformedPatch);
+        return matchedCount > 0;
+    }
+    async patchManyByFilter(filter, patch) {
+        const transformedFilter = this.transformFilter(filter);
+        const transformedPatch = this.transformPatch(patch);
+        const { matchedCount } = await this.baseRepository.updateMany(transformedFilter, transformedPatch);
+        return matchedCount;
+    }
+    async insert(entity) {
+        const transformed = this.transformer.transform(entity);
+        const insertedEntity = await this.baseRepository.insert(transformed);
+        return this.transformer.untransform(insertedEntity);
+    }
+    async insertMany(entities) {
+        const transformed = entities.map((entity) => this.transformer.transform(entity));
+        const insertedEntities = await this.baseRepository.insertMany(transformed);
+        return insertedEntities.map((insertedEntity) => this.transformer.untransform(insertedEntity));
+    }
+    async insertIfNotExists(entity) {
+        const transformed = this.transformer.transform(entity);
+        const insertedEntity = await this.baseRepository.insertIfNotExists(transformed);
+        return isUndefined(insertedEntity) ? undefined : this.transformer.untransform(insertedEntity);
+    }
+    async insertManyIfNotExists(entities) {
+        const transformed = entities.map((entity) => this.transformer.transform(entity));
+        const insertedEntities = await this.baseRepository.insertManyIfNotExists(transformed);
+        return insertedEntities.map((insertedEntity) => this.transformer.untransform(insertedEntity));
+    }
+    async insertIfNotExistsByFilter(query, entity) {
+        const transformedFilter = this.transformFilter(query);
+        const transformed = this.transformer.transform(entity);
+        const document = await this.baseRepository.insertIfNotExistsByFilter(transformedFilter, transformed);
+        return isUndefined(document) ? undefined : this.transformer.untransform(document);
+    }
+    async insertManyIfNotExistsByFilter(items) {
+        const transformedItems = items.map((item) => ({
+            filter: this.transformFilter(item.query),
+            entity: this.transformer.transform(item.entity)
+        }));
+        const insertedEntities = await this.baseRepository.insertManyIfNotExistsByFilter(transformedItems);
+        return insertedEntities.map((insertedEntity) => this.transformer.untransform(insertedEntity));
+    }
+    async update(entity, options) {
+        const transformed = this.transformer.transform(entity);
+        return this.baseRepository.replace(transformed, options);
+    }
+    async updateMany(entities, options) {
+        const transformed = entities.map((entity) => this.transformer.transform(entity));
+        return this.baseRepository.replaceMany(transformed, options);
+    }
+    async delete(entity) {
+        return this.deleteById(entity.id);
+    }
+    async deleteMany(entities) {
+        const ids = entities.map((entity) => entity.id);
+        return this.deleteManyByFilter({ id: { $in: ids } });
+    }
+    async deleteById(id) {
+        return this.deleteByFilter({ id });
+    }
+    async deleteManyById(ids) {
+        return this.deleteManyByFilter({ id: { $in: ids } });
+    }
+    async deleteByFilter(filter) {
+        const transformedFilter = this.transformFilter(filter);
+        return this.baseRepository.deleteByFilter(transformedFilter);
+    }
+    async deleteManyByFilter(filter) {
+        const transformedFilter = this.transformFilter(filter);
+        return this.baseRepository.deleteManyByFilter(transformedFilter);
+    }
+    transformFilter(filter) {
+        return convertQuery(filter, this.transformerMappingMap);
+    }
+    transformPatch(patch) {
+        const transformedPatch = {};
+        for (const [property, value] of objectEntries(patch)) {
+            const mapping = this.transformerMappingMap.get(property);
+            if (isDefined(mapping)) {
+                transformedPatch[mapping.key] = mapping.transform(value);
+            }
+            else {
+                transformedPatch[property] = value;
+            }
+        }
+        return { $set: { ...transformedPatch } };
+    }
 }
 function normalizeIndex(index) {
-  const { name: providedName, unique, v, background, ns, ...indexRest } = index;
-  const name = providedName ?? (0, import_object.objectKeys)(index.key).join("_");
-  return (0, import_object.filterUndefinedFromRecord)({ name, unique: unique == true ? true : void 0, ...indexRest });
+    const { name: providedName, unique, v, background, ns, ...indexRest } = index; // eslint-disable-line @typescript-eslint/no-unused-vars
+    const name = providedName ?? objectKeys(index.key).join('_');
+    return filterUndefinedFromRecord({ name, unique: (unique == true) ? true : undefined, ...indexRest });
 }
 function convertOptions(options, mappingMap) {
-  if (options == void 0) {
-    return void 0;
-  }
-  const loadOptions = {
-    skip: options.skip,
-    limit: options.limit,
-    sort: options.sort?.map((item) => (0, import_query_converter.convertSort)(item, mappingMap))
-  };
-  return loadOptions;
+    if (options == undefined) {
+        return undefined;
+    }
+    const loadOptions = {
+        skip: options.skip,
+        limit: options.limit,
+        sort: options.sort?.map((item) => convertSort(item, mappingMap))
+    };
+    return loadOptions;
 }