@bitblit/ratchet-aws 4.0.113-alpha → 4.0.116-alpha

package/lib/sync-lock/dynamo-db-sync-lock.js

@@ -1,69 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-import { PutItemCommand } from '@aws-sdk/client-dynamodb';
-export class DynamoDbSyncLock {
-    ratchet;
-    tableName;
-    constructor(ratchet, tableName) {
-        this.ratchet = ratchet;
-        this.tableName = tableName;
-        RequireRatchet.notNullOrUndefined(ratchet, 'ratchet');
-        RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(this.tableName), 'tableName');
-    }
-    async acquireLock(lockKey, expirationSeconds = 30) {
-        let rval = false;
-        if (!!lockKey && !!expirationSeconds) {
-            const nowSeconds = Math.floor(new Date().getTime() / 1000);
-            const row = {
-                lockingKey: lockKey,
-                timestamp: nowSeconds,
-                expires: nowSeconds + expirationSeconds,
-            };
-            const params = {
-                Item: row,
-                ReturnConsumedCapacity: 'TOTAL',
-                TableName: this.tableName,
-                ConditionExpression: 'attribute_not_exists(lockingKey)',
-            };
-            try {
-                const pio = await this.ratchet.getDDB().send(new PutItemCommand(params));
-                rval = true;
-            }
-            catch (err) {
-                if (String(err).indexOf('ConditionalCheckFailedException') > -1) {
-                    Logger.silly('Unable to acquire lock on %s', lockKey);
-                }
-            }
-        }
-        return rval;
-    }
-    async releaseLock(lockKey) {
-        if (StringRatchet.trimToNull(lockKey)) {
-            try {
-                const dio = await this.ratchet.simpleDelete(this.tableName, { lockingKey: lockKey });
-                Logger.silly('Released lock %s : %s', lockKey, dio);
-            }
-            catch (err) {
-                Logger.warn('Failed to release lock key : %s : %s', lockKey, err, err);
-            }
-        }
-    }
-    async clearExpiredSyncLocks() {
-        const nowSeconds = Math.floor(new Date().getTime() / 1000);
-        const scan = {
-            TableName: this.tableName,
-            FilterExpression: 'expires < :now',
-            ExpressionAttributeValues: {
-                ':now': nowSeconds,
-            },
-        };
-        const vals = await this.ratchet.fullyExecuteScan(scan);
-        const keysOnly = vals.map((v) => {
-            const next = { lockingKey: v['lockingKey'] };
-            return next;
-        });
-        const removed = await this.ratchet.deleteAllInBatches(this.tableName, keysOnly, 25);
-        return removed;
-    }
-}

package/lib/sync-lock/dynamo-db-sync-lock.spec.js

@@ -1,30 +0,0 @@
-import { DynamoDbSyncLock } from './dynamo-db-sync-lock.js';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { JestRatchet } from '@bitblit/ratchet-jest/lib/jest/jest-ratchet.js';
-import { jest } from '@jest/globals';
-let mockDR;
-describe('#syncLockService', () => {
-    beforeEach(() => {
-        mockDR = JestRatchet.mock(jest.fn);
-    });
-    xit('should test sync locks', async () => {
-        const svc = new DynamoDbSyncLock(mockDR, 'test-table');
-        const lockTestValue = 'SYNC_LOCK_TEST';
-        const aq1 = await svc.acquireLock(lockTestValue);
-        expect(aq1).toBe(true);
-        const aq2 = await svc.acquireLock(lockTestValue);
-        expect(aq2).toBe(false);
-        await svc.releaseLock(lockTestValue);
-        const aq3 = await svc.acquireLock(lockTestValue);
-        expect(aq3).toBe(true);
-        await svc.releaseLock(lockTestValue);
-    });
-    it('should clear expired sync locks', async () => {
-        mockDR.fullyExecuteScan.mockResolvedValue([{ lockingKey: 'aa' }, { lockingKey: 'ab' }]);
-        mockDR.deleteAllInBatches.mockResolvedValue(2);
-        const svc = new DynamoDbSyncLock(mockDR, 'test-table');
-        const res = await svc.clearExpiredSyncLocks();
-        Logger.info('Got : %s', res);
-        expect(res).toEqual(2);
-    });
-});

package/lib/sync-lock/memory-sync-lock.js

@@ -1,35 +0,0 @@
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-export class MemorySyncLock {
-    _locks = new Map();
-    constructor() { }
-    async acquireLock(lockKey, expirationSeconds = 30) {
-        let rval = false;
-        if (StringRatchet.trimToNull(lockKey)) {
-            const now = Date.now();
-            const val = this._locks.get(lockKey);
-            if (!val || val < now) {
-                this._locks.set(lockKey, now + expirationSeconds * 1000);
-                rval = true;
-            }
-        }
-        return rval;
-    }
-    async releaseLock(lockKey) {
-        if (StringRatchet.trimToNull(lockKey)) {
-            this._locks.delete(lockKey);
-        }
-    }
-    async clearExpiredSyncLocks() {
-        const toRemove = [];
-        const now = Date.now();
-        this._locks.forEach((v, k) => {
-            if (v < now) {
-                toRemove.push(k);
-            }
-        });
-        toRemove.forEach((k) => {
-            this._locks.delete(k);
-        });
-        return toRemove.length;
-    }
-}

package/lib/sync-lock/sync-lock-provider.js

@@ -1 +0,0 @@
-export {};