@in.pulse-crm/sdk 1.6.1 → 2.0.0

package/src/index.ts

@@ -1,87 +1,9 @@
-import AuthSDK, { LoginData, SessionData } from "./auth";
-import FileSDK, { File, FileDirType } from "./file";
-import InstanceSDK from "./instance";
-import UserSDK, { CreateUserDTO, UpdateUserDTO, User, UserRole } from "./user";
-import CustomerSDK, { Customer, CreateCustomerDTO, UpdateCustomerDTO } from "./customer";
-import { DataResponse, ErrorResponse, PaginatedResponse, QueryResponse } from "./response";
-import ReportSDK, { ChatsReport, ChatsReportFormat, GenerateChatsReportOptions } from "./report";
-import SocketClientSDK from "./socket-client";
-import SocketServerSDK from "./socket-server";
-import {
-    EmitFunction,
-    ChatsReportStatusData,
-    SocketServerAdminRoom,
-    SocketServerMonitorRoom,
-    SocketServerReportsRoom,
-    SocketServerRoom,
-    ChatId,
-    QRCode,
-    SocketEventType,
-} from "./types/socket-server.types";
-import {
-    SocketClientChatRoom,
-    SocketClientAdminRoom,
-    SocketClientMonitorRoom,
-    SocketClientReportsRoom,
-    SocketClientRoom,
-} from "./types/socket-client.types";
-
-export {
-    // Auth
-    AuthSDK,
-    LoginData,
-    SessionData,
-
-    // File
-    FileSDK,
-    File,
-    FileDirType,
-
-    // Instance
-    InstanceSDK,
-
-    // User
-    UserSDK,
-    CreateUserDTO,
-    UpdateUserDTO,
-    User,
-    UserRole,
-
-    // Customer
-    CustomerSDK,
-    Customer,
-    CreateCustomerDTO,
-    UpdateCustomerDTO,
-
-    // Response
-    DataResponse,
-    ErrorResponse,
-    PaginatedResponse,
-    QueryResponse,
-
-    // Report
-    ReportSDK,
-    ChatsReport,
-    ChatsReportFormat as ChatsReportFileFormat,
-    GenerateChatsReportOptions,
-
-    // Socket Client
-    SocketClientSDK,
-    SocketClientChatRoom as SocketChatRoom,
-    SocketClientAdminRoom,
-    SocketClientMonitorRoom,
-    SocketClientReportsRoom,
-    SocketClientRoom,
-
-    // Socket Server
-    SocketServerSDK,
-    EmitFunction,
-    SocketEventType,
-    ChatsReportStatusData,
-    SocketServerAdminRoom,
-    SocketServerMonitorRoom,
-    SocketServerReportsRoom,
-    SocketServerRoom,
-    ChatId,
-    QRCode,
-};
+export * from "./types";
+export { default as AuthClient } from "./auth.client";
+export { default as CustomersClient } from "./customers.client";
+export { default as FilesClient } from "./files.client";
+export { default as InstancesClient } from "./instance.client";
+export { default as ReportsClient } from "./reports.client";
+export { default as SocketServerClient } from "./socket-server.client";
+export { default as SocketClient } from "./socket.client";
+export { default as UsersClient } from "./users.client";

package/src/{instance.ts → instance.client.ts}

@@ -1,15 +1,11 @@
 import { AxiosInstance } from "axios";
-import { QueryResponse } from "./response";
+import { QueryResponse } from "./types/response.types";
+import ApiClient from "./api-client";
 
 /**
  * Classe InstanceSDK para interagir com a API de instâncias.
  */
-class InstanceSDK {
-	/**
-	 * Cria uma instância do SDK de instância.
-	 * @param {AxiosInstance} httpClient A instância do cliente HTTP a ser usada para fazer requisições à API.
-	 */
-	constructor(private readonly httpClient: AxiosInstance) { }
+class InstancesClient extends ApiClient {
 
 	/**
 	 * Executa uma consulta na instância especificada.
@@ -41,4 +37,4 @@ class InstanceSDK {
 	}
 }
 
-export default InstanceSDK;
+export default InstancesClient;

package/src/reports.client.ts

@@ -0,0 +1,34 @@
+import ApiClient from "./api-client";
+import { ChatsReport, GenerateChatsReportOptions } from "./types/reports.types";
+import { DataResponse, MessageResponse } from "./types/response.types";
+
+export default class ReportsClient extends ApiClient {
+	public async getChatsReports() {
+		const url = `/reports/chats`;
+		const response =
+			await this.httpClient.get<DataResponse<Array<ChatsReport>>>(url);
+
+		return response.data;
+	}
+
+	public async generateChatsReport(body: GenerateChatsReportOptions) {
+		const url = `/reports/chats`;
+		const response = await this.httpClient.post<DataResponse<ChatsReport>>(
+			url,
+			body,
+		);
+
+		return response.data;
+	}
+
+	public async deleteChatsReport(chatsReportId: number) {
+		const url = `/reports/chats/${chatsReportId}`;
+		const response = await this.httpClient.delete<MessageResponse>(url);
+
+		return response.data;
+	}
+
+	public setAuth(token: string) {
+		this.httpClient.defaults.headers.common["Authorization"] = `Bearer ${token}`;
+	}
+}

package/src/socket-server.client.ts

@@ -0,0 +1,32 @@
+import { EmitSocketEventFn } from "./types/socket-events.types";
+import ApiClient from "./api-client";
+import { MessageResponse } from "./types/response.types";
+
+/**
+ * A client for interacting with a socket server API.
+ * Extends the `ApiClient` class to provide http functionality
+ * for emitting events to specific rooms on the server.
+ */
+export default class SocketServerApi extends ApiClient {
+    /**
+     * Creates an instance of the SocketServerApiClient.
+     *
+     * @param baseUrl - The base URL for the socket server API.
+     */
+    constructor(baseUrl: string) {
+        super(baseUrl);
+    }
+
+    /**
+     * Emits a socket event to a specified room with a given event name and value.
+     *
+     * @param event - The name of the event to emit.
+     * @param room - The name of the room to which the event should be emitted.
+     * @param value - The payload or data to send with the event.
+     * @returns A promise that resolves with the response from the API call.
+     */
+    public emit: EmitSocketEventFn = (event, room, value) => {
+        return this.httpClient.post<MessageResponse>(`/emit/${room}/${event}`, value)
+            .then(res => res.data);
+    }
+}

package/src/socket.client.ts

@@ -0,0 +1,78 @@
+import { io, Socket } from "socket.io-client";
+import { ListenSocketEventFn, SocketEventType, UnlistenSocketEventFn } from "./types/socket-events.types";
+
+/**
+ * A client for interacting with a WebSocket server.
+ * This class provides methods to connect to the server, listen for events,
+ * and manage WebSocket connections.
+ */
+export default class SocketClient {
+    private readonly ws: Socket;
+    private readonly listeners: Map<SocketEventType, any> = new Map();
+
+    /**
+     * Initializes a new instance of the socket client.
+     *
+     * @param baseUrl - The base URL of the WebSocket server to connect to.
+     *                  This URL is used to establish the WebSocket connection.
+     *
+     * The WebSocket client is configured with the following options:
+     * - `autoConnect`: Disabled by default to allow manual connection control.
+     * - `transports`: Uses the 'websocket' transport protocol exclusively.
+     */
+    constructor(baseUrl: string) {
+        this.ws = io(baseUrl, {
+            autoConnect: false,
+            transports: ['websocket'],
+        });
+    }
+
+    /**
+     * Establishes a WebSocket connection using the provided authentication token.
+     *
+     * @param token - The authentication token to be used for the WebSocket connection.
+     *                This token is sent as part of the WebSocket authentication payload.
+     */
+    public connect(token: string) {
+        this.ws.auth = { token };
+        this.ws.connect();
+    }
+
+    /**
+     * Disconnects the WebSocket client from the server.
+     * This method terminates the current WebSocket connection
+     * by invoking the `disconnect` method on the WebSocket instance.
+     */
+    public disconnect() {
+        this.ws.disconnect();
+    }
+
+    /**
+     * Registers an event listener for a specified WebSocket event and provides a way to remove it.
+     *
+     * @param event - The name of the WebSocket event to listen for.
+     * @param callback - A function to be executed when the event is triggered. The function receives the event data as its argument.
+     * @returns A function that, when called, removes the event listener for the specified event.
+     */
+    public on: ListenSocketEventFn = (event, callback) => {
+        if (!this.listeners.get(event)) {
+            this.ws.on(event, (data) => {
+                callback(data);
+            });
+
+            this.listeners.set(event, callback);
+        }
+    }
+
+    /**
+     * Removes a previously registered event listener from the WebSocket connection.
+     *
+     * @param event - The name of the event to stop listening for.
+     * @param callback - The callback function that was previously registered for the event.
+     */
+    public off: UnlistenSocketEventFn = (event) => {
+        const listener = this.listeners.get(event);
+        if (!listener) return;
+        this.ws.off(event, listener);
+    }
+}

package/src/types/auth.types.ts

@@ -0,0 +1,31 @@
+import { User } from "./user.types";
+
+export interface LoginData {
+    /**
+     * Token de autenticação.
+     */
+    token: string;
+    /**
+     * Dados do usuário.
+     */
+    user: User;
+}
+
+export interface SessionData {
+    /**
+     * ID do usuário.
+     */
+    userId: number;
+    /**
+     * ID do setor do usuário.
+     */
+    sectorId: number
+    /**
+     * Papel do usuário.
+     */
+    role: string;
+    /**
+     * Nome da instância.
+     */
+    instance: string;
+}

package/src/types/customers.types.ts

@@ -0,0 +1,68 @@
+export interface Customer {
+    CODIGO: number;
+    RAZAO: string;
+    FANTASIA: string;
+    PESSOA: 'FIS' | 'JUR' | null;
+    ATIVO: 'SIM' | 'NAO' | null;
+    CPF_CNPJ: string;
+    IE_RG: string;
+    GRUPO: number;
+    END_RUA: string;
+    CIDADE: string;
+    BAIRRO: string;
+    ESTADO: string;
+    CEP: string;
+    COMPLEMENTO: string;
+    AREA1: number;
+    AREA2: number;
+    AREA3: number;
+    AREAFAX: number;
+    FONE1: string;
+    FONE2: string;
+    FONE3: string;
+    FAX: string;
+    DESC_FONE1: string;
+    DESC_FONE2: string;
+    DESC_FONE3: string;
+    DESCFAX: string;
+    EMAIL: string;
+    WEBSITE: string;
+    DATACAD: Date;
+    STATUS_CAD: string;
+    OBS_ADMIN: string;
+    OBS_OPERADOR: string;
+    ORIGEM: number;
+    OPERADOR: number;
+    COD_MIDIA: number;
+    COD_ERP: string;
+    BLOCK_COMPRAS: 'SIM' | 'NAO' | null;
+    COD_UNIDADE: number;
+    SALDO_DISPONIVEL: number;
+    SALDO_LIMITE: number;
+    POTENCIAL: number;
+    DATA_ULT_COMPRA: Date;
+    SEGMENTO: number;
+    ULTI_RESULTADO: Date;
+    DT_AGENDAMENTO: Date;
+    COD_CAMPANHA: number;
+    COD_RESULTADO: number;
+    CONTATO_MAIL: string;
+    ATUALIZADOR: 'CADASTRO' | 'ATUALIZAÇÃO' | null;
+    OPERADOR_LOGIN: string;
+    OBS_FONE1: string;
+    OBS_FONE2: string;
+    OBS_FONE3: string;
+    NR_FUNCIONARIOS: number;
+    EMAIL2: string;
+    OBS_CLIENTES: string;
+    VENCIMENTO_LIMITE_CREDITO: Date;
+    PERIODO_RECOMPRA: number;
+    DT_ULTIMO_ORCAMENTO_VENDA: Date;
+    POSSUI_ORCAMENTO: 'S' | 'N' | null;
+    POSSUI_VENDA: 'S' | 'N' | null;
+    CODIGOPRINCIPAL: number;
+    SETOR: number;
+}
+
+export type CreateCustomerDTO = Pick<Customer, "RAZAO" | "FANTASIA" | "CPF_CNPJ" | "PESSOA" | "CIDADE" | "ESTADO" | "COD_ERP">;
+export type UpdateCustomerDTO = Partial<CreateCustomerDTO>;

package/src/types/files.types.ts

@@ -0,0 +1,78 @@
+export interface UploadFileOptions {
+    /**
+     * Nome da instância onde o arquivo está armazenado.
+     */
+    instance: string;
+
+    /**
+     * Tipo de diretório onde o arquivo está armazenado.
+     */
+    dirType: FileDirType;
+
+    /**
+     * Nome do arquivo.
+     */
+    fileName: string;
+
+    /**
+     * Buffer com o conteúdo do arquivo.
+     */
+    buffer: Buffer;
+}
+
+/**
+ * Enum que representa os tipos de diretórios de arquivos.
+ * 
+ * @enum {string}
+ * @property {string} PUBLIC - Representa o diretório público.
+ * @property {string} MODELS - Representa o diretório de modelos.
+ */
+export enum FileDirType {
+    PUBLIC = "public",
+    MODELS = "models",
+}
+
+/**
+ * Representa um arquivo no sistema.
+ */
+export interface File {
+    /**
+     * Identificador único para o arquivo.
+     */
+    id: number;
+
+    /**
+     * Identificador único para o arquivo no armazenamento.
+     */
+    id_storage: string;
+
+    /**
+     * Identificador único para o armazenamento.
+     */
+    storage_id: number;
+
+    /**
+     * Nome do arquivo.
+     */
+    name: string;
+
+    /**
+     * Tipo MIME do arquivo.
+     */
+    mime_type: string;
+
+    /**
+     * Tamanho do arquivo em bytes.
+     */
+    size: number;
+
+    /**
+     * Tipo de diretório onde o arquivo está armazenado.
+     */
+    dir_type: FileDirType;
+
+    /**
+     * Data e hora em que o arquivo foi criado.
+     */
+    created_at: Date;
+}

package/src/types/index.ts

@@ -0,0 +1,7 @@
+export * from "./response.types";
+export * from "./socket-events.types";
+export * from "./socket-rooms.types";
+export * from "./auth.types";
+export * from "./user.types";
+export * from "./customers.types";
+export * from "./files.types";

package/src/types/reports.types.ts

@@ -0,0 +1,24 @@
+export type ReportType = "chats";
+export type ChatsReportFormat = "txt" | "csv" | "pdf";
+export type ChatsReportStatus = "pending" | "completed" | "failed";
+
+export interface ChatsReport {
+    id: number;
+    userId: string;
+    fileId: number;
+    instance: string;
+    startDate: string;
+    endDate: string;
+    exportDate: string;
+    chats: number;
+    messages: number;
+    format: ChatsReportFormat;
+    status: ChatsReportStatus;
+}
+
+export interface GenerateChatsReportOptions {
+    userId: string;
+    format: ChatsReportFormat;
+    startDate: string;
+    endDate: string;
+}

package/src/types/socket-events.types.ts

@@ -0,0 +1,76 @@
+import { SocketServerAdminRoom, SocketServerChatRoom, SocketServerReportsRoom, SocketServerRoom } from "./socket-rooms.types";
+import { MessageResponse } from "./response.types";
+
+export enum SocketEventType {
+    WppChatStarted = "wpp_chat_started",
+    WppChatFinished = "wpp_chat_finished",
+    WppMessage = "wpp_message",
+    WppMessageStatus = "wpp_message_status",
+    WppMessageReaction = "wpp_message_reaction",
+    WwebjsQr = "wwebjs_qr",
+    WwebjsAuth = "wwebjs_auth",
+    ReportStatus = "report_status"
+}
+
+export interface EmitSocketEventFn {
+    (type: SocketEventType.WwebjsQr, room: SocketServerAdminRoom, data: WWEBJSQrEventData): Promise<MessageResponse>;
+    (type: SocketEventType.WwebjsAuth, room: SocketServerAdminRoom, data: WWEBJSAuthEventData): Promise<MessageResponse>;
+    (type: SocketEventType.WppChatStarted, room: SocketServerRoom, data: WppChatStartedEventData): Promise<MessageResponse>;
+    (type: SocketEventType.WppChatFinished, room: SocketServerRoom, data: WppChatFinishedEventData): Promise<MessageResponse>;
+    (type: SocketEventType.WppMessage, room: SocketServerChatRoom, data: WppMessageEventData): Promise<MessageResponse>;
+    (type: SocketEventType.WppMessageStatus, room: SocketServerChatRoom, data: WppMessageStatusEventData): Promise<MessageResponse>;
+    (type: SocketEventType.WppMessageReaction, room: SocketServerChatRoom, data: WppMessageReactionEventData): Promise<MessageResponse>;
+    (type: SocketEventType.ReportStatus, room: SocketServerReportsRoom, data: ReportStatusEventData): Promise<MessageResponse>;
+}
+
+export interface ListenSocketEventFn {
+    (type: SocketEventType.WwebjsQr, callback: (data: WWEBJSQrEventData) => void): void;
+    (type: SocketEventType.WwebjsAuth, callback: (data: WWEBJSAuthEventData) => void): void;
+    (type: SocketEventType.WppChatStarted, callback: (data: WppChatStartedEventData) => void): void;
+    (type: SocketEventType.WppChatFinished, callback: (data: WppChatFinishedEventData) => void): void;
+    (type: SocketEventType.WppMessage, callback: (data: WppMessageEventData) => void): void;
+    (type: SocketEventType.WppMessageStatus, callback: (data: WppMessageStatusEventData) => void): void;
+    (type: SocketEventType.WppMessageReaction, callback: (data: WppMessageReactionEventData) => void): void;
+    (type: SocketEventType.ReportStatus, callback: (data: ReportStatusEventData) => void): void;
+}
+
+export interface UnlistenSocketEventFn {
+    (type: SocketEventType): void;
+}
+
+// EventData
+export interface WWEBJSQrEventData {
+    qr: string;
+    phone: string;
+}
+
+export interface WWEBJSAuthEventData {
+    phone: string;
+    success: boolean;
+    message?: string;
+}
+
+export interface WppChatStartedEventData { };
+export interface WppChatFinishedEventData { };
+export interface WppMessageEventData { };
+export interface WppMessageStatusEventData { };
+export interface WppMessageReactionEventData { };
+
+export type ReportStatusEventData = {
+    id: number;
+    type: string;
+} & ({
+    isCompleted: true;
+    isFailed: false;
+    fileId: number;
+    chats: number;
+    messages: number;
+} | {
+    isCompleted: false;
+    isFailed: true;
+    error: string;
+} | {
+    isCompleted: false;
+    isFailed: false;
+    progress: number;
+});

package/src/types/socket-rooms.types.ts

@@ -0,0 +1,31 @@
+type ReportType = "chats";
+type PhoneNumber = string;
+
+/* 
+    Salas de Socket do lado do cliente;
+    Essas salas omitem o nome da instancia e/ou id do setor,
+    pois isso é controlado pelo servidor;
+*/
+export type SocketClientChatRoom = `chat:${PhoneNumber}`;
+export type SocketClientAdminRoom = "admin";
+export type SocketClientMonitorRoom = `monitor`;
+export type SocketClientReportsRoom = `reports:${ReportType}`;
+export type SocketClientRoom = SocketClientChatRoom | SocketClientAdminRoom | SocketClientReportsRoom | SocketClientMonitorRoom;
+
+// Interface que incluí o nome da instancia na sala de socket;
+type SocketRoomWithInstance<T extends string> = `${string}:${T}`;
+
+// Interface que incluí o nome da instancia e o id do setor na sala de socket;
+type SocketRoomWithSector<T extends string> = SocketRoomWithInstance<`${number}:${T}`>;
+
+/* 
+    Salas de Socket do lado do servidor;
+    Essas salas incluem o nome da instancia e o id do setor,
+    Permitindo que cada instancia consiga ver apenas o que lhe
+    pertence, e não as salas de outras instancias.
+*/
+export type SocketServerAdminRoom = SocketRoomWithSector<SocketClientAdminRoom>;
+export type SocketServerMonitorRoom = SocketRoomWithSector<SocketClientMonitorRoom>;
+export type SocketServerReportsRoom = SocketRoomWithSector<SocketClientReportsRoom>;
+export type SocketServerChatRoom = SocketRoomWithInstance<SocketClientChatRoom>;
+export type SocketServerRoom = SocketServerChatRoom | SocketServerAdminRoom | SocketServerMonitorRoom | SocketServerReportsRoom;

package/src/{user.ts → types/user.types.ts}

@@ -1,6 +1,3 @@
-import { AxiosInstance } from "axios";
-import { DataResponse, PaginatedResponse } from "./response";
-
 /**
  * Enum que representa os diferentes papéis de usuário dentro do sistema.
  * 
@@ -158,78 +155,4 @@ export interface CreateUserDTO {
 /**
  * Interface que representa o objeto de transferência de dados para atualizar um usuário.
  */
-export type UpdateUserDTO = Partial<CreateUserDTO>;
-
-/**
- * SDK para operações de usuários.
- */
-class UserSDK {
-    /**
-     * Cria uma instância do SDK de usuários.
-     * @param httpClient - A instância do cliente HTTP a ser usada para fazer requisições à API.
-     */
-    constructor(private readonly httpClient: AxiosInstance) { }
-
-    /**
-     * Obtém a lista de usuários.
-     * @returns Uma resposta paginada contendo os usuários.
-     */
-    public async getUsers() {
-        const response = await this.httpClient.get<PaginatedResponse<User>>(`/users`);
-
-        return response.data;
-    }
-
-    /**
-     * Obtém um usuário pelo ID.
-     * @param userId - O ID do usuário.
-     * @returns Uma resposta contendo os dados do usuário.
-     */
-    public async getUserById(userId: number) {
-        const response = await this.httpClient.get<DataResponse<User>>(`/users/${userId}`);
-
-        return response.data;
-    }
-
-    /**
-     * Cria um novo usuário.
-     * @param data - Os dados para criação do usuário.
-     * @returns Uma resposta contendo os dados do usuário criado.
-     * @throws Um erro se a criação do usuário falhar.
-     */
-    public async createUser(data: CreateUserDTO) {
-        try {
-            const response = await this.httpClient.post<DataResponse<User>>(`/users`, data);
-
-            return response.data;
-        } catch (error) {
-            throw new Error("Failed to create user", { cause: error });
-        }
-    }
-
-    /**
-     * Atualiza um usuário existente.
-     * @param userId - O ID do usuário.
-     * @param data - Os dados para atualização do usuário.
-     * @returns Uma resposta contendo os dados do usuário atualizado.
-     * @throws Um erro se a atualização do usuário falhar.
-     */
-    public async updateUser(userId: string, data: UpdateUserDTO) {
-        try {
-            const response = await this.httpClient.patch<DataResponse<User>>(
-                `/users/${userId}`,
-                data,
-            );
-
-            return response.data;
-        } catch (error) {
-            throw new Error("Failed to update user", { cause: error });
-        }
-    }
-
-    public setAuth(token: string) {
-        this.httpClient.defaults.headers.common["Authorization"] = `Bearer ${token}`;
-    }
-}
-
-export default UserSDK;
+export type UpdateUserDTO = Partial<CreateUserDTO>;