email_list_api 0.1.0.rc.1 → 0.1.0.rc.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9f6eff66fff016c13db422fe77d7b6173a6389a4ebb48e56c6a976180fe78e9
-  data.tar.gz: 5eb26fa011aeb57b16a6d22dbfb422f69310c16d75a0750337c22c25771394bd
+  metadata.gz: e1ed6ace184bb9f8af7eaffe002158c0b2dcd67bd5d11fcc4fad7a93bd33bca0
+  data.tar.gz: b14740c3dc18fca184637df8402f92957201e637c817ca193cde6298dcd1df8b
 SHA512:
-  metadata.gz: 5d8fa655ccabbdb642b73954f6a426a26ff8f6c92c8cb9a1b4bbf4f8e391977327779aaa5b78956e6fe1dcf8b978d0094b6650b478b4df3e17599b3df13c3790
-  data.tar.gz: 32760843f905f7c7918fd4b358394c10e57420b6eedc4f8b98b2ef24cac062d32f2c4bb6a307f30e180d6200acfaac527628ff423c768af94d8b896e33eb466d
+  metadata.gz: 8e3aadd9e8de672857ee08a3d27bd657dde1ae6e9af9d75fe07a6abd0e6b8a128d1503804f824e6880aaafe6def2459dbfb05eb0207bc26e3b4e630014409c33
+  data.tar.gz: 03b298cb089969cb48e429b069cc07accb36cac2eac32d5d1c019790376ffd01a64ec87b497bb62400197689fecb586364e15254dfeb04b8d526329816f5ac10

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Email List Dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -18,21 +18,131 @@ Or install it yourself as:
 
     $ gem install email_list_api
 
+## Configuration
+
+You can configure the gem globally using an initializer (recommended for Rails apps):
+
+```ruby
+# config/initializers/email_list_api.rb
+EmailListApi.configure do |config|
+  config.api_key = ENV['EMAILLIST_API_KEY'] || Rails.application.credentials.dig(:emaillist, :api_key)
+  # api_version is optional (defaults to latest based on gem version)
+  # config.api_version = 1
+end
+```
+
+This sets a global default that will be used by all clients unless overridden. The configuration priority is:
+1. Explicit parameter (highest priority)
+2. Global configuration (`EmailListApi.configure`)
+3. Environment variable (`EMAILLIST_API_KEY`)
+
 ## Usage
 
 ```ruby
 require 'email_list_api'
 
+# If configured globally, you can create a client without specifying the API key
+client = EmailListApi::Client.new
+
+# Or explicitly pass the API key (overrides global config)
 client = EmailListApi::Client.new(api_key: 'your_api_key')
 
+# Optionally specify API version (defaults to latest)
+client = EmailListApi::Client.new(api_key: 'your_api_key', api_version: 1)
+
 # Projects
 projects = client.projects
 project = client.create_project(name: 'My Project')
 
-# Lists
-lists = client.lists(project_id: project['id'])
-list = client.create_list(project_id: project['id'], name: 'Newsletter')
+# Lists (project can be slug or ID)
+lists = client.lists(project: project['data']['slug'])
+list = client.create_list(project: project['data']['slug'], name: 'Newsletter')
 
 # Contacts
-client.create_contact(project_id: project['id'], email: 'user@example.com')
+client.create_contact(project: project['data']['slug'], email: 'user@example.com')
+client.update_contact(project: project['data']['slug'], id: contact_id, first_name: 'John')
+# Upsert: creates if new, updates if exists (by email)
+client.upsert_contact(project: project['data']['slug'], email: 'user@example.com', first_name: 'Jane')
+
+# Unsubscribe URLs
+# Contact responses include unsubscribe_urls hash (list_id => unsubscribe_url)
+contact = client.contact(project: project['data']['slug'], id: contact_id)
+contact['data']['unsubscribe_urls'] # => { 1 => "https://emaillist.dev/unsubscribe/...", 2 => "..." }
+
+# List contact responses include unsubscribe_url for that specific list
+list_contacts = client.list_contacts(project: project['data']['slug'], list_id: list_id)
+list_contacts['data'].each do |contact|
+  unsubscribe_url = contact['unsubscribe_url'] # => "https://emaillist.dev/unsubscribe/..."
+  # Include this URL in your email templates
+end
+```
+
+## Automatic Contact Sync (Rails Models)
+
+The gem includes a concern that automatically syncs Rails models to EmailList contacts. This is useful for syncing User models or other models that represent contacts.
+
+### Basic Usage
+
+Include the concern in your model and configure it:
+
+```ruby
+class User < ApplicationRecord
+  include EmailListApi::SyncsEmailListContact
+
+  syncs_email_list_contact project_slug: 'newsletter'
+end
+```
+
+Now, whenever a User is created or updated, it will automatically create or update the corresponding contact in EmailList.
+
+### Custom Field Mapping
+
+If your model uses different field names, you can configure them:
+
+```ruby
+class User < ApplicationRecord
+  include EmailListApi::SyncsEmailListContact
+
+  syncs_email_list_contact project_slug: 'newsletter',
+                           email_field: :email_address,
+                           first_name_field: :given_name,
+                           last_name_field: :family_name
+end
 ```
+
+### Custom API Version
+
+You can specify a custom API version per model (overrides global config):
+
+```ruby
+class User < ApplicationRecord
+  include EmailListApi::SyncsEmailListContact
+
+  syncs_email_list_contact project_slug: 'newsletter',
+                           api_version: 1
+end
+```
+
+The API key is always taken from the global configuration (`EmailListApi.configure`) or the `EMAILLIST_API_KEY` environment variable. The API version defaults to 1 if not specified, and the base URL is automatically determined (production: `https://emaillist.dev/api/v1`, development: `http://localhost:3000/api/v1`)
+
+### Optional: Store Contact ID
+
+You can optionally add a column to store the EmailList contact ID for faster lookups:
+
+```ruby
+# Migration
+add_column :users, :emaillist_contact_id, :integer
+add_index :users, :emaillist_contact_id
+```
+
+The concern will automatically populate this field when contacts are created or updated.
+
+## Environments
+
+Each API key is associated with an environment. When you make API requests, all operations are automatically scoped to the environment associated with your API key. This means:
+
+- Projects, lists, and contacts are automatically filtered to your environment
+- You don't need to specify an environment in API calls - it's determined by your API key
+- To work with multiple environments, use different API keys (one per environment)
+
+You can manage environments and create API keys in the EmailList web dashboard.

data/lib/email_list_api/client.rb

@@ -1,17 +1,41 @@
-require 'faraday'
-require 'faraday/retry'
-require 'faraday/follow_redirects'
+require 'httpx'
 require 'json'
+require 'uri'
 
 module EmailListApi
   class Client
-    DEFAULT_BASE_URL = "http://localhost:3000/api/v1"
+    PRODUCTION_BASE_URL = "https://emaillist.dev/api"
+    DEVELOPMENT_BASE_URL = "http://localhost:3000/api"
 
-    def initialize(api_key: ENV['EMAILLIST_API_KEY'], base_url: DEFAULT_BASE_URL)
-      @api_key = api_key
-      @base_url = base_url
+    def initialize(api_key: nil, api_version: nil, base_url: nil)
+      # Priority: explicit parameter > global config
+      @api_key = api_key || EmailListApi.configuration.api_key
+      @version = api_version || EmailListApi.configuration.api_version || 1
+      @origin, @base_path = build_url_parts(base_url)
     end
 
+    private
+
+    def build_url_parts(base_url_override = nil)
+      # Priority: explicit parameter > config
+      base_url = base_url_override || EmailListApi.configuration.base_url
+
+      raise ArgumentError, "base_url must be configured" unless base_url
+
+      uri = URI.parse(base_url)
+      origin = "#{uri.scheme}://#{uri.host}#{uri.port && uri.port != (uri.scheme == 'https' ? 443 : 80) ? ":#{uri.port}" : ''}"
+      base_path = "#{uri.path}/v#{@version}".gsub(%r{/+}, '/')
+      [ origin, base_path ]
+    end
+
+    def build_path(path)
+      # Ensure path starts with / and combine with base_path
+      path = "/#{path}" unless path.start_with?('/')
+      "#{@base_path}#{path}".gsub(%r{/+}, '/')
+    end
+
+    public
+
     # Projects
     def projects
       get("projects")
@@ -25,6 +49,10 @@ module EmailListApi
       post("projects", { project: { name: name, description: description } })
     end
 
+    def upsert_project(name:, description: nil)
+      post("projects/upsert", { project: { name: name, description: description } })
+    end
+
     def update_project(id, name: nil, description: nil)
       params = { project: {} }
       params[:project][:name] = name if name
@@ -37,116 +65,187 @@ module EmailListApi
     end
 
     # Lists
-    def lists(project_id:)
-      get("projects/#{project_id}/lists")
+    def lists(project:)
+      get("projects/#{project}/lists")
+    end
+
+    def list(project:, slug:)
+      get("projects/#{project}/lists/#{slug}")
     end
 
-    def list(project_id:, id:)
-      get("projects/#{project_id}/lists/#{id}")
+    def create_list(project:, name:, description: nil)
+      post("projects/#{project}/lists", { list: { name: name, description: description } })
     end
 
-    def create_list(project_id:, name:, description: nil)
-      post("projects/#{project_id}/lists", { list: { name: name, description: description } })
+    def upsert_list(project:, name:, description: nil)
+      post("projects/#{project}/lists/upsert", { list: { name: name, description: description } })
     end
 
-    def update_list(project_id:, id:, name: nil, description: nil)
+    def update_list(project:, slug:, name: nil, description: nil)
       params = { list: {} }
       params[:list][:name] = name if name
       params[:list][:description] = description if description
-      patch("projects/#{project_id}/lists/#{id}", params)
+      patch("projects/#{project}/lists/#{slug}", params)
     end
 
-    def delete_list(project_id:, id:)
-      delete("projects/#{project_id}/lists/#{id}")
+    def delete_list(project:, slug:)
+      delete("projects/#{project}/lists/#{slug}")
     end
 
     # Contacts
-    def contacts(project_id:, page: 1)
-      get("projects/#{project_id}/contacts", { page: page })
+    def contacts(project:, page: 1)
+      get("projects/#{project}/contacts", { page: page })
     end
 
-    def contact(project_id:, id:)
-      get("projects/#{project_id}/contacts/#{id}")
+    def contact(project:, id:)
+      get("projects/#{project}/contacts/#{id}")
     end
 
-    def create_contact(project_id:, email:, first_name: nil, last_name: nil)
+    def create_contact(project:, email:, first_name: nil, last_name: nil)
       params = { contact: { email: email } }
       params[:contact][:first_name] = first_name if first_name
       params[:contact][:last_name] = last_name if last_name
-      post("projects/#{project_id}/contacts", params)
+      post("projects/#{project}/contacts", params)
     end
 
-    def update_contact(project_id:, id:, email: nil, first_name: nil, last_name: nil)
+    def update_contact(project:, id:, email: nil, first_name: nil, last_name: nil)
       params = { contact: {} }
       params[:contact][:email] = email if email
       params[:contact][:first_name] = first_name if first_name
       params[:contact][:last_name] = last_name if last_name
-      patch("projects/#{project_id}/contacts/#{id}", params)
+      patch("projects/#{project}/contacts/#{id}", params)
     end
 
-    def delete_contact(project_id:, id:)
-      delete("projects/#{project_id}/contacts/#{id}")
+    def upsert_contact(project:, email:, first_name: nil, last_name: nil)
+      params = { contact: { email: email } }
+      params[:contact][:first_name] = first_name if first_name
+      params[:contact][:last_name] = last_name if last_name
+      post("projects/#{project}/contacts/upsert", params)
+    end
+
+    def delete_contact(project:, id:)
+      delete("projects/#{project}/contacts/#{id}")
     end
 
     # List Memberships
-    def list_contacts(project_id:, list_id:)
-      get("projects/#{project_id}/lists/#{list_id}/contacts")
+    def list_contacts(project:, list_slug:)
+      get("projects/#{project}/lists/#{list_slug}/contacts")
     end
 
-    def add_contacts_to_list(project_id:, list_id:, contacts:)
+    def add_contacts_to_list(project:, list_slug:, contacts:)
       # contacts can be an array of hashes or a single hash, but API expects array
-      contacts = [contacts] unless contacts.is_a?(Array)
-      post("projects/#{project_id}/lists/#{list_id}/contacts", { contacts: contacts })
+      contacts = [ contacts ] unless contacts.is_a?(Array)
+      post("projects/#{project}/lists/#{list_slug}/contacts", { contacts: contacts })
     end
 
-    def add_contact_to_list(project_id:, list_id:, contact_id:)
+    def add_contact_to_list(project:, list_slug:, contact_id:)
       # Helper for adding single existing contact by ID
-      add_contacts_to_list(project_id: project_id, list_id: list_id, contacts: [{ id: contact_id }])
+      add_contacts_to_list(project: project, list_slug: list_slug, contacts: [ { id: contact_id } ])
     end
 
-    def remove_contact_from_list(project_id:, list_id:, contact_id:)
-      delete("projects/#{project_id}/lists/#{list_id}/contacts/#{contact_id}")
+    def remove_contact_from_list(project:, list_slug:, contact_id:)
+      delete("projects/#{project}/lists/#{list_slug}/contacts/#{contact_id}")
     end
 
     # Bulk Operations
-    def bulk_create_contacts(project_id:, contacts:)
-       post("projects/#{project_id}/contacts/bulk", { contacts: contacts })
+    def bulk_create_contacts(project:, contacts:)
+       post("projects/#{project}/contacts/bulk", { contacts: contacts })
     end
 
     private
 
-    def connection
-      @connection ||= Faraday.new(url: @base_url) do |conn|
-        conn.request :json
-        conn.request :retry
-        conn.response :json, content_type: /\bjson$/
-        conn.response :raise_error
-        conn.response :follow_redirects
-        conn.headers['Authorization'] = "Bearer #{@api_key}"
-        conn.headers['Content-Type'] = 'application/json'
-        conn.headers['User-Agent'] = "EmailListApi Ruby Client/#{EmailListApi::VERSION}"
-        conn.adapter Faraday.default_adapter
-      end
+    def http_client
+      @http_client ||= HTTPX.plugin(:follow_redirects).plugin(:retries).with(
+        origin: @origin,
+        headers: {
+          'Authorization' => "Bearer #{@api_key}",
+          'Content-Type' => 'application/json',
+          'User-Agent' => "EmailListApi Ruby Client/#{EmailListApi::VERSION}"
+        }
+      )
     end
 
     def get(path, params = {})
-      response = connection.get(path, params)
-      response.body
+      response = http_client.get(build_path(path), params: params)
+      raise_error_if_needed(response)
+      parse_json_response(response)
     end
 
     def post(path, body = {})
-      response = connection.post(path, body)
-      response.body
+      response = http_client.post(build_path(path), json: body)
+      raise_error_if_needed(response)
+      parse_json_response(response)
     end
 
     def patch(path, body = {})
-      response = connection.patch(path, body)
-      response.body
+      response = http_client.patch(build_path(path), json: body)
+      raise_error_if_needed(response)
+      parse_json_response(response)
     end
 
     def delete(path)
-      response = connection.delete(path)
-      response.body
+      response = http_client.delete(build_path(path))
+      raise_error_if_needed(response)
+      parse_json_response(response)
+    end
+
+    def parse_json_response(response)
+      # Handle 204 No Content and empty responses
+      return nil if response.status == 204 || response.body.to_s.empty?
+
+      response.json
+    end
+
+    def raise_error_if_needed(response)
+      # HTTPX returns status as Integer (200-299 are success)
+      return if response.status >= 200 && response.status < 300
+
+      # Try to parse JSON error response
+      error_message = extract_error_message(response)
+      raise HTTPX::Error, error_message
+    end
+
+    def extract_error_message(response)
+      body = response.body.to_s
+
+      # Try to parse as JSON first
+      begin
+        json = JSON.parse(body)
+        if json.is_a?(Hash)
+          # Extract error message from common JSON error formats
+          error = json['error'] || json['errors']
+          if error.is_a?(Hash)
+            message = error['message'] || error['code'] || error.to_s
+          elsif error.is_a?(Array) && error.any?
+            message = error.first.is_a?(Hash) ? (error.first['message'] || error.first.to_s) : error.first.to_s
+          elsif error.is_a?(String)
+            message = error
+          end
+
+          return "HTTP #{response.status}: #{message || json.to_s}" if message
+        end
+      rescue JSON::ParserError
+        # Not JSON, continue to HTML handling
+      end
+
+      # If it's HTML (likely an error page), extract a meaningful message
+      if body.include?('<!DOCTYPE') || body.include?('<html')
+        # Extract title or h1 if available
+        if body =~ /<title>(.*?)<\/title>/i
+          title = $1.strip
+          return "HTTP #{response.status}: #{title}" unless title.empty?
+        end
+        if body =~ /<h1[^>]*>(.*?)<\/h1>/i
+          heading = $1.strip
+          return "HTTP #{response.status}: #{heading}" unless heading.empty?
+        end
+        # Fallback to a generic message for HTML errors
+        return "HTTP #{response.status}: Server returned an error page"
+      end
+
+      # Default: return status and truncated body
+      truncated_body = body.length > 200 ? "#{body[0..200]}..." : body
+      "HTTP #{response.status}: #{truncated_body}"
     end
   end
 end

data/lib/email_list_api/configuration.rb

@@ -0,0 +1,14 @@
+module EmailListApi
+  class Configuration
+    attr_accessor :api_key, :api_version, :base_url, :raise_on_sync_error
+
+    def initialize
+      @api_key = nil
+      @api_version = nil
+      @base_url = nil
+      # Default: raise exceptions on sync errors (fail loudly)
+      # Set to false to fail silently if needed (e.g., during gem bugs)
+      @raise_on_sync_error = true
+    end
+  end
+end

data/lib/email_list_api/syncs_email_list_contact.rb

@@ -0,0 +1,144 @@
+require 'active_support/concern'
+
+module EmailListApi
+  module SyncsEmailListContact
+    extend ActiveSupport::Concern
+
+    included do
+      # Optional: Add a column to store the contact_id for caching
+      # You can add this migration: add_column :users, :emaillist_contact_id, :integer
+
+      after_create :sync_to_email_list_after_create
+      after_update :sync_to_email_list_after_update
+    end
+
+    module ClassMethods
+      # Configure the sync behavior
+      # Example:
+      #   syncs_email_list_contact project_slug: 'my-project',
+      #                            email_field: :email_address,
+      #                            first_name_field: :given_name,
+      #                            last_name_field: :family_name,
+      #                            api_version: 1
+      #
+      # @param project_slug [String] The project slug to sync contacts to
+      # @param email_field [Symbol] The attribute name for email (default: :email)
+      # @param first_name_field [Symbol] The attribute name for first name (default: :first_name)
+      # @param last_name_field [Symbol] The attribute name for last name (default: :last_name)
+      # @param api_version [Integer, nil] API version override (default: nil, uses global config)
+      # @param always_sync [Boolean] Sync on every save, not just when fields change (default: false)
+      def syncs_email_list_contact(project_slug:,
+                                   email_field: :email,
+                                   first_name_field: :first_name,
+                                   last_name_field: :last_name,
+                                   api_version: nil,
+                                   always_sync: false)
+        @emaillist_project = project_slug
+        @emaillist_email_field = email_field
+        @emaillist_first_name_field = first_name_field
+        @emaillist_last_name_field = last_name_field
+        @emaillist_api_version = api_version
+        @emaillist_always_sync = always_sync
+      end
+
+      def emaillist_project
+        @emaillist_project
+      end
+
+      def emaillist_email_field
+        @emaillist_email_field || :email
+      end
+
+      def emaillist_first_name_field
+        @emaillist_first_name_field || :first_name
+      end
+
+      def emaillist_last_name_field
+        @emaillist_last_name_field || :last_name
+      end
+
+      def emaillist_api_version
+        @emaillist_api_version
+      end
+
+      def emaillist_always_sync
+        @emaillist_always_sync || false
+      end
+    end
+
+    private
+
+    def emaillist_client
+      # Use shared client if no model-specific api_version override is configured
+      if self.class.emaillist_api_version.nil?
+        EmailListApi.client
+      else
+        # Create a custom client only if model has specific api_version override
+        @emaillist_client ||= EmailListApi::Client.new(api_version: self.class.emaillist_api_version)
+      end
+    end
+
+    def sync_to_email_list_after_create
+      sync_to_email_list
+    end
+
+    def sync_to_email_list_after_update
+      # If always_sync is enabled, sync on every update
+      if self.class.emaillist_always_sync
+        sync_to_email_list
+        return
+      end
+
+      # Otherwise, only sync if relevant fields changed
+      email_field = self.class.emaillist_email_field
+      first_name_field = self.class.emaillist_first_name_field
+      last_name_field = self.class.emaillist_last_name_field
+
+      if saved_change_to_attribute?(email_field) ||
+         saved_change_to_attribute?(first_name_field) ||
+         saved_change_to_attribute?(last_name_field)
+        sync_to_email_list
+      end
+    end
+
+    def sync_to_email_list
+      return unless self.class.emaillist_project
+
+      email = read_attribute(self.class.emaillist_email_field)
+      return unless email.present?
+
+      first_name = read_attribute(self.class.emaillist_first_name_field)
+      last_name = read_attribute(self.class.emaillist_last_name_field)
+
+      project_slug = self.class.emaillist_project
+
+      begin
+        # Ensure project exists (idempotent - creates if doesn't exist)
+        # Convert slug to name for upsert (e.g., "my-project" -> "My Project")
+        project_name = project_slug.to_s.split('-').map(&:capitalize).join(' ')
+        emaillist_client.upsert_project(name: project_name)
+
+        # Upsert contact (creates if new, updates if exists)
+        contact = emaillist_client.upsert_contact(
+          project: project_slug,
+          email: email,
+          first_name: first_name,
+          last_name: last_name
+        )
+
+        # Optionally store the contact_id if column exists
+        if respond_to?(:emaillist_contact_id=) && contact && contact[:data]
+          contact_id = contact[:data][:id]
+          update_column(:emaillist_contact_id, contact_id) if persisted? && contact_id
+        end
+      rescue => e
+        # Log error
+        Rails.logger.error("Failed to sync #{self.class.name}##{id} to EmailList: #{e.message}") if defined?(Rails)
+        Rails.logger.error(e.backtrace.join("\n")) if defined?(Rails) && Rails.logger.respond_to?(:level) && Rails.logger.level <= 0
+
+        # Raise exception based on global configuration (defaults to true)
+        raise e if EmailListApi.configuration.raise_on_sync_error
+      end
+    end
+  end
+end

data/lib/email_list_api/version.rb

@@ -1,3 +1,3 @@
 module EmailListApi
-  VERSION = "0.1.0.rc.1"
+  VERSION = "0.1.0.rc.2"
 end

data/lib/email_list_api.rb

@@ -1,6 +1,31 @@
 require "email_list_api/version"
+require "email_list_api/configuration"
 require "email_list_api/client"
+require "email_list_api/syncs_email_list_contact"
 
 module EmailListApi
   class Error < StandardError; end
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+      # Reset client when configuration changes
+      @client = nil
+    end
+
+    def reset
+      @configuration = Configuration.new
+      @client = nil
+    end
+
+    def client
+      @client ||= Client.new
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: email_list_api
 version: !ruby/object:Gem::Version
-  version: 0.1.0.rc.1
+  version: 0.1.0.rc.2
 platform: ruby
 authors:
 - Email List Dev
@@ -10,47 +10,33 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: httpx
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: faraday-retry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: faraday-follow_redirects
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -80,19 +66,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '5.0'
 description: A simple Ruby client for managing projects, lists, and contacts via the
   Email List API.
 email:
@@ -101,14 +87,18 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE.txt
 - README.md
 - lib/email_list_api.rb
 - lib/email_list_api/client.rb
+- lib/email_list_api/configuration.rb
+- lib/email_list_api/syncs_email_list_contact.rb
 - lib/email_list_api/version.rb
-homepage: https://github.com/yourusername/emaillist-ruby
+homepage: https://emaillist.dev/docs
 licenses:
 - MIT
-metadata: {}
+metadata:
+  allowed_push_host: https://rubygems.org
 rdoc_options: []
 require_paths:
 - lib
@@ -116,7 +106,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="