@tstdl/base 0.87.13 → 0.88.0-alpha1

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

@@ -1,287 +1,263 @@
-"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";
+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";
 })(ProjectionMode || (ProjectionMode = {}));
-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();
-  }
+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();
+    }
 }
 function throwIfUndefinedElsePass(value, collectionName) {
-  if (value == void 0) {
-    throw new import_not_found_error.NotFoundError(`entity not found in ${collectionName}`);
-  }
-  return value;
+    if (value == undefined) {
+        throw new NotFoundError(`entity not found in ${collectionName}`);
+    }
+    return value;
 }