mblabs-roccato-backend-commons 1.0.7 → 1.1.0

package/dist/services/gcp/sheets.js

@@ -2,17 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const googleapis_1 = require("googleapis");
 class GoogleSheetsService {
-    async readSheet({ credentials, data, }) {
+    async readSheet(req) {
         const instance = googleapis_1.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,
         };
     }
 }

package/dist/services/grafana.d.ts

@@ -1,7 +1,7 @@
 import { Grafana, IGrafanaService } from '../interfaces/grafana';
 declare class GrafanaService implements IGrafanaService {
-    getDashboard({ credentials, data, }: Grafana.GetDashboard.Request): Promise<Grafana.GetDashboard.Response>;
-    searchDashboard({ credentials, data, }: Grafana.SearchDashboard.Request): Promise<Grafana.SearchDashboard.Response>;
+    getDashboard(req: Grafana.GetDashboard.Request): Promise<Grafana.GetDashboard.Response>;
+    searchDashboard(req: Grafana.SearchDashboard.Request): Promise<Grafana.SearchDashboard.Response>;
 }
 declare const _default: GrafanaService;
 export default _default;

package/dist/services/grafana.js

@@ -5,33 +5,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const http_1 = __importDefault(require("./http"));
 class GrafanaService {
-    async getDashboard({ credentials, data, }) {
-        const { data: response } = await http_1.default.request({
+    async getDashboard(req) {
+        const { data } = await http_1.default.request({
             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, }) {
-        const { data: response } = await http_1.default.request({
+    async searchDashboard(req) {
+        const { data } = await http_1.default.request({
             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,
+            dashboards: data,
         };
     }
 }

package/dist/services/keycloak.d.ts

@@ -1,19 +1,7 @@
 import { IKeycloakService, Keycloak } from '../interfaces/keycloak';
 declare class KeycloakService implements IKeycloakService {
-    authenticate({ credentials, data, url, }: Keycloak.Authenticate.Request): Promise<Keycloak.Authenticate.Response>;
-    authenticateServer({ credentials, url, }: Keycloak.AuthenticateServer.Request): Promise<Keycloak.AuthenticateServer.Response>;
-    refreshAccess({ credentials, data, url, }: Keycloak.RefreshAccess.Request): Promise<Keycloak.RefreshAccess.Response>;
-    revokeAccess({ credentials, data, url, }: Keycloak.RevokeAccess.Request): Promise<void>;
-    createUser({ credentials, data, url, }: Keycloak.CreateUser.Request): Promise<void>;
-    updateUser({ credentials, data, url, }: Keycloak.UpdateUser.Request): Promise<void>;
-    getUser({ credentials, data, url, }: Keycloak.GetUser.Request): Promise<Keycloak.GetUser.Response>;
-    deleteUser({ credentials, data, url, }: Keycloak.DeleteUser.Request): Promise<void>;
-    changeUserPassword({ credentials, data, url, }: Keycloak.ChangeUserPassword.Request): Promise<void>;
-    addRealm({ url, data, credentials, }: Keycloak.AddRealm.Request): Promise<void>;
-    addRole({ url, data, credentials, }: Keycloak.AddRole.Request): Promise<void>;
-    associateUserRole({ url, data, credentials, }: Keycloak.AssociateUserRole.Request): Promise<void>;
-    getRoles({ url, data, credentials, }: Keycloak.GetRoles.Request): Promise<Keycloak.GetRoles.Response>;
-    deleteRole({ url, data, credentials, }: Keycloak.DeleteRole.Request): Promise<void>;
+    authenticate(req: Keycloak.Authenticate.Request): Promise<Keycloak.Authenticate.Response>;
+    refreshAccess(req: Keycloak.RefreshAccess.Request): Promise<Keycloak.RefreshAccess.Response>;
 }
 declare const _default: KeycloakService;
 export default _default;

package/dist/services/keycloak.js

@@ -5,314 +5,38 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const http_1 = __importDefault(require("./http"));
 class KeycloakService {
-    async authenticate({ credentials, data, url, }) {
-        const { data: response } = await http_1.default.request({
-            baseURL: url,
-            method: 'post',
-            resourcePath: `/auth/realms/${credentials.realm}/protocol/openid-connect/token/`,
-            headers: {
-                'Cache-Control': 'no-cache',
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-            body: new URLSearchParams({
-                client_id: credentials.clientId,
-                client_secret: credentials.clientSecret,
-                grant_type: credentials.grantType,
-                username: data.username,
-                password: data.password,
-            }),
-        });
-        return response;
-    }
-    async authenticateServer({ credentials, url, }) {
-        const { data: response } = await http_1.default.request({
-            baseURL: url,
-            method: 'post',
-            resourcePath: `/auth/realms/${credentials.realm}/protocol/openid-connect/token/`,
-            headers: {
-                'Cache-Control': 'no-cache',
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-            body: new URLSearchParams({
-                client_id: credentials.clientId,
-                client_secret: credentials.clientSecret,
-                grant_type: credentials.grantType,
-            }),
-        });
-        return response;
-    }
-    async refreshAccess({ credentials, data, url, }) {
-        const { data: response } = await http_1.default.request({
-            baseURL: url,
-            method: 'post',
-            resourcePath: `/auth/realms/${credentials.realm}/protocol/openid-connect/token`,
-            headers: {
-                'Cache-Control': 'no-cache',
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-            body: new URLSearchParams({
-                client_id: credentials.clientId,
-                client_secret: credentials.clientSecret,
-                grant_type: 'refresh_token',
-                refresh_token: data.refreshToken,
-            }),
-        });
-        return response;
-    }
-    async revokeAccess({ credentials, data, url, }) {
-        await http_1.default.request({
-            baseURL: url,
-            method: 'post',
-            resourcePath: `/auth/realms/${credentials.realm}/protocol/openid-connect/revoke`,
-            headers: {
-                'Cache-Control': 'no-cache',
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-            body: new URLSearchParams({
-                client_id: credentials.clientId,
-                client_secret: credentials.clientSecret,
-                token: data.accessToken,
-            }),
+    async authenticate(req) {
+        const query = new URLSearchParams({
+            client_id: req.credentials.clientId,
+            client_secret: req.credentials.clientSecret,
+            grant_type: req.credentials.grantType,
+            username: req.username,
+            password: req.password,
         });
-    }
-    async createUser({ credentials, data, url, }) {
-        const { access_token } = await this.authenticateServer({
-            credentials,
-            url,
-        });
-        await http_1.default.request({
-            baseURL: url,
+        const { data } = await http_1.default.request({
+            baseURL: req.url,
             method: 'post',
             resourcePath: '/',
-            headers: {
-                'Cache-Control': 'no-cache',
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${access_token}`,
-            },
-            body: {
-                email: data.email,
-                username: data.username,
-                firstName: data.firstName,
-                lastName: data.lastName ?? '',
-                enabled: true,
-                emailVerified: true,
-                credentials: [
-                    {
-                        type: 'password',
-                        value: data.password,
-                        temporary: data.isTemporaryPassword ?? false,
-                    },
-                ],
-                groups: data.groups,
-                attributes: {
-                    isFirstAccess: true,
-                },
-            },
-        });
-    }
-    async updateUser({ credentials, data, url, }) {
-        const { access_token } = await this.authenticateServer({
-            credentials,
-            url,
-        });
-        await http_1.default.request({
-            baseURL: url,
-            method: 'put',
-            resourcePath: `/auth/admin/realms/${credentials.realm}/users/${data.id}`,
-            headers: {
-                'Cache-Control': 'no-cache',
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${access_token}`,
-            },
-            body: {
-                email: data.email,
-                username: data.username,
-                firstName: data.firstName,
-                lastName: data.lastName ?? '',
-                enabled: true,
-                emailVerified: true,
-                ...(data.password && {
-                    credentials: [
-                        {
-                            type: 'password',
-                            value: data.password,
-                            temporary: data.isTemporaryPassword ?? false,
-                        },
-                    ],
-                }),
-                groups: data.groups,
-                attributes: {
-                    isFirstAccess: false,
-                },
-            },
-        });
-    }
-    async getUser({ credentials, data, url, }) {
-        const { access_token } = await this.authenticateServer({
-            credentials,
-            url,
-        });
-        const { data: response } = await http_1.default.request({
-            baseURL: url,
-            method: 'get',
-            resourcePath: `/auth/admin/realms/${credentials.realm}/users/${data.id}`,
-            headers: {
-                'Cache-Control': 'no-cache',
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${access_token}`,
-            },
-        });
-        return response;
-    }
-    async deleteUser({ credentials, data, url, }) {
-        const { access_token } = await this.authenticateServer({
-            credentials,
-            url,
-        });
-        await http_1.default.request({
-            baseURL: url,
-            method: 'delete',
-            resourcePath: `/auth/admin/realms/${credentials.realm}/users/${data.id}`,
-            headers: {
-                'Cache-Control': 'no-cache',
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${access_token}`,
-            },
-        });
-    }
-    async changeUserPassword({ credentials, data, url, }) {
-        const { access_token } = await this.authenticateServer({
-            credentials,
-            url,
-        });
-        await http_1.default.request({
-            baseURL: url,
-            method: 'put',
-            resourcePath: `/auth/admin/realms/${credentials.realm}/users/${data.id}/reset-password`,
-            headers: {
-                'Cache-Control': 'no-cache',
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${access_token}`,
-            },
-            body: {
-                type: 'password',
-                value: data.password,
-                temporary: data.isTemporaryPassword ?? false,
-            },
-        });
-    }
-    async addRealm({ url, data, credentials, }) {
-        const { access_token } = await this.authenticateServer({
-            credentials,
-            url,
-        });
-        await http_1.default.request({
-            baseURL: url,
-            method: 'post',
-            resourcePath: '/auth/admin/realms',
-            headers: {
-                'Cache-Control': 'no-cache',
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${access_token}`,
-            },
-            body: {
-                id: data.name,
-                realm: data.name,
-                enabled: data.enabled ?? false,
-                loginWithEmailAllowed: false,
-                duplicateEmailsAllowed: true,
-                resetPasswordAllowed: false,
-                editUsernameAllowed: true,
-                bruteForceProtected: true,
-                permanentLockout: false,
-                maxFailureWaitSeconds: 900,
-                minimumQuickLoginWaitSeconds: 60,
-                waitIncrementSeconds: 60,
-                quickLoginCheckMilliSeconds: 1000,
-                maxDeltaTimeSeconds: 43200,
-                failureFactor: 5,
-            },
-        });
-    }
-    async addRole({ url, data, credentials, }) {
-        const { access_token } = await this.authenticateServer({
-            credentials,
-            url,
-        });
-        await http_1.default.request({
-            baseURL: url,
-            method: 'post',
-            resourcePath: `/auth/admin/realms/${credentials.realm}/roles`,
-            headers: {
-                'Cache-Control': 'no-cache',
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${access_token}`,
-            },
-            body: {
-                name: data.name,
-                description: data.description,
-            },
+            headers: {},
+            query: query,
         });
+        return data;
     }
-    async associateUserRole({ url, data, credentials, }) {
-        const { access_token } = await this.authenticateServer({
-            credentials,
-            url,
-        });
-        const { roles } = await this.getRoles({
-            url,
-            data: {
-                search: data.role,
-            },
-            credentials,
+    async refreshAccess(req) {
+        const query = new URLSearchParams({
+            client_id: req.credentials.clientId,
+            client_secret: req.credentials.clientSecret,
+            grant_type: 'refresh_token',
+            refresh_token: req.refreshToken,
         });
-        await http_1.default.request({
-            baseURL: url,
+        const { data } = await http_1.default.request({
+            baseURL: req.url,
             method: 'post',
-            resourcePath: `/auth/admin/realms/${credentials.realm}/users/${data.user}/role-mappings/realm`,
-            headers: {
-                'Cache-Control': 'no-cache',
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${access_token}`,
-            },
-            body: roles,
-        });
-    }
-    async getRoles({ url, data, credentials, }) {
-        const { access_token } = await this.authenticateServer({
-            credentials,
-            url,
-        });
-        const { data: response } = await http_1.default.request({
-            baseURL: url,
-            method: 'get',
-            resourcePath: `/auth/admin/realms/${credentials.realm}/roles`,
-            headers: {
-                'Cache-Control': 'no-cache',
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${access_token}`,
-            },
-            query: data,
-        });
-        return {
-            roles: response,
-        };
-    }
-    async deleteRole({ url, data, credentials, }) {
-        const { access_token } = await this.authenticateServer({
-            credentials,
-            url,
-        });
-        await http_1.default.request({
-            baseURL: url,
-            method: 'delete',
-            resourcePath: `/auth/admin/realms/${credentials.realm}/roles-by-id/${data.id}`,
-            headers: {
-                'Cache-Control': 'no-cache',
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${access_token}`,
-            },
+            resourcePath: '/',
+            headers: {},
+            query: query,
         });
+        return data;
     }
 }
 exports.default = new KeycloakService();

package/dist/services/nodemailer.d.ts

@@ -1,7 +1,7 @@
 import { INodeMailerService, NodeMailer } from '../interfaces/nodemailer';
 declare class NodeMailerService implements INodeMailerService {
-    send({ credentials, data }: NodeMailer.Send.Request): Promise<void>;
-    sendWithTemplate({ credentials, data }: NodeMailer.SendWithTemplate.Request): Promise<void>;
+    send(req: NodeMailer.Send.Request): Promise<void>;
+    sendWithTemplate(req: NodeMailer.SendWithTemplate.Request): Promise<void>;
 }
 declare const _default: NodeMailerService;
 export default _default;

package/dist/services/nodemailer.js

@@ -5,44 +5,134 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const nodemailer_1 = __importDefault(require("nodemailer"));
 class NodeMailerService {
-    async send({ credentials, data }) {
+    async send(req) {
         const transporter = nodemailer_1.default.createTransport({
-            host: credentials.host,
-            port: credentials.port,
-            secure: credentials.secure,
-            auth: credentials.auth,
+            host: req.credentials.host,
+            port: req.credentials.port,
+            secure: req.credentials.secure,
+            auth: req.credentials.auth,
             tls: {
                 rejectUnauthorized: false,
             },
         });
         const options = {
-            from: data.from,
-            to: data.to,
-            subject: data.subject,
-            text: data.text,
+            from: req.from,
+            to: req.to,
+            subject: req.subject,
+            text: req.text,
         };
         await transporter.sendMail(options);
         transporter.close();
     }
-    async sendWithTemplate({ credentials, data }) {
+    async sendWithTemplate(req) {
         const transporter = nodemailer_1.default.createTransport({
-            host: credentials.host,
-            port: credentials.port,
-            secure: credentials.secure,
-            auth: credentials.auth,
+            host: req.credentials.host,
+            port: req.credentials.port,
+            secure: req.credentials.secure,
+            auth: req.credentials.auth,
             tls: {
                 rejectUnauthorized: false,
             },
         });
         const options = {
-            from: data.from,
-            to: data.to,
-            subject: data.subject,
-            html: data.html,
-            attachments: data.attachments,
+            from: req.from,
+            to: req.to,
+            subject: req.subject,
+            html: req.html,
+            attachments: req.attachments,
         };
         await transporter.sendMail(options);
         transporter.close();
     }
 }
 exports.default = new NodeMailerService();
+/* import { ISMTPTemplateMail, ISMTPTextMail } from '@shared/mechanisms/smtp/interfaces';
+import { readTemplate, stringReplace } from '@shared/utils';
+import mjml from 'mjml';
+import nodemailer, { SendMailOptions, Transporter } from 'nodemailer';
+import { join } from 'path';
+
+class SMTPService {
+  static getTransporter (): Transporter {
+    const { host, auth, port, secure } = getEnv().mailing.smtp;
+
+    return nodemailer.createTransport({
+      host,
+      port,
+      secure,
+      auth,
+      tls: {
+        rejectUnauthorized: false,
+      },
+    });
+  }
+
+  static async send (params: ISMTPTextMail): Promise<void> {
+    const transporter = SMTPService.getTransporter();
+
+    const options: SendMailOptions = {
+      from: {
+        name: params.from.name,
+        address: params.from.address,
+      },
+      to: params.to,
+      subject: params.subject,
+      text: params.text,
+    };
+
+    await transporter.sendMail(options);
+    transporter.close();
+  }
+
+  static async sendWithTemplate (params: ISMTPTemplateMail): Promise<void> {
+    const transporter = SMTPService.getTransporter();
+
+    const options: SendMailOptions = {
+      from: {
+        name: params.from.name,
+        address: params.from.address,
+      },
+      to: params.to,
+      subject: params.subject,
+      html: params.template,
+      attachments: params.attachments,
+    };
+
+    await transporter.sendMail(options);
+    transporter.close();
+  }
+
+  static async getTemplate (filename: string, options?: Dictionary<string | number>) {
+    let template = null;
+
+    const path = join(__dirname, `./templates/${filename}`);
+
+    try {
+      template = await readTemplate(path, 'utf8');
+
+      if (!template) throw new BusinessError(BusinessErrorCodes.TEMPLATE_NOT_FOUND);
+
+    } catch (err) {
+      throw new BusinessError(BusinessErrorCodes.TEMPLATE_NOT_FOUND);
+    }
+
+    if (options) {
+      template = stringReplace(template, options);
+    }
+
+    if (filename.includes('.mjml')) {
+      const { html, errors } = mjml(template);
+
+      if (errors && errors.length) {
+        throw new BusinessError(BusinessErrorCodes.TEMPLATE_NOT_FOUND);
+      }
+
+      template = html;
+    }
+
+    return template;
+  }
+}
+
+export default SMTPService;
+ */

package/dist/services/redis.d.ts

@@ -1,9 +1,11 @@
 import { IRedisService, Redis } from '../interfaces/redis';
 declare class RedisService implements IRedisService {
-    set({ credentials, data }: Redis.Set.Request): Promise<void>;
-    get<T>({ credentials, data }: Redis.Get.Request): Promise<Redis.Get.Response<T>>;
-    del({ credentials, data }: Redis.Get.Request): Promise<void>;
-    exists({ credentials, data }: Redis.Get.Request): Promise<Redis.Exists.Response>;
+    private credentials;
+    private client;
+    constructor(credentials: Redis.Credentials);
+    set(key: string, value: unknown, ttl?: number): Promise<void>;
+    get<T>(key: string): Promise<T | null>;
+    del(key: string): Promise<void>;
+    exists(key: string): Promise<boolean>;
 }
-declare const _default: RedisService;
-export default _default;
+export default RedisService;