prime-sdk 1.0.0 → 1.1.2

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "prime-sdk",
-  "version": "1.0.0",
+  "version": "1.1.2",
   "description": "swiss army knife",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "",
   "private": false,
-  "license": "UNLICENSED",
+  "license": "MIT",
   "scripts": {
     "build": "nest build",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
@@ -22,7 +22,12 @@
     "test:e2e": "jest --config ./test/jest-e2e.json"
   },
   "dependencies": {
+    "@aws-sdk/client-kms": "^3.572.0",
+    "@aws-sdk/client-s3": "^3.572.0",
+    "@aws-sdk/client-ses": "^3.572.0",
+    "@aws-sdk/client-sns": "^3.572.0",
     "@aws-sdk/client-sqs": "^3.569.0",
+    "@aws-sdk/s3-request-presigner": "^3.572.0",
     "@nestjs/common": "^10.0.0",
     "@nestjs/config": "^3.2.2",
     "@nestjs/core": "^10.0.0",

package/queue.bash

@@ -2,6 +2,6 @@ awslocal sqs delete-queue --queue-url=http://localhost:4566/000000000000/teste
 awslocal sqs create-queue --queue-name teste
 awslocal sqs purge-queue --queue-url=http://localhost:4566/000000000000/teste
 
-awslocal sns delete-topic --topic-arn arn:aws:sns:us-east-1:000000000000:identity-validation-requested
-awslocal sns create-topic --name identity-validation-requested
-awslocal sns subscribe --topic-arn arn:aws:sns:us-east-1:000000000000:identity-validation-requested --protocol sqs --notification-endpoint arn:aws:sqs:us-east-1:000000000000:teste --attributes RawMessageDelivery=true
+awslocal sns delete-topic --topic-arn arn:aws:sns:us-east-1:000000000000:teste-topic
+awslocal sns create-topic --name teste-topic
+awslocal sns subscribe --topic-arn arn:aws:sns:us-east-1:000000000000:teste-topic --protocol sqs --notification-endpoint arn:aws:sqs:us-east-1:000000000000:teste --attributes RawMessageDelivery=true

package/src/app.module.ts

@@ -1,7 +1,12 @@
 import { Module } from '@nestjs/common';
 import { AppService } from './app.service';
 import { QueueModule } from './lib/queue/queue.module';
+import { StorageModule } from './lib/storage/storage.module';
+import { EventModule } from './lib/events/event.module';
+import { CryptoModule } from './lib/crypto/crypto.module';
+import { EmailModule } from './lib/email/email.module';
 
+//Example
 @Module({
   imports: [
     QueueModule.forRoot({
@@ -12,6 +17,38 @@ import { QueueModule } from './lib/queue/queue.module';
       endpoint: 'http://localhost:4566/',
       region: 'us-east-1',
     }),
+    StorageModule.forRoot({
+      credentials: {
+        accessKeyId: '000000000',
+        secretAccessKey: '000000000',
+      },
+      endpoint: 'http://localhost:4566/sample-bucket',
+      region: 'us-east-1',
+    }),
+    EventModule.forRoot({
+      credentials: {
+        accessKeyId: '000000000',
+        secretAccessKey: '000000000',
+      },
+      endpoint: 'http://localhost:4566/',
+      region: 'us-east-1',
+    }),
+    CryptoModule.forRoot({
+      credentials: {
+        accessKeyId: '000000000',
+        secretAccessKey: '000000000',
+      },
+      endpoint: 'http://localhost:4566/',
+      region: 'us-east-1',
+    }),
+    EmailModule.forRoot({
+      credentials: {
+        accessKeyId: '000000000',
+        secretAccessKey: '000000000',
+      },
+      endpoint: 'http://localhost:4566/',
+      region: 'us-east-1',
+    }),
   ],
   providers: [AppService],
   exports: [],

package/src/app.service.ts

@@ -2,10 +2,16 @@ import { Injectable } from '@nestjs/common';
 import { IConsumer } from './lib/queue/interfaces/consumer.interface';
 import { Message } from '@aws-sdk/client-sqs';
 import { Queue } from './lib/queue/queue';
+import { Storage } from './lib/storage/storage';
+import { Events } from './lib/events/events';
 
 @Injectable()
 export class AppService implements IConsumer {
-  constructor(private readonly queueHandler: Queue) {
+  constructor(
+    private readonly queueHandler: Queue,
+    private readonly storage: Storage,
+    private readonly event: Events,
+  ) {
     this.queueHandler.handler({
       QueueUrl: `${'teste'}`,
       context: this,
@@ -16,6 +22,23 @@ export class AppService implements IConsumer {
 
   handleMessage(message: Message | Message[]): Promise<void> {
     console.log(message);
+
+    const data = JSON.stringify({ teste: new Date().toISOString() });
+
+    this.event.triggerEvent({
+      topic: 'arn:aws:sns:us-east-1:000000000000:teste-topic',
+      message: data,
+    });
+
+    const file = Buffer.from(data, 'utf-8');
+
+    this.storage.uploadFile({
+      bucket: 'sample-bucket',
+      file: file,
+      nameFile: 'teste.txt',
+      path: 'prime-sdk',
+    });
+
     return;
   }
 

package/src/external/aws/kms/kms.provider.ts

@@ -0,0 +1,39 @@
+import { KMSClient } from '@aws-sdk/client-kms';
+import { DynamicModule } from '@nestjs/common';
+
+export type KMSSetup = {
+  region: string;
+  endpoint?: string;
+  credentials: {
+    accessKeyId: string;
+    secretAccessKey: string;
+  };
+};
+
+const KMSProvider = (params: KMSSetup) => {
+  return {
+    provide: 'CONNECTION_KMS',
+    useFactory: () => {
+      return new KMSClient({
+        credentials: {
+          accessKeyId: params.credentials.accessKeyId,
+          secretAccessKey: params.credentials.secretAccessKey,
+        },
+        ...(params.endpoint && { endpoint: params.endpoint }),
+        region: params.region,
+      });
+    },
+  };
+};
+
+export class KMSModule {
+  static forRoot(params: KMSSetup): DynamicModule {
+    const kmsProvider = KMSProvider(params);
+
+    return {
+      module: KMSModule,
+      providers: [kmsProvider],
+      exports: [kmsProvider],
+    };
+  }
+}

package/src/external/aws/kms/kms.service.ts

@@ -0,0 +1,33 @@
+import { Inject, Injectable } from '@nestjs/common';
+import {
+  DecryptCommand,
+  DecryptCommandOutput,
+  EncryptCommand,
+  EncryptCommandOutput,
+  KMSClient,
+} from '@aws-sdk/client-kms';
+import { ICrypto } from 'src/lib/crypto/interfaces/crypto.interface';
+import { DecryptData, EncryptData } from 'src/lib/crypto/types/crypto.type';
+
+@Injectable()
+export class KMS implements ICrypto {
+  constructor(@Inject('CONNECTION_KMS') private readonly client: KMSClient) {}
+
+  async encrypt(data: EncryptData): Promise<EncryptCommandOutput> {
+    const command = new EncryptCommand({
+      KeyId: data.keyId,
+      Plaintext: data.value,
+    });
+
+    return await this.client.send(command);
+  }
+
+  async decrypt(data: DecryptData): Promise<DecryptCommandOutput> {
+    const command = new DecryptCommand({
+      CiphertextBlob: data.value,
+      KeyId: data.keyId,
+    });
+
+    return await this.client.send(command);
+  }
+}

package/src/external/aws/s3/s3.provider.ts

@@ -0,0 +1,39 @@
+import { S3Client } from '@aws-sdk/client-s3';
+import { DynamicModule } from '@nestjs/common';
+
+export type S3Setup = {
+  region: string;
+  endpoint?: string;
+  credentials: {
+    accessKeyId: string;
+    secretAccessKey: string;
+  };
+};
+
+const S3Provider = (params: S3Setup) => {
+  return {
+    provide: 'CONNECTION_S3',
+    useFactory: () => {
+      return new S3Client({
+        credentials: {
+          accessKeyId: params.credentials.accessKeyId,
+          secretAccessKey: params.credentials.secretAccessKey,
+        },
+        ...(params.endpoint && { endpoint: params.endpoint }),
+        region: params.region,
+      });
+    },
+  };
+};
+
+export class S3Module {
+  static forRoot(params: S3Setup): DynamicModule {
+    const s3Provider = S3Provider(params);
+
+    return {
+      module: S3Module,
+      providers: [s3Provider],
+      exports: [s3Provider],
+    };
+  }
+}

package/src/external/aws/s3/s3.service.ts

@@ -0,0 +1,86 @@
+import {
+  DeleteObjectCommand,
+  DeleteObjectCommandOutput,
+  GetObjectCommand,
+  GetObjectCommandOutput,
+  ListObjectsV2Command,
+  ListObjectsV2CommandOutput,
+  PutObjectCommand,
+  PutObjectCommandOutput,
+  S3Client,
+} from '@aws-sdk/client-s3';
+import { Inject, Injectable } from '@nestjs/common';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { IStorage } from '../../../lib/storage/interfaces/storage.interface';
+import {
+  DeleteFile,
+  GetFile,
+  ListFiles,
+  UploadFile,
+} from '../../../lib/storage/types/storage.type';
+
+@Injectable()
+export class S3 implements IStorage {
+  constructor(@Inject('CONNECTION_S3') private readonly client: S3Client) {}
+
+  async uploadFile(file: UploadFile): Promise<PutObjectCommandOutput> {
+    const command = new PutObjectCommand({
+      Bucket: file.bucket,
+      Key: `${file.path}/${file.nameFile}`,
+      Body: file.file,
+    });
+
+    const response = await this.client.send(command);
+
+    return response;
+  }
+
+  async generateSignUrlFile(file: GetFile): Promise<string> {
+    const params = {
+      Bucket: file.bucket,
+      Key: file.key,
+      ResponseContentType: file.responseContentType,
+    };
+
+    const command = new GetObjectCommand(params);
+
+    const url = await getSignedUrl(this.client, command, { expiresIn: 3600 });
+
+    return url;
+  }
+
+  async getFile(file: GetFile): Promise<GetObjectCommandOutput> {
+    const params = {
+      Bucket: file.bucket,
+      Key: file.key,
+      ResponseContentType: file.responseContentType,
+    };
+
+    const command = new GetObjectCommand(params);
+
+    const response = await this.client.send(command);
+
+    return response;
+  }
+
+  async listFiles(data: ListFiles): Promise<ListObjectsV2CommandOutput> {
+    const params = { Bucket: data.bucket, Prefix: data.folder };
+
+    const command = new ListObjectsV2Command(params);
+
+    const response = await this.client.send(command);
+
+    return response;
+  }
+
+  async deleteFile(file: DeleteFile): Promise<DeleteObjectCommandOutput> {
+    const params = {
+      Bucket: file.bucket,
+      Key: file.key,
+    };
+
+    const command = new DeleteObjectCommand(params);
+
+    return await this.client.send(command);
+  }
+}

package/src/external/aws/ses/ses.provider.ts

@@ -0,0 +1,39 @@
+import { SESClient } from '@aws-sdk/client-ses';
+import { DynamicModule } from '@nestjs/common';
+
+export type SESSetup = {
+  region: string;
+  endpoint?: string;
+  credentials: {
+    accessKeyId: string;
+    secretAccessKey: string;
+  };
+};
+
+const SESProvider = (params: SESSetup) => {
+  return {
+    provide: 'CONNECTION_SES',
+    useFactory: () => {
+      return new SESClient({
+        credentials: {
+          accessKeyId: params.credentials.accessKeyId,
+          secretAccessKey: params.credentials.secretAccessKey,
+        },
+        ...(params.endpoint && { endpoint: params.endpoint }),
+        region: params.region,
+      });
+    },
+  };
+};
+
+export class SESModule {
+  static forRoot(params: SESSetup): DynamicModule {
+    const sesProvider = SESProvider(params);
+
+    return {
+      module: SESModule,
+      providers: [sesProvider],
+      exports: [sesProvider],
+    };
+  }
+}

package/src/external/aws/ses/ses.service.ts

@@ -0,0 +1,52 @@
+import { Inject, Injectable } from '@nestjs/common';
+import {
+  SendEmailCommand,
+  SendEmailCommandOutput,
+  SendRawEmailCommand,
+  SendRawEmailCommandOutput,
+  SESClient,
+} from '@aws-sdk/client-ses';
+import { IEmail } from 'src/lib/email/interfaces/email.interface';
+import { SendMail, SendRawMail } from 'src/lib/email/types/email.type';
+
+@Injectable()
+export class SES implements IEmail {
+  constructor(@Inject('CONNECTION_SES') private readonly client: SESClient) {}
+
+  async sendRawEmail(data: SendRawMail): Promise<SendRawEmailCommandOutput> {
+    const resEncodedMessage = new TextEncoder().encode(data.message);
+
+    const params = {
+      Source: data.from,
+      Destination: data.to,
+      RawMessage: {
+        Data: resEncodedMessage,
+      },
+    };
+
+    const command = new SendRawEmailCommand(params);
+
+    return await this.client.send(command);
+  }
+
+  async sendEmail(data: SendMail): Promise<SendEmailCommandOutput> {
+    const command = new SendEmailCommand({
+      Source: data.source,
+      Destination: { ToAddresses: data.destination },
+      Message: {
+        Body: {
+          Html: {
+            Charset: 'UTF-8',
+            Data: data.message,
+          },
+        },
+        Subject: {
+          Charset: 'UTF-8',
+          Data: data.message,
+        },
+      },
+    });
+
+    return await this.client.send(command);
+  }
+}

package/src/external/aws/sns/sns.provider.ts

@@ -0,0 +1,39 @@
+import { SNSClient } from '@aws-sdk/client-sns';
+import { DynamicModule } from '@nestjs/common';
+
+export type SNSSetup = {
+  region: string;
+  endpoint?: string;
+  credentials: {
+    accessKeyId: string;
+    secretAccessKey: string;
+  };
+};
+
+const SNSProvider = (params: SNSSetup) => {
+  return {
+    provide: 'CONNECTION_SNS',
+    useFactory: () => {
+      return new SNSClient({
+        credentials: {
+          accessKeyId: params.credentials.accessKeyId,
+          secretAccessKey: params.credentials.secretAccessKey,
+        },
+        ...(params.endpoint && { endpoint: params.endpoint }),
+        region: params.region,
+      });
+    },
+  };
+};
+
+export class SNSModule {
+  static forRoot(params: SNSSetup): DynamicModule {
+    const snsProvider = SNSProvider(params);
+
+    return {
+      module: SNSModule,
+      providers: [snsProvider],
+      exports: [snsProvider],
+    };
+  }
+}

package/src/external/aws/sns/sns.service.ts

@@ -0,0 +1,31 @@
+import {
+  PublishCommand,
+  PublishCommandOutput,
+  SNSClient,
+} from '@aws-sdk/client-sns';
+import { Inject, Injectable } from '@nestjs/common';
+import { IEvent } from 'src/lib/events/interfaces/event.interface';
+import { EventData, EventSmsData } from 'src/lib/events/types/event.type';
+
+@Injectable()
+export class Sns implements IEvent {
+  constructor(@Inject('CONNECTION_SNS') private readonly client: SNSClient) {}
+
+  async publishSns(event: EventData): Promise<PublishCommandOutput> {
+    const command = new PublishCommand({
+      TopicArn: event.topic,
+      Message: event.message,
+    });
+
+    return await this.client.send(command);
+  }
+
+  async publishSms(event: EventSmsData): Promise<PublishCommandOutput> {
+    const command = new PublishCommand({
+      PhoneNumber: event.phoneNumber,
+      Message: event.message,
+    });
+
+    return await this.client.send(command);
+  }
+}

package/src/lib/crypto/crypto.module.ts

@@ -0,0 +1,17 @@
+import { DynamicModule, Module } from '@nestjs/common';
+import { Crypto } from './crypto';
+import { ICrypto } from './interfaces/crypto.interface';
+import { KMS } from '../../external/aws/kms/kms.service';
+import { KMSModule, KMSSetup } from 'src/external/aws/kms/kms.provider';
+
+@Module({})
+export class CryptoModule {
+  static forRoot(params: KMSSetup): DynamicModule {
+    return {
+      module: CryptoModule,
+      imports: [KMSModule.forRoot(params)],
+      providers: [Crypto, { provide: ICrypto, useClass: KMS }],
+      exports: [Crypto, { provide: ICrypto, useClass: KMS }],
+    };
+  }
+}

package/src/lib/crypto/crypto.ts

@@ -0,0 +1,20 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { ICrypto } from './interfaces/crypto.interface';
+import {
+  DecryptCommandOutput,
+  EncryptCommandOutput,
+} from '@aws-sdk/client-kms';
+import { DecryptData, EncryptData } from './types/crypto.type';
+
+@Injectable()
+export class Crypto {
+  constructor(@Inject(ICrypto) private readonly crypto: ICrypto) {}
+
+  async encrypt(data: EncryptData): Promise<EncryptCommandOutput> {
+    return await this.crypto.encrypt(data);
+  }
+
+  async decrypt(data: DecryptData): Promise<DecryptCommandOutput> {
+    return await this.crypto.encrypt(data);
+  }
+}

package/src/lib/crypto/interfaces/crypto.interface.ts

@@ -0,0 +1,12 @@
+import {
+  DecryptCommandOutput,
+  EncryptCommandOutput,
+} from '@aws-sdk/client-kms';
+import { DecryptData, EncryptData } from '../types/crypto.type';
+
+export interface ICrypto {
+  encrypt(data: EncryptData): Promise<EncryptCommandOutput>;
+  decrypt(data: DecryptData): Promise<DecryptCommandOutput>;
+}
+
+export const ICrypto = Symbol('ICrypto');

package/src/lib/crypto/types/crypto.type.ts

@@ -0,0 +1,3 @@
+export type EncryptData = { keyId: string; value: Uint8Array };
+
+export type DecryptData = { keyId: string; value: Buffer };

package/src/lib/email/email.module.ts

@@ -0,0 +1,17 @@
+import { DynamicModule, Module } from '@nestjs/common';
+import { SESModule, SESSetup } from 'src/external/aws/ses/ses.provider';
+import { IEmail } from './interfaces/email.interface';
+import { SES } from 'src/external/aws/ses/ses.service';
+import { Email } from './email';
+
+@Module({})
+export class EmailModule {
+  static forRoot(params: SESSetup): DynamicModule {
+    return {
+      module: EmailModule,
+      imports: [SESModule.forRoot(params)],
+      providers: [Email, { provide: IEmail, useClass: SES }],
+      exports: [Email, { provide: IEmail, useClass: SES }],
+    };
+  }
+}

package/src/lib/email/email.ts

@@ -0,0 +1,20 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { IEmail } from './interfaces/email.interface';
+import {
+  SendEmailCommandOutput,
+  SendRawEmailCommandOutput,
+} from '@aws-sdk/client-ses';
+import { SendMail, SendRawMail } from './types/email.type';
+
+@Injectable()
+export class Email {
+  constructor(@Inject(IEmail) private readonly email: IEmail) {}
+
+  async sendRawEmail(data: SendRawMail): Promise<SendRawEmailCommandOutput> {
+    return await this.email.sendRawEmail(data);
+  }
+
+  async sendEmail(data: SendMail): Promise<SendEmailCommandOutput> {
+    return await this.email.sendEmail(data);
+  }
+}

package/src/lib/email/interfaces/email.interface.ts

@@ -0,0 +1,12 @@
+import {
+  SendEmailCommandOutput,
+  SendRawEmailCommandOutput,
+} from '@aws-sdk/client-ses';
+import { SendMail, SendRawMail } from '../types/email.type';
+
+export interface IEmail {
+  sendRawEmail(data: SendRawMail): Promise<SendRawEmailCommandOutput>;
+  sendEmail(data: SendMail): Promise<SendEmailCommandOutput>;
+}
+
+export const IEmail = Symbol('IEmail');

package/src/lib/email/types/email.type.ts

@@ -0,0 +1,12 @@
+export type SendRawMail = {
+  message: string;
+  from: string;
+  to: Array<string>;
+};
+
+export type SendMail = {
+  source: string;
+  destination: Array<string>;
+  message: string;
+  subject: string;
+};

package/src/lib/events/event.module.ts

@@ -0,0 +1,17 @@
+import { DynamicModule, Module } from '@nestjs/common';
+import { SNSModule, SNSSetup } from '../../external/aws/sns/sns.provider';
+import { IEvent } from './interfaces/event.interface';
+import { Sns } from 'src/external/aws/sns/sns.service';
+import { Events } from './events';
+
+@Module({})
+export class EventModule {
+  static forRoot(params: SNSSetup): DynamicModule {
+    return {
+      module: EventModule,
+      imports: [SNSModule.forRoot(params)],
+      providers: [Events, { provide: IEvent, useClass: Sns }],
+      exports: [Events, { provide: IEvent, useClass: Sns }],
+    };
+  }
+}

package/src/lib/events/events.ts

@@ -1,4 +1,17 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
+import { IEvent } from './interfaces/event.interface';
+import { EventData, EventSmsData } from './types/event.type';
+import { PublishCommandOutput } from '@aws-sdk/client-sns';
 
 @Injectable()
-export class Events {}
+export class Events {
+  constructor(@Inject(IEvent) private readonly event: IEvent) {}
+
+  async triggerEvent(event: EventData): Promise<PublishCommandOutput> {
+    return this.event.publishSns(event);
+  }
+
+  async publishSms(event: EventSmsData): Promise<PublishCommandOutput> {
+    return this.event.publishSms(event);
+  }
+}

package/src/lib/events/interfaces/event.interface.ts

@@ -0,0 +1,9 @@
+import { PublishCommandOutput } from '@aws-sdk/client-sns';
+import { EventData, EventSmsData } from '../types/event.type';
+
+export interface IEvent {
+  publishSns(event: EventData): Promise<PublishCommandOutput>;
+  publishSms(event: EventSmsData): Promise<PublishCommandOutput>;
+}
+
+export const IEvent = Symbol('IEvent');