@smartsoft001/trans-shell-nestjs 2.76.0 → 2.80.0

package/index.js

@@ -0,0 +1,3090 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// packages/trans/shell/nestjs/src/lib/nestjs.module.ts
+import { HttpModule } from "@nestjs/axios";
+import { Module as Module2 } from "@nestjs/common";
+import { JwtModule as JwtModule2 } from "@nestjs/jwt";
+import { PassportModule as PassportModule2 } from "@nestjs/passport";
+
+// packages/crud/shell/nestjs/src/lib/nestjs.module.ts
+import { Module } from "@nestjs/common";
+import { JwtModule } from "@nestjs/jwt";
+import { PassportModule } from "@nestjs/passport";
+
+// packages/crud/shell/app-services/src/lib/services/crud/crud.service.ts
+import { Injectable, Logger } from "@nestjs/common";
+import * as CombinedStream from "combined-stream";
+import { Guid as Guid2 } from "guid-typescript";
+import { Memoize } from "lodash-decorators";
+
+// 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
+import "reflect-metadata";
+
+// packages/shared/models/src/lib/decorators/field/field.decorator.ts
+import "reflect-metadata";
+
+// packages/shared/utils/src/lib/services/password/password.service.ts
+import * as md5_ from "md5";
+var md5 = md5_;
+var PasswordService = class _PasswordService {
+  /**
+   * Hash password text
+   * @param p {string} - text
+   * @return - hashed text
+   */
+  static hash(p) {
+    return Promise.resolve(md5(p));
+  }
+  /**
+   * Compare password text with hashed text
+   * @param p {string} - password text
+   * @param h {string} - hashed text
+   */
+  static async compare(p, h) {
+    const hp = await _PasswordService.hash(p);
+    return hp === h;
+  }
+};
+
+// packages/shared/utils/src/lib/services/object/object.service.ts
+import { stringify } from "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 = 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
+import { Guid } from "guid-typescript";
+var GuidService = class {
+  /***
+   * Create guid as string
+   */
+  static create() {
+    return Guid.raw();
+  }
+};
+
+// packages/shared/utils/src/lib/services/array/array.service.ts
+import * as _ from "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)
+    };
+  });
+}
+function isModel(instance) {
+  if (!instance || !instance.constructor)
+    return false;
+  return Reflect.hasMetadata(SYMBOL_MODEL, instance.constructor);
+}
+function getInvalidFields(instance, mode, permissions) {
+  const result = [];
+  getModelFieldsWithOptions(instance).forEach(({ key, options }) => {
+    let required = options.required;
+    if ((mode === "create" || mode === "update") && options[mode] && options[mode]?.constructor) {
+      required = options[mode].required;
+      if (required && permissions && options[mode].permissions) {
+        required = options[mode]?.permissions?.some(
+          (op) => permissions.some((p) => p === op)
+        );
+      }
+    }
+    if (required && (instance[key] === null || instance[key] === void 0 || instance[key] === ""))
+      result.push(key);
+  });
+  return result;
+}
+function castModel(instance, mode, permissions) {
+  if (!isModel(instance))
+    return;
+  const fieldsWithOptions = getModelFieldsWithOptions(instance);
+  Object.keys(instance).filter((key) => key !== "id").forEach((key) => {
+    const fieldWidthOptions = fieldsWithOptions.find((f) => f.key === key);
+    if (!fieldWidthOptions) {
+      delete instance[key];
+      return;
+    }
+    if ((mode === "create" || mode === "update") && (!fieldWidthOptions.options[mode] || permissions && fieldWidthOptions.options[mode].permissions && !fieldWidthOptions.options[mode]?.permissions?.some((op) => permissions.some((p) => op === p)))) {
+      delete instance[key];
+      return;
+    } else if (mode !== "create" && mode !== "update" && (!fieldWidthOptions.options.customs || !fieldWidthOptions.options.customs.some((c) => c.mode === mode))) {
+      delete instance[key];
+      return;
+    }
+  });
+}
+
+// packages/shared/domain-core/src/lib/errors.ts
+var DomainValidationError = class _DomainValidationError extends Error {
+  constructor(msg) {
+    super(msg);
+    this.type = _DomainValidationError;
+  }
+};
+var DomainForbiddenError = class _DomainForbiddenError extends Error {
+  constructor(msg) {
+    super(msg);
+    this.type = _DomainForbiddenError;
+  }
+};
+
+// packages/shared/domain-core/src/lib/repositories.ts
+var IUnitOfWork = class {
+};
+var IItemRepository = class {
+};
+var IAttachmentRepository = class {
+};
+
+// packages/crud/shell/app-services/src/lib/services/crud/crud.service.ts
+var CrudService = class {
+  constructor(permissionService, repository, attachmentRepository) {
+    this.permissionService = permissionService;
+    this.repository = repository;
+    this.attachmentRepository = attachmentRepository;
+    this._logger = new Logger(CrudService.name, { timestamp: true });
+  }
+  async create(data, user) {
+    data.id = Guid2.raw();
+    try {
+      this.permissionService.valid("create", user);
+      castModel(data, "create", user.permissions);
+      this.checkValidCreate(data, user.permissions);
+      if (data["password"]) {
+        data["password"] = await PasswordService.hash(data["password"]);
+      }
+      if (data["passwordConfirm"]) {
+        delete data["passwordConfirm"];
+      }
+      await this.repository.create(data, user);
+      return data.id;
+    } catch (e) {
+      this._logger.error(e);
+      throw e;
+    }
+  }
+  async createMany(data, user, options) {
+    data.forEach((item) => {
+      item.id = Guid2.raw();
+    });
+    try {
+      this.permissionService.valid("create", user);
+      data.forEach((item) => {
+        castModel(item, "create", user.permissions);
+        this.checkValidCreate(item, user.permissions);
+      });
+      if (options && options.mode === "replace") {
+        await this.repository.clear(user);
+      }
+      for (let index = 0; index < data.length; index++) {
+        const item = data[index];
+        if (item["password"]) {
+          item["password"] = await PasswordService.hash(item["password"]);
+        }
+        if (item["passwordConfirm"]) {
+          delete item["passwordConfirm"];
+        }
+      }
+      await this.repository.createMany(data, user);
+    } catch (e) {
+      this._logger.error(e);
+      throw e;
+    }
+    return data;
+  }
+  async readById(id, user) {
+    try {
+      this.permissionService.valid("read", user);
+      const result = await this.repository.getById(id);
+      delete result["password"];
+      return result;
+    } catch (e) {
+      this._logger.error(e);
+      throw e;
+    }
+  }
+  async read(criteria, options, user) {
+    try {
+      this.permissionService.valid("read", user);
+      const result = await this.repository.getByCriteria(criteria, options);
+      result.data.forEach((item) => delete item["password"]);
+      return result;
+    } catch (e) {
+      this._logger.error(e);
+      throw e;
+    }
+  }
+  readBySpec(spec, options, user) {
+    return this.read(spec.criteria, options, user);
+  }
+  async update(id, data, user) {
+    try {
+      data.id = id;
+      this.permissionService.valid("update", user);
+      castModel(data, "update", user.permissions);
+      this.checkValidUpdate(data, user.permissions);
+      if (data["password"]) {
+        data["password"] = await PasswordService.hash(data["password"]);
+      }
+      if (data["passwordConfirm"]) {
+        delete data["passwordConfirm"];
+      }
+      await this.repository.update(data, user);
+    } catch (e) {
+      this._logger.error(e);
+      throw e;
+    }
+  }
+  async updatePartial(id, data, user) {
+    try {
+      data.id = id;
+      this.permissionService.valid("update", user);
+      castModel(data, "update", user.permissions);
+      this.checkValidUpdatePartial(data, user.permissions);
+      if (data["password"]) {
+        data["password"] = await PasswordService.hash(data["password"]);
+      }
+      if (data["passwordConfirm"]) {
+        delete data["passwordConfirm"];
+      }
+      await this.repository.updatePartial(data, user);
+    } catch (e) {
+      this._logger.error(e);
+      throw e;
+    }
+  }
+  async delete(id, user) {
+    try {
+      this.permissionService.valid("delete", user);
+      await this.repository.delete(id, user);
+    } catch (e) {
+      this._logger.error(e);
+      throw e;
+    }
+  }
+  async uploadAttachment(data, options) {
+    if (!data.id) {
+      data.id = GuidService.create();
+    }
+    let oldId = null;
+    if (options?.start) {
+      oldId = data.id;
+      const stream = await this.attachmentRepository.getStream(data.id, {
+        start: 0,
+        end: options.start - 1
+      });
+      const combinedStream = CombinedStream.create();
+      combinedStream.append(stream);
+      combinedStream.append(data.stream);
+      data.stream = combinedStream;
+      data.id = GuidService.create();
+    }
+    this.attachmentRepository.upload(data, options);
+    if (oldId)
+      await this.attachmentRepository.delete(data.id);
+    return data.id;
+  }
+  getAttachmentInfo(id) {
+    return this.attachmentRepository.getInfo(id);
+  }
+  getAttachmentStream(id, options) {
+    return this.attachmentRepository.getStream(id, options);
+  }
+  async deleteAttachment(id) {
+    return this.attachmentRepository.delete(id);
+  }
+  changes(criteria) {
+    return this.repository.changesByCriteria(criteria);
+  }
+  checkValidCreate(item, permissions) {
+    const array = getInvalidFields(item, "create", permissions);
+    if (array.length) {
+      throw new DomainValidationError("Required fields: " + array.join(", "));
+    }
+  }
+  checkValidUpdate(item, permissions) {
+    const array = getInvalidFields(item, "update", permissions);
+    if (array.length) {
+      throw new DomainValidationError("Required fields: " + array.join(", "));
+    }
+  }
+  checkValidUpdatePartial(item, permissions) {
+    if (!isModel(item))
+      return;
+    const keys = Object.keys(item);
+    const array = getInvalidFields(item, "update", permissions).filter(
+      (invalidField) => keys.some((key) => key === invalidField)
+    );
+    if (array.length) {
+      throw new DomainValidationError("Required fields: " + array.join(", "));
+    }
+  }
+};
+__decorateClass([
+  Memoize()
+], CrudService.prototype, "getAttachmentInfo", 1);
+CrudService = __decorateClass([
+  Injectable()
+], CrudService);
+
+// packages/crud/shell/app-services/src/lib/services/index.ts
+var SERVICES = [CrudService];
+
+// packages/shared/mongo/src/lib/mongo.config.ts
+var MongoConfig = class {
+};
+
+// packages/shared/mongo/src/lib/mongo.unitofwork.ts
+import { Injectable as Injectable2 } from "@nestjs/common";
+import { MongoClient } from "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 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([
+  Injectable2()
+], MongoUnitOfWork);
+
+// packages/shared/mongo/src/lib/repositories/attachment.repository.ts
+import { Injectable as Injectable3 } from "@nestjs/common";
+import { MongoClient as MongoClient2 } from "mongodb";
+import * as mongo from "mongodb";
+var MongoAttachmentRepository = class extends IAttachmentRepository {
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  async upload(data, options) {
+    const client = await MongoClient2.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 MongoClient2.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 MongoClient2.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 MongoClient2.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([
+  Injectable3()
+], MongoAttachmentRepository);
+
+// packages/shared/mongo/src/lib/repositories/item.repository.ts
+import { Injectable as Injectable4 } from "@nestjs/common";
+import {
+  MongoClient as MongoClient3
+} from "mongodb";
+import { Observable } from "rxjs";
+import { finalize, share } from "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 Observable((observer) => {
+      (async () => {
+        try {
+          client = await MongoClient3.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(
+      finalize(async () => {
+        console.log("Stop watch");
+        await stream.close();
+        await client.close();
+      }),
+      share()
+    );
+  }
+  async getContext(handler) {
+    const client = await MongoClient3.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 MongoClient3.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 MongoClient3.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([
+  Injectable4()
+], 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
+    };
+  }
+};
+
+// packages/shared/nestjs/src/lib/shared.config.ts
+import { Injectable as Injectable5 } from "@nestjs/common";
+var SharedConfig = class {
+};
+SharedConfig = __decorateClass([
+  Injectable5()
+], SharedConfig);
+
+// packages/shared/nestjs/src/lib/auth/jwt.strategy.ts
+import { Injectable as Injectable6 } from "@nestjs/common";
+import { PassportStrategy } from "@nestjs/passport";
+import { ExtractJwt, Strategy } from "passport-jwt";
+var JwtStrategy = class extends PassportStrategy(Strategy) {
+  constructor(config) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ignoreExpiration: false,
+      secretOrKey: config.tokenConfig?.secretOrPrivateKey
+    });
+    this.config = config;
+  }
+  async validate(payload) {
+    return {
+      ...payload,
+      permissions: payload.permissions,
+      username: payload.sub
+    };
+  }
+};
+JwtStrategy = __decorateClass([
+  Injectable6()
+], JwtStrategy);
+
+// packages/shared/nestjs/src/lib/auth/permission.service.ts
+import { Injectable as Injectable7 } from "@nestjs/common";
+var PermissionService = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Validates if the user has the required permissions for a given type.
+   * @param {PermissionType} type - The type of permission to validate.
+   * @param {IUser} user - The user object containing permissions.
+   * @throws {DomainForbiddenError} If the user does not have the required permissions.
+   */
+  valid(type, user) {
+    if (!this.config.permissions)
+      return;
+    const typeConfig = this.config.permissions[type];
+    if (!typeConfig)
+      return;
+    if (!user.permissions)
+      throw new DomainForbiddenError(`Context forbidden`);
+    if (!typeConfig.some((tc) => user.permissions.some((up) => tc === up)))
+      throw new DomainForbiddenError(`Context forbidden`);
+  }
+};
+PermissionService = __decorateClass([
+  Injectable7()
+], PermissionService);
+
+// packages/shared/nestjs/src/lib/shared.module.ts
+var SharedModule = class _SharedModule {
+  /**
+   * Configures the module's core functionalities.
+   *
+   * @param {SharedConfig} config - An object containing the module's configuration.
+   * @returns {DynamicModule} A DynamicModule object with providers and exports.
+   */
+  static forFeature(config) {
+    return {
+      module: _SharedModule,
+      providers: [
+        { provide: SharedConfig, useValue: config },
+        JwtStrategy,
+        PermissionService
+      ],
+      exports: [
+        { provide: SharedConfig, useValue: config },
+        PermissionService,
+        JwtStrategy
+      ]
+    };
+  }
+  /**
+   * Extends the forFeature() configuration by adding database settings. Use in AppModule.
+   *
+   * @param {SharedConfig & { db: { host: string; port: number; database: string; username?: string; password?: string; }}} config - An extended SharedConfig object that includes additional database settings.
+   * @returns {DynamicModule} A DynamicModule object that imports and exports the forFeature() configuration.
+   */
+  static forRoot(config) {
+    return {
+      module: _SharedModule,
+      imports: [_SharedModule.forFeature(config)],
+      exports: [_SharedModule.forFeature(config)]
+    };
+  }
+};
+
+// packages/shared/nestjs/src/lib/filters/execution/exception.filter.ts
+import {
+  Catch,
+  HttpException,
+  HttpStatus,
+  Logger as Logger2
+} from "@nestjs/common";
+var AppExceptionFilter = class {
+  /**
+   * Method to catch and handle exceptions.
+   *
+   * @param {any} exception - The exception thrown.
+   * @param {ArgumentsHost} host - The arguments host.
+   */
+  catch(exception, host) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    let status = HttpStatus.INTERNAL_SERVER_ERROR;
+    let message = null;
+    if (exception instanceof HttpException) {
+      status = exception.getStatus();
+      message = exception["message"];
+    } else if (exception["type"] === DomainValidationError) {
+      status = HttpStatus.BAD_REQUEST;
+      message = exception["message"];
+    } else if (exception["type"] === DomainForbiddenError) {
+      status = HttpStatus.FORBIDDEN;
+      message = exception["message"];
+    } else {
+      status = HttpStatus.INTERNAL_SERVER_ERROR;
+      message = "Internal server error";
+    }
+    Logger2.error(
+      exception["stack"] || exception["message"] || exception,
+      AppExceptionFilter.name
+    );
+    const result = response.status(status);
+    if (message && result.json) {
+      result.json({
+        details: message
+      });
+    } else if (!message && result.json) {
+      result.json();
+    } else if (message && !result.json) {
+      result.send({
+        details: message
+      });
+    } else {
+      result.send();
+    }
+  }
+};
+AppExceptionFilter = __decorateClass([
+  Catch()
+], AppExceptionFilter);
+
+// packages/shared/nestjs/src/lib/decorators/user/user.decorator.ts
+import { createParamDecorator } from "@nestjs/common";
+var User = createParamDecorator((_3, context) => {
+  const [req] = context.getArgs();
+  return req.user;
+});
+
+// packages/crud/shell/nestjs/src/lib/controllers/crud/crud.controller.ts
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  NotFoundException,
+  Param,
+  Patch,
+  Post,
+  Put,
+  Query,
+  Req,
+  Res,
+  UseGuards
+} from "@nestjs/common";
+import * as Busboy from "busboy";
+import { Parser } from "json2csv";
+import * as _2 from "lodash";
+import * as moment from "moment-timezone";
+import * as XLSX from "xlsx";
+import { Readable } from "stream";
+
+// packages/crud/shell/nestjs/src/lib/controllers/crud/query-to-mongo.ts
+import * as querystring from "querystring";
+var iso8601 = /^\d{4}(-(0[1-9]|1[0-2])(-(0[1-9]|[12][0-9]|3[01]))?)?(T([01][0-9]|2[0-3]):[0-5]\d(:[0-5]\d(\.\d+)?)?(Z|[+-]\d{2}:\d{2}))?$/;
+function fieldsToMongo(fields) {
+  if (!fields)
+    return null;
+  const hash = {};
+  fields.split(",").forEach(function(field) {
+    hash[field.trim()] = 1;
+  });
+  return hash;
+}
+function convertRegex(val) {
+  return val.toString().replace(/\*/g, "[*]");
+}
+function omitFieldsToMongo(omitFields) {
+  if (!omitFields)
+    return null;
+  const hash = {};
+  omitFields.split(",").forEach(function(omitField) {
+    hash[omitField.trim()] = 0;
+  });
+  return hash;
+}
+function sortToMongo(sort) {
+  if (!sort)
+    return null;
+  const hash = {};
+  let c;
+  sort.split(",").forEach(function(field) {
+    c = field.charAt(0);
+    if (c === "-")
+      field = field.substr(1);
+    hash[field.trim()] = c === "-" ? -1 : 1;
+  });
+  return hash;
+}
+function typedValue(value) {
+  if (value[0] === "!")
+    value = value.substr(1);
+  const regex = value.match(/^\/(.*)\/(i?)$/);
+  const quotedString = value.match(/(["'])(?:\\\1|.)*?\1/);
+  if (regex) {
+    return new RegExp(regex[1], regex[2]);
+  } else if (quotedString) {
+    return quotedString[0].substr(1, quotedString[0].length - 2);
+  } else if (value === "true") {
+    return true;
+  } else if (value === "false") {
+    return false;
+  } else if (iso8601.test(value) && value.length !== 4 && value.length !== 10) {
+    return new Date(value);
+  } else if (!isNaN(Number(value))) {
+    return Number(value);
+  }
+  return value;
+}
+function typedValues(svalue) {
+  const commaSplit = /("[^"]*")|('[^']*')|(\/[^/]*\/i?)|([^,]+)/g;
+  const values = [];
+  svalue.match(commaSplit).forEach(function(value) {
+    values.push(typedValue(value));
+  });
+  return values;
+}
+function comparisonToMongo(key, value) {
+  const join = value === "" ? key : key.concat("=", value);
+  const parts = join.match(/^(!?[^><~!=:]+)(?:=?([><]=?|~?=|!?=|:.+=)(.+))?$/);
+  let op;
+  const hash = {};
+  if (!parts)
+    return null;
+  key = parts[1];
+  op = parts[2];
+  if (!op) {
+    if (key[0] !== "!")
+      value = { $exists: true };
+    else {
+      key = key.substr(1);
+      value = { $exists: false };
+    }
+  } else if (op === "=" && parts[3] === "!") {
+    value = { $exists: false };
+  } else if (op === "=" || op === "!=") {
+    if (op === "=" && parts[3][0] === "!")
+      op = "!=";
+    const array = typedValues(parts[3]);
+    if (array.length > 1) {
+      value = {};
+      op = op === "=" ? "$in" : "$nin";
+      value[op] = array;
+    } else if (op === "!=") {
+      value = array[0] instanceof RegExp ? { $not: array[0] } : { $ne: array[0] };
+    } else if (array[0][0] === "!") {
+      const sValue = array[0].substr(1);
+      const regex = sValue.match(/^\/(.*)\/(i?)$/);
+      value = regex ? { $not: new RegExp(regex[1], regex[2]) } : { $ne: sValue };
+    } else {
+      value = array[0];
+    }
+  } else if (op[0] === ":" && op[op.length - 1] === "=") {
+    op = "$" + op.substr(1, op.length - 2);
+    const array = [];
+    parts[3].split(",").forEach(function(value2) {
+      array.push(typedValue(value2));
+    });
+    value = {};
+    value[op] = array.length === 1 ? array[0] : array;
+  } else {
+    value = typedValue(parts[3]);
+    if (op === ">")
+      value = { $gt: value };
+    else if (op === ">=")
+      value = { $gte: value };
+    else if (op === "<")
+      value = { $lt: value };
+    else if (op === "<=")
+      value = { $lte: value };
+    else if (op === "~=")
+      value = {
+        $regex: value ? convertRegex(value) : "",
+        $options: "i"
+      };
+  }
+  hash.key = key;
+  hash.value = value;
+  return hash;
+}
+function hasOrdinalKeys(obj) {
+  let c = 0;
+  for (const key in obj) {
+    if (Number(key) !== c++)
+      return false;
+  }
+  return true;
+}
+function queryCriteriaToMongo(query, options = null) {
+  const hash = {};
+  let deep, p;
+  options = options || {};
+  for (const key in query) {
+    if (Object.prototype.hasOwnProperty.call(query, key) && (!options.ignore || options.ignore.indexOf(key) === -1)) {
+      deep = typeof query[key] === "object" && !hasOrdinalKeys(query[key]);
+      if (deep) {
+        p = {
+          key,
+          value: queryCriteriaToMongo(query[key])
+        };
+      } else {
+        p = comparisonToMongo(key, query[key]);
+      }
+      if (p) {
+        if (!hash[p.key]) {
+          hash[p.key] = p.value;
+        } else if (typeof p.value === "string") {
+          hash[p.key] = Object.assign(hash[p.key], {
+            $eq: p.value
+          });
+        } else {
+          hash[p.key] = Object.assign(hash[p.key], p.value);
+        }
+      }
+    }
+  }
+  return hash;
+}
+function queryOptionsToMongo(query, options) {
+  const hash = {}, fields = fieldsToMongo(query[options.keywords.fields]), omitFields = omitFieldsToMongo(query[options.keywords.omit]), sort = sortToMongo(query[options.keywords.sort]), maxLimit = options.maxLimit || 9007199254740992;
+  let limit = options.maxLimit || 0;
+  if (fields)
+    hash.fields = fields;
+  if (omitFields)
+    hash.fields = omitFields;
+  if (sort)
+    hash.sort = sort;
+  if (query[options.keywords.offset])
+    hash.skip = Number(query[options.keywords.offset]);
+  if (query[options.keywords.limit])
+    limit = Math.min(Number(query[options.keywords.limit]), maxLimit);
+  if (limit) {
+    hash.limit = limit;
+  } else if (options.maxLimit) {
+    hash.limit = maxLimit;
+  }
+  return hash;
+}
+function q2m(query = null, options = null) {
+  query = query || {};
+  options = options || {};
+  options.keywords = options.keywords || {};
+  const defaultKeywords = {
+    fields: "fields",
+    omit: "omit",
+    sort: "sort",
+    offset: "offset",
+    limit: "limit"
+  };
+  options.keywords = Object.assign(defaultKeywords, options.keywords);
+  const ignoreKeywords = [
+    options.keywords.fields,
+    options.keywords.omit,
+    options.keywords.sort,
+    options.keywords.offset,
+    options.keywords.limit
+  ];
+  if (!options.ignore) {
+    options.ignore = [];
+  } else {
+    options.ignore = typeof options.ignore === "string" ? [options.ignore] : options.ignore;
+  }
+  options.ignore = options.ignore.concat(ignoreKeywords);
+  if (!options.parser)
+    options.parser = querystring;
+  if (typeof query === "string")
+    query = options.parser.parse(query);
+  return {
+    criteria: queryCriteriaToMongo(query, options),
+    options: queryOptionsToMongo(query, options),
+    links: function(url, totalCount) {
+      const offset = this.options.skip || 0;
+      const limit = Math.min(this.options.limit || 0, totalCount);
+      const links = {};
+      const last = {};
+      if (!limit)
+        return null;
+      options = options || {};
+      if (offset > 0) {
+        query[options.keywords.offset] = Math.max(offset - limit, 0);
+        links["prev"] = url + "?" + options.parser.stringify(query);
+        query[options.keywords.offset] = 0;
+        links["first"] = url + "?" + options.parser.stringify(query);
+      }
+      if (offset + limit < totalCount) {
+        last.pages = Math.ceil(totalCount / limit);
+        last.offset = (last.pages - 1) * limit;
+        query[options.keywords.offset] = Math.min(offset + limit, last.offset);
+        links["next"] = url + "?" + options.parser.stringify(query);
+        query[options.keywords.offset] = last.offset;
+        links["last"] = url + "?" + options.parser.stringify(query);
+      }
+      return links;
+    }
+  };
+}
+
+// packages/crud/shell/nestjs/src/lib/guards/auth/auth.guard.ts
+import { Injectable as Injectable8, UnauthorizedException, Logger as Logger3 } from "@nestjs/common";
+import { AuthGuard } from "@nestjs/passport";
+var AuthJwtGuard = class extends AuthGuard("jwt") {
+  constructor() {
+    super(...arguments);
+    this.logger = new Logger3(AuthJwtGuard.name, { timestamp: true });
+  }
+  handleRequest(err, user, info) {
+    if (err || !user) {
+      this.logger.warn(JSON.stringify(info));
+      throw err || new UnauthorizedException();
+    }
+    return user;
+  }
+};
+AuthJwtGuard = __decorateClass([
+  Injectable8()
+], AuthJwtGuard);
+var AuthOrAnonymousJwtGuard = class extends AuthGuard("jwt") {
+  handleRequest(err, user, info) {
+    return user;
+  }
+};
+AuthOrAnonymousJwtGuard = __decorateClass([
+  Injectable8()
+], AuthOrAnonymousJwtGuard);
+
+// packages/crud/shell/nestjs/src/lib/controllers/crud/crud.controller.ts
+var CrudController = class {
+  constructor(service) {
+    this.service = service;
+  }
+  static getLink(req) {
+    return req.protocol + "://" + req.headers.host + req.url;
+  }
+  async create(data, user, res) {
+    const id = await this.service.create(data, user);
+    res.set("Location", CrudController.getLink(res.req) + "/" + id);
+    return res.send({
+      id
+    });
+  }
+  async createMany(data, user, res, mode) {
+    const result = await this.service.createMany(data, user, { mode });
+    return res.send(result);
+  }
+  async readById(params, user) {
+    const result = await this.service.readById(params.id, user);
+    if (!result) {
+      throw new NotFoundException("Invalid id");
+    }
+    return result;
+  }
+  async read(user, req, res) {
+    const object = this.getQueryObject(req.query);
+    const { data, totalCount } = await this.service.read(
+      object.criteria,
+      {
+        ...object.options,
+        allowDiskUse: req.headers["content-type"] === "text/csv" || req.headers["content-type"] === "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+      },
+      user
+    );
+    if (req.headers["content-type"] === "text/csv") {
+      res.set({
+        "Content-Type": "text/csv"
+      });
+      res.send(this.parseToCsv(data));
+    }
+    if (req.headers["content-type"] === "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") {
+      res.set({
+        "Content-Type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+      });
+      res.send(this.parseToXlsx(data));
+    }
+    res.send({
+      data,
+      totalCount,
+      links: object.links(
+        CrudController.getLink(req).split("?")[0],
+        totalCount
+      )
+    });
+  }
+  async update(params, data, user) {
+    await this.service.update(params.id, data, user);
+  }
+  async updatePartial(params, data, user) {
+    await this.service.updatePartial(params.id, data, user);
+  }
+  async delete(params, user) {
+    await this.service.delete(params.id, user);
+  }
+  uploadAttachment(request, response) {
+    const busboy = new Busboy({
+      headers: request.headers
+    });
+    const id = GuidService.create();
+    const readable = new Readable();
+    readable._read = () => {
+    };
+    let fileName, encoding, mimeType;
+    busboy.on(
+      "file",
+      (field, file, resultFileName, resultEncoding, resultMimeType) => {
+        fileName = resultFileName;
+        encoding = resultEncoding;
+        mimeType = resultMimeType;
+        this.service.uploadAttachment({
+          id,
+          stream: readable,
+          fileName,
+          encoding,
+          mimeType
+        });
+        file.on("data", (data) => {
+          readable.push(data);
+        });
+      }
+    );
+    busboy.on("finish", function() {
+      readable.push(null);
+      response.set("Location", CrudController.getLink(response.req) + "/" + id);
+      response.json({
+        id,
+        fileName,
+        contentType: mimeType,
+        length: readable.readableLength
+      });
+      response.end();
+    });
+    return request.pipe(busboy);
+  }
+  async downloadAttachment(id, request, response) {
+    const fileInfo = await this.service.getAttachmentInfo(id);
+    if (request.headers.range) {
+      const range = request.headers.range.substr(6).split("-");
+      const start = parseInt(range[0], 10);
+      const end = parseInt(range[1], 10) || null;
+      const readstream = await this.service.getAttachmentStream(id, {
+        start,
+        end
+      });
+      response.status(206);
+      response.set({
+        "Accept-Ranges": "bytes",
+        "Content-Type": fileInfo.contentType,
+        "Content-Range": `bytes ${start}-${end ? end : fileInfo.length - 1}/${fileInfo.length}`,
+        "Content-Length": (end ? end : fileInfo.length) - start,
+        "Content-Disposition": `attachment; filename="${encodeURI(fileInfo.fileName)}"`
+      });
+      response.on("close", () => {
+        readstream.destroy();
+      });
+      readstream.pipe(response);
+    } else {
+      const readstream = await this.service.getAttachmentStream(id);
+      response.on("close", () => {
+        readstream.destroy();
+      });
+      response.status(200);
+      response.set({
+        "Accept-Range": "bytes",
+        "Content-Type": fileInfo.contentType,
+        "Content-Length": fileInfo.length,
+        "Content-Disposition": `attachment; filename="${encodeURI(fileInfo.fileName)}"`
+      });
+      readstream.pipe(response);
+    }
+  }
+  async deleteAttachment(id) {
+    await this.service.deleteAttachment(id);
+  }
+  getQueryObject(queryObject) {
+    let q = "";
+    Object.keys(queryObject).forEach((key) => {
+      q += `&${key}=${queryObject[key]}`;
+    });
+    const result = q2m(q);
+    return result;
+  }
+  parseToXlsx(data) {
+    if (!data || !data.length) {
+      return "";
+    }
+    const { res } = this.getDataWithFields(data);
+    const ws = XLSX.utils.json_to_sheet(res);
+    const wb = XLSX.utils.book_new();
+    XLSX.utils.book_append_sheet(wb, ws, "data");
+    return XLSX.write(wb, { bookType: "xlsx", type: "buffer" });
+  }
+  parseToCsv(data) {
+    if (!data || !data.length) {
+      return "";
+    }
+    const { res, fields } = this.getDataWithFields(data);
+    return new Parser(fields).parse(data);
+  }
+  getDataWithFields(data) {
+    const fields = [];
+    const execute = (item, baseKey, baseItem) => {
+      Object.keys(item).forEach((key) => {
+        if (item[key] && typeof item[key] === "string") {
+          item[key] = item[key].replace(/<[^>]*>?/gm, "");
+        }
+        if (item[key] && item[key] instanceof Date) {
+          item[key] = moment(item[key]).tz("Europe/Warsaw").format("YYYY-MM-DD HH:mm:ss");
+        }
+        const val = item[key];
+        if (_2.isArray(val)) {
+          return;
+        } else if (_2.isObject(val) && Object.keys(val).length) {
+          execute(val, baseKey + key + "_", baseItem);
+        } else if (baseKey) {
+          baseItem[baseKey + key] = val;
+          if (!fields.some((f) => f === baseKey + key))
+            fields.push(baseKey + key);
+        } else {
+          if (!fields.some((f) => f === key))
+            fields.push(key);
+        }
+      });
+    };
+    data.forEach((item) => {
+      execute(item, "", item);
+    });
+    data.forEach((item) => {
+      Object.keys(item).forEach((key) => {
+        if (!fields.some((f) => f === key)) {
+          delete item[key];
+        }
+      });
+    });
+    return { res: data, fields };
+  }
+};
+__decorateClass([
+  UseGuards(AuthJwtGuard),
+  Post(),
+  HttpCode(200),
+  __decorateParam(0, Body()),
+  __decorateParam(1, User()),
+  __decorateParam(2, Res())
+], CrudController.prototype, "create", 1);
+__decorateClass([
+  UseGuards(AuthJwtGuard),
+  Post("bulk"),
+  __decorateParam(0, Body()),
+  __decorateParam(1, User()),
+  __decorateParam(2, Res()),
+  __decorateParam(3, Query("mode"))
+], CrudController.prototype, "createMany", 1);
+__decorateClass([
+  UseGuards(AuthOrAnonymousJwtGuard),
+  Get(":id"),
+  __decorateParam(0, Param()),
+  __decorateParam(1, User())
+], CrudController.prototype, "readById", 1);
+__decorateClass([
+  UseGuards(AuthOrAnonymousJwtGuard),
+  Get(),
+  __decorateParam(0, User()),
+  __decorateParam(1, Req()),
+  __decorateParam(2, Res())
+], CrudController.prototype, "read", 1);
+__decorateClass([
+  UseGuards(AuthJwtGuard),
+  Put(":id"),
+  __decorateParam(0, Param()),
+  __decorateParam(1, Body()),
+  __decorateParam(2, User())
+], CrudController.prototype, "update", 1);
+__decorateClass([
+  UseGuards(AuthJwtGuard),
+  Patch(":id"),
+  __decorateParam(0, Param()),
+  __decorateParam(1, Body()),
+  __decorateParam(2, User())
+], CrudController.prototype, "updatePartial", 1);
+__decorateClass([
+  UseGuards(AuthJwtGuard),
+  Delete(":id"),
+  __decorateParam(0, Param()),
+  __decorateParam(1, User())
+], CrudController.prototype, "delete", 1);
+__decorateClass([
+  Post("attachments"),
+  __decorateParam(0, Req()),
+  __decorateParam(1, Res())
+], CrudController.prototype, "uploadAttachment", 1);
+__decorateClass([
+  Get("attachments/:id"),
+  __decorateParam(0, Param("id")),
+  __decorateParam(1, Req()),
+  __decorateParam(2, Res())
+], CrudController.prototype, "downloadAttachment", 1);
+__decorateClass([
+  Delete("attachments/:id"),
+  __decorateParam(0, Param("id"))
+], CrudController.prototype, "deleteAttachment", 1);
+CrudController = __decorateClass([
+  Controller("")
+], CrudController);
+
+// packages/crud/shell/nestjs/src/lib/controllers/index.ts
+var CONTROLLERS = [CrudController];
+
+// packages/crud/shell/nestjs/src/lib/gateways/crud/crud.gateway.ts
+import {
+  ConnectedSocket,
+  MessageBody,
+  SubscribeMessage,
+  WebSocketGateway
+} from "@nestjs/websockets";
+import { Observable as Observable2 } from "rxjs";
+var CrudGateway = class {
+  constructor(service) {
+    this.service = service;
+  }
+  handleFilter(data, client) {
+    const event = "changes";
+    return new Observable2((observer) => {
+      this.clearSubscription(client);
+      this._clientsSubscriptions.set(
+        client.id,
+        this.service.changes(data).subscribe(
+          (res) => {
+            observer.next({ event, data: res });
+          },
+          (error) => observer.error(error)
+        )
+      );
+    });
+  }
+  afterInit(server) {
+    this._clientsSubscriptions = /* @__PURE__ */ new Map();
+    console.log("CrudGateway Init");
+  }
+  handleDisconnect(client) {
+    this.clearSubscription(client);
+    console.log(`Client disconnected: ${client.id}`);
+  }
+  clearSubscription(client) {
+    if (this._clientsSubscriptions.has(client.id)) {
+      this._clientsSubscriptions.get(client.id).unsubscribe();
+      this._clientsSubscriptions.delete(client.id);
+    }
+  }
+  handleConnection(client, ...args) {
+    console.log(`Client connected: ${client.id}`);
+  }
+};
+__decorateClass([
+  SubscribeMessage("changes"),
+  __decorateParam(0, MessageBody()),
+  __decorateParam(1, ConnectedSocket())
+], CrudGateway.prototype, "handleFilter", 1);
+CrudGateway = __decorateClass([
+  WebSocketGateway({
+    transports: ["websocket"],
+    path: "/" + process.env.URL_PREFIX + "/_socket",
+    namespace: "/" + process.env.URL_PREFIX
+  })
+], CrudGateway);
+
+// packages/crud/shell/nestjs/src/lib/gateways/index.ts
+var GATEWAYS = [CrudGateway];
+
+// packages/crud/shell/nestjs/src/lib/nestjs.module.ts
+var CrudShellNestjsModule = class {
+  static forRoot(options) {
+    return {
+      module: CrudShellNestjsModule,
+      controllers: options.restApi ? CONTROLLERS : [],
+      providers: [
+        ...SERVICES,
+        ...options.socket ? GATEWAYS : [],
+        AuthJwtGuard
+      ],
+      imports: [
+        ...options.restApi && options.tokenConfig.secretOrPrivateKey ? [
+          PassportModule.register({
+            defaultStrategy: "jwt",
+            session: false
+          }),
+          JwtModule.register({
+            secret: options.tokenConfig.secretOrPrivateKey,
+            signOptions: {
+              expiresIn: options.tokenConfig.expiredIn
+            }
+          })
+        ] : [],
+        SharedModule.forFeature(options),
+        MongoModule.forRoot(options.db)
+      ],
+      exports: [...SERVICES, AuthJwtGuard, MongoModule.forRoot(options.db)]
+    };
+  }
+};
+CrudShellNestjsModule = __decorateClass([
+  Module({})
+], CrudShellNestjsModule);
+var CrudShellNestjsCoreModule = class {
+  static forRoot(options) {
+    return {
+      module: CrudShellNestjsModule,
+      providers: [...SERVICES, ...GATEWAYS, AuthJwtGuard],
+      imports: [
+        PassportModule.register({ defaultStrategy: "jwt", session: false }),
+        JwtModule.register({
+          secret: options.tokenConfig.secretOrPrivateKey,
+          signOptions: {
+            expiresIn: options.tokenConfig.expiredIn
+          }
+        }),
+        SharedModule.forRoot(options),
+        MongoModule.forRoot(options.db)
+      ],
+      exports: []
+    };
+  }
+};
+CrudShellNestjsCoreModule = __decorateClass([
+  Module({})
+], CrudShellNestjsCoreModule);
+
+// packages/shared/paynow/src/lib/paynow.service.ts
+import { Injectable as Injectable9, Logger as Logger4 } from "@nestjs/common";
+import * as CryptoJS from "crypto-js";
+
+// packages/shared/paynow/src/lib/paynow.config.ts
+var PaynowConfig = class {
+};
+var PAYNOW_CONFIG_PROVIDER = "PAYNOW_CONFIG_PROVIDER";
+
+// packages/shared/paynow/src/lib/paynow.service.ts
+var PaynowService = class {
+  constructor(httpService, config, moduleRef) {
+    this.httpService = httpService;
+    this.config = config;
+    this.moduleRef = moduleRef;
+  }
+  async create(obj) {
+    const config = await this.getConfig(obj.data);
+    const data = {
+      externalId: obj.id,
+      description: obj.name,
+      currency: "PLN",
+      amount: obj.amount,
+      continueUrl: config.continueUrl,
+      buyer: {
+        email: obj.email
+      }
+    };
+    if (obj.contactPhone || obj.firstName || obj.lastName) {
+      data["buyer"] = {
+        email: obj.email,
+        phone: obj.contactPhone,
+        firstName: obj.firstName,
+        lastName: obj.lastName
+      };
+    }
+    const signature = this.getSignature(data, config);
+    const response = await this.httpService.post(this.getBaseUrl(config) + "/v1/payments", data, {
+      headers: {
+        "Content-Type": "application/json",
+        "Api-Key": config.apiKey,
+        "Idempotency-Key": GuidService.create(),
+        Signature: signature
+      },
+      maxRedirects: 0
+    }).toPromise();
+    return {
+      redirectUrl: response.data.redirectUrl,
+      orderId: response.data.paymentId
+    };
+  }
+  async getStatus(trans) {
+    const orderId = this.getOrderId(trans);
+    const config = await this.getConfig(trans.data);
+    const response = await this.httpService.get(this.getBaseUrl(config) + "/v1/payments/" + orderId + "/status", {
+      headers: {
+        "Content-Type": "application/json",
+        "Api-Key": config.apiKey
+      }
+    }).toPromise();
+    return {
+      status: this.getStatusFromExternal(response.data.status),
+      data: response.data
+    };
+  }
+  async refund(trans, comment) {
+    const orderId = this.getOrderId(trans);
+    const config = await this.getConfig(trans.data);
+    const data = {
+      amount: trans.amount
+    };
+    const signature = this.getSignature(data, config);
+    const response = await this.httpService.post(
+      this.getBaseUrl(config) + "/v1/payments/" + orderId + "/refunds",
+      data,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          "Api-Key": config.apiKey,
+          "Idempotency-Key": GuidService.create(),
+          Signature: signature
+        }
+      }
+    ).toPromise();
+    return response.data;
+  }
+  getOrderId(trans) {
+    const historyItem = trans.history.find((x) => x.status === "started");
+    if (!historyItem) {
+      console.warn("Transaction without start status");
+      return null;
+    }
+    return historyItem.data.orderId;
+  }
+  async getConfig(data) {
+    try {
+      const provider = this.moduleRef.get(
+        PAYNOW_CONFIG_PROVIDER,
+        { strict: false }
+      );
+      return await provider.get(data);
+    } catch (e) {
+      Logger4.warn("Paynow config provider not found", PaynowService.name);
+    }
+    return this.config;
+  }
+  getBaseUrl(config) {
+    if (config.test)
+      return "https://api.sandbox.paynow.pl";
+    return "https://api.paynow.pl";
+  }
+  getStatusFromExternal(status) {
+    switch (status) {
+      case "CONFIRMED":
+        return "completed";
+      case "REJECTED":
+        return "canceled";
+      case "PENDING":
+        return "pending";
+      default:
+        return status;
+    }
+  }
+  getSignature(data, config) {
+    return CryptoJS.enc.Base64.stringify(
+      CryptoJS.HmacSHA256(JSON.stringify(data), config.apiSignatureKey)
+    );
+  }
+};
+PaynowService = __decorateClass([
+  Injectable9()
+], PaynowService);
+
+// packages/shared/paypal/src/lib/paypal.config.ts
+var PaypalConfig = class {
+  constructor(clientId, clientSecret, currencyCode, returnUrl, apiUrl, cancelUrl, test) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.currencyCode = currencyCode;
+    this.returnUrl = returnUrl;
+    this.apiUrl = apiUrl;
+    this.cancelUrl = cancelUrl;
+    this.test = test;
+  }
+};
+var PAYPAL_CONFIG_PROVIDER = "PAYPAL_CONFIG_PROVIDER";
+
+// packages/shared/paypal/src/lib/paypal.service.ts
+import { Injectable as Injectable10, Logger as Logger5 } from "@nestjs/common";
+import * as paypal from "paypal-rest-sdk";
+var PaypalService = class {
+  constructor(httpService, config, moduleRef) {
+    this.httpService = httpService;
+    this.config = config;
+    this.moduleRef = moduleRef;
+  }
+  async create(obj) {
+    const config = await this.getConfig(obj.data);
+    const data = {
+      intent: "sale",
+      payer: {
+        payment_method: "paypal"
+      },
+      redirect_urls: {
+        return_url: config.apiUrl + "paypal/" + obj.id + "/confirm",
+        cancel_url: config.cancelUrl
+      },
+      transactions: [
+        {
+          item_list: {
+            items: [
+              {
+                name: obj.name,
+                sku: obj.id,
+                price: obj.amount / 100,
+                currency: config.currencyCode,
+                quantity: 1
+              }
+            ]
+          },
+          amount: {
+            currency: config.currencyCode,
+            total: obj.amount / 100
+          },
+          description: obj.name
+        }
+      ]
+    };
+    const result = await new Promise((res, rej) => {
+      paypal.payment.create(
+        data,
+        this.getEnv(config),
+        (error, payment2) => {
+          if (error) {
+            rej(error);
+          } else {
+            res(payment2);
+          }
+        }
+      );
+    });
+    return {
+      redirectUrl: result.links.find(
+        (l) => l.rel === "approval_url"
+      ).href,
+      orderId: result.id
+    };
+  }
+  async confirm(payerId, paymentId, amount, externalData) {
+    const config = await this.getConfig(externalData);
+    const data = {
+      payer_id: payerId,
+      transactions: [
+        {
+          amount: {
+            currency: config.currencyCode,
+            total: amount
+          }
+        }
+      ]
+    };
+    return await new Promise((res, rej) => {
+      paypal.payment.execute(
+        paymentId,
+        data,
+        this.getEnv(config),
+        (error, payment2) => {
+          if (error) {
+            rej(error);
+          } else {
+            res(payment2);
+          }
+        }
+      );
+    });
+  }
+  async getStatus(trans) {
+    const orderId = this.getOrderId(trans) ?? "";
+    const config = await this.getConfig(trans.data);
+    const payment2 = await new Promise((res, rej) => {
+      paypal.payment.get(
+        orderId,
+        this.getEnv(config),
+        (error, result) => {
+          if (error) {
+            rej(error);
+          } else {
+            res(result);
+          }
+        }
+      );
+    });
+    return {
+      status: this.getStatusFromExternal(payment2.state),
+      data: payment2
+    };
+  }
+  async refund(trans, comment) {
+    const orderId = this.getOrderId(trans);
+    const config = await this.getConfig(trans.data);
+    const transactionId = this.getTransactionId(trans);
+    if (!transactionId) {
+      throw new Error("Paypal transaction ID not found for refund");
+    }
+    const refundData = {
+      amount: {
+        total: (trans.amount / 100).toString(),
+        currency: config.currencyCode
+      },
+      description: comment
+    };
+    return new Promise((resolve, reject) => {
+      paypal.sale.refund(
+        transactionId,
+        refundData,
+        this.getEnv(config),
+        (error, refund) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(refund);
+          }
+        }
+      );
+    });
+  }
+  getOrderId(trans) {
+    const historyItem = trans.history.find((x) => x.status === "started");
+    if (!historyItem) {
+      console.warn("Transaction without start status");
+      return null;
+    }
+    return historyItem.data.orderId;
+  }
+  getStatusFromExternal(status) {
+    status = status.toUpperCase();
+    switch (status) {
+      case "COMPLETED":
+        return "completed";
+      case "VOIDED":
+        return "canceled";
+      case "CREATED":
+        return "pending";
+      case "SAVED":
+        return "pending";
+      case "APPROVED":
+        return "completed";
+      default:
+        return status;
+    }
+  }
+  async getConfig(data) {
+    try {
+      const provider = this.moduleRef.get(
+        PAYPAL_CONFIG_PROVIDER,
+        { strict: false }
+      );
+      return await provider.get(data);
+    } catch (e) {
+      Logger5.warn("PayPal config provider not found", PaypalService.name);
+    }
+    return this.config;
+  }
+  getEnv(config) {
+    return {
+      mode: config.test ? "sandbox" : "live",
+      client_id: config.clientId,
+      client_secret: config.clientSecret
+    };
+  }
+  getApiUrl(config) {
+    return config.test ? "https://api-m.sandbox.paypal.com/" : "https://api-m.paypal.com/";
+  }
+  getTransactionId(trans) {
+    const historyItem = trans.history.find(
+      (i) => i.status === "completed" && i.data && i.data.customData && i.data.customData.transactions && i.data.customData.transactions.length && i.data.customData.transactions[0].related_resources && i.data.customData.transactions[0].related_resources.length && i.data.customData.transactions[0].related_resources[0].sale
+    );
+    return historyItem ? historyItem.data.customData.transactions[0].related_resources[0].sale.id : null;
+  }
+};
+PaypalService = __decorateClass([
+  Injectable10()
+], PaypalService);
+
+// packages/shared/payu/src/lib/payu.service.ts
+import { Injectable as Injectable11, Logger as Logger6 } from "@nestjs/common";
+
+// packages/shared/payu/src/lib/payu.config.ts
+var PayuConfig = class {
+};
+var PAYU_CONFIG_PROVIDER = "PAYU_CONFIG_PROVIDER";
+
+// packages/shared/payu/src/lib/payu.service.ts
+var PayuService = class {
+  constructor(httpService, config, moduleRef) {
+    this.httpService = httpService;
+    this.config = config;
+    this.moduleRef = moduleRef;
+  }
+  async create(obj) {
+    const config = await this.getConfig(obj.data);
+    const token = await this.getToken(config);
+    const data = {
+      customerIp: obj.clientIp,
+      extOrderId: obj.id,
+      merchantPosId: config.posId,
+      description: obj.name,
+      currencyCode: "PLN",
+      totalAmount: obj.amount,
+      notifyUrl: config.notifyUrl,
+      continueUrl: config.continueUrl,
+      products: [
+        {
+          name: obj.name,
+          unitPrice: obj.amount,
+          quantity: "1"
+        }
+      ]
+    };
+    if (obj.options && obj.options["payMethod"]) {
+      data["payMethods"] = {
+        payMethod: obj.options["payMethod"]
+      };
+    }
+    if (obj.contactPhone || obj.email || obj.firstName || obj.lastName) {
+      data["buyer"] = {
+        email: obj.email,
+        phone: obj.contactPhone,
+        firstName: obj.firstName,
+        lastName: obj.lastName
+      };
+    }
+    try {
+      await this.httpService.post(this.getBaseUrl(config) + "/api/v2_1/orders", data, {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + token,
+          "X-Requested-With": "XMLHttpRequest"
+        },
+        maxRedirects: 0
+      }).toPromise();
+      return null;
+    } catch (e) {
+      if (e.response && e.response.status === 302) {
+        return {
+          redirectUrl: e.response.data.redirectUri,
+          orderId: e.response.data.orderId
+        };
+      }
+      console.error(e);
+      throw e;
+    }
+  }
+  async getStatus(trans) {
+    const orderId = this.getOrderId(trans);
+    const config = await this.getConfig(trans.data);
+    const token = await this.getToken(config);
+    const response = await this.httpService.get(this.getBaseUrl(config) + "/api/v2_1/orders/" + orderId, {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + token,
+        "X-Requested-With": "XMLHttpRequest"
+      },
+      maxRedirects: 0
+    }).toPromise();
+    if (!response.data.orders)
+      return null;
+    const order = response.data.orders[0];
+    return {
+      status: this.getStatusFromExternal(order.status),
+      data: order
+    };
+  }
+  async refund(trans, comment) {
+    const orderId = this.getOrderId(trans);
+    const config = await this.getConfig(trans.data);
+    const token = await this.getToken(config);
+    const response = await this.httpService.post(
+      this.getBaseUrl(config) + "/api/v2_1/orders/" + orderId,
+      {
+        refund: {
+          description: comment
+        }
+      },
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + token,
+          "X-Requested-With": "XMLHttpRequest"
+        },
+        maxRedirects: 0
+      }
+    ).toPromise();
+    return response.data;
+  }
+  getOrderId(trans) {
+    const historyItem = trans.history.find((x) => x.status === "started");
+    if (!historyItem) {
+      console.warn("Transaction without start status");
+      return null;
+    }
+    return historyItem.data.orderId;
+  }
+  async getToken(config) {
+    try {
+      const response = await this.httpService.post(
+        this.getBaseUrl(config) + "/pl/standard/user/oauth/authorize",
+        `grant_type=client_credentials&client_id=${config.clientId}&client_secret=${config.clientSecret}`
+      ).toPromise();
+      return response.data["access_token"];
+    } catch (e) {
+      console.error({
+        url: this.getBaseUrl(config) + "/pl/standard/user/oauth/authorize",
+        data: `grant_type=client_credentials&client_id=${config.clientId}&client_secret=${config.clientSecret}`,
+        ex: e
+      });
+      throw e;
+    }
+  }
+  async getConfig(data) {
+    try {
+      const provider = this.moduleRef.get(
+        PAYU_CONFIG_PROVIDER,
+        { strict: false }
+      );
+      return await provider.get(data);
+    } catch (e) {
+      Logger6.warn("PayPal config provider not found", PayuService.name);
+    }
+    return this.config;
+  }
+  getBaseUrl(config) {
+    if (config.test)
+      return "https://secure.snd.payu.com";
+    return "https://secure.payu.com";
+  }
+  getStatusFromExternal(status) {
+    switch (status) {
+      case "COMPLETED":
+        return "completed";
+      case "CANCELED":
+        return "canceled";
+      case "PENDING":
+        return "pending";
+      default:
+        return status;
+    }
+  }
+};
+PayuService = __decorateClass([
+  Injectable11()
+], PayuService);
+
+// packages/shared/revolut/src/lib/revolut.config.ts
+var RevolutConfig = class {
+};
+var REVOLUT_CONFIG_PROVIDER = "REVOLUT_CONFIG_PROVIDER";
+
+// packages/shared/revolut/src/lib/revolut.service.ts
+import { Injectable as Injectable12, Logger as Logger7, Optional as Optional2 } from "@nestjs/common";
+var RevolutService = class {
+  constructor(httpService, moduleRef, config) {
+    this.httpService = httpService;
+    this.moduleRef = moduleRef;
+    this.config = config;
+  }
+  async create(obj) {
+    const config = await this.getConfig(obj.data);
+    const data = {
+      amount: obj.amount,
+      description: obj.name,
+      capture_mode: "AUTOMATIC",
+      merchant_order_ext_ref: obj.id,
+      customer_email: obj.email,
+      currency: "PLN"
+    };
+    const response = await this.httpService.post(this.getBaseUrl(config) + "/api/1.0/orders", data, {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + config.token
+      },
+      maxRedirects: 0
+    }).toPromise();
+    return {
+      responseData: response.data,
+      orderId: response.data["public_id"]
+    };
+  }
+  async getStatus(trans) {
+    const config = await this.getConfig(trans.data);
+    const historyItem = trans.history.find((h) => h.status === "started");
+    const response = await this.httpService.get(
+      this.getBaseUrl(config) + "/api/1.0/orders/" + historyItem.data.responseData.id,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + config.token
+        },
+        maxRedirects: 0
+      }
+    ).toPromise();
+    return {
+      data: response.data,
+      status: this.getStatusFromExternal(response.data["state"])
+    };
+  }
+  refund(trans, comment) {
+    return Promise.reject("Revolut does not support refund");
+  }
+  getBaseUrl(config) {
+    if (config.test)
+      return "https://sandbox-merchant.revolut.com";
+    return "https://merchant.revolut.com/api";
+  }
+  async getConfig(data) {
+    try {
+      const provider = this.moduleRef.get(
+        REVOLUT_CONFIG_PROVIDER,
+        { strict: false }
+      );
+      return await provider.get(data);
+    } catch (e) {
+      Logger7.warn("Revolut config provider not found", RevolutService.name);
+    }
+    return this.config;
+  }
+  getStatusFromExternal(status) {
+    switch (status) {
+      case "PROCESSING":
+        return "completed";
+      case "CANCELLED":
+        return "canceled";
+      case "FAILED":
+        return "canceled";
+      case "PENDING":
+        return "pending";
+      default:
+        return status;
+    }
+  }
+};
+RevolutService = __decorateClass([
+  Injectable12(),
+  __decorateParam(2, Optional2())
+], RevolutService);
+
+// packages/trans/domain/src/lib/feature-create-trans/creator.service.ts
+import { Injectable as Injectable13 } from "@nestjs/common";
+import { Guid as Guid3 } from "guid-typescript";
+
+// packages/trans/domain/src/lib/entities/trans.entity.ts
+import { Column, Entity, ObjectIdColumn } from "typeorm";
+var Trans = class {
+};
+__decorateClass([
+  ObjectIdColumn({ generated: false })
+], Trans.prototype, "id", 2);
+__decorateClass([
+  Column()
+], Trans.prototype, "externalId", 2);
+__decorateClass([
+  Column()
+], Trans.prototype, "name", 2);
+__decorateClass([
+  Column()
+], Trans.prototype, "amount", 2);
+__decorateClass([
+  Column()
+], Trans.prototype, "firstName", 2);
+__decorateClass([
+  Column()
+], Trans.prototype, "lastName", 2);
+__decorateClass([
+  Column()
+], Trans.prototype, "email", 2);
+__decorateClass([
+  Column()
+], Trans.prototype, "contactPhone", 2);
+__decorateClass([
+  Column()
+], Trans.prototype, "data", 2);
+__decorateClass([
+  Column()
+], Trans.prototype, "system", 2);
+__decorateClass([
+  Column()
+], Trans.prototype, "options", 2);
+__decorateClass([
+  Column()
+], Trans.prototype, "status", 2);
+__decorateClass([
+  Column()
+], Trans.prototype, "modifyDate", 2);
+__decorateClass([
+  Column(() => TransHistory)
+], Trans.prototype, "history", 2);
+__decorateClass([
+  Column()
+], Trans.prototype, "clientIp", 2);
+Trans = __decorateClass([
+  Entity("trans")
+], Trans);
+var TransHistory = class {
+};
+__decorateClass([
+  Column()
+], TransHistory.prototype, "amount", 2);
+__decorateClass([
+  Column()
+], TransHistory.prototype, "data", 2);
+__decorateClass([
+  Column()
+], TransHistory.prototype, "system", 2);
+__decorateClass([
+  Column()
+], TransHistory.prototype, "status", 2);
+__decorateClass([
+  Column()
+], TransHistory.prototype, "modifyDate", 2);
+var TRANS_SYSTEMS = ["payu", "paypal", "revolut", "paynow"];
+
+// packages/trans/domain/src/lib/trans.service.ts
+var TransBaseService = class {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  addHistory(trans, data) {
+    const historyItem = new TransHistory();
+    historyItem.amount = trans.amount;
+    historyItem.modifyDate = trans.modifyDate;
+    historyItem.data = ObjectService.removeTypes(data);
+    historyItem.system = trans.system;
+    historyItem.status = trans.status;
+    if (!trans.history)
+      trans.history = [];
+    trans.history.push(historyItem);
+  }
+  async setError(trans, error) {
+    trans.modifyDate = /* @__PURE__ */ new Date();
+    trans.status = "error";
+    this.addHistory(trans, error);
+    await this.repository.update(trans, null);
+  }
+};
+
+// packages/trans/domain/src/lib/feature-create-trans/creator.service.ts
+var CreatorService = class extends TransBaseService {
+  constructor(repository) {
+    super(repository);
+  }
+  create(config, internalService, paymentService) {
+    this.valid(config);
+    let trans = null;
+    return this.prepare(config).then((r) => {
+      trans = r;
+      return this.setAsNew(trans, internalService);
+    }).then(() => {
+      return this.setAsStarted(trans, paymentService);
+    }).catch((e) => {
+      if (trans) {
+        this.setError(trans, e);
+      }
+      console.error(e);
+      throw e;
+    });
+  }
+  async setAsStarted(trans, paymentService) {
+    const paymentResult = await paymentService[trans.system].create({
+      id: trans.id,
+      name: trans.name,
+      amount: trans.amount,
+      firstName: trans.firstName,
+      lastName: trans.lastName,
+      email: trans.email,
+      contactPhone: trans.contactPhone,
+      clientIp: trans.clientIp,
+      data: trans.data,
+      options: trans.options
+    });
+    trans.status = "started";
+    trans.modifyDate = /* @__PURE__ */ new Date();
+    trans.externalId = paymentResult.orderId;
+    this.addHistory(trans, paymentResult);
+    await this.repository.update(trans, null);
+    return paymentResult;
+  }
+  async setAsNew(trans, internalService) {
+    const internalResult = await internalService.create(trans);
+    if (internalResult.amount) {
+      trans.amount = internalResult.amount;
+    }
+    trans.status = "new";
+    trans.modifyDate = /* @__PURE__ */ new Date();
+    this.addHistory(trans, internalResult);
+    await this.repository.update(trans, null);
+  }
+  async prepare(config) {
+    const trans = new Trans();
+    Object.keys(config).forEach((key) => {
+      trans[key] = config[key];
+    });
+    trans.id = Guid3.raw();
+    trans.modifyDate = /* @__PURE__ */ new Date();
+    trans.status = "prepare";
+    this.addHistory(trans, trans.data);
+    await this.repository.create(trans, null);
+    return trans;
+  }
+  valid(req) {
+    if (!req)
+      throw new DomainValidationError("config is empty");
+    if (!req.name)
+      throw new DomainValidationError("name is empty");
+    if (!req.clientIp)
+      throw new DomainValidationError("client ip is empty");
+    if (!req.amount || req.amount < 1)
+      throw new DomainValidationError("amount is empty");
+    if (!req.data)
+      throw new DomainValidationError("data is empty");
+    if (!req.system || !TRANS_SYSTEMS.some((s) => s === req.system))
+      throw new DomainValidationError("system is empty");
+  }
+};
+CreatorService = __decorateClass([
+  Injectable13()
+], CreatorService);
+
+// packages/trans/domain/src/lib/feature-refresh-trans/refresher.service.ts
+import { Injectable as Injectable14, NotFoundException as NotFoundException2 } from "@nestjs/common";
+var RefresherService = class extends TransBaseService {
+  constructor(repository) {
+    super(repository);
+  }
+  async refresh(transId, internalService, paymentService, customData = {}) {
+    const trans = (await this.repository.getByCriteria({
+      externalId: transId
+    })).data[0];
+    if (!trans) {
+      throw new NotFoundException2("Transaction not found: " + transId);
+    }
+    try {
+      const { status, data } = await paymentService[trans.system].getStatus(trans);
+      if (status === trans.status)
+        return;
+      trans.modifyDate = /* @__PURE__ */ new Date();
+      trans.status = status;
+      data["customData"] = customData;
+      this.addHistory(trans, data);
+      const internalRes = await internalService.refresh(trans);
+      if (!internalRes)
+        return;
+      this.addHistory(trans, internalRes);
+      await this.repository.updatePartial(
+        {
+          id: trans.id,
+          modifyDate: trans.modifyDate,
+          status: trans.status,
+          history: trans.history
+        },
+        null
+      );
+    } catch (err) {
+      console.error(err);
+      await this.setError(trans, err);
+      throw err;
+    }
+  }
+};
+RefresherService = __decorateClass([
+  Injectable14()
+], RefresherService);
+
+// packages/trans/domain/src/lib/feature-refund-trans/refund.service.ts
+import { Injectable as Injectable15, NotFoundException as NotFoundException3 } from "@nestjs/common";
+var RefundService = class extends TransBaseService {
+  constructor(repository) {
+    super(repository);
+  }
+  async refund(transId, internalService, paymentService, comment = "Refund") {
+    const trans = await this.repository.getById(transId);
+    if (!trans) {
+      throw new NotFoundException3("Transaction not found: " + transId);
+    }
+    if (trans.status !== "completed") {
+      throw new NotFoundException3(
+        "Transaction is not completed/error: " + transId
+      );
+    }
+    try {
+      const data = await paymentService[trans.system].refund(trans, comment);
+      trans.modifyDate = /* @__PURE__ */ new Date();
+      trans.status = "refund";
+      data["customData"] = {
+        comment
+      };
+      this.addHistory(trans, data);
+      await this.repository.update(trans, null);
+    } catch (err) {
+      console.error(err);
+      await this.setError(trans, err);
+      throw err;
+    }
+  }
+};
+RefundService = __decorateClass([
+  Injectable15()
+], RefundService);
+
+// packages/trans/domain/src/lib/trans.config.ts
+var TransConfig = class {
+  constructor(internalApiUrl, tokenConfig) {
+    this.internalApiUrl = internalApiUrl;
+    this.tokenConfig = tokenConfig;
+  }
+};
+
+// packages/trans/domain/src/index.ts
+var DOMAIN_SERVICES = [
+  CreatorService,
+  RefresherService,
+  RefundService
+];
+
+// packages/trans/shell/app-services/src/lib/services/trans/trans.service.ts
+import { Injectable as Injectable16, Optional as Optional3 } from "@nestjs/common";
+
+// packages/trans/shell/app-services/src/lib/services/internal/internal.service.ts
+var TRANS_TOKEN_INTERNAL_SERVICE = "TRANS_TOKEN_INTERNAL_SERVICE";
+
+// packages/trans/shell/app-services/src/lib/services/trans/trans.service.ts
+var TransService = class {
+  constructor(moduleRef, creatorService, refresherService, refundService, httpService, config, repository, payuService, paynowService, paypalService, revolutService) {
+    this.moduleRef = moduleRef;
+    this.creatorService = creatorService;
+    this.refresherService = refresherService;
+    this.refundService = refundService;
+    this.httpService = httpService;
+    this.config = config;
+    this.repository = repository;
+    this.payuService = payuService;
+    this.paynowService = paynowService;
+    this.paypalService = paypalService;
+    this.revolutService = revolutService;
+    this._paymentService = {
+      payu: this.payuService,
+      paypal: this.paypalService,
+      paynow: this.paynowService,
+      revolut: this.revolutService
+    };
+    this._internalService = {
+      create: (trans) => {
+        if (!this.config.internalApiUrl)
+          return Promise.resolve({
+            date: /* @__PURE__ */ new Date(),
+            req: trans
+          });
+        return this.httpService.post(this.config.internalApiUrl, trans).toPromise().then((res) => res.data);
+      },
+      refresh: (trans) => {
+        if (!this.config.internalApiUrl)
+          return Promise.resolve({
+            date: /* @__PURE__ */ new Date(),
+            req: trans,
+            id: trans.id
+          });
+        return this.httpService.put(this.config.internalApiUrl + "/" + trans.id, trans).toPromise().then((res) => res.data);
+      }
+    };
+  }
+  create(ops) {
+    return this.creatorService.create(
+      ops,
+      this.getInternalService(),
+      this._paymentService
+    );
+  }
+  async refresh(transId, data = {}) {
+    await this.refresherService.refresh(
+      transId,
+      this.getInternalService(),
+      this._paymentService,
+      data
+    );
+  }
+  async refund(transId, comment = "Refund") {
+    await this.refundService.refund(
+      transId,
+      this.getInternalService(),
+      this._paymentService,
+      comment
+    );
+  }
+  async getById(id) {
+    return await this.repository.getById(id);
+  }
+  getInternalService() {
+    try {
+      return this.moduleRef.get(TRANS_TOKEN_INTERNAL_SERVICE, {
+        strict: false
+      });
+    } catch (e) {
+      return this._internalService;
+    }
+  }
+};
+TransService = __decorateClass([
+  Injectable16(),
+  __decorateParam(7, Optional3()),
+  __decorateParam(8, Optional3()),
+  __decorateParam(9, Optional3()),
+  __decorateParam(10, Optional3())
+], TransService);
+
+// packages/trans/shell/app-services/src/lib/services/index.ts
+var SERVICES2 = [TransService];
+
+// packages/trans/shell/nestjs/src/lib/controllers/paynow/paynow.controller.ts
+import { Body as Body2, Controller as Controller2, HttpCode as HttpCode2, Post as Post2 } from "@nestjs/common";
+var PaynowController = class {
+  constructor(service) {
+    this.service = service;
+  }
+  async refreshStatus(obj) {
+    try {
+      await this.service.refresh(obj.paymentId, obj);
+      return "ok";
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+  }
+};
+__decorateClass([
+  Post2(),
+  HttpCode2(200),
+  __decorateParam(0, Body2())
+], PaynowController.prototype, "refreshStatus", 1);
+PaynowController = __decorateClass([
+  Controller2("paynow")
+], PaynowController);
+
+// packages/trans/shell/nestjs/src/lib/controllers/paypal/paypal.controller.ts
+import {
+  Body as Body3,
+  Controller as Controller3,
+  HttpCode as HttpCode3,
+  Post as Post3,
+  Get as Get2,
+  Param as Param2,
+  Query as Query2,
+  Res as Res2,
+  HttpStatus as HttpStatus2,
+  Optional as Optional4
+} from "@nestjs/common";
+var PaypalController = class {
+  constructor(service, config, paypalService) {
+    this.service = service;
+    this.config = config;
+    this.paypalService = paypalService;
+  }
+  async refreshStatus(obj) {
+    try {
+      const trans = await this.service.getById(obj.item_number1);
+      await this.service.refresh(trans.externalId, obj);
+      return "ok";
+    } catch (e) {
+      console.error("ERROR ---> ", obj);
+      console.error(e);
+      throw e;
+    }
+  }
+  async confirm(id, payerId, paymentId, res) {
+    try {
+      const trans = await this.service.getById(id);
+      if (trans.externalId !== paymentId) {
+        throw new Error("Invalid externaId");
+      }
+      const payment2 = await this.paypalService.confirm(
+        payerId,
+        paymentId,
+        trans.amount / 100,
+        trans.data
+      );
+      await this.service.refresh(paymentId, payment2);
+      return res.redirect(HttpStatus2.MOVED_PERMANENTLY, this.config.returnUrl);
+    } catch (e) {
+      console.log(e);
+      return res.redirect(HttpStatus2.MOVED_PERMANENTLY, this.config.cancelUrl);
+    }
+  }
+};
+__decorateClass([
+  Post3(),
+  HttpCode3(200),
+  __decorateParam(0, Body3())
+], PaypalController.prototype, "refreshStatus", 1);
+__decorateClass([
+  Get2(":id/confirm"),
+  __decorateParam(0, Param2("id")),
+  __decorateParam(1, Query2("PayerID")),
+  __decorateParam(2, Query2("paymentId")),
+  __decorateParam(3, Res2())
+], PaypalController.prototype, "confirm", 1);
+PaypalController = __decorateClass([
+  Controller3("paypal"),
+  __decorateParam(1, Optional4()),
+  __decorateParam(2, Optional4())
+], PaypalController);
+
+// packages/trans/shell/nestjs/src/lib/controllers/payu/payu.controller.ts
+import { Body as Body4, Controller as Controller4, HttpCode as HttpCode4, Post as Post4 } from "@nestjs/common";
+var PayUController = class {
+  constructor(service) {
+    this.service = service;
+  }
+  async refreshStatus(obj) {
+    try {
+      await this.service.refresh(obj.order.orderId, obj);
+      return "ok";
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+  }
+};
+__decorateClass([
+  Post4(),
+  HttpCode4(200),
+  __decorateParam(0, Body4())
+], PayUController.prototype, "refreshStatus", 1);
+PayUController = __decorateClass([
+  Controller4("payu")
+], PayUController);
+
+// packages/trans/shell/nestjs/src/lib/controllers/trans/trans.controller.ts
+import { Body as Body5, Controller as Controller5, Param as Param3, Post as Post5, Req as Req2 } from "@nestjs/common";
+var TransController = class {
+  constructor(service) {
+    this.service = service;
+  }
+  async create(obj, req) {
+    obj.clientIp = req.connection.remoteAddress.indexOf("::") === 0 ? "10.0.0.1" : req.connection.remoteAddress;
+    const { redirectUrl, orderId } = await this.service.create(obj);
+    return {
+      url: redirectUrl,
+      orderId
+    };
+  }
+  async refresh(orderId, obj) {
+    await this.service.refresh(orderId, {});
+  }
+};
+__decorateClass([
+  Post5(),
+  __decorateParam(0, Body5()),
+  __decorateParam(1, Req2())
+], TransController.prototype, "create", 1);
+__decorateClass([
+  Post5(":id/refresh"),
+  __decorateParam(0, Param3("id")),
+  __decorateParam(1, Body5())
+], TransController.prototype, "refresh", 1);
+TransController = __decorateClass([
+  Controller5("")
+], TransController);
+
+// packages/trans/shell/nestjs/src/lib/controllers/index.ts
+var CONTROLLERS2 = [
+  TransController,
+  PayUController,
+  PaypalController,
+  PaynowController
+];
+
+// packages/trans/shell/nestjs/src/lib/nestjs.module.ts
+var TransShellNestjsModule = class {
+  static forRoot(config) {
+    return {
+      module: TransShellNestjsModule,
+      controllers: CONTROLLERS2,
+      providers: [
+        ...SERVICES2,
+        ...DOMAIN_SERVICES,
+        { provide: TransConfig, useValue: config },
+        ...config.payuConfig ? [{ provide: PayuConfig, useValue: config.payuConfig }, PayuService] : [],
+        ...config.paypalConfig ? [
+          { provide: PaypalConfig, useValue: config.paypalConfig },
+          PaypalService
+        ] : [],
+        ...config.revolutConfig ? [
+          { provide: RevolutConfig, useValue: config.revolutConfig },
+          RevolutService
+        ] : [],
+        ...config.paynowConfig ? [
+          { provide: PaynowConfig, useValue: config.paynowConfig },
+          PaynowService
+        ] : []
+      ],
+      imports: [
+        CrudShellNestjsModule.forRoot({
+          ...config,
+          db: {
+            ...config.db,
+            collection: "trans"
+          },
+          restApi: false,
+          socket: false
+        }),
+        PassportModule2.register({ defaultStrategy: "jwt", session: false }),
+        JwtModule2.register({
+          secret: config.tokenConfig.secretOrPrivateKey,
+          signOptions: {
+            expiresIn: config.tokenConfig.expiredIn
+          }
+        })
+      ],
+      exports: [
+        ...SERVICES2,
+        TransConfig,
+        ...config.payuConfig ? [PayuConfig, PayuService] : [],
+        ...config.paypalConfig ? [PaypalConfig, PaypalService] : [],
+        ...config.revolutConfig ? [RevolutConfig, RevolutService] : []
+      ]
+    };
+  }
+};
+TransShellNestjsModule = __decorateClass([
+  Module2({
+    imports: [HttpModule]
+  })
+], TransShellNestjsModule);
+var TransShellNestjsCoreModule = class {
+  static forRoot(config) {
+    return {
+      module: TransShellNestjsCoreModule,
+      providers: [
+        ...SERVICES2,
+        ...DOMAIN_SERVICES,
+        { provide: TransConfig, useValue: config },
+        ...config.payuConfig ? [{ provide: PayuConfig, useValue: config.payuConfig }, PayuService] : [],
+        ...config.paypalConfig ? [
+          { provide: PaypalConfig, useValue: config.paypalConfig },
+          PaypalService
+        ] : [],
+        ...config.paynowConfig ? [
+          { provide: PaynowConfig, useValue: config.paynowConfig },
+          PaynowService
+        ] : []
+      ],
+      imports: [
+        CrudShellNestjsModule.forRoot({
+          ...config,
+          db: {
+            ...config.db,
+            collection: "trans"
+          },
+          restApi: false,
+          socket: false
+        }),
+        PassportModule2.register({ defaultStrategy: "jwt", session: false }),
+        JwtModule2.register({
+          secret: config.tokenConfig.secretOrPrivateKey,
+          signOptions: {
+            expiresIn: config.tokenConfig.expiredIn
+          }
+        })
+      ],
+      exports: [
+        ...SERVICES2,
+        TransConfig,
+        ...config.payuConfig ? [PayuConfig, PayuService] : [],
+        ...config.paypalConfig ? [PaypalConfig, PaypalService] : [],
+        ...config.revolutConfig ? [RevolutConfig, RevolutService] : [],
+        ...config.paynowConfig ? [PaynowConfig, PaynowService] : []
+      ]
+    };
+  }
+};
+TransShellNestjsCoreModule = __decorateClass([
+  Module2({
+    imports: [HttpModule]
+  })
+], TransShellNestjsCoreModule);
+export {
+  CONTROLLERS2 as CONTROLLERS,
+  PayUController,
+  PaynowController,
+  PaypalController,
+  TransController,
+  TransShellNestjsCoreModule,
+  TransShellNestjsModule
+};