whatsapp_notifier 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e65ad0d6844d9762bccd0a929a9d70613a0e9fb145564b75c35f196fc87e4088
-  data.tar.gz: 109a415b4a618aac44d5ce9da4f886590a600e8bdb9168ada01e740e9b5add9f
+  metadata.gz: 130b5676184b753e6329f98ead313255db4a16be9393597f4b34f38741ae9c63
+  data.tar.gz: 7c7fe4a7eb0464676d4257443fa3003e80035e938e41d690aee7282787fd962a
 SHA512:
-  metadata.gz: 45cbd20b37120dd2b533db5fa28b31dddbbbb00a06538c5a8c75cccd458d2f598c9d2089b898ed890b8cb88693613849d8ca036743d96bbba0d482cf121c70b4
-  data.tar.gz: e63080fe514ff18d3f225baebeefef3856b10f83d80087c7c7a33e3b50cc5a150cdc4a964646520a5f866685c13dd08c14f0a8888bed93fc2df5403676eab93a
+  metadata.gz: 18e39291eabaa4a61e33a7a9f62a840b233320724147dc24614f740dafaa14151363a2e606943027098b42bed3dbea80db81459d1c73a38d1ad6989d0a1d2104
+  data.tar.gz: 35170c14888aa976a0eb211757e617a2237ab8e442ee75b9e319391d1737bbb75ce81d3a69802b71b9f712ab8d8731e4fd1d243123017cac05c5c686cac9830c

data/lib/whatsapp_notifier/services/web_automation/index.ts

@@ -32,7 +32,7 @@ import {
     mediaGetResponse,
     mediaDeleteResponse
 } from './media';
-import { sentMessageId } from './send';
+import { sentMessageId, sendValidationError, fetchMedia, captionOptions } from './send';
 
 const app = new Hono();
 const port = Number(process.env.PORT || 3001);
@@ -203,7 +203,7 @@ async function waitForClientReady(clientData: ClientData, timeoutMs = 30000): Pr
 
 // Resolves to the sent whatsapp-web.js Message so /send can hand the real
 // message id back to the host (the echo-dedupe key for two-way capture).
-async function sendMessageWithRetry(client: Client, clientData: ClientData, chatId: string, message: string, mediaUrl?: string | null) {
+async function sendMessageWithRetry(client: Client, clientData: ClientData, chatId: string, message?: string | null, mediaUrl?: string | null) {
     const maxAttempts = 5;
 
     // Wait for the internal WWeb store to be fully loaded before first attempt
@@ -213,11 +213,12 @@ async function sendMessageWithRetry(client: Client, clientData: ClientData, chat
         try {
             if (mediaUrl) {
                 const { MessageMedia } = require('whatsapp-web.js');
-                const media = await MessageMedia.fromUrl(mediaUrl);
-                return await client.sendMessage(chatId, media, { caption: message });
+                // unsafeMime + no-caption handling live in send.ts (unit-tested).
+                const media = await fetchMedia(MessageMedia, mediaUrl);
+                return await client.sendMessage(chatId, media, captionOptions(message));
             }
 
-            return await client.sendMessage(chatId, message);
+            return await client.sendMessage(chatId, message!);
         } catch (error) {
             console.error(`Send attempt ${attempt}/${maxAttempts} failed for chat ${chatId}:`, error);
 
@@ -529,8 +530,10 @@ app.post('/logout/:userId', async (c) => {
 app.post('/send/:userId', async (c) => {
     const userId = c.req.param('userId');
     const { to, message, mediaUrl } = await c.req.json();
-    if (!to || !message) {
-        return c.json({ success: false, error: 'Both `to` and `message` are required' }, 422);
+    // `to` + something deliverable (message and/or mediaUrl) — see send.ts.
+    const validationError = sendValidationError({ to, message, mediaUrl });
+    if (validationError) {
+        return c.json({ success: false, error: validationError }, 422);
     }
     // Never spawn a client just to fail the auth check below: a send for a
     // never-paired user (e.g. a job defaulting to user "default") would

data/lib/whatsapp_notifier/services/web_automation/send.test.ts

@@ -1,5 +1,5 @@
 import { test, expect } from 'bun:test';
-import { sentMessageId } from './send';
+import { sentMessageId, sendValidationError, fetchMedia, captionOptions } from './send';
 
 // The id the host stores against its outbound record — it MUST be the real
 // serialized WhatsApp id so the fromMe echo of this send dedupes on it.
@@ -18,3 +18,61 @@ test('sentMessageId falls back to null when no id is available', () => {
     expect(sentMessageId({ id: {} })).toBeNull();         // id without a serialization
     expect(sentMessageId({ id: { _serialized: '' } })).toBeNull(); // empty id is no id
 });
+
+// ── /send body validation ──
+//
+// Hosts attach files one-by-one with the caption only on the FIRST file, so
+// a file-only body (message "" + mediaUrl) is the NORMAL shape for files
+// 2..n of a batch — it must pass, not 422.
+test('file-only send (to + mediaUrl, no message) passes validation', () => {
+    expect(sendValidationError({ to: '919999000001', message: '', mediaUrl: 'https://host/blob/1' })).toBeNull();
+    expect(sendValidationError({ to: '919999000001', mediaUrl: 'https://host/blob/1' })).toBeNull();
+});
+
+test('message-only send still passes validation', () => {
+    expect(sendValidationError({ to: '919999000001', message: 'hello' })).toBeNull();
+});
+
+test('message + media together pass validation', () => {
+    expect(sendValidationError({ to: '919999000001', message: 'caption', mediaUrl: 'https://host/blob/1' })).toBeNull();
+});
+
+test('a body with nothing to deliver is rejected with 422 copy', () => {
+    const error = '`to` and one of `message`/`mediaUrl` are required';
+    expect(sendValidationError({ to: '919999000001' })).toBe(error);
+    expect(sendValidationError({ to: '919999000001', message: '', mediaUrl: '' })).toBe(error);
+});
+
+test('`to` is always required, media or not', () => {
+    const error = '`to` and one of `message`/`mediaUrl` are required';
+    expect(sendValidationError({ message: 'hello' })).toBe(error);
+    expect(sendValidationError({ to: '', message: 'hello', mediaUrl: 'https://host/blob/1' })).toBe(error);
+});
+
+// ── media fetch options ──
+//
+// ActiveStorage blob/proxy URLs carry no file extension, so wwebjs's
+// URL-based MIME sniff throws ("Unable to determine MIME type using URL").
+// The send path MUST pass unsafeMime so the response Content-Type is used.
+test('fetchMedia downloads with unsafeMime so extension-less URLs work', async () => {
+    const calls: Array<[string, object | undefined]> = [];
+    const fakeMessageMedia = {
+        fromUrl: async (url: string, options?: object) => { calls.push([url, options]); return 'the-media'; }
+    };
+
+    const media = await fetchMedia(fakeMessageMedia, 'https://host/rails/active_storage/blobs/proxy/abc123');
+
+    expect(media).toBe('the-media');
+    expect(calls).toEqual([['https://host/rails/active_storage/blobs/proxy/abc123', { unsafeMime: true }]]);
+});
+
+// ── caption shape ──
+test('captionOptions carries the caption when there is one', () => {
+    expect(captionOptions('itinerary attached')).toEqual({ caption: 'itinerary attached' });
+});
+
+test('captionOptions omits the caption entirely for caption-less files', () => {
+    expect(captionOptions('')).toEqual({});
+    expect(captionOptions(undefined)).toEqual({});
+    expect(captionOptions(null)).toEqual({});
+});

data/lib/whatsapp_notifier/services/web_automation/send.ts

@@ -15,3 +15,44 @@
 export function sentMessageId(sent: any): string | null {
     return (sent && sent.id && sent.id._serialized) || null;
 }
+
+// Validation for the POST /send body. `to` is always required; the payload
+// must additionally carry SOMETHING deliverable — a text message, a media
+// URL, or both.
+//
+// The old `!to || !message` check 422'd every caption-less file: hosts that
+// attach files one-by-one put the caption only on the FIRST file, so files
+// 2..n of a batch (and any file sent without a caption) arrive as
+// message "" + mediaUrl and were rejected.
+//
+// Returns the 422 error string, or null when the body is valid.
+export function sendValidationError(body: { to?: unknown; message?: unknown; mediaUrl?: unknown }): string | null {
+    if (!body.to || (!body.message && !body.mediaUrl)) {
+        return '`to` and one of `message`/`mediaUrl` are required';
+    }
+    return null;
+}
+
+// The whatsapp-web.js surface fetchMedia needs — injected so the fetch
+// options are unit-testable without booting the real library. Promise<any>
+// on purpose: the real MessageMedia comes from require() untyped, and the
+// result feeds client.sendMessage's MessageContent parameter.
+type MediaFactory = { fromUrl: (url: string, options?: object) => Promise<any> };
+
+// Downloads the outgoing attachment for a media send.
+//
+// unsafeMime: hosts hand us extension-less URLs (Rails ActiveStorage
+// blob/proxy paths), and whatsapp-web.js refuses to guess a MIME type from
+// a URL without an extension ("Unable to determine MIME type using URL").
+// unsafeMime downloads anyway and trusts the response Content-Type header,
+// which those hosts set correctly.
+export async function fetchMedia(messageMedia: MediaFactory, mediaUrl: string) {
+    return messageMedia.fromUrl(mediaUrl, { unsafeMime: true });
+}
+
+// sendMessage options for a media send: caption only when there IS one. A
+// caption-less file arrives with message "" — omitting the key entirely
+// matches a hand-sent file instead of attaching an empty caption.
+export function captionOptions(message?: string | null): { caption?: string } {
+    return message ? { caption: message } : {};
+}

data/lib/whatsapp_notifier/version.rb

@@ -1,4 +1,4 @@
 module WhatsAppNotifier
-  VERSION = "0.8.0"
+  VERSION = "0.8.1"
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whatsapp_notifier
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Kshitiz Sinha