@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/lock/mongo/lock.js

@@ -1,125 +1,149 @@
-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;
+"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 __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+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;
 };
-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;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lock_exports = {};
+__export(lock_exports, {
+  MongoLock: () => MongoLock
+});
+module.exports = __toCommonJS(lock_exports);
+var import_decorators = require("../../injector/decorators.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;
 const renewBuffer = expirationTime / 2;
-export let MongoLock = class MongoLock extends Lock {
-    lockRepository;
-    logger;
-    constructor(lockRepository, resource, logger) {
-        super(resource);
-        this.lockRepository = lockRepository;
-        this.logger = logger;
+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);
+      }
     }
-    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;
+    if (result == false) {
+      if (throwOnFail) {
+        throw new Error("Failed to acquire lock.");
+      }
+      return false;
     }
-    async use(timeout, throwOnFail, func) {
-        const controller = await this.acquire(timeout, throwOnFail);
-        if (controller == false) {
-            return { success: false, result: undefined };
-        }
+    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) {
         try {
-            const result = await func(controller);
-            return { success: true, result };
-        }
-        finally {
-            await controller.release();
+          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);
         }
+      }
+    })();
+    return controller;
+  }
+  async use(timeout, throwOnFail, func) {
+    const controller = await this.acquire(timeout, throwOnFail);
+    if (controller == false) {
+      return { success: false, result: void 0 };
     }
-    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);
+    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);
+  }
 };
 MongoLock = __decorate([
-    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])
+  (0, import_decorators.Injectable)({
+    provider: {
+      useFactory: (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 = context.resolve(import_provider.MongoLockProvider, prefix);
+        return provider.get(resource);
+      }
+    }
+  }),
+  __metadata("design:paramtypes", [import_mongo_lock_repository.MongoLockRepository, String, import_logger.Logger])
 ], MongoLock);
 function getExpirationDate() {
-    return new Date(currentTimestamp() + expirationTime);
+  return new Date((0, import_date_time.currentTimestamp)() + expirationTime);
 }

package/lock/mongo/model.js

@@ -1 +1,16 @@
-export {};
+"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);

package/lock/mongo/module.js

@@ -1,20 +1,39 @@
-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
+"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 });
 };
-/**
- * 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 });
-    }
+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_injector = require("../../injector/injector.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_injector.Injector.registerSingleton(import_provider.LockProvider, { useToken: import_provider2.MongoLockProvider });
+    import_injector.Injector.register(import_lock.Lock, { useToken: import_lock2.MongoLock });
+  }
 }

package/lock/mongo/mongo-lock-repository.d.ts

@@ -1,10 +1,10 @@
-import type { Injectable } from '../../container/index.js';
-import { type resolveArgumentType } from '../../container/index.js';
 import type { CollectionArgument } from '../../database/mongo/index.js';
 import { Collection, MongoEntityRepository } from '../../database/mongo/index.js';
+import { resolveArgumentType } from '../../injector/index.js';
+import type { Resolvable } from '../../injector/interfaces.js';
 import { Logger } from '../../logger/index.js';
 import type { MongoLockEntity } from './model.js';
-export declare class MongoLockRepository extends MongoEntityRepository<MongoLockEntity> implements Injectable<CollectionArgument<MongoLockEntity>> {
+export declare class MongoLockRepository extends MongoEntityRepository<MongoLockEntity> implements Resolvable<CollectionArgument<MongoLockEntity>> {
     readonly [resolveArgumentType]: CollectionArgument<MongoLockEntity>;
     constructor(collection: Collection<MongoLockEntity>, logger: Logger);
     tryInsertOrRefresh(resource: string, key: string, newExpirationDate: Date): Promise<false | Date>;

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

@@ -1,66 +1,95 @@
-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;
+"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 __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+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 __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
+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_database = require("../../database/index.js");
+var import_mongo = require("../../database/mongo/index.js");
+var import_injector = require("../../injector/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);
+  };
 };
-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 }
 ];
-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;
+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)() } }
+          ]
         }
+      ]
+    };
+    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: 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: (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 });
+  }
 };
 MongoLockRepository = __decorate([
-    singleton(),
-    __param(0, forwardArg()),
-    __metadata("design:paramtypes", [Collection, Logger])
+  (0, import_injector.Singleton)(),
+  __param(0, (0, import_injector.ForwardArg)()),
+  __metadata("design:paramtypes", [import_mongo.Collection, import_logger.Logger])
 ], MongoLockRepository);

package/lock/mongo/provider.js

@@ -1,45 +1,75 @@
-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;
+"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 __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+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 __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var provider_exports = {};
+__export(provider_exports, {
+  MongoLockProvider: () => MongoLockProvider
+});
+module.exports = __toCommonJS(provider_exports);
+var import_decorators = require("../../injector/decorators.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 MongoLockProvider_1;
-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);
-    }
+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);
+  }
 };
 MongoLockProvider = MongoLockProvider_1 = __decorate([
-    singleton(),
-    __param(0, resolveArgProvider(collectionArgumentProvider)),
-    __param(1, resolveArg('MongoLock')),
-    __param(2, injectArg()),
-    __metadata("design:paramtypes", [MongoLockRepository, Logger, String])
+  (0, import_decorators.Singleton)(),
+  __param(0, (0, import_decorators.ResolveArgProvider)(collectionArgumentProvider)),
+  __param(1, (0, import_decorators.ResolveArg)("MongoLock")),
+  __param(2, (0, import_decorators.InjectArg)()),
+  __metadata("design:paramtypes", [import_mongo_lock_repository.MongoLockRepository, import_logger.Logger, String])
 ], MongoLockProvider);

package/lock/provider.d.ts

@@ -1,8 +1,9 @@
-import type { Injectable, resolveArgumentType } from '../container/index.js';
+import type { Resolvable } from '../injector/index.js';
+import { resolveArgumentType } from '../injector/index.js';
 import type { Lock } from './lock.js';
 /** prefix */
 export type LockProviderArgument = string;
-export declare abstract class LockProvider implements Injectable<LockProviderArgument> {
+export declare abstract class LockProvider implements Resolvable<LockProviderArgument> {
     readonly [resolveArgumentType]: LockProviderArgument;
     abstract prefix(prefix: string): LockProvider;
     abstract get(resource: string): Lock;