@bitblit/ratchet-aws 6.0.146-alpha → 6.0.147-alpha

package/src/dynamodb/dynamo-table-ratchet.spec.ts

@@ -0,0 +1,23 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { DescribeTableCommandOutput, DynamoDBClient } from '@aws-sdk/client-dynamodb';
+
+import { mockClient } from 'aws-sdk-client-mock';
+import { DynamoTableRatchet } from './dynamo-table-ratchet.js';
+import { beforeEach, describe, test } from 'vitest';
+
+let mockDynamo;
+
+describe('#dynamoTableRatchet', function () {
+  mockDynamo = mockClient(DynamoDBClient);
+
+  beforeEach(() => {
+    mockDynamo.reset();
+  });
+
+  test.skip('should copy a table', async () => {
+    const dr: DynamoTableRatchet = new DynamoTableRatchet(mockDynamo);
+    //const tn: string[] = await dr.listAllTables();
+    const result: DescribeTableCommandOutput = await dr.copyTable('src-dev', 'dst-dev');
+    Logger.info('result was : %j', result);
+  }, 300_000_000);
+});

package/src/dynamodb/dynamo-table-ratchet.ts

@@ -0,0 +1,189 @@
+import {
+  AttributeDefinition,
+  CreateTableCommand,
+  CreateTableCommandInput,
+  CreateTableCommandOutput,
+  DeleteTableCommand,
+  DeleteTableCommandInput,
+  DeleteTableCommandOutput,
+  DescribeTableCommand,
+  DescribeTableCommandOutput,
+  DynamoDBClient,
+  GlobalSecondaryIndex,
+  GlobalSecondaryIndexDescription,
+  KeySchemaElement,
+  ListTablesCommand,
+  ListTablesCommandInput,
+  ListTablesCommandOutput,
+  ProvisionedThroughput,
+  ResourceNotFoundException,
+} from '@aws-sdk/client-dynamodb';
+import { LocalSecondaryIndex } from '@aws-sdk/client-dynamodb/dist-types/models/models_0.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lang/promise-ratchet';
+
+export class DynamoTableRatchet {
+  constructor(private awsDDB: DynamoDBClient) {
+    if (!awsDDB) {
+      throw 'awsDDB may not be null';
+    }
+  }
+
+  public async deleteTable(tableName: string, waitForDelete = true): Promise<DeleteTableCommandOutput> {
+    RequireRatchet.notNullOrUndefined(tableName);
+    const input: DeleteTableCommandInput = {
+      TableName: tableName,
+    };
+    Logger.debug('Deleting ddb table %s', tableName);
+    const rval: DeleteTableCommandOutput = await this.awsDDB.send(new DeleteTableCommand(input));
+
+    if (waitForDelete) {
+      Logger.debug('Table marked for delete, waiting for deletion');
+      await this.waitForTableDelete(tableName);
+    }
+
+    return rval;
+  }
+
+  public async createTable(
+    input: CreateTableCommandInput,
+    waitForReady = true,
+    replaceIfExists = false,
+  ): Promise<CreateTableCommandOutput> {
+    RequireRatchet.notNullOrUndefined(input);
+    RequireRatchet.notNullOrUndefined(input.TableName);
+
+    Logger.debug('Creating new table : %j', input);
+    const exists: boolean = await this.tableExists(input.TableName);
+
+    if (exists) {
+      if (replaceIfExists) {
+        Logger.debug('Table %s exists and replace specified - deleting', input.TableName);
+        await this.deleteTable(input.TableName);
+      } else {
+        ErrorRatchet.throwFormattedErr('Cannot create table %s - exists already and replace not specified', input.TableName);
+      }
+    }
+
+    const rval: CreateTableCommandOutput = await this.awsDDB.send(new CreateTableCommand(input));
+
+    if (waitForReady) {
+      Logger.debug('Table created, awaiting ready');
+      await this.waitForTableReady(input.TableName);
+    }
+
+    return rval;
+  }
+
+  public async waitForTableReady(tableName: string): Promise<boolean> {
+    let rval = true;
+    let out: DescribeTableCommandOutput = await this.safeDescribeTable(tableName);
+
+    while (!!out && !!out.Table && out.Table.TableStatus !== 'ACTIVE') {
+      Logger.silly('Table not ready - waiting 2 seconds');
+      await PromiseRatchet.wait(2000);
+      out = await this.safeDescribeTable(tableName);
+    }
+
+    if (!out && !out.Table) {
+      Logger.warn('Cannot wait for %s to be ready - table does not exist', tableName);
+      rval = false;
+    }
+
+    return rval;
+  }
+
+  public async waitForTableDelete(tableName: string): Promise<void> {
+    let out: DescribeTableCommandOutput = await this.safeDescribeTable(tableName);
+
+    while (out) {
+      Logger.silly('Table %s still exists, waiting 2 seconds (State is %s)', tableName, out.Table.TableStatus);
+      await PromiseRatchet.wait(2000);
+      out = await this.safeDescribeTable(tableName);
+    }
+  }
+
+  public async tableExists(tableName: string): Promise<boolean> {
+    const desc: DescribeTableCommandOutput = await this.safeDescribeTable(tableName);
+    return !!desc;
+  }
+
+  public async listAllTables(): Promise<string[]> {
+    const input: ListTablesCommandInput = {};
+    let rval: string[] = [];
+
+    do {
+      const out: ListTablesCommandOutput = await this.awsDDB.send(new ListTablesCommand(input));
+      rval = rval.concat(out.TableNames);
+      input.ExclusiveStartTableName = out.LastEvaluatedTableName;
+    } while (input.ExclusiveStartTableName);
+    return rval;
+  }
+
+  public async safeDescribeTable(tableName: string): Promise<DescribeTableCommandOutput> {
+    try {
+      const out: DescribeTableCommandOutput = await this.awsDDB.send(new DescribeTableCommand({ TableName: tableName }));
+      return out;
+    } catch (err) {
+      if (err instanceof ResourceNotFoundException) {
+        return null;
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  public async copyTable(
+    srcTableName: string,
+    dstTableName: string,
+    overrides?: CreateTableCommandInput,
+    copyData?: boolean,
+  ): Promise<CreateTableCommandOutput> {
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(srcTableName, 'srcTableName');
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(dstTableName, 'dstTableName');
+    if (copyData) {
+      throw ErrorRatchet.fErr('Cannot copy %s to %s - copy data not supported yet', srcTableName, dstTableName);
+    }
+    const srcTableDef: DescribeTableCommandOutput = await this.safeDescribeTable(srcTableName);
+    if (await this.tableExists(dstTableName)) {
+      throw ErrorRatchet.fErr('Cannot copy to %s - table already exists', dstTableName);
+    }
+    if (!srcTableDef) {
+      throw ErrorRatchet.fErr('Cannot copy %s - doesnt exist', srcTableName);
+    }
+
+    const _ads: AttributeDefinition[] = srcTableDef.Table.AttributeDefinitions;
+    const _ks: KeySchemaElement[] = srcTableDef.Table.KeySchema;
+    const _gi: GlobalSecondaryIndexDescription[] = srcTableDef.Table.GlobalSecondaryIndexes;
+
+    const createInput: CreateTableCommandInput = Object.assign({}, overrides || {}, {
+      AttributeDefinitions: srcTableDef.Table.AttributeDefinitions,
+      TableName: dstTableName,
+      KeySchema: srcTableDef.Table.KeySchema,
+      LocalSecondaryIndexes: srcTableDef.Table.LocalSecondaryIndexes as LocalSecondaryIndex[],
+      GlobalSecondaryIndexes: srcTableDef.Table.GlobalSecondaryIndexes.map((gi) => {
+        const output: GlobalSecondaryIndex = gi as GlobalSecondaryIndex;
+        if (output.ProvisionedThroughput?.WriteCapacityUnits === 0 || output.ProvisionedThroughput?.ReadCapacityUnits === 0) {
+          output.ProvisionedThroughput = undefined;
+        }
+        return output;
+      }),
+      BillingMode: srcTableDef.Table.BillingModeSummary.BillingMode,
+      ProvisionedThroughput:
+        srcTableDef.Table.BillingModeSummary.BillingMode === 'PROVISIONED'
+          ? (srcTableDef.Table.ProvisionedThroughput as ProvisionedThroughput)
+          : undefined,
+      StreamSpecification: srcTableDef.Table.StreamSpecification,
+      SSESpecification: srcTableDef.Table.SSEDescription,
+      Tags: undefined,
+      TableClass: srcTableDef.Table.TableClassSummary?.TableClass,
+      DeletionProtectionEnabled: srcTableDef.Table.DeletionProtectionEnabled,
+    });
+
+    const rval: CreateTableCommandOutput = await this.awsDDB.send(new CreateTableCommand(createInput));
+
+    return rval;
+  }
+}

package/src/dynamodb/hash-spreader.spec.ts

@@ -0,0 +1,22 @@
+import { HashSpreader } from './hash-spreader.js';
+import { describe, expect, test } from 'vitest';
+
+describe('#hashSpreader', function () {
+  test('should enumerate spread', async () => {
+    const spread: HashSpreader = new HashSpreader(3, 16);
+    expect(spread.allBuckets.length).toEqual(16);
+
+    const spread2: HashSpreader = new HashSpreader(3, 19);
+    expect(spread2.allBuckets.length).toEqual(19);
+  });
+
+  test('should spread1', async () => {
+    const spread: HashSpreader = new HashSpreader(3, 16);
+    expect(spread.allSpreadValues('x').length).toEqual(16);
+  });
+
+  test('should spread multi', async () => {
+    const spread: HashSpreader = new HashSpreader(3, 16);
+    expect(spread.allSpreadValuesForArray(['x', 'y']).length).toEqual(32);
+  });
+});

package/src/dynamodb/hash-spreader.ts

@@ -0,0 +1,89 @@
+/**
+ * A helper for adding "spreaders" suffixes to keys to prevent hot key problems on indexes and
+ * hash keys.
+ *
+ * If you need to, you can easily increase the buckets number later, but may NOT decrease it.  Increasing
+ * spots is also hard (although I have an idea for implementing that later...)
+ */
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+
+export class HashSpreader {
+  private _allSlots: string[];
+
+  /*
+  Spots is how many locations to use, buckets is the number of unique strings to use, and the alphabet
+   are the strings to use in the spreader.  Every element in the alphabet must be unique and alphanumeric.  If there
+   are N items in the alphabet, then buckets must be less than N^spots
+
+   The separator is placed between the source data and the spreader
+   */
+  constructor(
+    private spots: number = 3,
+    private buckets: number = 16,
+    private separator: string = '_',
+    private alphabet: string = '0123456789ABCDEF',
+  ) {
+    RequireRatchet.true(spots > 0, 'Spots must be larger than 0');
+    RequireRatchet.true(buckets > 1, 'Buckets must be larger than 1');
+    RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(alphabet), 'Alphabet may not be null or empty');
+    RequireRatchet.true(StringRatchet.allUnique(alphabet), 'Alphabet must be unique');
+    RequireRatchet.true(StringRatchet.stringContainsOnlyAlphanumeric(alphabet), 'Alphabet must be alphanumeric');
+    const permutations: number = Math.pow(alphabet.length, spots);
+    RequireRatchet.true(buckets < permutations, 'Buckets must be less than permutations (' + buckets + ' / ' + permutations + ')');
+    RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(this.separator), 'Separator must be nonnull and nonempty');
+    const allPerms: string[] = StringRatchet.allPermutationsOfLength(spots, alphabet);
+    this._allSlots = allPerms.slice(0, buckets);
+  }
+
+  public get allBuckets(): string[] {
+    return Object.assign([], this._allSlots);
+  }
+
+  public get randomBucket(): string {
+    return this._allSlots[Math.floor(Math.random() * this.buckets)];
+  }
+
+  public allSpreadValues(input: string): string[] {
+    RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(input), 'Cannot spread null/empty value');
+    const rval: string[] = this._allSlots.map((s) => input + this.separator + s);
+    return rval;
+  }
+
+  public allSpreadValuesForArray(inputs: string[]): string[] {
+    RequireRatchet.true(inputs && inputs.length > 0, 'Cannot spread null/empty array');
+    let rval: string[] = [];
+    inputs.forEach((i) => {
+      rval = rval.concat(this.allSpreadValues(i));
+    });
+    return rval;
+  }
+
+  public addSpreader(input: string): string {
+    RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(input), 'Cannot spread null/empty value');
+    return input + this.separator + this.randomBucket;
+  }
+
+  public extractBucket(input: string): string {
+    RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(input), 'Cannot extract from null or empty value');
+    const loc: number = input.length - this.spots;
+    if (loc < 0 || input.charAt(loc) !== this.separator) {
+      ErrorRatchet.throwFormattedErr(
+        'Cannot extract bucket, not created by this spreader (missing %s at location %d)',
+        this.separator,
+        loc,
+      );
+    }
+    return input.substring(loc);
+  }
+
+  public removeBucket(input: string): string {
+    RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(input), 'Cannot extract from null or empty value');
+    const loc: number = input.length - this.spots;
+    if (loc < 0 || input.charAt(loc) !== this.separator) {
+      ErrorRatchet.throwFormattedErr('Cannot remove bucket, not created by this spreader (missing %s at location %d)', this.separator, loc);
+    }
+    return input.substring(0, loc);
+  }
+}

package/src/dynamodb/impl/dynamo-db-storage-provider.spec.ts

@@ -0,0 +1,60 @@
+import { DynamoDbSimpleCacheOptions, DynamoDbStorageProvider } from './dynamo-db-storage-provider.js';
+import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoRatchet } from '../dynamo-ratchet.js';
+import { SimpleCache } from '../../cache/simple-cache.js';
+import { SimpleCacheObjectWrapper } from '../../cache/simple-cache-object-wrapper.js';
+
+import { describe, expect, test } from 'vitest';
+
+describe('#DynamoDbStorageProvider', function () {
+  test.skip('should read/write/delete with an dynamo handler', async () => {
+    const dr: DynamoRatchet = new DynamoRatchet(DynamoDBDocument.from(new DynamoDBClient({ region: 'us-east-1' })));
+    const opts: DynamoDbSimpleCacheOptions = DynamoDbStorageProvider.createDefaultOptions();
+    opts.tableName = 'test-table';
+    opts.useRangeKeys = false;
+    opts.hashKeyName = 'cacheUid';
+    opts.dynamoExpiresColumnName = 'expiresEpochSeconds';
+
+    const ddbStorage: DynamoDbStorageProvider = new DynamoDbStorageProvider(dr, opts);
+
+    const simpleCache: SimpleCache = new SimpleCache(ddbStorage, 2000000);
+
+    await simpleCache.removeFromCache('test1'); // Make sure clear
+
+    const test1a: SimpleCacheObjectWrapper<any> = await simpleCache.fetchWrapper<any>('test1', () => Promise.resolve({ x: 1 }));
+    expect(test1a).not.toBeNull();
+    expect(test1a.generated).toBeTruthy();
+    expect(test1a.value).not.toBeNull();
+    expect(test1a.value['x']).toEqual(1);
+
+    const test1b: SimpleCacheObjectWrapper<any> = await simpleCache.fetchWrapper<any>('test1', () => Promise.resolve({ x: 1 }));
+    expect(test1b).not.toBeNull();
+    expect(test1b.generated).toBeFalsy();
+    expect(test1b.value).not.toBeNull();
+    expect(test1b.value['x']).toEqual(1);
+
+    await simpleCache.removeFromCache('test1'); // Make sure clear
+  }, 60_000);
+
+  test.skip('should write a bunch', async () => {
+    const dr: DynamoRatchet = new DynamoRatchet(DynamoDBDocument.from(new DynamoDBClient({ region: 'us-east-1' })));
+    const opts: DynamoDbSimpleCacheOptions = DynamoDbStorageProvider.createDefaultOptions();
+    opts.tableName = 'test-table';
+    opts.useRangeKeys = false;
+    opts.hashKeyName = 'cacheUid';
+    opts.dynamoExpiresColumnName = 'expiresEpochSeconds';
+
+    const ddbStorage: DynamoDbStorageProvider = new DynamoDbStorageProvider(dr, opts);
+    const simpleCache: SimpleCache = new SimpleCache(ddbStorage, 1000);
+
+    for (let i = 0; i < 10; i++) {
+      const _tests: SimpleCacheObjectWrapper<any> = await simpleCache.fetchWrapper<any>('test' + i, () => Promise.resolve({ x: i }));
+    }
+
+    const all: SimpleCacheObjectWrapper<any>[] = await simpleCache.readAll();
+    expect(all).not.toBeNull();
+    expect(all.length).toBeGreaterThan(9);
+    await simpleCache.clearCache();
+  }, 60_000);
+});

package/src/dynamodb/impl/dynamo-db-storage-provider.ts

@@ -0,0 +1,140 @@
+/*
+  Objects implementing this interface can store and retrieve objects in a cache, using a read-thru
+  approach.
+*/
+
+import { PutCommandOutput, QueryCommandInput, ScanCommandInput } from '@aws-sdk/lib-dynamodb';
+import { SimpleCacheObjectWrapper } from '../../cache/simple-cache-object-wrapper.js';
+import { SimpleCacheStorageProvider } from '../../cache/simple-cache-storage-provider.js';
+import { DynamoRatchet } from '../dynamo-ratchet.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+
+export class DynamoDbStorageProvider implements SimpleCacheStorageProvider {
+  // If hash key is provided, then the cache key is the range, otherwise the cache key is the hash
+  constructor(
+    private dynamo: DynamoRatchet,
+    private opts: DynamoDbSimpleCacheOptions,
+  ) {
+    RequireRatchet.notNullOrUndefined(this.dynamo, 'dynamo');
+    RequireRatchet.notNullOrUndefined(this.opts, 'opts');
+    RequireRatchet.notNullOrUndefined(this.opts.tableName, 'opts.tableName');
+    RequireRatchet.notNullOrUndefined(this.opts.hashKeyName, 'opts.hashKeyName');
+    RequireRatchet.true(!this.opts.useRangeKeys || (!!this.opts.rangeKeyName && !!this.opts.hashKeyValue), 'invalid range configuration');
+  }
+
+  public static createDefaultOptions(): DynamoDbSimpleCacheOptions {
+    const rval: DynamoDbSimpleCacheOptions = {
+      tableName: 'simple-cache',
+      useRangeKeys: false,
+      hashKeyName: 'cache-key',
+      rangeKeyName: null,
+      hashKeyValue: null,
+    };
+    return rval;
+  }
+
+  public createKeyObject(cacheKey: string): any {
+    const keys: any = {};
+    if (this.opts.useRangeKeys) {
+      keys[this.opts.hashKeyName] = this.opts.hashKeyValue;
+      keys[this.opts.rangeKeyName] = cacheKey;
+    } else {
+      keys[this.opts.hashKeyName] = cacheKey;
+    }
+    return keys;
+  }
+
+  public cleanDynamoFieldsFromObjectInPlace(rval: any): void {
+    if (rval) {
+      //eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete rval[this.opts.hashKeyName];
+      if (this.opts.rangeKeyName) {
+        //eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete rval[this.opts.rangeKeyName];
+      }
+      if (this.opts.dynamoExpiresColumnName) {
+        //eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete rval[this.opts.dynamoExpiresColumnName];
+      }
+    }
+  }
+
+  public extractKeysFromObject(rval: SimpleCacheObjectWrapper<any>): any {
+    let keys: any = null;
+    if (rval) {
+      keys = {};
+      if (this.opts.useRangeKeys) {
+        keys[this.opts.hashKeyName] = this.opts.hashKeyValue;
+        keys[this.opts.rangeKeyName] = rval.cacheKey;
+      } else {
+        keys[this.opts.hashKeyName] = rval.cacheKey;
+      }
+    }
+    return keys;
+  }
+
+  public async readFromCache<T>(cacheKey: string): Promise<SimpleCacheObjectWrapper<T>> {
+    const dKey: any = this.createKeyObject(cacheKey);
+    const rval: SimpleCacheObjectWrapper<T> = await this.dynamo.simpleGet<SimpleCacheObjectWrapper<T>>(this.opts.tableName, dKey);
+    this.cleanDynamoFieldsFromObjectInPlace(rval);
+
+    return rval;
+  }
+
+  public async storeInCache<T>(value: SimpleCacheObjectWrapper<T>): Promise<boolean> {
+    RequireRatchet.notNullOrUndefined(value, 'value');
+    RequireRatchet.notNullOrUndefined(value.cacheKey, 'value.cacheKey');
+    const toSave: any = Object.assign({}, value, this.createKeyObject(value.cacheKey));
+    if (this.opts.dynamoExpiresColumnName && value.expiresEpochMS) {
+      toSave[this.opts.dynamoExpiresColumnName] = Math.floor(value.expiresEpochMS / 1000);
+    }
+    const wrote: PutCommandOutput = await this.dynamo.simplePut(this.opts.tableName, toSave);
+    return !!wrote;
+  }
+
+  public async removeFromCache(cacheKey: string): Promise<void> {
+    await this.dynamo.simpleDelete(this.opts.tableName, this.createKeyObject(cacheKey));
+  }
+
+  public async clearCache(): Promise<number> {
+    // This ain't super efficient, I can make it more so later with a projection expression
+    const allValues: SimpleCacheObjectWrapper<any>[] = await this.readAll();
+    const allKeys: any[] = allValues.map((a) => this.extractKeysFromObject(a));
+    const rval: number = await this.dynamo.deleteAllInBatches(this.opts.tableName, allKeys, 25);
+    return rval;
+  }
+
+  public async readAll(): Promise<SimpleCacheObjectWrapper<any>[]> {
+    let rval: SimpleCacheObjectWrapper<any>[] = null;
+    if (this.opts.useRangeKeys) {
+      const qry: QueryCommandInput = {
+        TableName: this.opts.tableName,
+        KeyConditionExpression: '#cacheKey = :cacheKey',
+        ExpressionAttributeNames: {
+          '#cacheKey': this.opts.hashKeyName,
+        },
+        ExpressionAttributeValues: {
+          ':cacheKey': this.opts.hashKeyValue,
+        },
+      };
+      rval = await this.dynamo.fullyExecuteQuery<SimpleCacheObjectWrapper<any>>(qry);
+    } else {
+      const scan: ScanCommandInput = {
+        TableName: this.opts.tableName,
+      };
+      rval = await this.dynamo.fullyExecuteScan<SimpleCacheObjectWrapper<any>>(scan);
+    }
+    rval.forEach((r) => this.cleanDynamoFieldsFromObjectInPlace(r));
+
+    return rval;
+  }
+}
+
+export interface DynamoDbSimpleCacheOptions {
+  tableName: string;
+  useRangeKeys: boolean;
+  hashKeyName: string;
+  rangeKeyName?: string;
+  hashKeyValue?: string;
+  dynamoExpiresColumnName?: string;
+}

package/src/dynamodb/impl/dynamo-db-sync-lock.spec.ts

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

package/src/dynamodb/impl/dynamo-db-sync-lock.ts

@@ -0,0 +1,78 @@
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { DynamoRatchet } from '../dynamo-ratchet.js';
+import { DeleteCommandOutput, PutCommand, PutCommandOutput, ScanCommandInput } from '@aws-sdk/lib-dynamodb';
+import { SyncLockProvider } from '../../sync-lock/sync-lock-provider.js';
+import { ConditionalCheckFailedException, ReturnConsumedCapacity } from '@aws-sdk/client-dynamodb';
+
+export class DynamoDbSyncLock implements SyncLockProvider {
+  constructor(
+    private ratchet: DynamoRatchet,
+    private tableName: string,
+  ) {
+    RequireRatchet.notNullOrUndefined(ratchet, 'ratchet');
+    RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(this.tableName), 'tableName');
+  }
+
+  public async acquireLock(lockKey: string, expirationSeconds: number = 30): Promise<boolean> {
+    let rval: boolean = false;
+    if (!!lockKey && !!expirationSeconds) {
+      const nowSeconds: number = Math.floor(new Date().getTime() / 1000);
+      const row: any = {
+        lockingKey: lockKey,
+        timestamp: nowSeconds,
+        expires: nowSeconds + expirationSeconds,
+      };
+
+      const params = {
+        Item: row,
+        ReturnConsumedCapacity: ReturnConsumedCapacity.TOTAL,
+        TableName: this.tableName,
+        ConditionExpression: 'attribute_not_exists(lockingKey)',
+      };
+
+      try {
+        const _pio: PutCommandOutput = await this.ratchet.getDDB().send(new PutCommand(params));
+        rval = true;
+      } catch (err) {
+        if (err instanceof ConditionalCheckFailedException) {
+          Logger.silly('Unable to acquire lock on %s', lockKey);
+        }
+      }
+    }
+
+    return rval;
+  }
+
+  public async releaseLock(lockKey: string): Promise<void> {
+    if (StringRatchet.trimToNull(lockKey)) {
+      try {
+        const dio: DeleteCommandOutput = 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);
+      }
+    }
+  }
+
+  public async clearExpiredSyncLocks(): Promise<number> {
+    const nowSeconds: number = Math.floor(new Date().getTime() / 1000);
+    const scan: ScanCommandInput = {
+      TableName: this.tableName,
+      FilterExpression: 'expires < :now',
+      ExpressionAttributeValues: {
+        ':now': nowSeconds,
+      },
+    };
+
+    const vals: any[] = await this.ratchet.fullyExecuteScan(scan);
+    const keysOnly: any[] = vals.map((v) => {
+      const next: any = { lockingKey: v['lockingKey'] };
+      return next;
+    });
+    const removed: number = await this.ratchet.deleteAllInBatches(this.tableName, keysOnly, 25);
+
+    return removed;
+  }
+}

package/src/dynamodb/impl/dynamo-expiring-code-provider.ts

@@ -0,0 +1,31 @@
+import { ExpiringCodeProvider } from '../../expiring-code/expiring-code-provider.js';
+import { DynamoRatchet } from '../dynamo-ratchet.js';
+import { ExpiringCode } from '../../expiring-code/expiring-code.js';
+import { DynamoTableRatchet } from '../dynamo-table-ratchet.js';
+import { PutCommandOutput } from '@aws-sdk/lib-dynamodb';
+
+export class DynamoExpiringCodeProvider implements ExpiringCodeProvider {
+  constructor(
+    private tableName: string,
+    private dynamoRatchet: DynamoRatchet,
+  ) {}
+
+  public async checkCode(code: string, context: string, deleteOnMatch?: boolean): Promise<boolean> {
+    const keys: any = { code: code, context: context };
+    const expCode: ExpiringCode = await this.dynamoRatchet.simpleGet<ExpiringCode>(this.tableName, keys);
+    const rval: boolean = expCode && expCode.expiresEpochMS > Date.now();
+    if (rval && deleteOnMatch) {
+      await this.dynamoRatchet.simpleDelete(this.tableName, keys);
+    }
+    return rval;
+  }
+
+  public async storeCode(code: ExpiringCode): Promise<boolean> {
+    const output: PutCommandOutput = await this.dynamoRatchet.simplePut(this.tableName, code);
+    return output && output.ConsumedCapacity.CapacityUnits > 0;
+  }
+
+  public async createTableIfMissing(_dtr: DynamoTableRatchet): Promise<any> {
+    return null; // TODO: Impl
+  }
+}