mblabs-roccato-backend-commons 1.0.8 → 1.1.0

package/src/services/azure/application-insights.ts

@@ -3,28 +3,28 @@ import * as ApplicationInsights from 'applicationinsights';
 import { AzureApplicationInsights, IAzureApplicationInsightsService } from '../../interfaces/azure';
 
 class AzureApplicationInsightsService implements IAzureApplicationInsightsService {
-  async trackTrace ({ credentials, data }: AzureApplicationInsights.TrackTrace.Request) {
-    const client = new ApplicationInsights.TelemetryClient(credentials.connection!);
+  async trackTrace (req: AzureApplicationInsights.TrackTrace.Request) {
+    const client = new ApplicationInsights.TelemetryClient(req.credentials.connection!);
 
-    client.trackTrace({ message: data.message, severity: data.severity });
+    client.trackTrace({ message: req.message, severity: req.severity });
   }
 
-  async trackEvent ({ credentials, data }: AzureApplicationInsights.TrackEvent.Request) {
-    const client = new ApplicationInsights.TelemetryClient(credentials.connection!);
+  async trackEvent (req: AzureApplicationInsights.TrackEvent.Request) {
+    const client = new ApplicationInsights.TelemetryClient(req.credentials.connection!);
 
-    client.trackEvent({ name: data.name, properties: data.properties });
+    client.trackEvent({ name: req.name, properties: req.properties });
   }
 
-  async trackException ({ credentials, data }: AzureApplicationInsights.TrackException.Request) {
-    const client = new ApplicationInsights.TelemetryClient(credentials.connection!);
+  async trackException (req: AzureApplicationInsights.TrackException.Request) {
+    const client = new ApplicationInsights.TelemetryClient(req.credentials.connection!);
 
-    client.trackException({ exception: data.error });
+    client.trackException({ exception: req.error });
   }
 
-  async trackMetric ({ credentials, data }: AzureApplicationInsights.TrackMetric.Request) {
-    const client = new ApplicationInsights.TelemetryClient(credentials.connection!);
+  async trackMetric (req: AzureApplicationInsights.TrackMetric.Request) {
+    const client = new ApplicationInsights.TelemetryClient(req.credentials.connection!);
 
-    client.trackMetric({ name: data.name, value: data.value });
+    client.trackMetric({ name: req.name, value: req.value });
   }
 }
 

package/src/services/azure/communication.ts

@@ -4,17 +4,17 @@ import { SmsClient, SmsSendRequest } from '@azure/communication-sms';
 import { AzureCommunication, IAzureCommunicationService } from '../../interfaces/azure';
 
 class AzureCommunicationService implements IAzureCommunicationService {
-  async sendMail ({ credentials, data }: AzureCommunication.SendMail.Request): Promise<void> {
-    const client = new EmailClient(credentials.connection!);
+  async sendMail (req: AzureCommunication.SendMail.Request): Promise<void> {
+    const client = new EmailClient(req.credentials.connection!);
 
-    const recipients = Array.isArray(data.emails) ? data.emails : [ data.emails ];
+    const recipients = Array.isArray(req.emails) ? req.emails : [ req.emails ];
     const addresses = recipients.map(recipient => ({ address: recipient }));
 
     const payload: EmailMessage = {
-      senderAddress: data.from,
+      senderAddress: req.from,
       content: {
-        subject: data.subject,
-        plainText: data.text,
+        subject: req.subject,
+        plainText: req.text,
       },
       recipients: {
         to: addresses,
@@ -25,17 +25,17 @@ class AzureCommunicationService implements IAzureCommunicationService {
     await poller.pollUntilDone();
   }
 
-  async sendTemplateMail ({ credentials, data }: AzureCommunication.SendTemplateMail.Request): Promise<void> {
-    const client = new EmailClient(credentials.connection!);
+  async sendTemplateMail (req: AzureCommunication.SendTemplateMail.Request): Promise<void> {
+    const client = new EmailClient(req.credentials.connection!);
 
-    const recipients = Array.isArray(data.emails) ? data.emails : [ data.emails ];
+    const recipients = Array.isArray(req.emails) ? req.emails : [ req.emails ];
     const addresses = recipients.map(recipient => ({ address: recipient }));
 
     const payload: EmailMessage = {
-      senderAddress: data.from,
+      senderAddress: req.from,
       content: {
-        subject: data.subject,
-        html: data.template,
+        subject: req.subject,
+        html: req.template,
       },
       recipients: {
         to: addresses,
@@ -46,14 +46,14 @@ class AzureCommunicationService implements IAzureCommunicationService {
     await poller.pollUntilDone();
   }
 
-  async sendSMS ({ credentials, data }: AzureCommunication.SendSMS.Request): Promise<void> {
-    const client = new SmsClient(credentials.connection!);
+  async sendSMS (req: AzureCommunication.SendSMS.Request): Promise<void> {
+    const client = new SmsClient(req.credentials.connection!);
 
-    const recipients = Array.isArray(data.phones) ? data.phones : [ data.phones ];
+    const recipients = Array.isArray(req.phones) ? req.phones : [ req.phones ];
 
     const payload: SmsSendRequest = {
-      from: data.sender,
-      message: data.text,
+      from: req.sender,
+      message: req.text,
       to: recipients,
     };
 
@@ -61,4 +61,4 @@ class AzureCommunicationService implements IAzureCommunicationService {
   }
 }
 
-export default new AzureCommunicationService();
+export default new AzureCommunicationService();

package/src/services/azure/keyvault.ts

@@ -5,11 +5,11 @@ import { AzureKeyVault, IAzureKeyVaultService } from '../../interfaces/azure';
 import { parseRecord } from '../../utils/parser';
 
 class AzureKeyVaultService implements IAzureKeyVaultService {
-  async getSecret<T> ({ data }: AzureKeyVault.GetSecret.Request): Promise<AzureKeyVault.GetSecret.Response<T>> {
+  async getSecret<T> (req: AzureKeyVault.GetSecret.Request): Promise<AzureKeyVault.GetSecret.Response<T>> {
     const credential = new DefaultAzureCredential();
-    const client = new SecretClient(data.vault, credential);
+    const client = new SecretClient(req.vault, credential);
 
-    const { value } = await client.getSecret(data.secretName);
+    const { value } = await client.getSecret(req.secretName);
 
     if (value) {
       const secret = parseRecord(value) as T;

package/src/services/azure/storage-blob.ts

@@ -11,37 +11,34 @@ import DateService from '../../services/date';
 import FileService from '../../services/file';
 
 class AzureStorageBlobService implements IAzureStorageBlobService {
-  async uploadBuffer ({
-    credentials,
-    data,
-  }: AzureStorageBlob.UploadBuffer.Request): Promise<void> {
+
+  async uploadBuffer (req: AzureStorageBlob.UploadBuffer.Request): Promise<void> {
     const sharedKeyCredential = new StorageSharedKeyCredential(
-      credentials.accountName!,
-      credentials.accountKey!
+      req.credentials.accountName!,
+      req.credentials.accountKey!
     );
 
-    const client = new BlobServiceClient(data.storageUrl, sharedKeyCredential);
+    const client = new BlobServiceClient(req.storageUrl, sharedKeyCredential);
 
     await client
-      .getContainerClient(data.storageContainer)
-      .getBlockBlobClient(data.filename)
-      .uploadData(data.file);
+      .getContainerClient(req.storageContainer)
+      .getBlockBlobClient(req.filename)
+      .uploadData(req.file);
   }
 
-  async downloadBuffer ({
-    credentials,
-    data,
-  }: AzureStorageBlob.DownloadBuffer.Request): Promise<AzureStorageBlob.DownloadBuffer.Response> {
+  async downloadBuffer (
+    req: AzureStorageBlob.DownloadBuffer.Request
+  ): Promise<AzureStorageBlob.DownloadBuffer.Response> {
     const sharedKeyCredential = new StorageSharedKeyCredential(
-      credentials.accountName!,
-      credentials.accountKey!
+      req.credentials.accountName!,
+      req.credentials.accountKey!
     );
 
-    const client = new BlobServiceClient(data.storageUrl, sharedKeyCredential);
+    const client = new BlobServiceClient(req.storageUrl, sharedKeyCredential);
 
     const { readableStreamBody } = await client
-      .getContainerClient(data.storageContainer)
-      .getBlockBlobClient(data.filename)
+      .getContainerClient(req.storageContainer)
+      .getBlockBlobClient(req.filename)
       .download(0);
 
     const buffer = await FileService.streamToBuffer(readableStreamBody);
@@ -51,31 +48,30 @@ class AzureStorageBlobService implements IAzureStorageBlobService {
     };
   }
 
-  async getPreSignedUrl ({
-    credentials,
-    data,
-  }: AzureStorageBlob.GetPreSignedUrl.Request): Promise<AzureStorageBlob.GetPreSignedUrl.Response> {
+  async getPreSignedUrl (
+    req: AzureStorageBlob.GetPreSignedUrl.Request
+  ): Promise<AzureStorageBlob.GetPreSignedUrl.Response> {
     const sharedKeyCredential = new StorageSharedKeyCredential(
-      credentials.accountName!,
-      credentials.accountKey!
+      req.credentials.accountName!,
+      req.credentials.accountKey!
     );
 
     const payload: BlobSASSignatureValues = {
-      containerName: data.storageContainer,
-      blobName: data.filename,
-      version: data.options?.version,
-      contentEncoding: data.options?.contentEncoding,
-      contentType: data.options?.contentType,
+      containerName: req.storageContainer,
+      blobName: req.filename,
+      version: req.options?.version,
+      contentEncoding: req.options?.contentEncoding,
+      contentType: req.options?.contentType,
       permissions: 'rwac' as unknown as BlobSASPermissions,
       startsOn:
-        data.options?.hoursToExpire &&
+        req.options?.hoursToExpire &&
         DateService.getCurrentDate(),
       expiresOn:
-        data.options?.hoursToExpire &&
-        DateService.addHours(DateService.getCurrentDate(), Number(data.options?.hoursToExpire)),
+        req.options?.hoursToExpire &&
+        DateService.addHours(DateService.getCurrentDate(), Number(req.options?.hoursToExpire)),
     };
 
-    const url = `https://${credentials.accountName!}.blob.core.windows.net/${data.storageContainer}/${data.filename}`;
+    const url = `https://${req.credentials.accountName!}.blob.core.windows.net/${req.storageContainer}/${req.filename}`;
     const token = generateBlobSASQueryParameters(payload, sharedKeyCredential).toString();
 
     return {

package/src/services/firebase.ts

@@ -3,41 +3,31 @@ import FirebaseAdmin from 'firebase-admin';
 import { Firebase, IFirebaseService } from '../interfaces/firebase';
 
 class FirebaseService implements IFirebaseService {
-  async publishConfig ({
-    credentials,
-    data,
-  }: Firebase.PublishConfig.Request): Promise<void> {
+  async publishConfig (req: Firebase.PublishConfig.Request): Promise<void> {
     const client = FirebaseAdmin.initializeApp({
-      credential: FirebaseAdmin.credential.cert(credentials.cert),
-      databaseURL: credentials.database,
-    }, credentials.instance);
+      credential: FirebaseAdmin.credential.cert(req.credentials.cert),
+      databaseURL: req.credentials.database,
+    }, req.credentials.instance);
 
     const template = client
       .remoteConfig()
-      .createTemplateFromJSON(data.template);
+      .createTemplateFromJSON(req.template);
 
     await client
       .remoteConfig()
       .publishTemplate(template);
-
-    await client.delete();
   }
 
-  async sendNotification ({
-    credentials,
-    data,
-  }: Firebase.SendNotification.Request): Promise<void> {
+  async sendNotification (req: Firebase.SendNotification.Request): Promise<void> {
     const client = FirebaseAdmin.initializeApp({
-      credential: FirebaseAdmin.credential.cert(credentials.cert),
-      databaseURL: credentials.database,
-    }, credentials.instance);
+      credential: FirebaseAdmin.credential.cert(req.credentials.cert),
+      databaseURL: req.credentials.database,
+    }, req.credentials.instance);
 
     await client
       .messaging()
-      .sendEachForMulticast(data.message, data.isTest);
-
-    await client.delete();
+      .sendEachForMulticast(req.message, req.isTest);
   }
 }
 
-export default new FirebaseService();
+export default new FirebaseService();

package/src/services/gcp/drive.ts

@@ -3,21 +3,18 @@ import { google } from 'googleapis';
 import { GoogleDrive, IGoogleDriveService } from '../../interfaces/gcp';
 
 class GoogleDriveService implements IGoogleDriveService {
-  public async readFile ({
-    credentials,
-    data,
-  }: GoogleDrive.ReadFile.Request): Promise<GoogleDrive.ReadFile.Response> {
+  public async readFile (req: GoogleDrive.ReadFile.Request): Promise<GoogleDrive.ReadFile.Response> {
     const instance = google.drive({
       version: 'v3',
-      auth: credentials.apiKey,
+      auth: req.credentials.apiKey,
     });
 
-    const { data: response } = await instance.files.get({ fileId: data.file });
+    const { data } = await instance.files.get({ fileId: req.fileId });
 
     return {
-      file: response,
+      file: data,
     };
   }
 }
 
-export default new GoogleDriveService();
+export default new GoogleDriveService();

package/src/services/gcp/secrets.ts

@@ -4,21 +4,22 @@ import { GoogleSecrets, IGoogleSecretsService } from '../../interfaces/gcp';
 import { parseRecord } from '../../utils/parser';
 
 class GoogleSecretsService implements IGoogleSecretsService {
-  public async getSecret<T> ({
-    credentials,
-    data,
-  }: GoogleSecrets.GetSecret.Request): Promise<GoogleSecrets.GetSecret.Response<T>> {
-    const client = new SecretManagerServiceClient({ apiKey: credentials.apiKey });
+  public async getSecret<T> (req: GoogleSecrets.GetSecret.Request): Promise<GoogleSecrets.GetSecret.Response<T>> {
+    const credentials = JSON.parse(req.credentials.apiKey);
+
+    const client = new SecretManagerServiceClient({ credentials });
 
     const [ version ] = await client.accessSecretVersion({
-      name: `projects/${data.project}/secrets/${data.secret}/versions/latest`,
+      name: `projects/${req.projectId}/secrets/${req.secretId}/versions/latest`,
     });
 
-    const buffer = (version.payload?.data ?? new Uint8Array()) as Uint8Array;
-    const secret = Buffer.from(buffer).toString('utf-8');
+    const data = (version.payload?.data ?? new Uint8Array()) as Uint8Array;
+    const secretData = Buffer.from(data).toString('utf-8');
+
+    const secret = parseRecord(secretData) as T;
 
     return {
-      secret: parseRecord(secret) as T,
+      secret,
     };
   }
 }

package/src/services/gcp/sheets.ts

@@ -3,24 +3,21 @@ import { google } from 'googleapis';
 import { GoogleSheets, IGoogleSheetsService } from '../../interfaces/gcp';
 
 class GoogleSheetsService implements IGoogleSheetsService {
-  public async readSheet ({
-    credentials,
-    data,
-  }: GoogleSheets.ReadSheet.Request): Promise<GoogleSheets.ReadSheet.Response> {
+  public async readSheet (req: GoogleSheets.ReadSheet.Request): Promise<GoogleSheets.ReadSheet.Response> {
     const instance = google.sheets({
       version: 'v4',
-      auth: credentials.apiKey,
+      auth: req.credentials.apiKey,
     });
 
-    const { data: response } = await instance.spreadsheets.values.batchGet({
-      spreadsheetId: data.spreadsheet,
-      ranges: data.tabs,
+    const { data } = await instance.spreadsheets.values.batchGet({
+      spreadsheetId: req.spreadsheetId,
+      ranges: req.tabs,
     });
 
     return {
-      sheet: response,
+      sheet: data,
     };
   }
 }
 
-export default new GoogleSheetsService();
+export default new GoogleSheetsService();

package/src/services/grafana.ts

@@ -2,42 +2,36 @@ import { Grafana, IGrafanaService } from '../interfaces/grafana';
 import HttpService from './http';
 
 class GrafanaService implements IGrafanaService {
-  async getDashboard ({
-    credentials,
-    data,
-  }: Grafana.GetDashboard.Request): Promise<Grafana.GetDashboard.Response> {
-    const { data: response } = await HttpService.request<unknown>({
+  async getDashboard (req: Grafana.GetDashboard.Request): Promise<Grafana.GetDashboard.Response> {
+    const { data } = await HttpService.request<unknown>({
       method: 'get',
-      baseURL: credentials.url,
-      resourcePath: `/api/dashboards/uid/${data.uid}`,
+      baseURL: req.credentials.url,
+      resourcePath: `/api/dashboards/uid/${req.uid}`,
       headers: {
-        Authorization: `Bearer ${credentials.apiKey}`,
+        Authorization: `Bearer ${req.credentials.apiKey}`,
       },
     });
 
     return {
-      dashboard: response,
+      dashboard: data,
     };
   }
 
-  async searchDashboard ({
-    credentials,
-    data,
-  }: Grafana.SearchDashboard.Request): Promise<Grafana.SearchDashboard.Response> {
-    const { data: response } = await HttpService.request<unknown>({
+  async searchDashboard (req: Grafana.SearchDashboard.Request): Promise<Grafana.SearchDashboard.Response> {
+    const { data } = await HttpService.request<unknown>({
       method: 'get',
-      baseURL: credentials.url,
+      baseURL: req.credentials.url,
       resourcePath: '/api/search',
       headers: {
-        Authorization: `Bearer ${credentials.apiKey}`,
+        Authorization: `Bearer ${req.credentials.apiKey}`,
       },
       query: {
-        query: data.query,
+        query: req.query,
       },
     });
 
     return {
-      dashboards: response as unknown[],
+      dashboards: data as unknown[],
     };
   }
 }