super_settings 1.0.1 → 2.0.0

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

data/lib/super_settings/storage/mongodb_storage.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "mongo"
+
+module SuperSettings
+  module Storage
+    # MongoDB implementation of the SuperSettings::Storage model.
+    #
+    # You must define the connection URL to use by setting the `url` or `mongodb` attribute on the class.
+    #
+    # @example
+    #   SuperSettings::Storage::MongoDBStorage.url = "mongodb://user:password@localhost:27017/super_settings"
+    #
+    # @example
+    #  SuperSettings::Storage::MongoDBStorage.mongodb = Mongo::Client.new("mongodb://user:password@localhost:27017/super_settings")
+    class MongoDBStorage < StorageAttributes
+      include Storage
+      include Transaction
+
+      DEFAULT_COLLECTION_NAME = "super_settings"
+
+      @mongodb = nil
+      @url = nil
+      @url_hash = @url.hash
+      @collection_name = DEFAULT_COLLECTION_NAME
+      @mutex = Mutex.new
+
+      class HistoryStorage < HistoryAttributes
+        def as_bson
+          attributes = {
+            value: value,
+            changed_by: changed_by,
+            created_at: created_at
+          }
+          attributes[:deleted] = true if deleted?
+          attributes
+        end
+      end
+
+      class << self
+        attr_writer :url, :mongodb
+        attr_accessor :collection_name
+
+        def mongodb
+          if @mongodb.nil? || @url_hash != @url.hash
+            @mutex.synchronize do
+              unless @url_hash == @url.hash
+                @url_hash = @url.hash
+                @mongodb = Mongo::Client.new(@url)
+                create_indexes!(@mongodb)
+              end
+            end
+          end
+          @mongodb
+        end
+
+        def settings_collection
+          mongodb[collection_name]
+        end
+
+        def updated_since(time)
+          time = TimePrecision.new(time, :millisecond).time
+          settings_collection.find(updated_at: {"$gt": time}).projection(history: 0).sort({updated_at: -1}).collect do |attributes|
+            record = new(attributes)
+            record.persisted = true
+            record
+          end
+        end
+
+        def all
+          settings_collection.find.projection(history: 0).collect do |attributes|
+            record = new(attributes)
+            record.persisted = true
+            record
+          end
+        end
+
+        def find_by_key(key)
+          query = {
+            key: key,
+            deleted: false
+          }
+          record = settings_collection.find(query).projection(history: 0).first
+          new(record) if record
+        end
+
+        def last_updated_at
+          last_updated_setting = settings_collection.find.projection(updated_at: 1).sort(updated_at: -1).limit(1).first
+          last_updated_setting["updated_at"] if last_updated_setting
+        end
+
+        def destroy_all
+          settings_collection.delete_many({})
+        end
+
+        def save_all(changes)
+          upserts = changes.collect { |setting| upsert(setting) }
+          changes.each { |setting| setting.new_history.clear }
+          settings_collection.bulk_write(upserts)
+          true
+        end
+
+        protected
+
+        def default_load_asynchronous?
+          true
+        end
+
+        private
+
+        def upsert(setting)
+          doc = setting.as_bson
+          history = setting.new_history.collect(&:as_bson)
+          {
+            update_one: {
+              filter: {key: setting.key},
+              update: {
+                "$set": doc.except(:key, :history),
+                "$setOnInsert": {key: setting.key},
+                "$push": {history: {"$each": history}}
+              },
+              upsert: true
+            }
+          }
+        end
+
+        def create_indexes!(client)
+          collection = client[collection_name]
+          collection_exists = client.database.collection_names.include?(collection.name)
+          existing_indexes = (collection_exists ? collection.indexes.to_a : [])
+
+          unique_key_index = {key: 1}
+          unless existing_indexes.any? { |index| index["key"] == unique_key_index }
+            collection.indexes.create_one(unique_key_index, unique: true)
+          end
+
+          updated_at_index = {updated_at: -1}
+          unless existing_indexes.any? { |index| index["key"] == updated_at_index }
+            collection.indexes.create_one(updated_at_index)
+          end
+
+          history_created_at_desc_index = {key: 1, "history.created_at": -1}
+          unless existing_indexes.any? { |index| index["key"] == history_created_at_desc_index }
+            collection.indexes.create_one(history_created_at_desc_index)
+          end
+        end
+      end
+
+      attr_reader :new_history
+
+      def initialize(*)
+        @new_history = []
+        super
+      end
+
+      def history(limit: nil, offset: 0)
+        pipeline = [
+          {
+            "$match": {key: key}
+          },
+          {
+            "$addFields": {
+              history: {
+                "$sortArray": {
+                  input: "$history",
+                  sortBy: {created_at: -1}
+                }
+              }
+            }
+          }
+        ]
+
+        if limit || offset > 0
+          pipeline << {
+            "$addFields": {
+              history: {
+                "$slice": ["$history", offset, (limit || {"$size": "$history"})]
+              }
+            }
+          }
+        end
+
+        pipeline << {
+          "$project": {
+            _id: 0,
+            history: 1
+          }
+        }
+
+        record = self.class.settings_collection.aggregate(pipeline).to_a.first
+        return [] unless record && record["history"].is_a?(Array)
+
+        record["history"].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)
+        created_at = TimePrecision.new(created_at, :millisecond).time
+        history = HistoryStorage.new(key: key, value: value, changed_by: changed_by, created_at: created_at, deleted: deleted)
+        @new_history.unshift(history)
+        history
+      end
+
+      def created_at=(val)
+        super(TimePrecision.new(val, :millisecond).time)
+      end
+
+      def updated_at=(val)
+        super(TimePrecision.new(val, :millisecond).time)
+      end
+
+      def destroy
+        settings_collection.delete_one(key: key)
+      end
+
+      def as_bson
+        {
+          key: key,
+          raw_value: raw_value,
+          value_type: value_type,
+          description: description,
+          created_at: created_at,
+          updated_at: updated_at,
+          deleted: deleted?
+        }
+      end
+    end
+
+    def created_at=(val)
+      super(TimePrecision.new(val, :millisecond).time)
+    end
+
+    def updated_at=(val)
+      super(TimePrecision.new(val, :millisecond).time)
+    end
+  end
+end

data/lib/super_settings/storage/redis_storage.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "json"
+require "redis"
 
 module SuperSettings
   module Storage
@@ -22,20 +22,15 @@ module SuperSettings
     #
     # @example
     #   SuperSettings::Storage::RedisStorage.redis = ConnectionPool.new(size: 5) { Redis.new(url: ENV["REDIS_URL"]) }
-    class RedisStorage
-      include Storage
+    class RedisStorage < StorageAttributes
+      include Transaction
 
       SETTINGS_KEY = "SuperSettings.settings"
       UPDATED_KEY = "SuperSettings.order_by_updated_at"
 
-      class HistoryStorage
+      class HistoryStorage < HistoryAttributes
         HISTORY_KEY_PREFIX = "SuperSettings.history"
 
-        include SuperSettings::Attributes
-
-        attr_accessor :key, :value, :changed_by, :deleted
-        attr_reader :created_at
-
         class << self
           def find_all_by_key(key:, offset: 0, limit: nil)
             end_index = (limit.nil? ? -1 : offset + limit - 1)
@@ -54,10 +49,8 @@ module SuperSettings
             record
           end
 
-          def destroy_all_by_key(key)
-            RedisStorage.transaction do |redis|
-              redis.del("#{HISTORY_KEY_PREFIX}.#{key}")
-            end
+          def destroy_all_by_key(key, redis)
+            redis.del("#{HISTORY_KEY_PREFIX}.#{key}")
           end
 
           def redis_key(key)
@@ -65,24 +58,20 @@ module SuperSettings
           end
         end
 
-        def initialize(*)
-          @deleted = false
-          super
-        end
-
-        def created_at=(val)
-          @created_at = SuperSettings::Coerce.time(val)
-        end
-
         def save!
           raise ArgumentError.new("Missing key") if Coerce.blank?(key)
-          RedisStorage.transaction do |redis|
-            redis.lpush(self.class.redis_key(key), payload_json.to_json)
+
+          RedisStorage.transaction do |changes|
+            changes << self
           end
         end
 
-        def deleted?
-          !!@deleted
+        def save_to_redis(redis)
+          redis.lpush(self.class.redis_key(key), payload_json.to_json)
+        end
+
+        def created_at
+          SuperSettings::Storage::RedisStorage.time_at_microseconds(super)
         end
 
         private
@@ -91,16 +80,13 @@ module SuperSettings
           payload = {
             value: value,
             changed_by: changed_by,
-            created_at: created_at.to_f
+            created_at: SuperSettings::Storage::RedisStorage.microseconds(created_at)
           }
           payload[:deleted] = true if deleted?
           payload
         end
       end
 
-      attr_reader :key, :raw_value, :description, :value_type, :updated_at, :created_at
-      attr_accessor :changed_by
-
       class << self
         def all
           with_redis do |redis|
@@ -109,15 +95,15 @@ module SuperSettings
         end
 
         def updated_since(time)
-          time = SuperSettings::Coerce.time(time)
+          min_score = microseconds(time)
           with_redis do |redis|
-            min_score = time.to_f
             keys = redis.zrangebyscore(UPDATED_KEY, min_score, "+inf")
             return [] if keys.empty?
 
             settings = []
             redis.hmget(SETTINGS_KEY, *keys).each do |json|
-              settings << load_from_json(json) if json
+              setting = load_from_json(json) if json
+              settings << setting if setting && setting.updated_at > time
             end
             settings
           end
@@ -133,7 +119,7 @@ module SuperSettings
         def last_updated_at
           result = with_redis { |redis| redis.zrevrange(UPDATED_KEY, 0, 1, withscores: true).first }
           return nil unless result
-          Time.at(result[1])
+          time_at_microseconds(result[1])
         end
 
         def destroy_all
@@ -151,26 +137,23 @@ module SuperSettings
           end
         end
 
-        def transaction(&block)
-          if Thread.current[:super_settings_transaction_redis]
-            block.call(Thread.current[:super_settings_transaction_redis])
-          else
-            begin
-              with_redis do |redis|
-                redis.multi do |multi_redis|
-                  Thread.current[:super_settings_transaction_redis] = multi_redis
-                  Thread.current[:super_settings_transaction_after_commit] = []
-                  block.call(multi_redis)
-                end
-                after_commits = Thread.current[:super_settings_transaction_after_commit]
-                Thread.current[:super_settings_transaction_after_commit] = nil
-                after_commits.each(&:call)
+        def save_all(changes)
+          with_redis do |redis|
+            redis.multi do |multi_redis|
+              changes.each do |object|
+                object.save_to_redis(multi_redis)
               end
-            ensure
-              Thread.current[:super_settings_transaction_redis] = nil
-              Thread.current[:super_settings_transaction_after_commit] = nil
             end
           end
+          true
+        end
+
+        def time_at_microseconds(time)
+          TimePrecision.new(time, :microsecond).time
+        end
+
+        def microseconds(time)
+          TimePrecision.new(time, :microsecond).to_f
         end
 
         protected
@@ -184,7 +167,7 @@ module SuperSettings
         def load_from_json(json)
           attributes = JSON.parse(json)
           setting = new(attributes)
-          setting.send(:set_persisted!)
+          setting.persisted = true
           setting
         end
       end
@@ -205,83 +188,39 @@ module SuperSettings
         HistoryStorage.create!(key: key, value: value, deleted: deleted, changed_by: changed_by, created_at: created_at)
       end
 
-      def save!
-        self.updated_at ||= Time.now
-        self.created_at ||= updated_at
-        self.class.transaction do |redis|
-          redis.hset(SETTINGS_KEY, key, payload_json)
-          redis.zadd(UPDATED_KEY, updated_at.to_f, key)
-          set_persisted!
-        end
-        true
+      def save_to_redis(redis)
+        redis.hset(SETTINGS_KEY, key, payload_json)
+        redis.zadd(UPDATED_KEY, self.class.microseconds(updated_at), key)
       end
 
       def destroy
-        self.class.transaction do |redis|
-          redis.hdel(SETTINGS_KEY, key)
-          redis.zrem(UPDATED_KEY, key)
-          HistoryStorage.destroy_all_by_key(key)
+        self.class.with_redis do |redis|
+          redis.multi do |multi_redis|
+            multi_redis.hdel(SETTINGS_KEY, key)
+            multi_redis.zrem(UPDATED_KEY, key)
+            HistoryStorage.destroy_all_by_key(key, multi_redis)
+          end
         end
       end
 
-      def key=(value)
-        @key = (Coerce.blank?(value) ? nil : value.to_s)
+      def created_at
+        self.class.time_at_microseconds(super)
       end
 
-      def raw_value=(value)
-        @raw_value = (Coerce.blank?(value) ? nil : value.to_s)
-      end
-
-      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
+      def updated_at
+        self.class.time_at_microseconds(super)
       end
 
       private
 
-      def after_commit(&block)
-        if Thread.current[:super_settings_transaction_after_commit]
-          Thread.current[:super_settings_transaction_after_commit] << block
-        else
-          block.call
-        end
-      end
-
-      def set_persisted!
-        @persisted = true
-      end
-
       def payload_json
         payload = {
           key: key,
           raw_value: raw_value,
           value_type: value_type,
           description: description,
-          created_at: created_at.to_f,
-          updated_at: updated_at.to_f
+          created_at: self.class.microseconds(created_at),
+          updated_at: self.class.microseconds(updated_at)
         }
         payload[:deleted] = true if deleted?
         payload.to_json