mblabs-roccato-backend-commons 1.0.7 → 1.1.0

package/dist/interfaces/keycloak.d.ts

@@ -1,37 +1,15 @@
 interface Credentials {
-    clientId: string;
     realm: string;
+    clientId: string;
     clientSecret: string;
     grantType: string;
 }
-export interface Roles {
-    id: string;
-    name: string;
-    description: string;
-}
 export declare namespace Keycloak {
     namespace Authenticate {
         interface Request {
             url: string;
-            data: {
-                username: string;
-                password: string;
-            };
-            credentials: Credentials;
-        }
-        interface Response {
-            access_token: string;
-            expires_in: number;
-            refresh_expires_in: number;
-            refresh_token: string;
-            token_type: string;
-            profileType?: number;
-            active?: boolean;
-        }
-    }
-    namespace AuthenticateServer {
-        interface Request {
-            url: string;
+            username: string;
+            password: string;
             credentials: Credentials;
         }
         interface Response {
@@ -47,9 +25,7 @@ export declare namespace Keycloak {
     namespace RefreshAccess {
         interface Request {
             url: string;
-            data: {
-                refreshToken: string;
-            };
+            refreshToken: string;
             credentials: Credentials;
         }
         interface Response {
@@ -62,152 +38,9 @@ export declare namespace Keycloak {
             active?: boolean;
         }
     }
-    namespace RevokeAccess {
-        interface Request {
-            url: string;
-            data: {
-                accessToken: string;
-            };
-            credentials: Credentials;
-        }
-    }
-    namespace CreateUser {
-        interface Request {
-            url: string;
-            data: {
-                username: string;
-                firstName: string;
-                lastName?: string;
-                email: string;
-                password: string;
-                isTemporaryPassword?: boolean;
-                groups: string[];
-            };
-            credentials: Credentials;
-        }
-    }
-    namespace UpdateUser {
-        interface Request {
-            url: string;
-            data: {
-                id: string;
-                username?: string;
-                firstName?: string;
-                lastName?: string;
-                email?: string;
-                password?: string;
-                isTemporaryPassword?: boolean;
-                groups?: string[];
-            };
-            credentials: Credentials;
-        }
-    }
-    namespace GetUser {
-        interface Request {
-            url: string;
-            data: {
-                id: string;
-            };
-            credentials: Credentials;
-        }
-        interface Response {
-            id: string;
-            sub: string;
-            firstName: string;
-            lastName: string;
-            email: string;
-            enabled: boolean;
-            attributes: {
-                isFirstAccess: boolean;
-            };
-        }
-    }
-    namespace DeleteUser {
-        interface Request {
-            url: string;
-            data: {
-                id: string;
-            };
-            credentials: Credentials;
-        }
-    }
-    namespace ChangeUserPassword {
-        interface Request {
-            url: string;
-            data: {
-                id: string;
-                password: string;
-                isTemporaryPassword?: boolean;
-            };
-            credentials: Credentials;
-        }
-    }
-    namespace AddRealm {
-        interface Request {
-            url: string;
-            data: {
-                name: string;
-                enabled: boolean;
-            };
-            credentials: Credentials;
-        }
-    }
-    namespace AddRole {
-        interface Request {
-            url: string;
-            data: {
-                name: string;
-                description: string;
-            };
-            credentials: Credentials;
-        }
-    }
-    namespace AssociateUserRole {
-        interface Request {
-            url: string;
-            data: {
-                user: string;
-                role: string;
-            };
-            credentials: Credentials;
-        }
-    }
-    namespace GetRoles {
-        interface Request {
-            url: string;
-            data: {
-                search: string;
-            };
-            credentials: Credentials;
-        }
-        interface Response {
-            roles: Roles[];
-        }
-    }
-    namespace DeleteRole {
-        interface Request {
-            url: string;
-            data: {
-                id: string;
-            };
-            credentials: Credentials;
-        }
-    }
 }
 export interface IKeycloakService {
     authenticate(req: Keycloak.Authenticate.Request): Promise<Keycloak.Authenticate.Response>;
-    authenticateServer(req: Keycloak.AuthenticateServer.Request): Promise<Keycloak.AuthenticateServer.Response>;
     refreshAccess(req: Keycloak.RefreshAccess.Request): Promise<Keycloak.RefreshAccess.Response>;
-    revokeAccess(req: Keycloak.RevokeAccess.Request): Promise<void>;
-    createUser(req: Keycloak.CreateUser.Request): Promise<void>;
-    updateUser(req: Keycloak.UpdateUser.Request): Promise<void>;
-    getUser(req: Keycloak.GetUser.Request): Promise<Keycloak.GetUser.Response>;
-    deleteUser(req: Keycloak.DeleteUser.Request): Promise<void>;
-    changeUserPassword(req: Keycloak.ChangeUserPassword.Request): Promise<void>;
-    addRealm(req: Keycloak.AddRealm.Request): Promise<void>;
-    addRole(req: Keycloak.AddRole.Request): Promise<void>;
-    associateUserRole(req: Keycloak.AssociateUserRole.Request): Promise<void>;
-    getRoles(req: Keycloak.GetRoles.Request): Promise<Keycloak.GetRoles.Response>;
-    deleteRole(req: Keycloak.DeleteRole.Request): Promise<void>;
 }
 export {};

package/dist/interfaces/nodemailer.d.ts

@@ -10,33 +10,29 @@ interface Credentials {
 export declare namespace NodeMailer {
     namespace Send {
         interface Request {
-            data: {
-                from: {
-                    name: string;
-                    address: string;
-                };
-                to: string;
-                subject: string;
-                text: string;
+            from: {
+                name: string;
+                address: string;
             };
+            to: string;
+            subject: string;
+            text: string;
             credentials: Credentials;
         }
     }
     namespace SendWithTemplate {
         interface Request {
-            data: {
-                from: {
-                    name: string;
-                    address: string;
-                };
-                to: string;
-                subject: string;
-                html: string;
-                attachments: {
-                    filename: string;
-                    content: Buffer;
-                }[];
+            from: {
+                name: string;
+                address: string;
             };
+            to: string;
+            subject: string;
+            html: string;
+            attachments: {
+                filename: string;
+                content: Buffer;
+            }[];
             credentials: Credentials;
         }
     }

package/dist/interfaces/redis.d.ts

@@ -1,54 +1,13 @@
-interface Credentials {
-    host: string;
-    port: number;
-    password?: string;
-}
 export declare namespace Redis {
-    namespace Set {
-        interface Request {
-            data: {
-                key: string;
-                value: unknown;
-                ttl?: number;
-            };
-            credentials: Credentials;
-        }
-    }
-    namespace Get {
-        interface Request {
-            data: {
-                key: string;
-            };
-            credentials: Credentials;
-        }
-        interface Response<T> {
-            data: T;
-        }
-    }
-    namespace Del {
-        interface Request {
-            data: {
-                key: string;
-            };
-            credentials: Credentials;
-        }
-    }
-    namespace Exists {
-        interface Request {
-            data: {
-                key: string;
-            };
-            credentials: Credentials;
-        }
-        interface Response {
-            exists: boolean;
-        }
+    interface Credentials {
+        host: string;
+        port: number;
+        password?: string;
     }
 }
 export interface IRedisService {
-    set(req: Redis.Set.Request): Promise<void>;
-    get<T>(req: Redis.Get.Request): Promise<Redis.Get.Response<T>>;
-    del(req: Redis.Del.Request): Promise<void>;
-    exists(req: Redis.Exists.Request): Promise<Redis.Exists.Response>;
+    set(key: string, value: unknown, ttlInSeconds?: number): Promise<void>;
+    get<T>(key: string): Promise<T | null>;
+    del(key: string): Promise<void>;
+    exists(key: string): Promise<boolean>;
 }
-export {};

package/dist/interfaces/sendgrid.d.ts

@@ -4,21 +4,19 @@ interface Credentials {
 export declare namespace Sendgrid {
     namespace SendMail {
         interface Request {
-            data: {
-                to: string;
-                from: string;
-                subject?: string;
-                text?: string;
-                html?: string;
-                template?: string;
-                substitutions?: Record<string, unknown>;
-                attachments?: {
-                    content: string;
-                    filename: string;
-                    type?: string;
-                    disposition?: string;
-                }[];
-            };
+            to: string;
+            from: string;
+            subject?: string;
+            text?: string;
+            html?: string;
+            template?: string;
+            substitutions?: Record<string, unknown>;
+            attachments?: {
+                content: string;
+                filename: string;
+                type?: string;
+                disposition?: string;
+            }[];
             credentials: Credentials;
         }
     }

package/dist/services/aws/cloudwatch.d.ts

@@ -1,6 +1,6 @@
 import { AmazonCloudwatch, IAmazonCloudwatchService } from '../../interfaces/aws';
 declare class AmazonCloudwatchService implements IAmazonCloudwatchService {
-    createLogEvent({ credentials, data }: AmazonCloudwatch.CreateLogEvent.Request): Promise<void>;
+    createLogEvent(req: AmazonCloudwatch.CreateLogEvent.Request): Promise<void>;
     private getLogGroupByName;
     private getLogStreamByName;
     private listApplicationLogGroups;

package/dist/services/aws/cloudwatch.js

@@ -2,84 +2,84 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const client_cloudwatch_logs_1 = require("@aws-sdk/client-cloudwatch-logs");
 class AmazonCloudwatchService {
-    async createLogEvent({ credentials, data }) {
+    async createLogEvent(req) {
         const client = new client_cloudwatch_logs_1.CloudWatchLogs({
             credentials: {
-                accessKeyId: credentials.accessKey,
-                secretAccessKey: credentials.secretKey,
+                accessKeyId: req.credentials.accessKey,
+                secretAccessKey: req.credentials.secretKey,
             },
-            region: credentials.region,
+            region: req.credentials.region,
         });
-        await this.createLogGroup({ credentials, data });
-        await this.createLogStream({ credentials, data });
+        await this.createLogGroup(req);
+        await this.createLogStream(req);
         await client.putLogEvents({
-            logGroupName: data.group,
-            logStreamName: data.stream,
-            logEvents: data.events,
+            logGroupName: req.group,
+            logStreamName: req.stream,
+            logEvents: req.events,
         });
     }
-    async getLogGroupByName({ credentials, data }) {
-        const logGroups = await this.listApplicationLogGroups({ credentials, data });
-        return logGroups.find((logGroup) => logGroup.logGroupName === data.group);
+    async getLogGroupByName(req) {
+        const logGroups = await this.listApplicationLogGroups(req);
+        return logGroups.find((logGroup) => logGroup.logGroupName === req.group);
     }
-    async getLogStreamByName({ credentials, data }) {
-        const logStreams = await this.listApplicationLogStreams({ credentials, data });
-        return logStreams.find((logStream) => logStream.logStreamName === data.stream);
+    async getLogStreamByName(req) {
+        const logStreams = await this.listApplicationLogStreams(req);
+        return logStreams.find((logStream) => logStream.logStreamName === req.stream);
     }
-    async listApplicationLogGroups({ credentials, data }) {
+    async listApplicationLogGroups(req) {
         const client = new client_cloudwatch_logs_1.CloudWatchLogs({
             credentials: {
-                accessKeyId: credentials.accessKey,
-                secretAccessKey: credentials.secretKey,
+                accessKeyId: req.credentials.accessKey,
+                secretAccessKey: req.credentials.secretKey,
             },
-            region: credentials.region,
+            region: req.credentials.region,
         });
         const { logGroups } = await client.describeLogGroups({
-            logGroupNamePrefix: data.application,
+            logGroupNamePrefix: req.application,
         });
         return logGroups;
     }
-    async listApplicationLogStreams({ credentials, data }) {
+    async listApplicationLogStreams(req) {
         const client = new client_cloudwatch_logs_1.CloudWatchLogs({
             credentials: {
-                accessKeyId: credentials.accessKey,
-                secretAccessKey: credentials.secretKey,
+                accessKeyId: req.credentials.accessKey,
+                secretAccessKey: req.credentials.secretKey,
             },
-            region: credentials.region,
+            region: req.credentials.region,
         });
         const { logStreams } = await client.describeLogStreams({
-            logGroupName: data.group,
+            logGroupName: req.group,
         });
         return logStreams;
     }
-    async createLogGroup({ credentials, data }) {
-        const logGroup = await this.getLogGroupByName({ credentials, data });
+    async createLogGroup(req) {
+        const logGroup = await this.getLogGroupByName(req);
         if (!logGroup) {
             const client = new client_cloudwatch_logs_1.CloudWatchLogs({
                 credentials: {
-                    accessKeyId: credentials.accessKey,
-                    secretAccessKey: credentials.secretKey,
+                    accessKeyId: req.credentials.accessKey,
+                    secretAccessKey: req.credentials.secretKey,
                 },
-                region: credentials.region,
+                region: req.credentials.region,
             });
             await client.createLogGroup({
-                logGroupName: data.group,
+                logGroupName: req.group,
             });
         }
     }
-    async createLogStream({ credentials, data }) {
-        const logStream = await this.getLogStreamByName({ credentials, data });
+    async createLogStream(req) {
+        const logStream = await this.getLogStreamByName(req);
         if (!logStream) {
             const client = new client_cloudwatch_logs_1.CloudWatchLogs({
                 credentials: {
-                    accessKeyId: credentials.accessKey,
-                    secretAccessKey: credentials.secretKey,
+                    accessKeyId: req.credentials.accessKey,
+                    secretAccessKey: req.credentials.secretKey,
                 },
-                region: credentials.region,
+                region: req.credentials.region,
             });
             await client.createLogStream({
-                logGroupName: data.group,
-                logStreamName: data.stream,
+                logGroupName: req.group,
+                logStreamName: req.stream,
             });
         }
     }

package/dist/services/aws/pinpoint.d.ts

@@ -1,8 +1,8 @@
 import { AmazonPinpoint, IAmazonPinpointService } from '../../interfaces/aws';
 declare class AmazonPinpointService implements IAmazonPinpointService {
-    sendMail({ credentials, data }: AmazonPinpoint.SendMail.Request): Promise<void>;
-    sendTemplateMail({ credentials, data }: AmazonPinpoint.SendTemplateMail.Request): Promise<void>;
-    sendSMS({ credentials, data }: AmazonPinpoint.SendSMS.Request): Promise<void>;
+    sendMail(req: AmazonPinpoint.SendMail.Request): Promise<void>;
+    sendTemplateMail(req: AmazonPinpoint.SendTemplateMail.Request): Promise<void>;
+    sendSMS(req: AmazonPinpoint.SendSMS.Request): Promise<void>;
 }
 declare const _default: AmazonPinpointService;
 export default _default;

package/dist/services/aws/pinpoint.js

@@ -2,41 +2,41 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const client_pinpoint_1 = require("@aws-sdk/client-pinpoint");
 class AmazonPinpointService {
-    async sendMail({ credentials, data }) {
+    async sendMail(req) {
         const client = new client_pinpoint_1.PinpointClient({
             credentials: {
-                accessKeyId: credentials.accessKey,
-                secretAccessKey: credentials.secretKey,
+                accessKeyId: req.credentials.accessKey,
+                secretAccessKey: req.credentials.secretKey,
             },
-            region: credentials.region,
+            region: req.credentials.region,
         });
-        const recipient = Array.isArray(data.emails) ? data.emails : [data.emails];
+        const recipient = Array.isArray(req.emails) ? req.emails : [req.emails];
         const addresses = recipient.reduce((acc, curr) => ({
             ...acc,
             [curr]: {
                 ChannelType: 'EMAIL',
             },
         }), {});
-        const substitutions = Object.entries(data.variables || {}).reduce((acc, [key, value]) => ({
+        const substitutions = Object.entries(req.variables || {}).reduce((acc, [key, value]) => ({
             ...acc,
             [key]: [value],
         }), {});
         const payload = {
-            ApplicationId: data.application,
+            ApplicationId: req.applicationId,
             MessageRequest: {
                 Addresses: addresses,
                 MessageConfiguration: {
                     EmailMessage: {
-                        FromAddress: data.from,
+                        FromAddress: req.from,
                         Substitutions: substitutions,
                         SimpleEmail: {
                             Subject: {
                                 Charset: 'utf-8',
-                                Data: data.subject,
+                                Data: req.subject,
                             },
                             TextPart: {
                                 Charset: 'utf-8',
-                                Data: data.text,
+                                Data: req.text,
                             },
                         },
                     },
@@ -45,38 +45,38 @@ class AmazonPinpointService {
         };
         await client.send(new client_pinpoint_1.SendMessagesCommand(payload));
     }
-    async sendTemplateMail({ credentials, data }) {
+    async sendTemplateMail(req) {
         const client = new client_pinpoint_1.PinpointClient({
             credentials: {
-                accessKeyId: credentials.accessKey,
-                secretAccessKey: credentials.secretKey,
+                accessKeyId: req.credentials.accessKey,
+                secretAccessKey: req.credentials.secretKey,
             },
-            region: credentials.region,
+            region: req.credentials.region,
         });
-        const recipient = Array.isArray(data.emails) ? data.emails : [data.emails];
+        const recipient = Array.isArray(req.emails) ? req.emails : [req.emails];
         const addresses = recipient.reduce((acc, curr) => ({
             ...acc,
             [curr]: {
                 ChannelType: 'EMAIL',
             },
         }), {});
-        const substitutions = Object.entries(data.variables || {}).reduce((acc, [key, value]) => ({
+        const substitutions = Object.entries(req.variables || {}).reduce((acc, [key, value]) => ({
             ...acc,
             [key]: [value],
         }), {});
         const payload = {
-            ApplicationId: data.application,
+            ApplicationId: req.applicationId,
             MessageRequest: {
                 Addresses: addresses,
                 MessageConfiguration: {
                     EmailMessage: {
-                        FromAddress: data.from,
+                        FromAddress: req.from,
                         Substitutions: substitutions,
                     },
                 },
                 TemplateConfiguration: {
                     EmailTemplate: {
-                        Name: data.template,
+                        Name: req.template,
                         Version: 'latest',
                     },
                 },
@@ -84,34 +84,34 @@ class AmazonPinpointService {
         };
         await client.send(new client_pinpoint_1.SendMessagesCommand(payload));
     }
-    async sendSMS({ credentials, data }) {
+    async sendSMS(req) {
         const client = new client_pinpoint_1.PinpointClient({
             credentials: {
-                accessKeyId: credentials.accessKey,
-                secretAccessKey: credentials.secretKey,
+                accessKeyId: req.credentials.accessKey,
+                secretAccessKey: req.credentials.secretKey,
             },
-            region: credentials.region,
+            region: req.credentials.region,
         });
-        const recipient = Array.isArray(data.phones) ? data.phones : [data.phones];
+        const recipient = Array.isArray(req.phones) ? req.phones : [req.phones];
         const addresses = recipient.reduce((acc, curr) => ({
             ...acc,
             [curr]: {
                 ChannelType: 'SMS',
             },
         }), {});
-        const substitutions = Object.entries(data.variables || {}).reduce((acc, [key, value]) => ({
+        const substitutions = Object.entries(req.variables || {}).reduce((acc, [key, value]) => ({
             ...acc,
             [key]: [value],
         }), {});
         const payload = {
-            ApplicationId: data.application,
+            ApplicationId: req.applicationId,
             MessageRequest: {
                 Addresses: addresses,
                 MessageConfiguration: {
                     SMSMessage: {
-                        Body: data.text,
-                        MessageType: data.type,
-                        SenderId: data.sender,
+                        Body: req.text,
+                        MessageType: req.type,
+                        SenderId: req.sender,
                         Substitutions: substitutions,
                     },
                 },

package/dist/services/aws/s3.d.ts

@@ -1,10 +1,10 @@
 import { AmazonS3, IAmazonS3Service } from '../../interfaces/aws';
 declare class AmazonS3Service implements IAmazonS3Service {
-    uploadBase64({ credentials, data }: AmazonS3.UploadBase64.Request): Promise<AmazonS3.UploadBase64.Response>;
-    uploadBuffer({ credentials, data }: AmazonS3.UploadBuffer.Request): Promise<AmazonS3.UploadBuffer.Response>;
-    deleteFile({ credentials, data }: AmazonS3.DeleteFile.Request): Promise<void>;
-    listFiles({ credentials, data }: AmazonS3.ListFiles.Request): Promise<AmazonS3.ListFiles.Response>;
-    getSignedUrl({ credentials, data }: AmazonS3.GetSignedUrl.Request): Promise<AmazonS3.GetSignedUrl.Response>;
+    uploadBase64(req: AmazonS3.UploadBase64.Request): Promise<AmazonS3.UploadBase64.Response>;
+    uploadBuffer(req: AmazonS3.UploadBuffer.Request): Promise<AmazonS3.UploadBuffer.Response>;
+    deleteFile(req: AmazonS3.DeleteFile.Request): Promise<void>;
+    listFiles(req: AmazonS3.ListFiles.Request): Promise<AmazonS3.ListFiles.Response>;
+    getSignedUrl(req: AmazonS3.GetSignedUrl.Request): Promise<AmazonS3.GetSignedUrl.Response>;
     private getBucketPath;
 }
 declare const _default: AmazonS3Service;