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

package/src/s3/s3-ratchet.ts

@@ -0,0 +1,26 @@
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+
+export class S3Ratchet {
+  // Returns whether the URL passed is s3 valid (not whether it exists or not)
+  public static checkS3UrlForValidity(value: string): boolean {
+    let rval: boolean = false;
+    if (value) {
+      rval = value.startsWith('s3://') && value.trim().length > 5;
+    }
+    return rval;
+  }
+
+  public static extractBucketFromURL(value: string): string {
+    RequireRatchet.true(S3Ratchet.checkS3UrlForValidity(value), 'invalid s3 url');
+    const idx1: number = value.indexOf('/', 5);
+    const rval: string = idx1 > 0 ? value.substring(5, idx1) : value.substring(5);
+    return rval;
+  }
+
+  public static extractKeyFromURL(value: string): string {
+    RequireRatchet.true(S3Ratchet.checkS3UrlForValidity(value), 'invalid s3 url');
+    const idx1: number = value.indexOf('/', 5);
+    const rval: string = idx1 > 0 ? value.substring(idx1 + 1) : null;
+    return rval;
+  }
+}

package/src/ses/ses-mail-sending-provider.ts

@@ -0,0 +1,85 @@
+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 { SendRawEmailCommand, SendRawEmailCommandOutput, SendRawEmailRequest, SESClient } from '@aws-sdk/client-ses';
+import { DateTime } from 'luxon';
+import { CompleteMultipartUploadCommandOutput } from '@aws-sdk/client-s3';
+import { S3CacheRatchetLike } from '../s3/s3-cache-ratchet-like.js';
+import { MailSendingProvider } from '@bitblit/ratchet-common/mail/mail-sending-provider';
+import { ResolvedReadyToSendEmail } from '@bitblit/ratchet-common/mail/resolved-ready-to-send-email';
+import { MailerUtil } from '@bitblit/ratchet-common/mail/mailer-util';
+
+/**
+ * Generic Mail Sender for AWS.
+ *
+ * Params:
+ * ses: AWS SES handler, properly configured
+ * defaultSendingAddress:
+ */
+export class SesMailSendingProvider implements MailSendingProvider<SendRawEmailCommandOutput, CompleteMultipartUploadCommandOutput> {
+  constructor(
+    private _ses: SESClient,
+    private _archiveRatchet?: S3CacheRatchetLike,
+    private archivePrefix?: string,
+  ) {
+    RequireRatchet.notNullOrUndefined(this._ses);
+    if (!!_archiveRatchet && !_archiveRatchet.getDefaultBucket()) {
+      throw new Error('If archiveRatchet specified, must set a default bucket');
+    }
+  }
+
+  public async archiveEmail(
+    mail: ResolvedReadyToSendEmail,
+    _rawSendResult: SendRawEmailCommandOutput,
+  ): Promise<CompleteMultipartUploadCommandOutput> {
+    let rval: CompleteMultipartUploadCommandOutput = null;
+    if (this._archiveRatchet) {
+      Logger.debug('Archiving outbound email to : %j', mail.destinationAddresses);
+      let targetPath: string = StringRatchet.trimToEmpty(this.archivePrefix);
+      if (!targetPath.endsWith('/')) {
+        targetPath += '/';
+      }
+      const now: DateTime = DateTime.utc();
+      targetPath +=
+        'year=' +
+        now.toFormat('yyyy') +
+        '/month=' +
+        now.toFormat('MM') +
+        '/day=' +
+        now.toFormat('dd') +
+        '/hour=' +
+        now.toFormat('HH') +
+        '/' +
+        now.toFormat('mm_ss__SSS');
+      targetPath += '.json';
+      try {
+        rval = await this._archiveRatchet.writeObjectToCacheFile(targetPath, mail);
+      } catch (err) {
+        Logger.warn('Failed to archive email %s %j : %s', targetPath, mail, err);
+      }
+    }
+    return rval;
+  }
+
+  public get sesClient(): SESClient {
+    return this._ses;
+  }
+
+  public get archiveRatchet(): S3CacheRatchetLike {
+    return this._archiveRatchet;
+  }
+
+  public async sendEmail(inRts: ResolvedReadyToSendEmail): Promise<SendRawEmailCommandOutput> {
+    RequireRatchet.notNullOrUndefined(inRts, 'RTS must be defined');
+    RequireRatchet.notNullOrUndefined(inRts.destinationAddresses, 'Destination addresses must be defined');
+    let rval: SendRawEmailCommandOutput = null;
+    const rawMail: string = MailerUtil.convertResolvedReadyToSendEmailToRaw(inRts);
+
+    const params: SendRawEmailRequest = {
+      RawMessage: { Data: new TextEncoder().encode(rawMail) },
+    };
+
+    rval = await this._ses.send(new SendRawEmailCommand(params));
+    return rval;
+  }
+}

package/src/sns/sns-ratchet.spec.ts

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

package/src/sns/sns-ratchet.ts

@@ -0,0 +1,52 @@
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { PublishCommand, PublishCommandInput, PublishCommandOutput, SNSClient } from '@aws-sdk/client-sns';
+
+export class SnsRatchet {
+  constructor(
+    private sns: SNSClient = new SNSClient({ region: 'us-east-1' }),
+    private topicArn: string,
+  ) {
+    RequireRatchet.notNullOrUndefined(this.sns, 'sns');
+    RequireRatchet.notNullOrUndefined(this.topicArn, 'topicArn');
+  }
+
+  public get snsClient(): SNSClient {
+    return this.sns;
+  }
+
+  public async sendMessage(inMsg: any, suppressErrors: boolean = false): Promise<PublishCommandOutput> {
+    let result: PublishCommandOutput = null;
+    try {
+      const safeInMsg: any = inMsg ? inMsg : 'NO-MESSAGE-PROVIDED';
+      const msg: string = typeof safeInMsg === 'string' ? safeInMsg : JSON.stringify(safeInMsg);
+
+      const params: PublishCommandInput = {
+        TopicArn: this.topicArn,
+        Message: msg,
+      };
+
+      Logger.debug('Sending via SNS : %j', params);
+      result = await this.sns.send(new PublishCommand(params));
+    } catch (err) {
+      if (suppressErrors) {
+        Logger.error('Failed to fire SNS notification : %j : %s', inMsg, err);
+      } else {
+        throw err;
+      }
+    }
+    return result;
+  }
+
+  // Kinda a special case, used for when you want to only send messages when a certain condition is true
+  // (Like when you are running in production)
+  public async conditionallySendMessage(inMsg: any, condition: boolean, suppressErrors: boolean = false): Promise<PublishCommandOutput> {
+    let rval: PublishCommandOutput = null;
+    if (condition) {
+      rval = await this.sendMessage(inMsg, suppressErrors);
+    } else {
+      Logger.info('Not sending message, condition was false : %j', inMsg);
+    }
+    return rval;
+  }
+}

package/src/sync-lock/memory-sync-lock.ts

@@ -0,0 +1,48 @@
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { SyncLockProvider } from './sync-lock-provider.js';
+
+/**
+ * Simple in-memory implementation of the SyncLockProvider interface
+ */
+export class MemorySyncLock implements SyncLockProvider {
+  private _locks: Map<string, number> = new Map<string, number>();
+
+  // Empty constructor prevents instantiation
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+  constructor() {
+    // Placeholder
+  }
+
+  public async acquireLock(lockKey: string, expirationSeconds: number = 30): Promise<boolean> {
+    let rval: boolean = false;
+    if (StringRatchet.trimToNull(lockKey)) {
+      const now: number = Date.now();
+      const val: number = this._locks.get(lockKey);
+      if (!val || val < now) {
+        this._locks.set(lockKey, now + expirationSeconds * 1000);
+        rval = true;
+      }
+    }
+    return rval;
+  }
+
+  public async releaseLock(lockKey: string): Promise<void> {
+    if (StringRatchet.trimToNull(lockKey)) {
+      this._locks.delete(lockKey);
+    }
+  }
+
+  public async clearExpiredSyncLocks(): Promise<number> {
+    const toRemove: string[] = [];
+    const now: number = Date.now();
+    this._locks.forEach((v, k) => {
+      if (v < now) {
+        toRemove.push(k);
+      }
+    });
+    toRemove.forEach((k) => {
+      this._locks.delete(k);
+    });
+    return toRemove.length;
+  }
+}

package/src/sync-lock/sync-lock-provider.ts

@@ -0,0 +1,5 @@
+export interface SyncLockProvider {
+  acquireLock(lockKey: string, expirationSeconds?: number): Promise<boolean>;
+  releaseLock(lockKey: string): Promise<void>;
+  clearExpiredSyncLocks?(): Promise<number>;
+}