whatsapp_notifier 0.7.0 → 0.8.0

data/spec/web_adapter_spec.rb

@@ -24,6 +24,52 @@ RSpec.describe WhatsAppNotifier::WebAdapter do
     expect(result).to include(success: true, message_id: "k1")
   end
 
+  # The 0.8.0 service returns the real WhatsApp message id — the key the host
+  # dedupes the send's own fromMe echo on. It must beat the fabricated id.
+  it "prefers the service-issued message id over the idempotency key" do
+    response = http_success(body: { "success" => true, "messageId" => "true_919@c.us_ABC" })
+    allow(Net::HTTP).to receive(:start).and_return(response)
+
+    result = adapter.send_message(
+      payload: { to: "+1", body: "hi", metadata: { user_id: 1 }, idempotency_key: "k1" },
+      session: {}
+    )
+
+    expect(result).to include(success: true, message_id: "true_919@c.us_ABC")
+  end
+
+  it "accepts the snake_case message_id alias in the send response" do
+    response = http_success(body: { "success" => true, "message_id" => "true_919@c.us_DEF" })
+    allow(Net::HTTP).to receive(:start).and_return(response)
+
+    result = adapter.send_message(payload: { to: "+1", body: "hi", metadata: {} }, session: {})
+
+    expect(result).to include(message_id: "true_919@c.us_DEF")
+  end
+
+  # A 0.8.0 service that could not read the sent message's id answers
+  # messageId: null — fall through to the 0.7.0 fabrication chain.
+  it "falls back to the idempotency key when the service returns a null id" do
+    response = http_success(body: { "success" => true, "messageId" => nil })
+    allow(Net::HTTP).to receive(:start).and_return(response)
+
+    result = adapter.send_message(
+      payload: { to: "+1", body: "hi", metadata: {}, idempotency_key: "k1" },
+      session: {}
+    )
+
+    expect(result).to include(message_id: "k1")
+  end
+
+  it "fabricates a local id when neither the service nor the payload offers one" do
+    response = http_success(body: { "success" => true })
+    allow(Net::HTTP).to receive(:start).and_return(response)
+
+    result = adapter.send_message(payload: { to: "+1", body: "hi", metadata: {} }, session: {})
+
+    expect(result[:message_id]).to match(/\Alocal-\d+\z/)
+  end
+
   it "yields the http connection to run the request" do
     response = http_success(body: { "success" => true })
     http = instance_double(Net::HTTP, request: response)
@@ -131,7 +177,9 @@ RSpec.describe WhatsAppNotifier::WebAdapter do
 
   # A 0.6.0 service sends no media keys at all — the mapped hash must omit
   # them (not nil them), because hosts key-gate ingest on has_media presence.
-  it "omits the media keys entirely for 0.6.0-shaped payloads" do
+  # Same contract for the 0.8.0 two-way keys: a customer message carries no
+  # from_me/to, so they must be absent (hosts key-gate fromMe ingest too).
+  it "omits the media and two-way keys entirely for plain inbound payloads" do
     body = [{ "from" => "919@c.us", "body" => "hi", "messageId" => "m1", "timestamp" => 123, "type" => "chat" }]
     allow(Net::HTTP).to receive(:start).and_return(http_success(body: body))
 
@@ -140,6 +188,35 @@ RSpec.describe WhatsAppNotifier::WebAdapter do
     expect(message.keys).to match_array(%i[from body message_id timestamp type])
   end
 
+  # 0.8.0 two-way capture: operator-sent messages arrive with fromMe + to —
+  # `to` is the counterparty chat id the host threads the conversation on.
+  it "maps the 0.8.0 two-way keys when the wire payload carries them" do
+    body = { "messages" => [{
+      "from" => "919000000001@c.us", "to" => "919@c.us", "fromMe" => true,
+      "body" => "on my way", "messageId" => "true_919@c.us_OP1", "timestamp" => 5, "type" => "chat"
+    }] }
+    allow(Net::HTTP).to receive(:start).and_return(http_success(body: body))
+
+    message = adapter.fetch_inbound(metadata: { user_id: "u-1" }).first
+
+    expect(message).to include(
+      from: "919000000001@c.us", to: "919@c.us", from_me: true,
+      body: "on my way", message_id: "true_919@c.us_OP1"
+    )
+  end
+
+  it "accepts the snake_case from_me wire alias" do
+    body = { "messages" => [{
+      "from" => "919000000001@c.us", "to" => "919@c.us", "from_me" => true,
+      "body" => "done", "message_id" => "m9", "timestamp" => 9, "type" => "chat"
+    }] }
+    allow(Net::HTTP).to receive(:start).and_return(http_success(body: body))
+
+    message = adapter.fetch_inbound(metadata: {}).first
+
+    expect(message).to include(from_me: true, to: "919@c.us")
+  end
+
   def binary_response(code:, body: "", headers: {})
     response = double("binary response", code: code, body: body)
     allow(response).to receive(:is_a?) { |klass| code == "200" && klass == Net::HTTPSuccess }
@@ -242,6 +319,160 @@ RSpec.describe WhatsAppNotifier::WebAdapter do
       .to raise_error(/service request failed \(500\)/)
   end
 
+  it "refetches media via POST, mapping the success verdict and attaching the token" do
+    allow(ENV).to receive(:[]).and_call_original
+    allow(ENV).to receive(:[]).with("WHATSAPP_WEBHOOK_TOKEN").and_return("sekrit")
+    response = http_success(body: {
+      "success" => true, "messageId" => "true_919@c.us_ABC", "mediaStatus" => "available",
+      "mediaMime" => "image/jpeg", "mediaFilename" => "beach.jpg", "mediaSize" => 10
+    })
+    captured = nil
+    http = double("http")
+    allow(http).to receive(:request) { |req| captured = req; response }
+    allow(Net::HTTP).to receive(:start) { |*_args, **_kwargs, &blk| blk.call(http) }
+
+    result = adapter.refetch_media(message_id: "true_919@c.us_ABC", chat_id: "919@c.us", metadata: { user_id: "u-1" })
+
+    expect(result).to eq(mime: "image/jpeg", filename: "beach.jpg", size: 10, status: "available")
+    expect(captured).to be_a(Net::HTTP::Post)
+    expect(captured.path).to eq("/media/u-1/refetch")
+    expect(captured["X-WA-Token"]).to eq("sekrit")
+    expect(JSON.parse(captured.body)).to eq("messageId" => "true_919@c.us_ABC", "chatId" => "919@c.us")
+  end
+
+  it "accepts the snake_case media keys in the refetch response" do
+    body = { "success" => true, "media_status" => "available", "media_mime" => "audio/ogg",
+             "media_filename" => "vn.ogg", "media_size" => 3 }
+    allow(Net::HTTP).to receive(:start).and_return(http_success(body: body))
+
+    expect(adapter.refetch_media(message_id: "m1", chat_id: "919@c.us", metadata: {}))
+      .to eq(mime: "audio/ogg", filename: "vn.ogg", size: 3, status: "available")
+  end
+
+  # Media gone upstream → the service answers 404 success:false; refetch
+  # degrades to nil like fetch_media, so the host can grey the bubble out.
+  it "returns nil when the refetch reports the media is gone (404)" do
+    allow(Net::HTTP).to receive(:start)
+      .and_return(http_failure(code: "404", body: JSON.generate({ success: false, mediaStatus: "unavailable", mediaError: "gone" })))
+
+    expect(adapter.refetch_media(message_id: "m1", chat_id: "919@c.us", metadata: {})).to be_nil
+  end
+
+  # A success:false body that somehow arrives with a 2xx still degrades to nil.
+  it "returns nil when the refetch response is unsuccessful" do
+    allow(Net::HTTP).to receive(:start).and_return(http_success(body: { "success" => false, "mediaError" => "gone" }))
+
+    expect(adapter.refetch_media(message_id: "m1", chat_id: "919@c.us", metadata: {})).to be_nil
+  end
+
+  it "still raises when the refetch fails with a non-404 code" do
+    allow(Net::HTTP).to receive(:start)
+      .and_return(http_failure(code: "401", body: JSON.generate({ error: "User not authenticated" })))
+
+    expect { adapter.refetch_media(message_id: "m1", chat_id: "919@c.us", metadata: {}) }
+      .to raise_error(/service request failed \(401\)/)
+  end
+
+  it "lists chats with the token attached and maps the discovery keys" do
+    allow(ENV).to receive(:[]).and_call_original
+    allow(ENV).to receive(:[]).with("WHATSAPP_WEBHOOK_TOKEN").and_return("sekrit")
+    response = http_success(body: { "success" => true, "chats" => [
+      { "id" => "919@c.us", "name" => "Asha", "lastMessageAt" => 1_717_000_000 },
+      { "id" => "918@c.us", "name" => nil, "lastMessageAt" => nil }
+    ] })
+    captured = nil
+    http = double("http")
+    allow(http).to receive(:request) { |req| captured = req; response }
+    allow(Net::HTTP).to receive(:start) { |*_args, **_kwargs, &blk| blk.call(http) }
+
+    chats = adapter.list_chats(metadata: { user_id: "u-1" })
+
+    expect(chats).to eq([
+      { id: "919@c.us", name: "Asha", last_message_at: 1_717_000_000 },
+      { id: "918@c.us", name: nil, last_message_at: nil }
+    ])
+    expect(captured).to be_a(Net::HTTP::Get)
+    expect(captured.path).to eq("/chats/u-1")
+    expect(captured["X-WA-Token"]).to eq("sekrit")
+  end
+
+  it "accepts the snake_case last_message_at wire alias" do
+    body = { "chats" => [{ "id" => "919@c.us", "name" => "Asha", "last_message_at" => 9 }] }
+    allow(Net::HTTP).to receive(:start).and_return(http_success(body: body))
+
+    expect(adapter.list_chats(metadata: {}).first).to include(last_message_at: 9)
+  end
+
+  it "returns an empty chat list when the service omits the key" do
+    allow(Net::HTTP).to receive(:start).and_return(http_success(body: { "success" => true }))
+
+    expect(adapter.list_chats(metadata: {})).to eq([])
+  end
+
+  # An unpaired or not-ready user answers 401 — the standard non-2xx raise
+  # passes straight through to the caller.
+  it "raises the standard error when the chat list is unauthorized" do
+    allow(Net::HTTP).to receive(:start)
+      .and_return(http_failure(code: "401", body: JSON.generate({ error: "User not authenticated" })))
+
+    expect { adapter.list_chats(metadata: {}) }
+      .to raise_error(/service request failed \(401\): User not authenticated/)
+  end
+
+  it "fetches history with the token, posting the chat id and clamped limit" do
+    allow(ENV).to receive(:[]).and_call_original
+    allow(ENV).to receive(:[]).with("WHATSAPP_WEBHOOK_TOKEN").and_return("sekrit")
+    response = http_success(body: { "success" => true, "messages" => [
+      { "from" => "919@c.us", "body" => "old reply", "messageId" => "h1", "timestamp" => 1, "type" => "chat" },
+      { "from" => "919000000001@c.us", "to" => "919@c.us", "fromMe" => true,
+        "body" => "old send", "messageId" => "h2", "timestamp" => 2, "type" => "chat" },
+      { "from" => "919@c.us", "body" => "", "messageId" => "h3", "timestamp" => 3, "type" => "image",
+        "hasMedia" => true, "mediaStatus" => "unavailable", "mediaError" => "history" }
+    ] })
+    captured = nil
+    http = double("http")
+    allow(http).to receive(:request) { |req| captured = req; response }
+    allow(Net::HTTP).to receive(:start) { |*_args, **_kwargs, &blk| blk.call(http) }
+
+    messages = adapter.fetch_history(chat_id: "919@c.us", limit: 100_000, metadata: { user_id: "u-1" })
+
+    expect(captured).to be_a(Net::HTTP::Post)
+    expect(captured.path).to eq("/history/u-1")
+    expect(captured["X-WA-Token"]).to eq("sekrit")
+    expect(JSON.parse(captured.body)).to eq("chatId" => "919@c.us", "limit" => 200)
+
+    # Same mapper as fetch_inbound: two-way keys on the operator's messages,
+    # the by-design unavailable media verdict on history media.
+    expect(messages[0]).to eq(from: "919@c.us", body: "old reply", message_id: "h1", timestamp: 1, type: "chat")
+    expect(messages[1]).to include(from_me: true, to: "919@c.us", message_id: "h2")
+    expect(messages[2]).to include(has_media: true, media_status: "unavailable", media_error: "history")
+  end
+
+  it "clamps the history limit into 1..200 and defaults garbage to 50" do
+    bodies = []
+    http = double("http")
+    allow(http).to receive(:request) { |req| bodies << JSON.parse(req.body); http_success(body: { "messages" => [] }) }
+    allow(Net::HTTP).to receive(:start) { |*_args, **_kwargs, &blk| blk.call(http) }
+
+    adapter.fetch_history(chat_id: "919@c.us", metadata: {})              # default
+    adapter.fetch_history(chat_id: "919@c.us", limit: 0, metadata: {})    # below floor
+    adapter.fetch_history(chat_id: "919@c.us", limit: 201, metadata: {})  # above cap
+    adapter.fetch_history(chat_id: "919@c.us", limit: "120", metadata: {}) # numeric string
+    adapter.fetch_history(chat_id: "919@c.us", limit: 75.9, metadata: {}) # float floors
+    adapter.fetch_history(chat_id: "919@c.us", limit: "lots", metadata: {}) # garbage
+    adapter.fetch_history(chat_id: "919@c.us", limit: nil, metadata: {})  # nil
+
+    expect(bodies.map { |b| b["limit"] }).to eq([50, 1, 200, 120, 75, 50, 50])
+  end
+
+  it "raises the standard error when the history fetch fails" do
+    allow(Net::HTTP).to receive(:start)
+      .and_return(http_failure(code: "422", body: JSON.generate({ error: "`chatId` is required" })))
+
+    expect { adapter.fetch_history(chat_id: "12@g.us", metadata: {}) }
+      .to raise_error(/service request failed \(422\)/)
+  end
+
   it "logs out via the service" do
     allow(Net::HTTP).to receive(:start).and_return(http_success(body: { "success" => true }))
 

data/spec/whatsapp_notifier_spec.rb

@@ -96,6 +96,9 @@ RSpec.describe WhatsAppNotifier do
     allow(fake_client).to receive(:fetch_inbound).and_return([{ from: "q@c.us" }])
     allow(fake_client).to receive(:fetch_media).and_return(body: "bytes", mime: "image/jpeg", filename: nil, size: 5)
     allow(fake_client).to receive(:delete_media).and_return(success: true)
+    allow(fake_client).to receive(:refetch_media).and_return(mime: "image/jpeg", filename: nil, size: 5, status: "available")
+    allow(fake_client).to receive(:list_chats).and_return([{ id: "919@c.us", name: "Asha", last_message_at: 9 }])
+    allow(fake_client).to receive(:fetch_history).and_return([{ from: "919@c.us", body: "old", message_id: "h1" }])
     allow(fake_client).to receive(:logout).and_return(success: true)
     described_class.instance_variable_set(:@client, fake_client)
 
@@ -105,9 +108,33 @@ RSpec.describe WhatsAppNotifier do
     expect(described_class.fetch_inbound(provider: :web_automation, metadata: { user_id: 1 })).to eq([{ from: "q@c.us" }])
     expect(described_class.fetch_media(message_id: "m1", provider: :web_automation, metadata: { user_id: 1 })).to include(mime: "image/jpeg")
     expect(described_class.delete_media(message_id: "m1", provider: :web_automation, metadata: { user_id: 1 })).to eq(success: true)
+    expect(described_class.refetch_media(message_id: "m1", chat_id: "919@c.us", provider: :web_automation, metadata: { user_id: 1 })).to include(status: "available")
+    expect(described_class.list_chats(provider: :web_automation, metadata: { user_id: 1 })).to eq([{ id: "919@c.us", name: "Asha", last_message_at: 9 }])
+    expect(described_class.fetch_history(chat_id: "919@c.us", limit: 20, provider: :web_automation, metadata: { user_id: 1 })).to eq([{ from: "919@c.us", body: "old", message_id: "h1" }])
     expect(described_class.logout(provider: :web_automation, metadata: { user_id: 1 })).to eq(success: true)
     expect(fake_client).to have_received(:fetch_media).with(message_id: "m1", provider: :web_automation, metadata: { user_id: 1 })
     expect(fake_client).to have_received(:delete_media).with(message_id: "m1", provider: :web_automation, metadata: { user_id: 1 })
+    expect(fake_client).to have_received(:refetch_media).with(message_id: "m1", chat_id: "919@c.us", provider: :web_automation, metadata: { user_id: 1 })
+    expect(fake_client).to have_received(:list_chats).with(provider: :web_automation, metadata: { user_id: 1 })
+    expect(fake_client).to have_received(:fetch_history).with(chat_id: "919@c.us", limit: 20, provider: :web_automation, metadata: { user_id: 1 })
+  end
+
+  it "fetches history through the module API end to end with the default limit" do
+    adapter = double(
+      send_message: { success: true, session: {} },
+      fetch_qr_code: "qr",
+      connection_status: { state: "AUTHENTICATED", authenticated: true }
+    )
+    allow(adapter).to receive(:fetch_history).and_return([{ from: "z@c.us", body: "old", message_id: "h1" }])
+    described_class.configure do |config|
+      config.provider = :web_automation
+      config.web_automation_enabled = true
+      config.web_adapter = adapter
+    end
+
+    expect(described_class.fetch_history(chat_id: "919@c.us", metadata: { user_id: 1 }))
+      .to eq([{ from: "z@c.us", body: "old", message_id: "h1" }])
+    expect(adapter).to have_received(:fetch_history).with(chat_id: "919@c.us", limit: 50, metadata: { user_id: 1 })
   end
 
   it "fetches inbound through the module API end to end" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whatsapp_notifier
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Kshitiz Sinha
@@ -80,6 +80,8 @@ files:
 - lib/whatsapp_notifier/railtie.rb
 - lib/whatsapp_notifier/result.rb
 - lib/whatsapp_notifier/services/web_automation/bun.lock
+- lib/whatsapp_notifier/services/web_automation/history.test.ts
+- lib/whatsapp_notifier/services/web_automation/history.ts
 - lib/whatsapp_notifier/services/web_automation/inbound.test.ts
 - lib/whatsapp_notifier/services/web_automation/inbound.ts
 - lib/whatsapp_notifier/services/web_automation/index.ts
@@ -90,6 +92,8 @@ files:
 - lib/whatsapp_notifier/services/web_automation/metrics.test.ts
 - lib/whatsapp_notifier/services/web_automation/metrics.ts
 - lib/whatsapp_notifier/services/web_automation/package.json
+- lib/whatsapp_notifier/services/web_automation/send.test.ts
+- lib/whatsapp_notifier/services/web_automation/send.ts
 - lib/whatsapp_notifier/services/web_automation/sessions.test.ts
 - lib/whatsapp_notifier/services/web_automation/sessions.ts
 - lib/whatsapp_notifier/session/qr_service.rb