super_settings 1.0.2 → 2.0.1

data/lib/super_settings/storage/http_storage.rb

@@ -1,59 +1,51 @@
 # frozen_string_literal: true
 
-require "json"
-require "net/http"
-
 module SuperSettings
   module Storage
     # SuperSettings::Storage model that reads from a remote service running the SuperSettings REST API.
     # This storage engine is read only. It is intended to allow microservices to read settings from a
     # central application that exposes the SuperSettings::RestAPI.
-    class HttpStorage
+    #
+    # You must the the base_url class attribute to the base URL of a SuperSettings REST API endpoint.
+    # You can also set the timeout, headers, and query_params used in reqeusts to the API.
+    class HttpStorage < StorageAttributes
       include Storage
+      include Transaction
 
       DEFAULT_HEADERS = {"Accept" => "application/json"}.freeze
       DEFAULT_TIMEOUT = 5.0
 
+      @base_url = nil
+      @timeout = nil
       @headers = {}
       @query_params = {}
+      @http_client = nil
+      @http_client_hash = nil
 
-      attr_reader :key, :raw_value, :description, :value_type, :updated_at, :created_at
-
-      class Error < StandardError
-      end
-
-      class NotFoundError < Error
+      class HistoryStorage < HistoryAttributes
       end
 
-      class InvalidRecordError < Error
-        attr_reader :errors
-
-        def initialize(message, errors:)
-          super(message)
-          @errors = errors
-        end
-      end
-
-      class HistoryStorage
-        include SuperSettings::Attributes
-
-        attr_accessor :key, :value, :changed_by, :deleted
+      class << self
+        # Set the base URL for the SuperSettings REST API.
+        attr_accessor :base_url
 
-        def initialize(*)
-          @deleted = false
-          super
-        end
+        # Set the timeout for requests to the SuperSettings REST API.
+        attr_accessor :timeout
 
-        def created_at=(val)
-          @created_at = SuperSettings::Coerce.time(val)
-        end
+        # Add headers to this hash to add them to all requests to the SuperSettings REST API.
+        #
+        # @example
+        #
+        # SuperSettings::HttpStorage.headers["Authorization"] = "Bearer 12345"
+        attr_reader :headers
 
-        def deleted?
-          !!@deleted
-        end
-      end
+        # Add query parameters to this hash to add them to all requests to the SuperSettings REST API.
+        #
+        # @example
+        #
+        # SuperSettings::HttpStorage.query_params["access_token"] = "12345"
+        attr_reader :query_params
 
-      class << self
         def all
           call_api(:get, "/settings")["settings"].collect do |attributes|
             new(attributes)
@@ -68,9 +60,9 @@ module SuperSettings
 
         def find_by_key(key)
           record = new(call_api(:get, "/setting", key: key))
-          record.send(:set_persisted!)
+          record.persisted = true
           record
-        rescue NotFoundError
+        rescue HttpClient::NotFoundError
           nil
         end
 
@@ -79,13 +71,30 @@ module SuperSettings
           SuperSettings::Coerce.time(value)
         end
 
-        attr_accessor :base_url
+        def save_all(changes)
+          payload = []
+          changes.each do |setting|
+            setting_payload = {key: setting.key}
 
-        attr_accessor :timeout
+            if setting.deleted?
+              setting_payload[:deleted] = true
+            else
+              setting_payload[:value] = setting.value
+              setting_payload[:value_type] = setting.value_type
+              setting_payload[:description] = setting.description
+            end
 
-        attr_reader :headers
+            payload << setting_payload
+          end
 
-        attr_reader :query_params
+          begin
+            call_api(:post, "/settings", settings: payload)
+          rescue HttpClient::InvalidRecordError
+            return false
+          end
+
+          true
+        end
 
         protected
 
@@ -96,115 +105,21 @@ module SuperSettings
         private
 
         def call_api(method, path, params = {})
-          url_params = ((method == :get) ? query_params.merge(params) : query_params)
-          uri = api_uri(path, url_params)
-
-          body = nil
-          request_headers = DEFAULT_HEADERS.merge(headers)
-          if method == :post && !params&.empty?
-            body = params.to_json
-            request_headers["content-type"] = "application/json; charset=utf8-"
-          end
-
-          response = http_request(method: method, uri: uri, headers: request_headers, body: body)
-
-          begin
-            response.value # raises exception unless response is a success
-            JSON.parse(response.body)
-          rescue Net::ProtocolError
-            if [404, 410].include?(response.code.to_i)
-              raise NotFoundError.new("#{response.code} #{response.message}")
-            elsif response.code.to_i == 422
-              raise InvalidRecordError.new("#{response.code} #{response.message}", errors: JSON.parse(response.body)["errors"])
-            else
-              raise Error.new("#{response.code} #{response.message}")
-            end
-          rescue JSON::JSONError => e
-            raise Error.new(e.message)
+          if method == :post
+            http_client.post(path, params)
+          else
+            http_client.get(path, params)
           end
         end
 
-        def http_request(method:, uri:, headers: {}, body: nil, redirect_count: 0)
-          response = nil
-          http = Net::HTTP.new(uri.host, uri.port || uri.inferred_port)
-          begin
-            http.read_timeout = (timeout || DEFAULT_TIMEOUT)
-            http.open_timeout = (timeout || DEFAULT_TIMEOUT)
-            if uri.scheme == "https"
-              http.use_ssl = true
-              http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-            end
-
-            request = ((method == :post) ? Net::HTTP::Post.new(uri.request_uri) : Net::HTTP::Get.new(uri.request_uri))
-            set_headers(request, headers)
-            request.body = body if body
-
-            response = http.request(request)
-          ensure
-            begin
-              http.finish if http.started?
-            rescue IOError
-            end
-          end
-
-          if response.is_a?(Net::HTTPRedirection)
-            location = resp["location"]
-            if redirect_count < 5 && SuperSettings::Coerce.present?(location)
-              return http_request(method: :get, uri: URI(location), headers: headers, body: body, redirect_count: redirect_count + 1)
-            end
-          end
-
-          response
-        end
-
-        def api_uri(path, params)
-          uri = URI("#{base_url.chomp("/")}#{path}")
-          if params && !params.empty?
-            q = []
-            q << uri.query unless uri.query.to_s.empty?
-            params.each do |name, value|
-              q << "#{URI.encode_www_form_component(name.to_s)}=#{URI.encode_www_form_component(value.to_s)}"
-            end
-            uri.query = q.join("&")
+        def http_client
+          hash = [base_url, timeout, headers, query_params].hash
+          if @http_client.nil? || @http_client_hash != hash
+            @http_client = HttpClient.new(base_url, headers: headers, params: query_params, timeout: timeout)
+            @http_client_hash = hash
           end
-          uri
-        end
-
-        def set_headers(request, headers)
-          headers.each do |name, value|
-            name = name.to_s
-            values = Array(value)
-            request[name] = values[0].to_s
-            values[1, values.length].each do |val|
-              request.add_field(name, val.to_s)
-            end
-          end
-        end
-      end
-
-      def initialize(*)
-        @persisted = false
-        @deleted = false
-        super
-      end
-
-      def save!
-        payload = {key: key}
-        if deleted?
-          payload[:deleted] = true
-        else
-          payload[:value] = value
-          payload[:value_type] = value_type
-          payload[:description] = description
-        end
-
-        begin
-          call_api(:post, "/settings", settings: [payload])
-          set_persisted!
-        rescue InvalidRecordError
-          return false
+          @http_client
         end
-        true
       end
 
       def history(limit: nil, offset: 0)
@@ -227,50 +142,11 @@ module SuperSettings
         self
       end
 
-      def key=(value)
-        @key = (Coerce.blank?(value) ? nil : value.to_s)
-      end
-
-      def raw_value=(value)
-        @raw_value = (Coerce.blank?(value) ? nil : value.to_s)
-      end
       alias_method :value=, :raw_value=
       alias_method :value, :raw_value
 
-      def value_type=(value)
-        @value_type = (Coerce.blank?(value) ? nil : value.to_s)
-      end
-
-      def description=(value)
-        @description = (Coerce.blank?(value) ? nil : value.to_s)
-      end
-
-      def deleted=(value)
-        @deleted = Coerce.boolean(value)
-      end
-
-      def created_at=(value)
-        @created_at = SuperSettings::Coerce.time(value)
-      end
-
-      def updated_at=(value)
-        @updated_at = SuperSettings::Coerce.time(value)
-      end
-
-      def deleted?
-        !!@deleted
-      end
-
-      def persisted?
-        !!@persisted
-      end
-
       private
 
-      def set_persisted!
-        @persisted = true
-      end
-
       def call_api(method, path, params = {})
         self.class.send(:call_api, method, path, params)
       end

data/lib/super_settings/storage/json_storage.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module SuperSettings
+  module Storage
+    # This is an abstract storage class that provides support for storing settings in a JSON file.
+    # The settings are stored in JSON as an array of hashes with each hash representing a setting.
+    #
+    # Setting history should be stored in separate JSON files per key and are loaded separately
+    # from the main settings file.
+    #
+    # This class can be used as the base for any storage class where the settings are all stored
+    # together in a single JSON payload.
+    #
+    # Subclasses must implement the following methods:
+    # - self.all
+    # - self.last_updated_at
+    # - save!
+    class JSONStorage < StorageAttributes
+      include Transaction
+
+      class HistoryStorage < HistoryAttributes
+        def created_at=(val)
+          super(TimePrecision.new(val).time)
+        end
+      end
+
+      class << self
+        def all
+          parse_settings(settings_json_payload)
+        end
+
+        def updated_since(timestamp)
+          all.select { |setting| setting.updated_at > timestamp }
+        end
+
+        def find_by_key(key)
+          active.detect { |setting| setting.key == key }
+        end
+
+        def save_all(changes)
+          existing = {}
+          parse_settings(settings_json_payload).each do |setting|
+            existing[setting.key] = setting
+          end
+
+          changes.each do |setting|
+            existing[setting.key] = setting
+          end
+
+          settings = existing.values.sort_by(&:key)
+          changed_histories = {}
+          changes.collect do |setting|
+            history = (setting.new_history + setting.history).sort_by(&:created_at).reverse
+            changed_histories[setting.key] = history.collect do |history_item|
+              {
+                value: history_item.value,
+                changed_by: history_item.changed_by,
+                created_at: history_item.created_at&.iso8601(6),
+                deleted: history_item.deleted?
+              }
+            end
+            setting.new_history.clear
+          end
+
+          settings_json = JSON.dump(settings.collect(&:as_json))
+          save_settings_json(settings_json)
+
+          changed_histories.each do |setting_key, setting_history|
+            history_json = JSON.dump(setting_history)
+            save_history_json(setting_key, history_json)
+          end
+        end
+
+        # Heper method to load settings from a JSON string.
+        #
+        # @param json [String] JSON string to parse.
+        # @return [Array<SuperSettings::Storage::JSONStorage>] Array of settings.
+        def parse_settings(json)
+          return [] if Coerce.blank?(json)
+
+          JSON.parse(json).collect do |attributes|
+            setting = new(
+              key: attributes["key"],
+              raw_value: attributes["value"],
+              description: attributes["description"],
+              value_type: attributes["value_type"],
+              updated_at: Time.parse(attributes["updated_at"]),
+              created_at: Time.parse(attributes["created_at"]),
+              deleted: attributes["deleted"]
+            )
+            setting.persisted = true
+            setting
+          end
+        end
+
+        protected
+
+        # Subclasses must implement this method to return the JSON payload containing all of the
+        # settings as a string.
+        #
+        # @return [String] JSON string.
+        def settings_json_payload
+          # :nocov:
+          raise NotImplementedError
+          # :nocov:
+        end
+
+        # Subclasses must implement this method to persist the JSON payload containing all of the
+        # settings.
+        #
+        # @param json [String] JSON string to save.
+        def save_settings_json(json)
+          # :nocov:
+          raise NotImplementedError
+          # :nocov:
+        end
+
+        # Subclasses must implement this method to persist the JSON payload containing the history
+        # records for a setting key.
+        #
+        # @param key [String] Setting key.
+        # @param json [String] JSON string to save.
+        # @return [void]
+        def save_history_json(key, json)
+          # :nocov:
+          raise NotImplementedError
+          # :nocov:
+        end
+      end
+
+      def initialize(*)
+        @new_history = []
+        super
+      end
+
+      def created_at=(val)
+        super(TimePrecision.new(val).time)
+      end
+
+      def updated_at=(val)
+        super(TimePrecision.new(val).time)
+      end
+
+      def history(limit: nil, offset: 0)
+        history = fetch_history
+        limit ||= history.length
+        history[offset, limit].collect do |record|
+          HistoryItem.new(key: key, value: record.value, changed_by: record.changed_by, created_at: record.created_at, deleted: record.deleted?)
+        end
+      end
+
+      def create_history(changed_by:, created_at:, value: nil, deleted: false)
+        history = HistoryStorage.new(key: key, value: value, changed_by: changed_by, created_at: created_at, deleted: deleted)
+        @new_history.unshift(history)
+        history
+      end
+
+      attr_reader :new_history
+
+      def as_json
+        {
+          key: key,
+          value: raw_value,
+          value_type: value_type,
+          description: description,
+          created_at: created_at&.iso8601(6),
+          updated_at: updated_at&.iso8601(6),
+          deleted: deleted?
+        }
+      end
+
+      protected
+
+      # Subclasses must implement this method to return the JSON payload containing all of the
+      # history records for the setting key. The payload must be an array that contains hashes
+      # with the keys "value", "changed_by", "deleted", and "created_at".
+      def fetch_history_json
+        raise NotImplementedError
+      end
+
+      private
+
+      def fetch_history
+        json = fetch_history_json
+        history_payload = Coerce.blank?(json) ? [] : JSON.parse(json)
+
+        history_items = history_payload.collect do |attributes|
+          HistoryStorage.new(
+            key: key,
+            value: attributes["value"],
+            changed_by: attributes["changed_by"],
+            created_at: Time.parse(attributes["created_at"]),
+            deleted: attributes["deleted"]
+          )
+        end
+
+        history_items.sort_by(&:created_at).reverse
+      end
+    end
+  end
+end