Fixes #1311 by ensuring that the response body is always a Hash, even if ShopifyAPI.Context.response_as_struct is true.

Had to add a Utility (ShopifyAPI::Utils::OstructHashUtils) to handle the conversion since a simple .to_h and even JSON.parse(response.body.to_json) did not work as expected (nested Keys and Array handling failed).

Author: DaveEshopGuide

lib/shopify_api/utils/ostruct_hash_utils.rb

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash"
+
+module ShopifyAPI
+  module Utils
+    module OstructHashUtils
+      class << self
+        extend T::Sig
+
+        sig { params(object: OpenStruct, hash: T::Hash).returns(T::Hash[String, T.untyped]) }
+        def open_struct_to_hash(object, hash = {})
+          object.each_pair do |key, value|
+            hash[key] = case value
+                        when OpenStruct then open_struct_to_hash(value)
+                        when Array then value.map { |v| v.is_a?(OpenStruct) ? open_struct_to_hash(v) : v }
+                        else value
+                        end
+          end
+          hash.deep_stringify_keys
+        end
+
+        sig { params(obj: T.any(Hash, OpenStruct)).returns(T::Hash[String, T.untyped]) }
+        def ensure_hash(obj)
+          case obj
+          when Hash
+            obj
+          when OpenStruct
+            open_struct_to_hash(obj)
+          else
+            raise ArgumentError, "Expected Hash or OpenStruct, got #{obj.class}"
+          end
+        end
+
+      end
+    end
+  end
+end

lib/shopify_api/webhooks/registry.rb

@@ -141,7 +141,8 @@ def unregister(topic:, session:)
           delete_response = client.query(query: delete_mutation)
           raise Errors::WebhookRegistrationError,
             "Failed to delete webhook from Shopify" unless delete_response.ok?
-          result = T.cast(delete_response.body, T::Hash[String, T.untyped])
+          result = T.cast(ShopifyAPI::Utils::OstructHashUtils.ensure_hash(delete_response.body),
+            T::Hash[String, T.untyped])
           errors = result["errors"] || {}
           raise Errors::WebhookRegistrationError,
             "Failed to delete webhook from Shopify: #{errors[0]["message"]}" unless errors.empty?
@@ -173,7 +174,8 @@ def get_webhook_id(topic:, client:)
           fetch_id_response = client.query(query: fetch_id_query)
           raise Errors::WebhookRegistrationError,
             "Failed to fetch webhook from Shopify" unless fetch_id_response.ok?
-          body = T.cast(fetch_id_response.body, T::Hash[String, T.untyped])
+          body = T.cast(ShopifyAPI::Utils::OstructHashUtils.ensure_hash(fetch_id_response.body),
+            T::Hash[String, T.untyped])
           errors = body["errors"] || {}
           raise Errors::WebhookRegistrationError,
             "Failed to fetch webhook from Shopify: #{errors[0]["message"]}" unless errors.empty?
@@ -219,7 +221,10 @@ def webhook_registration_needed?(client, registration)
           check_response = client.query(query: registration.build_check_query)
           raise Errors::WebhookRegistrationError,
             "Failed to check if webhook was already registered" unless check_response.ok?
-          parsed_check_result = registration.parse_check_result(T.cast(check_response.body, T::Hash[String, T.untyped]))
+
+          response_body = ShopifyAPI::Utils::OstructHashUtils.ensure_hash(check_response.body)
+
+          parsed_check_result = registration.parse_check_result(T.cast(response_body, T::Hash[String, T.untyped]))
           must_register = parsed_check_result[:current_address] != registration.callback_address
 
           { webhook_id: parsed_check_result[:webhook_id], must_register: must_register }
@@ -237,7 +242,8 @@ def send_register_request(client, registration, webhook_id)
 
           raise Errors::WebhookRegistrationError, "Failed to register webhook with Shopify" unless register_response.ok?
 
-          T.cast(register_response.body, T::Hash[String, T.untyped])
+          response_body = ShopifyAPI::Utils::OstructHashUtils.ensure_hash(register_response.body)
+          T.cast(response_body, T::Hash[String, T.untyped])
         end
 
         sig { params(body: T::Hash[String, T.untyped], mutation_name: String).returns(T::Boolean) }

test/utils/ostruct_hash_utils_test.rb

@@ -0,0 +1,28 @@
+# typed: false
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+module ShopifyAPITest
+  module Utils
+    class OstructHashUtilsTest < Test::Unit::TestCase
+      def setup
+        @utils = ShopifyAPI::Utils::OstructHashUtils
+        @ostruct = OpenStruct.new({ key1: "value1", key2: OpenStruct.new({ nested_key: "nested_value" }) })
+        @hash = { "key1" => "value1", "key2" => { "nested_key" => "nested_value" } }
+      end
+
+      def test_open_struct_to_hash_with_open_struct
+        assert_equal(@hash, @utils.open_struct_to_hash(@ostruct))
+      end
+
+      def test_ensure_hash_with_hash
+        assert_equal(@hash, @utils.ensure_hash(@hash))
+      end
+
+      def test_ensure_hash_with_open_struct
+        assert_equal(@hash, @utils.ensure_hash(@ostruct))
+      end
+
+    end
+  end
+end

test/webhooks/registry_test.rb

@@ -59,6 +59,29 @@ def test_process
         assert(handler_called)
       end
 
+      def test_process_with_response_as_struct
+        modify_context(response_as_struct: true)
+
+        handler_called = false
+
+        handler = TestHelpers::FakeWebhookHandler.new(
+          lambda do |topic, shop, body,|
+            assert_equal(@topic, topic)
+            assert_equal(@shop, shop)
+            assert_equal({}, body)
+            handler_called = true
+          end,
+          )
+
+        ShopifyAPI::Webhooks::Registry.add_registration(
+          topic: @topic, path: "path", delivery_method: :http, handler: handler,
+          )
+
+        ShopifyAPI::Webhooks::Registry.process(@webhook_request)
+
+        assert(handler_called)
+      end
+
       def test_process_new_handler
         handler_called = false