nextmail 0.0.1 → 0.1.0

data/lib/nextmail/live_event_stream.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Nextmail
+  class LiveEventStream
+    STREAM_EVENTS = Protocol::LIVE_STREAM_EVENTS
+    MS_PER_SECOND = 1000.0
+
+    def initialize(transport, query:, last_event_id:, api_key:, timing:)
+      @transport = transport
+      @query = query
+      @api_key = api_key
+      @timing = timing
+      @resume_id = last_event_id.to_s
+      @reconnect_gap = seconds([timing[:DEFAULT_RETRY_MS], timing[:MAX_BACKOFF_MS]].min)
+      @failures = 0
+      @delivering = false
+    end
+
+    def run(yielder)
+      delay = 0
+
+      loop do
+        sleep(delay) if delay.positive?
+        delay = attempt(yielder)
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name}>"
+    end
+
+    private
+
+    def attempt(yielder)
+      started = clock
+      return failure_delay if connect(yielder)
+
+      [0, started + @reconnect_gap - clock].max
+    rescue NetworkError, ApiError => error
+      raise if @delivering || !retryable?(error)
+
+      failure_delay(error.is_a?(ApiError) ? error.retry_after_seconds : nil)
+    end
+
+    def connect(yielder)
+      @transport.stream(ApiPaths::LIVE_EVENTS, query: @query, headers: resume_headers,
+        accept: Protocol::CONTENT_TYPES[:EVENT_STREAM], api_key: @api_key,
+        idle_timeout: seconds(@timing[:IDLE_TIMEOUT_MS])) do |response|
+        raise not_an_event_stream(response) unless event_stream?(response)
+
+        @failures = 0
+        read(response, yielder)
+      end
+    end
+
+    def read(response, yielder)
+      parser = EventStreamParser.new
+      response.each_chunk do |chunk|
+        break if dispatch_until_end(parser.push(chunk), yielder)
+      end
+      false
+    rescue NetworkError
+      raise if @delivering
+
+      true
+    end
+
+    def dispatch_until_end(records, yielder)
+      records.each do |record|
+        track(record)
+        next if record.data.nil?
+        return true if record.event == STREAM_EVENTS[:END]
+
+        event = event_of(record)
+        deliver(yielder, event) unless event.nil?
+      end
+      false
+    end
+
+    def track(record)
+      @reconnect_gap = seconds([record.retry_ms, @timing[:MAX_BACKOFF_MS]].min) unless record.retry_ms.nil?
+      @resume_id = record.id unless record.id.nil?
+    end
+
+    def deliver(yielder, event)
+      @delivering = true
+      yielder << event
+      @delivering = false
+    end
+
+    def event_of(record)
+      payload = payload_of(record.data)
+      return reset_of(payload) if record.event == STREAM_EVENTS[:RESET]
+      return nil if payload.nil? || !LIVE_EVENT_TYPES.value?(record.event)
+
+      payload
+    end
+
+    def payload_of(data)
+      parsed = Decode.json(data)
+      parsed.is_a?(Hash) ? parsed : nil
+    rescue JSON::ParserError
+      nil
+    end
+
+    def reset_of(payload)
+      reason = payload && payload[:reason]
+
+      {
+        id: @resume_id,
+        type: STREAM_EVENTS[:RESET],
+        occurredAt: Wire.instant(Time.now),
+        data: {reason: reason.is_a?(String) ? reason : LIVE_RESET_REASONS[:UNKNOWN]}
+      }
+    end
+
+    def resume_headers
+      @resume_id.empty? ? nil : {Protocol::HEADER_KEYS[:LAST_EVENT_ID] => @resume_id}
+    end
+
+    def event_stream?(response)
+      media_type(response) == Protocol::CONTENT_TYPES[:EVENT_STREAM]
+    end
+
+    def media_type(response)
+      value = response.header(Protocol::HEADER_KEYS[:CONTENT_TYPE]).to_s
+      value.split(Protocol::MEDIA_TYPE_PARAMETER_SEPARATOR).first.to_s.strip.downcase
+    end
+
+    def not_an_event_stream(response)
+      media = media_type(response)
+
+      ApiError.build(
+        message: format(Defaults::MESSAGES[:NOT_AN_EVENT_STREAM], status: response.status,
+          media_type: media.empty? ? Defaults::MESSAGES[:NO_CONTENT_TYPE] : media),
+        status: response.status,
+        type: ERROR_TYPES[:API_ERROR],
+        code: Protocol::ERROR_CODES[:UNRECOGNISED_RESPONSE],
+        request_id: response.header(Protocol::HEADER_KEYS[:REQUEST_ID])
+      )
+    end
+
+    def retryable?(error)
+      error.is_a?(NetworkError) || error.retryable? || error.server_error?
+    end
+
+    def failure_delay(retry_after = nil)
+      wait = backoff(@failures)
+      @failures += 1
+      return wait if retry_after.nil?
+
+      asked = [retry_after, seconds(@timing[:MAX_RETRY_AFTER_MS])].min
+      [wait, asked].max
+    end
+
+    def backoff(attempt)
+      ceiling = [@timing[:MAX_BACKOFF_MS], @timing[:BASE_BACKOFF_MS] * (2.0**attempt)].min
+      seconds((ceiling * (0.5 + (rand * 0.5))).round)
+    end
+
+    def seconds(milliseconds)
+      milliseconds / MS_PER_SECOND
+    end
+
+    def clock
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/nextmail/protocol.rb

@@ -12,7 +12,8 @@ module Nextmail
       JSON: "application/json",
       CALENDAR: "text/calendar",
       VCARD: "text/vcard",
-      OCTET_STREAM: "application/octet-stream"
+      OCTET_STREAM: "application/octet-stream",
+      EVENT_STREAM: "text/event-stream"
     }.freeze
 
     CURSOR_STYLES = {
@@ -41,6 +42,18 @@ module Nextmail
       429 => "rate_limit_error"
     }.freeze
 
+    EVENT_STREAM_FIELDS = {EVENT: "event", DATA: "data", ID: "id", RETRY: "retry"}.freeze
+
+    EVENT_STREAM_SYNTAX = {
+      DEFAULT_EVENT: "message",
+      COLON: ":",
+      SPACE: " ",
+      NULL: "\u0000",
+      LINE_FEED: "\n",
+      CARRIAGE_RETURN: "\r",
+      MAX_BLOCK_CHARS: 1048576
+    }.freeze
+
     HEADER_KEYS = {
       AUTHORIZATION: "Authorization",
       ACCEPT: "Accept",
@@ -48,7 +61,8 @@ module Nextmail
       USER_AGENT: "User-Agent",
       IDEMPOTENCY_KEY: "Idempotency-Key",
       RETRY_AFTER: "retry-after",
-      REQUEST_ID: "x-request-id"
+      REQUEST_ID: "x-request-id",
+      LAST_EVENT_ID: "Last-Event-ID"
     }.freeze
 
     HTTP_METHODS = {GET: "GET", POST: "POST", PUT: "PUT", PATCH: "PATCH", DELETE: "DELETE"}.freeze
@@ -84,6 +98,16 @@ module Nextmail
 
     LIST_SEPARATOR = ","
 
+    LIVE_STREAM_EVENTS = {READY: "ready", RESET: "reset", END: "end"}.freeze
+
+    LIVE_STREAM_TIMING = {
+      BASE_BACKOFF_MS: 1000,
+      MAX_BACKOFF_MS: 30000,
+      DEFAULT_RETRY_MS: 3000,
+      MAX_RETRY_AFTER_MS: 300000,
+      IDLE_TIMEOUT_MS: 60000
+    }.freeze
+
     LOCAL_HOSTS = ["localhost", "::1", "[::1]", "127.0.0.1", "0.0.0.0", "::", "[::]"].freeze
 
     LOOPBACK_HOSTNAMES = ["localhost", "::1", "[::1]"].freeze
@@ -92,6 +116,8 @@ module Nextmail
 
     LOOPBACK_IPV6_ADDRESS = "[::1]"
 
+    MEDIA_TYPE_PARAMETER_SEPARATOR = ";"
+
     QUERY_KEYS = {
       LIMIT: "limit",
       CURSOR: "cursor",
@@ -170,6 +196,7 @@ module Nextmail
       CONNECTED_APPS: "connectedApps",
       TASK_ID: "taskId",
       RUN_ID: "runId",
+      CHAT_ID: "chatId",
       VIEW: "view",
       PAGE_ID: "pageId",
       DURATION_MINUTES: "durationMinutes",
@@ -194,7 +221,19 @@ module Nextmail
       COUNT: "count",
       HIDE_LABELLED: "hideLabelled",
       INACTIVE_DAYS: "inactiveDays",
-      MESSAGE_ID: "messageId"
+      MESSAGE_ID: "messageId",
+      DOMAIN_ID: "domainId",
+      TYPES: "types",
+      SUBJECT: "subject",
+      TIMEOUT: "timeout",
+      CALENDAR_IDS: "calendarIds",
+      CALENDAR_ID: "calendarId",
+      ADDRESS_BOOK: "addressBook",
+      MEMBER: "member",
+      STATE: "state",
+      DUE_BEFORE: "dueBefore",
+      DUE_AFTER: "dueAfter",
+      NOTIFY_GUESTS: "notifyGuests"
     }.freeze
 
     RETRY = {
@@ -208,6 +247,8 @@ module Nextmail
 
     SEALED_ENCRYPTION_FORMATS = ["pgp-mime", "pgp-inline", "smime-encrypted"].freeze
 
+    THREAD_WAIT = {DEFAULT_TIMEOUT_SECONDS: 30, DEADLINE_MARGIN_SECONDS: 15}.freeze
+
     UNSPECIFIED_HOSTNAMES = ["0.0.0.0", "::", "[::]"].freeze
 
     WEBHOOK_SIGNATURE = {

data/lib/nextmail/resources/calendar.rb

@@ -3,19 +3,21 @@
 module Nextmail
   module Resources
     class Calendar < Resource
-      def list_events(from:, to:, timezone: nil, include_team: nil, q: nil, limit: nil, cursor: nil, api_key: nil)
-        query = range_query(from, to, timezone, include_team, q)
+      def list_events(from:, to:, timezone: nil, include_team: nil, q: nil, calendar_ids: nil, limit: nil, cursor: nil,
+        api_key: nil)
+        query = range_query(from, to, timezone, include_team, q, calendar_ids)
         fetch_page(ApiPaths::CALENDAR_EVENTS, query, limit:, cursor:, api_key:)
       end
 
-      def list_all_events(from:, to:, timezone: nil, include_team: nil, q: nil, limit: nil, cursor: nil, api_key: nil)
-        query = range_query(from, to, timezone, include_team, q)
+      def list_all_events(from:, to:, timezone: nil, include_team: nil, q: nil, calendar_ids: nil, limit: nil, cursor: nil,
+        api_key: nil)
+        query = range_query(from, to, timezone, include_team, q, calendar_ids)
         collect_all(ApiPaths::CALENDAR_EVENTS, query, limit:, cursor:, api_key:)
       end
 
-      def iterate_events(from:, to:, timezone: nil, include_team: nil, q: nil, limit: nil, cursor: nil, api_key: nil,
-        &)
-        query = range_query(from, to, timezone, include_team, q)
+      def iterate_events(from:, to:, timezone: nil, include_team: nil, q: nil, calendar_ids: nil, limit: nil, cursor: nil,
+        api_key: nil, &)
+        query = range_query(from, to, timezone, include_team, q, calendar_ids)
         iterate_pages(ApiPaths::CALENDAR_EVENTS, query, limit:, cursor:, api_key:, &)
       end
 
@@ -65,6 +67,85 @@ module Nextmail
         request(fill(ApiPaths::CALENDAR_EVENT_DECLINE_PROPOSAL, id:), method: :post, body: payload(body, fields), api_key:)
       end
 
+      def list_calendars(kind: nil, api_key: nil)
+        fetch_list(ApiPaths::CALENDAR_CALENDARS, query_params(kind:), api_key:)
+      end
+
+      def get_calendar(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_CALENDAR, id:), api_key:)
+      end
+
+      def create_calendar(body = nil, api_key: nil, **fields)
+        request(ApiPaths::CALENDAR_CALENDARS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update_calendar(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CALENDAR_CALENDAR, id:), method: :patch, body: payload(patch, fields), api_key:)
+      end
+
+      def delete_calendar(id, notify_guests: nil, api_key: nil)
+        query = query_params(notify_guests: flag(notify_guests))
+        request(fill(ApiPaths::CALENDAR_CALENDAR, id:), method: :delete, query:, api_key:)
+      end
+
+      def set_calendar_member(id, member_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CALENDAR_CALENDAR_MEMBER, id:, memberId: member_id), method: :put,
+          body: payload(body, fields), repeatable: true, api_key:)
+      end
+
+      def remove_calendar_member(id, member_id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_CALENDAR_MEMBER, id:, memberId: member_id), method: :delete, api_key:)
+      end
+
+      def list_todos(calendar_ids: nil, state: nil, due_before: nil, due_after: nil, limit: nil, cursor: nil, api_key: nil)
+        query = todo_query(calendar_ids, state, due_before, due_after)
+        fetch_page(ApiPaths::CALENDAR_TODOS, query, limit:, cursor:, api_key:)
+      end
+
+      def list_all_todos(calendar_ids: nil, state: nil, due_before: nil, due_after: nil, limit: nil, cursor: nil,
+        api_key: nil)
+        query = todo_query(calendar_ids, state, due_before, due_after)
+        collect_all(ApiPaths::CALENDAR_TODOS, query, limit:, cursor:, api_key:)
+      end
+
+      def iterate_todos(calendar_ids: nil, state: nil, due_before: nil, due_after: nil, limit: nil, cursor: nil,
+        api_key: nil, &)
+        query = todo_query(calendar_ids, state, due_before, due_after)
+        iterate_pages(ApiPaths::CALENDAR_TODOS, query, limit:, cursor:, api_key:, &)
+      end
+
+      def get_todo(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_TODO, id:), api_key:)
+      end
+
+      def create_todo(body = nil, api_key: nil, **fields)
+        request(ApiPaths::CALENDAR_TODOS, method: :post, body: todo_wire(payload(body, fields)), api_key:)
+      end
+
+      def update_todo(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CALENDAR_TODO, id:), method: :patch, body: todo_wire(payload(patch, fields)), api_key:)
+      end
+
+      def delete_todo(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_TODO, id:), method: :delete, api_key:)
+      end
+
+      def list_calendar_logins(member: nil, api_key: nil)
+        fetch_list(ApiPaths::CALENDAR_LOGINS, query_params(member:), api_key:)
+      end
+
+      def create_calendar_login(body = nil, api_key: nil, **fields)
+        request(ApiPaths::CALENDAR_LOGINS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def revoke_calendar_login(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_LOGIN, id:), method: :delete, api_key:)
+      end
+
+      def create_calendar_login_profile_link(body = nil, api_key: nil, **fields)
+        request(ApiPaths::CALENDAR_LOGIN_PROFILE_LINK, method: :post, body: payload(body, fields), api_key:)
+      end
+
       def list_feeds(api_key: nil)
         fetch_list(ApiPaths::CALENDAR_FEEDS, api_key:)
       end
@@ -101,9 +182,10 @@ module Nextmail
         request(fill(ApiPaths::CALENDAR_SUBSCRIPTION, id:), method: :delete, api_key:)
       end
 
-      def import_ics(data, filename: nil, api_key: nil)
-        request(ApiPaths::CALENDAR_IMPORTS, method: :post, query: query_params(filename: optional_upload_name(data, filename)),
-          raw: data, content_type: Protocol::CONTENT_TYPES[:CALENDAR], api_key:)
+      def import_ics(data, filename: nil, calendar_id: nil, api_key: nil)
+        query = query_params(filename: optional_upload_name(data, filename), calendar_id:)
+        request(ApiPaths::CALENDAR_IMPORTS, method: :post, query:, raw: data, content_type: Protocol::CONTENT_TYPES[:CALENDAR],
+          api_key:)
       end
 
       def list_imports(limit: nil, cursor: nil, api_key: nil)
@@ -128,8 +210,20 @@ module Nextmail
 
       private
 
-      def range_query(from, to, timezone, include_team, q)
-        query_params(from: instant(from), to: instant(to), timezone:, include_team: flag(include_team), q:)
+      def range_query(from, to, timezone, include_team, q, calendar_ids)
+        query_params(from: instant(from), to: instant(to), timezone:, include_team: flag(include_team), q:,
+          calendar_ids: joined(calendar_ids))
+      end
+
+      def todo_query(calendar_ids, state, due_before, due_after)
+        query_params(calendar_ids: joined(calendar_ids), state:, due_before: instant(due_before),
+          due_after: instant(due_after))
+      end
+
+      def todo_wire(wire)
+        wire["start"] = instant(wire["start"]) if wire.key?("start")
+        wire["due"] = instant(wire["due"]) if wire.key?("due")
+        wire
       end
 
       def event_wire(wire)

data/lib/nextmail/resources/contacts.rb

@@ -113,22 +113,37 @@ module Nextmail
         request(fill(ApiPaths::CONTACT_ACTIVITY, email:), query:, api_key:)
       end
 
-      def list_cards(email: nil, without_email: nil, kind: nil, group_id: nil, limit: nil, cursor: nil, api_key: nil)
-        query = card_query(email, without_email, kind, group_id)
+      def list_cards(email: nil, without_email: nil, kind: nil, group_id: nil, address_book: nil, limit: nil, cursor: nil,
+        api_key: nil)
+        query = card_query(email, without_email, kind, group_id, address_book)
         fetch_page(ApiPaths::CONTACT_CARDS, query, limit:, cursor:, api_key:)
       end
 
-      def list_all_cards(email: nil, without_email: nil, kind: nil, group_id: nil, limit: nil, cursor: nil, api_key: nil)
-        query = card_query(email, without_email, kind, group_id)
+      def list_all_cards(email: nil, without_email: nil, kind: nil, group_id: nil, address_book: nil, limit: nil,
+        cursor: nil, api_key: nil)
+        query = card_query(email, without_email, kind, group_id, address_book)
         collect_all(ApiPaths::CONTACT_CARDS, query, limit:, cursor:, api_key:)
       end
 
-      def iterate_cards(email: nil, without_email: nil, kind: nil, group_id: nil, limit: nil, cursor: nil, api_key: nil,
-        &)
-        query = card_query(email, without_email, kind, group_id)
+      def iterate_cards(email: nil, without_email: nil, kind: nil, group_id: nil, address_book: nil, limit: nil,
+        cursor: nil, api_key: nil, &)
+        query = card_query(email, without_email, kind, group_id, address_book)
         iterate_pages(ApiPaths::CONTACT_CARDS, query, limit:, cursor:, api_key:, &)
       end
 
+      def list_address_books(api_key: nil)
+        fetch_list(ApiPaths::ADDRESS_BOOKS, api_key:)
+      end
+
+      def set_address_book_member(id, member_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::ADDRESS_BOOK_MEMBER, id:, memberId: member_id), method: :put, body: payload(body, fields),
+          repeatable: true, api_key:)
+      end
+
+      def remove_address_book_member(id, member_id, api_key: nil)
+        request(fill(ApiPaths::ADDRESS_BOOK_MEMBER, id:, memberId: member_id), method: :delete, api_key:)
+      end
+
       def get_card(id, api_key: nil)
         request(fill(ApiPaths::CONTACT_CARD, id:), api_key:)
       end
@@ -189,8 +204,8 @@ module Nextmail
         query_params(q:, email:, sort:, blocked: flag(blocked))
       end
 
-      def card_query(email, without_email, kind, group_id)
-        query_params(email:, without_email: flag(without_email), kind:, group_id:)
+      def card_query(email, without_email, kind, group_id, address_book)
+        query_params(email:, without_email: flag(without_email), kind:, group_id:, address_book:)
       end
     end
   end

data/lib/nextmail/resources/emails.rb

@@ -8,6 +8,11 @@ module Nextmail
           idempotency_key:, repeatable: true, api_key:)
       end
 
+      def send_raw(body = nil, idempotency_key: nil, api_key: nil, **fields)
+        request(ApiPaths::EMAILS_RAW, method: :post, body: Wire.email_raw(payload(body, fields)), idempotent: true,
+          idempotency_key:, repeatable: true, api_key:)
+      end
+
       def send_batch(emails, idempotency_key: nil, api_key: nil)
         wire = emails.map { |email| Wire.email(payload(email, {})) }
         result = request(ApiPaths::EMAILS_BATCH, method: :post, body: {"emails" => wire}, idempotent: true,

data/lib/nextmail/resources/live_events.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class LiveEvents < Resource
+      def initialize(transport, timing: Protocol::LIVE_STREAM_TIMING)
+        super(transport)
+        @timing = timing
+      end
+
+      def stream(types: nil, address: nil, last_event_id: nil, api_key: nil, &)
+        query = query_params(types: joined(types), address:)
+        events = Enumerator.new do |yielder|
+          LiveEventStream.new(@transport, query:, last_event_id:, api_key:, timing: @timing).run(yielder)
+        end
+
+        each_or_enumerator(events, &)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/share_links.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class ShareLinks < Resource
+      def list(kind: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::SHARE_LINKS, query_params(kind:), limit:, cursor:, api_key:)
+      end
+
+      def list_all(kind: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::SHARE_LINKS, query_params(kind:), limit:, cursor:, api_key:)
+      end
+
+      def iterate(kind: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::SHARE_LINKS, query_params(kind:), limit:, cursor:, api_key:, &)
+      end
+
+      def get(kind, item_id, api_key: nil)
+        request(fill(ApiPaths::SHARE_LINK, kind:, itemId: item_id), api_key:)
+      end
+
+      def set(kind, item_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::SHARE_LINK, kind:, itemId: item_id), method: :put, body: payload(body, fields),
+          repeatable: true, api_key:)
+      end
+
+      def delete(kind, item_id, api_key: nil)
+        request(fill(ApiPaths::SHARE_LINK, kind:, itemId: item_id), method: :delete, api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/shared.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Shared < Resource
+      def get(token, api_key: nil)
+        request(fill(ApiPaths::SHARED_ITEM, token:), api_key:)
+      end
+
+      def copy(token, api_key: nil)
+        request(fill(ApiPaths::SHARED_ITEM_COPY, token:), method: :post, api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/tasks.rb

@@ -3,16 +3,16 @@
 module Nextmail
   module Resources
     class Tasks < Resource
-      def list(status: nil, limit: nil, cursor: nil, api_key: nil)
-        fetch_page(ApiPaths::TASKS, query_params(status:), limit:, cursor:, api_key:)
+      def list(status: nil, chat_id: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::TASKS, query_params(status:, chat_id:), limit:, cursor:, api_key:)
       end
 
-      def list_all(status: nil, limit: nil, cursor: nil, api_key: nil)
-        collect_all(ApiPaths::TASKS, query_params(status:), limit:, cursor:, api_key:)
+      def list_all(status: nil, chat_id: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::TASKS, query_params(status:, chat_id:), limit:, cursor:, api_key:)
       end
 
-      def iterate(status: nil, limit: nil, cursor: nil, api_key: nil, &)
-        iterate_pages(ApiPaths::TASKS, query_params(status:), limit:, cursor:, api_key:, &)
+      def iterate(status: nil, chat_id: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::TASKS, query_params(status:, chat_id:), limit:, cursor:, api_key:, &)
       end
 
       def get(id, api_key: nil)

data/lib/nextmail/resources/threads.rb

@@ -92,6 +92,10 @@ module Nextmail
         request(fill(ApiPaths::THREAD_DELIVERY, id:), query: query_params(address:), api_key:)
       end
 
+      def list_automations(id, api_key: nil)
+        fetch_list(fill(ApiPaths::THREAD_AUTOMATIONS, id:), api_key:)
+      end
+
       def get_event(id, api_key: nil)
         request(fill(ApiPaths::THREAD_EVENT, id:), api_key:)
       end
@@ -123,6 +127,11 @@ module Nextmail
         request(ApiPaths::THREADS_COUNTS, query: query_params(address:, hide_labelled: flag(hide_labelled)), api_key:)
       end
 
+      def wait_for_email(address: nil, from: nil, subject: nil, since: nil, timeout: nil, api_key: nil)
+        request(ApiPaths::THREADS_WAIT, query: query_params(address:, from:, subject:, since: instant(since), timeout:),
+          timeout: wait_deadline(timeout), api_key:)
+      end
+
       def summary(id, api_key: nil)
         request(fill(ApiPaths::THREAD_SUMMARY, id:), api_key:)
       end
@@ -213,6 +222,13 @@ module Nextmail
       def file_link_query(include_revoked)
         query_params(include_revoked: flag(include_revoked))
       end
+
+      def wait_deadline(timeout)
+        wait = timeout.nil? ? Protocol::THREAD_WAIT[:DEFAULT_TIMEOUT_SECONDS] : timeout
+        raise ArgumentError, Defaults::MESSAGES[:WAIT_TIMEOUT_SHAPE] unless wait.is_a?(Numeric)
+
+        wait + Protocol::THREAD_WAIT[:DEADLINE_MARGIN_SECONDS]
+      end
     end
   end
 end

data/lib/nextmail/resources/traffic.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Traffic < Resource
+      def list(domain_id: nil, direction: nil, outcomes: nil, address: nil, recipient: nil, since: nil, until: nil,
+        limit: nil, cursor: nil, api_key: nil)
+        query = traffic_query(domain_id, direction, outcomes, address, recipient, since,
+          binding.local_variable_get(:until))
+        fetch_page(ApiPaths::TRAFFIC, query, limit:, cursor:, api_key:)
+      end
+
+      def list_all(domain_id: nil, direction: nil, outcomes: nil, address: nil, recipient: nil, since: nil,
+        until: nil, limit: nil, cursor: nil, api_key: nil)
+        query = traffic_query(domain_id, direction, outcomes, address, recipient, since,
+          binding.local_variable_get(:until))
+        collect_all(ApiPaths::TRAFFIC, query, limit:, cursor:, api_key:)
+      end
+
+      def iterate(domain_id: nil, direction: nil, outcomes: nil, address: nil, recipient: nil, since: nil,
+        until: nil, limit: nil, cursor: nil, api_key: nil, &)
+        query = traffic_query(domain_id, direction, outcomes, address, recipient, since,
+          binding.local_variable_get(:until))
+        iterate_pages(ApiPaths::TRAFFIC, query, limit:, cursor:, api_key:, &)
+      end
+
+      private
+
+      def traffic_query(domain_id, direction, outcomes, address, recipient, since, until_value)
+        outcome = (outcomes.nil? || outcomes.empty?) ? nil : joined(outcomes)
+        log_window_query(since, until_value)
+          .merge(query_params(domain_id:, direction:, outcome:, address:, recipient:))
+      end
+    end
+  end
+end