mblabs-roccato-backend-commons 1.0.8 → 1.1.0

package/src/services/keycloak.ts

@@ -1,400 +1,44 @@
-import { IKeycloakService, Keycloak, Roles } from '../interfaces/keycloak';
+import { IKeycloakService, Keycloak } from '../interfaces/keycloak';
 import HttpService from './http';
 
 class KeycloakService implements IKeycloakService {
-  async authenticate ({
-    credentials,
-    data,
-    url,
-  }: Keycloak.Authenticate.Request): Promise<Keycloak.Authenticate.Response> {
-    const { data: response } = await HttpService.request<Keycloak.Authenticate.Response>({
-      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,
-      }),
+  async authenticate (req: Keycloak.Authenticate.Request): Promise<Keycloak.Authenticate.Response> {
+    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,
     });
 
-    return response;
-  }
-
-  async authenticateServer ({
-    credentials,
-    url,
-  }: Keycloak.AuthenticateServer.Request): Promise<Keycloak.AuthenticateServer.Response> {
-    const { data: response } = await HttpService.request<Keycloak.AuthenticateServer.Response>({
-      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,
-  }: Keycloak.RefreshAccess.Request): Promise<Keycloak.RefreshAccess.Response> {
-    const { data: response } = await HttpService.request<Keycloak.RefreshAccess.Response>({
-      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,
-  }: Keycloak.RevokeAccess.Request): Promise<void> {
-    await HttpService.request<void>({
-      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 createUser ({
-    credentials,
-    data,
-    url,
-  }: Keycloak.CreateUser.Request): Promise<void> {
-    const { access_token } = await this.authenticateServer({
-      credentials,
-      url,
-    });
-
-    await HttpService.request<void>({
-      baseURL: url,
+    const { data } = await HttpService.request<Keycloak.Authenticate.Response>({
+      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,
-  }: Keycloak.UpdateUser.Request): Promise<void> {
-    const { access_token } = await this.authenticateServer({
-      credentials,
-      url,
-    });
-
-    await HttpService.request<void>({
-      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,
-  }: Keycloak.GetUser.Request): Promise<Keycloak.GetUser.Response> {
-    const { access_token } = await this.authenticateServer({
-      credentials,
-      url,
-    });
-
-    const { data: response } = await HttpService.request<Keycloak.GetUser.Response>({
-      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}`,
-      },
+      headers: {},
+      query: query as unknown as Record<string, unknown>,
     });
 
-    return response;
+    return data;
   }
 
-  async deleteUser ({
-    credentials,
-    data,
-    url,
-  }: Keycloak.DeleteUser.Request): Promise<void> {
-    const { access_token } = await this.authenticateServer({
-      credentials,
-      url,
-    });
-
-    await HttpService.request<void>({
-      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 refreshAccess (req: Keycloak.RefreshAccess.Request): Promise<Keycloak.RefreshAccess.Response> {
+    const query = new URLSearchParams({
+      client_id: req.credentials.clientId,
+      client_secret: req.credentials.clientSecret,
+      grant_type: 'refresh_token',
+      refresh_token: req.refreshToken,
     });
-  }
 
-  async changeUserPassword ({
-    credentials,
-    data,
-    url,
-  }: Keycloak.ChangeUserPassword.Request): Promise<void> {
-    const { access_token } = await this.authenticateServer({
-      credentials,
-      url,
-    });
-
-    await HttpService.request<void>({
-      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,
-  }: Keycloak.AddRealm.Request): Promise<void> {
-    const { access_token } = await this.authenticateServer({
-      credentials,
-      url,
-    });
-
-    await HttpService.request<void>({
-      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,
-  }: Keycloak.AddRole.Request): Promise<void> {
-    const { access_token } = await this.authenticateServer({
-      credentials,
-      url,
-    });
-
-    await HttpService.request<void>({
-      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,
-      },
-    });
-  }
-
-  async associateUserRole ({
-    url,
-    data,
-    credentials,
-  }: Keycloak.AssociateUserRole.Request): Promise<void> {
-    const { access_token } = await this.authenticateServer({
-      credentials,
-      url,
-    });
-
-    const { roles } = await this.getRoles({
-      url,
-      data: {
-        search: data.role,
-      },
-      credentials,
-    });
-
-    await HttpService.request<void>({
-      baseURL: url,
+    const { data } = await HttpService.request<Keycloak.RefreshAccess.Response>({
+      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,
-  }: Keycloak.GetRoles.Request): Promise<Keycloak.GetRoles.Response> {
-    const { access_token } = await this.authenticateServer({
-      credentials,
-      url,
-    });
-
-    const { data: response } = await HttpService.request<Roles[]>({
-      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 as unknown as Record<string, unknown>,
-    });
-
-    return {
-      roles: response,
-    };
-  }
-
-  async deleteRole ({
-    url,
-    data,
-    credentials,
-  }: Keycloak.DeleteRole.Request): Promise<void> {
-    const { access_token } = await this.authenticateServer({
-      credentials,
-      url,
+      resourcePath: '/',
+      headers: {},
+      query: query as unknown as Record<string, unknown>,
     });
 
-    await HttpService.request<void>({
-      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}`,
-      },
-    });
+    return data;
   }
 }
 

package/src/services/nodemailer.ts

@@ -3,45 +3,45 @@ import nodemailer from 'nodemailer';
 import { INodeMailerService, NodeMailer } from '../interfaces/nodemailer';
 
 class NodeMailerService implements INodeMailerService {
-  async send ({ credentials, data }: NodeMailer.Send.Request): Promise<void> {
+  async send (req: NodeMailer.Send.Request): Promise<void> {
     const transporter = nodemailer.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 }: NodeMailer.SendWithTemplate.Request): Promise<void> {
+  async sendWithTemplate (req: NodeMailer.SendWithTemplate.Request): Promise<void> {
     const transporter = nodemailer.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);
@@ -50,3 +50,94 @@ class NodeMailerService implements INodeMailerService {
 }
 
 export 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/src/services/redis.ts

@@ -1,11 +1,12 @@
-import { createClient, SetOptions } from 'redis';
+import { createClient, RedisClientType } from 'redis';
 
 import { IRedisService, Redis } from '../interfaces/redis';
 
 class RedisService implements IRedisService {
+  private client: RedisClientType;
 
-  public async set ({ credentials, data }: Redis.Set.Request): Promise<void> {
-    const client = createClient({
+  constructor (private credentials: Redis.Credentials) {
+    this.client = createClient({
       socket: {
         host: credentials.host,
         port: credentials.port,
@@ -13,69 +14,32 @@ class RedisService implements IRedisService {
       password: credentials.password,
     });
 
-    const options: SetOptions = {
-      ...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();
   }
 
-  public async get<T> ({ credentials, data }: Redis.Get.Request): Promise<Redis.Get.Response<T>> {
-    const client = createClient({
-      socket: {
-        host: credentials.host,
-        port: credentials.port,
-      },
-      password: credentials.password,
-    });
-
-    await client.connect();
-    const response = await client.get(data.key);
-    await client.close();
+  public async set (key: string, value: unknown, ttl?: number): Promise<void> {
+    const data = JSON.stringify(value);
 
-    return {
-      data: typeof response === 'string' ? (JSON.parse(response) as T) : null,
-    };
+    if (ttl) {
+      await this.client.set(key, data, { EX: ttl });
+    } else {
+      await this.client.set(key, data);
+    }
   }
 
-  public async del ({ credentials, data }: Redis.Get.Request): Promise<void> {
-    const client = createClient({
-      socket: {
-        host: credentials.host,
-        port: credentials.port,
-      },
-      password: credentials.password,
-    });
-
-    await client.connect();
-    await client.del(data.key);
-    await client.close();
+  public async get<T> (key: string): Promise<T | null> {
+    const data = await this.client.get(key);
+    return typeof data === 'string' ? (JSON.parse(data) as T) : null;
   }
 
-  public async exists ({ credentials, data }: Redis.Get.Request): Promise<Redis.Exists.Response> {
-    const client = createClient({
-      socket: {
-        host: credentials.host,
-        port: credentials.port,
-      },
-      password: credentials.password,
-    });
-
-    await client.connect();
-    const exists = await client.exists(data.key);
-    await client.close();
+  public async del (key: string): Promise<void> {
+    await this.client.del(key);
+  }
 
-    return {
-      exists: !!exists,
-    };
+  public async exists (key: string): Promise<boolean> {
+    const exists = await this.client.exists(key);
+    return exists === 1;
   }
 }
 
-export default new RedisService();
+export default RedisService;