quonfig-openfeature 2.0.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20da9ec1d24f20fa576a6430d8cd765b6d821a2cc052e0bfb8f59a5511b8447a
-  data.tar.gz: 333ea7e9395c479af7e7768bdb256c79860e7c495e009e9c51e8d14af51807e4
+  metadata.gz: d4a4af7330ac53ebeb637ed61d4c7cd0530bcfe62db92b845e5233d105496a3b
+  data.tar.gz: 7761829a3596aace1dad718f622b1156656079fd9ffe15123fcf0114c06e9837
 SHA512:
-  metadata.gz: b3319e1dbd57f6bcfa125befb424e8c2f811dc3c01f921b94c3426a0e62eed5f3ab100a49c372236e68adaa1fde3ca5d259d55af09800c40e0a4043393915c2d
-  data.tar.gz: 5cc0aecc4fcd057d426ae31381572bb27e97160dea9e154cc84e85bf668849618d5a2def62c950f3713353aef3c6f1d0c8e386055bcc35cd58b0affd1e3e0321
+  metadata.gz: 1de71990148d10403dcc3559f5a2d07d16a73a3c6c920e1fc38bdd282a8ba2fbd2d6e9e10524c1b8f04195c337918757f51d94365ec8368824aaccc52da17e8e
+  data.tar.gz: 80802c8ddb10fada30d464bbbaf55a9b45e45d05a819980dd555d601568c01003b2d8de9aa5c3f970727e39a4e0d5bcfe5c370d29b82bd11db4b33de987d5ae0

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 2.2.0 - 2026-10-29
+
+`fetch_string_value` on a `duration` config returns its stored ISO 8601 text again (reason
+`STATIC`), as in openfeature-go and the shared OpenFeature cases (qfg-177f). The text comes back
+unchanged: `"PT90S"` stays `"PT90S"`, not `"PT1M30S"`. 2.x returned your default with
+`TYPE_MISMATCH`. Number reads of a duration still return your default. A malformed stored duration
+such as `"30s"` still returns your default with `PARSE_ERROR`, and so does a duration ENV_VAR set
+to a malformed value.
+
+Requires quonfig (sdk-ruby) 2.1.0: the text is read with its new public `evaluate_details`, in one
+evaluation, and checked against the shared duration grammar with `Quonfig::Duration.valid?`.
+
+## 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

data/README.md

@@ -134,9 +134,9 @@ 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** -- 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`.
+3. **`duration` configs** -- `fetch_string_value` returns the stored ISO 8601 text unchanged
+   (`"PT90S"`). For integer milliseconds use `provider.client.get_duration`. `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.
@@ -153,8 +153,10 @@ code `TYPE_MISMATCH`:
 - 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 stored or ENV_VAR value (an int `"twelve"`) also returns your default with
-  `TYPE_MISMATCH`. An unset ENV_VAR returns your default with `GENERAL`.
+- 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.
 

data/VERSION

@@ -1 +1 @@
-2.0.0
+2.2.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,19 @@ 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
 
+      # A +duration+ config reads as its stored ISO 8601 text, unchanged
+      # ("PT90S" stays "PT90S"): OpenFeature has no duration type (qfg-177f).
       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)
+          next duration_iso_resolution(client, flag_key, mapped_ctx, default_value) if stored_value_type(client, flag_key) == 'duration'
+
+          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 +166,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 +191,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 +232,69 @@ 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
+
+      # Read a duration config as its ISO 8601 text with one evaluation:
+      # sdk-ruby's evaluate_details (quonfig >= 2.1.0) returns the resolved
+      # value in stored form, so the text is the stored text, or an ENV_VAR's
+      # text for a provided duration. evaluate_details does no type check, so
+      # the text is validated here with Quonfig::Duration.valid?, the grammar
+      # get_duration uses:
+      #
+      #   * valid text: the text, with the evaluation's reason, variant and
+      #     flag_metadata.
+      #   * malformed stored text ("30s"): the default with PARSE_ERROR.
+      #   * malformed ENV_VAR: evaluate_details reports ERROR / TYPE_MISMATCH,
+      #     which on a duration config can only mean a value that did not
+      #     parse, so it is PARSE_ERROR too.
+      #   * the structured { seconds, nanos } shape has no ISO text: the
+      #     default with TYPE_MISMATCH.
+      def duration_iso_resolution(client, flag_key, mapped_ctx, default_value)
+        details = client.evaluate_details(flag_key, context: mapped_ctx)
+        if details.reason == ::Quonfig::EvaluationDetails::REASON_ERROR
+          parse_error = details.error_code == ::Quonfig::EvaluationDetails::ERROR_TYPE_MISMATCH
+          return to_resolution(details, default_value, parse_error: parse_error)
+        end
+        return to_resolution(details, default_value) if details.reason == ::Quonfig::EvaluationDetails::REASON_DEFAULT
+
+        value = details.value
+        return to_resolution(details, default_value) if value.is_a?(String) && ::Quonfig::Duration.valid?(value)
+
+        error_code = value.is_a?(String) ? ErrorCode::PARSE_ERROR : ErrorCode::TYPE_MISMATCH
+        ResolutionDetails.new(value: default_value, reason: Reason::ERROR, error_code: error_code,
+                              error_message: "duration #{flag_key.inspect} has no valid ISO 8601 text",
+                              variant: details.variant, flag_metadata: details.flag_metadata || {})
+      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 +314,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: 2.0.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-27 00:00:00.000000000 Z
+date: 2026-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: openfeature-sdk
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement