nicot 1.2.12 → 1.2.13

package/dist/index.mjs

@@ -1,5 +1,34 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __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--)
@@ -9,6 +38,539 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 
+// node_modules/@nestjs/typeorm/dist/typeorm.constants.js
+var require_typeorm_constants = __commonJS({
+  "node_modules/@nestjs/typeorm/dist/typeorm.constants.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DEFAULT_DATA_SOURCE_NAME = exports.TYPEORM_MODULE_ID = exports.TYPEORM_MODULE_OPTIONS = void 0;
+    exports.TYPEORM_MODULE_OPTIONS = "TypeOrmModuleOptions";
+    exports.TYPEORM_MODULE_ID = "TypeOrmModuleId";
+    exports.DEFAULT_DATA_SOURCE_NAME = "default";
+  }
+});
+
+// node_modules/@nestjs/typeorm/dist/exceptions/circular-dependency.exception.js
+var require_circular_dependency_exception = __commonJS({
+  "node_modules/@nestjs/typeorm/dist/exceptions/circular-dependency.exception.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CircularDependencyException = void 0;
+    var CircularDependencyException = class extends Error {
+      constructor(context) {
+        const ctx = context ? ` inside ${context}` : ``;
+        super(`A circular dependency has been detected${ctx}. Please, make sure that each side of a bidirectional relationships are decorated with "forwardRef()". Also, try to eliminate barrel files because they can lead to an unexpected behavior too.`);
+      }
+    };
+    exports.CircularDependencyException = CircularDependencyException;
+  }
+});
+
+// node_modules/@nestjs/typeorm/dist/common/typeorm.utils.js
+var require_typeorm_utils = __commonJS({
+  "node_modules/@nestjs/typeorm/dist/common/typeorm.utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.generateString = exports.getConnectionToken = void 0;
+    exports.getRepositoryToken = getRepositoryToken;
+    exports.getCustomRepositoryToken = getCustomRepositoryToken;
+    exports.getDataSourceToken = getDataSourceToken;
+    exports.getDataSourcePrefix = getDataSourcePrefix;
+    exports.getEntityManagerToken = getEntityManagerToken2;
+    exports.handleRetry = handleRetry;
+    exports.getDataSourceName = getDataSourceName;
+    var common_1 = __require("@nestjs/common");
+    var operators_1 = __require("rxjs/operators");
+    var typeorm_1 = __require("typeorm");
+    var circular_dependency_exception_1 = require_circular_dependency_exception();
+    var typeorm_constants_1 = require_typeorm_constants();
+    var logger = new common_1.Logger("TypeOrmModule");
+    function getRepositoryToken(entity, dataSource = typeorm_constants_1.DEFAULT_DATA_SOURCE_NAME) {
+      if (entity === null || entity === void 0) {
+        throw new circular_dependency_exception_1.CircularDependencyException("@InjectRepository()");
+      }
+      const dataSourcePrefix = getDataSourcePrefix(dataSource);
+      if (entity instanceof Function && (entity.prototype instanceof typeorm_1.Repository || entity.prototype instanceof typeorm_1.AbstractRepository)) {
+        if (!dataSourcePrefix) {
+          return entity;
+        }
+        return `${dataSourcePrefix}${getCustomRepositoryToken(entity)}`;
+      }
+      if (entity instanceof typeorm_1.EntitySchema) {
+        return `${dataSourcePrefix}${entity.options.target ? entity.options.target.name : entity.options.name}Repository`;
+      }
+      return `${dataSourcePrefix}${entity.name}Repository`;
+    }
+    function getCustomRepositoryToken(repository) {
+      if (repository === null || repository === void 0) {
+        throw new circular_dependency_exception_1.CircularDependencyException("@InjectRepository()");
+      }
+      return repository.name;
+    }
+    function getDataSourceToken(dataSource = typeorm_constants_1.DEFAULT_DATA_SOURCE_NAME) {
+      return typeorm_constants_1.DEFAULT_DATA_SOURCE_NAME === dataSource ? typeorm_1.DataSource ?? typeorm_1.Connection : "string" === typeof dataSource ? `${dataSource}DataSource` : typeorm_constants_1.DEFAULT_DATA_SOURCE_NAME === dataSource.name || !dataSource.name ? typeorm_1.DataSource ?? typeorm_1.Connection : `${dataSource.name}DataSource`;
+    }
+    exports.getConnectionToken = getDataSourceToken;
+    function getDataSourcePrefix(dataSource = typeorm_constants_1.DEFAULT_DATA_SOURCE_NAME) {
+      if (dataSource === typeorm_constants_1.DEFAULT_DATA_SOURCE_NAME) {
+        return "";
+      }
+      if (typeof dataSource === "string") {
+        return dataSource + "_";
+      }
+      if (dataSource.name === typeorm_constants_1.DEFAULT_DATA_SOURCE_NAME || !dataSource.name) {
+        return "";
+      }
+      return dataSource.name + "_";
+    }
+    function getEntityManagerToken2(dataSource = typeorm_constants_1.DEFAULT_DATA_SOURCE_NAME) {
+      return typeorm_constants_1.DEFAULT_DATA_SOURCE_NAME === dataSource ? typeorm_1.EntityManager : "string" === typeof dataSource ? `${dataSource}EntityManager` : typeorm_constants_1.DEFAULT_DATA_SOURCE_NAME === dataSource.name || !dataSource.name ? typeorm_1.EntityManager : `${dataSource.name}EntityManager`;
+    }
+    function handleRetry(retryAttempts = 9, retryDelay = 3e3, dataSourceName = typeorm_constants_1.DEFAULT_DATA_SOURCE_NAME, verboseRetryLog = false, toRetry) {
+      return (source) => source.pipe((0, operators_1.retryWhen)((e) => e.pipe((0, operators_1.scan)((errorCount, error) => {
+        if (toRetry && !toRetry(error)) {
+          throw error;
+        }
+        const dataSourceInfo = dataSourceName === typeorm_constants_1.DEFAULT_DATA_SOURCE_NAME ? "" : ` (${dataSourceName})`;
+        const verboseMessage = verboseRetryLog ? ` Message: ${error.message}.` : "";
+        logger.error(`Unable to connect to the database${dataSourceInfo}.${verboseMessage} Retrying (${errorCount + 1})...`, error.stack);
+        if (errorCount + 1 >= retryAttempts) {
+          throw error;
+        }
+        return errorCount + 1;
+      }, 0), (0, operators_1.delay)(retryDelay))));
+    }
+    function getDataSourceName(options) {
+      return options && options.name ? options.name : typeorm_constants_1.DEFAULT_DATA_SOURCE_NAME;
+    }
+    var generateString = () => crypto.randomUUID();
+    exports.generateString = generateString;
+  }
+});
+
+// node_modules/@nestjs/typeorm/dist/common/typeorm.decorators.js
+var require_typeorm_decorators = __commonJS({
+  "node_modules/@nestjs/typeorm/dist/common/typeorm.decorators.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.InjectEntityManager = exports.InjectConnection = exports.InjectDataSource = exports.InjectRepository = void 0;
+    var common_1 = __require("@nestjs/common");
+    var typeorm_constants_1 = require_typeorm_constants();
+    var typeorm_utils_1 = require_typeorm_utils();
+    var InjectRepository = (entity, dataSource = typeorm_constants_1.DEFAULT_DATA_SOURCE_NAME) => (0, common_1.Inject)((0, typeorm_utils_1.getRepositoryToken)(entity, dataSource));
+    exports.InjectRepository = InjectRepository;
+    var InjectDataSource = (dataSource) => (0, common_1.Inject)((0, typeorm_utils_1.getDataSourceToken)(dataSource));
+    exports.InjectDataSource = InjectDataSource;
+    exports.InjectConnection = exports.InjectDataSource;
+    var InjectEntityManager = (dataSource) => (0, common_1.Inject)((0, typeorm_utils_1.getEntityManagerToken)(dataSource));
+    exports.InjectEntityManager = InjectEntityManager;
+  }
+});
+
+// node_modules/@nestjs/typeorm/dist/common/index.js
+var require_common = __commonJS({
+  "node_modules/@nestjs/typeorm/dist/common/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_typeorm_decorators(), exports);
+    __exportStar(require_typeorm_utils(), exports);
+  }
+});
+
+// node_modules/@nestjs/typeorm/dist/interfaces/typeorm-options.interface.js
+var require_typeorm_options_interface = __commonJS({
+  "node_modules/@nestjs/typeorm/dist/interfaces/typeorm-options.interface.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// node_modules/@nestjs/typeorm/dist/interfaces/index.js
+var require_interfaces = __commonJS({
+  "node_modules/@nestjs/typeorm/dist/interfaces/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_typeorm_options_interface(), exports);
+  }
+});
+
+// node_modules/@nestjs/typeorm/dist/entities-metadata.storage.js
+var require_entities_metadata_storage = __commonJS({
+  "node_modules/@nestjs/typeorm/dist/entities-metadata.storage.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EntitiesMetadataStorage = void 0;
+    var EntitiesMetadataStorage = class {
+      static addEntitiesByDataSource(dataSource, entities) {
+        const dataSourceToken = typeof dataSource === "string" ? dataSource : dataSource.name;
+        if (!dataSourceToken) {
+          return;
+        }
+        let collection = this.storage.get(dataSourceToken);
+        if (!collection) {
+          collection = [];
+          this.storage.set(dataSourceToken, collection);
+        }
+        entities.forEach((entity) => {
+          if (collection.includes(entity)) {
+            return;
+          }
+          collection.push(entity);
+        });
+      }
+      static getEntitiesByDataSource(dataSource) {
+        const dataSourceToken = typeof dataSource === "string" ? dataSource : dataSource.name;
+        if (!dataSourceToken) {
+          return [];
+        }
+        return this.storage.get(dataSourceToken) || [];
+      }
+    };
+    exports.EntitiesMetadataStorage = EntitiesMetadataStorage;
+    EntitiesMetadataStorage.storage = /* @__PURE__ */ new Map();
+  }
+});
+
+// node_modules/@nestjs/typeorm/dist/typeorm-core.module.js
+var require_typeorm_core_module = __commonJS({
+  "node_modules/@nestjs/typeorm/dist/typeorm-core.module.js"(exports) {
+    "use strict";
+    var __decorate = exports && exports.__decorate || function(decorators, target, key, desc) {
+      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      return c > 3 && r && Object.defineProperty(target, key, r), r;
+    };
+    var __metadata = exports && exports.__metadata || function(k, v) {
+      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+    };
+    var __param = exports && exports.__param || function(paramIndex, decorator) {
+      return function(target, key) {
+        decorator(target, key, paramIndex);
+      };
+    };
+    var TypeOrmCoreModule_1;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TypeOrmCoreModule = void 0;
+    var common_1 = __require("@nestjs/common");
+    var core_1 = __require("@nestjs/core");
+    var rxjs_1 = __require("rxjs");
+    var typeorm_1 = __require("typeorm");
+    var typeorm_utils_1 = require_typeorm_utils();
+    var entities_metadata_storage_1 = require_entities_metadata_storage();
+    var typeorm_constants_1 = require_typeorm_constants();
+    var TypeOrmCoreModule = TypeOrmCoreModule_1 = class TypeOrmCoreModule {
+      constructor(options, moduleRef) {
+        this.options = options;
+        this.moduleRef = moduleRef;
+        this.logger = new common_1.Logger("TypeOrmModule");
+      }
+      static forRoot(options = {}) {
+        const typeOrmModuleOptions = {
+          provide: typeorm_constants_1.TYPEORM_MODULE_OPTIONS,
+          useValue: options
+        };
+        const dataSourceProvider = {
+          provide: (0, typeorm_utils_1.getDataSourceToken)(options),
+          useFactory: async () => await this.createDataSourceFactory(options)
+        };
+        const entityManagerProvider = this.createEntityManagerProvider(options);
+        const providers = [
+          entityManagerProvider,
+          dataSourceProvider,
+          typeOrmModuleOptions
+        ];
+        const exports2 = [entityManagerProvider, dataSourceProvider];
+        if (dataSourceProvider.provide === typeorm_1.DataSource) {
+          providers.push({
+            provide: typeorm_1.Connection,
+            useExisting: typeorm_1.DataSource
+          });
+          exports2.push(typeorm_1.Connection);
+        }
+        return {
+          module: TypeOrmCoreModule_1,
+          providers,
+          exports: exports2
+        };
+      }
+      static forRootAsync(options) {
+        const dataSourceProvider = {
+          provide: (0, typeorm_utils_1.getDataSourceToken)(options),
+          useFactory: async (typeOrmOptions) => {
+            if (options.name) {
+              return await this.createDataSourceFactory({
+                ...typeOrmOptions,
+                name: options.name
+              }, options.dataSourceFactory);
+            }
+            return await this.createDataSourceFactory(typeOrmOptions, options.dataSourceFactory);
+          },
+          inject: [typeorm_constants_1.TYPEORM_MODULE_OPTIONS]
+        };
+        const entityManagerProvider = {
+          provide: (0, typeorm_utils_1.getEntityManagerToken)(options),
+          useFactory: (dataSource) => dataSource.manager,
+          inject: [(0, typeorm_utils_1.getDataSourceToken)(options)]
+        };
+        const asyncProviders = this.createAsyncProviders(options);
+        const providers = [
+          ...asyncProviders,
+          entityManagerProvider,
+          dataSourceProvider,
+          {
+            provide: typeorm_constants_1.TYPEORM_MODULE_ID,
+            useValue: (0, typeorm_utils_1.generateString)()
+          },
+          ...options.extraProviders || []
+        ];
+        const exports2 = [
+          entityManagerProvider,
+          dataSourceProvider
+        ];
+        if (dataSourceProvider.provide === typeorm_1.DataSource) {
+          providers.push({
+            provide: typeorm_1.Connection,
+            useExisting: typeorm_1.DataSource
+          });
+          exports2.push(typeorm_1.Connection);
+        }
+        return {
+          module: TypeOrmCoreModule_1,
+          imports: options.imports,
+          providers,
+          exports: exports2
+        };
+      }
+      async onApplicationShutdown() {
+        const dataSource = this.moduleRef.get((0, typeorm_utils_1.getDataSourceToken)(this.options));
+        try {
+          if (dataSource && dataSource.isInitialized) {
+            await dataSource.destroy();
+          }
+        } catch (e) {
+          this.logger.error(e?.message);
+        }
+      }
+      static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+          return [this.createAsyncOptionsProvider(options)];
+        }
+        const useClass = options.useClass;
+        return [
+          this.createAsyncOptionsProvider(options),
+          {
+            provide: useClass,
+            useClass
+          }
+        ];
+      }
+      static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+          return {
+            provide: typeorm_constants_1.TYPEORM_MODULE_OPTIONS,
+            useFactory: options.useFactory,
+            inject: options.inject || []
+          };
+        }
+        const inject = [
+          options.useClass || options.useExisting
+        ];
+        return {
+          provide: typeorm_constants_1.TYPEORM_MODULE_OPTIONS,
+          useFactory: async (optionsFactory) => await optionsFactory.createTypeOrmOptions(options.name),
+          inject
+        };
+      }
+      static createEntityManagerProvider(options) {
+        return {
+          provide: (0, typeorm_utils_1.getEntityManagerToken)(options),
+          useFactory: (dataSource) => dataSource.manager,
+          inject: [(0, typeorm_utils_1.getDataSourceToken)(options)]
+        };
+      }
+      static async createDataSourceFactory(options, dataSourceFactory) {
+        const dataSourceToken = (0, typeorm_utils_1.getDataSourceName)(options);
+        const createTypeormDataSource = dataSourceFactory ?? ((options2) => {
+          return typeorm_1.DataSource === void 0 ? (0, typeorm_1.createConnection)(options2) : new typeorm_1.DataSource(options2);
+        });
+        return await (0, rxjs_1.lastValueFrom)((0, rxjs_1.defer)(async () => {
+          let dataSource;
+          if (!options.autoLoadEntities) {
+            dataSource = await createTypeormDataSource(options);
+          } else {
+            let entities = options.entities;
+            if (Array.isArray(entities)) {
+              entities = entities.concat(entities_metadata_storage_1.EntitiesMetadataStorage.getEntitiesByDataSource(dataSourceToken));
+            } else {
+              entities = entities_metadata_storage_1.EntitiesMetadataStorage.getEntitiesByDataSource(dataSourceToken);
+            }
+            dataSource = await createTypeormDataSource({
+              ...options,
+              entities
+            });
+          }
+          return dataSource.initialize && !dataSource.isInitialized && !options.manualInitialization ? dataSource.initialize() : dataSource;
+        }).pipe((0, typeorm_utils_1.handleRetry)(options.retryAttempts, options.retryDelay, dataSourceToken, options.verboseRetryLog, options.toRetry)));
+      }
+    };
+    exports.TypeOrmCoreModule = TypeOrmCoreModule;
+    exports.TypeOrmCoreModule = TypeOrmCoreModule = TypeOrmCoreModule_1 = __decorate([
+      (0, common_1.Global)(),
+      (0, common_1.Module)({}),
+      __param(0, (0, common_1.Inject)(typeorm_constants_1.TYPEORM_MODULE_OPTIONS)),
+      __metadata("design:paramtypes", [Object, core_1.ModuleRef])
+    ], TypeOrmCoreModule);
+  }
+});
+
+// node_modules/@nestjs/typeorm/dist/typeorm.providers.js
+var require_typeorm_providers = __commonJS({
+  "node_modules/@nestjs/typeorm/dist/typeorm.providers.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createTypeOrmProviders = createTypeOrmProviders;
+    var typeorm_1 = __require("typeorm");
+    var typeorm_utils_1 = require_typeorm_utils();
+    function createTypeOrmProviders(entities, dataSource) {
+      return (entities || []).map((entity) => ({
+        provide: (0, typeorm_utils_1.getRepositoryToken)(entity, dataSource),
+        useFactory: (dataSource2) => {
+          const entityMetadata = dataSource2.entityMetadatas.find((meta) => meta.target === entity);
+          const isTreeEntity = typeof entityMetadata?.treeType !== "undefined";
+          return isTreeEntity ? dataSource2.getTreeRepository(entity) : dataSource2.options.type === "mongodb" ? dataSource2.getMongoRepository(entity) : dataSource2.getRepository(entity);
+        },
+        inject: [(0, typeorm_utils_1.getDataSourceToken)(dataSource)],
+        /**
+         * Extra property to workaround dynamic modules serialisation issue
+         * that occurs when "TypeOrm#forFeature()" method is called with the same number
+         * of arguments and all entities share the same class names.
+         */
+        targetEntitySchema: (0, typeorm_1.getMetadataArgsStorage)().tables.find((item) => item.target === entity)
+      }));
+    }
+  }
+});
+
+// node_modules/@nestjs/typeorm/dist/typeorm.module.js
+var require_typeorm_module = __commonJS({
+  "node_modules/@nestjs/typeorm/dist/typeorm.module.js"(exports) {
+    "use strict";
+    var __decorate = exports && exports.__decorate || function(decorators, target, key, desc) {
+      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      return c > 3 && r && Object.defineProperty(target, key, r), r;
+    };
+    var TypeOrmModule_1;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TypeOrmModule = void 0;
+    var common_1 = __require("@nestjs/common");
+    var entities_metadata_storage_1 = require_entities_metadata_storage();
+    var typeorm_core_module_1 = require_typeorm_core_module();
+    var typeorm_constants_1 = require_typeorm_constants();
+    var typeorm_providers_1 = require_typeorm_providers();
+    var TypeOrmModule2 = TypeOrmModule_1 = class TypeOrmModule {
+      static forRoot(options) {
+        return {
+          module: TypeOrmModule_1,
+          imports: [typeorm_core_module_1.TypeOrmCoreModule.forRoot(options)]
+        };
+      }
+      static forFeature(entities = [], dataSource = typeorm_constants_1.DEFAULT_DATA_SOURCE_NAME) {
+        const providers = (0, typeorm_providers_1.createTypeOrmProviders)(entities, dataSource);
+        entities_metadata_storage_1.EntitiesMetadataStorage.addEntitiesByDataSource(dataSource, [...entities]);
+        return {
+          module: TypeOrmModule_1,
+          providers,
+          exports: providers
+        };
+      }
+      static forRootAsync(options) {
+        return {
+          module: TypeOrmModule_1,
+          imports: [typeorm_core_module_1.TypeOrmCoreModule.forRootAsync(options)]
+        };
+      }
+    };
+    exports.TypeOrmModule = TypeOrmModule2;
+    exports.TypeOrmModule = TypeOrmModule2 = TypeOrmModule_1 = __decorate([
+      (0, common_1.Module)({})
+    ], TypeOrmModule2);
+  }
+});
+
+// node_modules/@nestjs/typeorm/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/@nestjs/typeorm/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_common(), exports);
+    __exportStar(require_interfaces(), exports);
+    __exportStar(require_typeorm_module(), exports);
+  }
+});
+
+// node_modules/@nestjs/typeorm/index.js
+var require_typeorm = __commonJS({
+  "node_modules/@nestjs/typeorm/index.js"(exports) {
+    "use strict";
+    function __export(m) {
+      for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+    }
+    exports.__esModule = true;
+    __export(require_dist());
+  }
+});
+
 // index.ts
 export * from "nesties";
 
@@ -1701,7 +2263,11 @@ var CrudBase = class {
         const existingEnt = await repo.findOne({
           where: { id: ent.id },
           select: this.crudOptions.createOrUpdate ? void 0 : ["id", "deleteTime"],
-          withDeleted: true
+          withDeleted: true,
+          lock: {
+            mode: "pessimistic_write",
+            tables: [repo.metadata.tableName]
+          }
         });
         if (existingEnt) {
           if (existingEnt.deleteTime) {
@@ -2135,7 +2701,8 @@ var CrudBase = class {
       await flush();
       return result;
     };
-    const res = await (options.repo ? op(options.repo) : this.repo.manager.transaction(
+    const hasActiveTx = !!this.repo.manager.queryRunner?.isTransactionActive;
+    const res = await (options.repo ? op(options.repo) : hasActiveTx ? op(this.repo) : this.repo.manager.transaction(
       (tdb) => op(tdb.getRepository(this.entityClass))
     ));
     return res == null ? new BlankReturnMessageDto2(200, "success") : new GenericReturnMessageDto(200, "success", res);
@@ -3099,6 +3666,195 @@ var applyQueryMatchBooleanMySQL = createQueryCondition(
     }
   }
 );
+
+// src/transactional-typeorm.module.ts
+var import_typeorm8 = __toESM(require_typeorm());
+import { EntityManager } from "typeorm";
+import {
+  Inject as Inject2,
+  Injectable,
+  Module,
+  Scope
+} from "@nestjs/common";
+import { createProvider } from "nesties";
+import { REQUEST } from "@nestjs/core";
+
+// src/utility/create-dynamic-fetcher-proxy.ts
+var createDynamicFetcherProxy = (initial, fetcher) => {
+  return new Proxy(initial, {
+    get(_target, prop, receiver) {
+      const current = fetcher();
+      const value = Reflect.get(current, prop, receiver);
+      if (typeof value === "function") {
+        return value.bind(current);
+      }
+      return value;
+    },
+    set(_target, prop, value, receiver) {
+      const current = fetcher();
+      return Reflect.set(current, prop, value, receiver);
+    },
+    has(_target, prop) {
+      const current = fetcher();
+      return Reflect.has(current, prop);
+    },
+    ownKeys(_target) {
+      const current = fetcher();
+      return Reflect.ownKeys(current);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      const current = fetcher();
+      return Reflect.getOwnPropertyDescriptor(current, prop);
+    },
+    defineProperty(_target, prop, descriptor) {
+      const current = fetcher();
+      return Reflect.defineProperty(current, prop, descriptor);
+    },
+    deleteProperty(_target, prop) {
+      const current = fetcher();
+      return Reflect.deleteProperty(current, prop);
+    }
+  });
+};
+
+// src/utility/create-inject-from-token-factory.ts
+import { Inject } from "@nestjs/common";
+var createInjectFromTokenFactory = (factory) => (...params) => Inject(factory(...params));
+
+// src/transactional-typeorm.module.ts
+import { Observable } from "rxjs";
+var requestWeakMap = /* @__PURE__ */ new WeakMap();
+var normalizeDataSourceToken = (token) => typeof token === "string" ? token : token.name || token.toString();
+var TransactionalTypeOrmInterceptor = (dataSource) => {
+  const token = (0, import_typeorm8.getEntityManagerToken)(dataSource);
+  const interceptorClass = class SpecificTransactionalTypeOrmInterceptor {
+    constructor(entityManager) {
+      this.entityManager = entityManager;
+    }
+    intercept(context, next) {
+      const request = context.switchToHttp().getRequest();
+      return new Observable((observer) => {
+        let innerSub = null;
+        let finished = false;
+        let abort;
+        const aborted = new Promise((_6, reject) => {
+          abort = reject;
+        });
+        const run = this.entityManager.transaction(async (txEm) => {
+          requestWeakMap.set(request, txEm);
+          const completion = new Promise((resolve, reject) => {
+            innerSub = next.handle().subscribe({
+              next: (v) => observer.next(v),
+              error: (err) => {
+                finished = true;
+                observer.error(err);
+                reject(err);
+              },
+              complete: () => {
+                finished = true;
+                observer.complete();
+                resolve();
+              }
+            });
+          });
+          await Promise.race([completion, aborted]);
+        }).finally(() => {
+          requestWeakMap.delete(request);
+        }).catch((err) => {
+          if (!finished) observer.error(err);
+        });
+        return () => {
+          try {
+            innerSub?.unsubscribe();
+          } finally {
+            if (!finished) {
+              abort(new Error("Request aborted / subscription unsubscribed"));
+            }
+          }
+        };
+      });
+    }
+  };
+  Object.defineProperty(interceptorClass, "name", {
+    value: `TransactionalTypeOrmInterceptor_${normalizeDataSourceToken(token)}`
+  });
+  Reflect.defineMetadata(
+    "design:paramtypes",
+    [EntityManager],
+    interceptorClass
+  );
+  Inject2(token)(interceptorClass.prototype, void 0, 0);
+  Injectable()(interceptorClass);
+  return interceptorClass;
+};
+var getTransactionalEntityManagerToken = (dataSource) => `Transactional${normalizeDataSourceToken((0, import_typeorm8.getEntityManagerToken)(dataSource))}`;
+var getTransactionalEntityManagerProvider = (dataSource) => createProvider(
+  {
+    provide: getTransactionalEntityManagerToken(dataSource),
+    inject: [(0, import_typeorm8.getEntityManagerToken)(dataSource), REQUEST],
+    scope: Scope.REQUEST
+  },
+  (entityManager, request) => {
+    if (requestWeakMap.has(request)) {
+      return requestWeakMap.get(request);
+    }
+    return createDynamicFetcherProxy(
+      entityManager,
+      () => requestWeakMap.get(request) || entityManager
+    );
+  }
+);
+var InjectTransactionalEntityManager = createInjectFromTokenFactory(
+  getTransactionalEntityManagerToken
+);
+var getTransactionalRepositoryToken = (entity, dataSource) => `Transactional${normalizeDataSourceToken(
+  (0, import_typeorm8.getEntityManagerToken)(dataSource)
+)}Repository_${entity.name || entity.toString()}`;
+var getTransactionalRepositoryProvider = (entity, dataSource) => createProvider(
+  {
+    provide: getTransactionalRepositoryToken(entity, dataSource),
+    inject: [(0, import_typeorm8.getEntityManagerToken)(dataSource), REQUEST],
+    scope: Scope.REQUEST
+  },
+  (entityManager, req) => {
+    if (requestWeakMap.has(req)) {
+      const transactionalEntityManager = requestWeakMap.get(req);
+      return transactionalEntityManager.getRepository(entity);
+    }
+    return createDynamicFetcherProxy(
+      entityManager.getRepository(entity),
+      () => {
+        const transactionalEntityManager = requestWeakMap.get(req) || entityManager;
+        return transactionalEntityManager.getRepository(entity);
+      }
+    );
+  }
+);
+var InjectTransactionalRepository = createInjectFromTokenFactory(
+  getTransactionalRepositoryToken
+);
+var TransactionalTypeOrmModule = class {
+  static forFeature(entities, dataSource) {
+    const entityArray = Array.isArray(entities) ? entities : [entities];
+    const providers = [
+      getTransactionalEntityManagerProvider(dataSource),
+      ...entityArray.map(
+        (entity) => getTransactionalRepositoryProvider(entity, dataSource)
+      )
+    ];
+    const moduleImports = entityArray.length ? [import_typeorm8.TypeOrmModule.forFeature(entityArray, dataSource)] : [];
+    const moduleExports = [...providers, ...moduleImports];
+    return {
+      module: TransactionalTypeOrmModule,
+      imports: moduleImports,
+      providers,
+      exports: moduleExports
+    };
+  }
+};
+TransactionalTypeOrmModule = __decorateClass([
+  Module({})
+], TransactionalTypeOrmModule);
 export {
   BindingColumn,
   BindingValue,
@@ -3127,6 +3883,8 @@ export {
   ImportDataDto,
   ImportEntryBaseDto,
   ImportEntryDto,
+  InjectTransactionalEntityManager,
+  InjectTransactionalRepository,
   Inner,
   IntColumn,
   InternalColumn,
@@ -3174,6 +3932,8 @@ export {
   StringJsonColumn,
   TextColumn,
   TimeBase,
+  TransactionalTypeOrmInterceptor,
+  TransactionalTypeOrmModule,
   UuidColumn,
   applyQueryMatchBoolean,
   applyQueryMatchBooleanMySQL,
@@ -3186,6 +3946,10 @@ export {
   createQueryCondition,
   createQueryOperator,
   createQueryOperatorArrayify,
-  createQueryWrap
+  createQueryWrap,
+  getTransactionalEntityManagerProvider,
+  getTransactionalEntityManagerToken,
+  getTransactionalRepositoryProvider,
+  getTransactionalRepositoryToken
 };
 //# sourceMappingURL=index.mjs.map