@gymspace/evolution 1.0.0 → 1.0.2

package/src/api/errors.ts

@@ -1,220 +0,0 @@
-export class EvolutionApiError extends Error {
-	public readonly statusCode?: number;
-	public readonly details?: unknown;
-
-	constructor(message: string, cause?: unknown, statusCode?: number) {
-		const extractedMessage = extractErrorMessage(cause);
-		const finalMessage = extractedMessage || message || "Unknown error occurred";
-
-		super(finalMessage);
-
-		this.name = EvolutionApiError.name;
-		this.message = finalMessage;
-		this.statusCode = statusCode;
-		this.details = cause;
-
-		// Maintain proper stack trace
-		if ((Error as any).captureStackTrace) {
-			(Error as any).captureStackTrace(this, EvolutionApiError);
-		}
-	}
-
-	/**
-	 * Returns a user-friendly string representation of the error
-	 */
-	toString(): string {
-		let result = `${this.name}: ${this.message}`;
-		
-		if (this.statusCode) {
-			result += ` (${this.statusCode})`;
-		}
-		
-		// Add relevant details without showing [Object ...]
-		if (this.details && typeof this.details === 'object') {
-			const details = this.details as Record<string, any>;
-			const relevantDetails: string[] = [];
-			
-			if (details.url) {
-				relevantDetails.push(`URL: ${details.url}`);
-			}
-			
-			if (details.method) {
-				relevantDetails.push(`Method: ${details.method}`);
-			}
-			
-			// Show response details if they exist and are meaningful
-			if (details.response && typeof details.response === 'object') {
-				const response = details.response as Record<string, any>;
-				if (response.error && response.error !== this.message) {
-					relevantDetails.push(`Server Error: ${response.error}`);
-				}
-				if (response.message && response.message !== this.message) {
-					relevantDetails.push(`Server Message: ${response.message}`);
-				}
-			}
-			
-			if (relevantDetails.length > 0) {
-				result += `\n  ${relevantDetails.join('\n  ')}`;
-			}
-		}
-		
-		return result;
-	}
-
-	/**
-	 * Returns a JSON representation suitable for logging
-	 */
-	toJSON(): object {
-		return {
-			name: this.name,
-			message: this.message,
-			statusCode: this.statusCode,
-			details: this.details,
-			stack: this.stack,
-		};
-	}
-}
-
-/**
- * Extracts error message from various Evolution API error response formats
- */
-export function extractErrorMessage(response: unknown): string | null {
-	if (!response) {
-		return null;
-	}
-
-	// Handle string responses
-	if (typeof response === "string") {
-		return response;
-	}
-
-	// Handle object responses
-	if (typeof response === "object" && response !== null) {
-		const errorObj = response as Record<string, any>;
-
-		// Try different common error message paths, prioritizing Evolution API format
-		const messagePaths = [
-			// Evolution API specific nested structure (most common)
-			errorObj.response?.response?.message?.[0],
-			errorObj.response?.response?.error,
-			errorObj.response?.response?.description,
-			
-			// Evolution API first level nested
-			Array.isArray(errorObj.response?.message) ? errorObj.response.message[0] : null,
-			errorObj.response?.error,
-			errorObj.response?.description,
-			
-			// Direct error message
-			Array.isArray(errorObj.message) ? errorObj.message[0] : errorObj.message,
-			errorObj.error,
-			errorObj.description,
-			errorObj.detail,
-			
-			// Other nested error messages
-			errorObj.data?.error,
-			errorObj.data?.message,
-			
-			// Array format messages (fallback)
-			Array.isArray(errorObj.error) ? errorObj.error[0] : null,
-			Array.isArray(errorObj.errors) ? errorObj.errors[0] : null,
-		];
-
-		for (const path of messagePaths) {
-			if (typeof path === "string" && path.trim()) {
-				return path.trim();
-			}
-			// Handle nested objects in arrays
-			if (typeof path === "object" && path !== null) {
-				const nestedMessage = extractErrorMessage(path);
-				if (nestedMessage) {
-					return nestedMessage;
-				}
-			}
-		}
-
-		// Handle validation errors (common format)
-		if (errorObj.validation && Array.isArray(errorObj.validation)) {
-			const validationErrors = errorObj.validation
-				.map((v: any) => v.message || v.error || String(v))
-				.filter(Boolean)
-				.join(", ");
-			if (validationErrors) {
-				return `Validation error: ${validationErrors}`;
-			}
-		}
-
-		// Handle specific Evolution API error patterns
-		if (errorObj.statusCode && errorObj.statusText) {
-			return `${errorObj.statusCode}: ${errorObj.statusText}`;
-		}
-
-		// Last resort: try to stringify the object meaningfully
-		if (Object.keys(errorObj).length > 0) {
-			try {
-				return JSON.stringify(errorObj);
-			} catch {
-				return "[Complex error object]";
-			}
-		}
-	}
-
-	return null;
-}
-
-/**
- * Legacy error message patterns for specific Evolution API errors
- * Kept for backward compatibility
- */
-const SpecificErrorPatterns = [
-	{
-		pattern: (obj: any) => 
-			obj?.message?.some?.((m: any) => m?.exists === false && m?.jid && m?.number),
-		message: "Provided number is not a valid WhatsApp number"
-	},
-	{
-		pattern: (obj: any) => 
-			obj?.message?.some?.((m: string) => typeof m === "string" && m.includes("Media upload failed")),
-		message: "Media upload failed on all hosts"
-	},
-	{
-		pattern: (obj: any) => 
-			obj?.message?.some?.((m: string) => typeof m === "string" && m.includes("No session")),
-		message: "No session found, try restarting your instance"
-	},
-	{
-		pattern: (obj: any) => 
-			obj?.message?.some?.((m: string) => typeof m === "string" && m.includes("AggregateError")),
-		message: "Connection error occurred"
-	},
-	{
-		pattern: (obj: any) => 
-			obj?.message?.some?.((m: string) => typeof m === "string" && m.includes("AxiosError")),
-		message: (obj: any) => obj.message[0] || "Network error occurred"
-	},
-];
-
-/**
- * Enhanced error message extraction with specific pattern matching
- */
-function getErrorMessage(response: unknown): string | null {
-	// First try the general extraction
-	const generalMessage = extractErrorMessage(response);
-	if (generalMessage) {
-		return generalMessage;
-	}
-
-	// Then try specific patterns
-	if (typeof response === "object" && response !== null) {
-		for (const { pattern, message } of SpecificErrorPatterns) {
-			try {
-				if (pattern(response)) {
-					return typeof message === "string" ? message : message(response);
-				}
-			} catch {
-				// Continue to next pattern if this one fails
-			}
-		}
-	}
-
-	return null;
-}

package/src/api/routes.ts

@@ -1,76 +0,0 @@
-export const Routes = {
-  Message: {
-    SendText: "message/sendText",
-    SendMedia: "message/sendMedia",
-    SendVoice: "message/sendWhatsAppAudio",
-    SendSticker: "message/sendSticker",
-    SendLocation: "message/sendLocation",
-    SendContact: "message/sendContact",
-    SendPoll: "message/sendPoll",
-    SendReaction: "message/sendReaction",
-    SendTemplate: "message/sendTemplate",
-    SendStatus: "message/sendStatus",
-    SendList: "message/sendList",
-  },
-  Chats: {
-    Check: "chat/whatsappNumbers",
-    FindAll: "chat/findChats",
-    SendPresence: "chat/sendPresence",
-    MarkAsRead: "chat/markMessageAsRead",
-    MarkAsUnread: "chat/markChatUnread",
-    Archive: "chat/archive",
-    DeleteMessage: "chat/deleteMessageForEveryone",
-    FetchProfilePicture: "chat/fetchProfilePictureUrl",
-    FindContacts: "chat/findContacts",
-    FindMessages: "chat/findMessages",
-    FindStatusMessage: "chat/findStatusMessage",
-    UpdateMessage: "chat/updateMessage",
-    GetBase64FromMediaMessage: "chat/getBase64FromMediaMessage",
-  },
-  Groups: {
-    FindAll: "group/fetchAllGroups",
-    FindByJid: "group/findGroupInfos",
-    FindByInviteCode: "group/inviteInfo",
-    Create: "group/create",
-    UpdatePicture: "group/updateGroupPicture",
-    UpdateSubject: "group/updateGroupSubject",
-    UpdateDescription: "group/updateGroupDescription",
-    FetchInviteCode: "group/fetchInviteCode",
-    AcceptInviteCode: "group/acceptInviteCode",
-    RevokeInviteCode: "group/revokeInviteCode",
-    SendGroupInvite: "group/sendGroupInvite",
-    FindMembers: "group/findGroupMembers",
-    UpdateMembers: "group/updateGroupMembers",
-    UpdateSetting: "group/updateGroupSetting",
-    ToggleEphemeral: "group/toggleEphemeral",
-    Leave: "group/leaveGroup",
-  },
-  Profile: {
-    FetchBusinessProfile: "chat/fetchBusinessProfile",
-    FetchProfile: "chat/fetchProfile",
-    UpdateName: "chat/updateProfileName",
-    UpdateStatus: "chat/updateProfileStatus",
-    UpdatePicture: "chat/updateProfilePicture",
-    RemovePicture: "chat/removeProfilePicture",
-    FetchPrivacySettings: "chat/fetchPrivacySettings",
-    UpdatePrivacySettings: "chat/updatePrivacySettings",
-  },
-  Webhook: {
-    Set: "webhook/set",
-    Find: "webhook/find",
-  },
-  Settings: {
-    Set: "settings/set",
-    Find: "settings/find",
-  },
-  Instance: {
-    Create: "instance/create",
-    FetchAll: "instance/fetchInstances",
-    Connect: "instance/connect",
-    Restart: "instance/restart",
-    ConnectionState: "instance/connectionState",
-    Logout: "instance/logout",
-    Delete: "instance/delete",
-    SetPresence: "instance/setPresence",
-  },
-};

package/src/api/service.ts

@@ -1,141 +0,0 @@
-import type { ClientOptions } from "@/schemas/client";
-import type { APIRequestInit } from "@/types/api";
-
-import { EvolutionApiError, extractErrorMessage } from "./errors";
-
-export class ApiService {
-  constructor(private options: ClientOptions) {}
-
-  setInstance(instance: string) {
-    this.options.instance = instance;
-  }
-
-  async request<T = unknown>(
-    path: string,
-    options: APIRequestInit = {}
-  ): Promise<T> {
-    const { isInstanceUrl = true } = options;
-    let instance = this.options.instance;
-
-    // Priority: options.instance > this.options.instance
-    if (options.instance) {
-      instance = options.instance;
-      delete options.instance;
-    }
-
-    if (isInstanceUrl && !instance) {
-      throw new EvolutionApiError("Instance not set", {
-        message:
-          "Please set the instance before making a request or pass instance in the method options.",
-      });
-    }
-
-    const { init, params } = this.makeInit(options);
-
-    const urlPath = isInstanceUrl ? `/${path}/${instance}/` : `/${path}/`;
-    const url = new URL(urlPath, this.options.serverUrl);
-
-    // Add query parameters if any
-    if (params.toString()) {
-      url.search = params.toString();
-    }
-
-    let response: Response;
-    let data: any;
-
-    try {
-      response = await fetch(url, init);
-      data = await response.json();
-    } catch (error) {
-      // Handle network errors or JSON parsing errors
-      throw new EvolutionApiError("Network or parsing error", error);
-    }
-
-    if (!response.ok) {
-      // Extract meaningful error message from the response
-      const errorMessage =
-        extractErrorMessage(data) ||
-        `Request failed with status ${response.status}: ${response.statusText}`;
-
-      throw new EvolutionApiError(
-        errorMessage,
-        {
-          message: errorMessage,
-          response: JSON.stringify(data),
-          url: url.toString(),
-          params: params.toString(),
-          body: JSON.stringify(options.body),
-        } as unknown as Record<string, any>,
-        response.status
-      );
-    }
-
-    return data;
-  }
-
-  private makeInit(options: APIRequestInit): {
-    init: RequestInit;
-    params: URLSearchParams;
-  } {
-    const init: RequestInit = {
-      method: options.method || "GET",
-      headers: {
-        "Content-Type": "application/json",
-        apikey: this.options.token, // Evolution API uses apikey header
-        ...this.options.headers,
-        ...options.headers,
-      },
-    };
-
-    if (options.body) {
-      init.body = JSON.stringify(options.body);
-    }
-
-    const params = new URLSearchParams();
-    if (options.params) {
-      // Convert any object to URLSearchParams
-      Object.entries(options.params).forEach(([key, value]) => {
-        if (value !== undefined && value !== null) {
-          params.append(key, String(value));
-        }
-      });
-    }
-
-    return { init, params };
-  }
-
-  async get<T = unknown>(
-    path: string,
-    options: Omit<APIRequestInit, "method"> = {}
-  ): Promise<T> {
-    return this.request<T>(path, { ...options, method: "GET" });
-  }
-
-  async post<T = unknown>(
-    path: string,
-    options: Omit<APIRequestInit, "method"> = {}
-  ): Promise<T> {
-    return this.request<T>(path, { ...options, method: "POST" });
-  }
-
-  async put<T = unknown>(
-    path: string,
-    options: Omit<APIRequestInit, "method"> = {}
-  ): Promise<T> {
-    return this.request<T>(path, { ...options, method: "PUT" });
-  }
-
-  async patch<T = unknown>(
-    path: string,
-    options: Omit<APIRequestInit, "method"> = {}
-  ): Promise<T> {
-    return this.request<T>(path, { ...options, method: "PATCH" });
-  }
-
-  async delete<T = unknown>(
-    path: string,
-    options: Omit<APIRequestInit, "method"> = {}
-  ): Promise<T> {
-    return this.request<T>(path, { ...options, method: "DELETE" });
-  }
-}

package/src/index.ts

@@ -1,89 +0,0 @@
-export * from "./types/webhooks";
-
-import { ApiService } from "./api/service";
-import {
-  ChatsModule,
-  GroupsModule,
-  InstanceModule,
-  MessagesModule,
-  ProfileModule,
-  SettingsModule,
-  WebhookModule,
-} from "./modules";
-import { type ClientOptions } from "./schemas/client";
-
-export class EvolutionClient {
-  /**
-   * API service for directly interacting with the Evolution API (no specific typings)
-   */
-  public readonly api: ApiService;
-
-  /**
-   * Find and manage chats, send presences and check numbers
-   */
-  public readonly chats: ChatsModule;
-  /**
-   * Find and manage groups
-   */
-  public readonly groups: GroupsModule;
-  /**
-   * Send messages
-   */
-  public readonly messages: MessagesModule;
-  /**
-   * Create and manage instances
-   */
-  public readonly instances: InstanceModule;
-  /**
-   * Manage profile settings
-   */
-  public readonly profile: ProfileModule;
-  /**
-   * Manage webhooks
-   */
-  public readonly webhook: WebhookModule;
-  /**
-   * Manage settings
-   */
-  public readonly settings: SettingsModule;
-
-  /**
-   * Evolution Client - API client for interacting with the Evolution API
-   * @param options - Client options
-   */
-  constructor(public options: ClientOptions) {
-    this.api = new ApiService(options);
-    this.chats = new ChatsModule(this.api);
-    this.groups = new GroupsModule(this.api);
-    this.messages = new MessagesModule(this.api);
-    this.instances = new InstanceModule(this.api);
-    this.profile = new ProfileModule(this.api);
-    this.webhook = new WebhookModule(this.api);
-    this.settings = new SettingsModule(this.api);
-  }
-
-  setInstance(instance: string) {
-    this.options.instance = instance;
-    this.api.setInstance(instance);
-  }
-}
-
-export { EvolutionApiError } from "./api/errors";
-export { phoneNumberFromJid } from "./utils/phone-numer-from-jid";
-export { validatePhoneNumber } from "./schemas/common";
-
-export type * from "./modules/chats/schemas";
-export type * from "./modules/groups/schemas";
-export type * from "./modules/messages/schemas";
-export type * from "./modules/instance/schemas";
-export type * from "./modules/profile/schemas";
-export type * from "./modules/webhook/schemas";
-export type * from "./modules/settings/schemas";
-export type { ClientOptions };
-
-// API types
-export { APIRequestInit, MethodOptions } from "./types/api";
-export { MessageUpdateStatus } from "./types/messages";
-export { ChatId, GroupJid, Jid, MessageId } from "./types/tags";
-export * from "./types/webhooks";
-export { WebhookEvent, WebhookEventSetup } from "./types/events";