simplyq 0.8.0rc

data/lib/simplyq/models/event.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Simplyq
+  module Model
+    class Event
+      attr_accessor :uid
+
+      attr_accessor :event_type
+
+      attr_accessor :topics
+
+      attr_accessor :payload
+
+      attr_accessor :retention_period
+
+      attr_accessor :created_at
+
+      def initialize(attributes = {})
+        self.uid = attributes[:uid] if attributes.key?(:uid)
+
+        self.event_type = attributes[:event_type] if attributes.key?(:event_type)
+
+        self.topics = attributes[:topics] if attributes.key?(:topics)
+
+        self.payload = attributes[:payload] if attributes.key?(:payload)
+
+        self.retention_period = attributes[:retention_period] if attributes.key?(:retention_period)
+
+        self.created_at = attributes[:created_at] if attributes.key?(:created_at)
+      end
+
+      # The model identifier attribute used in list operations
+      #
+      # @return [Symbol]
+      def self.identifier
+        :uid
+      end
+
+      # Serializes the object from a hash
+      #
+      # @param hash [Hash] Hash with the object data
+      # @return [Simplyq::Model::Event]
+      def self.from_hash(hash)
+        return if hash.nil?
+
+        new(hash)
+      end
+
+      # Show invalid properties with the reasons. Usually used together with valid?
+      # @return Array for valid properties with the reasons
+      def validation_errors
+        invalid_properties = []
+        if !@uid.nil? && @uid.to_s.length > 255
+          invalid_properties.push('invalid value for "uid", the character length must be smaller than or equal to 255.')
+        end
+
+        if !@uid.nil? && @uid.to_s.empty?
+          invalid_properties.push('invalid value for "uid", the character length must be great than or equal to 1.')
+        end
+
+        pattern = Regexp.new(/^[a-zA-Z0-9\-_.]+$/)
+        if !@uid.nil? && @uid !~ pattern
+          invalid_properties.push("invalid value for \"uid\", must conform to the pattern #{pattern}.")
+        end
+
+        if !@event_type.nil? && @event_type.to_s.length > 255
+          invalid_properties.push('invalid value for "event_type", the character length must be smaller than or equal to 255.')
+        end
+
+        if !@event_type.nil? && @event_type.to_s.empty?
+          invalid_properties.push('invalid value for "event_type", the character length must be great than or equal to 1.')
+        end
+
+        pattern = Regexp.new(/^[a-zA-Z0-9\-_.]+$/)
+        if !@event_type.nil? && @event_type !~ pattern
+          invalid_properties.push("invalid value for \"event_type\", must conform to the pattern #{pattern}.")
+        end
+
+        if !@retention_period.nil? && @retention_period > 90
+          invalid_properties.push('invalid value for "retention_period", must be smaller than or equal to 90.')
+        end
+
+        invalid_properties
+      end
+
+      # Check if the model is valid
+      # @return true if valid, false otherwise
+      def valid?
+        validation_errors.empty?
+      end
+
+      def [](key)
+        instance_variable_get(:"@#{key}")
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Event)
+
+        uid == other.uid &&
+          event_type == other.event_type &&
+          topics == other.topics &&
+          payload == other.payload &&
+          retention_period == other.retention_period &&
+          created_at == other.created_at
+      end
+
+      def to_h
+        {
+          uid: uid,
+          event_type: event_type,
+          topics: topics,
+          payload: _safe_parse_payload_to_hash(payload),
+          retention_period: retention_period,
+          created_at: created_at
+        }
+      end
+
+      def _safe_parse_payload_to_hash(value)
+        return if value.nil?
+        return value if value.is_a?(Hash)
+        return value.to_h if value.respond_to?(:to_h)
+
+        JSON.parse(value)
+      rescue JSON::ParserError
+        value
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+  end
+end

data/lib/simplyq/models/inbound_event.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Simplyq
+  module Model
+    class InboundEvent
+      attr_accessor :data
+
+      def initialize(data)
+        self.data = data
+      end
+
+      def self.from_hash(hash)
+        return if hash.nil?
+
+        new(hash)
+      end
+
+      def ==(other)
+        return false unless other.is_a?(InboundEvent)
+
+        data == other.data
+      end
+
+      def to_h
+        data
+      end
+
+      def [](key)
+        data[key]
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+  end
+end

data/lib/simplyq/models/list.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Simplyq
+  module Model
+    class List
+      extend Forwardable
+      include Enumerable
+
+      attr_accessor :data
+      attr_accessor :has_more
+
+      attr_accessor :data_type
+      attr_accessor :api_method
+      attr_accessor :list_args
+      attr_accessor :filters
+      attr_accessor :api
+
+      def initialize(data_type, attributes = {}, api_method:, api:, filters: {}, list_args: [])
+        self.data = if attributes.key?(:data)
+                      attributes[:data].map do |item|
+                        if data_type == Hash
+                          item
+                        else
+                          data_type.from_hash(item)
+                        end
+                      end
+                    else
+                      []
+                    end
+
+        self.has_more = attributes[:has_more]
+
+        self.data_type = data_type
+
+        self.api_method = api_method
+
+        self.filters = filters
+
+        self.list_args = list_args
+
+        self.api = api
+      end
+
+      def_delegators :data, :size, :length, :count, :empty?,
+                     :first, :last, :each_with_index, :each_with_object,
+                     :reduce, :inject, :find, :find_index, :index, :rindex
+
+      def [](key)
+        if key.is_a?(Integer)
+          data[key]
+        else
+          instance_variable_get(:"@#{key}")
+        end
+      end
+
+      # Iterates through each resource in the page represented by the current
+      # `List`.
+      #
+      # Note that this method will not attempt to fetch the next page when it
+      # reaches the end of the current page.
+      def each(&blk)
+        data.each(&blk)
+      end
+
+      # Iterates through each resource in the page represented by the current
+      # `List`.
+      #
+      # Note that this method will not attempt to fetch the next page when it
+      # reaches the end of the current page.
+      def map(&blk)
+        data.map(&blk)
+      end
+
+      def next_page
+        return nil unless has_more || !empty?
+
+        query_params = filters.dup.tap { |h| h.delete(:ending_before) }
+        query_params[:start_after] = last.send(data_type.identifier)
+        api.send(api_method, *list_args, query_params)
+      end
+
+      def prev_page
+        return nil if empty?
+
+        query_params = filters.dup.tap { |h| h.delete(:start_after) }
+        query_params[:ending_before] = first.send(data_type.identifier)
+        api.send(api_method, *list_args, query_params)
+      end
+
+      def to_h
+        {
+          data: data.map(&:to_h),
+          has_more: has_more
+        }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      # Serializes the object from a hash
+      #
+      # @param hash [Hash] Hash with the object data
+      # @return [Simplyq::Model::List]
+      def self.from_hash(hash, data_type, api:, filters: {})
+        return if hash.nil?
+
+        new(data_type, hash, api: api, filters: filters)
+      end
+
+      def ==(other)
+        return false unless other.is_a?(List)
+
+        data == other.data && has_more == other.has_more
+      end
+    end
+  end
+end

data/lib/simplyq/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Simplyq
+  VERSION = "0.8.0rc"
+end

data/lib/simplyq/webhook.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "base64"
+
+module Simplyq
+  module Webhook
+    DEFAULT_TOLERANCE = 300
+    TIMESTAMP_HEADER = "x-simplyq-timestamp"
+    SIGNATURE_HEADER = "x-simplyq-signature"
+
+    # Verify signature of webhook request
+    #
+    # @param payload_body [String] raw payload body
+    # @param signatures [String] request signature header
+    # @param timestamp [String] request timestamp header
+    # @param secret [String] your endpoint secret
+    # @param tolerance [Integer] duration before signature expires
+    #   (default: 300 seconds) replay attack protection
+    # @raise [SignatureVerificationError] if signature verification fails
+    #
+    # @return [Boolean] true if signature verification succeeds
+    def self.verify_signature(payload_body, signatures:, timestamp:, secret:, tolerance: DEFAULT_TOLERANCE)
+      Signature.verify_header(payload_body, signatures, timestamp, secret, tolerance: tolerance)
+    end
+
+    # Decerialize and verify signature of payload into an InboundEvent
+    #
+    # @param payload_body [String] raw payload body
+    # @param signatures [String] request signature header
+    # @param timestamp [String] request timestamp header
+    # @param secret [String] your endpoint secret
+    # @param tolerance [Integer] duration before signature expires
+    #   (default: 300 seconds) replay attack protection
+    # @raise [SignatureVerificationError] if signature verification fails
+    # @raise [JSON::ParserError] if payload_body is not valid JSON
+    #
+    # @return [Model::InboundEvent]
+    def self.construct_event(payload_body, signatures:, timestamp:, secret:, tolerance: DEFAULT_TOLERANCE)
+      Signature.verify_header(payload_body, signatures, timestamp, secret, tolerance: tolerance)
+
+      Model::InboundEvent.from_hash(JSON.parse(payload_body, symbolize_names: true))
+    end
+
+    module Signature
+      def self.calculate_signature(timestamp, payload, secret)
+        raise ArgumentError, "timestamp should be an instance of Time" unless timestamp.is_a?(Time)
+        raise ArgumentError, "payload should be a string" unless payload.is_a?(String)
+        raise ArgumentError, "secret should be a string" unless secret.is_a?(String)
+
+        sig = OpenSSL::HMAC.digest("SHA256", secret, "#{timestamp.to_i}#{payload}")
+        Base64.strict_encode64(sig)
+      end
+
+      def self.verify_header(payload, signatures_header, timestamp_header, secret, tolerance: nil)
+        timestamp, signatures = parse_timestampt_and_sigs(signatures_header, timestamp_header)
+
+        expected_sig = calculate_signature(timestamp, payload, secret)
+        unless signatures.any? { |sig| secure_compare(sig, expected_sig) }
+          header = { TIMESTAMP_HEADER => timestamp_header, SIGNATURE_HEADER => signatures_header }
+          raise Simplyq::SignatureVerificationError.new(
+            "No signatures found matching the expected signature for payload",
+            http_headers: header, http_body: payload
+          )
+        end
+
+        if tolerance && timestamp < Time.now - tolerance
+          header = { TIMESTAMP_HEADER => timestamp_header, SIGNATURE_HEADER => signatures_header }
+          raise SignatureVerificationError.new(
+            "Timestamp outside the tolerance zone (#{timestamp.to_i})",
+            http_headers: header, http_body: payload
+          )
+        end
+
+        true
+      end
+
+      def self.parse_timestampt_and_sigs(signatures_header, timestamp_header)
+        timestamp = Integer(timestamp_header)
+
+        signatures = signatures_header.split(",").map(&:strip)
+        raise Simplyq::SignatureVerificationError.new("No signatures found", http_headers: header) if signatures.empty?
+
+        [Time.at(timestamp), signatures]
+      end
+      private_class_method :parse_timestampt_and_sigs
+
+      # Constant time string comparison to prevent timing attacks
+      # Code borrowed from ActiveSupport
+      def self.secure_compare(str_a, str_b)
+        return false unless str_a.bytesize == str_b.bytesize
+
+        l = str_a.unpack "C#{str_a.bytesize}"
+
+        res = 0
+        str_b.each_byte { |byte| res |= byte ^ l.shift }
+        res.zero?
+      end
+      private_class_method :secure_compare
+    end
+  end
+end

data/lib/simplyq.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Version
+require_relative "simplyq/version"
+
+# API resources support classes
+require "simplyq/errors"
+require "simplyq/client"
+require "simplyq/configuration"
+require "simplyq/webhook"
+
+# API models
+require "simplyq/models/list"
+require "simplyq/models/application"
+require "simplyq/models/endpoint"
+require "simplyq/models/event"
+require "simplyq/models/delivery_attempt"
+require "simplyq/models/inbound_event"
+
+# APIs
+require "simplyq/api/application_api"
+require "simplyq/api/endpoint_api"
+require "simplyq/api/event_api"
+
+module Simplyq
+end

data/sig/simplyq.rbs

@@ -0,0 +1,4 @@
+module Simplyq
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/simplyq.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "lib/simplyq/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "simplyq"
+  spec.version = Simplyq::VERSION
+  spec.authors = ["simplyq-dxtimer"]
+  spec.email = ["ivan@simplyq.io"]
+
+  spec.summary = "The SimplyQ API client for Ruby"
+  spec.description = "The SimplyQ API client for Ruby"
+  spec.homepage = "https://github.com/simplyqio/apis"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.7"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/simplyqio/apis/tree/main/ruby"
+  spec.metadata["changelog_uri"] = "https://github.com/simplyqio/apis/tree/main/ruby/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features|examples)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "faraday", [">= 0.15", "< 2.0"]
+  spec.add_dependency "multi_json", "~> 1.0"
+  spec.add_dependency "net-http-persistent"
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+  # We are looking to automate the release process so MFA is not supported yet
+  # spec.metadata["rubygems_mfa_required"] = "true"
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: simplyq
+version: !ruby/object:Gem::Version
+  version: 0.8.0rc
+platform: ruby
+authors:
+- simplyq-dxtimer
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-11-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.15'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.15'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: net-http-persistent
+  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'
+description: The SimplyQ API client for Ruby
+email:
+- ivan@simplyq.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".tool-versions"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/simplyq.rb
+- lib/simplyq/api/application_api.rb
+- lib/simplyq/api/endpoint_api.rb
+- lib/simplyq/api/event_api.rb
+- lib/simplyq/client.rb
+- lib/simplyq/configuration.rb
+- lib/simplyq/errors.rb
+- lib/simplyq/models/application.rb
+- lib/simplyq/models/delivery_attempt.rb
+- lib/simplyq/models/endpoint.rb
+- lib/simplyq/models/event.rb
+- lib/simplyq/models/inbound_event.rb
+- lib/simplyq/models/list.rb
+- lib/simplyq/version.rb
+- lib/simplyq/webhook.rb
+- sig/simplyq.rbs
+- simplyq.gemspec
+homepage: https://github.com/simplyqio/apis
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/simplyqio/apis
+  source_code_uri: https://github.com/simplyqio/apis/tree/main/ruby
+  changelog_uri: https://github.com/simplyqio/apis/tree/main/ruby/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.3.11
+signing_key:
+specification_version: 4
+summary: The SimplyQ API client for Ruby
+test_files: []