@bitblit/ratchet-aws 4.0.99-alpha → 4.0.103-alpha

package/lib/s3/s3-cache-ratchet.spec.js

@@ -0,0 +1,97 @@
+import { CopyObjectCommand, CreateMultipartUploadCommand, GetObjectCommand, HeadObjectCommand, PutObjectCommand, S3Client, UploadPartCommand, } from '@aws-sdk/client-s3';
+import { S3CacheRatchet } from './s3-cache-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
+import { StreamRatchet } from '@bitblit/ratchet-common/lib/stream/stream-ratchet.js';
+import { mockClient } from 'aws-sdk-client-mock';
+import { jest } from '@jest/globals';
+jest.mock('@aws-sdk/s3-request-presigner', () => ({
+    getSignedUrl: jest.fn(() => Promise.resolve('https://test.link/test.jpg')),
+}));
+let mockS3 = null;
+let mockS3OtherAccount = null;
+describe('#fileExists', function () {
+    mockS3 = mockClient(S3Client);
+    mockS3OtherAccount = mockClient(S3Client);
+    beforeEach(() => {
+        mockS3.reset();
+        mockS3OtherAccount.reset();
+    });
+    it('should return false for files that do not exist', async () => {
+        mockS3.on(HeadObjectCommand).rejects({ statusCode: 404, $metadata: null });
+        const cache = new S3CacheRatchet(mockS3, 'test-bucket');
+        const out = await cache.fileExists('test-missing-file');
+        expect(out).toEqual(false);
+    });
+    xit('should create a expiring link', async () => {
+        const cache = new S3CacheRatchet(mockS3, 'test-bucket');
+        const out = await cache.preSignedDownloadUrlForCacheFile('test.jpg', 300);
+        expect(out).toEqual('https://test.link/test.jpg');
+    });
+    it('should copy an object', async () => {
+        mockS3.on(CopyObjectCommand).resolves({});
+        const cache = new S3CacheRatchet(mockS3, 'test-bucket');
+        const out = await cache.quietCopyFile('test.png', 'test2.png');
+        expect(out).toBeTruthy();
+    });
+    xit('should copy a file to s3', async () => {
+        mockS3.on(PutObjectCommand).resolves({});
+        mockS3.on(CreateMultipartUploadCommand).resolves({ UploadId: '1' });
+        mockS3.on(UploadPartCommand).resolves({ ETag: '1' });
+        const cache = new S3CacheRatchet(mockS3, 'test-bucket');
+        const stream = StreamRatchet.stringToWebReadableStream(StringRatchet.createRandomHexString(1024 * 1024 * 6));
+        const out = await cache.writeStreamToCacheFile('s3-cache-ratchet.spec.ts', stream, {
+            ContentType: 'text/typescript',
+        });
+        Logger.info('Calls: %j', mockS3.calls());
+        expect(out).toBeTruthy();
+    });
+    it('should pull a file as a string', async () => {
+        async function createNew() {
+            return {
+                Body: {
+                    transformToByteArray: async () => Promise.resolve(StringRatchet.stringToUint8Array(JSON.stringify({ test: StringRatchet.createRandomHexString(128) }))),
+                    transformToString: async () => Promise.resolve(JSON.stringify({ test: StringRatchet.createRandomHexString(128) })),
+                },
+                $metadata: null,
+            };
+        }
+        mockS3.on(GetObjectCommand).resolves(createNew());
+        const cache = new S3CacheRatchet(mockS3, 'test-bucket');
+        const fileName = 'test-file.json';
+        const outBuf = await cache.fetchCacheFileAsBuffer(fileName);
+        expect(outBuf).toBeTruthy();
+        expect(outBuf.length).toBeGreaterThan(100);
+        mockS3.reset();
+        mockS3.on(GetObjectCommand).resolves(createNew());
+        const outString = await cache.fetchCacheFileAsString(fileName);
+        expect(outString).toBeTruthy();
+        expect(outString.length).toBeGreaterThan(100);
+        mockS3.reset();
+        mockS3.on(GetObjectCommand).resolves(createNew());
+        const outObject = await cache.fetchCacheFileAsObject(fileName);
+        expect(outObject).toBeTruthy();
+        expect(outObject['test']).toBeTruthy();
+    });
+    xit('should sync 2 folders', async () => {
+        const cache1 = new S3CacheRatchet(mockS3, 'test1');
+        const cache2 = new S3CacheRatchet(mockS3, 'test2');
+        const out = await cache1.synchronize('src/', 'dst/', cache2);
+        expect(out).not.toBeNull();
+    }, 60_000);
+    xit('should list direct children past 1000', async () => {
+        const s3 = new S3Client({ region: 'us-east-1' });
+        const cache = new S3CacheRatchet(s3, 'test-bucket');
+        const out = await cache.directChildrenOfPrefix('test/aws/test-path-with-lots-of-childen/');
+        expect(out).toBeTruthy();
+        expect(out.length).toBeGreaterThan(1000);
+        Logger.info('Got: %s', out);
+        expect(out).toBeTruthy();
+    });
+    xit('should sync cross-account', async () => {
+        const cache1 = new S3CacheRatchet(mockS3, 'bucket1');
+        const cache2 = new S3CacheRatchet(mockS3OtherAccount, 'bucket2');
+        const res = await cache1.synchronize('test1/', 'test2/', cache2, true);
+        expect(res).not.toBeNull();
+    }, 50_000);
+});

package/{dist/types → lib}/s3/s3-cache-to-local-disk-ratchet.d.ts

@@ -1,8 +1,5 @@
-/// <reference types="node" />
-import { S3CacheRatchet } from './s3-cache-ratchet';
-/**
- * Use this when you want a lambda to cache a remote S3 bucket locally on disk for faster access
- */
+/// <reference types="node" resolution-mode="require"/>
+import { S3CacheRatchet } from './s3-cache-ratchet.js';
 export declare class S3CacheToLocalDiskRatchet {
     private s3;
     private tmpFolder;

package/{dist/es → lib}/s3/s3-cache-to-local-disk-ratchet.js

@@ -1,13 +1,19 @@
 import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
-import { Logger, RequireRatchet, StringRatchet } from '@bitblit/ratchet-common';
+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';
 export class S3CacheToLocalDiskRatchet {
+    s3;
+    tmpFolder;
+    cacheTimeoutSeconds;
+    static DEFAULT_CACHE_TIMEOUT_SEC = 7 * 24 * 3600;
+    currentlyLoading = new Map();
     constructor(s3, tmpFolder, cacheTimeoutSeconds = S3CacheToLocalDiskRatchet.DEFAULT_CACHE_TIMEOUT_SEC) {
         this.s3 = s3;
         this.tmpFolder = tmpFolder;
         this.cacheTimeoutSeconds = cacheTimeoutSeconds;
-        this.currentlyLoading = new Map();
         RequireRatchet.notNullOrUndefined(s3, 's3');
         RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(tmpFolder));
         RequireRatchet.true(fs.existsSync(tmpFolder), 'folder must exist : ' + tmpFolder);
@@ -97,4 +103,3 @@ export class S3CacheToLocalDiskRatchet {
         return rval;
     }
 }
-S3CacheToLocalDiskRatchet.DEFAULT_CACHE_TIMEOUT_SEC = 7 * 24 * 3600;

package/lib/s3/s3-cache-to-local-dist-ratchet.spec.d.ts

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

package/lib/s3/s3-cache-to-local-dist-ratchet.spec.js

@@ -0,0 +1,22 @@
+import { S3CacheToLocalDiskRatchet } from './s3-cache-to-local-disk-ratchet.js';
+import { tmpdir } from 'os';
+import { JestRatchet } from '@bitblit/ratchet-jest/lib/jest/jest-ratchet.js';
+import { jest } from '@jest/globals';
+let mockS3CR;
+describe('#S3CacheToLocalDiskRatchet', () => {
+    beforeEach(() => {
+        mockS3CR = JestRatchet.mock(jest.fn);
+    });
+    it('should download file and store in tmp', async () => {
+        mockS3CR.fetchCacheFileAsBuffer.mockResolvedValue(Buffer.from(JSON.stringify({ a: 'b' })));
+        const pth = 'test-path';
+        const svc = new S3CacheToLocalDiskRatchet(mockS3CR, tmpdir());
+        svc.removeCacheFileForKey(pth);
+        const proms = [];
+        for (let i = 0; i < 5; i++) {
+            proms.push(svc.getFileBuffer(pth));
+        }
+        const all = await Promise.all(proms);
+        expect(all.length).toEqual(5);
+    });
+});

package/{dist/es → lib}/s3/s3-location-sync-ratchet.js

@@ -1,8 +1,11 @@
 import { CopyObjectCommand, GetObjectCommand, ListObjectsV2Command, } from '@aws-sdk/client-s3';
 import _ from 'lodash';
-import { Logger, PromiseRatchet, RequireRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
 import { Upload } from '@aws-sdk/lib-storage';
 export class S3LocationSyncRatchet {
+    config;
     constructor(config) {
         RequireRatchet.notNullOrUndefined(config, 'config');
         this.config = config;

package/{dist/es → lib}/s3/s3-ratchet.js

@@ -1,4 +1,4 @@
-import { RequireRatchet } from '@bitblit/ratchet-common';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
 export class S3Ratchet {
     static checkS3UrlForValidity(value) {
         let rval = false;

package/lib/s3/s3-ratchet.spec.d.ts

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

package/lib/s3/s3-ratchet.spec.js

@@ -0,0 +1,20 @@
+import { S3Client } from '@aws-sdk/client-s3';
+import { S3Ratchet } from './s3-ratchet.js';
+import { mockClient } from 'aws-sdk-client-mock';
+let mockS3;
+describe('#S3Ratchet', function () {
+    mockS3 = mockClient(S3Client);
+    beforeEach(() => {
+        mockS3.reset();
+    });
+    it('should checkS3UrlForValidity', async () => {
+        expect(S3Ratchet.checkS3UrlForValidity('s3://test/out/b.txt')).toBeTruthy();
+        expect(S3Ratchet.checkS3UrlForValidity('http://test/out/b.txt')).toBeFalsy();
+    });
+    it('should extractBucketFromURL', async () => {
+        expect(S3Ratchet.extractBucketFromURL('s3://test/out/b.txt')).toEqual('test');
+    });
+    it('should extractKeyFromURL', async () => {
+        expect(S3Ratchet.extractKeyFromURL('s3://test/out/b.txt')).toEqual('out/b.txt');
+    });
+});

package/lib/ses/email-attachment.d.ts

@@ -0,0 +1,5 @@
+export interface EmailAttachment {
+    filename?: string;
+    contentType?: string;
+    base64Data?: string;
+}

package/lib/ses/email-attachment.js

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

package/{dist/types → lib}/ses/mailer-config.d.ts

@@ -1,8 +1,5 @@
-import { RatchetTemplateRenderer } from './ratchet-template-renderer';
-import { S3CacheRatchet } from '../s3/s3-cache-ratchet';
-/**
- * Configuration options for generic mailer
- */
+import { RatchetTemplateRenderer } from './ratchet-template-renderer.js';
+import { S3CacheRatchet } from '../s3/s3-cache-ratchet.js';
 export interface MailerConfig {
     defaultSendingAddress?: string;
     autoBccAddresses?: string[];

package/lib/ses/mailer-config.js

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

package/{dist/types → lib}/ses/mailer-like.d.ts

@@ -1,13 +1,6 @@
-import { ReadyToSendEmail } from './ready-to-send-email';
+import { ReadyToSendEmail } from './ready-to-send-email.js';
 import { SendRawEmailResponse } from '@aws-sdk/client-ses';
-import { ResolvedReadyToSendEmail } from './resolved-ready-to-send-email';
-/**
- * Generic Mail Sender for AWS.
- *
- * Params:
- * ses: AWS SES handler, properly configured
- * defaultSendingAddress:
- */
+import { ResolvedReadyToSendEmail } from './resolved-ready-to-send-email.js';
 export interface MailerLike {
     fillEmailBody(rts: ReadyToSendEmail, context: any, htmlTemplateName: string, txtTemplateName?: string, layoutName?: string, partialNames?: string[]): Promise<ReadyToSendEmail>;
     fillEmailBodyAndSend(rts: ReadyToSendEmail, context: any, htmlTemplateName: string, txtTemplateName?: string, layoutName?: string, partialNames?: string[]): Promise<SendRawEmailResponse>;

package/lib/ses/mailer-like.js

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

package/{dist/types → lib}/ses/mailer.d.ts

@@ -1,15 +1,8 @@
-import { ReadyToSendEmail } from './ready-to-send-email';
+import { ReadyToSendEmail } from './ready-to-send-email.js';
 import { SendRawEmailCommandOutput, SendRawEmailResponse, SESClient } from '@aws-sdk/client-ses';
-import { MailerConfig } from './mailer-config';
-import { ResolvedReadyToSendEmail } from './resolved-ready-to-send-email';
-import { MailerLike } from './mailer-like';
-/**
- * Generic Mail Sender for AWS.
- *
- * Params:
- * ses: AWS SES handler, properly configured
- * defaultSendingAddress:
- */
+import { MailerConfig } from './mailer-config.js';
+import { ResolvedReadyToSendEmail } from './resolved-ready-to-send-email.js';
+import { MailerLike } from './mailer-like.js';
 export declare class Mailer implements MailerLike {
     private ses;
     private config;

package/{dist/es → lib}/ses/mailer.js

@@ -1,11 +1,14 @@
-import { Logger } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
+import { Base64Ratchet } from '@bitblit/ratchet-common/lib/lang/base64-ratchet.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
 import { SendRawEmailCommand } from '@aws-sdk/client-ses';
-import { StringRatchet } from '@bitblit/ratchet-common';
-import { ErrorRatchet } from '@bitblit/ratchet-common';
 import { DateTime } from 'luxon';
-import { Base64Ratchet } from '@bitblit/ratchet-common';
-import { RequireRatchet } from '@bitblit/ratchet-common';
 export class Mailer {
+    ses;
+    config;
+    static EMAIL = new RegExp('.+@.+\\.[a-z]+');
     constructor(ses, config = {}) {
         this.ses = ses;
         this.config = config;
@@ -201,4 +204,3 @@ export class Mailer {
         return email !== null && Mailer.EMAIL.test(email);
     }
 }
-Mailer.EMAIL = new RegExp('.+@.+\\.[a-z]+');

package/lib/ses/mailer.spec.d.ts

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

package/lib/ses/mailer.spec.js

@@ -0,0 +1,104 @@
+import { SendRawEmailCommand, SESClient } from '@aws-sdk/client-ses';
+import { Mailer } from './mailer.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
+import { Base64Ratchet } from '@bitblit/ratchet-common/lib/lang/base64-ratchet.js';
+import { mockClient } from 'aws-sdk-client-mock';
+let mockSES;
+const smallImageBase64 = 'iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3Y5AAAADklEQVQI12P4AIX8EAgALgAD/aNpbtEAAAAASUVORK5CYII';
+describe('#mailer', function () {
+    mockSES = mockClient(SESClient);
+    beforeEach(() => {
+        mockSES.reset();
+    });
+    it('should send email', async () => {
+        const config = {
+            defaultSendingAddress: 'test1@test.com',
+            autoBccAddresses: [],
+            archive: null,
+            archivePrefix: null,
+        };
+        const svc = new Mailer(mockSES, config);
+        const attach1 = {
+            filename: 'test.txt',
+            contentType: 'text/plain',
+            base64Data: Base64Ratchet.generateBase64VersionOfString('This is a test2'),
+        };
+        const attach2 = {
+            filename: 'a2.png',
+            contentType: 'image/png',
+            base64Data: smallImageBase64,
+        };
+        const rts = {
+            txtMessage: 'test txt',
+            htmlMessage: '<h1>Test html</h1><p>Test paragraph</p>',
+            subject: 'Test subject',
+            fromAddress: 'test@test.com',
+            destinationAddresses: ['testout@test.com'],
+            attachments: [attach1, attach2],
+        };
+        mockSES.on(SendRawEmailCommand).resolves({});
+        const result = await svc.sendEmail(rts);
+        expect(result).toBeTruthy();
+    });
+    it('should allow for unicode in email subject', async () => {
+        const config = {
+            defaultSendingAddress: 'jflint@adomni.com',
+            autoBccAddresses: [],
+            archive: null,
+            archivePrefix: null,
+        };
+        const svc = new Mailer(mockSES, config);
+        const rts = {
+            txtMessage: 'test txt',
+            htmlMessage: '<h1>Test html</h1><p>Test paragraph</p>',
+            subject: "Rappel: Votre panneau d'affichage Shout est diffusé aujourd'hui!",
+            fromAddress: 'jflint@adomni.com',
+            destinationAddresses: ['jflint@adomni.com'],
+        };
+        mockSES.on(SendRawEmailCommand).resolves({});
+        const result = await svc.sendEmail(rts);
+        expect(result).toBeTruthy();
+    });
+    it('should filter outbound', async () => {
+        const config = {
+            allowedDestinationEmails: [/.*test\.com/, /.*.test2\.com/],
+        };
+        const svc = new Mailer({}, config);
+        const out1 = ['a@test.com', 'b@fail.com'];
+        const res1 = svc.filterEmailsToValid(out1);
+        expect(res1).toBeTruthy();
+        expect(res1.length).toEqual(1);
+        const out2 = ['a@fail.com', 'b@fail.com'];
+        const res2 = svc.filterEmailsToValid(out2);
+        expect(res2).toBeTruthy();
+        expect(res2.length).toEqual(0);
+    });
+    it('should fix a huge text/html body', async () => {
+        const config = {
+            defaultSendingAddress: 'test@test.com',
+            autoBccAddresses: [],
+            archive: null,
+            archivePrefix: null,
+            maxMessageBodySizeInBytes: 500,
+            maxAttachmentSizeInBase64Bytes: 1000,
+        };
+        const svc = new Mailer(mockSES, config);
+        const bigBody = StringRatchet.createRandomHexString(300);
+        const bigAttach = {
+            filename: 'test.txt',
+            contentType: 'text/plain',
+            base64Data: Base64Ratchet.generateBase64VersionOfString(StringRatchet.createRandomHexString(2000)),
+        };
+        const rts = {
+            txtMessage: bigBody,
+            htmlMessage: bigBody,
+            subject: 'Test big message',
+            fromAddress: 'test@test.com',
+            destinationAddresses: ['test@test.com'],
+            attachments: [bigAttach],
+        };
+        mockSES.on(SendRawEmailCommand).resolves({});
+        const result = await svc.sendEmail(rts);
+        expect(result).toBeTruthy();
+    });
+});

package/{dist/types → lib}/ses/ratchet-template-renderer.d.ts

@@ -1,7 +1,3 @@
-/**
- * tbd
- * @interface RatchetTemplateRenderer
- */
 export interface RatchetTemplateRenderer {
     renderTemplate(templateName: string, context: any, layoutName?: string, partialNames?: string[]): Promise<string>;
     renderTemplateDirect(templateValue: string, context: any, layoutName?: string): Promise<string>;

package/lib/ses/ratchet-template-renderer.js

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

package/lib/ses/ready-to-send-email.d.ts

@@ -0,0 +1,13 @@
+import { EmailAttachment } from './email-attachment.js';
+export interface ReadyToSendEmail {
+    destinationAddresses?: Array<string>;
+    bccAddresses?: Array<string>;
+    attachments?: Array<EmailAttachment>;
+    fromAddress?: string;
+    txtMessage?: string;
+    htmlMessage?: string;
+    subject?: string;
+    fromName?: string;
+    doNotAutoBcc?: boolean;
+    doNotArchive?: boolean;
+}

package/lib/ses/ready-to-send-email.js

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

package/{dist/types → lib}/ses/remote-handlebars-template-renderer.d.ts

@@ -1,6 +1,4 @@
-import { RatchetTemplateRenderer } from './ratchet-template-renderer';
-/**
- */
+import { RatchetTemplateRenderer } from './ratchet-template-renderer.js';
 export declare class RemoteHandlebarsTemplateRenderer implements RatchetTemplateRenderer {
     private prefix;
     private suffix;

package/{dist/es → lib}/ses/remote-handlebars-template-renderer.js

@@ -1,9 +1,13 @@
 import handlebars from 'handlebars';
 import fetch from 'cross-fetch';
-import { StringRatchet } from '@bitblit/ratchet-common';
-import { Logger } from '@bitblit/ratchet-common';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
 import layouts from 'handlebars-layouts';
 export class RemoteHandlebarsTemplateRenderer {
+    prefix;
+    suffix;
+    maxCacheTemplates;
+    cache;
     constructor(prefix = '', suffix = '', maxCacheTemplates = 10) {
         this.prefix = prefix;
         this.suffix = suffix;

package/lib/ses/resolved-ready-to-send-email.d.ts

@@ -0,0 +1,5 @@
+import { ReadyToSendEmail } from './ready-to-send-email.js';
+export interface ResolvedReadyToSendEmail extends ReadyToSendEmail {
+    srcDestinationAddresses?: string[];
+    srcBccAddresses?: string[];
+}

package/lib/ses/resolved-ready-to-send-email.js

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

package/{dist/es → lib}/sns/sns-ratchet.js

@@ -1,7 +1,9 @@
-import { Logger } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
 import { PublishCommand, SNSClient } from '@aws-sdk/client-sns';
-import { RequireRatchet } from '@bitblit/ratchet-common';
 export class SnsRatchet {
+    sns;
+    topicArn;
     constructor(sns = new SNSClient({ region: 'us-east-1' }), topicArn) {
         this.sns = sns;
         this.topicArn = topicArn;

package/lib/sns/sns-ratchet.spec.d.ts

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

package/lib/sns/sns-ratchet.spec.js

@@ -0,0 +1,17 @@
+import { PublishCommand, SNSClient } from '@aws-sdk/client-sns';
+import { SnsRatchet } from './sns-ratchet.js';
+import { mockClient } from 'aws-sdk-client-mock';
+let mockSNS;
+describe('#SNSRatchet', function () {
+    mockSNS = mockClient(SNSClient);
+    beforeEach(() => {
+        mockSNS.reset();
+    });
+    it('should send a message', async () => {
+        mockSNS.on(PublishCommand).resolves({});
+        const topicArn = 'TOPIC-ARN-HERE';
+        const ratchet = new SnsRatchet(mockSNS, topicArn);
+        const out = await ratchet.sendMessage('test \n\n' + new Date() + '\n\n---\n\nTest CR');
+        expect(out).toBeTruthy();
+    });
+});

package/{dist/types → lib}/sync-lock/dynamo-db-sync-lock.d.ts

@@ -1,5 +1,5 @@
-import { DynamoRatchet } from '../dynamodb/dynamo-ratchet';
-import { SyncLockProvider } from './sync-lock-provider';
+import { DynamoRatchet } from '../dynamodb/dynamo-ratchet.js';
+import { SyncLockProvider } from './sync-lock-provider.js';
 export declare class DynamoDbSyncLock implements SyncLockProvider {
     private ratchet;
     private tableName;

package/{dist/es → lib}/sync-lock/dynamo-db-sync-lock.js

@@ -1,6 +1,10 @@
-import { Logger, RequireRatchet, StringRatchet } from '@bitblit/ratchet-common';
+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;

package/lib/sync-lock/dynamo-db-sync-lock.spec.d.ts

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

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

@@ -0,0 +1,30 @@
+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/{dist/types → lib}/sync-lock/memory-sync-lock.d.ts

@@ -1,7 +1,4 @@
-import { SyncLockProvider } from './sync-lock-provider';
-/**
- * Simple in-memory implementation of the SyncLockProvider interface
- */
+import { SyncLockProvider } from './sync-lock-provider.js';
 export declare class MemorySyncLock implements SyncLockProvider {
     private _locks;
     constructor();

package/{dist/es → lib}/sync-lock/memory-sync-lock.js

@@ -1,8 +1,7 @@
-import { StringRatchet } from '@bitblit/ratchet-common';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
 export class MemorySyncLock {
-    constructor() {
-        this._locks = new Map();
-    }
+    _locks = new Map();
+    constructor() { }
     async acquireLock(lockKey, expirationSeconds = 30) {
         let rval = false;
         if (StringRatchet.trimToNull(lockKey)) {

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

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

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@bitblit/ratchet-aws",
-  "version": "4.0.99-alpha",
+  "version": "4.0.103-alpha",
   "description": "Common tools for use with AWS browser and node",
   "sideEffects": false,
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/types/index.d.ts",
+  "type": "module",
+  "module": "index.js",
   "files": [
-    "dist/*"
+    "lib/*",
+    "bin/*"
   ],
   "contributors": [
     "Christopher Weiss <bitblit@gmail.com>",
@@ -30,16 +30,15 @@
   "config": {},
   "scripts": {
     "watch": "tsc-watch",
-    "clean": "shx rm -Rf dist",
-    "test": "jest",
+    "clean": "shx rm -Rf lib",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest",
     "docs": "typedoc",
     "lint": "eslint src/**/*.ts",
     "lint-fix": "eslint --fix src/**/*.ts",
-    "generate-barrels": "barrelsby -q --delete -d src -e .*\\.spec\\.ts",
-    "build": "yarn run generate-barrels && concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
-    "build:cjs": "tsc -p tsconfig.cjs.json",
-    "build:es": "tsc -p tsconfig.es.json",
-    "build:types": "tsc -p tsconfig.types.json"
+    "__generate-barrels": "barrelsby -q --delete -d src -e .*\\.spec\\.ts",
+    "__build": "yarn run generate-barrels && tsc",
+    "build": "tsc",
+    "force-build": "tsc --build --force"
   },
   "repository": {
     "type": "git",