millionsend 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da6448e6cf8b24c1c2badb8bb4c4d4904d873882ede341fefdbcb6949561753e
-  data.tar.gz: e68c0e3c988f18fee505aa780fbfc1974593da463f1aba01162eff0e50d4a0b4
+  metadata.gz: e15bda7d83e77437273c93cad192bc1da266e48ffb560b29037c898e26cc825d
+  data.tar.gz: be0dbc70f2210ff128541664405e74278f03825a2ea3e5eaa7ef887ce8c73a3b
 SHA512:
-  metadata.gz: dc6a03a18b27ff92b46203c37df82eed46687420b14ac010e7b671ca6506f4f4c008e9177728c4640bb8aff3019f67fd7dbf23b9636a64a75b48cbfc658e2007
-  data.tar.gz: f5988d2662081f5bb34323cf482c10fc3762051b0b44e307a391cb867214d6dd6306664b052ed5f59e6ea5e2ef0e9187f6dba582c1c1b9c5ca4341ecdc076c4d
+  metadata.gz: 2a851400dfdff77ecd956e54df92b6ce0bf8b201c471b5354734e43a27dae34d66dff76602d61ac347758da0ee027f3cd9d331653752097dd13d637f10a38a17
+  data.tar.gz: aded65d56245645bef51bf1aa9954caf9f212c7c73e88946d3e6bc39ec59849ef3c05fd522b5dc259548c2408b01c834b684cd3609874ff23df4c960837d7e6c

data/README.md

@@ -53,7 +53,7 @@ Millionsend.base_url = "https://mail.acme.dev" # falls back to ENV["MILLIONSEND_
 MillionSend is self-hosted, so there is no cloud default — **set `base_url` to your
 deployment in production.** An explicitly assigned value always wins over the environment.
 Params are symbol-keyed hashes and map straight to the wire (Ruby's snake_case is already
-the wire's snake_case: `reply_to`, `scheduled_at`, `audience_id`).
+the wire's snake_case: `reply_to`, `scheduled_at`, `segment_id`).
 
 ## Resources
 
@@ -70,28 +70,25 @@ Millionsend::Batch.send([payload_a, payload_b], idempotency_key: "run-7") # up t
 `to`, `cc`, `bcc` and `reply_to` accept either a string or an array. `Emails.create` is
 an alias of `Emails.send` (as is `Batch.create`), mirroring Resend.
 
-### Audiences & contacts
+### Contacts
+
+Contacts are team-global — one list per team, no audiences.
 
 ```ruby
-audience = Millionsend::Audiences.create(name: "Registered users")
-Millionsend::Audiences.list(limit: 20, after: cursor)
-Millionsend::Audiences.get(id)
-Millionsend::Audiences.remove(id)
-
-Millionsend::Contacts.create(audience_id: audience[:id], email: "ada@acme.dev",
-                             first_name: "Ada", properties: { plan: "pro" })
-Millionsend::Contacts.get("ada@acme.dev", audience_id: audience[:id]) # by id or email
-Millionsend::Contacts.get(contact_id)                                  # top-level, by id
-Millionsend::Contacts.update(id: contact_id, unsubscribed: true, first_name: nil) # nil clears
-Millionsend::Contacts.remove("ada@acme.dev", audience_id: audience[:id])
-Millionsend::Contacts.list(audience_id: audience[:id], limit: 50)
+contact = Millionsend::Contacts.create(email: "ada@acme.dev", first_name: "Ada",
+                                       properties: { plan: "pro" })
+Millionsend::Contacts.get("ada@acme.dev") # by id or email
+Millionsend::Contacts.update(id: contact[:id], unsubscribed: true, first_name: nil) # nil clears
+Millionsend::Contacts.remove("ada@acme.dev")
+Millionsend::Contacts.list(limit: 50)
 
 # Topic subscriptions (granular unsubscribe) — mirrors resend's contacts.topics.update
 Millionsend::Contacts.topics_update("ada@acme.dev", [{ id: topic_id, subscription: "opt_out" }])
 ```
 
 Contacts are addressable by id or email; when an `update` hash carries both, the email wins.
-Omit `audience_id:` to use the top-level `/contacts` endpoints.
+Emails are unique per team (case-insensitive) — a duplicate `create` raises
+`Millionsend::ValidationError`.
 
 ### Topics
 
@@ -106,7 +103,7 @@ Millionsend::Topics.remove(id)
 
 ```ruby
 broadcast = Millionsend::Broadcasts.create(
-  audience_id: audience[:id],
+  segment_id: segment[:id], # optional; omit segment_id and topic_id to send to all contacts
   from: "Acme <news@acme.dev>",
   subject: "Launch",
   html: "<p>Hi {{{FIRST_NAME|there}}}</p>"
@@ -121,13 +118,12 @@ Millionsend::Broadcasts.remove(broadcast[:id]) # draft only
 
 ### Segments (MillionSend extension)
 
-Dynamic segments are a saved filter over an audience's contacts — a MillionSend superset with
-no Resend equivalent, served under `/segments2`.
+Dynamic segments are a saved filter over the team's contacts — a MillionSend superset with
+no Resend equivalent.
 
 ```ruby
 segment = Millionsend::Segments.create(
   name: "Pro plan",
-  audience_id: audience[:id],
   filter: { match: "all", conditions: [{ field: "property:plan", op: "equals", value: "pro" }] }
 )
 Millionsend::Segments.get(segment[:id]) # includes a live contact_count
@@ -174,8 +170,9 @@ Method names, nesting and payloads match. Notes:
   are no `Domains` / `ApiKeys` resources here.
 - Resend's `Contacts.topics.update` becomes `Millionsend::Contacts.topics_update` (Ruby has no
   nested-module method on a module function).
-- `Millionsend::Segments` is the distinct dynamic-filter feature (`/segments2`), not Resend's
-  audiences alias. Use `Millionsend::Audiences` for a straight port.
+- **No audiences** — contacts are team-global, so there is no `Audiences` resource and no
+  `audience_id` params. `Millionsend::Segments` is the dynamic-filter feature (`/segments`),
+  not Resend's audiences alias.
 
 ## License
 

data/lib/millionsend/broadcasts.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 module Millionsend
-  # Broadcasts — one email sent to a whole audience or segment.
+  # Broadcasts — one email sent to a segment, a topic's subscribers, or every
+  # contact (pass neither segment_id nor topic_id).
   module Broadcasts
     class << self
       # POST /broadcasts

data/lib/millionsend/contacts.rb

@@ -1,59 +1,51 @@
 # frozen_string_literal: true
 
 module Millionsend
-  # Contacts live inside an audience or at the top level, and are addressable by
-  # id or by email (email wins when an update hash carries both).
+  # Contacts are team-global and addressable by id or by email (email wins when
+  # an update hash carries both).
   module Contacts
     class << self
-      # POST /audiences/:audience_id/contacts (or /contacts). audience_id is
-      # addressing, not a body field, so it is stripped from the payload.
+      # POST /contacts
       def create(params)
-        body = params.reject { |k, _| k == :audience_id }
-        Millionsend::Request.new(method: :post, path: collection_path(params[:audience_id]), body: body).perform
+        Millionsend::Request.new(method: :post, path: "/contacts", body: params).perform
       end
 
       # GET a single contact by id or email.
-      def get(id_or_email, audience_id: nil)
-        Millionsend::Request.new(method: :get, path: member_path(id_or_email, audience_id)).perform
+      def get(id_or_email)
+        Millionsend::Request.new(method: :get, path: member_path(id_or_email)).perform
       end
 
-      # PATCH a contact. Addressing keys (:audience_id, :id, :email) are pulled
-      # out; everything else is the body. A nil value clears a field; omit a key
-      # to leave it unchanged.
+      # PATCH a contact. Addressing keys (:id, :email) are pulled out;
+      # everything else is the body. A nil value clears a field; omit a key to
+      # leave it unchanged.
       def update(params)
         key = params[:email] || params[:id]
-        body = params.reject { |k, _| [:audience_id, :id, :email].include?(k) }
-        Millionsend::Request.new(method: :patch, path: member_path(key, params[:audience_id]), body: body).perform
+        body = params.reject { |k, _| [:id, :email].include?(k) }
+        Millionsend::Request.new(method: :patch, path: member_path(key), body: body).perform
       end
 
       # DELETE a contact by id or email.
-      def remove(id_or_email, audience_id: nil)
-        Millionsend::Request.new(method: :delete, path: member_path(id_or_email, audience_id)).perform
+      def remove(id_or_email)
+        Millionsend::Request.new(method: :delete, path: member_path(id_or_email)).perform
       end
 
-      # GET a list of contacts; pass audience_id: to scope it, plus limit:/after:/before:.
+      # GET /contacts — accepts limit:/after:/before:.
       def list(options = {})
         Millionsend::Request.new(
-          method: :get, path: collection_path(options[:audience_id]), query: Millionsend::Util.list_query(options)
+          method: :get, path: "/contacts", query: Millionsend::Util.list_query(options)
         ).perform
       end
 
       # PATCH /contacts/:id_or_email/topics with a bare array of
       # { id:, subscription: }. Mirrors resend-ruby's contacts.topics.update.
       def topics_update(id_or_email, topics)
-        path = "/contacts/#{Millionsend::Util.encode(id_or_email)}/topics"
-        Millionsend::Request.new(method: :patch, path: path, body: topics).perform
+        Millionsend::Request.new(method: :patch, path: "#{member_path(id_or_email)}/topics", body: topics).perform
       end
 
       private
 
-      def collection_path(audience_id)
-        audience_id ? "/audiences/#{Millionsend::Util.encode(audience_id)}/contacts" : "/contacts"
-      end
-
-      def member_path(id_or_email, audience_id)
-        key = Millionsend::Util.encode(id_or_email)
-        audience_id ? "/audiences/#{Millionsend::Util.encode(audience_id)}/contacts/#{key}" : "/contacts/#{key}"
+      def member_path(id_or_email)
+        "/contacts/#{Millionsend::Util.encode(id_or_email)}"
       end
     end
   end

data/lib/millionsend/segments.rb

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
 module Millionsend
-  # Dynamic segments — a saved filter over an audience's contacts. A MillionSend
-  # extension with no Resend equivalent; served under /segments2.
+  # Dynamic segments — a saved filter over the team's contacts. A MillionSend
+  # extension with no Resend equivalent.
   module Segments
     class << self
-      # POST /segments2
+      # POST /segments
       def create(params)
-        Millionsend::Request.new(method: :post, path: "/segments2", body: params).perform
+        Millionsend::Request.new(method: :post, path: "/segments", body: params).perform
       end
 
-      # GET /segments2/:id — also returns a live contact_count.
+      # GET /segments/:id — also returns a live contact_count.
       def get(id)
-        Millionsend::Request.new(method: :get, path: "/segments2/#{Millionsend::Util.encode(id)}").perform
+        Millionsend::Request.new(method: :get, path: "/segments/#{Millionsend::Util.encode(id)}").perform
       end
 
-      # GET /segments2 — accepts limit:/after:/before:.
+      # GET /segments — accepts limit:/after:/before:.
       def list(options = {})
         Millionsend::Request.new(
-          method: :get, path: "/segments2", query: Millionsend::Util.list_query(options)
+          method: :get, path: "/segments", query: Millionsend::Util.list_query(options)
         ).perform
       end
 
-      # PATCH /segments2/:id
+      # PATCH /segments/:id
       def update(id, params)
-        Millionsend::Request.new(method: :patch, path: "/segments2/#{Millionsend::Util.encode(id)}", body: params).perform
+        Millionsend::Request.new(method: :patch, path: "/segments/#{Millionsend::Util.encode(id)}", body: params).perform
       end
 
-      # DELETE /segments2/:id
+      # DELETE /segments/:id
       def remove(id)
-        Millionsend::Request.new(method: :delete, path: "/segments2/#{Millionsend::Util.encode(id)}").perform
+        Millionsend::Request.new(method: :delete, path: "/segments/#{Millionsend::Util.encode(id)}").perform
       end
     end
   end

data/lib/millionsend/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Millionsend
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/millionsend.rb

@@ -6,7 +6,6 @@ require "millionsend/error"
 require "millionsend/request"
 require "millionsend/emails"
 require "millionsend/batch"
-require "millionsend/audiences"
 require "millionsend/contacts"
 require "millionsend/topics"
 require "millionsend/broadcasts"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: millionsend
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - MillionSend
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-16 00:00:00.000000000 Z
+date: 2026-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -52,10 +52,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.19'
-description: 'Ruby client for the MillionSend HTTP API: emails, batch, audiences,
-  contacts, topics, broadcasts, and dynamic segments. Wire-compatible with Resend
-  and mirror-shaped after resend-ruby, so migrating is mostly an import swap plus
-  a base_url.'
+description: 'Ruby client for the MillionSend HTTP API: emails, batch, contacts, topics,
+  broadcasts, and dynamic segments. Wire-compatible with Resend and mirror-shaped
+  after resend-ruby, so migrating is mostly an import swap plus a base_url.'
 email:
 executables: []
 extensions: []
@@ -64,7 +63,6 @@ files:
 - LICENSE
 - README.md
 - lib/millionsend.rb
-- lib/millionsend/audiences.rb
 - lib/millionsend/batch.rb
 - lib/millionsend/broadcasts.rb
 - lib/millionsend/contacts.rb

data/lib/millionsend/audiences.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Millionsend
-  # Audiences — named contact lists (Resend-compatible).
-  module Audiences
-    class << self
-      # POST /audiences
-      def create(params)
-        Millionsend::Request.new(method: :post, path: "/audiences", body: { name: params[:name] }).perform
-      end
-
-      # GET /audiences/:id
-      def get(id)
-        Millionsend::Request.new(method: :get, path: "/audiences/#{Millionsend::Util.encode(id)}").perform
-      end
-
-      # GET /audiences — accepts limit:/after:/before:.
-      def list(options = {})
-        Millionsend::Request.new(
-          method: :get, path: "/audiences", query: Millionsend::Util.list_query(options)
-        ).perform
-      end
-
-      # DELETE /audiences/:id
-      def remove(id)
-        Millionsend::Request.new(method: :delete, path: "/audiences/#{Millionsend::Util.encode(id)}").perform
-      end
-    end
-  end
-end