quonfig-openfeature 1.1.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 518ef7e90608d00dc60292d93fa9c9b6a14037df9194597a1cc309a4c02ea166
-  data.tar.gz: bc52ae8cda109bd7aa20dcc5e0a235716a503d497987d4000d45a97ae6541bba
+  metadata.gz: cd942b88517b56c8ff6d676684e0f1c27fbd5fd62c96c15964af1239d0ac2fe6
+  data.tar.gz: bff802046f4d1ec5c0422e93f7c13a28edeb98178f2703354511976dc4c3384e
 SHA512:
-  metadata.gz: '080feecf4971e26beff1c05427d6ffa0d9c494c26696968502ae7fe8ea462e6eb770a1a57d6486bf8d39093133902b8672cebea3f3f4cd3fc4a92ed0355ba5ae'
-  data.tar.gz: e783174efaa4e7c8577259bec7ebaa7ccc3eb1f900a844fed68e1449cabffeada4b2925fc5d650f15c51c52d27da35a79380bec8d716e6cf4259bd4f5d93ee6b
+  metadata.gz: 57db850f4f8384be2cc8b47e690ff363876d9ab51a5c7e80468880b3cf9b4607b7263f9081b965feef1dc6cc3e3c0594180153cb67cf9a5317fb7025562e70a9
+  data.tar.gz: 56bb8b4420465725dd15303de581c254abae3d5f27a98205463dbed394f9cc9848ae47c61d97f7ac89962d707fa35ae8ed6d8c05fb66c2f9e0a50050c434123f

data/CHANGELOG.md

@@ -1,5 +1,69 @@
 # Changelog
 
+## 2.1.0 - 2026-10-28
+
+A malformed value now resolves with error code `PARSE_ERROR` instead of `TYPE_MISMATCH`
+(qfg-9xsl, mirrors integration-test-data `tests/openfeature/openfeature.yaml` Case 6). You still
+get your default with reason `ERROR`. This covers a value of a type the `fetch_*` method reads that
+does not parse:
+
+- a stored int `"twelve"` or double `"abc"`;
+- an int or double provided by an ENV_VAR set to an unparseable string, such as `"twelve"`;
+- a malformed stored duration such as `"30s"`, read with `fetch_string_value`.
+
+A read with the method for another type (an int config read with `fetch_boolean_value`) stays
+`TYPE_MISMATCH`, as does a number that parses but does not convert exactly (`fetch_integer_value`
+on `3.9`). sdk-ruby's `*_details` report both cases as `TYPE_MISMATCH`, so the provider tells them
+apart: on a `TYPE_MISMATCH` it checks the config's stored `valueType` and, if the method can read
+that type, reads it with the native getter for that type. If that read fails too, the value is
+malformed. This extra read happens only on the error path.
+
+If you alert or branch on `TYPE_MISMATCH` for bad config data, match `PARSE_ERROR` as well.
+
+## 2.0.0 - 2026-10-27
+
+**BREAKING / UPGRADE (major, qfg-zvyy.6).** This release tracks sdk-ruby 2.0.0, the cross-SDK
+typed-getter contract. Require `quonfig` (sdk-ruby) `>= 2.0.0` (floor raised from `>= 1.11.0`). No
+change to this provider's code: it passes through the SDK's `*_details` results, so provider users
+inherit the contract below.
+
+### UPGRADE to 2.0
+
+A value a `fetch_*` method cannot read as its type returns your default with reason `ERROR` and
+error code `TYPE_MISMATCH`. Strings are never coerced, and the only number conversions are exact
+ones. What changes for provider users:
+
+- `fetch_float_value` on an int config now returns the value (`30` -> `30.0`). 1.x returned your
+  default with `TYPE_MISMATCH`.
+- `fetch_integer_value` on a double config returns the value when it is whole and within
+  +/-(2^53-1) (`3.0` -> `3`). 1.x returned your default for every double. `3.9`, `2^53` and `1e300`
+  still return your default with `TYPE_MISMATCH`, never truncated.
+- `fetch_number_value` on a `duration` config returns your default with `TYPE_MISMATCH`. 1.x
+  returned the duration in milliseconds (`30000`, reason `STATIC`). Durations are native-only: use
+  `provider.client.get_duration` (integer milliseconds). `fetch_float_value` on a duration already
+  returned your default.
+- A malformed stored int or double (for example `"twelve"`) or a malformed ENV_VAR value returns
+  your default with error code `TYPE_MISMATCH`, as in sdk-go. 1.x reported `GENERAL`. An unset
+  ENV_VAR still returns your default with `GENERAL`.
+- sdk-ruby logs one WARN per key per client when a read returns your default because of a type
+  mismatch, a malformed value, an unset ENV_VAR or a decryption failure. The line names the key and
+  types, never the value. A wrong decryption key now degrades to your defaults with these WARNs.
+- If you call the native client via `provider.client`: typed getters with a `default:` return the
+  default instead of raising, `enabled?` is true only for the bool `true` and never raises, and
+  `get_bool` on a stored string `"true"` is a type mismatch. See the sdk-ruby CHANGELOG
+  "UPGRADE to 2.0".
+
+These already held under 1.11.0 through the provider, and the new tests now pin them: a stored
+string `"true"` / `"false"` read as a boolean, a stored `"3"` read as a number, an int or bool read as
+a string, an int read as a boolean, and a string or bool read as an object all return your default
+with `TYPE_MISMATCH`.
+
+### Tests
+
+- New `test/integration/test_typed_getter_contract.rb` (31 tests) drives the real provider through
+  the OpenFeature client against the integration-test-data `getter.contract.*` fixtures. 7 of the 31
+  fail on sdk-ruby 1.11.0; all pass on 2.0.0.
+
 ## 1.1.0 - 2026-10-23
 
 - **UPGRADE: raise the `quonfig` floor from `>= 1.10.0` to `>= 1.11.0`. Requires sdk-ruby 1.11.0:

data/README.md

@@ -134,13 +134,32 @@ Quonfig features require the native `quonfig` SDK:
 
 1. **Log levels** -- `should_log?` and the `semantic_logger_filter` are native-only.
 2. **`string_list` configs** -- accessed via `fetch_object_value` and used as `Array<String>`.
-3. **`duration` configs** -- exposed only via the native `get_duration` (returns milliseconds).
+3. **`duration` configs** -- native-only: read them with `provider.client.get_duration` (integer
+   milliseconds). `fetch_float_value` and `fetch_number_value` on a duration config return your
+   default with `TYPE_MISMATCH`.
 4. **`bytes` configs** -- not accessible via OpenFeature (no binary type in OF).
 5. **`keys` / raw config inspection** -- native-only via `provider.client`.
 6. **Context keys use dot-notation** -- `"user.email"`, not nested hashes.
 7. **`targeting_key` maps to `user.id` by default** -- configure
    `targeting_key_mapping` if you target a different namespace.
 
+## Typed reads
+
+Each `fetch_*` method reads only values of its type (the cross-SDK typed-getter contract,
+`quonfig` >= 2.0.0). A value of another type returns your default with reason `ERROR` and error
+code `TYPE_MISMATCH`:
+
+- A stored string is never coerced: `"false"` is not a boolean and `"3"` is not a number.
+- Numbers convert only when exact: `fetch_float_value` on an int config returns `30.0`, and
+  `fetch_integer_value` on a double config returns the value only when it is whole and within
+  +/-(2^53-1) (`3.0` -> `3`; `3.9` is a mismatch, never truncated).
+- A malformed value of a type the method reads returns your default with `PARSE_ERROR`: a stored
+  int `"twelve"`, an int or double ENV_VAR set to `"twelve"`, or a stored duration `"30s"` read
+  with `fetch_string_value`. A read with the method for another type stays `TYPE_MISMATCH`. An
+  unset ENV_VAR returns your default with `GENERAL`.
+
+sdk-ruby logs one WARN per key when a read returns your default for one of these reasons.
+
 ## Offline / test mode
 
 Pass `datadir:` to evaluate against a Quonfig workspace on disk -- the same

data/VERSION

@@ -1 +1 @@
-1.1.0
+2.1.0

data/lib/quonfig/openfeature/provider.rb

@@ -56,6 +56,32 @@ module Quonfig
       ErrorCode         = ::OpenFeature::SDK::Provider::ErrorCode
       ProviderMetadata  = ::OpenFeature::SDK::Provider::ProviderMetadata
 
+      # The stored +valueType+s each fetch method can read: its own type plus
+      # the ones it converts exactly (int <-> double, duration -> ISO string).
+      # A TYPE_MISMATCH on a config of one of these types means the value
+      # did not parse, so it is reported as PARSE_ERROR (qfg-9xsl).
+      READABLE_VALUE_TYPES = {
+        boolean: %w[bool],
+        string: %w[string log_level duration],
+        integer: %w[int double],
+        float: %w[double int],
+        number: %w[int double],
+        object: %w[string_list json]
+      }.freeze
+
+      # The native details getter that reads each stored +valueType+ as itself.
+      NATIVE_DETAILS_GETTER = {
+        'bool' => :get_bool_details,
+        'string' => :get_string_details,
+        'log_level' => :get_string_details,
+        'duration' => :get_duration_details,
+        'int' => :get_int_details,
+        'double' => :get_float_details,
+        'string_list' => :get_string_list_details,
+        'json' => :get_json_details
+      }.freeze
+      private_constant :READABLE_VALUE_TYPES, :NATIVE_DETAILS_GETTER
+
       attr_reader :metadata, :targeting_key_mapping
 
       # @param sdk_key [String, nil] SDK key for the live delivery service.
@@ -117,13 +143,15 @@ module Quonfig
 
       def fetch_boolean_value(flag_key:, default_value:, evaluation_context: nil)
         evaluate(flag_key, default_value, evaluation_context) do |client, mapped_ctx|
-          to_resolution(client.get_bool_details(flag_key, context: mapped_ctx), default_value)
+          details = client.get_bool_details(flag_key, context: mapped_ctx)
+          to_resolution(details, default_value, parse_error: malformed?(client, flag_key, mapped_ctx, :boolean, details))
         end
       end
 
       def fetch_string_value(flag_key:, default_value:, evaluation_context: nil)
         evaluate(flag_key, default_value, evaluation_context) do |client, mapped_ctx|
-          to_resolution(client.get_string_details(flag_key, context: mapped_ctx), default_value)
+          details = client.get_string_details(flag_key, context: mapped_ctx)
+          to_resolution(details, default_value, parse_error: malformed?(client, flag_key, mapped_ctx, :string, details))
         end
       end
 
@@ -134,19 +162,21 @@ module Quonfig
         evaluate(flag_key, default_value, evaluation_context) do |client, mapped_ctx|
           details = client.get_int_details(flag_key, context: mapped_ctx)
           details = client.get_float_details(flag_key, context: mapped_ctx) if details.error_code == ::Quonfig::EvaluationDetails::ERROR_TYPE_MISMATCH
-          to_resolution(details, default_value)
+          to_resolution(details, default_value, parse_error: malformed?(client, flag_key, mapped_ctx, :number, details))
         end
       end
 
       def fetch_integer_value(flag_key:, default_value:, evaluation_context: nil)
         evaluate(flag_key, default_value, evaluation_context) do |client, mapped_ctx|
-          to_resolution(client.get_int_details(flag_key, context: mapped_ctx), default_value)
+          details = client.get_int_details(flag_key, context: mapped_ctx)
+          to_resolution(details, default_value, parse_error: malformed?(client, flag_key, mapped_ctx, :integer, details))
         end
       end
 
       def fetch_float_value(flag_key:, default_value:, evaluation_context: nil)
         evaluate(flag_key, default_value, evaluation_context) do |client, mapped_ctx|
-          to_resolution(client.get_float_details(flag_key, context: mapped_ctx), default_value)
+          details = client.get_float_details(flag_key, context: mapped_ctx)
+          to_resolution(details, default_value, parse_error: malformed?(client, flag_key, mapped_ctx, :float, details))
         end
       end
 
@@ -157,7 +187,7 @@ module Quonfig
         evaluate(flag_key, default_value, evaluation_context) do |client, mapped_ctx|
           details = client.get_string_list_details(flag_key, context: mapped_ctx)
           details = client.get_json_details(flag_key, context: mapped_ctx) if details.error_code == ::Quonfig::EvaluationDetails::ERROR_TYPE_MISMATCH
-          to_resolution(details, default_value)
+          to_resolution(details, default_value, parse_error: malformed?(client, flag_key, mapped_ctx, :object, details))
         end
       end
 
@@ -198,10 +228,37 @@ module Quonfig
         end
       end
 
+      # True when +details+ is a TYPE_MISMATCH for a config whose value has a
+      # type +kind+ can read but did not parse: a stored int "twelve", an int
+      # ENV_VAR set to "twelve", a duration "30s" (qfg-9xsl). sdk-ruby's
+      # *_details report a malformed value and a wrong-type read alike as
+      # TYPE_MISMATCH, so this checks the stored +valueType+ and reads the
+      # config with the getter for that type: if that read fails too, the
+      # value is malformed. A config of a type +kind+ cannot read stays
+      # TYPE_MISMATCH, and so does a value that parsed but does not convert
+      # exactly (fetch_integer_value on a 3.9 double).
+      def malformed?(client, flag_key, mapped_ctx, kind, details)
+        return false unless details.error_code == ::Quonfig::EvaluationDetails::ERROR_TYPE_MISMATCH
+
+        value_type = stored_value_type(client, flag_key)
+        return false unless READABLE_VALUE_TYPES.fetch(kind).include?(value_type)
+
+        native = client.public_send(NATIVE_DETAILS_GETTER.fetch(value_type), flag_key, context: mapped_ctx)
+        native.error_code == ::Quonfig::EvaluationDetails::ERROR_TYPE_MISMATCH
+      end
+
+      def stored_value_type(client, flag_key)
+        config = client.store.get(flag_key)
+        return nil unless config.is_a?(Hash)
+
+        (config['valueType'] || config[:valueType] || config['value_type'] || config[:value_type])&.to_s
+      end
+
       # Map a Quonfig::EvaluationDetails to the OpenFeature ResolutionDetails
       # the SDK consumes. The Quonfig SDK's *_details methods don't raise, so
-      # this is a pure mapping layer.
-      def to_resolution(details, default_value)
+      # this is a pure mapping layer. +parse_error+ reports an ERROR as
+      # PARSE_ERROR (see #malformed?).
+      def to_resolution(details, default_value, parse_error: false)
         variant = details.variant
         flag_metadata = details.flag_metadata || {}
         case details.reason
@@ -221,7 +278,7 @@ module Quonfig
           ResolutionDetails.new(
             value: default_value,
             reason: Reason::ERROR,
-            error_code: map_error_code(details.error_code),
+            error_code: parse_error ? ErrorCode::PARSE_ERROR : map_error_code(details.error_code),
             error_message: details.error_message,
             variant: variant,
             flag_metadata: flag_metadata

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quonfig-openfeature
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-23 00:00:00.000000000 Z
+date: 2026-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: openfeature-sdk
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.11.0
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.11.0
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement