@smartsoft001/crud-shell-nestjs 2.76.0 → 2.80.0

package/index.js

@@ -0,0 +1,1840 @@
+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/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);
+export {
+  AuthJwtGuard,
+  AuthOrAnonymousJwtGuard,
+  CONTROLLERS,
+  CrudController,
+  CrudShellNestjsCoreModule,
+  CrudShellNestjsModule,
+  GATEWAYS
+};