@punks/backend-entity-manager 0.0.260 → 0.0.262

package/dist/cjs/index.js

@@ -21865,9 +21865,11 @@ function differenceInMinutes(dateLeft, dateRight, options) {
   return getRoundingMethod(options === null || options === void 0 ? void 0 : options.roundingMethod)(diff);
 }
 
-exports.OperationLockService = class OperationLockService {
+var OperationLockService_1;
+exports.OperationLockService = OperationLockService_1 = class OperationLockService {
     constructor(operations) {
         this.operations = operations;
+        this.logger = backendCore.Log.getLogger(OperationLockService_1.name);
         this.executeExclusive = async (input) => {
             const lock = await this.operations.acquire({
                 lockUid: input.lockUid,
@@ -21905,15 +21907,70 @@ exports.OperationLockService = class OperationLockService {
         this.isLockExpired = (item, refDate, timeoutMinutes) => {
             return differenceInMinutes(refDate, item.createdOn) > timeoutMinutes;
         };
+        if (!operations) {
+            this.logger.warn(`Cannot resolve locks repository: ${getEntityManagerProviderToken("OperationsLockRepository")}`);
+        }
     }
 };
-exports.OperationLockService = __decorate([
+exports.OperationLockService = OperationLockService_1 = __decorate([
     common.Injectable(),
     __param(0, common.Optional()),
     __param(0, common.Inject(getEntityManagerProviderToken("OperationsLockRepository"))),
     __metadata("design:paramtypes", [Object])
 ], exports.OperationLockService);
 
+exports.TypeormOperationLockRepository = class TypeormOperationLockRepository {
+    constructor(repo, entityClass) {
+        this.repo = repo;
+        this.entityClass = entityClass;
+        // todo: fix typing (and remove as any)
+        this.get = async (lockUid) => (await this.repo.findOne({
+            where: {
+                uid: lockUid,
+            },
+        })) ?? undefined;
+        this.acquire = async (input) => {
+            return await this.repo.manager.transaction(async (manager) => {
+                const currentLock = await manager.findOne(this.entityClass, {
+                    where: [
+                        {
+                            uid: input.lockUid,
+                        },
+                    ],
+                });
+                if (currentLock) {
+                    return {
+                        available: false,
+                        lockItem: currentLock,
+                    };
+                }
+                const newLock = manager.create(this.entityClass, {
+                    id: backendCore.newUuid(),
+                    uid: input.lockUid,
+                    lockedBy: input.requestedBy,
+                });
+                await manager.save([newLock]);
+                return {
+                    available: true,
+                    lockItem: newLock,
+                };
+            });
+        };
+        this.release = async (input) => {
+            const result = await this.repo.delete({
+                uid: input.lockUid,
+            });
+            if (result.affected === 0) {
+                throw new LockNotFoundError(`Lock ${input.lockUid} was not found`);
+            }
+        };
+    }
+};
+exports.TypeormOperationLockRepository = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [typeorm.Repository, Object])
+], exports.TypeormOperationLockRepository);
+
 exports.EmailService = class EmailService {
     constructor(registry) {
         this.registry = registry;