nicot 1.2.12 → 1.3.0

package/dist/index.cjs

@@ -4,6 +4,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -35,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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DEFAULT_DATA_SOURCE_NAME = exports2.TYPEORM_MODULE_ID = exports2.TYPEORM_MODULE_OPTIONS = void 0;
+    exports2.TYPEORM_MODULE_OPTIONS = "TypeOrmModuleOptions";
+    exports2.TYPEORM_MODULE_ID = "TypeOrmModuleId";
+    exports2.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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.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.`);
+      }
+    };
+    exports2.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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.generateString = exports2.getConnectionToken = void 0;
+    exports2.getRepositoryToken = getRepositoryToken;
+    exports2.getCustomRepositoryToken = getCustomRepositoryToken;
+    exports2.getDataSourceToken = getDataSourceToken;
+    exports2.getDataSourcePrefix = getDataSourcePrefix;
+    exports2.getEntityManagerToken = getEntityManagerToken2;
+    exports2.handleRetry = handleRetry;
+    exports2.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`;
+    }
+    exports2.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();
+    exports2.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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.InjectEntityManager = exports2.InjectConnection = exports2.InjectDataSource = exports2.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));
+    exports2.InjectRepository = InjectRepository;
+    var InjectDataSource = (dataSource) => (0, common_1.Inject)((0, typeorm_utils_1.getDataSourceToken)(dataSource));
+    exports2.InjectDataSource = InjectDataSource;
+    exports2.InjectConnection = exports2.InjectDataSource;
+    var InjectEntityManager = (dataSource) => (0, common_1.Inject)((0, typeorm_utils_1.getEntityManagerToken)(dataSource));
+    exports2.InjectEntityManager = InjectEntityManager;
+  }
+});
+
+// node_modules/@nestjs/typeorm/dist/common/index.js
+var require_common = __commonJS({
+  "node_modules/@nestjs/typeorm/dist/common/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__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 = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_typeorm_decorators(), exports2);
+    __exportStar(require_typeorm_utils(), exports2);
+  }
+});
+
+// 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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// node_modules/@nestjs/typeorm/dist/interfaces/index.js
+var require_interfaces = __commonJS({
+  "node_modules/@nestjs/typeorm/dist/interfaces/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__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 = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_typeorm_options_interface(), exports2);
+  }
+});
+
+// node_modules/@nestjs/typeorm/dist/entities-metadata.storage.js
+var require_entities_metadata_storage = __commonJS({
+  "node_modules/@nestjs/typeorm/dist/entities-metadata.storage.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.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) || [];
+      }
+    };
+    exports2.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"(exports2) {
+    "use strict";
+    var __decorate = exports2 && exports2.__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 = exports2 && exports2.__metadata || function(k, v) {
+      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+    };
+    var __param = exports2 && exports2.__param || function(paramIndex, decorator) {
+      return function(target, key) {
+        decorator(target, key, paramIndex);
+      };
+    };
+    var TypeOrmCoreModule_1;
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.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 exports3 = [entityManagerProvider, dataSourceProvider];
+        if (dataSourceProvider.provide === typeorm_1.DataSource) {
+          providers.push({
+            provide: typeorm_1.Connection,
+            useExisting: typeorm_1.DataSource
+          });
+          exports3.push(typeorm_1.Connection);
+        }
+        return {
+          module: TypeOrmCoreModule_1,
+          providers,
+          exports: exports3
+        };
+      }
+      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 exports3 = [
+          entityManagerProvider,
+          dataSourceProvider
+        ];
+        if (dataSourceProvider.provide === typeorm_1.DataSource) {
+          providers.push({
+            provide: typeorm_1.Connection,
+            useExisting: typeorm_1.DataSource
+          });
+          exports3.push(typeorm_1.Connection);
+        }
+        return {
+          module: TypeOrmCoreModule_1,
+          imports: options.imports,
+          providers,
+          exports: exports3
+        };
+      }
+      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)));
+      }
+    };
+    exports2.TypeOrmCoreModule = TypeOrmCoreModule;
+    exports2.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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.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"(exports2) {
+    "use strict";
+    var __decorate = exports2 && exports2.__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(exports2, "__esModule", { value: true });
+    exports2.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)]
+        };
+      }
+    };
+    exports2.TypeOrmModule = TypeOrmModule2;
+    exports2.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"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__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 = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_common(), exports2);
+    __exportStar(require_interfaces(), exports2);
+    __exportStar(require_typeorm_module(), exports2);
+  }
+});
+
+// node_modules/@nestjs/typeorm/index.js
+var require_typeorm = __commonJS({
+  "node_modules/@nestjs/typeorm/index.js"(exports2) {
+    "use strict";
+    function __export2(m) {
+      for (var p in m) if (!exports2.hasOwnProperty(p)) exports2[p] = m[p];
+    }
+    exports2.__esModule = true;
+    __export2(require_dist());
+  }
+});
+
 // index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -65,6 +601,8 @@ __export(index_exports, {
   ImportDataDto: () => ImportDataDto,
   ImportEntryBaseDto: () => ImportEntryBaseDto,
   ImportEntryDto: () => ImportEntryDto,
+  InjectTransactionalEntityManager: () => InjectTransactionalEntityManager,
+  InjectTransactionalRepository: () => InjectTransactionalRepository,
   Inner: () => Inner,
   IntColumn: () => IntColumn,
   InternalColumn: () => InternalColumn,
@@ -74,6 +612,7 @@ __export(index_exports, {
   NotCreatable: () => NotCreatable,
   NotInResult: () => NotInResult,
   NotQueryable: () => NotQueryable,
+  NotUpsertable: () => NotUpsertable,
   NotWritable: () => NotWritable,
   OmitPipe: () => OmitPipe,
   OptionalDataPipe: () => OptionalDataPipe,
@@ -112,6 +651,10 @@ __export(index_exports, {
   StringJsonColumn: () => StringJsonColumn,
   TextColumn: () => TextColumn,
   TimeBase: () => TimeBase,
+  TransactionalTypeOrmInterceptor: () => TransactionalTypeOrmInterceptor,
+  TransactionalTypeOrmModule: () => TransactionalTypeOrmModule,
+  UpsertColumn: () => UpsertColumn,
+  UpsertableEntity: () => UpsertableEntity,
   UuidColumn: () => UuidColumn,
   applyQueryMatchBoolean: () => applyQueryMatchBoolean,
   applyQueryMatchBooleanMySQL: () => applyQueryMatchBooleanMySQL,
@@ -124,7 +667,11 @@ __export(index_exports, {
   createQueryCondition: () => createQueryCondition,
   createQueryOperator: () => createQueryOperator,
   createQueryOperatorArrayify: () => createQueryOperatorArrayify,
-  createQueryWrap: () => createQueryWrap
+  createQueryWrap: () => createQueryWrap,
+  getTransactionalEntityManagerProvider: () => getTransactionalEntityManagerProvider,
+  getTransactionalEntityManagerToken: () => getTransactionalEntityManagerToken,
+  getTransactionalRepositoryProvider: () => getTransactionalRepositoryProvider,
+  getTransactionalRepositoryToken: () => getTransactionalRepositoryToken
 });
 module.exports = __toCommonJS(index_exports);
 __reExport(index_exports, require("nesties"), module.exports);
@@ -175,6 +722,7 @@ var import_class_validator2 = require("class-validator");
 
 // src/utility/metadata.ts
 var import_typed_reflector = require("typed-reflector");
+var import_lodash = __toESM(require("lodash"));
 var Metadata = new import_typed_reflector.MetadataSetter();
 var reflector = new import_typed_reflector.Reflector();
 function getSpecificFields(obj, type, filter = () => true) {
@@ -187,11 +735,11 @@ function getSpecificFields(obj, type, filter = () => true) {
   });
 }
 function getNotInResultFields(obj, keepEntityVersioningDates = false) {
-  return getSpecificFields(
-    obj,
-    "notInResult",
-    (meta) => !keepEntityVersioningDates || !meta.entityVersioningDate
-  );
+  const res = getSpecificFields(obj, "notInResult");
+  if (keepEntityVersioningDates) {
+    return import_lodash.default.difference(res, getSpecificFields(obj, "entityVersioningDate"));
+  }
+  return res;
 }
 
 // src/decorators/access.ts
@@ -207,8 +755,12 @@ var NotCreatable = () => (0, import_nesties2.MergePropertyDecorators)([
 var NotChangeable = () => (0, import_nesties2.MergePropertyDecorators)([
   Metadata.set("notChangeable", true, "notChangeableFields")
 ]);
+var NotUpsertable = () => (0, import_nesties2.MergePropertyDecorators)([
+  (0, import_class_validator2.IsOptional)(),
+  Metadata.set("notUpsertable", true, "notUpsertableFields")
+]);
 var NotQueryable = () => Metadata.set("notQueryable", true, "notQueryableFields");
-var NotInResult = (options = {}) => Metadata.set("notInResult", options, "notInResultFields");
+var NotInResult = () => Metadata.set("notInResult", true, "notInResultFields");
 
 // src/decorators/property.ts
 var import_swagger2 = require("@nestjs/swagger");
@@ -890,6 +1442,24 @@ var BindingValue = (bindingKey = DefaultBindingKey) => (obj, key, des) => {
   )(obj, key);
 };
 
+// src/decorators/upsert.ts
+var import_typeorm3 = require("typeorm");
+var UpsertColumn = () => Metadata.set("upsertColumn", true, "upsertColumnFields");
+var UpsertableEntity = () => (cls) => {
+  const upsertColumns = getSpecificFields(cls, "upsertColumn");
+  const bindingColumns = getSpecificFields(cls, "bindingColumn");
+  if (!upsertColumns.length && !bindingColumns.length) {
+    throw new Error(
+      `UpsertableEntity ${cls.name} must have at least one UpsertColumn or BindingColumn defined.`
+    );
+  }
+  Metadata.set("upsertableEntity", true)(cls);
+  if (!bindingColumns.length && upsertColumns.length === 1 && upsertColumns[0] === "id") {
+    return;
+  }
+  (0, import_typeorm3.Unique)([.../* @__PURE__ */ new Set([...bindingColumns, ...upsertColumns])])(cls);
+};
+
 // src/dto/cursor-pagination.ts
 var CursorPaginationDto = class {
 };
@@ -963,10 +1533,10 @@ function CursorPaginationReturnMessageDto(type) {
 }
 
 // src/crud-base.ts
-var import_typeorm7 = require("typeorm");
+var import_typeorm8 = require("typeorm");
 
 // src/bases/time-base.ts
-var import_typeorm3 = require("typeorm");
+var import_typeorm4 = require("typeorm");
 
 // src/bases/page-settings.ts
 var import_class_validator5 = require("class-validator");
@@ -1021,6 +1591,7 @@ __decorateClass([
 ], PageSettingsDto.prototype, "recordsPerPage", 2);
 
 // src/bases/time-base.ts
+var EntityVersioningDate = () => Metadata.set("entityVersioningDate", true, "entityVersioningDateFields");
 var TimeBase = class extends PageSettingsDto {
   isValidInCreate() {
     return;
@@ -1043,28 +1614,40 @@ var TimeBase = class extends PageSettingsDto {
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   async beforeUpdate() {
   }
+  isValidInUpsert() {
+    return;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async beforeUpsert() {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async afterUpsert() {
+  }
 };
 __decorateClass([
-  (0, import_typeorm3.CreateDateColumn)({ select: false }),
+  (0, import_typeorm4.CreateDateColumn)({ select: false }),
   NotColumn(),
-  NotInResult({ entityVersioningDate: true }),
+  NotInResult(),
+  EntityVersioningDate(),
   Reflect.metadata("design:type", Date)
 ], TimeBase.prototype, "createTime", 2);
 __decorateClass([
-  (0, import_typeorm3.UpdateDateColumn)({ select: false }),
+  (0, import_typeorm4.UpdateDateColumn)({ select: false }),
   NotColumn(),
-  NotInResult({ entityVersioningDate: true }),
+  NotInResult(),
+  EntityVersioningDate(),
   Reflect.metadata("design:type", Date)
 ], TimeBase.prototype, "updateTime", 2);
 __decorateClass([
-  (0, import_typeorm3.DeleteDateColumn)({ select: false }),
+  (0, import_typeorm4.DeleteDateColumn)({ select: false }),
   NotColumn(),
-  NotInResult({ entityVersioningDate: true }),
+  NotInResult(),
+  EntityVersioningDate(),
   Reflect.metadata("design:type", Date)
 ], TimeBase.prototype, "deleteTime", 2);
 
 // src/bases/id-base.ts
-var import_typeorm4 = require("typeorm");
+var import_typeorm5 = require("typeorm");
 var import_class_validator6 = require("class-validator");
 var import_nesties7 = require("nesties");
 function IdBase(idOptions = {}) {
@@ -1084,7 +1667,7 @@ function IdBase(idOptions = {}) {
       columnExtras: { nullable: false, primary: true }
     }),
     Reflect.metadata("design:type", Number),
-    (0, import_typeorm4.Generated)("increment"),
+    (0, import_typeorm5.Generated)("increment"),
     QueryEqual(),
     Metadata.set(
       "notRequiredButHasDefault",
@@ -1120,7 +1703,8 @@ function StringIdBase(idOptions) {
     ...idOptions.uuid ? [UuidColumn({ ...columnOptions, generated: true }), NotWritable()] : [
       StringColumn(idOptions.length || 255, columnOptions),
       (0, import_class_validator6.IsNotEmpty)(),
-      NotChangeable()
+      NotChangeable(),
+      UpsertColumn()
     ]
   ];
   const dec = (0, import_nesties7.MergePropertyDecorators)(decs);
@@ -1131,14 +1715,14 @@ function StringIdBase(idOptions) {
 // src/crud-base.ts
 var import_common2 = require("@nestjs/common");
 var import_StringUtils = require("typeorm/util/StringUtils");
-var import_lodash3 = __toESM(require("lodash"));
+var import_lodash4 = __toESM(require("lodash"));
 var import_nesties8 = require("nesties");
 
 // src/utility/get-typeorm-relations.ts
-var import_typeorm5 = require("typeorm");
-var import_lodash = __toESM(require("lodash"));
+var import_typeorm6 = require("typeorm");
+var import_lodash2 = __toESM(require("lodash"));
 function getTypeormRelations(cl) {
-  const relations = (0, import_typeorm5.getMetadataArgsStorage)().relations.filter(
+  const relations = (0, import_typeorm6.getMetadataArgsStorage)().relations.filter(
     (r) => r.target === cl
   );
   const typeormRelations = relations.map((relation) => {
@@ -1177,7 +1761,7 @@ function getTypeormRelations(cl) {
       };
     }
   );
-  return import_lodash.default.uniqBy(
+  return import_lodash2.default.uniqBy(
     [...typeormRelations, ...computedRelations],
     // Merge typeorm relations and computed relations
     (r) => r.propertyName
@@ -1185,8 +1769,8 @@ function getTypeormRelations(cl) {
 }
 
 // src/utility/cursor-pagination-utils.ts
-var import_typeorm6 = require("typeorm");
-var import_lodash2 = __toESM(require("lodash"));
+var import_typeorm7 = require("typeorm");
+var import_lodash3 = __toESM(require("lodash"));
 var import_superjson = __toESM(require("superjson"));
 
 // src/utility/filter-relations.ts
@@ -1354,7 +1938,7 @@ async function getPaginatedResult(qb, entityClass, entityAliasName, take, cursor
     );
     if (keys.length) {
       const staircasedKeys = keys.map(
-        (key, i) => import_lodash2.default.range(i + 1).map((j) => keys[j])
+        (key, i) => import_lodash3.default.range(i + 1).map((j) => keys[j])
       );
       const cursorKey = (key) => `_cursor_${key.replace(/\./g, "__").replace(/"/g, "")}`;
       const expressionMatrix = staircasedKeys.map(
@@ -1404,8 +1988,8 @@ async function getPaginatedResult(qb, entityClass, entityAliasName, take, cursor
       ).filter((s) => !s.includes("__never__"));
       if (expressionMatrix.length) {
         qb.andWhere(
-          new import_typeorm6.Brackets((sqb) => {
-            const levelToBrackets = (level) => new import_typeorm6.Brackets((qb2) => {
+          new import_typeorm7.Brackets((sqb) => {
+            const levelToBrackets = (level) => new import_typeorm7.Brackets((qb2) => {
               level.forEach((expr, i) => {
                 if (i === 0) {
                   qb2.where(expr);
@@ -1658,22 +2242,30 @@ var CrudBase = class {
     this._restoreBindings(snap);
     return res;
   }
+  async _mayBeTransaction(cb, manager = this.repo.manager) {
+    const hasActiveTx = !!manager.queryRunner?.isTransactionActive;
+    const getRepo = (m) => m.getRepository(this.entityClass);
+    if (hasActiveTx) {
+      return cb(manager, getRepo(manager));
+    } else {
+      return manager.transaction(async (tdb) => await cb(tdb, getRepo(tdb)));
+    }
+  }
   async _batchCreate(ents, beforeCreate, skipErrors = false) {
     const entsWithId = ents.filter((ent) => ent.id != null);
-    return this.repo.manager.transaction(async (mdb) => {
+    return this._mayBeTransaction(async (mdb, repo) => {
       let skipped = [];
-      const repo = mdb.getRepository(this.entityClass);
       let entsToSave = ents;
       if (entsWithId.length) {
         const entIds = entsWithId.map((ent) => ent.id);
-        const entIdChunks = import_lodash3.default.chunk(entIds, 65535);
+        const entIdChunks = import_lodash4.default.chunk(entIds, 65535);
         const existingEnts = (await Promise.all(
           entIdChunks.map(
             (chunk) => repo.find({
               // eslint-disable-next-line @typescript-eslint/ban-ts-comment
               // @ts-ignore
               where: {
-                id: (0, import_typeorm7.In)(chunk)
+                id: (0, import_typeorm8.In)(chunk)
               },
               select: this.crudOptions.createOrUpdate ? void 0 : ["id", "deleteTime"],
               withDeleted: true
@@ -1737,7 +2329,7 @@ var CrudBase = class {
         await beforeCreate(repo);
       }
       try {
-        const entChunksToSave = import_lodash3.default.chunk(
+        const entChunksToSave = import_lodash4.default.chunk(
           entsToSave,
           Math.floor(
             65535 / Math.max(1, Object.keys(entsToSave[0] || {}).length)
@@ -1770,19 +2362,22 @@ var CrudBase = class {
     let ent = new this.entityClass();
     Object.assign(
       ent,
-      (0, import_lodash3.omit)(_ent, ...this._typeormRelations.map((r) => r.propertyName))
+      (0, import_lodash4.omit)(_ent, ...this._typeormRelations.map((r) => r.propertyName))
     );
     const invalidReason = ent.isValidInCreate();
     if (invalidReason) {
       throw new import_nesties8.BlankReturnMessageDto(400, invalidReason).toException();
     }
-    const savedEnt = await this.repo.manager.transaction(async (mdb) => {
-      const repo = mdb.getRepository(this.entityClass);
+    const savedEnt = await this._mayBeTransaction(async (mdb, repo) => {
       if (ent.id != null) {
         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) {
@@ -1872,12 +2467,24 @@ var CrudBase = class {
       });
     }
   }
+  _applyQueryKeepEntityVersioningDates(qb) {
+    if (this.crudOptions.keepEntityVersioningDates) {
+      const versioningDateFields = getSpecificFields(
+        this.entityClass,
+        "entityVersioningDate"
+      );
+      for (const field of versioningDateFields) {
+        qb.addSelect(`${this.entityAliasName}.${field}`);
+      }
+    }
+  }
   async findOne(id, extraQuery = () => {
   }) {
     const bindingEnt = await this.getBindingPartialEntity();
     const query = this.queryBuilder().where(`${this.entityAliasName}.id = :id`, { id }).take(1);
     this._applyQueryRelations(query);
     this._applyQueryFromBinding(bindingEnt, query);
+    this._applyQueryKeepEntityVersioningDates(query);
     this.extraGetQuery(query);
     extraQuery(query);
     query.take(1);
@@ -1919,6 +2526,7 @@ var CrudBase = class {
     this._applyQueryRelations(query);
     this._applyQueryFilters(query, newEnt);
     this._applyQueryFromBinding(bindingEnt, query);
+    this._applyQueryKeepEntityVersioningDates(query);
     const pageSettings = newEnt instanceof PageSettingsDto ? newEnt : Object.assign(new PageSettingsDto(), newEnt);
     this.extraGetQuery(query);
     extraQuery(query);
@@ -2011,6 +2619,116 @@ var CrudBase = class {
     }
     return new import_nesties8.BlankReturnMessageDto(200, "success");
   }
+  async upsert(_ent) {
+    const bindingEnt = await this.getBindingPartialEntity();
+    if (!_ent) {
+      throw new import_nesties8.BlankReturnMessageDto(400, "Invalid entity").toException();
+    }
+    const ent = new this.entityClass();
+    Object.assign(
+      ent,
+      (0, import_lodash4.omit)(_ent, ...this._typeormRelations.map((r) => r.propertyName))
+    );
+    const invalidReason = ent.isValidInUpsert();
+    if (invalidReason) {
+      throw new import_nesties8.BlankReturnMessageDto(400, invalidReason).toException();
+    }
+    const upsertColumns = getSpecificFields(this.entityClass, "upsertColumn");
+    const conditions = {
+      ...import_lodash4.default.pick(ent, upsertColumns),
+      ...bindingEnt
+    };
+    const conditionKeys = [
+      .../* @__PURE__ */ new Set([
+        ...getSpecificFields(this.entityClass, "bindingColumn"),
+        ...upsertColumns
+      ])
+    ];
+    Object.assign(ent, conditions);
+    let deleteColumnProperty = "";
+    if (!this.crudOptions.hardDelete) {
+      const deleteColumn = this.repo.manager.connection.getMetadata(
+        this.entityClass
+      ).deleteDateColumn;
+      if (deleteColumn) {
+        ent[deleteColumn.propertyName] = null;
+        deleteColumnProperty = deleteColumn.propertyName;
+      }
+    }
+    await ent.beforeUpsert?.();
+    try {
+      const savedEnt = await this._mayBeTransaction(async (mdb, repo) => {
+        const res = await repo.upsert(ent, {
+          conflictPaths: conditionKeys
+        });
+        const insertedId = res.identifiers[0]?.id;
+        const fetchSaved = () => {
+          const qb = repo.createQueryBuilder(this.entityAliasName);
+          if (insertedId != null) {
+            qb.where(`${this.entityAliasName}.id = :id`, { id: insertedId });
+          } else {
+            conditionKeys.forEach((key, i) => {
+              const paramKey = `_cond_${key}`;
+              qb[i === 0 ? "where" : "andWhere"](
+                `${this.entityAliasName}.${key} = :${paramKey}`,
+                {
+                  [paramKey]: conditions[key]
+                }
+              );
+            });
+          }
+          qb.take(1);
+          if (deleteColumnProperty) {
+            if (!this.crudOptions.keepEntityVersioningDates) {
+              qb.addSelect(`${this.entityAliasName}.${deleteColumnProperty}`);
+            }
+            qb.withDeleted();
+          }
+          this._applyQueryKeepEntityVersioningDates(qb);
+          if (this.crudOptions.upsertIncludeRelations) {
+            this._applyQueryRelations(qb);
+          }
+          return qb.getOne();
+        };
+        let saved = await fetchSaved();
+        if (!saved) {
+          this.log.error(
+            `Failed to upsert entity ${JSON.stringify(
+              ent
+            )}: cannot find saved entity after upsert.`
+          );
+          throw new import_nesties8.BlankReturnMessageDto(500, "Internal error").toException();
+        }
+        if (deleteColumnProperty && saved[deleteColumnProperty]) {
+          await repo.restore(insertedId ? { id: insertedId } : conditions);
+          saved = await fetchSaved();
+          if (!saved || saved[deleteColumnProperty]) {
+            this.log.error(
+              `Failed to upsert entity ${JSON.stringify(
+                ent
+              )}: cannot restore soft-deleted entity after upsert.`
+            );
+            throw new import_nesties8.BlankReturnMessageDto(
+              500,
+              "Internal error"
+            ).toException();
+          }
+        }
+        return saved;
+      });
+      await savedEnt.afterUpsert?.();
+      this.cleanEntityNotInResultFields(savedEnt);
+      return new this.entityReturnMessageDto(200, "success", savedEnt);
+    } catch (e) {
+      if (e instanceof import_common2.HttpException) {
+        throw e;
+      }
+      this.log.error(
+        `Failed to upsert entity ${JSON.stringify(ent)}: ${e.toString()}`
+      );
+      throw new import_nesties8.BlankReturnMessageDto(500, "Internal error").toException();
+    }
+  }
   async delete(id, cond = {}) {
     const bindingEnt = await this.getBindingPartialEntity();
     let result;
@@ -2039,11 +2757,11 @@ var CrudBase = class {
       const newEnt = new this.entityClass();
       Object.assign(
         newEnt,
-        (0, import_lodash3.omit)(ent, ...this._typeormRelations.map((r) => r.propertyName))
+        (0, import_lodash4.omit)(ent, ...this._typeormRelations.map((r) => r.propertyName))
       );
       return newEnt;
     });
-    const invalidResults = import_lodash3.default.compact(
+    const invalidResults = import_lodash4.default.compact(
       await Promise.all(
         ents.map(async (ent) => {
           const reason = ent.isValidInCreate();
@@ -2216,9 +2934,10 @@ var CrudBase = class {
       await flush();
       return result;
     };
-    const res = await (options.repo ? op(options.repo) : this.repo.manager.transaction(
-      (tdb) => op(tdb.getRepository(this.entityClass))
-    ));
+    const res = await this._mayBeTransaction(
+      (tdb, repo) => op(repo),
+      options.repo?.manager || this.repo.manager
+    );
     return res == null ? new import_nesties8.BlankReturnMessageDto(200, "success") : new import_nesties8.GenericReturnMessageDto(200, "success", res);
   }
   async _loadFullTextIndex() {
@@ -2272,7 +2991,7 @@ function CrudService(entityClass, crudOptions = {}) {
 var import_common3 = require("@nestjs/common");
 var import_nesties10 = require("nesties");
 var import_swagger6 = require("@nestjs/swagger");
-var import_lodash5 = __toESM(require("lodash"));
+var import_lodash6 = __toESM(require("lodash"));
 var import_nesties11 = require("nesties");
 
 // src/bases/base-restful-controller.ts
@@ -2281,6 +3000,7 @@ var RestfulMethods = [
   "findAll",
   "create",
   "update",
+  "upsert",
   "delete",
   "import"
 ];
@@ -2315,6 +3035,9 @@ var BaseRestfulController = class {
   update(id, dto) {
     return this._service.update(id, dto);
   }
+  upsert(dto) {
+    return this._service.upsert(dto);
+  }
   delete(id) {
     return this._service.delete(id);
   }
@@ -2346,7 +3069,7 @@ var PickTypeExpose = (cl, keys) => {
 
 // src/utility/patch-column-in-get.ts
 var import_nesties9 = require("nesties");
-var import_lodash4 = __toESM(require("lodash"));
+var import_lodash5 = __toESM(require("lodash"));
 var import_constants = require("@nestjs/swagger/dist/constants");
 var PatchColumnsInGet = (cl, originalCl = cl, fieldsToOmit = []) => {
   const omit2 = new Set(fieldsToOmit);
@@ -2372,7 +3095,7 @@ var PatchColumnsInGet = (cl, originalCl = cl, fieldsToOmit = []) => {
       field
     );
   }
-  const queryableFieldsRemaining = import_lodash4.default.difference(
+  const queryableFieldsRemaining = import_lodash5.default.difference(
     getSpecificFields(useCl, "queryCondition"),
     mutateFields
   );
@@ -2433,7 +3156,7 @@ var _RestfulFactory = class _RestfulFactory {
       this.entityClass,
       {
         ...this.options,
-        fieldsToOmit: import_lodash5.default.uniq([...this.options.fieldsToOmit || [], ...fields])
+        fieldsToOmit: import_lodash6.default.uniq([...this.options.fieldsToOmit || [], ...fields])
       },
       this.__resolveVisited
     );
@@ -2443,7 +3166,7 @@ var _RestfulFactory = class _RestfulFactory {
       this.entityClass,
       {
         ...this.options,
-        writeFieldsToOmit: import_lodash5.default.uniq([
+        writeFieldsToOmit: import_lodash6.default.uniq([
           ...this.options.writeFieldsToOmit || [],
           ...fields
         ])
@@ -2456,7 +3179,7 @@ var _RestfulFactory = class _RestfulFactory {
       this.entityClass,
       {
         ...this.options,
-        createFieldsToOmit: import_lodash5.default.uniq([
+        createFieldsToOmit: import_lodash6.default.uniq([
           ...this.options.createFieldsToOmit || [],
           ...fields
         ])
@@ -2469,7 +3192,7 @@ var _RestfulFactory = class _RestfulFactory {
       this.entityClass,
       {
         ...this.options,
-        updateFieldsToOmit: import_lodash5.default.uniq([
+        updateFieldsToOmit: import_lodash6.default.uniq([
           ...this.options.updateFieldsToOmit || [],
           ...fields
         ])
@@ -2477,12 +3200,25 @@ var _RestfulFactory = class _RestfulFactory {
       this.__resolveVisited
     );
   }
+  omitUpsert(...fields) {
+    return new _RestfulFactory(
+      this.entityClass,
+      {
+        ...this.options,
+        upsertFieldsToOmit: import_lodash6.default.uniq([
+          ...this.options.upsertFieldsToOmit || [],
+          ...fields
+        ])
+      },
+      this.__resolveVisited
+    );
+  }
   omitFindAll(...fields) {
     return new _RestfulFactory(
       this.entityClass,
       {
         ...this.options,
-        findAllFieldsToOmit: import_lodash5.default.uniq([
+        findAllFieldsToOmit: import_lodash6.default.uniq([
           ...this.options.findAllFieldsToOmit || [],
           ...fields
         ])
@@ -2495,7 +3231,7 @@ var _RestfulFactory = class _RestfulFactory {
       this.entityClass,
       {
         ...this.options,
-        outputFieldsToOmit: import_lodash5.default.uniq([
+        outputFieldsToOmit: import_lodash6.default.uniq([
           ...this.options.outputFieldsToOmit || [],
           ...fields
         ])
@@ -2557,7 +3293,7 @@ var _RestfulFactory = class _RestfulFactory {
     return this.options.entityClassName || this.entityClass.name;
   }
   get fieldsToOmit() {
-    return import_lodash5.default.uniq([
+    return import_lodash6.default.uniq([
       ...getSpecificFields(this.entityClass, "notColumn"),
       ...this.options.fieldsToOmit || [],
       ...getTypeormRelations(this.entityClass).map(
@@ -2566,7 +3302,7 @@ var _RestfulFactory = class _RestfulFactory {
     ]);
   }
   get fieldsInCreateToOmit() {
-    return import_lodash5.default.uniq([
+    return import_lodash6.default.uniq([
       ...this.fieldsToOmit,
       ...this.options.writeFieldsToOmit || [],
       ...this.options.createFieldsToOmit || [],
@@ -2581,7 +3317,7 @@ var _RestfulFactory = class _RestfulFactory {
     );
   }
   get fieldsInUpdateToOmit() {
-    return import_lodash5.default.uniq([
+    return import_lodash6.default.uniq([
       ...this.fieldsToOmit,
       ...this.options.writeFieldsToOmit || [],
       ...this.options.updateFieldsToOmit || [],
@@ -2595,21 +3331,36 @@ var _RestfulFactory = class _RestfulFactory {
       `Update${this.entityClassName}Dto`
     );
   }
+  get fieldsInUpsertToOmit() {
+    return import_lodash6.default.uniq([
+      ...this.fieldsToOmit,
+      ...this.options.writeFieldsToOmit || [],
+      ...this.options.upsertFieldsToOmit || [],
+      ...getSpecificFields(this.entityClass, "notWritable"),
+      ...getSpecificFields(this.entityClass, "notUpsertable")
+    ]);
+  }
+  get upsertDto() {
+    return (0, import_nesties11.RenameClass)(
+      OmitTypeExclude(this.entityClass, this.fieldsInUpsertToOmit),
+      `Upsert${this.entityClassName}Dto`
+    );
+  }
   get importDto() {
     return ImportDataDto(this.createDto);
   }
   get fieldsInGetToOmit() {
-    return import_lodash5.default.uniq([
+    return import_lodash6.default.uniq([
       ...this.fieldsToOmit,
       ...getSpecificFields(this.entityClass, "notQueryable"),
-      ...import_lodash5.default.difference(
+      ...import_lodash6.default.difference(
         getSpecificFields(this.entityClass, "requireGetMutator"),
         getSpecificFields(this.entityClass, "getMutator")
       )
     ]);
   }
   get queryableFields() {
-    return import_lodash5.default.difference(
+    return import_lodash6.default.difference(
       [
         ...getSpecificFields(this.entityClass, "queryCondition"),
         "pageCount",
@@ -2687,7 +3438,7 @@ var _RestfulFactory = class _RestfulFactory {
         const relationFactory = new _RestfulFactory(
           relation.propertyClass,
           {
-            entityClassName: `${this.entityClassName}${this.options.relations ? (0, import_lodash5.upperFirst)(relation.propertyName) : relation.propertyClass.name}`,
+            entityClassName: `${this.entityClassName}${this.options.relations ? (0, import_lodash6.upperFirst)(relation.propertyName) : relation.propertyClass.name}`,
             relations: this.options.relations && getNextLevelRelations(
               this.options.relations.map(extractRelationName),
               relation.propertyName
@@ -2741,6 +3492,21 @@ var _RestfulFactory = class _RestfulFactory {
       `${this.entityClassName}CreateResultDto`
     );
   }
+  get entityUpsertResultDto() {
+    return (0, import_nesties11.RenameClass)(
+      (0, import_swagger6.OmitType)(this.entityResultDto, [
+        ...this.options.upsertIncludeRelations ? [] : getTypeormRelations(this.entityClass).map(
+          (r) => r.propertyName
+        ),
+        ...getSpecificFields(
+          this.entityClass,
+          "notColumn",
+          (m) => m.hideInUpsert
+        )
+      ]),
+      `${this.entityClassName}UpsertResultDto`
+    );
+  }
   get entityReturnMessageDto() {
     return (0, import_nesties10.ReturnMessageDto)(this.entityResultDto);
   }
@@ -2776,7 +3542,7 @@ var _RestfulFactory = class _RestfulFactory {
       (0, import_common3.HttpCode)(200),
       (0, import_swagger6.ApiOperation)({
         summary: `Create a new ${this.entityClassName}`,
-        ...import_lodash5.default.omit(extras, "prefix")
+        ...import_lodash6.default.omit(extras, "prefix")
       }),
       (0, import_swagger6.ApiBody)({ type: this.createDto }),
       (0, import_swagger6.ApiOkResponse)({ type: this.entityCreateReturnMessageDto }),
@@ -2786,12 +3552,36 @@ var _RestfulFactory = class _RestfulFactory {
   createParam() {
     return (0, import_common3.Body)((0, import_nesties10.DataPipe)(), OmitPipe(this.fieldsInCreateToOmit));
   }
+  isUpsertable() {
+    return !!reflector.get("upsertableEntity", this.entityClass);
+  }
+  upsert(extras = {}) {
+    if (!this.isUpsertable()) {
+      throw new Error(
+        `Entity ${this.entityClass.name} is not upsertable. Please define at least one UpsertColumn or BindingColumn, and set @UpsertableEntity() decorator.`
+      );
+    }
+    return (0, import_nesties10.MergeMethodDecorators)([
+      this.usePrefix(import_common3.Put, extras.prefix),
+      (0, import_common3.HttpCode)(200),
+      (0, import_swagger6.ApiOperation)({
+        summary: `Upsert a ${this.entityClassName}`,
+        ...import_lodash6.default.omit(extras, "prefix")
+      }),
+      (0, import_swagger6.ApiBody)({ type: this.upsertDto }),
+      (0, import_swagger6.ApiOkResponse)({ type: this.entityUpsertResultDto }),
+      (0, import_nesties10.ApiError)(400, `The ${this.entityClassName} is not valid`)
+    ]);
+  }
+  upsertParam() {
+    return (0, import_common3.Body)((0, import_nesties10.DataPipe)(), OmitPipe(this.fieldsInUpsertToOmit));
+  }
   findOne(extras = {}) {
     return (0, import_nesties10.MergeMethodDecorators)([
       this.usePrefix(import_common3.Get, extras.prefix, ":id"),
       (0, import_swagger6.ApiOperation)({
         summary: `Find a ${this.entityClassName} by id`,
-        ...import_lodash5.default.omit(extras, "prefix")
+        ...import_lodash6.default.omit(extras, "prefix")
       }),
       (0, import_swagger6.ApiParam)({ name: "id", type: this.idType, required: true }),
       (0, import_swagger6.ApiOkResponse)({ type: this.entityReturnMessageDto }),
@@ -2813,7 +3603,7 @@ var _RestfulFactory = class _RestfulFactory {
       this.usePrefix(import_common3.Get, extras.prefix),
       (0, import_swagger6.ApiOperation)({
         summary: `Find all ${this.entityClassName}`,
-        ...import_lodash5.default.omit(extras, "prefix")
+        ...import_lodash6.default.omit(extras, "prefix")
       }),
       (0, import_swagger6.ApiOkResponse)({ type: this.entityArrayReturnMessageDto })
     ]);
@@ -2823,14 +3613,14 @@ var _RestfulFactory = class _RestfulFactory {
       this.usePrefix(import_common3.Get, extras.prefix),
       (0, import_swagger6.ApiOperation)({
         summary: `Find all ${this.entityClassName}`,
-        ...import_lodash5.default.omit(extras, "prefix")
+        ...import_lodash6.default.omit(extras, "prefix")
       }),
       (0, import_swagger6.ApiOkResponse)({ type: this.entityCursorPaginationReturnMessageDto })
     ]);
   }
   getMutatorColumns() {
     const mutatorColumns = getSpecificFields(this.entityClass, "getMutator");
-    return import_lodash5.default.difference(mutatorColumns, this.fieldsInGetToOmit);
+    return import_lodash6.default.difference(mutatorColumns, this.fieldsInGetToOmit);
   }
   findAllParam() {
     const mutatorColumns = this.getMutatorColumns();
@@ -2850,7 +3640,7 @@ var _RestfulFactory = class _RestfulFactory {
       (0, import_common3.HttpCode)(200),
       (0, import_swagger6.ApiOperation)({
         summary: `Update a ${this.entityClassName} by id`,
-        ...import_lodash5.default.omit(extras, "prefix")
+        ...import_lodash6.default.omit(extras, "prefix")
       }),
       (0, import_swagger6.ApiParam)({ name: "id", type: this.idType, required: true }),
       (0, import_swagger6.ApiBody)({ type: this.updateDto }),
@@ -2872,7 +3662,7 @@ var _RestfulFactory = class _RestfulFactory {
       (0, import_common3.HttpCode)(200),
       (0, import_swagger6.ApiOperation)({
         summary: `Delete a ${this.entityClassName} by id`,
-        ...import_lodash5.default.omit(extras, "prefix")
+        ...import_lodash6.default.omit(extras, "prefix")
       }),
       (0, import_swagger6.ApiParam)({ name: "id", type: this.idType, required: true }),
       (0, import_nesties10.ApiBlankResponse)(),
@@ -2889,7 +3679,7 @@ var _RestfulFactory = class _RestfulFactory {
       (0, import_common3.HttpCode)(200),
       (0, import_swagger6.ApiOperation)({
         summary: `Import ${this.entityClassName}`,
-        ...import_lodash5.default.omit(extras, "prefix")
+        ...import_lodash6.default.omit(extras, "prefix")
       }),
       (0, import_swagger6.ApiBody)({ type: this.importDto }),
       (0, import_swagger6.ApiOkResponse)({ type: this.importReturnMessageDto }),
@@ -2901,8 +3691,8 @@ var _RestfulFactory = class _RestfulFactory {
       this.usePrefix(import_common3.Post, options.prefix, ":id", operationName),
       (0, import_common3.HttpCode)(200),
       (0, import_swagger6.ApiOperation)({
-        summary: `${(0, import_lodash5.upperFirst)(operationName)} a ${this.entityClassName} by id`,
-        ...import_lodash5.default.omit(options, "prefix", "returnType")
+        summary: `${(0, import_lodash6.upperFirst)(operationName)} a ${this.entityClassName} by id`,
+        ...import_lodash6.default.omit(options, "prefix", "returnType")
       }),
       options.returnType ? (0, import_nesties10.ApiTypeResponse)(options.returnType) : (0, import_nesties10.ApiBlankResponse)(),
       (0, import_nesties10.ApiError)(
@@ -2926,6 +3716,7 @@ var _RestfulFactory = class _RestfulFactory {
       (m) => routeOptions?.routes?.[m]?.enabled === true
     );
     const validMethods = RestfulMethods.filter((m) => {
+      if (m === "upsert" && !this.isUpsertable()) return false;
       const value = routeOptions?.routes?.[m]?.enabled;
       if (value === false) return false;
       if (value === true) return true;
@@ -2959,6 +3750,11 @@ var _RestfulFactory = class _RestfulFactory {
         paramDecorators: () => [this.idParam(), this.updateParam()],
         methodDecorators: () => [this.update()]
       },
+      upsert: {
+        paramTypes: [this.upsertDto],
+        paramDecorators: () => [this.upsertParam()],
+        methodDecorators: () => [this.upsert()]
+      },
       delete: {
         paramTypes: [this.idType],
         paramDecorators: () => [this.idParam()],
@@ -3025,9 +3821,14 @@ var _RestfulFactory = class _RestfulFactory {
     return (0, import_nesties11.RenameClass)(cl, `${this.entityClassName}Controller`);
   }
   crudService(options = {}) {
+    const keysToMigrate = [
+      "relations",
+      "outputFieldsToOmit",
+      "upsertIncludeRelations",
+      "keepEntityVersioningDates"
+    ];
     return CrudService(this.entityClass, {
-      relations: this.options.relations,
-      outputFieldsToOmit: this.options.outputFieldsToOmit,
+      ...import_lodash6.default.pick(this.options, keysToMigrate),
       ...options
     });
   }
@@ -3047,6 +3848,12 @@ __decorateClass([
 __decorateClass([
   (0, import_nfkit.Memorize)()
 ], _RestfulFactory.prototype, "updateDto", 1);
+__decorateClass([
+  (0, import_nfkit.Memorize)()
+], _RestfulFactory.prototype, "fieldsInUpsertToOmit", 1);
+__decorateClass([
+  (0, import_nfkit.Memorize)()
+], _RestfulFactory.prototype, "upsertDto", 1);
 __decorateClass([
   (0, import_nfkit.Memorize)()
 ], _RestfulFactory.prototype, "importDto", 1);
@@ -3068,6 +3875,9 @@ __decorateClass([
 __decorateClass([
   (0, import_nfkit.Memorize)()
 ], _RestfulFactory.prototype, "entityCreateResultDto", 1);
+__decorateClass([
+  (0, import_nfkit.Memorize)()
+], _RestfulFactory.prototype, "entityUpsertResultDto", 1);
 __decorateClass([
   (0, import_nfkit.Memorize)()
 ], _RestfulFactory.prototype, "entityReturnMessageDto", 1);
@@ -3152,6 +3962,190 @@ var applyQueryMatchBooleanMySQL = createQueryCondition(
     }
   }
 );
+
+// src/transactional-typeorm.module.ts
+var import_typeorm9 = __toESM(require_typeorm());
+var import_typeorm10 = require("typeorm");
+var import_common5 = require("@nestjs/common");
+var import_nesties12 = require("nesties");
+var import_core = require("@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
+var import_common4 = require("@nestjs/common");
+var createInjectFromTokenFactory = (factory) => (...params) => (0, import_common4.Inject)(factory(...params));
+
+// src/transactional-typeorm.module.ts
+var import_rxjs = require("rxjs");
+var requestWeakMap = /* @__PURE__ */ new WeakMap();
+var normalizeDataSourceToken = (token) => typeof token === "string" ? token : token.name || token.toString();
+var TransactionalTypeOrmInterceptor = (dataSource) => {
+  const token = (0, import_typeorm9.getEntityManagerToken)(dataSource);
+  const interceptorClass = class SpecificTransactionalTypeOrmInterceptor {
+    constructor(entityManager) {
+      this.entityManager = entityManager;
+    }
+    intercept(context, next) {
+      const request = context.switchToHttp().getRequest();
+      return new import_rxjs.Observable((observer) => {
+        let innerSub = null;
+        let finished = false;
+        let abort;
+        const aborted = new Promise((_7, 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",
+    [import_typeorm10.EntityManager],
+    interceptorClass
+  );
+  (0, import_common5.Inject)(token)(interceptorClass.prototype, void 0, 0);
+  (0, import_common5.Injectable)()(interceptorClass);
+  return interceptorClass;
+};
+var getTransactionalEntityManagerToken = (dataSource) => `Transactional${normalizeDataSourceToken((0, import_typeorm9.getEntityManagerToken)(dataSource))}`;
+var getTransactionalEntityManagerProvider = (dataSource) => (0, import_nesties12.createProvider)(
+  {
+    provide: getTransactionalEntityManagerToken(dataSource),
+    inject: [(0, import_typeorm9.getEntityManagerToken)(dataSource), import_core.REQUEST],
+    scope: import_common5.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_typeorm9.getEntityManagerToken)(dataSource)
+)}Repository_${entity.name || entity.toString()}`;
+var getTransactionalRepositoryProvider = (entity, dataSource) => (0, import_nesties12.createProvider)(
+  {
+    provide: getTransactionalRepositoryToken(entity, dataSource),
+    inject: [(0, import_typeorm9.getEntityManagerToken)(dataSource), import_core.REQUEST],
+    scope: import_common5.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_typeorm9.TypeOrmModule.forFeature(entityArray, dataSource)] : [];
+    const moduleExports = [...providers, ...moduleImports];
+    return {
+      module: TransactionalTypeOrmModule,
+      imports: moduleImports,
+      providers,
+      exports: moduleExports
+    };
+  }
+};
+TransactionalTypeOrmModule = __decorateClass([
+  (0, import_common5.Module)({})
+], TransactionalTypeOrmModule);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BindingColumn,
@@ -3181,6 +4175,8 @@ var applyQueryMatchBooleanMySQL = createQueryCondition(
   ImportDataDto,
   ImportEntryBaseDto,
   ImportEntryDto,
+  InjectTransactionalEntityManager,
+  InjectTransactionalRepository,
   Inner,
   IntColumn,
   InternalColumn,
@@ -3190,6 +4186,7 @@ var applyQueryMatchBooleanMySQL = createQueryCondition(
   NotCreatable,
   NotInResult,
   NotQueryable,
+  NotUpsertable,
   NotWritable,
   OmitPipe,
   OptionalDataPipe,
@@ -3228,6 +4225,10 @@ var applyQueryMatchBooleanMySQL = createQueryCondition(
   StringJsonColumn,
   TextColumn,
   TimeBase,
+  TransactionalTypeOrmInterceptor,
+  TransactionalTypeOrmModule,
+  UpsertColumn,
+  UpsertableEntity,
   UuidColumn,
   applyQueryMatchBoolean,
   applyQueryMatchBooleanMySQL,
@@ -3241,6 +4242,10 @@ var applyQueryMatchBooleanMySQL = createQueryCondition(
   createQueryOperator,
   createQueryOperatorArrayify,
   createQueryWrap,
+  getTransactionalEntityManagerProvider,
+  getTransactionalEntityManagerToken,
+  getTransactionalRepositoryProvider,
+  getTransactionalRepositoryToken,
   ...require("nesties")
 });
 //# sourceMappingURL=index.cjs.map