@solufy/evolution-sdk
Version:
Unofficial SDK for the Evolution Whatsapp API v2
698 lines (681 loc) • 22.9 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/modules/messages/index.ts
var messages_exports = {};
__export(messages_exports, {
MessagesModule: () => MessagesModule
});
module.exports = __toCommonJS(messages_exports);
// src/api/routes.ts
var Routes = {
Message: {
SendText: "message/sendText",
SendMedia: "message/sendMedia",
SendVoice: "message/sendWhatsAppAudio",
SendSticker: "message/sendSticker",
SendLocation: "message/sendLocation",
SendContact: "message/sendContact",
SendPoll: "message/sendPoll"
},
Chats: {
Check: "chat/whatsappNumbers",
FindAll: "chat/findChats",
SendPresence: "chat/sendPresence"
},
Groups: {
FindAll: "group/fetchAllGroups",
FindByJid: "group/findGroupInfos",
FindByInviteCode: "group/inviteInfo"
}
};
// src/modules/messages/schemas/audio.ts
var import_zod3 = require("zod");
// src/schemas/common.ts
var import_libphonenumber_js = require("libphonenumber-js");
var import_zod = require("zod");
var PhoneNumberSchema = import_zod.z.custom((value) => (0, import_libphonenumber_js.isValidPhoneNumber)(value), "Invalid phone number").transform((phoneNumber) => (0, import_libphonenumber_js.parsePhoneNumber)(phoneNumber).number);
var JidSchema = import_zod.z.string().endsWith(
"@s.whatsapp.net",
"Invalid remote JID, should end with @s.whatsapp.net"
);
var GroupJidSchema = import_zod.z.string().endsWith(
"@g.us",
"Invalid group JID, should end with @g.us"
);
var GroupInviteCodeSchema = import_zod.z.string().length(22).regex(
/^[a-zA-Z0-9]{22}$/,
"Invalid group invite code"
);
var ApiNumberSchema = import_zod.z.union([
PhoneNumberSchema,
JidSchema,
GroupJidSchema
]);
var mediaSchema = import_zod.z.union([import_zod.z.string().url(), import_zod.z.string().base64()]);
// src/types/tags.ts
var Jid = (jid) => jid;
var MessageId = (id) => id;
// src/utils/phone-numer-from-jid.ts
var import_libphonenumber_js2 = require("libphonenumber-js");
function phoneNumberFromJid(jid) {
return (0, import_libphonenumber_js2.parsePhoneNumber)(`+${jid.split("@")[0]}`).number;
}
// src/modules/messages/schemas/base.ts
var import_zod2 = require("zod");
var BaseMessageOptionsSchema = import_zod2.z.object({
/**
* Number (with country code) or JID to receive the message
*/
number: ApiNumberSchema,
/**
* Time in milliseconds before sending message
*/
delay: import_zod2.z.number().optional()
});
// src/modules/messages/schemas/audio.ts
var AudioMessageOptionsSchema = BaseMessageOptionsSchema.extend({
/**
* Audio URL or file in base64
*/
audio: mediaSchema,
/**
* Audio mimetype
*/
mimetype: import_zod3.z.string().optional()
});
var AudioMessageBodySchema = AudioMessageOptionsSchema.transform(
({ audio, ...data }) => ({ ...data, media: audio, mediatype: "audio" })
);
var AudioMessageResponseSchema = import_zod3.z.object({
key: import_zod3.z.object({
remoteJid: import_zod3.z.string(),
id: import_zod3.z.string()
}),
message: import_zod3.z.object({
audioMessage: import_zod3.z.object({
url: import_zod3.z.string().url(),
mimetype: import_zod3.z.string().optional(),
fileSha256: import_zod3.z.string().base64(),
fileLength: import_zod3.z.coerce.number(),
seconds: import_zod3.z.number(),
mediaKey: import_zod3.z.string().base64(),
fileEncSha256: import_zod3.z.string().base64(),
directPath: import_zod3.z.string(),
mediaKeyTimestamp: import_zod3.z.coerce.number().transform((value) => new Date(value))
})
}),
messageTimestamp: import_zod3.z.coerce.date()
}).transform((data) => ({
receiver: {
phoneNumber: phoneNumberFromJid(data.key.remoteJid),
jid: Jid(data.key.remoteJid)
},
media: {
url: data.message.audioMessage.url,
mimetype: data.message.audioMessage.mimetype,
length: data.message.audioMessage.fileLength,
durationInSeconds: data.message.audioMessage.seconds,
sha256: data.message.audioMessage.fileSha256,
encryptedSha256: data.message.audioMessage.fileEncSha256,
directPath: data.message.audioMessage.directPath,
key: data.message.audioMessage.mediaKey,
keyTimestamp: data.message.audioMessage.mediaKeyTimestamp
},
id: MessageId(data.key.id),
timestamp: data.messageTimestamp
}));
// src/modules/messages/schemas/contact.ts
var import_libphonenumber_js3 = require("libphonenumber-js");
var import_zod4 = require("zod");
var ContactMessageOptionsSchema = BaseMessageOptionsSchema.extend({
/**
* Contact list
*/
contacts: import_zod4.z.array(
import_zod4.z.object({
/**
* Contact display name
*/
fullName: import_zod4.z.string(),
/**
* Contact phone number
*/
phoneNumber: PhoneNumberSchema,
/**
* Contact organization
*/
organization: import_zod4.z.string().optional(),
/**
* Contact email
*/
email: import_zod4.z.string().email().optional(),
/**
* Contact website url
*/
url: import_zod4.z.string().url().optional()
})
)
});
var ContactMessageBodySchema = ContactMessageOptionsSchema.transform(
({ contacts, ...data }) => ({
...data,
contact: contacts.map((contact) => ({
...contact,
phoneNumber: (0, import_libphonenumber_js3.parsePhoneNumber)(contact.phoneNumber).formatInternational(),
wuid: contact.phoneNumber.replace(/\D/g, "")
}))
})
);
var ContactMessageResponseSchema = import_zod4.z.object({
key: import_zod4.z.object({
remoteJid: import_zod4.z.string(),
id: import_zod4.z.string()
}),
message: import_zod4.z.union([
import_zod4.z.object({
contactMessage: import_zod4.z.object({
displayName: import_zod4.z.string(),
vcard: import_zod4.z.string()
})
}),
import_zod4.z.object({
contactsArrayMessage: import_zod4.z.object({
contacts: import_zod4.z.array(
import_zod4.z.object({
displayName: import_zod4.z.string(),
vcard: import_zod4.z.string()
})
)
})
})
]),
messageTimestamp: import_zod4.z.coerce.date()
}).transform((data) => ({
receiver: {
phoneNumber: phoneNumberFromJid(data.key.remoteJid),
jid: Jid(data.key.remoteJid)
},
contacts: "contactMessage" in data.message ? [data.message.contactMessage] : data.message.contactsArrayMessage.contacts,
id: MessageId(data.key.id),
timestamp: data.messageTimestamp
}));
// src/modules/messages/schemas/document.ts
var import_zod5 = require("zod");
var DocumentMessageOptionsSchema = BaseMessageOptionsSchema.extend({
/**
* Document URL or file in base64
*/
document: mediaSchema,
/**
* Caption to send with document
*/
caption: import_zod5.z.string().optional(),
/**
* Document mimetype
*/
mimetype: import_zod5.z.string().optional(),
/**
* Name of the file
*/
fileName: import_zod5.z.string().optional()
}).refine(
(data) => URL.canParse(data.document) ? true : Boolean(data.fileName),
{
message: "fileName must be provided when document is not an URL",
path: ["fileName"]
}
);
var DocumentMessageBodySchema = DocumentMessageOptionsSchema.transform(
({ document, ...data }) => ({
...data,
media: document,
mediatype: "document"
})
);
var DocumentMessageResponseSchema = import_zod5.z.object({
key: import_zod5.z.object({
remoteJid: import_zod5.z.string(),
id: import_zod5.z.string()
}),
message: import_zod5.z.object({
documentMessage: import_zod5.z.object({
url: import_zod5.z.string().url(),
mimetype: import_zod5.z.string().optional(),
fileSha256: import_zod5.z.string().base64(),
fileLength: import_zod5.z.coerce.number(),
mediaKey: import_zod5.z.string().base64(),
caption: import_zod5.z.string().optional(),
fileName: import_zod5.z.string(),
fileEncSha256: import_zod5.z.string().base64(),
directPath: import_zod5.z.string(),
mediaKeyTimestamp: import_zod5.z.coerce.number().transform((value) => new Date(value))
})
}),
messageTimestamp: import_zod5.z.coerce.date()
}).transform((data) => ({
receiver: {
phoneNumber: phoneNumberFromJid(data.key.remoteJid),
jid: Jid(data.key.remoteJid)
},
media: {
url: data.message.documentMessage.url,
caption: data.message.documentMessage.caption,
mimetype: data.message.documentMessage.mimetype,
length: data.message.documentMessage.fileLength,
sha256: data.message.documentMessage.fileSha256,
fileName: data.message.documentMessage.fileName,
encryptedSha256: data.message.documentMessage.fileEncSha256,
directPath: data.message.documentMessage.directPath,
key: data.message.documentMessage.mediaKey,
keyTimestamp: data.message.documentMessage.mediaKeyTimestamp
},
id: MessageId(data.key.id),
timestamp: data.messageTimestamp
}));
// src/modules/messages/schemas/image.ts
var import_zod6 = require("zod");
var ImageMessageOptionsSchema = BaseMessageOptionsSchema.extend({
/**
* Image URL or file in base64
*/
image: mediaSchema,
/**
* Caption to send with image
*/
caption: import_zod6.z.string().optional(),
/**
* Image mimetype
*/
mimetype: import_zod6.z.string().optional()
});
var ImageMessageBodySchema = ImageMessageOptionsSchema.transform(
({ image, ...data }) => ({ ...data, media: image, mediatype: "image" })
);
var ImageMessageResponseSchema = import_zod6.z.object({
key: import_zod6.z.object({
remoteJid: import_zod6.z.string(),
id: import_zod6.z.string()
}),
message: import_zod6.z.object({
imageMessage: import_zod6.z.object({
url: import_zod6.z.string().url(),
mimetype: import_zod6.z.string().optional(),
fileSha256: import_zod6.z.string().base64(),
fileLength: import_zod6.z.coerce.number(),
height: import_zod6.z.number(),
width: import_zod6.z.number(),
mediaKey: import_zod6.z.string().base64(),
caption: import_zod6.z.string().optional(),
fileEncSha256: import_zod6.z.string().base64(),
directPath: import_zod6.z.string(),
mediaKeyTimestamp: import_zod6.z.coerce.number().transform((value) => new Date(value))
})
}),
messageTimestamp: import_zod6.z.coerce.date()
}).transform((data) => ({
receiver: {
phoneNumber: phoneNumberFromJid(data.key.remoteJid),
jid: Jid(data.key.remoteJid)
},
media: {
url: data.message.imageMessage.url,
caption: data.message.imageMessage.caption,
mimetype: data.message.imageMessage.mimetype,
length: data.message.imageMessage.fileLength,
height: data.message.imageMessage.height,
width: data.message.imageMessage.width,
sha256: data.message.imageMessage.fileSha256,
encryptedSha256: data.message.imageMessage.fileEncSha256,
directPath: data.message.imageMessage.directPath,
key: data.message.imageMessage.mediaKey,
keyTimestamp: data.message.imageMessage.mediaKeyTimestamp
},
id: MessageId(data.key.id),
timestamp: data.messageTimestamp
}));
// src/modules/messages/schemas/location.ts
var import_zod7 = require("zod");
var LocationMessageOptionsSchema = BaseMessageOptionsSchema.extend({
/**
* Location name
*/
name: import_zod7.z.string(),
/**
* Location address
*/
address: import_zod7.z.string(),
/**
* Location latitude
*/
latitude: import_zod7.z.number(),
/**
* Location longitude
*/
longitude: import_zod7.z.number()
});
var LocationMessageBodySchema = LocationMessageOptionsSchema;
var LocationMessageResponseSchema = import_zod7.z.object({
key: import_zod7.z.object({
remoteJid: import_zod7.z.string(),
id: import_zod7.z.string()
}),
message: import_zod7.z.object({
locationMessage: import_zod7.z.object({
degreesLatitude: import_zod7.z.number(),
degreesLongitude: import_zod7.z.number(),
name: import_zod7.z.string(),
address: import_zod7.z.string()
})
}),
messageTimestamp: import_zod7.z.coerce.date()
}).transform((data) => ({
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: data.messageTimestamp
}));
// src/modules/messages/schemas/sticker.ts
var import_zod8 = require("zod");
var StickerMessageOptionsSchema = BaseMessageOptionsSchema.extend({
/**
* Image URL or file in base64
*/
sticker: mediaSchema
});
var StickerMessageBodySchema = StickerMessageOptionsSchema;
var StickerMessageResponseSchema = import_zod8.z.object({
key: import_zod8.z.object({
remoteJid: import_zod8.z.string(),
id: import_zod8.z.string()
}),
message: import_zod8.z.object({
stickerMessage: import_zod8.z.object({
url: import_zod8.z.string().url(),
fileSha256: import_zod8.z.string().base64(),
fileEncSha256: import_zod8.z.string().base64(),
mediaKey: import_zod8.z.string().base64(),
mimetype: import_zod8.z.string().optional(),
directPath: import_zod8.z.string(),
fileLength: import_zod8.z.coerce.number(),
mediaKeyTimestamp: import_zod8.z.coerce.number().transform((value) => new Date(value))
})
}),
messageTimestamp: import_zod8.z.coerce.date()
}).transform((data) => ({
receiver: {
phoneNumber: phoneNumberFromJid(data.key.remoteJid),
jid: Jid(data.key.remoteJid)
},
media: {
url: data.message.stickerMessage.url,
mimetype: data.message.stickerMessage.mimetype,
length: data.message.stickerMessage.fileLength,
sha256: data.message.stickerMessage.fileSha256,
encryptedSha256: data.message.stickerMessage.fileEncSha256,
directPath: data.message.stickerMessage.directPath,
key: data.message.stickerMessage.mediaKey,
keyTimestamp: data.message.stickerMessage.mediaKeyTimestamp
},
id: MessageId(data.key.id),
timestamp: data.messageTimestamp
}));
// src/modules/messages/schemas/text.ts
var import_zod9 = require("zod");
var TextMessageOptionsSchema = BaseMessageOptionsSchema.extend({
/**
* Message text content
*/
text: import_zod9.z.string(),
/**
* Whether link preview should be shown
*/
linkPreview: import_zod9.z.boolean().optional()
});
var TextMessageBodySchema = TextMessageOptionsSchema;
var TextMessageResponseSchema = import_zod9.z.object({
key: import_zod9.z.object({
remoteJid: import_zod9.z.string(),
id: import_zod9.z.string()
}),
messageTimestamp: import_zod9.z.coerce.date()
}).transform((data) => ({
receiver: {
phoneNumber: phoneNumberFromJid(data.key.remoteJid),
jid: Jid(data.key.remoteJid)
},
messageId: MessageId(data.key.id),
timestamp: data.messageTimestamp
}));
// src/modules/messages/schemas/video.ts
var import_zod10 = require("zod");
var VideoMessageOptionsSchema = BaseMessageOptionsSchema.extend({
/**
* Video URL or file in base64
*/
video: mediaSchema,
/**
* Caption to send with video
*/
caption: import_zod10.z.string().optional(),
/**
* Video mimetype
*/
mimetype: import_zod10.z.string().optional()
});
var VideoMessageBodySchema = VideoMessageOptionsSchema.transform(
({ video, ...data }) => ({ ...data, media: video, mediatype: "video" })
);
var VideoMessageResponseSchema = import_zod10.z.object({
key: import_zod10.z.object({
remoteJid: import_zod10.z.string(),
id: import_zod10.z.string()
}),
message: import_zod10.z.object({
videoMessage: import_zod10.z.object({
url: import_zod10.z.string().url(),
mimetype: import_zod10.z.string().optional(),
fileSha256: import_zod10.z.string().base64(),
fileLength: import_zod10.z.coerce.number(),
mediaKey: import_zod10.z.string().base64(),
caption: import_zod10.z.string().optional(),
gifPlayback: import_zod10.z.boolean(),
fileEncSha256: import_zod10.z.string().base64(),
directPath: import_zod10.z.string(),
mediaKeyTimestamp: import_zod10.z.coerce.number().transform((value) => new Date(value))
})
}),
messageTimestamp: import_zod10.z.coerce.date()
}).transform((data) => ({
receiver: {
phoneNumber: phoneNumberFromJid(data.key.remoteJid),
jid: Jid(data.key.remoteJid)
},
media: {
url: data.message.videoMessage.url,
caption: data.message.videoMessage.caption,
mimetype: data.message.videoMessage.mimetype,
gifPlayback: data.message.videoMessage.gifPlayback,
length: data.message.videoMessage.fileLength,
sha256: data.message.videoMessage.fileSha256,
encryptedSha256: data.message.videoMessage.fileEncSha256,
directPath: data.message.videoMessage.directPath,
key: data.message.videoMessage.mediaKey,
keyTimestamp: data.message.videoMessage.mediaKeyTimestamp
},
id: MessageId(data.key.id),
timestamp: data.messageTimestamp
}));
// src/modules/messages/schemas/voice.ts
var import_zod11 = require("zod");
var VoiceMessageOptionsSchema = BaseMessageOptionsSchema.extend({
/**
* Audio URL or file in base64
*/
audio: mediaSchema,
/**
* Encode audio into WhatsApp default format (allows audio to be sped up)
* @default true
*/
encoding: import_zod11.z.boolean().optional().default(true)
});
var VoiceMessageBodySchema = VoiceMessageOptionsSchema;
var VoiceMessageResponseSchema = import_zod11.z.object({
key: import_zod11.z.object({
remoteJid: import_zod11.z.string(),
id: import_zod11.z.string()
}),
message: import_zod11.z.object({
audioMessage: import_zod11.z.object({
url: import_zod11.z.string().url(),
mimetype: import_zod11.z.string(),
fileSha256: import_zod11.z.string().base64(),
fileLength: import_zod11.z.coerce.number(),
seconds: import_zod11.z.number(),
ptt: import_zod11.z.boolean().optional(),
mediaKey: import_zod11.z.string().base64(),
fileEncSha256: import_zod11.z.string().base64(),
directPath: import_zod11.z.string(),
mediaKeyTimestamp: import_zod11.z.coerce.number().transform((value) => new Date(value)),
waveform: import_zod11.z.string().base64().nullish()
})
}),
messageTimestamp: import_zod11.z.coerce.date()
}).transform((data) => ({
receiver: {
phoneNumber: phoneNumberFromJid(data.key.remoteJid),
jid: Jid(data.key.remoteJid)
},
media: {
url: data.message.audioMessage.url,
mimetype: data.message.audioMessage.mimetype,
length: data.message.audioMessage.fileLength,
durationInSeconds: data.message.audioMessage.seconds,
sha256: data.message.audioMessage.fileSha256,
encryptedSha256: data.message.audioMessage.fileEncSha256,
directPath: data.message.audioMessage.directPath,
/**
* Indicates whether the audio message is a push-to-talk (PTT) message
*/
isPtt: data.message.audioMessage.ptt,
key: data.message.audioMessage.mediaKey,
keyTimestamp: data.message.audioMessage.mediaKeyTimestamp,
waveform: data.message.audioMessage.waveform
},
messageId: MessageId(data.key.id),
timestamp: data.messageTimestamp
}));
// src/modules/messages/index.ts
var MessagesModule = class {
constructor(api) {
this.api = api;
}
/**
* Sends a text message
* @param options - Text message options
*/
async sendText(options) {
const body = TextMessageBodySchema.parse(options);
const response = await this.api.post(Routes.Message.SendText, { body });
return TextMessageResponseSchema.parse(response);
}
/**
* Sends an image
* @param options - Image message options
*/
async sendImage(options) {
const body = ImageMessageBodySchema.parse(options);
const response = await this.api.post(Routes.Message.SendMedia, { body });
return ImageMessageResponseSchema.parse(response);
}
/**
* Sends a video
* @param options - Video message options
*/
async sendVideo(options) {
const body = VideoMessageBodySchema.parse(options);
const response = await this.api.post(Routes.Message.SendMedia, { body });
return VideoMessageResponseSchema.parse(response);
}
/**
* Sends a document
* @param options - Document message options
*/
async sendDocument(options) {
const body = DocumentMessageBodySchema.parse(options);
const response = await this.api.post(Routes.Message.SendMedia, { body });
return DocumentMessageResponseSchema.parse(response);
}
/**
* Sends an audio
* @param options - Audio message options
*/
async sendAudio(options) {
const body = AudioMessageBodySchema.parse(options);
const response = await this.api.post(Routes.Message.SendMedia, { body });
return AudioMessageResponseSchema.parse(response);
}
/**
* Sends a voice message
* @param options - Voice message options
*/
async sendVoice(options) {
const body = VoiceMessageBodySchema.parse(options);
const response = await this.api.post(Routes.Message.SendVoice, { body });
return VoiceMessageResponseSchema.parse(response);
}
/**
* Sends a sticker
* @param options - Sticker message options
*/
async sendSticker(options) {
const body = StickerMessageBodySchema.parse(options);
const response = await this.api.post(Routes.Message.SendSticker, { body });
return StickerMessageResponseSchema.parse(response);
}
/**
* Sends a location
* @param options - Location message options
*/
async sendLocation(options) {
const body = LocationMessageBodySchema.parse(options);
const response = await this.api.post(Routes.Message.SendLocation, { body });
return LocationMessageResponseSchema.parse(response);
}
/**
* Sends a contact
* @param options - Contact message options
*/
async sendContact(options) {
const body = ContactMessageBodySchema.parse(options);
const response = await this.api.post(Routes.Message.SendContact, { body });
return ContactMessageResponseSchema.parse(response);
}
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
MessagesModule
});
//# sourceMappingURL=index.js.map