mblabs-roccato-backend-commons 1.0.8 → 1.1.0

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;

package/dist/services/redis.js

@@ -2,67 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const redis_1 = require("redis");
 class RedisService {
-    async set({ credentials, data }) {
-        const client = (0, redis_1.createClient)({
+    credentials;
+    client;
+    constructor(credentials) {
+        this.credentials = credentials;
+        this.client = (0, redis_1.createClient)({
             socket: {
                 host: credentials.host,
                 port: credentials.port,
             },
             password: credentials.password,
         });
-        const options = {
-            ...data.ttl && {
-                expiration: {
-                    type: 'EX',
-                    value: data.ttl,
-                },
-            },
-        };
-        await client.connect();
-        await client.set(data.key, JSON.stringify(data.value), options);
-        await client.close();
+        this.client.connect();
     }
-    async get({ credentials, data }) {
-        const client = (0, redis_1.createClient)({
-            socket: {
-                host: credentials.host,
-                port: credentials.port,
-            },
-            password: credentials.password,
-        });
-        await client.connect();
-        const response = await client.get(data.key);
-        await client.close();
-        return {
-            data: typeof response === 'string' ? JSON.parse(response) : null,
-        };
+    async set(key, value, ttl) {
+        const data = JSON.stringify(value);
+        if (ttl) {
+            await this.client.set(key, data, { EX: ttl });
+        }
+        else {
+            await this.client.set(key, data);
+        }
     }
-    async del({ credentials, data }) {
-        const client = (0, redis_1.createClient)({
-            socket: {
-                host: credentials.host,
-                port: credentials.port,
-            },
-            password: credentials.password,
-        });
-        await client.connect();
-        await client.del(data.key);
-        await client.close();
+    async get(key) {
+        const data = await this.client.get(key);
+        return typeof data === 'string' ? JSON.parse(data) : null;
     }
-    async exists({ credentials, data }) {
-        const client = (0, redis_1.createClient)({
-            socket: {
-                host: credentials.host,
-                port: credentials.port,
-            },
-            password: credentials.password,
-        });
-        await client.connect();
-        const exists = await client.exists(data.key);
-        await client.close();
-        return {
-            exists: !!exists,
-        };
+    async del(key) {
+        await this.client.del(key);
+    }
+    async exists(key) {
+        const exists = await this.client.exists(key);
+        return exists === 1;
     }
 }
-exports.default = new RedisService();
+exports.default = RedisService;

package/dist/services/sendgrid.d.ts

@@ -1,6 +1,6 @@
 import { ISendgridService, Sendgrid } from '../interfaces/sendgrid';
 declare class SendgridService implements ISendgridService {
-    sendMail({ credentials, data }: Sendgrid.SendMail.Request): Promise<void>;
+    sendMail(req: Sendgrid.SendMail.Request): Promise<void>;
 }
 declare const _default: SendgridService;
 export default _default;

package/dist/services/sendgrid.js

@@ -5,17 +5,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const mail_1 = __importDefault(require("@sendgrid/mail"));
 class SendgridService {
-    async sendMail({ credentials, data }) {
-        mail_1.default.setApiKey(credentials.apiKey);
+    async sendMail(req) {
+        mail_1.default.setApiKey(req.credentials.apiKey);
         await mail_1.default.send({
-            from: data.from,
-            to: data.to,
-            subject: data.subject,
-            text: data.text,
-            html: data.html,
-            templateId: data.template,
-            attachments: data.attachments,
-            dynamicTemplateData: data.substitutions,
+            from: req.from,
+            to: req.to,
+            subject: req.subject,
+            text: req.text,
+            html: req.html,
+            templateId: req.template,
+            attachments: req.attachments,
+            dynamicTemplateData: req.substitutions,
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mblabs-roccato-backend-commons",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/database/entities/account.ts

@@ -21,10 +21,7 @@ export default class AccountEntity extends BaseEntity {
   public email?: string;
 
   @Column({ type: 'varchar', nullable: true })
-  public personalDocument?: string;
-
-  @Column({ type: 'varchar', nullable: true })
-  public businessDocument?: string;
+  public cellphone?: string;
 
   @ManyToOne((): ObjectType<ProfileEntity> => ProfileEntity)
   @JoinColumn({ name: 'profileId', referencedColumnName: 'id' })
@@ -35,6 +32,7 @@ export default class AccountEntity extends BaseEntity {
 
   constructor (partial: Partial<AccountEntity>) {
     super();
+
     Object.assign(this, partial);
   }
-}
+}