whatsapp_notifier 0.6.0 → 0.7.0

data/spec/generators/install_service_generator_spec.rb

@@ -58,7 +58,7 @@ RSpec.describe "WhatsAppNotifier::Generators::InstallServiceGenerator" do
       generator.copy_service_files
 
       sources = generator.copied.map(&:first)
-      expect(sources).to match_array(%w[index.ts inbound.ts init_gate.ts metrics.ts sessions.ts package.json bun.lock])
+      expect(sources).to match_array(%w[index.ts inbound.ts init_gate.ts media.ts metrics.ts sessions.ts package.json bun.lock])
       expect(sources.grep(/test|node_modules|\.wwebjs|\.puppeteer/)).to be_empty
       expect(generator.copied.map(&:last)).to all(start_with("whatsapp_service/"))
     end
@@ -69,6 +69,17 @@ RSpec.describe "WhatsAppNotifier::Generators::InstallServiceGenerator" do
                         "SERVICE_FILES lists #{file} but it is missing from the service dir"
       end
     end
+
+    # An ejected service that is missing a module index.ts imports dies on
+    # boot — pin the file list to the imports so a new module (like media.ts
+    # in 0.7.0) can never be forgotten again.
+    it "ships every local module index.ts imports" do
+      index = File.read(File.join(generator_class.source_root, "index.ts"), encoding: "UTF-8")
+      local_imports = index.scan(%r{from '\./([A-Za-z0-9_]+)'}).flatten.map { |name| "#{name}.ts" }
+
+      expect(local_imports).not_to be_empty
+      expect(generator_class.const_get(:SERVICE_FILES)).to include(*local_imports)
+    end
   end
 
   describe "#add_to_gitignore" do

data/spec/providers/web_automation_spec.rb

@@ -137,6 +137,45 @@ RSpec.describe WhatsAppNotifier::Providers::WebAutomation do
     end
   end
 
+  it "fetches and deletes media via the adapter when enabled" do
+    Dir.mktmpdir do |dir|
+      adapter = double(
+        fetch_qr_code: "qr", connection_status: {},
+        fetch_media: { body: "bytes", mime: "image/jpeg", filename: "a.jpg", size: 5 },
+        delete_media: { success: true }
+      )
+      config = build_config(path: File.join(dir, "session.json"), adapter: adapter)
+      provider = described_class.new(configuration: config)
+
+      expect(provider.fetch_media(message_id: "m1", metadata: { user_id: 1 })).to include(mime: "image/jpeg")
+      expect(provider.delete_media(message_id: "m1", metadata: { user_id: 1 })).to eq(success: true)
+      expect(adapter).to have_received(:fetch_media).with(message_id: "m1", metadata: { user_id: 1 })
+      expect(adapter).to have_received(:delete_media).with(message_id: "m1", metadata: { user_id: 1 })
+    end
+  end
+
+  it "raises on the media helpers when the provider is disabled" do
+    Dir.mktmpdir do |dir|
+      adapter = double(fetch_qr_code: "qr", connection_status: {}, fetch_media: nil, delete_media: { success: true })
+      config = build_config(path: File.join(dir, "session.json"), adapter: adapter, enabled: false)
+      provider = described_class.new(configuration: config)
+
+      expect { provider.fetch_media(message_id: "m1") }.to raise_error(WhatsAppNotifier::ConfigurationError, /disabled/)
+      expect { provider.delete_media(message_id: "m1") }.to raise_error(WhatsAppNotifier::ConfigurationError, /disabled/)
+    end
+  end
+
+  it "raises on the media helpers when the adapter lacks media support" do
+    Dir.mktmpdir do |dir|
+      adapter = double(fetch_qr_code: "qr", connection_status: {})
+      config = build_config(path: File.join(dir, "session.json"), adapter: adapter)
+      provider = described_class.new(configuration: config)
+
+      expect { provider.fetch_media(message_id: "m1") }.to raise_error(WhatsAppNotifier::ConfigurationError, /media fetch/)
+      expect { provider.delete_media(message_id: "m1") }.to raise_error(WhatsAppNotifier::ConfigurationError, /media deletion/)
+    end
+  end
+
   it "logs out via adapter when enabled" do
     Dir.mktmpdir do |dir|
       adapter = double(fetch_qr_code: "qr", connection_status: {}, logout: { success: true })

data/spec/web_adapter_spec.rb

@@ -100,6 +100,148 @@ RSpec.describe WhatsAppNotifier::WebAdapter do
     expect { adapter.fetch_inbound(metadata: {}) }.to raise_error(/service request failed/)
   end
 
+  it "maps the 0.7.0 media and sender keys when the wire payload carries them" do
+    body = { "messages" => [{
+      "from" => "919@c.us", "body" => "", "messageId" => "m1", "timestamp" => 123, "type" => "image",
+      "hasMedia" => true, "mediaStatus" => "available", "mediaMime" => "image/jpeg",
+      "mediaFilename" => "beach.jpg", "mediaSize" => 1024, "senderName" => "Asha"
+    }] }
+    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(
+      has_media: true, media_status: "available", media_mime: "image/jpeg",
+      media_filename: "beach.jpg", media_size: 1024, sender_name: "Asha"
+    )
+  end
+
+  it "accepts snake_case wire aliases and maps an unavailable verdict's error" do
+    body = { "messages" => [{
+      "from" => "919@c.us", "body" => "", "message_id" => "m1", "timestamp" => 1, "type" => "video",
+      "has_media" => true, "media_status" => "unavailable", "media_error" => "unsupported_type"
+    }] }
+    allow(Net::HTTP).to receive(:start).and_return(http_success(body: body))
+
+    message = adapter.fetch_inbound(metadata: {}).first
+
+    expect(message).to include(has_media: true, media_status: "unavailable", media_error: "unsupported_type")
+    expect(message).not_to have_key(:media_mime)
+  end
+
+  # 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
+    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))
+
+    message = adapter.fetch_inbound(metadata: {}).first
+
+    expect(message.keys).to match_array(%i[from body message_id timestamp type])
+  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 }
+    allow(response).to receive(:[]) { |name| headers[name] }
+    response
+  end
+
+  def run_binary_request(response)
+    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) }
+    -> { captured }
+  end
+
+  it "fetches media bytes with mime, filename and size on a dedicated binary path" do
+    allow(ENV).to receive(:[]).and_call_original
+    allow(ENV).to receive(:[]).with("WHATSAPP_WEBHOOK_TOKEN").and_return(nil)
+    response = binary_response(
+      code: "200", body: "\xFF\xD8raw-jpeg".b,
+      headers: { "Content-Type" => "image/jpeg", "Content-Disposition" => 'attachment; filename="beach.jpg"' }
+    )
+    captured = run_binary_request(response)
+
+    media = adapter.fetch_media(message_id: "true_919@c.us_ABC", metadata: { user_id: "u-1" })
+
+    expect(media).to eq(body: "\xFF\xD8raw-jpeg".b, mime: "image/jpeg", filename: "beach.jpg", size: 10)
+    expect(captured.call.path).to eq("/media/u-1/true_919@c.us_ABC")
+    expect(captured.call["X-WA-Token"]).to be_nil # env unset -> no token header
+  end
+
+  it "returns nil when the service has no copy of the media (404)" do
+    allow(Net::HTTP).to receive(:start).and_return(binary_response(code: "404", body: '{"error":"not_found"}'))
+
+    expect(adapter.fetch_media(message_id: "m1", metadata: {})).to be_nil
+  end
+
+  it "raises on non-404 media fetch failures" do
+    allow(Net::HTTP).to receive(:start).and_return(binary_response(code: "500", body: "boom"))
+
+    expect { adapter.fetch_media(message_id: "m1", metadata: {}) }.to raise_error(/service request failed \(500\)/)
+  end
+
+  it "sends X-WA-Token on the media fetch when WHATSAPP_WEBHOOK_TOKEN is set" do
+    allow(ENV).to receive(:[]).and_call_original
+    allow(ENV).to receive(:[]).with("WHATSAPP_WEBHOOK_TOKEN").and_return("sekrit")
+    response = binary_response(code: "200", body: "x", headers: { "Content-Type" => "audio/ogg" })
+    captured = run_binary_request(response)
+
+    media = adapter.fetch_media(message_id: "m1", metadata: { user_id: "u-1" })
+
+    expect(captured.call["X-WA-Token"]).to eq("sekrit")
+    expect(media).to include(mime: "audio/ogg", filename: nil, size: 1)
+  end
+
+  it "strips path and query characters from the message id before building the URL" do
+    response = binary_response(code: "404")
+    captured = run_binary_request(response)
+
+    adapter.fetch_media(message_id: "../m1?x=1#f", metadata: { user_id: "u-1" })
+
+    expect(captured.call.path).to eq("/media/u-1/..m1x1f")
+  end
+
+  it "deletes media via the JSON control plane with the token attached" 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 })
+    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) }
+
+    expect(adapter.delete_media(message_id: "m/1", metadata: { user_id: "u-1" })).to eq(success: true)
+    expect(captured).to be_a(Net::HTTP::Delete)
+    expect(captured.path).to eq("/media/u-1/m1")
+    expect(captured["X-WA-Token"]).to eq("sekrit")
+  end
+
+  it "defaults delete_media success to false when the service omits it" do
+    allow(Net::HTTP).to receive(:start).and_return(http_success(body: {}))
+
+    expect(adapter.delete_media(message_id: "m1", metadata: {})).to eq(success: false)
+  end
+
+  # A 0.6.0 service mid-rollout has no /media routes — delete must degrade
+  # like fetch_media's nil-on-404, not raise.
+  it "returns success false when delete_media hits a 404" do
+    allow(Net::HTTP).to receive(:start)
+      .and_return(http_failure(code: "404", body: JSON.generate({ error: "not_found" })))
+
+    expect(adapter.delete_media(message_id: "m1", metadata: {})).to eq(success: false)
+  end
+
+  it "still raises when delete_media fails with a non-404 code" do
+    allow(Net::HTTP).to receive(:start)
+      .and_return(http_failure(code: "500", body: JSON.generate({ error: "boom" })))
+
+    expect { adapter.delete_media(message_id: "m1", metadata: {}) }
+      .to raise_error(/service request failed \(500\)/)
+  end
+
   it "logs out via the service" do
     allow(Net::HTTP).to receive(:start).and_return(http_success(body: { "success" => true }))
 
@@ -123,6 +265,40 @@ RSpec.describe WhatsAppNotifier::WebAdapter do
     expect(Net::HTTP::Get).to have_received(:new).with("/qr/default")
   end
 
+  # Net::HTTP does not infer TLS from the URL scheme — an https service URL
+  # without use_ssl would send the token and payloads in plaintext.
+  it "enables TLS for https service URLs on the JSON request path" do
+    secure = described_class.new(base_url: "https://wa.example.com")
+    allow(Net::HTTP).to receive(:start).and_return(http_success(body: { "success" => true }))
+
+    secure.logout(metadata: { user_id: "u-1" })
+
+    expect(Net::HTTP).to have_received(:start)
+      .with("wa.example.com", 443, hash_including(use_ssl: true))
+  end
+
+  it "enables TLS for https service URLs on the binary media path" do
+    secure = described_class.new(base_url: "https://wa.example.com")
+    allow(Net::HTTP).to receive(:start).and_return(binary_response(code: "404"))
+
+    secure.fetch_media(message_id: "m1", metadata: { user_id: "u-1" })
+
+    expect(Net::HTTP).to have_received(:start)
+      .with("wa.example.com", 443, hash_including(use_ssl: true))
+  end
+
+  it "keeps TLS off for plain http service URLs on both paths" do
+    allow(Net::HTTP).to receive(:start).and_return(
+      http_success(body: { "success" => true }), binary_response(code: "404")
+    )
+
+    adapter.logout(metadata: {})
+    adapter.fetch_media(message_id: "m1", metadata: {})
+
+    expect(Net::HTTP).to have_received(:start)
+      .with("127.0.0.1", 3001, hash_including(use_ssl: false)).twice
+  end
+
   it "executes the request inside the Net::HTTP block" do
     fake_http = instance_double(Net::HTTP)
     allow(fake_http).to receive(:request).and_return(http_success(body: { "qr" => "data:image/png;base64,x" }))

data/spec/whatsapp_notifier_spec.rb

@@ -94,6 +94,8 @@ RSpec.describe WhatsAppNotifier do
     allow(fake_client).to receive(:scan_qr).and_return("qr-code")
     allow(fake_client).to receive(:connection_status).and_return(state: "QR_REQUIRED")
     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(:logout).and_return(success: true)
     described_class.instance_variable_set(:@client, fake_client)
 
@@ -101,7 +103,11 @@ RSpec.describe WhatsAppNotifier do
     expect(described_class.scan_qr(provider: :web_automation, metadata: { user_id: 1 })).to eq("qr-code")
     expect(described_class.connection_status(provider: :web_automation, metadata: { user_id: 1 })).to include(state: "QR_REQUIRED")
     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.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 })
   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.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Kshitiz Sinha
@@ -85,6 +85,8 @@ files:
 - lib/whatsapp_notifier/services/web_automation/index.ts
 - lib/whatsapp_notifier/services/web_automation/init_gate.test.ts
 - lib/whatsapp_notifier/services/web_automation/init_gate.ts
+- lib/whatsapp_notifier/services/web_automation/media.test.ts
+- lib/whatsapp_notifier/services/web_automation/media.ts
 - 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