castle-rb 5.0.0 → 6.0.0

data/lib/castle/api/get_device.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Castle
+  module API
+    # Sends GET devices/#{device_token} request
+    module GetDevice
+      class << self
+        # @param options [Hash]
+        # return [Hash]
+        def call(options = {})
+          options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
+          http = options.delete(:http)
+          config = options.delete(:config) || Castle.config
+
+          Castle::API.call(
+            Castle::Commands::GetDevice.build(options),
+            {},
+            http,
+            config
+          )
+        end
+      end
+    end
+  end
+end

data/lib/castle/api/get_devices_for_user.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Castle
+  module API
+    # Sends GET users/#{user_id}/devices request
+    module GetDevicesForUser
+      class << self
+        # @param options [Hash]
+        # return [Hash]
+        def call(options = {})
+          options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
+          http = options.delete(:http)
+          config = options.delete(:config) || Castle.config
+
+          Castle::API.call(
+            Castle::Commands::GetDevicesForUser.build(options),
+            {},
+            http,
+            config
+          )
+        end
+      end
+    end
+  end
+end

data/lib/castle/api/identify.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Castle
+  module API
+    module Identify
+      class << self
+        # @param options [Hash]
+        def call(options = {})
+          unless options[:no_symbolize]
+            options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
+          end
+          options.delete(:no_symbolize)
+          http = options.delete(:http)
+          config = options.delete(:config) || Castle.config
+
+          Castle::API.call(
+            Castle::Commands::Identify.build(options),
+            {},
+            http,
+            config
+          )
+        end
+      end
+    end
+  end
+end

data/lib/castle/api/report_device.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Castle
+  module API
+    # Sends PUT devices/#{device_token}/report request
+    module ReportDevice
+      class << self
+        # @param options [Hash]
+        # return [Hash]
+        def call(options = {})
+          options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
+          http = options.delete(:http)
+          config = options.delete(:config) || Castle.config
+
+          Castle::API.call(
+            Castle::Commands::ReportDevice.build(options),
+            {},
+            http,
+            config
+          )
+        end
+      end
+    end
+  end
+end

data/lib/castle/api/review.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Castle
+  module API
+    module Review
+      class << self
+        # @param options [Hash]
+        # return [Hash]
+        def call(options = {})
+          options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
+          http = options.delete(:http)
+          config = options.delete(:config) || Castle.config
+
+          Castle::API.call(
+            Castle::Commands::Review.build(options),
+            {},
+            http,
+            config
+          )
+        end
+      end
+    end
+  end
+end

data/lib/castle/api/start_impersonation.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Castle
+  module API
+    # Sends POST impersonate request
+    module StartImpersonation
+      class << self
+        # @param options [Hash]
+        def call(options = {})
+          unless options[:no_symbolize]
+            options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
+          end
+          options.delete(:no_symbolize)
+          http = options.delete(:http)
+          config = options.delete(:config) || Castle.config
+
+          Castle::API.call(
+            Castle::Commands::StartImpersonation.build(options),
+            {},
+            http,
+            config
+          ).tap do |response|
+            raise Castle::ImpersonationFailed unless response[:success]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/castle/api/track.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Castle
+  module API
+    module Track
+      class << self
+        # @param options [Hash]
+        def call(options = {})
+          unless options[:no_symbolize]
+            options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
+          end
+          options.delete(:no_symbolize)
+          http = options.delete(:http)
+          config = options.delete(:config) || Castle.config
+
+          Castle::API.call(
+            Castle::Commands::Track.build(options),
+            {},
+            http,
+            config
+          )
+        end
+      end
+    end
+  end
+end

data/lib/castle/client.rb

@@ -5,83 +5,87 @@ module Castle
     class << self
       def from_request(request, options = {})
         new(
-          to_context(request, options),
-          to_options(options)
+          options.merge(context: Castle::Context::Prepare.call(request, options))
         )
       end
-
-      def to_context(request, options = {})
-        default_context = Castle::Context::Default.new(request, options[:cookies]).call
-        Castle::Context::Merger.call(default_context, options[:context])
-      end
-
-      def to_options(options = {})
-        options[:timestamp] ||= Castle::Utils::Timestamp.call
-        warn '[DEPRECATION] use user_traits instead of traits key' if options.key?(:traits)
-        options
-      end
-
-      def failover_response_or_raise(failover_response, error)
-        return failover_response.generate unless Castle.config.failover_strategy == :throw
-
-        raise error
-      end
     end
 
     attr_accessor :context
 
-    def initialize(context, options = {})
+    # @param options [Hash]
+    def initialize(options = {})
+      options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
       @do_not_track = options.fetch(:do_not_track, false)
-      @timestamp = options[:timestamp]
-      @context = context
+      @timestamp = options.fetch(:timestamp) { Castle::Utils::GetTimestamp.call }
+      @context = options.fetch(:context) { {} }
     end
 
+    # @param options [Hash]
     def authenticate(options = {})
-      options = Castle::Utils.deep_symbolize_keys(options || {})
+      options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
 
       return generate_do_not_track_response(options[:user_id]) unless tracked?
 
       add_timestamp_if_necessary(options)
 
-      begin
-        Castle::API
-          .call(authenticate_command(options), {}, options[:http])
-          .merge(failover: false, failover_reason: nil)
-      rescue Castle::RequestError, Castle::InternalServerError => e
-        self.class.failover_response_or_raise(
-          FailoverAuthResponse.new(options[:user_id], reason: e.to_s), e
-        )
-      end
+      new_context = Castle::Context::Merge.call(@context, options[:context])
+
+      Castle::API::Authenticate.call(options.merge(context: new_context, no_symbolize: true))
     end
 
+    # @param options [Hash]
     def identify(options = {})
-      options = Castle::Utils.deep_symbolize_keys(options || {})
+      options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
 
       return unless tracked?
 
       add_timestamp_if_necessary(options)
 
-      Castle::API.call(identify_command(options), {}, options[:http])
+      new_context = Castle::Context::Merge.call(@context, options[:context])
+
+      Castle::API::Identify.call(options.merge(context: new_context, no_symbolize: true))
     end
 
+    # @param options [Hash]
     def track(options = {})
-      options = Castle::Utils.deep_symbolize_keys(options || {})
+      options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
 
       return unless tracked?
 
       add_timestamp_if_necessary(options)
 
-      Castle::API.call(track_command(options), {}, options[:http])
+      new_context = Castle::Context::Merge.call(@context, options[:context])
+
+      Castle::API::Track.call(options.merge(context: new_context, no_symbolize: true))
     end
 
-    def impersonate(options = {})
-      options = Castle::Utils.deep_symbolize_keys(options || {})
+    # @param options [Hash]
+    def start_impersonation(options = {})
+      options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
 
       add_timestamp_if_necessary(options)
 
-      Castle::API.call(impersonate_command(options), {}, options[:http]).tap do |response|
-        raise Castle::ImpersonationFailed unless response[:success]
-      end
+      new_context = Castle::Context::Merge.call(@context, options[:context])
+
+      Castle::API::StartImpersonation.call(options.merge(context: new_context, no_symbolize: true))
+    end
+
+    # @param options [Hash]
+    def end_impersonation(options = {})
+      options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
+
+      add_timestamp_if_necessary(options)
+
+      new_context = Castle::Context::Merge.call(@context, options[:context])
+
+      Castle::API::EndImpersonation.call(options.merge(context: new_context, no_symbolize: true))
+    end
+
+    # @param options [Hash]
+    def review(options = {})
+      options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
+
+      Castle::API::Review.call(options.merge(no_symbolize: true))
     end
 
     def disable_tracking
@@ -98,33 +102,15 @@ module Castle
 
     private
 
+    # @param user_id [String|Boolean]
     def generate_do_not_track_response(user_id)
-      FailoverAuthResponse.new(
+      Castle::Failover::PrepareResponse.new(
         user_id,
         strategy: :allow, reason: 'Castle is set to do not track.'
-      ).generate
-    end
-
-    # @param options [Hash]
-    def authenticate_command(options)
-      Castle::Commands::Authenticate.new(@context).build(options)
-    end
-
-    # @param options [Hash]
-    def identify_command(options)
-      Castle::Commands::Identify.new(@context).build(options)
+      ).call
     end
 
     # @param options [Hash]
-    def impersonate_command(options)
-      Castle::Commands::Impersonate.new(@context).build(options)
-    end
-
-    # @param options [Hash]
-    def track_command(options)
-      Castle::Commands::Track.new(@context).build(options)
-    end
-
     def add_timestamp_if_necessary(options)
       options[:timestamp] ||= @timestamp if @timestamp
     end

data/lib/castle/{extractors/client_id.rb → client_id/extract.rb}

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module Castle
-  module Extractors
+  module ClientId
     # used for extraction of cookies and headers from the request
-    class ClientId
+    class Extract
       # @param headers [Hash]
       # @param cookies [NilClass|Hash]
       def initialize(headers, cookies)

data/lib/castle/commands/approve_device.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Castle
+  module Commands
+    # Generates the payload for the PUT devices/#{device_token}/approve request
+    class ApproveDevice
+      class << self
+        # @param options [Hash]
+        # @return [Castle::Command]
+        def build(options = {})
+          Castle::Validators::Present.call(options, %i[device_token])
+          Castle::Command.new(
+            "devices/#{options[:device_token]}/approve",
+            nil,
+            :put
+          )
+        end
+      end
+    end
+  end
+end

data/lib/castle/commands/authenticate.rb

@@ -2,21 +2,21 @@
 
 module Castle
   module Commands
+    # Generates the payload for the authenticate request
     class Authenticate
-      def initialize(context)
-        @context = context
-      end
-
-      def build(options = {})
-        Castle::Validators::Present.call(options, %i[event])
-        context = Castle::Context::Merger.call(@context, options[:context])
-        context = Castle::Context::Sanitizer.call(context)
+      class << self
+        # @param options [Hash]
+        # @return [Castle::Command]
+        def build(options = {})
+          Castle::Validators::Present.call(options, %i[event])
+          context = Castle::Context::Sanitize.call(options[:context])
 
-        Castle::Command.new(
-          'authenticate',
-          options.merge(context: context, sent_at: Castle::Utils::Timestamp.call),
-          :post
-        )
+          Castle::Command.new(
+            'authenticate',
+            options.merge(context: context, sent_at: Castle::Utils::GetTimestamp.call),
+            :post
+          )
+        end
       end
     end
   end

data/lib/castle/commands/end_impersonation.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Castle
+  module Commands
+    # builder for impersonate command
+    class EndImpersonation
+      class << self
+        # @param options [Hash]
+        # @return [Castle::Command]
+        def build(options = {})
+          Castle::Validators::Present.call(options, %i[user_id])
+          context = Castle::Context::Sanitize.call(options[:context])
+
+          Castle::Validators::Present.call(context, %i[user_agent ip])
+
+          Castle::Command.new(
+            'impersonate',
+            options.merge(context: context, sent_at: Castle::Utils::GetTimestamp.call),
+            :delete
+          )
+        end
+  end
+    end
+  end
+end