@tstdl/base 0.86.0-beta2 → 0.86.0-beta4

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

@@ -1,278 +1,304 @@
-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 };
+"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_database = require("../../database/index.js");
+var import_injector = require("../../injector/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 };
 }
-export const noopTransformerFunction = (item) => item;
-export const noopTransformer = {
-    transform: noopTransformerFunction,
-    untransform: noopTransformerFunction
+const noopTransformerFunction = (item) => item;
+const noopTransformer = {
+  transform: noopTransformerFunction,
+  untransform: noopTransformerFunction
 };
-export function getNoopTransformer() {
-    return noopTransformer;
+function getNoopTransformer() {
+  return noopTransformer;
 }
-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 } };
-    }
+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_injector.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 } };
+  }
 }
 function normalizeIndex(index) {
-    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 });
+  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 });
 }
 function convertOptions(options, mappingMap) {
-    if (options == undefined) {
-        return undefined;
-    }
-    const loadOptions = {
-        skip: options.skip,
-        limit: options.limit,
-        sort: options.sort?.map((item) => convertSort(item, mappingMap))
-    };
-    return loadOptions;
+  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;
 }