@smartsoft001/mongo 2.76.0 → 2.81.0

package/index.cjs

@@ -0,0 +1,722 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+
+// packages/shared/mongo/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  MongoConfig: () => MongoConfig,
+  MongoItemRepository: () => MongoItemRepository,
+  MongoModule: () => MongoModule
+});
+module.exports = __toCommonJS(src_exports);
+
+// packages/shared/models/src/lib/symbols.ts
+var SYMBOL_MODEL = Symbol.for("smartsoft:model");
+var SYMBOL_FIELD = Symbol.for("smartsoft:field");
+
+// packages/shared/models/src/lib/decorators/model/model.decorator.ts
+var import_reflect_metadata = require("reflect-metadata");
+
+// packages/shared/models/src/lib/decorators/field/field.decorator.ts
+var import_reflect_metadata2 = require("reflect-metadata");
+
+// packages/shared/utils/src/lib/services/password/password.service.ts
+var md5_ = __toESM(require("md5"));
+
+// packages/shared/utils/src/lib/services/object/object.service.ts
+var import_flatted = require("flatted");
+var ObjectService = class {
+  /***
+   * Create object with data
+   * @param data {object} - data to set
+   * @param type {type} - new type
+   * @return - new type object
+   */
+  static createByType(data, type) {
+    if (!data)
+      return data;
+    try {
+      if (data instanceof type)
+        return data;
+    } catch (e) {
+      console.warn(e);
+    }
+    const result = new type();
+    Object.keys(data).forEach((key) => {
+      result[key] = data[key];
+    });
+    return result;
+  }
+  /***
+   * Remove object type from data
+   * @param obj {object} - object
+   * @return - object without type
+   */
+  static removeTypes(obj) {
+    if (!obj)
+      return obj;
+    const result = {};
+    Object.keys(obj).forEach((key) => {
+      if (obj[key] && obj[key].constructor && !(obj[key] instanceof Date)) {
+        let stringValue = "";
+        try {
+          stringValue = JSON.stringify(obj[key]);
+        } catch (e) {
+          console.warn("can't stringify without circular package");
+          stringValue = (0, import_flatted.stringify)(obj[key]);
+        }
+        result[key] = JSON.parse(stringValue);
+      } else {
+        result[key] = obj[key];
+      }
+    });
+    return result;
+  }
+};
+
+// packages/shared/utils/src/lib/services/guid/guid.service.ts
+var import_guid_typescript = require("guid-typescript");
+
+// packages/shared/utils/src/lib/services/array/array.service.ts
+var _ = __toESM(require("lodash"));
+
+// packages/shared/models/src/lib/utils.ts
+function getModelFieldKeys(type) {
+  if (!type["__fields"])
+    return [];
+  return Object.keys(type["__fields"]);
+}
+function getModelFieldOptions(instance, fieldKey) {
+  return Reflect.getMetadata(SYMBOL_FIELD, instance, fieldKey);
+}
+function getModelFieldsWithOptions(instance) {
+  const keys = getModelFieldKeys(instance.constructor);
+  return keys.map((item) => {
+    return {
+      key: item,
+      options: getModelFieldOptions(instance, item)
+    };
+  });
+}
+
+// packages/shared/domain-core/src/lib/repositories.ts
+var IUnitOfWork = class {
+};
+var IItemRepository = class {
+};
+var IAttachmentRepository = class {
+};
+
+// packages/shared/mongo/src/lib/mongo.config.ts
+var MongoConfig = class {
+};
+
+// packages/shared/mongo/src/lib/mongo.unitofwork.ts
+var import_common = require("@nestjs/common");
+var import_mongodb = require("mongodb");
+
+// packages/shared/mongo/src/lib/mongo.utils.ts
+function getMongoUrl(config) {
+  let url;
+  if (config.username && config.password)
+    url = `mongodb://${config.username}:${config.password}@${config.host}:${config.port}`;
+  else
+    url = `mongodb://${config.host}:${config.port}`;
+  url = url + "?authSource=" + config.database;
+  if (config.host.indexOf("ondigitalocean.com") > -1) {
+    url = url.replace("mongodb://", "mongodb+srv://");
+    url = url + "&tls=true";
+  }
+  return url;
+}
+
+// packages/shared/mongo/src/lib/mongo.unitofwork.ts
+var MongoUnitOfWork = class extends IUnitOfWork {
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  async scope(definition) {
+    const client = await import_mongodb.MongoClient.connect(this.getUrl());
+    const session = client.startSession();
+    const transactionOptions = {
+      readPreference: "primary",
+      readConcern: { level: "local" },
+      writeConcern: { w: "majority" }
+    };
+    let error = null;
+    try {
+      await session.withTransaction(async () => {
+        await definition({
+          session,
+          connection: client
+        });
+      }, transactionOptions);
+    } catch (e) {
+      error = e;
+    } finally {
+      await session.endSession();
+      await client.close();
+    }
+    if (error)
+      throw error;
+  }
+  getUrl() {
+    return getMongoUrl(this.config);
+  }
+};
+MongoUnitOfWork = __decorateClass([
+  (0, import_common.Injectable)()
+], MongoUnitOfWork);
+
+// packages/shared/mongo/src/lib/repositories/attachment.repository.ts
+var import_common2 = require("@nestjs/common");
+var import_mongodb2 = require("mongodb");
+var mongo = __toESM(require("mongodb"));
+var MongoAttachmentRepository = class extends IAttachmentRepository {
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  async upload(data, options) {
+    const client = await import_mongodb2.MongoClient.connect(this.getUrl());
+    return await new Promise((res, rej) => {
+      const db = client.db(this.config.database);
+      const bucket = new mongo.GridFSBucket(db, {
+        bucketName: this.config.collection
+      });
+      const writeStream = bucket.openUploadStreamWithId(
+        data.id,
+        data.fileName,
+        {
+          contentType: data.mimeType
+        }
+      );
+      if (options?.streamCallback)
+        options.streamCallback(writeStream);
+      data.stream.pipe(writeStream);
+      writeStream.on("error", (error) => {
+        rej(error);
+      });
+      writeStream.on("finish", () => {
+        res();
+      });
+    });
+  }
+  async getInfo(id) {
+    const client = await import_mongodb2.MongoClient.connect(this.getUrl());
+    const db = client.db(this.config.database);
+    const bucket = new mongo.GridFSBucket(db, {
+      bucketName: this.config.collection
+    });
+    const items = await bucket.find({
+      _id: id
+    }).toArray();
+    if (!items || items.length === 0)
+      return null;
+    return {
+      fileName: items[0].filename,
+      contentType: items[0].contentType,
+      length: items[0].length
+    };
+  }
+  async getStream(id, options) {
+    const client = await import_mongodb2.MongoClient.connect(this.getUrl());
+    const db = client.db(this.config.database);
+    const bucket = new mongo.GridFSBucket(db, {
+      bucketName: this.config.collection
+    });
+    return bucket.openDownloadStream(id, options);
+  }
+  async delete(id) {
+    const client = await import_mongodb2.MongoClient.connect(this.getUrl());
+    const db = client.db(this.config.database);
+    const bucket = new mongo.GridFSBucket(db, {
+      bucketName: this.config.collection
+    });
+    await bucket.delete(id);
+    await client.close();
+  }
+  getUrl() {
+    return getMongoUrl(this.config);
+  }
+};
+MongoAttachmentRepository = __decorateClass([
+  (0, import_common2.Injectable)()
+], MongoAttachmentRepository);
+
+// packages/shared/mongo/src/lib/repositories/item.repository.ts
+var import_common3 = require("@nestjs/common");
+var import_mongodb3 = require("mongodb");
+var import_rxjs = require("rxjs");
+var import_operators = require("rxjs/operators");
+var MongoItemRepository = class extends IItemRepository {
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  async create(item, user, repoOptions) {
+    await this.collectionContext(async (collection) => {
+      try {
+        await collection.insertOne(this.getModelToCreate(item, user), {
+          session: repoOptions?.transaction?.session
+        });
+        this.logChange("create", item, repoOptions, user, null).then();
+      } catch (errInsert) {
+        this.logChange("create", item, repoOptions, user, errInsert).then();
+        throw errInsert;
+      }
+    });
+  }
+  async clear(user, repoOptions) {
+    await this.collectionContext(async (collection) => {
+      try {
+        await collection.deleteMany(
+          {},
+          { session: repoOptions?.transaction?.session }
+        );
+        this.logChange("clear", null, repoOptions, user, null).then();
+      } catch (errClear) {
+        this.logChange("clear", null, repoOptions, user, errClear).then();
+        throw errClear;
+      }
+    });
+  }
+  async createMany(list, user, repoOptions) {
+    await this.collectionContext(async (collection) => {
+      try {
+        await collection.insertMany(
+          list.map((item) => this.getModelToCreate(item, user)),
+          { session: repoOptions?.transaction?.session }
+        );
+        this.logChange("createMany", null, repoOptions, user, null).then();
+      } catch (errInsert) {
+        this.logChange("createMany", null, repoOptions, user, errInsert).then();
+        throw errInsert;
+      }
+    });
+  }
+  async update(item, user, repoOptions) {
+    await this.collectionContext(async (collection) => {
+      try {
+        const info = await this.getInfo(item.id, collection);
+        await collection.replaceOne(
+          { _id: item.id },
+          this.getModelToUpdate(item, user, info),
+          { session: repoOptions?.transaction?.session }
+        );
+        this.logChange("update", item, repoOptions, user, null).then();
+      } catch (errInsert) {
+        this.logChange("update", item, repoOptions, user, errInsert).then();
+        throw errInsert;
+      }
+    });
+  }
+  async updatePartial(item, user, repoOptions) {
+    await this.collectionContext(async (collection) => {
+      try {
+        const info = await this.getInfo(item.id, collection);
+        await collection.updateOne(
+          { _id: item.id },
+          {
+            $set: this.getModelToUpdate(item, user, info)
+          },
+          { session: repoOptions?.transaction?.session }
+        );
+        this.logChange("updatePartial", item, repoOptions, user, null).then();
+      } catch (errUpdate) {
+        this.logChange(
+          "updatePartial",
+          item,
+          repoOptions,
+          user,
+          errUpdate
+        ).then();
+        throw errUpdate;
+      }
+    });
+  }
+  async updatePartialManyByCriteria(criteria, set, user, repoOptions) {
+    await this.collectionContext(async (collection) => {
+      try {
+        this.convertIdInCriteria(criteria);
+        await collection.updateMany(
+          criteria,
+          {
+            $set: {
+              ...set,
+              "__info.update": {
+                username: user?.username,
+                date: /* @__PURE__ */ new Date()
+              }
+            }
+          },
+          { session: repoOptions?.transaction?.session }
+        );
+        this.logChange(
+          "updatePartialManyByCriteria",
+          {
+            ...criteria,
+            set
+          },
+          repoOptions,
+          user,
+          null
+        ).then();
+      } catch (errUpdate) {
+        this.logChange(
+          "updatePartialManyByCriteria",
+          {
+            ...criteria,
+            set
+          },
+          repoOptions,
+          user,
+          errUpdate
+        ).then();
+        throw errUpdate;
+      }
+    });
+  }
+  updatePartialManyBySpecification(spec, set, user, repoOptions) {
+    return this.updatePartialManyByCriteria(
+      spec.criteria,
+      set,
+      user,
+      repoOptions
+    );
+  }
+  async delete(id, user, repoOptions) {
+    await this.collectionContext(async (collection) => {
+      try {
+        await collection.deleteOne(
+          { _id: id },
+          { session: repoOptions?.transaction?.session }
+        );
+        this.logChange(
+          "delete",
+          {
+            id
+          },
+          repoOptions,
+          user,
+          null
+        ).then();
+      } catch (errDelete) {
+        this.logChange(
+          "delete",
+          {
+            id
+          },
+          repoOptions,
+          user,
+          errDelete
+        ).then();
+        throw errDelete;
+      }
+    });
+  }
+  async getById(id, repoOptions) {
+    return await this.collectionContext(async (collection) => {
+      const item = await collection.findOne(
+        { _id: id },
+        {
+          session: repoOptions?.transaction?.session
+        }
+      );
+      return this.getModelToResult(item);
+    });
+  }
+  async getByCriteria(criteria, options = {}) {
+    return await this.collectionContext(async (collection) => {
+      this.convertIdInCriteria(criteria);
+      this.generateSearch(criteria);
+      const totalCount = await this.getCount(criteria, collection);
+      const aggregate = [];
+      if (criteria) {
+        aggregate.push({ $match: criteria });
+      }
+      if (options?.sort) {
+        aggregate.push({ $sort: options.sort });
+      }
+      if (options?.skip) {
+        aggregate.push({ $skip: options.skip });
+      }
+      if (options?.limit) {
+        aggregate.push({ $limit: options.limit });
+      }
+      if (options?.project) {
+        aggregate.push({ $project: options.project });
+      }
+      if (options?.min) {
+        aggregate.push({ $min: options.min });
+      }
+      if (options?.max) {
+        aggregate.push({ $max: options.max });
+      }
+      if (options?.group) {
+        aggregate.push({ $group: options.group });
+      }
+      const list = await collection.aggregate(aggregate, {
+        allowDiskUse: options?.allowDiskUse,
+        session: options?.session
+      }).toArray();
+      return {
+        data: list.map((item) => this.getModelToResult(item)),
+        totalCount
+      };
+    });
+  }
+  getBySpecification(spec, options = {}) {
+    return this.getByCriteria(spec.criteria, options);
+  }
+  async countByCriteria(criteria) {
+    return await this.collectionContext(async (collection) => {
+      this.convertIdInCriteria(criteria);
+      this.generateSearch(criteria);
+      return await this.getCount(criteria, collection);
+    });
+  }
+  countBySpecification(spec) {
+    return this.countByCriteria(spec.criteria);
+  }
+  changesByCriteria(criteria) {
+    let stream;
+    let client;
+    return new import_rxjs.Observable((observer) => {
+      (async () => {
+        try {
+          client = await import_mongodb3.MongoClient.connect(this.getUrl());
+          const db = client.db(this.config.database);
+          const collection = db.collection(this.config.collection);
+          const pipeline = criteria.id ? [
+            {
+              $match: {
+                "documentKey._id": criteria.id
+              }
+            }
+          ] : [];
+          stream = collection.watch(pipeline).on("change", (result) => {
+            observer.next({
+              id: result["documentKey"]["_id"],
+              type: this.mapChangeType(result.operationType),
+              data: result.operationType === "update" ? result["updateDescription"] : this.getModelToResult(result["fullDocument"])
+            });
+          });
+        } catch (err) {
+          observer.error(err);
+        }
+      })();
+    }).pipe(
+      (0, import_operators.finalize)(async () => {
+        console.log("Stop watch");
+        await stream.close();
+        await client.close();
+      }),
+      (0, import_operators.share)()
+    );
+  }
+  async getContext(handler) {
+    const client = await import_mongodb3.MongoClient.connect(this.getUrl());
+    const db = client.db(this.config.database);
+    try {
+      const result = await handler(db);
+      await client.close();
+      return result;
+    } catch (e) {
+      await client.close();
+      throw e;
+    }
+  }
+  async getCount(criteria, collection) {
+    this.convertIdInCriteria(criteria);
+    return await collection.countDocuments(criteria);
+  }
+  async getInfo(id, collection) {
+    const array = await collection.aggregate([{ $match: { _id: id } }, { $project: { __info: 1 } }]).toArray();
+    return array[0] ? array[0]["__info"] : {};
+  }
+  getModelToCreate(item, user) {
+    const result = ObjectService.removeTypes(item);
+    result["_id"] = result.id;
+    delete result.id;
+    result["__info"] = {
+      create: {
+        username: user ? user.username : null,
+        date: /* @__PURE__ */ new Date()
+      }
+    };
+    return result;
+  }
+  mapChangeType(dbType) {
+    const map = {
+      insert: "create",
+      update: "update",
+      delete: "delete"
+    };
+    return map[dbType];
+  }
+  getModelToUpdate(item, user, info) {
+    const result = ObjectService.removeTypes(item);
+    result["_id"] = result.id;
+    delete result.id;
+    result["__info"] = {
+      ...info,
+      update: {
+        username: user ? user.username : null,
+        date: /* @__PURE__ */ new Date()
+      }
+    };
+    return result;
+  }
+  getModelToResult(item) {
+    if (!item)
+      return null;
+    const result = ObjectService.removeTypes(item);
+    result["id"] = result._id;
+    delete result._id;
+    delete result["__info"];
+    return result;
+  }
+  getUrl() {
+    return getMongoUrl(this.config);
+  }
+  async logChange(type, item, options, user, error) {
+    const client = await import_mongodb3.MongoClient.connect(this.getUrl());
+    const db = client.db(this.config.database);
+    try {
+      await db.collection("changes").insertOne({
+        type,
+        collection: this.config.collection,
+        item,
+        options,
+        user,
+        error,
+        date: /* @__PURE__ */ new Date()
+      });
+    } catch (e) {
+      console.warn(e);
+    } finally {
+      await client.close();
+    }
+  }
+  generateSearch(criteria) {
+    if (!criteria["$search"])
+      return;
+    if (this.config.type) {
+      const modelFields = getModelFieldsWithOptions(
+        new this.config.type()
+      ).filter((i) => i.options.search);
+      if (modelFields.length) {
+        const searchArray = [];
+        modelFields.forEach((val) => {
+          const res = {};
+          res[val.key] = {
+            $regex: this.convertRegex(criteria["$search"]),
+            $options: "i"
+          };
+          searchArray.push(res);
+        });
+        if (!criteria["$or"])
+          criteria["$or"] = searchArray;
+        else if (criteria["$or"] && !criteria["$and"]) {
+          criteria["$and"] = [{ $or: criteria["$or"] }, { $or: searchArray }];
+          delete criteria["$or"];
+        } else if (criteria["$and"]) {
+          criteria["$and"] = [...criteria["$and"], { $or: searchArray }];
+        }
+        delete criteria["$search"];
+        return;
+      }
+    }
+    const customCriteria = {
+      $text: { $search: ' "' + this.convertRegex(criteria["$search"]) + '" ' }
+    };
+    delete criteria["$search"];
+    criteria = {
+      ...criteria,
+      ...customCriteria
+    };
+  }
+  convertIdInCriteria(criteria) {
+    if (criteria["id"]) {
+      criteria["_id"] = criteria["id"];
+      delete criteria["id"];
+    }
+  }
+  convertRegex(val) {
+    return val.toString().replace(/\*/g, "[*]");
+  }
+  async collectionContext(callback, repoOptions) {
+    const client = repoOptions?.transaction?.connection ? repoOptions.transaction.connection : await import_mongodb3.MongoClient.connect(this.getUrl());
+    const db = client.db(this.config.database);
+    let result;
+    try {
+      result = await callback(db.collection(this.config.collection));
+    } finally {
+      if (!repoOptions?.transaction)
+        await client.close();
+    }
+    return result;
+  }
+};
+MongoItemRepository = __decorateClass([
+  (0, import_common3.Injectable)()
+], MongoItemRepository);
+
+// packages/shared/mongo/src/lib/mongo.module.ts
+var MongoModule = class _MongoModule {
+  static forRoot(config) {
+    const providers = [
+      { provide: MongoConfig, useValue: config },
+      { provide: IItemRepository, useClass: MongoItemRepository },
+      { provide: IAttachmentRepository, useClass: MongoAttachmentRepository },
+      { provide: IUnitOfWork, useClass: MongoUnitOfWork }
+    ];
+    return {
+      module: _MongoModule,
+      providers,
+      exports: providers
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MongoConfig,
+  MongoItemRepository,
+  MongoModule
+});