fix: reorganization of files and folders

src/api/abstract/abstract.cache.ts

@@ -0,0 +1,13 @@
+export interface ICache {
+  get(key: string): Promise<any>;
+
+  set(key: string, value: any, ttl?: number): void;
+
+  has(key: string): Promise<boolean>;
+
+  keys(appendCriteria?: string): Promise<string[]>;
+
+  delete(key: string | string[]): Promise<number>;
+
+  deleteAll(appendCriteria?: string): Promise<number>;
+}

src/api/abstract/abstract.repository.ts

@@ -0,0 +1,67 @@
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+import { ConfigService, Database } from '../../config/env.config';
+import { ROOT_DIR } from '../../config/path.config';
+
+export type IInsert = { insertCount: number };
+
+export interface IRepository {
+  insert(data: any, instanceName: string, saveDb?: boolean): Promise<IInsert>;
+  update(data: any, instanceName: string, saveDb?: boolean): Promise<IInsert>;
+  find(query: any): Promise<any>;
+  delete(query: any, force?: boolean): Promise<any>;
+
+  dbSettings: Database;
+  readonly storePath: string;
+}
+
+type WriteStore<U> = {
+  path: string;
+  fileName: string;
+  data: U;
+};
+
+export abstract class Repository implements IRepository {
+  constructor(configService: ConfigService) {
+    this.dbSettings = configService.get<Database>('DATABASE');
+  }
+
+  dbSettings: Database;
+  readonly storePath = join(ROOT_DIR, 'store');
+
+  public writeStore = <T = any>(create: WriteStore<T>) => {
+    if (!existsSync(create.path)) {
+      mkdirSync(create.path, { recursive: true });
+    }
+    try {
+      writeFileSync(join(create.path, create.fileName + '.json'), JSON.stringify({ ...create.data }), {
+        encoding: 'utf-8',
+      });
+
+      return { message: 'create - success' };
+    } finally {
+      create.data = undefined;
+    }
+  };
+
+  // eslint-disable-next-line
+    public insert(data: any, instanceName: string, saveDb = false): Promise<IInsert> {
+    throw new Error('Method not implemented.');
+  }
+
+  // eslint-disable-next-line
+    public update(data: any, instanceName: string, saveDb = false): Promise<IInsert> {
+    throw new Error('Method not implemented.');
+  }
+
+  // eslint-disable-next-line
+    public find(query: any): Promise<any> {
+    throw new Error('Method not implemented.');
+  }
+
+  // eslint-disable-next-line
+    delete(query: any, force?: boolean): Promise<any> {
+    throw new Error('Method not implemented.');
+  }
+}

src/api/abstract/abstract.router.ts

@@ -0,0 +1,227 @@
+import 'express-async-errors';
+
+import { Request } from 'express';
+import { JSONSchema7 } from 'json-schema';
+import { validate } from 'jsonschema';
+
+import { Logger } from '../../config/logger.config';
+import { BadRequestException } from '../../exceptions';
+import { GetParticipant, GroupInvite } from '../dto/group.dto';
+import { InstanceDto } from '../dto/instance.dto';
+
+type DataValidate<T> = {
+  request: Request;
+  schema: JSONSchema7;
+  ClassRef: any;
+  execute: (instance: InstanceDto, data: T) => Promise<any>;
+};
+
+const logger = new Logger('Validate');
+
+export abstract class RouterBroker {
+  constructor() {}
+  public routerPath(path: string, param = true) {
+    let route = '/' + path;
+    param ? (route += '/:instanceName') : null;
+
+    return route;
+  }
+
+  public async dataValidate<T>(args: DataValidate<T>) {
+    const { request, schema, ClassRef, execute } = args;
+
+    const ref = new ClassRef();
+    const body = request.body;
+    const instance = request.params as unknown as InstanceDto;
+
+    if (request?.query && Object.keys(request.query).length > 0) {
+      Object.assign(instance, request.query);
+    }
+
+    if (request.originalUrl.includes('/instance/create')) {
+      Object.assign(instance, body);
+    }
+
+    Object.assign(ref, body);
+
+    const v = schema ? validate(ref, schema) : { valid: true, errors: [] };
+
+    if (!v.valid) {
+      const message: any[] = v.errors.map(({ stack, schema }) => {
+        let message: string;
+        if (schema['description']) {
+          message = schema['description'];
+        } else {
+          message = stack.replace('instance.', '');
+        }
+        return message;
+      });
+      logger.error(message);
+      throw new BadRequestException(message);
+    }
+
+    return await execute(instance, ref);
+  }
+
+  public async groupNoValidate<T>(args: DataValidate<T>) {
+    const { request, ClassRef, schema, execute } = args;
+
+    const instance = request.params as unknown as InstanceDto;
+
+    const ref = new ClassRef();
+
+    Object.assign(ref, request.body);
+
+    const v = validate(ref, schema);
+
+    if (!v.valid) {
+      const message: any[] = v.errors.map(({ property, stack, schema }) => {
+        let message: string;
+        if (schema['description']) {
+          message = schema['description'];
+        } else {
+          message = stack.replace('instance.', '');
+        }
+        return {
+          property: property.replace('instance.', ''),
+          message,
+        };
+      });
+      logger.error([...message]);
+      throw new BadRequestException(...message);
+    }
+
+    return await execute(instance, ref);
+  }
+
+  public async groupValidate<T>(args: DataValidate<T>) {
+    const { request, ClassRef, schema, execute } = args;
+
+    const instance = request.params as unknown as InstanceDto;
+    const body = request.body;
+
+    let groupJid = body?.groupJid;
+
+    if (!groupJid) {
+      if (request.query?.groupJid) {
+        groupJid = request.query.groupJid;
+      } else {
+        throw new BadRequestException('The group id needs to be informed in the query', 'ex: "groupJid=120362@g.us"');
+      }
+    }
+
+    if (!groupJid.endsWith('@g.us')) {
+      groupJid = groupJid + '@g.us';
+    }
+
+    Object.assign(body, {
+      groupJid: groupJid,
+    });
+
+    const ref = new ClassRef();
+
+    Object.assign(ref, body);
+
+    const v = validate(ref, schema);
+
+    if (!v.valid) {
+      const message: any[] = v.errors.map(({ property, stack, schema }) => {
+        let message: string;
+        if (schema['description']) {
+          message = schema['description'];
+        } else {
+          message = stack.replace('instance.', '');
+        }
+        return {
+          property: property.replace('instance.', ''),
+          message,
+        };
+      });
+      logger.error([...message]);
+      throw new BadRequestException(...message);
+    }
+
+    return await execute(instance, ref);
+  }
+
+  public async inviteCodeValidate<T>(args: DataValidate<T>) {
+    const { request, ClassRef, schema, execute } = args;
+
+    const inviteCode = request.query as unknown as GroupInvite;
+
+    if (!inviteCode?.inviteCode) {
+      throw new BadRequestException(
+        'The group invite code id needs to be informed in the query',
+        'ex: "inviteCode=F1EX5QZxO181L3TMVP31gY" (Obtained from group join link)',
+      );
+    }
+
+    const instance = request.params as unknown as InstanceDto;
+    const body = request.body;
+
+    const ref = new ClassRef();
+
+    Object.assign(body, inviteCode);
+    Object.assign(ref, body);
+
+    const v = validate(ref, schema);
+
+    if (!v.valid) {
+      const message: any[] = v.errors.map(({ property, stack, schema }) => {
+        let message: string;
+        if (schema['description']) {
+          message = schema['description'];
+        } else {
+          message = stack.replace('instance.', '');
+        }
+        return {
+          property: property.replace('instance.', ''),
+          message,
+        };
+      });
+      logger.error([...message]);
+      throw new BadRequestException(...message);
+    }
+
+    return await execute(instance, ref);
+  }
+
+  public async getParticipantsValidate<T>(args: DataValidate<T>) {
+    const { request, ClassRef, schema, execute } = args;
+
+    const getParticipants = request.query as unknown as GetParticipant;
+
+    if (!getParticipants?.getParticipants) {
+      throw new BadRequestException('The getParticipants needs to be informed in the query');
+    }
+
+    const instance = request.params as unknown as InstanceDto;
+    const body = request.body;
+
+    const ref = new ClassRef();
+
+    Object.assign(body, getParticipants);
+    Object.assign(ref, body);
+
+    const v = validate(ref, schema);
+
+    if (!v.valid) {
+      const message: any[] = v.errors.map(({ property, stack, schema }) => {
+        let message: string;
+        if (schema['description']) {
+          message = schema['description'];
+        } else {
+          message = stack.replace('instance.', '');
+        }
+        return {
+          property: property.replace('instance.', ''),
+          message,
+        };
+      });
+      logger.error([...message]);
+      throw new BadRequestException(...message);
+    }
+
+    return await execute(instance, ref);
+  }
+}