cognito-client 0.4.1 → 0.5.0

data/lib/cognito/client/document.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+class Cognito
+  class Client
+    class Document
+      include Anima.new(:data, :included), Adamantium
+
+      def initialize(data:, included: [])
+        super
+      end
+
+      def resolve(resource_object)
+        lookup.fetch(resource_object).first
+      end
+
+      def include(resource)
+        with(included: included + resource.included)
+      end
+
+      private
+
+      def lookup
+        resources.group_by(&ResourceIdentifier)
+      end
+      memoize(:lookup)
+
+      def resources
+        included + [data]
+      end
+      memoize :resources
+    end # Document
+  end # Client
+end # Cognito

data/lib/cognito/client/params.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+class Cognito
+  class Client
+    class Params
+      include Procto.call(:to_h),
+              AbstractType,
+              Adamantium
+
+      abstract_method :to_h
+    end # Params
+    private_constant(:Params)
+  end # Client
+end # Cognito

data/lib/cognito/client/params/identity.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Cognito
+  class Client
+    class Params
+      class Identity < self
+        include AbstractType, Anima.new(:name, :phone_number)
+
+        abstract_method :relationships
+
+        def to_h
+          relationship_params.tap do |params|
+            params[:data][:attributes] = attributes unless attributes.empty?
+          end
+        end
+
+        def relationship_params
+          {
+            data: {
+              type:          self.class::TYPE,
+              relationships: relationships
+            }
+          }
+        end
+
+        private
+
+        def attributes
+          full_attributes.reject { |_, val| val.instance_of?(Omitted) }
+        end
+        memoize :attributes
+
+        def full_attributes
+          {
+            name:  name,
+            phone: phone
+          }
+        end
+
+        def phone
+          return phone_number if phone_number.instance_of?(Omitted)
+
+          { number: phone_number }
+        end
+      end # Identity
+    end # Params
+  end # Client
+end # Cognito

data/lib/cognito/client/params/identity_assessment.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Cognito
+  class Client
+    class Params
+      class IdentityAssessment < Identity
+        include anima.add(:identity_search_identifier)
+
+        TYPE = 'identity_assessment'
+
+        private
+
+        def relationships
+          {
+            identity_search: {
+              data: identity_search_identifier
+            }
+          }
+        end
+      end # IdentityAssessment
+    end # Params
+  end # Client
+end # Cognito

data/lib/cognito/client/params/identity_search.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Cognito
+  class Client
+    class Params
+      class IdentitySearch < Identity
+        include anima.add(:profile_id)
+
+        TYPE              = 'identity_search'
+        RELATIONSHIP_TYPE = 'profile'
+
+        def relationships
+          {
+            profile: {
+              data: {
+                type: RELATIONSHIP_TYPE,
+                id:   profile_id
+              }
+            }
+          }
+        end
+      end # IdentitySearch
+    end # Params
+  end # Client
+end # Cognito

data/lib/cognito/client/params/omitted.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+class Cognito
+  class Client
+    class Params
+      # Helpful type for clarifying when a caller intentionally omitted a param
+      Omitted = Class.new
+    end # Params
+  end # Client
+end # Cognito

data/lib/cognito/client/request.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+class Cognito
+  class Client
+    class Request
+      CONSTANT_HEADERS = IceNine.deep_freeze(
+        'Content-Type' => 'application/vnd.api+json'
+      )
+
+      include Anima.new(:verb, :endpoint, :data, :headers), Adamantium
+
+      def self.post(*arguments)
+        build(:post, *arguments)
+      end
+
+      def self.get(endpoint)
+        build(:get, endpoint, nil)
+      end
+
+      def self.build(verb, endpoint, data)
+        new(
+          verb:     verb,
+          endpoint: endpoint,
+          data:     data,
+          headers:  CONSTANT_HEADERS
+        )
+      end
+      private_class_method :build
+
+      def sign(**signature_params)
+        with(headers: SigningHeaders.call(request: self, **signature_params))
+      end
+
+      class SigningHeaders
+        include Procto.call(:to_h), Anima.new(:request, :date, :api_key, :api_secret), Adamantium
+
+        DIGEST_HEADER = 'SHA-256=%<digest>s'
+        EMPTY_BODY    = ''
+        SHA256        = IceNine.deep_freeze(OpenSSL::Digest::SHA256.new)
+
+        AUTHORIZATION_STRING = [
+          'Signature keyId="%<api_key>s"',
+          'algorithm="hmac-sha256"',
+          'headers="date digest (request-target)"',
+          'signature="%<signature>s"'
+        ].join(',').freeze
+
+        SIGNING_STRING = [
+          'date: %<date>s',
+          'digest: %<digest>s',
+          '(request-target): %<request_target>s'
+        ].join("\n").freeze
+
+        def to_h
+          request.headers.merge(
+            'Authorization' => auth_header,
+            'Digest'        => digest_header,
+            'Date'          => date
+          )
+        end
+
+        private
+
+        def auth_header
+          format(AUTHORIZATION_STRING, api_key: api_key, signature: signature)
+        end
+
+        def signature
+          Base64.strict_encode64(OpenSSL::HMAC.digest(SHA256, api_secret, signing_string))
+        end
+
+        def signing_string
+          format(SIGNING_STRING, date: date, digest: digest_header, request_target: request_target)
+        end
+
+        def digest_header
+          format(DIGEST_HEADER, digest: digest)
+        end
+
+        def request_target
+          "#{request.verb} #{request.endpoint}"
+        end
+
+        def digest
+          Base64.strict_encode64(SHA256.digest(request_body))
+        end
+        memoize :digest
+
+        def request_body
+          return EMPTY_BODY unless request.data
+
+          JSON.dump(request.data)
+        end
+
+        private_constant(*constants(false))
+      end # SigningHeaders
+    end # Request
+  end # Client
+end # Cognito

data/lib/cognito/client/resource.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+class Cognito
+  class Client
+    class Resource
+      include AbstractType,
+              Memoizable,
+              Anima.new(:id, :type, :attributes, :relationships, :parent)
+
+      class MissingRelation < StandardError
+        MESSAGE = "Registered relation key, '%s', not in relationships"\
+                  ' for resource: %p'
+
+        def initialize(key, resource)
+          super(format(MESSAGE, *[key, resource]))
+        end
+      end # MissingRelation
+
+      def self.register_type(type)
+        REGISTRY.add(type, self)
+      end
+      private_class_method :register_type
+
+      # ignores :reek:TooManyStatements:
+      def self.one(key)
+        define_relationship(key) do
+          identifier = relationship_data(key)
+          return unless identifier
+
+          find_identifier(identifier)
+        end
+      end
+      private_class_method :one
+
+      def self.many(key)
+        define_relationship(key) do
+          relationship_data(key).map(&method(:find_identifier))
+        end
+      end
+      private_class_method :many
+
+      def self.attribute(key, method_name = key)
+        define_method(method_name) do
+          attributes[key]
+        end
+      end
+
+      def self.define_relationship(key, &block)
+        memoize(define_method(key, &block))
+      end
+      private_class_method :define_relationship
+
+      def self.build(data, parent)
+        new(data.merge(parent: parent))
+      end
+
+      def include(resource)
+        with(parent: parent.include(resource))
+      end
+
+      def included
+        parent.included
+      end
+
+      def initialize(relationships: nil, **options)
+        super
+      end
+
+      protected
+
+      def resolve(identifier)
+        parent.resolve(identifier)
+      end
+
+      private
+
+      def find_identifier(identifier)
+        resource_class = REGISTRY.lookup(identifier.fetch(:type).to_sym)
+        resource_class.build(resolve(identifier), self)
+      end
+
+      def relationship_data(key)
+        fail MissingRelation.new(key, self) unless relationships && relationships.key?(key)
+
+        relationships.fetch(key).fetch(:data)
+      end
+
+      class Registry
+        include Concord.new(:registry)
+
+        class Error < StandardError
+          def initialize(type)
+            super(format(self.class::MESSAGE, type: type))
+          end
+        end # Error
+
+        class MissingError < Error
+          MESSAGE = 'Resource type not registered: %<type>s'
+        end # MissingError
+
+        class DuplicateTypeError < Error
+          MESSAGE = 'Resource type already registered: %<type>s'
+        end # DuplicateTypeError
+
+        def initialize
+          super({})
+        end
+
+        def lookup(type)
+          registry.fetch(type) do
+            fail MissingError, type
+          end
+        end
+
+        def add(type, resource_class)
+          fail DuplicateTypeError, type if registry.key?(type)
+
+          registry[type] = resource_class
+        end
+      end # Registry
+
+      REGISTRY = Registry.new
+    end # Resource
+  end # Client
+end # Cognito

data/lib/cognito/client/resource/identity_assessment.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+class Cognito
+  class Client
+    class Resource
+      class IdentityAssessment < self
+        register_type :identity_assessment
+
+        attribute :name
+        attribute :phone
+
+        many :identity_record_comparisons
+      end # IdentityAssessment
+
+      class IdentityRecordComparison < self
+        register_type :identity_record_comparison
+
+        many :name_comparisons
+        many :phone_comparisons
+        one :identity_record
+
+        attribute :score
+      end # IdentityRecordComparison
+
+      class PhoneComparison < self
+        register_type :phone_comparison
+
+        attribute :score
+
+        one :source_record
+      end # PhoneComparison
+
+      class NameComparison < self
+        register_type :name_comparison
+
+        attribute :score
+
+        one :source_record
+
+        class Components
+          include Anima.new(:first, :middle, :last), Adamantium
+
+          class Component
+            include Anima.new(:source, :input, :score)
+
+            class Name
+              include Concord.new(:name), Adamantium
+            end # Name
+          end # Component
+        end # Components
+      end # NameComparison
+    end # Resource
+  end # Client
+end # Cognito

data/lib/cognito/client/resource/identity_search.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+class Cognito
+  class Client
+    class Resource
+      class IdentitySearch < self
+        register_type :identity_search
+
+        many :identity_records
+      end # IdentitySearch
+
+      class IdentityRecord < self
+        register_type :identity_record
+
+        many :addresses
+        many :names
+        many :ssns
+        many :phones
+        many :births
+        many :deaths
+      end # IdentityRecord
+
+      class USAddress < self
+        register_type :us_address
+
+        attribute :street
+        attribute :city
+        attribute :subdivision
+        attribute :postal_code
+      end # USAddress
+
+      class PartialName < self
+        register_type :name
+
+        attribute :first
+        attribute :middle
+        attribute :last
+      end # PartialName
+
+      class SSN < self
+        register_type :ssn
+
+        attribute :number
+      end # SSN
+
+      class Phone < self
+        register_type :phone
+      end # Phone
+
+      class PartialDate < self
+        attribute :day
+        attribute :month
+        attribute :year
+      end # PartialDate
+
+      class Birth < PartialDate
+        register_type :birth
+      end # Birth
+
+      class Death < PartialDate
+        register_type :death
+      end # Death
+    end # Resource
+  end # Client
+end # Cognito