castle-rb 4.2.1 → 7.0.0

data/lib/castle/api/authenticate.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Castle
+  module API
+    module Authenticate
+      class << self
+        # @param options [Hash]
+        # return [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
+
+          response =
+            Castle::API.call(Castle::Commands::Authenticate.build(options), {}, http, config)
+          response.merge(failover: false, failover_reason: nil)
+        rescue Castle::RequestError, Castle::InternalServerError => e
+          unless config.failover_strategy == :throw
+            strategy = (config || Castle.config).failover_strategy
+            return(
+              Castle::Failover::PrepareResponse.new(
+                options[:user_id],
+                reason: e.to_s,
+                strategy: strategy
+              ).call
+            )
+          end
+
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/castle/api/end_impersonation.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Castle
+  module API
+    # Sends DELETE impersonate request
+    module EndImpersonation
+      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::EndImpersonation.build(options), {}, http, config)
+            .tap { |response| raise Castle::ImpersonationFailed unless response[:success] }
+        end
+      end
+    end
+  end
+end

data/lib/castle/api/filter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Castle
+  module API
+    # Module for filter endpoint
+    module Filter
+      class << self
+        # @param options [Hash]
+        # return [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
+
+          response = Castle::API.call(Castle::Commands::Filter.build(options), {}, http, config)
+          response.merge(failover: false, failover_reason: nil)
+        rescue Castle::RequestError, Castle::InternalServerError => e
+          unless config.failover_strategy == :throw
+            strategy = (config || Castle.config).failover_strategy
+            return(
+              Castle::Failover::PrepareResponse.new(
+                options[:user][:id],
+                reason: e.to_s,
+                strategy: strategy
+              ).call
+            )
+          end
+
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/castle/api/get_device.rb

@@ -0,0 +1,20 @@
+# 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,20 @@
+# 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/log.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Castle
+  module API
+    # Module for log endpoint
+    module Log
+      class << self
+        # @param options [Hash]
+        # return [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
+
+          response = Castle::API.call(Castle::Commands::Log.build(options), {}, http, config)
+          response.merge(failover: false, failover_reason: nil)
+        rescue Castle::RequestError, Castle::InternalServerError => e
+          unless config.failover_strategy == :throw
+            strategy = (config || Castle.config).failover_strategy
+            return(
+              Castle::Failover::PrepareResponse.new(
+                options[:user][:id],
+                reason: e.to_s,
+                strategy: strategy
+              ).call
+            )
+          end
+
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/castle/api/report_device.rb

@@ -0,0 +1,20 @@
+# 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/risk.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Castle
+  module API
+    # Module for risk endpoint
+    module Risk
+      class << self
+        # @param options [Hash]
+        # return [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
+
+          response = Castle::API.call(Castle::Commands::Risk.build(options), {}, http, config)
+          response.merge(failover: false, failover_reason: nil)
+        rescue Castle::RequestError, Castle::InternalServerError => e
+          unless config.failover_strategy == :throw
+            strategy = (config || Castle.config).failover_strategy
+            return(
+              Castle::Failover::PrepareResponse.new(
+                options[:user][:id],
+                reason: e.to_s,
+                strategy: strategy
+              ).call
+            )
+          end
+
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/castle/api/start_impersonation.rb

@@ -0,0 +1,24 @@
+# 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 { |response| raise Castle::ImpersonationFailed unless response[:success] }
+        end
+      end
+    end
+  end
+end

data/lib/castle/api/track.rb

@@ -0,0 +1,21 @@
+# 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

@@ -1,86 +1,109 @@
 # frozen_string_literal: true
 
 module Castle
+  # Castle's client.
   class Client
     class << self
       def from_request(request, options = {})
-        new(
-          to_context(request, options),
-          to_options(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
+        new(options.merge(context: Castle::Context::Prepare.call(request, options)))
       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)
-      command = Castle::Commands::Authenticate.new(@context).build(options)
-      begin
-        Castle::API.call(command).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
 
-    def identify(options = {})
-      options = Castle::Utils.deep_symbolize_keys(options || {})
+    # @param options [Hash]
+    def track(options = {})
+      options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
 
       return unless tracked?
 
       add_timestamp_if_necessary(options)
 
-      command = Castle::Commands::Identify.new(@context).build(options)
-      Castle::API.call(command)
+      new_context = Castle::Context::Merge.call(@context, options[:context])
+
+      Castle::API::Track.call(options.merge(context: new_context, no_symbolize: true))
     end
 
-    def track(options = {})
-      options = Castle::Utils.deep_symbolize_keys(options || {})
+    # @param options [Hash]
+    def filter(options = {})
+      options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
 
-      return unless tracked?
+      return generate_do_not_track_response(options[:user][:id]) unless tracked?
 
       add_timestamp_if_necessary(options)
 
-      command = Castle::Commands::Track.new(@context).build(options)
-      Castle::API.call(command)
+      new_context = Castle::Context::Merge.call(@context, options[:context])
+
+      Castle::API::Filter.call(options.merge(context: new_context, no_symbolize: true))
     end
 
-    def impersonate(options = {})
-      options = Castle::Utils.deep_symbolize_keys(options || {})
+    # @param options [Hash]
+    def risk(options = {})
+      options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
+
+      return generate_do_not_track_response(options[:user][:id]) unless tracked?
+
       add_timestamp_if_necessary(options)
-      command = Castle::Commands::Impersonate.new(@context).build(options)
-      Castle::API.call(command).tap do |response|
-        raise Castle::ImpersonationFailed unless response[:success]
-      end
+
+      new_context = Castle::Context::Merge.call(@context, options[:context])
+
+      Castle::API::Risk.call(options.merge(context: new_context, no_symbolize: true))
+    end
+
+    # @param options [Hash]
+    def log(options = {})
+      options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
+
+      return generate_do_not_track_response(options[:user][:id]) unless tracked?
+
+      add_timestamp_if_necessary(options)
+
+      new_context = Castle::Context::Merge.call(@context, options[:context])
+
+      Castle::API::Log.call(options.merge(context: new_context, no_symbolize: true))
+    end
+
+    # @param options [Hash]
+    def start_impersonation(options = {})
+      options = Castle::Utils::DeepSymbolizeKeys.call(options || {})
+
+      add_timestamp_if_necessary(options)
+
+      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
 
     def disable_tracking
@@ -91,19 +114,23 @@ module Castle
       @do_not_track = false
     end
 
+    # @return [Boolean]
     def tracked?
       !@do_not_track
     end
 
     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
+        strategy: :allow,
+        reason: 'Castle is set to do not track.'
+      ).call
     end
 
+    # @param options [Hash]
     def add_timestamp_if_necessary(options)
       options[:timestamp] ||= @timestamp if @timestamp
     end