@gymspace/evolution 1.0.0

package/src/modules/messages/index.ts

@@ -0,0 +1,246 @@
+import { Routes } from "@/api/routes";
+import type { ApiService } from "@/api/service";
+import type { MethodOptions } from "@/types/api";
+
+import type * as Audio from "./schemas/audio";
+import type * as Contact from "./schemas/contact";
+import type * as Document from "./schemas/document";
+import type * as Image from "./schemas/image";
+import type * as List from "./schemas/list";
+import type * as Location from "./schemas/location";
+import type * as Reaction from "./schemas/reaction";
+import type * as Status from "./schemas/status";
+import type * as Sticker from "./schemas/sticker";
+import type * as Template from "./schemas/template";
+import type * as Text from "./schemas/text";
+import type * as Video from "./schemas/video";
+import type * as Voice from "./schemas/voice";
+
+export class MessagesModule {
+  constructor(private readonly api: ApiService) {}
+
+  /**
+   * Sends a text message
+   * @param options - Text message options
+   * @param methodOptions - Method-specific options (instance override)
+   */
+  async sendText(
+    options: Text.TextMessageOptions,
+    methodOptions?: MethodOptions
+  ): Promise<Text.TextMessageResponse> {
+    const response = await this.api.post(Routes.Message.SendText, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as Text.TextMessageResponse;
+  }
+
+  /**
+   * Sends an image
+   * @param options - Image message options
+   * @param methodOptions - Method-specific options (instance override)
+   */
+  async sendImage(
+    options: Image.ImageMessageOptions,
+    methodOptions?: MethodOptions
+  ): Promise<Image.ImageMessageResponse> {
+    options.mediatype = "image";
+    const response = await this.api.post(Routes.Message.SendMedia, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as Image.ImageMessageResponse;
+  }
+
+  /**
+   * Sends a video
+   * @param options - Video message options
+   * @param methodOptions - Method-specific options (instance override)
+   */
+  async sendVideo(
+    options: Video.VideoMessageOptions,
+    methodOptions?: MethodOptions
+  ): Promise<Video.VideoMessageResponse> {
+    options.mediatype = "video";
+    const response = await this.api.post(Routes.Message.SendMedia, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as Video.VideoMessageResponse;
+  }
+
+  /**
+   * Sends a document
+   * @param options - Document message options
+   * @param methodOptions - Method-specific options (instance override)
+   */
+  async sendDocument(
+    options: Document.DocumentMessageOptions,
+    methodOptions?: MethodOptions
+  ): Promise<Document.DocumentMessageResponse> {
+    options.mediatype = "document";
+    const response = await this.api.post(Routes.Message.SendMedia, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as Document.DocumentMessageResponse;
+  }
+
+  /**
+   * Sends an audio
+   * @param options - Audio message options
+   * @param methodOptions - Method-specific options (instance override)
+   */
+  async sendAudio(
+    options: Audio.AudioMessageOptions,
+    methodOptions?: MethodOptions
+  ): Promise<Audio.AudioMessageResponse> {
+    options.mediatype = "audio";
+    const response = await this.api.post(Routes.Message.SendMedia, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as Audio.AudioMessageResponse;
+  }
+
+  /**
+   * Sends a voice message
+   * @param options - Voice message options
+   * @param methodOptions - Method-specific options (instance override)
+   */
+  async sendVoice(
+    options: Voice.VoiceMessageOptions,
+    methodOptions?: MethodOptions
+  ): Promise<Voice.VoiceMessageResponse> {
+    const response = await this.api.post(Routes.Message.SendVoice, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as Voice.VoiceMessageResponse;
+  }
+
+  /**
+   * Sends a sticker
+   * @param options - Sticker message options
+   * @param methodOptions - Method-specific options (instance override)
+   */
+  async sendSticker(
+    options: Sticker.StickerMessageOptions,
+    methodOptions?: MethodOptions
+  ): Promise<Sticker.StickerMessageResponse> {
+    const response = await this.api.post(Routes.Message.SendSticker, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as Sticker.StickerMessageResponse;
+  }
+
+  /**
+   * Sends a location
+   * @param options - Location message options
+   * @param methodOptions - Method-specific options (instance override)
+   */
+  async sendLocation(
+    options: Location.LocationMessageOptions,
+    methodOptions?: MethodOptions
+  ): Promise<Location.LocationMessageResponse> {
+    const response = await this.api.post(Routes.Message.SendLocation, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as Location.LocationMessageResponse;
+  }
+
+  /**
+   * Sends a contact
+   * @param options - Contact message options
+   * @param methodOptions - Method-specific options (instance override)
+   */
+  async sendContact(
+    options: Contact.ContactMessageOptions,
+    methodOptions?: MethodOptions
+  ): Promise<Contact.ContactMessageResponse> {
+    const response = await this.api.post(Routes.Message.SendContact, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as Contact.ContactMessageResponse;
+  }
+
+  /**
+   * Sends a reaction
+   * @param options - Reaction message options
+   * @param methodOptions - Method-specific options (instance override)
+   */
+  async sendReaction(
+    options: Reaction.ReactionMessageOptions,
+    methodOptions?: MethodOptions
+  ): Promise<Reaction.ReactionMessageResponse> {
+    const response = await this.api.post(Routes.Message.SendReaction, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as Reaction.ReactionMessageResponse;
+  }
+
+  /**
+   * Sends a template
+   * @param options - Template message options
+   * @param methodOptions - Method-specific options (instance override)
+   */
+  async sendTemplate(
+    options: Template.TemplateMessageOptions,
+    methodOptions?: MethodOptions
+  ): Promise<Template.TemplateMessageResponse> {
+    const response = await this.api.post(Routes.Message.SendTemplate, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as Template.TemplateMessageResponse;
+  }
+
+  /**
+   * Sends a status
+   * @param options - Status message options
+   * @param methodOptions - Method-specific options (instance override)
+   */
+  async sendStatus(
+    options: Status.StatusMessageOptions,
+    methodOptions?: MethodOptions
+  ): Promise<Status.StatusMessageResponse> {
+    const response = await this.api.post(Routes.Message.SendStatus, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as Status.StatusMessageResponse;
+  }
+
+  /**
+   * Sends a list
+   * @param options - List message options
+   * @param methodOptions - Method-specific options (instance override)
+   */
+  async sendList(
+    options: List.ListMessageOptions,
+    methodOptions?: MethodOptions
+  ): Promise<List.ListMessageResponse> {
+    const response = await this.api.post(Routes.Message.SendList, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as List.ListMessageResponse;
+  }
+}

package/src/modules/messages/schemas/audio.ts

@@ -0,0 +1,12 @@
+// Pure TypeScript interfaces for better IDE support and performance
+import { MediaMessageOptions, MediaMessageResponse } from "./media";
+
+// Request interfaces
+export interface AudioMessageOptions extends MediaMessageOptions {}
+
+// Response interfaces
+export interface AudioMessageResponse extends MediaMessageResponse {
+  message: MediaMessageResponse["message"] & {
+    audioMessage: MediaMessageResponse["message"]["audioMessage"];
+  };
+}

package/src/modules/messages/schemas/base.ts

@@ -0,0 +1,11 @@
+// Pure TypeScript interfaces for better IDE support and performance
+export interface BaseMessageOptions {
+	/**
+	 * Number (with country code) or JID to receive the message
+	 */
+	number: string;
+	/**
+	 * Time in milliseconds before sending message
+	 */
+	delay?: number;
+}

package/src/modules/messages/schemas/contact.ts

@@ -0,0 +1,70 @@
+// Pure TypeScript interfaces for better IDE support and performance
+import { BaseMessageOptions } from "./base";
+
+// Response interface from API (no transformer)
+export interface ContactMessageResponse {
+  key: {
+    remoteJid: string;
+    fromMe?: boolean;
+    id: string;
+  };
+  message: {
+    contactMessage?: {
+      displayName: string;
+      vcard: string;
+      contextInfo?: Record<string, unknown>;
+    };
+    contactsArrayMessage?: {
+      contacts: {
+        displayName: string;
+        vcard: string;
+      }[];
+    };
+  };
+  messageTimestamp: string | number | Date;
+  status?: string;
+}
+
+// Request interfaces
+export interface Contact {
+  /**
+   * Contact display name
+   */
+  fullName?: string;
+  /**
+   * Contact phone number
+   */
+  phoneNumber: string;
+  /**
+   * Contact organization
+   */
+  organization?: string;
+  /**
+   * Contact email
+   */
+  email?: string;
+  /**
+   * Contact website url
+   */
+  url?: string;
+}
+
+export type ContactMessageContact = Omit<Contact, "fullName"> & {
+  /**
+   * Contact display name
+   */
+  fullName?: string;
+  /**
+   * WhatsApp user id (JID or WUID)
+   */
+  wuid: string;
+};
+
+export interface ContactMessageOptions extends BaseMessageOptions {
+  /**
+   * Contact list
+   */
+  contact: [ContactMessageContact, ...ContactMessageContact[]];
+}
+
+// No additional response typing; API returns raw shape above

package/src/modules/messages/schemas/document.ts

@@ -0,0 +1,12 @@
+// Pure TypeScript interfaces for better IDE support and performance
+import { MediaMessageOptions, MediaMessageResponse } from "./media";
+
+// Request interfaces
+export interface DocumentMessageOptions extends MediaMessageOptions {}
+
+// Response interfaces
+export interface DocumentMessageResponse extends MediaMessageResponse {
+  message: MediaMessageResponse["message"] & {
+    documentMessage: MediaMessageResponse["message"]["documentMessage"];
+  };
+}

package/src/modules/messages/schemas/image.ts

@@ -0,0 +1,12 @@
+// Pure TypeScript interfaces for better IDE support and performance
+import { MediaMessageOptions, MediaMessageResponse } from "./media";
+
+// Request interfaces
+export interface ImageMessageOptions extends MediaMessageOptions {}
+
+// Response interfaces
+export interface ImageMessageResponse extends MediaMessageResponse {
+  message: MediaMessageResponse["message"] & {
+    imageMessage: MediaMessageResponse["message"]["imageMessage"];
+  };
+}

package/src/modules/messages/schemas/index.ts

@@ -0,0 +1,31 @@
+export type { AudioMessageOptions, AudioMessageResponse } from "./audio";
+export type { BaseMessageOptions } from "./base";
+export type {
+  ContactMessageOptions,
+  ContactMessageResponse,
+  ContactMessageContact,
+} from "./contact";
+export type {
+  DocumentMessageOptions,
+  DocumentMessageResponse,
+} from "./document";
+export type { ImageMessageOptions, ImageMessageResponse } from "./image";
+export type { ListMessageOptions, ListMessageResponse } from "./list";
+export type {
+  LocationMessageOptions,
+  LocationMessageResponse,
+} from "./location";
+export type { PollMessageOptions, PollMessageResponse } from "./poll";
+export type {
+  ReactionMessageOptions,
+  ReactionMessageResponse,
+} from "./reaction";
+export type { StatusMessageOptions, StatusMessageResponse } from "./status";
+export type { StickerMessageOptions, StickerMessageResponse } from "./sticker";
+export type {
+  TemplateMessageOptions,
+  TemplateMessageResponse,
+} from "./template";
+export type { TextMessageOptions, TextMessageResponse } from "./text";
+export type { VideoMessageOptions, VideoMessageResponse } from "./video";
+export type { VoiceMessageOptions, VoiceMessageResponse } from "./voice";

package/src/modules/messages/schemas/list.ts

@@ -0,0 +1,36 @@
+// Pure TypeScript interfaces for better IDE support and performance
+import type { ChatId, MessageId } from "@/types/tags";
+
+export interface Row {
+  title: string;
+  description?: string;
+  rowId: string;
+}
+
+export interface Section {
+  title: string;
+  rows: Row[];
+}
+
+export interface ListMessageOptions {
+  number: ChatId;
+  buttonText: string;
+  text: string;
+  title?: string;
+  footer?: string;
+  sections: Section[];
+  options?: {
+    delay?: number;
+    messageId?: MessageId;
+  };
+}
+
+export interface ListMessageResponse {
+  key: {
+    remoteJid: ChatId;
+    fromMe: boolean;
+    id: MessageId;
+  };
+  messageTimestamp: string;
+  status: string;
+} 

package/src/modules/messages/schemas/location.ts

@@ -0,0 +1,76 @@
+// Pure TypeScript interfaces for better IDE support and performance
+import { Jid, MessageId } from "@/types/tags";
+import { phoneNumberFromJid } from "@/utils/phone-numer-from-jid";
+import { BaseMessageOptions } from "./base";
+
+// Raw response interface from API
+export interface LocationMessageResponseRaw {
+	key: {
+		remoteJid: string;
+		id: string;
+	};
+	message: {
+		locationMessage: {
+			degreesLatitude: number;
+			degreesLongitude: number;
+			name: string;
+			address: string;
+		};
+	};
+	messageTimestamp: string | Date;
+}
+
+// Request interfaces
+export interface LocationMessageOptions extends BaseMessageOptions {
+	/**
+	 * Location name
+	 */
+	name: string;
+	/**
+	 * Location address
+	 */
+	address: string;
+	/**
+	 * Location latitude
+	 */
+	latitude: number;
+	/**
+	 * Location longitude
+	 */
+	longitude: number;
+}
+
+// Response interfaces
+export interface LocationMessageResponse {
+	receiver: {
+		phoneNumber: string;
+		jid: Jid;
+	};
+	location: {
+		latitude: number;
+		longitude: number;
+		name: string;
+		address: string;
+	};
+	id: MessageId;
+	timestamp: Date;
+}
+
+// Transform function
+export const LocationMessageResponseTransform = (data: LocationMessageResponseRaw): LocationMessageResponse => ({
+	receiver: {
+		phoneNumber: phoneNumberFromJid(data.key.remoteJid),
+		jid: Jid(data.key.remoteJid),
+	},
+	location: {
+		latitude: data.message.locationMessage.degreesLatitude,
+		longitude: data.message.locationMessage.degreesLongitude,
+		name: data.message.locationMessage.name,
+		address: data.message.locationMessage.address,
+	},
+	id: MessageId(data.key.id),
+	timestamp: new Date(data.messageTimestamp),
+});
+
+// Backward compatibility aliases
+export const ResponseSchema = { parse: LocationMessageResponseTransform };

package/src/modules/messages/schemas/media.ts

@@ -0,0 +1,51 @@
+import { Media } from "@/schemas/common";
+import { BaseMessageOptions } from "./base";
+
+// Request interfaces
+export interface MediaMessageOptions extends BaseMessageOptions {
+  mediatype: "audio" | "image" | "video" | "document";
+  mimetype?: string;
+  caption?: string;
+  media: Media;
+  fileName?: string;
+  linkPreview?: boolean;
+  mentionsEveryOne?: boolean;
+  mentioned?: string[];
+  quoted?: {
+    key: {
+      id: string;
+    };
+    message: {
+      conversation: string;
+    };
+  };
+}
+
+// Response interfaces
+export interface MediaMessageResponse {
+  key: {
+    remoteJid: string;
+    fromMe: boolean;
+    id: string;
+  };
+  message: {
+    [T in
+      | "audioMessage"
+      | "imageMessage"
+      | "videoMessage"
+      | "documentMessage"]: {
+      url: string;
+      mimetype: string;
+      fileSha256: string;
+      fileLength: string;
+      seconds: number;
+      ptt: boolean;
+      mediaKey: string;
+      fileEncSha256: string;
+      directPath: string;
+      mediaKeyTimestamp: string;
+    };
+  };
+  messageTimestamp: string;
+  status: "PENDING" | "SUCCESS" | "FAILED";
+}

package/src/modules/messages/schemas/poll.ts

@@ -0,0 +1,87 @@
+// Pure TypeScript interfaces for better IDE support and performance
+import { Jid, MessageId } from "@/types/tags";
+import { phoneNumberFromJid } from "@/utils/phone-numer-from-jid";
+import { BaseMessageOptions } from "./base";
+
+// Raw response interface from API
+export interface PollMessageResponseRaw {
+	key: {
+		remoteJid: string;
+		id: string;
+	};
+	message: {
+		pollCreationMessageV3: {
+			name: string;
+			options: { optionName: string }[];
+			selectableOptionsCount: number;
+		};
+	};
+	messageTimestamp: string | Date;
+}
+
+// Request interfaces
+export interface PollMessageOptions extends BaseMessageOptions {
+	/**
+	 * Name of the poll
+	 */
+	name: string;
+	/**
+	 * Whether multiple options can be selected
+	 * @default false
+	 */
+	multiple?: boolean;
+	/**
+	 * Poll options
+	 */
+	options: string[];
+}
+
+export interface PollMessageBody extends BaseMessageOptions {
+	name: string;
+	selectableCount: number;
+	values: string[];
+}
+
+// Response interfaces
+export interface PollMessageResponse {
+	receiver: {
+		phoneNumber: string;
+		jid: Jid;
+	};
+	poll: {
+		name: string;
+		options: string[];
+		multiple: boolean;
+	};
+	id: MessageId;
+	timestamp: Date;
+}
+
+// Transform functions
+export const PollMessageBodyTransform = (
+	{ multiple, options, ...data }: PollMessageOptions
+): PollMessageBody => ({
+	...data,
+	selectableCount: multiple ? options.length : 1,
+	values: options,
+});
+
+export const PollMessageResponseTransform = (data: PollMessageResponseRaw): PollMessageResponse => ({
+	receiver: {
+		phoneNumber: phoneNumberFromJid(data.key.remoteJid),
+		jid: Jid(data.key.remoteJid),
+	},
+	poll: {
+		name: data.message.pollCreationMessageV3.name,
+		options: data.message.pollCreationMessageV3.options.map(
+			(option) => option.optionName,
+		),
+		multiple: data.message.pollCreationMessageV3.selectableOptionsCount > 1,
+	},
+	id: MessageId(data.key.id),
+	timestamp: new Date(data.messageTimestamp),
+});
+
+// Backward compatibility aliases
+export const BodySchema = { parse: PollMessageBodyTransform };
+export const ResponseSchema = { parse: PollMessageResponseTransform };

package/src/modules/messages/schemas/reaction.ts

@@ -0,0 +1,21 @@
+// Pure TypeScript interfaces for better IDE support and performance
+import type { ChatId, MessageId } from "@/types/tags";
+
+export interface ReactionMessageOptions {
+  key: {
+    remoteJid: ChatId;
+    fromMe: boolean;
+    id: MessageId;
+  };
+  reaction: string;
+}
+
+export interface ReactionMessageResponse {
+  key: {
+    remoteJid: ChatId;
+    fromMe: boolean;
+    id: MessageId;
+  };
+  messageTimestamp: string;
+  status: string;
+}

package/src/modules/messages/schemas/status.ts

@@ -0,0 +1,18 @@
+// Pure TypeScript interfaces for better IDE support and performance
+export interface StatusMessageOptions {
+  message: string;
+  options?: {
+    backgroundColor?: string;
+    font?: number; // 0-6 range
+  };
+}
+
+export interface StatusMessageResponse {
+  key: {
+    remoteJid: string;
+    fromMe: boolean;
+    id: string;
+  };
+  messageTimestamp: string;
+  status: string;
+}