@tstdl/base 0.86.0-beta1 → 0.86.0-beta11

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

@@ -1,263 +1,287 @@
-import { NotFoundError } from '../../error/not-found.error.js';
-import { objectKeys } from '../../utils/object/object.js';
-import { assertDefined, isNullOrUndefined } from '../../utils/type-guards.js';
-import { mongoDocumentFromMaybeNewEntity, toEntity, toMongoDocument, toMongoProjection, toNewEntity, toProjectedEntity } from './model/document.js';
-import { MongoBulk } from './mongo-bulk.js';
-import { replaceOneOperation, updateOneOperation } from './operations.js';
-export var ProjectionMode;
-(function (ProjectionMode) {
-    ProjectionMode[ProjectionMode["Include"] = 0] = "Include";
-    ProjectionMode[ProjectionMode["Exclude"] = 1] = "Exclude";
+"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_base_repository_exports = {};
+__export(mongo_base_repository_exports, {
+  MongoBaseRepository: () => MongoBaseRepository,
+  ProjectionMode: () => ProjectionMode
+});
+module.exports = __toCommonJS(mongo_base_repository_exports);
+var import_not_found_error = require("../../error/not-found.error.js");
+var import_object = require("../../utils/object/object.js");
+var import_type_guards = require("../../utils/type-guards.js");
+var import_document = require("./model/document.js");
+var import_mongo_bulk = require("./mongo-bulk.js");
+var import_operations = require("./operations.js");
+var ProjectionMode;
+(function(ProjectionMode2) {
+  ProjectionMode2[ProjectionMode2["Include"] = 0] = "Include";
+  ProjectionMode2[ProjectionMode2["Exclude"] = 1] = "Exclude";
 })(ProjectionMode || (ProjectionMode = {}));
-export class MongoBaseRepository {
-    collection;
-    constructor(collection) {
-        this.collection = collection;
-    }
-    async createIndexes(indexes) {
-        await this.collection.createIndexes(indexes);
-    }
-    bulk() {
-        return new MongoBulk(this.collection);
-    }
-    async insert(entity) {
-        const document = mongoDocumentFromMaybeNewEntity(entity);
-        await this.collection.insertOne(document); // eslint-disable-line @typescript-eslint/no-unsafe-argument
-        return toEntity(document);
-    }
-    async insertMany(entities) {
-        if (entities.length == 0) {
-            return [];
-        }
-        const bulk = this.bulk();
-        const documents = bulk.insertMany(entities);
-        await bulk.execute();
-        return documents;
-    }
-    async insertIfNotExists(entity) {
-        const filter = toNewEntity(entity);
-        return this.insertIfNotExistsByFilter(filter, entity);
-    }
-    async insertManyIfNotExists(entities) {
-        const items = entities.map((entity) => ({ filter: toNewEntity(entity), entity }));
-        return this.insertManyIfNotExistsByFilter(items);
-    }
-    async insertIfNotExistsByFilter(filter, entity) {
-        const document = mongoDocumentFromMaybeNewEntity(entity);
-        const result = await this.collection.updateOne(filter, { $setOnInsert: document }, { upsert: true });
-        if (result.upsertedCount == 0) {
-            return undefined;
-        }
-        return toEntity(document);
-    }
-    /**
-     *
-     * @param items
-     * @returns inserted entities - entities which are already in the database are not returned
-     */
-    async insertManyIfNotExistsByFilter(items) {
-        if (items.length == 0) {
-            return [];
-        }
-        const documents = items.map(({ filter, entity }) => ({ filter, document: mongoDocumentFromMaybeNewEntity(entity) }));
-        const documentOperations = documents.map(({ filter, document }) => ({ document, operation: updateOneOperation(filter, { $setOnInsert: document }, { upsert: true }) }));
-        const operations = documentOperations.map((o) => o.operation);
-        const result = await this.collection.bulkWrite(operations, { ordered: false });
-        assertDefined(result.upsertedIds);
-        const entities = objectKeys(result.upsertedIds).map((index) => toEntity(documentOperations[index].document));
-        return entities;
-    }
-    async load(id, options) {
-        const entity = await this.tryLoad(id, options);
-        return throwIfUndefinedElsePass(entity, this.collection.collectionName);
-    }
-    async tryLoad(id, options) {
-        return this.tryLoadByFilter({ _id: id }, options);
-    }
-    async loadAndUpdate(id, update, options) {
-        const entity = await this.tryLoadAndUpdate(id, update, options);
-        return throwIfUndefinedElsePass(entity, this.collection.collectionName);
-    }
-    async tryLoadAndUpdate(id, update, options) {
-        return this.tryLoadByFilterAndUpdate({ _id: id }, update, options);
-    }
-    async loadAndDelete(id, options) {
-        const entity = await this.tryLoadAndDelete(id, options);
-        return throwIfUndefinedElsePass(entity, this.collection.collectionName);
-    }
-    async loadByFilter(filter, options) {
-        const entity = await this.tryLoadByFilter(filter, options);
-        return throwIfUndefinedElsePass(entity, this.collection.collectionName);
-    }
-    async tryLoadByFilter(filter, options) {
-        const document = await this.collection.findOne(filter, options);
-        if (isNullOrUndefined(document)) {
-            return undefined;
-        }
-        return toEntity(document);
-    }
-    async loadProjectedByFilter(filter, mode, projection, options) {
-        const id = await this.tryLoadProjectedByFilter(filter, mode, projection, options);
-        return throwIfUndefinedElsePass(id, this.collection.collectionName);
-    }
-    async tryLoadProjectedByFilter(filter, mode, projection, options) {
-        const document = await this.collection.findOne(filter, { ...options, projection: toMongoProjection(mode, projection) });
-        if (isNullOrUndefined(document)) {
-            return undefined;
-        }
-        return toProjectedEntity(document);
-    }
-    async loadByFilterAndDelete(filter, options) {
-        const entity = await this.tryLoadByFilterAndDelete(filter, options);
-        return throwIfUndefinedElsePass(entity, this.collection.collectionName);
-    }
-    async tryLoadAndDelete(id, options) {
-        return this.tryLoadByFilterAndDelete({ _id: id }, options);
-    }
-    async tryLoadByFilterAndDelete(filter, options) {
-        const result = await this.collection.findOneAndDelete(filter, options);
-        if (result.value == undefined) {
-            return undefined;
-        }
-        return toEntity(result.value);
-    }
-    async loadByFilterAndUpdate(filter, update, options) {
-        const entity = await this.tryLoadByFilterAndUpdate(filter, update, options);
-        return throwIfUndefinedElsePass(entity, this.collection.collectionName);
-    }
-    async tryLoadByFilterAndUpdate(filter, update, options) {
-        const { value: document } = await this.collection.findOneAndUpdate(filter, update, options);
-        if (document == undefined) {
-            return undefined;
-        }
-        return toEntity(document);
-    }
-    async loadManyById(ids, options) {
-        const filter = { _id: { $in: ids } };
-        return this.loadManyByFilter(filter, options);
-    }
-    async loadManyByFilter(filter, options) {
-        const documents = await this.collection.find(filter, options).toArray();
-        return documents.map(toEntity);
-    }
-    // eslint-disable-next-line @typescript-eslint/require-await
-    loadManyByIdWithCursor(ids, options) {
-        const filter = { _id: { $in: ids } };
-        return this.loadManyByFilterWithCursor(filter, options);
-    }
-    async *loadManyByFilterWithCursor(filter, options) {
-        const cursor = this.collection.find(filter, options);
-        for await (const document of cursor) {
-            if (isNullOrUndefined(document)) {
-                continue;
-            }
-            yield toEntity(document);
-        }
-    }
-    async loadManyProjectedById(ids, mode, projection, options) {
-        const filter = { _id: { $in: ids } };
-        return this.loadManyProjectedByFilter(filter, mode, projection, options);
-    }
-    async loadManyProjectedByFilter(filter, mode, projection, options) {
-        const documents = await this.collection.find(filter, { ...options, projection: toMongoProjection(mode, projection) }).toArray();
-        return documents.map(toProjectedEntity);
-    }
-    async *loadManyProjectedByFilterWithCursor(filter, mode, projection, options) {
-        const cursor = this.collection.find(filter, { ...options, projection: toMongoProjection(mode, projection) });
-        for await (const document of cursor) {
-            if (isNullOrUndefined(document)) {
-                continue;
-            }
-            yield toProjectedEntity(document);
-        }
-    }
-    async deleteById(id) {
-        return this.deleteByFilter({ _id: id });
-    }
-    async deleteManyById(ids) {
-        if (ids.length == 0) {
-            return 0;
-        }
-        const filter = { _id: { $in: ids } };
-        return this.deleteManyByFilter(filter);
-    }
-    async deleteByFilter(filter) {
-        const { deletedCount } = await this.collection.deleteOne(filter);
-        return deletedCount == 1;
-    }
-    async deleteManyByFilter(filter) {
-        const { deletedCount } = await this.collection.deleteMany(filter);
-        return deletedCount;
-    }
-    async replace(entity, options = {}) {
-        return this.replaceByFilter({ _id: entity.id }, entity, options);
-    }
-    async replaceByFilter(filter, entity, options = {}) {
-        const document = toMongoDocument(entity);
-        const result = await this.collection.replaceOne(filter, document, options);
-        return (result.matchedCount + result.upsertedCount) > 0;
-    }
-    async replaceMany(entities, options) {
-        if (entities.length == 0) {
-            return 0;
-        }
-        const documents = entities.map(toMongoDocument);
-        const operations = documents.map((document) => replaceOneOperation({ _id: document._id }, document, options));
-        const result = await this.collection.bulkWrite(operations);
-        if (result.matchedCount + result.upsertedCount != entities.length) {
-            throw new NotFoundError(`${entities.length - (result.matchedCount + result.upsertedCount)} entities in ${this.collection.collectionName} not found`);
-        }
-        return (result.matchedCount + result.upsertedCount);
-    }
-    async update(filter, update, options = {}) {
-        const { matchedCount, modifiedCount } = await this.collection.updateOne(filter, update, options);
-        const updateResult = {
-            matchedCount,
-            modifiedCount
-        };
-        return updateResult;
-    }
-    async updateMany(filter, update, options = {}) {
-        const { matchedCount, modifiedCount } = await this.collection.updateMany(filter, update, options);
-        const updateResult = {
-            matchedCount,
-            modifiedCount
-        };
-        return updateResult;
-    }
-    async has(id) {
-        return this.hasByFilter({ _id: id });
-    }
-    async hasByFilter(filter) {
-        const count = await this.countByFilter(filter, { limit: 1 });
-        return count > 0;
-    }
-    async hasMany(ids) {
-        const filter = { _id: { $in: ids } };
-        return this.getIdsByFilter(filter);
-    }
-    async getIdsByFilter(filter) {
-        const result = await this.collection.distinct('_id', filter);
-        return result;
-    }
-    async hasAll(ids) {
-        const filter = { _id: { $in: ids } };
-        const count = await this.countByFilter(filter);
-        return count == ids.length;
-    }
-    async countByFilter(filter, { limit, skip } = {}) {
-        return this.collection.countDocuments(filter, { limit, skip });
-    }
-    async countByFilterEstimated() {
-        return this.collection.estimatedDocumentCount();
-    }
-    async drop() {
-        await this.collection.drop();
-    }
+class MongoBaseRepository {
+  collection;
+  constructor(collection) {
+    this.collection = collection;
+  }
+  async createIndexes(indexes) {
+    await this.collection.createIndexes(indexes);
+  }
+  bulk() {
+    return new import_mongo_bulk.MongoBulk(this.collection);
+  }
+  async insert(entity) {
+    const document = (0, import_document.mongoDocumentFromMaybeNewEntity)(entity);
+    await this.collection.insertOne(document);
+    return (0, import_document.toEntity)(document);
+  }
+  async insertMany(entities) {
+    if (entities.length == 0) {
+      return [];
+    }
+    const bulk = this.bulk();
+    const documents = bulk.insertMany(entities);
+    await bulk.execute();
+    return documents;
+  }
+  async insertIfNotExists(entity) {
+    const filter = (0, import_document.toNewEntity)(entity);
+    return this.insertIfNotExistsByFilter(filter, entity);
+  }
+  async insertManyIfNotExists(entities) {
+    const items = entities.map((entity) => ({ filter: (0, import_document.toNewEntity)(entity), entity }));
+    return this.insertManyIfNotExistsByFilter(items);
+  }
+  async insertIfNotExistsByFilter(filter, entity) {
+    const document = (0, import_document.mongoDocumentFromMaybeNewEntity)(entity);
+    const result = await this.collection.updateOne(filter, { $setOnInsert: document }, { upsert: true });
+    if (result.upsertedCount == 0) {
+      return void 0;
+    }
+    return (0, import_document.toEntity)(document);
+  }
+  /**
+   *
+   * @param items
+   * @returns inserted entities - entities which are already in the database are not returned
+   */
+  async insertManyIfNotExistsByFilter(items) {
+    if (items.length == 0) {
+      return [];
+    }
+    const documents = items.map(({ filter, entity }) => ({ filter, document: (0, import_document.mongoDocumentFromMaybeNewEntity)(entity) }));
+    const documentOperations = documents.map(({ filter, document }) => ({ document, operation: (0, import_operations.updateOneOperation)(filter, { $setOnInsert: document }, { upsert: true }) }));
+    const operations = documentOperations.map((o) => o.operation);
+    const result = await this.collection.bulkWrite(operations, { ordered: false });
+    (0, import_type_guards.assertDefined)(result.upsertedIds);
+    const entities = (0, import_object.objectKeys)(result.upsertedIds).map((index) => (0, import_document.toEntity)(documentOperations[index].document));
+    return entities;
+  }
+  async load(id, options) {
+    const entity = await this.tryLoad(id, options);
+    return throwIfUndefinedElsePass(entity, this.collection.collectionName);
+  }
+  async tryLoad(id, options) {
+    return this.tryLoadByFilter({ _id: id }, options);
+  }
+  async loadAndUpdate(id, update, options) {
+    const entity = await this.tryLoadAndUpdate(id, update, options);
+    return throwIfUndefinedElsePass(entity, this.collection.collectionName);
+  }
+  async tryLoadAndUpdate(id, update, options) {
+    return this.tryLoadByFilterAndUpdate({ _id: id }, update, options);
+  }
+  async loadAndDelete(id, options) {
+    const entity = await this.tryLoadAndDelete(id, options);
+    return throwIfUndefinedElsePass(entity, this.collection.collectionName);
+  }
+  async loadByFilter(filter, options) {
+    const entity = await this.tryLoadByFilter(filter, options);
+    return throwIfUndefinedElsePass(entity, this.collection.collectionName);
+  }
+  async tryLoadByFilter(filter, options) {
+    const document = await this.collection.findOne(filter, options);
+    if ((0, import_type_guards.isNullOrUndefined)(document)) {
+      return void 0;
+    }
+    return (0, import_document.toEntity)(document);
+  }
+  async loadProjectedByFilter(filter, mode, projection, options) {
+    const id = await this.tryLoadProjectedByFilter(filter, mode, projection, options);
+    return throwIfUndefinedElsePass(id, this.collection.collectionName);
+  }
+  async tryLoadProjectedByFilter(filter, mode, projection, options) {
+    const document = await this.collection.findOne(filter, { ...options, projection: (0, import_document.toMongoProjection)(mode, projection) });
+    if ((0, import_type_guards.isNullOrUndefined)(document)) {
+      return void 0;
+    }
+    return (0, import_document.toProjectedEntity)(document);
+  }
+  async loadByFilterAndDelete(filter, options) {
+    const entity = await this.tryLoadByFilterAndDelete(filter, options);
+    return throwIfUndefinedElsePass(entity, this.collection.collectionName);
+  }
+  async tryLoadAndDelete(id, options) {
+    return this.tryLoadByFilterAndDelete({ _id: id }, options);
+  }
+  async tryLoadByFilterAndDelete(filter, options) {
+    const result = await this.collection.findOneAndDelete(filter, options);
+    if (result.value == void 0) {
+      return void 0;
+    }
+    return (0, import_document.toEntity)(result.value);
+  }
+  async loadByFilterAndUpdate(filter, update, options) {
+    const entity = await this.tryLoadByFilterAndUpdate(filter, update, options);
+    return throwIfUndefinedElsePass(entity, this.collection.collectionName);
+  }
+  async tryLoadByFilterAndUpdate(filter, update, options) {
+    const { value: document } = await this.collection.findOneAndUpdate(filter, update, options);
+    if (document == void 0) {
+      return void 0;
+    }
+    return (0, import_document.toEntity)(document);
+  }
+  async loadManyById(ids, options) {
+    const filter = { _id: { $in: ids } };
+    return this.loadManyByFilter(filter, options);
+  }
+  async loadManyByFilter(filter, options) {
+    const documents = await this.collection.find(filter, options).toArray();
+    return documents.map(import_document.toEntity);
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  loadManyByIdWithCursor(ids, options) {
+    const filter = { _id: { $in: ids } };
+    return this.loadManyByFilterWithCursor(filter, options);
+  }
+  async *loadManyByFilterWithCursor(filter, options) {
+    const cursor = this.collection.find(filter, options);
+    for await (const document of cursor) {
+      if ((0, import_type_guards.isNullOrUndefined)(document)) {
+        continue;
+      }
+      yield (0, import_document.toEntity)(document);
+    }
+  }
+  async loadManyProjectedById(ids, mode, projection, options) {
+    const filter = { _id: { $in: ids } };
+    return this.loadManyProjectedByFilter(filter, mode, projection, options);
+  }
+  async loadManyProjectedByFilter(filter, mode, projection, options) {
+    const documents = await this.collection.find(filter, { ...options, projection: (0, import_document.toMongoProjection)(mode, projection) }).toArray();
+    return documents.map(import_document.toProjectedEntity);
+  }
+  async *loadManyProjectedByFilterWithCursor(filter, mode, projection, options) {
+    const cursor = this.collection.find(filter, { ...options, projection: (0, import_document.toMongoProjection)(mode, projection) });
+    for await (const document of cursor) {
+      if ((0, import_type_guards.isNullOrUndefined)(document)) {
+        continue;
+      }
+      yield (0, import_document.toProjectedEntity)(document);
+    }
+  }
+  async deleteById(id) {
+    return this.deleteByFilter({ _id: id });
+  }
+  async deleteManyById(ids) {
+    if (ids.length == 0) {
+      return 0;
+    }
+    const filter = { _id: { $in: ids } };
+    return this.deleteManyByFilter(filter);
+  }
+  async deleteByFilter(filter) {
+    const { deletedCount } = await this.collection.deleteOne(filter);
+    return deletedCount == 1;
+  }
+  async deleteManyByFilter(filter) {
+    const { deletedCount } = await this.collection.deleteMany(filter);
+    return deletedCount;
+  }
+  async replace(entity, options = {}) {
+    return this.replaceByFilter({ _id: entity.id }, entity, options);
+  }
+  async replaceByFilter(filter, entity, options = {}) {
+    const document = (0, import_document.toMongoDocument)(entity);
+    const result = await this.collection.replaceOne(filter, document, options);
+    return result.matchedCount + result.upsertedCount > 0;
+  }
+  async replaceMany(entities, options) {
+    if (entities.length == 0) {
+      return 0;
+    }
+    const documents = entities.map(import_document.toMongoDocument);
+    const operations = documents.map((document) => (0, import_operations.replaceOneOperation)({ _id: document._id }, document, options));
+    const result = await this.collection.bulkWrite(operations);
+    if (result.matchedCount + result.upsertedCount != entities.length) {
+      throw new import_not_found_error.NotFoundError(`${entities.length - (result.matchedCount + result.upsertedCount)} entities in ${this.collection.collectionName} not found`);
+    }
+    return result.matchedCount + result.upsertedCount;
+  }
+  async update(filter, update, options = {}) {
+    const { matchedCount, modifiedCount } = await this.collection.updateOne(filter, update, options);
+    const updateResult = {
+      matchedCount,
+      modifiedCount
+    };
+    return updateResult;
+  }
+  async updateMany(filter, update, options = {}) {
+    const { matchedCount, modifiedCount } = await this.collection.updateMany(filter, update, options);
+    const updateResult = {
+      matchedCount,
+      modifiedCount
+    };
+    return updateResult;
+  }
+  async has(id) {
+    return this.hasByFilter({ _id: id });
+  }
+  async hasByFilter(filter) {
+    const count = await this.countByFilter(filter, { limit: 1 });
+    return count > 0;
+  }
+  async hasMany(ids) {
+    const filter = { _id: { $in: ids } };
+    return this.getIdsByFilter(filter);
+  }
+  async getIdsByFilter(filter) {
+    const result = await this.collection.distinct("_id", filter);
+    return result;
+  }
+  async hasAll(ids) {
+    const filter = { _id: { $in: ids } };
+    const count = await this.countByFilter(filter);
+    return count == ids.length;
+  }
+  async countByFilter(filter, { limit, skip } = {}) {
+    return this.collection.countDocuments(filter, { limit, skip });
+  }
+  async countByFilterEstimated() {
+    return this.collection.estimatedDocumentCount();
+  }
+  async drop() {
+    await this.collection.drop();
+  }
 }
 function throwIfUndefinedElsePass(value, collectionName) {
-    if (value == undefined) {
-        throw new NotFoundError(`entity not found in ${collectionName}`);
-    }
-    return value;
+  if (value == void 0) {
+    throw new import_not_found_error.NotFoundError(`entity not found in ${collectionName}`);
+  }
+  return value;
 }