openfeature-sdk-sorbet 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5bada3dd0c6a4687fb9c7f44768f668d809a4d12fdd11439d000ed77e10340e
-  data.tar.gz: 952ebbe9649d88fd4a76cbb29af2709514d863c1be6106e73f132092a2d9d9c7
+  metadata.gz: 96650d45be9bb86f0349e27d1ad9d56c748659b3d075b6c2cc6c769fff642571
+  data.tar.gz: 370bd63d0ffb1143eec2de19d3b70e5e0b5033b4dcd0f08117dfbaeee7c1f8cd
 SHA512:
-  metadata.gz: 26655c2337a276815db33affb69d3c53c2b48dd7176c6acf6e365caa0e7b84f8899a96a786376f1a316f5aa1618cc540f8e4ac8bb6d05c38dd1011f6e94641fb
-  data.tar.gz: b0e88fc7f6f91e85294126fc23c9a58a45165bc4b7f3394c158413955fdd428c250edb82a915d2a78491e7a2c2141b86fda0ef5b1ba96552166c22fd17ba2c51
+  metadata.gz: 915afef5bdae8110b53c4e96dc9494955636753c1170349eb25f432760590fc75004ebd6f8c47bd3359da982b81fbae0c08a7053df4b552fe760f939021bdd00
+  data.tar.gz: 799b9745b26bf0eac7cdf5e54b237d63abe8f2af5e238bcaf554bd368105dc880a7cc643e5565529053baa4a7041cbc61a5c95eafcc56331ad25b6c2527883e9

data/.rubocop.yml

@@ -19,16 +19,20 @@ Layout/LineLength:
 
 Lint/UnusedMethodArgument:
   Exclude:
+    - lib/open_feature/multiple_source_provider.rb
     - lib/open_feature/no_op_provider.rb
 
 Metrics/ClassLength:
   Exclude:
     - lib/open_feature/client.rb
     - test/open_feature/client_test.rb
+    - test/open_feature/multiple_source_provider_test.rb
 
 Metrics/MethodLength:
   Exclude:
     - test/open_feature/evaluation_details_test.rb
+    - test/open_feature/multiple_source_provider_test.rb
+    - test/support/test_provider.rb
 
 Style/AccessorGrouping:
   Enabled: false

data/CHANGELOG.md

@@ -6,6 +6,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.2] - 2023-05-16
+
+### Added
+
+- Introduced `OpenFeature::MultipleSourceProvider` to allow fetching flags from multiple sources.
+
+## [0.1.1] - 2023-05-15
+
+### Changed
+
+- Expanded type of structure resolver to `T.any(T::Array[T.untyped], T::Hash[T.untyped, T.untyped])`
+
 ## [0.1.0] - 2023-05-15
 
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    openfeature-sdk-sorbet (0.1.0)
+    openfeature-sdk-sorbet (0.1.2)
       sorbet-runtime (~> 0.5)
       sorbet-struct-comparable (~> 1.3)
       zeitwerk (~> 2.6)
@@ -56,14 +56,14 @@ GEM
     rubocop-sorbet (0.7.0)
       rubocop (>= 0.90.0)
     ruby-progressbar (1.13.0)
-    sorbet (0.5.10826)
-      sorbet-static (= 0.5.10826)
-    sorbet-runtime (0.5.10826)
-    sorbet-static (0.5.10826-universal-darwin-22)
-    sorbet-static (0.5.10826-x86_64-linux)
-    sorbet-static-and-runtime (0.5.10826)
-      sorbet (= 0.5.10826)
-      sorbet-runtime (= 0.5.10826)
+    sorbet (0.5.10827)
+      sorbet-static (= 0.5.10827)
+    sorbet-runtime (0.5.10827)
+    sorbet-static (0.5.10827-universal-darwin-22)
+    sorbet-static (0.5.10827-x86_64-linux)
+    sorbet-static-and-runtime (0.5.10827)
+      sorbet (= 0.5.10827)
+      sorbet-runtime (= 0.5.10827)
     sorbet-struct-comparable (1.3.0)
       sorbet-runtime (>= 0.5)
     spoom (1.2.1)

data/README.md

@@ -43,12 +43,27 @@ structure_evaluation_details = client.fetch_structure_details(flag_key: "my_stru
 
 ### Note on `Structure`
 
-The OpenFeature specification defines [Structure as a potential return type](https://openfeature.dev/specification/types#structure). This is somewhat ambiguous in Ruby, further complicated by `T::Struct` that we get from Sorbet. For now, the type I've elected here is `T::Hash[T.untyped, T.untyped]` for flexibility but with a little more structure than a YML or JSON parsable string. This decision might change in the future upon further interpretation or new versions of the specification.
+The OpenFeature specification defines [Structure as a potential return type](https://openfeature.dev/specification/types#structure). This is somewhat ambiguous in Ruby, further complicated by `T::Struct` that we get from Sorbet. For now, the type I've elected here is `T.any(T::Array[T.untyped], T::Hash[T.untyped, T.untyped]` (loosely, either an Array of untyped members or a Hash with untyped keys and untyped values) for flexibility but with a little more structure than a YML or JSON parsable string. This decision might change in the future upon further interpretation or new versions of the specification.
 
 ### Provider Interface
 
 By default, this implementation sets the provider to the `OpenFeature::NoOpProvider` which always returns the default value. It's up to the individual teams to define their own providers based on their flag source (in the future, I'll release open-source providers based on various, common vendors).
 
+This gem also provides `OpenFeature::MultipleSourceProvider` to allow fetching flags from multiple sources. This is especially useful if your existing application has flags spread across bespoke and vendor solutions and you want to unify the evaluation sites. It can be instantiated and configured like so:
+
+```ruby
+provider = OpenFeature::MultipleSourceProvider.new(
+  providers: [
+    CustomProvider.new,
+    OpenFeature::NoOpProvider.new
+  ]
+)
+
+OpenFeature.set_provider(provider)
+```
+
+#### Implementing Custom Providers
+
 Thanks to Sorbet interfaces, it's fairly straightforward to implement a new provider. Here is an example for a JSON-based flag format on disk:
 
 ```ruby

data/lib/open_feature/client.rb

@@ -145,10 +145,10 @@ module OpenFeature
     sig do
       params(
         flag_key: String,
-        default_value: T::Hash[T.untyped, T.untyped],
+        default_value: Structure,
         context: T.nilable(EvaluationContext),
         options: T.nilable(EvaluationOptions)
-      ).returns(T::Hash[T.untyped, T.untyped])
+      ).returns(Structure)
     end
     def fetch_structure_value(flag_key:, default_value:, context: nil, options: nil) # rubocop:disable Lint/UnusedMethodArgument
       provider.resolve_structure_value(flag_key: flag_key, default_value: default_value, context: context).value
@@ -159,10 +159,10 @@ module OpenFeature
     sig do
       params(
         flag_key: String,
-        default_value: T::Hash[T.untyped, T.untyped],
+        default_value: Structure,
         context: T.nilable(EvaluationContext),
         options: T.nilable(EvaluationOptions)
-      ).returns(EvaluationDetails[T::Hash[T.untyped, T.untyped]])
+      ).returns(EvaluationDetails[Structure])
     end
     def fetch_structure_details(flag_key:, default_value:, context: nil, options: nil) # rubocop:disable Lint/UnusedMethodArgument
       details = provider.resolve_structure_value(flag_key: flag_key, default_value: default_value, context: context)

data/lib/open_feature/multiple_source_provider.rb

@@ -0,0 +1,121 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenFeature
+  # Used to pull from multiple providers.
+  # Order of the providers given to initialize matters.
+  # The providers will be evaluated in that order and the first
+  # non-error result will be used. If all sources return an error
+  # then the default value is used.
+  class MultipleSourceProvider
+    extend T::Sig
+
+    include Provider
+
+    sig { params(providers: T::Array[Provider]).void }
+    def initialize(providers:)
+      @providers = providers
+    end
+
+    sig { override.returns(ProviderMetadata) }
+    def metadata
+      ProviderMetadata.new(name: "Multiple Sources: #{providers.map(&:metadata).map(&:name).join(", ")}")
+    end
+
+    sig { override.returns(T::Array[Hook]) }
+    def hooks
+      providers.flat_map(&:hooks)
+    end
+
+    sig do
+      override
+        .params(
+          flag_key: String,
+          default_value: T::Boolean,
+          context: T.nilable(EvaluationContext)
+        )
+        .returns(ResolutionDetails[T::Boolean])
+    end
+    def resolve_boolean_value(flag_key:, default_value:, context: nil)
+      resolve_from_sources(default_value: default_value) do |provider|
+        provider.resolve_boolean_value(flag_key: flag_key, default_value: default_value)
+      end
+    end
+
+    sig do
+      override
+        .params(
+          flag_key: String,
+          default_value: Numeric,
+          context: T.nilable(EvaluationContext)
+        )
+        .returns(ResolutionDetails[Numeric])
+    end
+    def resolve_number_value(flag_key:, default_value:, context: nil)
+      resolve_from_sources(default_value: default_value) do |provider|
+        provider.resolve_number_value(flag_key: flag_key, default_value: default_value)
+      end
+    end
+
+    sig do
+      override
+        .params(
+          flag_key: String,
+          default_value: Structure,
+          context: T.nilable(EvaluationContext)
+        )
+        .returns(ResolutionDetails[Structure])
+    end
+    def resolve_structure_value(flag_key:, default_value:, context: nil)
+      resolve_from_sources(default_value: default_value) do |provider|
+        provider.resolve_structure_value(flag_key: flag_key, default_value: default_value)
+      end
+    end
+
+    sig do
+      override
+        .params(
+          flag_key: String,
+          default_value: String,
+          context: T.nilable(EvaluationContext)
+        )
+        .returns(ResolutionDetails[String])
+    end
+    def resolve_string_value(flag_key:, default_value:, context: nil)
+      resolve_from_sources(default_value: default_value) do |provider|
+        provider.resolve_string_value(flag_key: flag_key, default_value: default_value)
+      end
+    end
+
+    private
+
+    sig { returns(T::Array[Provider]) }
+    attr_reader :providers
+
+    # rubocop:disable Metrics/MethodLength
+    sig do
+      type_parameters(:U)
+        .params(
+          default_value: T.type_parameter(:U),
+          blk: T.proc.params(arg0: Provider).returns(ResolutionDetails[T.type_parameter(:U)])
+        )
+        .returns(ResolutionDetails[T.type_parameter(:U)])
+    end
+    def resolve_from_sources(default_value:, &blk)
+      successful_details = providers.each do |provider|
+        details = yield(provider)
+
+        break details if details.error_code.nil?
+      rescue StandardError
+        next
+      end
+
+      if successful_details.is_a?(ResolutionDetails)
+        successful_details
+      else
+        ResolutionDetails.new(value: default_value, error_code: ErrorCode::General, reason: "ERROR")
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+  end
+end

data/lib/open_feature/no_op_provider.rb

@@ -65,10 +65,10 @@ module OpenFeature
       override
         .params(
           flag_key: String,
-          default_value: T::Hash[T.untyped, T.untyped],
+          default_value: Structure,
           context: T.nilable(EvaluationContext)
         )
-        .returns(ResolutionDetails[T::Hash[T.untyped, T.untyped]])
+        .returns(ResolutionDetails[Structure])
     end
     def resolve_structure_value(flag_key:, default_value:, context: nil)
       ResolutionDetails.new(value: default_value, reason: "DEFAULT")

data/lib/open_feature/provider.rb

@@ -51,10 +51,10 @@ module OpenFeature
       abstract
         .params(
           flag_key: String,
-          default_value: T::Hash[T.untyped, T.untyped],
+          default_value: Structure,
           context: T.nilable(EvaluationContext)
         )
-        .returns(ResolutionDetails[T::Hash[T.untyped, T.untyped]])
+        .returns(ResolutionDetails[Structure])
     end
     def resolve_structure_value(flag_key:, default_value:, context: nil); end
   end

data/lib/open_feature/structure.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenFeature
+  Structure = T.type_alias { T.any(T::Array[T.untyped], T::Hash[T.untyped, T.untyped]) }
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openfeature-sdk-sorbet
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Max VelDink
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-05-15 00:00:00.000000000 Z
+date: 2023-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -52,7 +52,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.6'
-description:
+description: 
 email:
 - maxveldink@gmail.com
 executables: []
@@ -80,10 +80,12 @@ files:
 - lib/open_feature/evaluation_options.rb
 - lib/open_feature/flag_metadata.rb
 - lib/open_feature/hook.rb
+- lib/open_feature/multiple_source_provider.rb
 - lib/open_feature/no_op_provider.rb
 - lib/open_feature/provider.rb
 - lib/open_feature/provider_metadata.rb
 - lib/open_feature/resolution_details.rb
+- lib/open_feature/structure.rb
 - sorbet/config
 - sorbet/rbi/annotations/rainbow.rbi
 - sorbet/rbi/gems/ast@2.4.2.rbi
@@ -128,7 +130,7 @@ metadata:
   homepage_uri: https://github.com/maxveldink/openfeature-sdk-sorbet
   source_code_uri: https://github.com/maxveldink/openfeature-sdk-sorbet
   changelog_uri: https://github.com/maxveldink/openfeature-sdk-sorbet/blob/main/CHANGELOG.md
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -143,8 +145,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.12
-signing_key:
+rubygems_version: 3.4.10
+signing_key: 
 specification_version: 4
 summary: Sorbet-aware implemention of the OpenFeature specification
 test_files: []