@tstdl/base 0.85.13 → 0.86.0-beta1

package/lock/mongo/lock.js

@@ -1,149 +1,125 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __decorate = (this && this.__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 __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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var lock_exports = {};
-__export(lock_exports, {
-  MongoLock: () => MongoLock
-});
-module.exports = __toCommonJS(lock_exports);
-var import_container = require("../../container/index.js");
-var import_lock = require("../../lock/index.js");
-var import_logger = require("../../logger/index.js");
-var import_alphabet = require("../../utils/alphabet.js");
-var import_cancellation_token = require("../../utils/cancellation-token.js");
-var import_date_time = require("../../utils/date-time.js");
-var import_random = require("../../utils/random.js");
-var import_timer = require("../../utils/timer.js");
-var import_timing = require("../../utils/timing.js");
-var import_type_guards = require("../../utils/type-guards.js");
-var import_mongo_lock_repository = require("./mongo-lock-repository.js");
-var import_provider = require("./provider.js");
-var __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 = function(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-    return Reflect.metadata(k, v);
-};
-const expirationTime = 1e4;
+import { injectable } from '../../container/index.js';
+import { Lock } from '../../lock/index.js';
+import { Logger } from '../../logger/index.js';
+import { Alphabet } from '../../utils/alphabet.js';
+import { CancellationToken } from '../../utils/cancellation-token.js';
+import { currentTimestamp } from '../../utils/date-time.js';
+import { getRandomString } from '../../utils/random.js';
+import { Timer } from '../../utils/timer.js';
+import { cancelableTimeoutUntil, timeout as utilsTimeout } from '../../utils/timing.js';
+import { assertStringPass, isObject, isUndefined } from '../../utils/type-guards.js';
+import { MongoLockRepository } from './mongo-lock-repository.js';
+import { MongoLockProvider } from './provider.js';
+const expirationTime = 10000;
 const renewBuffer = expirationTime / 2;
-let MongoLock = class MongoLock2 extends import_lock.Lock {
-  lockRepository;
-  logger;
-  constructor(lockRepository, resource, logger) {
-    super(resource);
-    this.lockRepository = lockRepository;
-    this.logger = logger;
-  }
-  async acquire(timeout, throwOnFail) {
-    const key = (0, import_random.getRandomString)(15, import_alphabet.Alphabet.LowerUpperCaseNumbers);
-    const timeoutDuration = Math.max(50, Math.min(1e3, (timeout ?? 0) / 10));
-    let result = false;
-    const timer = new import_timer.Timer(true);
-    while (result == false && ((0, import_type_guards.isUndefined)(timeout) || timer.milliseconds < timeout)) {
-      result = await this.tryAcquireOrRefresh(this.resource, key);
-      if (result == false && (0, import_type_guards.isUndefined)(timeout)) {
-        break;
-      }
-      if (result == false) {
-        await (0, import_timing.timeout)(timeoutDuration);
-      }
+export let MongoLock = class MongoLock extends Lock {
+    lockRepository;
+    logger;
+    constructor(lockRepository, resource, logger) {
+        super(resource);
+        this.lockRepository = lockRepository;
+        this.logger = logger;
     }
-    if (result == false) {
-      if (throwOnFail) {
-        throw new Error("Failed to acquire lock.");
-      }
-      return false;
+    async acquire(timeout, throwOnFail) {
+        const key = getRandomString(15, Alphabet.LowerUpperCaseNumbers);
+        const timeoutDuration = Math.max(50, Math.min(1000, (timeout ?? 0) / 10));
+        let result = false;
+        const timer = new Timer(true);
+        while ((result == false) && (isUndefined(timeout) || (timer.milliseconds < timeout))) { // eslint-disable-line no-unmodified-loop-condition
+            result = await this.tryAcquireOrRefresh(this.resource, key);
+            if ((result == false) && isUndefined(timeout)) {
+                break;
+            }
+            if (result == false) {
+                await utilsTimeout(timeoutDuration);
+            }
+        }
+        if (result == false) {
+            if (throwOnFail) {
+                throw new Error('Failed to acquire lock.');
+            }
+            return false;
+        }
+        let expiration = result;
+        const releaseToken = new CancellationToken();
+        const controller = {
+            get lost() {
+                return currentTimestamp() >= expiration.valueOf();
+            },
+            release: async () => {
+                releaseToken.set();
+                await this.release(this.resource, key);
+            }
+        };
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        (async () => {
+            await cancelableTimeoutUntil(expiration.valueOf() - renewBuffer, releaseToken);
+            while (!releaseToken.isSet && !controller.lost) {
+                try {
+                    const refreshResult = await this.tryRefresh(this.resource, key);
+                    expiration = (refreshResult == false) ? new Date(0) : refreshResult; // eslint-disable-line require-atomic-updates
+                }
+                catch (error) {
+                    this.logger.error(error);
+                }
+                finally {
+                    await cancelableTimeoutUntil(Math.max(currentTimestamp() + 1000, expiration.valueOf() - renewBuffer), releaseToken);
+                }
+            }
+        })();
+        return controller;
     }
-    let expiration = result;
-    const releaseToken = new import_cancellation_token.CancellationToken();
-    const controller = {
-      get lost() {
-        return (0, import_date_time.currentTimestamp)() >= expiration.valueOf();
-      },
-      release: async () => {
-        releaseToken.set();
-        await this.release(this.resource, key);
-      }
-    };
-    (async () => {
-      await (0, import_timing.cancelableTimeoutUntil)(expiration.valueOf() - renewBuffer, releaseToken);
-      while (!releaseToken.isSet && !controller.lost) {
+    async use(timeout, throwOnFail, func) {
+        const controller = await this.acquire(timeout, throwOnFail);
+        if (controller == false) {
+            return { success: false, result: undefined };
+        }
         try {
-          const refreshResult = await this.tryRefresh(this.resource, key);
-          expiration = refreshResult == false ? /* @__PURE__ */ new Date(0) : refreshResult;
-        } catch (error) {
-          this.logger.error(error);
-        } finally {
-          await (0, import_timing.cancelableTimeoutUntil)(Math.max((0, import_date_time.currentTimestamp)() + 1e3, expiration.valueOf() - renewBuffer), releaseToken);
+            const result = await func(controller);
+            return { success: true, result };
+        }
+        finally {
+            await controller.release();
         }
-      }
-    })();
-    return controller;
-  }
-  async use(timeout, throwOnFail, func) {
-    const controller = await this.acquire(timeout, throwOnFail);
-    if (controller == false) {
-      return { success: false, result: void 0 };
     }
-    try {
-      const result = await func(controller);
-      return { success: true, result };
-    } finally {
-      await controller.release();
+    async exists() {
+        return this.lockRepository.exists(this.resource);
+    }
+    async tryAcquireOrRefresh(resource, key) {
+        const expirationDate = getExpirationDate();
+        return this.lockRepository.tryInsertOrRefresh(resource, key, expirationDate);
+    }
+    async tryRefresh(resource, key) {
+        const expiration = getExpirationDate();
+        return this.lockRepository.tryUpdateExpiration(resource, key, expiration);
+    }
+    async release(resource, key) {
+        return this.lockRepository.deleteByResource(resource, key);
     }
-  }
-  async exists() {
-    return this.lockRepository.exists(this.resource);
-  }
-  async tryAcquireOrRefresh(resource, key) {
-    const expirationDate = getExpirationDate();
-    return this.lockRepository.tryInsertOrRefresh(resource, key, expirationDate);
-  }
-  async tryRefresh(resource, key) {
-    const expiration = getExpirationDate();
-    return this.lockRepository.tryUpdateExpiration(resource, key, expiration);
-  }
-  async release(resource, key) {
-    return this.lockRepository.deleteByResource(resource, key);
-  }
 };
 MongoLock = __decorate([
-  (0, import_container.injectable)({
-    provider: {
-      useFactory: async (argument, context) => {
-        const arg = argument;
-        const prefix = (0, import_type_guards.isObject)(arg) ? (0, import_type_guards.assertStringPass)(arg.prefix, "invalid lock argument") : void 0;
-        const resource = (0, import_type_guards.assertStringPass)((0, import_type_guards.isObject)(arg) ? arg.resource : arg, "invalid lock argument");
-        const provider = await context.resolveAsync(import_provider.MongoLockProvider, prefix);
-        return provider.get(resource);
-      }
-    }
-  }),
-  __metadata("design:paramtypes", [import_mongo_lock_repository.MongoLockRepository, String, import_logger.Logger])
+    injectable({
+        provider: {
+            useFactory: async (argument, context) => {
+                const arg = argument;
+                const prefix = isObject(arg) ? assertStringPass(arg.prefix, 'invalid lock argument') : undefined;
+                const resource = assertStringPass(isObject(arg) ? arg.resource : arg, 'invalid lock argument');
+                const provider = await context.resolveAsync(MongoLockProvider, prefix);
+                return provider.get(resource);
+            }
+        }
+    }),
+    __metadata("design:paramtypes", [MongoLockRepository, String, Logger])
 ], MongoLock);
 function getExpirationDate() {
-  return new Date((0, import_date_time.currentTimestamp)() + expirationTime);
+    return new Date(currentTimestamp() + expirationTime);
 }

package/lock/mongo/model.js

@@ -1,16 +1 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var model_exports = {};
-module.exports = __toCommonJS(model_exports);
+export {};

package/lock/mongo/module.js

@@ -1,39 +1,20 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+import { container } from '../../container/index.js';
+import { Lock } from '../lock.js';
+import { LockProvider } from '../provider.js';
+import { MongoLock } from './lock.js';
+import { MongoLockProvider } from './provider.js';
+export const mongoLockModuleConfig = {
+    lockEntityRepositoryConfig: undefined
 };
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var module_exports = {};
-__export(module_exports, {
-  configureMongoLock: () => configureMongoLock,
-  mongoLockModuleConfig: () => mongoLockModuleConfig
-});
-module.exports = __toCommonJS(module_exports);
-var import_container = require("../../container/index.js");
-var import_lock = require("../lock.js");
-var import_provider = require("../provider.js");
-var import_lock2 = require("./lock.js");
-var import_provider2 = require("./provider.js");
-const mongoLockModuleConfig = {
-  lockEntityRepositoryConfig: void 0
-};
-function configureMongoLock(lockRepositoryConfig, register = true) {
-  mongoLockModuleConfig.lockEntityRepositoryConfig = lockRepositoryConfig;
-  if (register) {
-    import_container.container.registerSingleton(import_provider.LockProvider, { useToken: import_provider2.MongoLockProvider });
-    import_container.container.register(import_lock.Lock, { useToken: import_lock2.MongoLock });
-  }
+/**
+ * configure mongo lock module
+ * @param lockRepositoryConfig repository configuration for locks
+ * @param register whether to register for {@link Lock} and {@link LockProvider}
+ */
+export function configureMongoLock(lockRepositoryConfig, register = true) {
+    mongoLockModuleConfig.lockEntityRepositoryConfig = lockRepositoryConfig;
+    if (register) {
+        container.registerSingleton(LockProvider, { useToken: MongoLockProvider });
+        container.register(Lock, { useToken: MongoLock });
+    }
 }

package/lock/mongo/mongo-lock-repository.js

@@ -1,95 +1,66 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __decorate = (this && this.__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 __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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var mongo_lock_repository_exports = {};
-__export(mongo_lock_repository_exports, {
-  MongoLockRepository: () => MongoLockRepository
-});
-module.exports = __toCommonJS(mongo_lock_repository_exports);
-var import_container = require("../../container/index.js");
-var import_database = require("../../database/index.js");
-var import_mongo = require("../../database/mongo/index.js");
-var import_logger = require("../../logger/index.js");
-var import_date_time = require("../../utils/date-time.js");
-var import_mongodb = require("mongodb");
-var __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 = function(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-    return Reflect.metadata(k, v);
-};
-var __param = function(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
 };
+import { forwardArg, singleton } from '../../container/index.js';
+import { getNewId } from '../../database/index.js';
+import { Collection, MongoEntityRepository, noopTransformer } from '../../database/mongo/index.js';
+import { Logger } from '../../logger/index.js';
+import { now } from '../../utils/date-time.js';
+import { MongoError } from 'mongodb';
 const indexes = [
-  { key: { resource: 1 }, unique: true },
-  { key: { expiration: 1 }, expireAfterSeconds: 1 }
+    { key: { resource: 1 }, unique: true },
+    { key: { expiration: 1 }, expireAfterSeconds: 1 }
 ];
-let MongoLockRepository = class MongoLockRepository2 extends import_mongo.MongoEntityRepository {
-  constructor(collection, logger) {
-    super(collection, import_mongo.noopTransformer, { logger, indexes });
-  }
-  async tryInsertOrRefresh(resource, key, newExpirationDate) {
-    const filter = {
-      $and: [
-        { resource },
-        {
-          $or: [
-            { key },
-            { expiration: { $lte: (0, import_date_time.now)() } }
-          ]
+export let MongoLockRepository = class MongoLockRepository extends MongoEntityRepository {
+    constructor(collection, logger) {
+        super(collection, noopTransformer, { logger, indexes });
+    }
+    async tryInsertOrRefresh(resource, key, newExpirationDate) {
+        const filter = {
+            $and: [
+                { resource },
+                {
+                    $or: [
+                        { key },
+                        { expiration: { $lte: now() } }
+                    ]
+                }
+            ]
+        };
+        try {
+            const { upsertedCount, modifiedCount } = await this.baseRepository.collection.updateOne(filter, { $set: { expiration: newExpirationDate }, $setOnInsert: { _id: getNewId(), key } }, { upsert: true });
+            return ((upsertedCount > 0) || (modifiedCount > 0)) ? newExpirationDate : false;
+        }
+        catch (error) {
+            if (error instanceof MongoError && error.code == 11000) {
+                return false;
+            }
+            throw error;
         }
-      ]
-    };
-    try {
-      const { upsertedCount, modifiedCount } = await this.baseRepository.collection.updateOne(filter, { $set: { expiration: newExpirationDate }, $setOnInsert: { _id: (0, import_database.getNewId)(), key } }, { upsert: true });
-      return upsertedCount > 0 || modifiedCount > 0 ? newExpirationDate : false;
-    } catch (error) {
-      if (error instanceof import_mongodb.MongoError && error.code == 11e3) {
-        return false;
-      }
-      throw error;
     }
-  }
-  async exists(resource) {
-    return this.baseRepository.hasByFilter({ resource, expiration: { $gt: (0, import_date_time.now)() } });
-  }
-  async tryUpdateExpiration(resource, key, expirationDate) {
-    const filter = { resource, key };
-    const result = await this.baseRepository.update(filter, { $set: { expiration: expirationDate } });
-    return result.modifiedCount > 0 ? expirationDate : false;
-  }
-  async deleteByResource(resource, key) {
-    return this.baseRepository.deleteByFilter({ resource, key });
-  }
+    async exists(resource) {
+        return this.baseRepository.hasByFilter({ resource, expiration: { $gt: now() } });
+    }
+    async tryUpdateExpiration(resource, key, expirationDate) {
+        const filter = { resource, key };
+        const result = await this.baseRepository.update(filter, { $set: { expiration: expirationDate } });
+        return (result.modifiedCount > 0) ? expirationDate : false;
+    }
+    async deleteByResource(resource, key) {
+        return this.baseRepository.deleteByFilter({ resource, key });
+    }
 };
 MongoLockRepository = __decorate([
-  (0, import_container.singleton)(),
-  __param(0, (0, import_container.forwardArg)()),
-  __metadata("design:paramtypes", [import_mongo.Collection, import_logger.Logger])
+    singleton(),
+    __param(0, forwardArg()),
+    __metadata("design:paramtypes", [Collection, Logger])
 ], MongoLockRepository);

package/lock/mongo/provider.js

@@ -1,75 +1,45 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __decorate = (this && this.__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 __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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var provider_exports = {};
-__export(provider_exports, {
-  MongoLockProvider: () => MongoLockProvider
-});
-module.exports = __toCommonJS(provider_exports);
-var import_container = require("../../container/index.js");
-var import_lock = require("../../lock/index.js");
-var import_logger = require("../../logger/index.js");
-var import_type_guards = require("../../utils/type-guards.js");
-var import_lock2 = require("./lock.js");
-var import_module = require("./module.js");
-var import_mongo_lock_repository = require("./mongo-lock-repository.js");
-var __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 = function(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-    return Reflect.metadata(k, v);
-};
-var __param = function(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
 };
 var MongoLockProvider_1;
-const collectionArgumentProvider = () => (0, import_type_guards.assertDefinedPass)(import_module.mongoLockModuleConfig.lockEntityRepositoryConfig, "mongo lock module not configured");
-let MongoLockProvider = MongoLockProvider_1 = class MongoLockProvider2 extends import_lock.LockProvider {
-  lockRepository;
-  logger;
-  _prefix;
-  constructor(lockRepository, logger, prefix = "") {
-    super();
-    this.lockRepository = lockRepository;
-    this.logger = logger;
-    this._prefix = prefix;
-  }
-  prefix(prefix) {
-    return new MongoLockProvider_1(this.lockRepository, this.logger, this._prefix + prefix);
-  }
-  get(resource) {
-    return new import_lock2.MongoLock(this.lockRepository, this._prefix + resource, this.logger);
-  }
+import { injectArg, resolveArg, resolveArgProvider, singleton } from '../../container/index.js';
+import { LockProvider } from '../../lock/index.js';
+import { Logger } from '../../logger/index.js';
+import { assertDefinedPass } from '../../utils/type-guards.js';
+import { MongoLock } from './lock.js';
+import { mongoLockModuleConfig } from './module.js';
+import { MongoLockRepository } from './mongo-lock-repository.js';
+const collectionArgumentProvider = () => assertDefinedPass(mongoLockModuleConfig.lockEntityRepositoryConfig, 'mongo lock module not configured');
+export let MongoLockProvider = MongoLockProvider_1 = class MongoLockProvider extends LockProvider {
+    lockRepository;
+    logger;
+    _prefix;
+    constructor(lockRepository, logger, prefix = '') {
+        super();
+        this.lockRepository = lockRepository;
+        this.logger = logger;
+        this._prefix = prefix;
+    }
+    prefix(prefix) {
+        return new MongoLockProvider_1(this.lockRepository, this.logger, this._prefix + prefix);
+    }
+    get(resource) {
+        return new MongoLock(this.lockRepository, this._prefix + resource, this.logger);
+    }
 };
 MongoLockProvider = MongoLockProvider_1 = __decorate([
-  (0, import_container.singleton)(),
-  __param(0, (0, import_container.resolveArgProvider)(collectionArgumentProvider)),
-  __param(1, (0, import_container.resolveArg)("MongoLock")),
-  __param(2, (0, import_container.injectArg)()),
-  __metadata("design:paramtypes", [import_mongo_lock_repository.MongoLockRepository, import_logger.Logger, String])
+    singleton(),
+    __param(0, resolveArgProvider(collectionArgumentProvider)),
+    __param(1, resolveArg('MongoLock')),
+    __param(2, injectArg()),
+    __metadata("design:paramtypes", [MongoLockRepository, Logger, String])
 ], MongoLockProvider);

package/lock/provider.js

@@ -1,25 +1,2 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var provider_exports = {};
-__export(provider_exports, {
-  LockProvider: () => LockProvider
-});
-module.exports = __toCommonJS(provider_exports);
-class LockProvider {
+export class LockProvider {
 }