reloop 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5a923721bade7783b51456350a1b02bd5a39f1ca07d99c17e78b359bf27459a7
+  data.tar.gz: b3246aa3911e52834cb6a3e4ab7053467222b2918598c550c670681b127f640d
+SHA512:
+  metadata.gz: 950029dadbf2e7fe00f38a7edcf0144e5205715d69757f2fae5d9371a07d367e6d083f2e29ed89415a00a309dfc6413ccc57502d297c8aac293d26c6b685450b
+  data.tar.gz: c9b11a03e2c41de33f3e82e6877ff0f70b970ea33e85890e4dac826668197fa941e24186ab3f377963e5b746bc27c6869ff52a758aaa07135b54a256b6b5618b

data/LICENSE

@@ -0,0 +1,36 @@
+Copyright (c) 2025 Reloop Labs
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+----------------------------------------------------------------------
+ADDITIONAL USE RESTRICTIONS (Custom Clause by Reloop Labs)
+----------------------------------------------------------------------
+
+1. You are free to use, copy, modify, and distribute this software for
+   personal use and internal company purposes.
+
+2. You are NOT permitted to:
+   - Sell, sublicense, or otherwise commercially redistribute this software.
+   - Offer this software, or any modified version of it, as a hosted service
+     (including but not limited to Software-as-a-Service, Platform-as-a-Service,
+     or any similar commercial hosting model).
+   - Use this software in any product or service whose primary purpose is to
+     compete with Reloop Labs.
+
+3. Reloop Labs offers Reloop as a hosted email service, or you may
+   self-host the open-source software on your own infrastructure.
+   There is no commercial license for third parties to resell or
+   offer competing hosted services using this software.
+
+   For questions about the license or project, contact:
+   reloop.sh@gmail.com

data/lib/reloop/client.rb

@@ -0,0 +1,58 @@
+module Reloop
+  class Error < StandardError; end
+
+  class Client
+    attr_reader :api_key, :base_url
+
+    def initialize(api_key:, base_url: "https://reloop.sh")
+      raise ArgumentError, "Reloop SDK requires an api_key" if api_key.nil? || api_key.empty?
+
+      @api_key = api_key
+      @base_url = base_url
+    end
+
+    def fetch(method, path, body = nil, params = nil)
+      conn = Faraday.new(url: @base_url) do |f|
+        f.headers["x-api-key"] = @api_key
+        f.headers["Content-Type"] = "application/json"
+        f.headers["Accept"] = "application/json"
+        f.adapter Faraday.default_adapter
+      end
+
+      response = conn.send(method) do |req|
+        req.url path
+        req.params = params if params
+        req.body = body.to_json if body
+      end
+
+      unless response.success?
+        error_body = begin
+          JSON.parse(response.body)
+        rescue StandardError
+          {}
+        end
+        raise Error, "Reloop API Error: #{response.status} #{response.reason_phrase}. #{error_body}"
+      end
+
+      return {} if response.status == 204
+
+      JSON.parse(response.body)
+    end
+
+    def api_keys
+      @api_keys ||= Services::ApiKey.new(self)
+    end
+
+    def domain
+      @domain ||= Services::Domain.new(self)
+    end
+
+    def contacts
+      @contacts ||= Services::Contacts.new(self)
+    end
+
+    def mail
+      @mail ||= Services::Mail.new(self)
+    end
+  end
+end

data/lib/reloop/services/api_key.rb

@@ -0,0 +1,52 @@
+require_relative "../support/parameters"
+
+module Reloop
+  module Services
+    class ApiKey
+      def initialize(client)
+        @client = client
+      end
+
+      def create(params)
+        @client.fetch(:post, "/api/api-key/v1/", params)
+      end
+
+      def list(params = {})
+        @client.fetch(
+          :get,
+          "/api/api-key/v1/",
+          nil,
+          Support::Parameters.for_query(params),
+        )
+      end
+
+      def get(id)
+        @client.fetch(:get, "/api/api-key/v1/#{id}")
+      end
+
+      def update(id, params)
+        @client.fetch(:patch, "/api/api-key/v1/#{id}", params)
+      end
+
+      def delete(id)
+        @client.fetch(:delete, "/api/api-key/v1/#{id}")
+      end
+
+      def rotate(id)
+        @client.fetch(:post, "/api/api-key/v1/rotate/#{id}")
+      end
+
+      def enable(id)
+        @client.fetch(:post, "/api/api-key/v1/enable/#{id}")
+      end
+
+      def disable(id)
+        @client.fetch(:post, "/api/api-key/v1/disable/#{id}")
+      end
+
+      def pause(id)
+        disable(id)
+      end
+    end
+  end
+end

data/lib/reloop/services/contact_channels.rb

@@ -0,0 +1,60 @@
+require_relative "../support/parameters"
+
+module Reloop
+  module Services
+    class ContactChannels
+      def initialize(client)
+        @client = client
+      end
+
+      def create(params)
+        @client.fetch(
+          :post,
+          "/api/contacts/v1/channels/create",
+          Support::Parameters.for_request(params),
+        )
+      end
+
+      def list(params = {})
+        @client.fetch(
+          :get,
+          "/api/contacts/v1/channels/list",
+          nil,
+          Support::Parameters.for_query(params),
+        )
+      end
+
+      def get(channel_id)
+        @client.fetch(:get, "/api/contacts/v1/channels/#{channel_id}")
+      end
+
+      def update(channel_id, params)
+        @client.fetch(
+          :patch,
+          "/api/contacts/v1/channels/#{channel_id}",
+          Support::Parameters.for_request(params),
+        )
+      end
+
+      def delete(channel_id)
+        @client.fetch(:delete, "/api/contacts/v1/channels/#{channel_id}")
+      end
+
+      def add_contact(channel_id, params)
+        @client.fetch(
+          :post,
+          "/api/contacts/channel/#{channel_id}",
+          Support::Parameters.for_request(params),
+        )
+      end
+
+      def update_subscription(channel_id, params)
+        @client.fetch(
+          :patch,
+          "/api/contacts/channel/#{channel_id}",
+          Support::Parameters.for_request(params),
+        )
+      end
+    end
+  end
+end

data/lib/reloop/services/contact_groups.rb

@@ -0,0 +1,36 @@
+require_relative "../support/parameters"
+
+module Reloop
+  module Services
+    class ContactGroups
+      def initialize(client)
+        @client = client
+      end
+
+      def add_contact(group_id, params)
+        @client.fetch(
+          :post,
+          "/api/contacts/group/#{group_id}",
+          Support::Parameters.for_request(params),
+        )
+      end
+
+      def remove_contact(group_id, params)
+        @client.fetch(
+          :delete,
+          "/api/contacts/group/#{group_id}",
+          Support::Parameters.for_request(params),
+        )
+      end
+
+      def list_contacts(group_id, params = {})
+        @client.fetch(
+          :get,
+          "/api/contacts/v1/groups/#{group_id}/contacts",
+          nil,
+          Support::Parameters.for_query(params),
+        )
+      end
+    end
+  end
+end

data/lib/reloop/services/contacts.rb

@@ -0,0 +1,115 @@
+require_relative "../support/parameters"
+require_relative "contact_groups"
+require_relative "contact_channels"
+
+module Reloop
+  module Services
+    class Contacts
+      attr_reader :groups, :channels
+
+      def initialize(client)
+        @client = client
+        @groups = ContactGroups.new(client)
+        @channels = ContactChannels.new(client)
+      end
+
+      def create(params)
+        @client.fetch(
+          :post,
+          "/api/contacts/create",
+          Support::Parameters.for_request(params),
+        )
+      end
+
+      def get(contact_id)
+        @client.fetch(:get, "/api/contacts/retrieve/#{contact_id}")
+      end
+
+      def list(params = {})
+        query = Support::Parameters.for_query(params)
+        group_id = query["groupId"] || query["group_id"]
+
+        if group_id
+          filtered = query.reject { |key, _| %w[groupId group_id].include?(key) }
+          return @groups.list_contacts(group_id, filtered)
+        end
+
+        @client.fetch(:get, "/api/contacts/list", nil, query)
+      end
+
+      def update(contact_id, params)
+        @client.fetch(
+          :patch,
+          "/api/contacts/#{contact_id}",
+          Support::Parameters.for_request(params),
+        )
+      end
+
+      def delete(contact_id)
+        @client.fetch(:delete, "/api/contacts/#{contact_id}")
+      end
+
+      def create_property(params)
+        @client.fetch(
+          :post,
+          "/api/contacts/v1/properties/create",
+          Support::Parameters.for_request(params),
+        )
+      end
+
+      def list_properties(params = {})
+        @client.fetch(
+          :get,
+          "/api/contacts/v1/properties/list",
+          nil,
+          Support::Parameters.for_query(params),
+        )
+      end
+
+      def update_property(property_id, params)
+        @client.fetch(
+          :patch,
+          "/api/contacts/v1/properties/#{property_id}",
+          Support::Parameters.for_request(params),
+        )
+      end
+
+      def delete_property(property_id)
+        @client.fetch(:delete, "/api/contacts/v1/properties/#{property_id}")
+      end
+
+      def create_group(params)
+        @client.fetch(
+          :post,
+          "/api/contacts/v1/groups/create",
+          Support::Parameters.for_request(params),
+        )
+      end
+
+      def list_groups(params = {})
+        @client.fetch(
+          :get,
+          "/api/contacts/v1/groups/list",
+          nil,
+          Support::Parameters.for_query(params),
+        )
+      end
+
+      def get_group(group_id)
+        @client.fetch(:get, "/api/contacts/v1/groups/#{group_id}")
+      end
+
+      def update_group(group_id, params)
+        @client.fetch(
+          :patch,
+          "/api/contacts/v1/groups/#{group_id}",
+          Support::Parameters.for_request(params),
+        )
+      end
+
+      def delete_group(group_id)
+        @client.fetch(:delete, "/api/contacts/v1/groups/#{group_id}")
+      end
+    end
+  end
+end

data/lib/reloop/services/domain.rb

@@ -0,0 +1,60 @@
+require_relative "../support/parameters"
+
+module Reloop
+  module Services
+    class Domain
+      def initialize(client)
+        @client = client
+      end
+
+      def create(params)
+        @client.fetch(
+          :post,
+          "/api/domain/v1/create",
+          Support::Parameters.for_snake_request(params),
+        )
+      end
+
+      def list(params = {})
+        @client.fetch(
+          :get,
+          "/api/domain/v1/list",
+          nil,
+          Support::Parameters.for_query(params),
+        )
+      end
+
+      def get(domain_id)
+        @client.fetch(:get, "/api/domain/v1/#{domain_id}")
+      end
+
+      def get_nameservers(domain_id)
+        @client.fetch(:get, "/api/domain/v1/nameservers/#{domain_id}")
+      end
+
+      def update(domain_id, params)
+        @client.fetch(
+          :patch,
+          "/api/domain/v1/#{domain_id}",
+          Support::Parameters.for_snake_request(params),
+        )
+      end
+
+      def delete(domain_id)
+        @client.fetch(:delete, "/api/domain/v1/#{domain_id}")
+      end
+
+      def verify(domain_id)
+        @client.fetch(:post, "/api/domain/v1/verify/#{domain_id}")
+      end
+
+      def forward_dns(domain_id, params)
+        @client.fetch(
+          :post,
+          "/api/domain/v1/verify/#{domain_id}/forward-dns",
+          Support::Parameters.for_snake_request(params),
+        )
+      end
+    end
+  end
+end

data/lib/reloop/services/mail.rb

@@ -0,0 +1,19 @@
+require_relative "../support/parameters"
+
+module Reloop
+  module Services
+    class Mail
+      def initialize(client)
+        @client = client
+      end
+
+      def send(params)
+        @client.fetch(
+          :post,
+          "/api/mail/v1/send",
+          Support::Parameters.for_snake_request(params),
+        )
+      end
+    end
+  end
+end

data/lib/reloop/support/parameters.rb

@@ -0,0 +1,67 @@
+module Reloop
+  module Support
+    module Parameters
+      REQUEST_KEY_MAP = {
+        "first_name" => "firstName",
+        "last_name" => "lastName",
+        "group_ids" => "groupIds",
+        "group_id" => "groupId",
+        "fallback_value" => "fallbackValue",
+        "default_subscription" => "defaultSubscription",
+        "channel_id" => "channelId",
+        "property_name" => "propertyName",
+        "property_type" => "propertyType",
+        "contact_id" => "contactId",
+        "rate_limit_enabled" => "rateLimitEnabled",
+        "user_id" => "userId",
+      }.freeze
+
+      def self.for_snake_request(params)
+        params.each_with_object({}) do |(key, value), normalized|
+          next if value.nil?
+
+          normalized[key.to_s] = value
+        end
+      end
+
+      def self.for_request(params)
+        normalized = {}
+
+        params.each do |key, value|
+          if key.to_s == "unsubscribed"
+            normalized["status"] = value ? "unsubscribed" : "subscribed" unless params.key?(:status) || params.key?("status")
+            next
+          end
+
+          api_key = REQUEST_KEY_MAP[key.to_s] || to_camel_case(key.to_s)
+          normalized[api_key] = normalize_value(value, for_request: true)
+        end
+
+        normalized.reject { |_, v| v.nil? }
+      end
+
+      def self.for_query(options)
+        for_request(options)
+      end
+
+      def self.normalize_value(value, for_request:)
+        return value unless value.is_a?(Hash)
+
+        if value.keys.all? { |key| key.is_a?(Integer) }
+          return value.map { |item| item.is_a?(Hash) ? normalize_value(item, for_request: for_request) : item }
+        end
+
+        for_request ? for_request(value) : value
+      end
+
+      def self.to_camel_case(key)
+        return REQUEST_KEY_MAP[key] if REQUEST_KEY_MAP.key?(key)
+        return key unless key.include?("_")
+
+        parts = key.split("_")
+        parts.first + parts.drop(1).map(&:capitalize).join
+      end
+      private_class_method :normalize_value, :to_camel_case
+    end
+  end
+end

data/lib/reloop.rb

@@ -0,0 +1,12 @@
+require "faraday"
+require "json"
+
+require_relative "reloop/client"
+require_relative "reloop/support/parameters"
+require_relative "reloop/services/api_key"
+require_relative "reloop/services/domain"
+require_relative "reloop/services/contacts"
+require_relative "reloop/services/mail"
+
+module Reloop
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: reloop
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Reloop Labs
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Reloop Ruby SDK for interacting with the Reloop API
+email:
+- support@reloop.sh
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/reloop.rb
+- lib/reloop/client.rb
+- lib/reloop/services/api_key.rb
+- lib/reloop/services/contact_channels.rb
+- lib/reloop/services/contact_groups.rb
+- lib/reloop/services/contacts.rb
+- lib/reloop/services/domain.rb
+- lib/reloop/services/mail.rb
+- lib/reloop/support/parameters.rb
+homepage: https://reloop.sh
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: Reloop Ruby SDK
+test_files: []