quonfig 0.0.2

data/lib/quonfig/datadir.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Quonfig
+  # Loads a Quonfig workspace from the local filesystem (offline / datadir
+  # mode). Mirrors sdk-node/src/datadir.ts.
+  #
+  # The workspace directory layout matches integration-test-data:
+  #   <datadir>/quonfig.json
+  #   <datadir>/configs/*.json
+  #   <datadir>/feature-flags/*.json
+  #   <datadir>/segments/*.json
+  #   <datadir>/schemas/*.json
+  #   <datadir>/log-levels/*.json
+  #
+  # Each <type>/*.json file is a WorkspaceConfigDocument. The loader projects
+  # it down to the ConfigResponse shape that the SSE/HTTP delivery path emits,
+  # so ConfigStore consumes both transports uniformly.
+  module Datadir
+    CONFIG_SUBDIRS = %w[configs feature-flags segments schemas log-levels].freeze
+
+    module_function
+
+    # Read every config JSON in `datadir`, project to ConfigResponse hashes,
+    # and wrap in a ConfigEnvelope. Does no network I/O.
+    def load_envelope(datadir, environment = nil)
+      env_id = resolve_environment(File.join(datadir, 'quonfig.json'), environment)
+      configs = []
+
+      CONFIG_SUBDIRS.each do |subdir|
+        dir = File.join(datadir, subdir)
+        next unless Dir.exist?(dir)
+
+        Dir.children(dir)
+           .select { |name| name.end_with?('.json') }
+           .sort
+           .each do |filename|
+          raw = JSON.parse(File.read(File.join(dir, filename)))
+          configs << to_config_response(raw, env_id)
+        end
+      end
+
+      Quonfig::ConfigEnvelope.new(
+        configs: configs,
+        meta: { 'version' => "datadir:#{datadir}", 'environment' => env_id }
+      )
+    end
+
+    # Convenience: load the envelope and populate a fresh ConfigStore.
+    def load_store(datadir, environment = nil)
+      envelope = load_envelope(datadir, environment)
+      store = Quonfig::ConfigStore.new
+      envelope.configs.each { |cfg| store.set(cfg['key'], cfg) }
+      store
+    end
+
+    def resolve_environment(quonfig_path, environment)
+      environment ||= ENV['QUONFIG_ENVIRONMENT']
+
+      if environment.nil? || environment.empty?
+        raise ArgumentError,
+              '[quonfig] Environment required for datadir mode; set the `environment` option or QUONFIG_ENVIRONMENT env var'
+      end
+
+      unless File.exist?(quonfig_path)
+        raise ArgumentError, "[quonfig] Datadir is missing quonfig.json: #{quonfig_path}"
+      end
+
+      environments = JSON.parse(File.read(quonfig_path)).fetch('environments', [])
+
+      if !environments.empty? && !environments.include?(environment)
+        raise ArgumentError,
+              "[quonfig] Environment \"#{environment}\" not found in workspace; available environments: #{environments.join(', ')}"
+      end
+
+      environment
+    end
+
+    def to_config_response(raw, env_id)
+      environment = Array(raw['environments']).find { |e| e['id'] == env_id }
+      type = raw['type']
+
+      {
+        'id' => raw['id'] || '',
+        'key' => raw['key'],
+        'type' => type,
+        'valueType' => raw['valueType'],
+        'sendToClientSdk' => effective_send_to_client_sdk(type, raw['sendToClientSdk']),
+        'default' => raw['default'] || { 'rules' => [] },
+        'environment' => environment
+      }
+    end
+
+    def effective_send_to_client_sdk(type, raw)
+      return true if type == 'feature_flag'
+
+      raw || false
+    end
+  end
+end

data/lib/quonfig/duration.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Quonfig
+  class Duration
+    PATTERN = /P(?:(?<days>\d+(?:\.\d+)?)D)?(?:T(?:(?<hours>\d+(?:\.\d+)?)H)?(?:(?<minutes>\d+(?:\.\d+)?)M)?(?:(?<seconds>\d+(?:\.\d+)?)S)?)?/
+    MINUTES_IN_SECONDS = 60
+    HOURS_IN_SECONDS = 60 * MINUTES_IN_SECONDS
+    DAYS_IN_SECONDS = 24 * HOURS_IN_SECONDS
+
+    def initialize(definition)
+      @seconds = self.class.parse(definition)
+    end
+
+    def self.parse(definition)
+      match = PATTERN.match(definition)
+      return 0 unless match
+
+      days = match[:days]&.to_f || 0
+      hours = match[:hours]&.to_f || 0
+      minutes = match[:minutes]&.to_f || 0
+      seconds = match[:seconds]&.to_f || 0
+
+      (days * DAYS_IN_SECONDS + hours * HOURS_IN_SECONDS + minutes * MINUTES_IN_SECONDS + seconds)
+    end
+
+    def in_seconds
+      @seconds
+    end
+
+    def in_minutes
+      in_seconds / 60.0
+    end
+
+    def in_hours
+      in_minutes / 60.0
+    end
+
+    def in_days
+      in_hours / 24.0
+    end
+
+    def in_weeks
+      in_days / 7.0
+    end
+
+    def to_i
+      in_seconds.to_i
+    end
+
+    def to_f
+      in_seconds.to_f
+    end
+
+    def as_json
+      { ms:  in_seconds * 1000, seconds: in_seconds }
+    end
+  end
+end

data/lib/quonfig/encryption.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Quonfig
+  class Encryption
+    CIPHER_TYPE = "aes-256-gcm" # 32/12
+    SEPARATOR = "--"
+    AUTH_TAG_LENGTH = 16
+
+    # Hexadecimal format ensures that generated keys are representable with
+    # plain text
+    #
+    # To convert back to the original string with the desired length:
+    #   [ value ].pack("H*")
+    def self.generate_new_hex_key
+      generate_random_key.unpack("H*")[0]
+    end
+
+    def initialize(key_string_hex)
+      @key = [key_string_hex].pack("H*")
+    end
+
+    def encrypt(clear_text)
+      cipher = OpenSSL::Cipher.new(CIPHER_TYPE)
+      cipher.encrypt
+      iv = cipher.random_iv
+
+      # load them into the cipher
+      cipher.key = @key
+      cipher.iv = iv
+      cipher.auth_data = ""
+
+      # encrypt the message
+      encrypted = cipher.update(clear_text)
+      encrypted << cipher.final
+      tag = cipher.auth_tag
+      
+      # pack and join
+      [encrypted, iv, tag].map { |p| p.unpack("H*")[0] }.join(SEPARATOR)
+    end
+
+    def decrypt(encrypted_string)
+      encrypted_data, iv, auth_tag = encrypted_string.split(SEPARATOR).map { |p| [p].pack("H*") }
+      
+      # Currently the OpenSSL bindings do not raise an error if auth_tag is
+      # truncated, which would allow an attacker to easily forge it. See
+      # https://github.com/ruby/openssl/issues/63
+      if auth_tag.bytesize != AUTH_TAG_LENGTH
+        raise "truncated auth_tag"
+      end
+
+      cipher = OpenSSL::Cipher.new(CIPHER_TYPE)
+      cipher.decrypt
+      cipher.key = @key
+      cipher.iv = iv
+  
+      cipher.auth_tag = auth_tag
+     
+      # and decrypt it
+      decrypted = cipher.update(encrypted_data)
+      decrypted << cipher.final
+      decrypted
+    end
+
+    private
+
+    def self.generate_random_key
+      SecureRandom.random_bytes(key_length)
+    end
+
+    def self.key_length
+      OpenSSL::Cipher.new(CIPHER_TYPE).key_len
+    end
+  end
+end

data/lib/quonfig/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Quonfig
+  class Error < StandardError
+  end
+end

data/lib/quonfig/errors/env_var_parse_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Quonfig
+  module Errors
+    class EnvVarParseError < Quonfig::Error
+      def initialize(env_var, config, env_var_name)
+        super("Evaluating #{config.key} couldn't coerce #{env_var_name} of #{env_var} to #{config.value_type}")
+      end
+    end
+  end
+end

data/lib/quonfig/errors/initialization_timeout_error.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Quonfig
+  module Errors
+    class InitializationTimeoutError < Quonfig::Error
+      def initialize(timeout_sec, key)
+        message = "Quonfig couldn't initialize in #{timeout_sec} second timeout. Trying to fetch key `#{key}`."
+        super(message)
+      end
+    end
+  end
+end

data/lib/quonfig/errors/invalid_sdk_key_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Quonfig
+  module Errors
+    class InvalidSdkKeyError < Quonfig::Error
+      def initialize(key)
+        if key.nil? || key.empty?
+          message = 'No SDK key. Set QUONFIG_BACKEND_SDK_KEY env var or use QUONFIG_DATAFILE'
+
+          super(message)
+        else
+          message = "Your SDK key format is invalid. Expecting something like 123-development-yourapikey-SDK. You provided `#{key}`"
+
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/quonfig/errors/missing_default_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Quonfig
+  module Errors
+    class MissingDefaultError < Quonfig::Error
+      def initialize(key)
+        message = "No value found for key '#{key}' and no default was provided.\n\nIf you'd prefer returning `nil` rather than raising when this occurs, modify the `on_no_default` value you provide in your Quonfig::Options."
+
+        super(message)
+      end
+    end
+  end
+end

data/lib/quonfig/errors/missing_env_var_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Quonfig
+  module Errors
+    class MissingEnvVarError < Quonfig::Error
+      def initialize(message)
+        super(message)
+      end
+    end
+  end
+end

data/lib/quonfig/errors/type_mismatch_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Quonfig
+  module Errors
+    class TypeMismatchError < Quonfig::Error
+      def initialize(key, expected, actual_value)
+        super("Quonfig value for key '#{key}' expected #{expected}, got #{actual_value.class}: #{actual_value.inspect}")
+      end
+    end
+  end
+end

data/lib/quonfig/errors/uninitialized_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Quonfig
+  module Errors
+    class UninitializedError < Quonfig::Error
+      def initialize(key=nil)
+        message = "Use Quonfig.initialize before calling Quonfig.get #{key}"
+
+        super(message)
+      end
+    end
+  end
+end

data/lib/quonfig/evaluation.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Quonfig
+  # Records the result of evaluating a config's criteria and forensics for reporting
+  class Evaluation
+    attr_reader :value, :context
+
+    def initialize(config:, value:, value_index:, config_row_index:, context:, resolver:, conditional_value: nil)
+      @config = config
+      @value = value
+      @value_index = value_index
+      @config_row_index = config_row_index
+      @context = context
+      @resolver = resolver
+      @conditional_value = conditional_value
+    end
+
+    def reason
+      @reason ||= @conditional_value ?
+        Quonfig::Reason.compute(
+          config: @config,
+          conditional_value: @conditional_value,
+          weighted_value_index: deepest_value.weighted_value_index
+        ) :
+        Quonfig::Reason::UNKNOWN
+    end
+
+    def unwrapped_value
+      deepest_value.unwrap
+    end
+
+    def reportable_value
+      deepest_value.reportable_value
+    end
+
+    def report_and_return(evaluation_summary_aggregator)
+      report(evaluation_summary_aggregator)
+
+      unwrapped_value
+    end
+
+    private
+
+    def report(evaluation_summary_aggregator)
+      return if @config.config_type == :LOG_LEVEL
+
+      evaluation_summary_aggregator&.record(
+        config_key: @config.key,
+        config_type: @config.config_type,
+        counter: {
+          config_id: @config.id,
+          config_row_index: @config_row_index,
+          conditional_value_index: @value_index,
+          selected_value: deepest_value.reportable_wrapped_value,
+          weighted_value_index: deepest_value.weighted_value_index,
+          selected_index: nil # TODO
+        })
+    end
+
+    def deepest_value
+      @deepest_value ||= Quonfig::ConfigValueUnwrapper.deepest_value(@value, @config, @context, @resolver)
+    end
+  end
+end