Use a Result class instead of a Hash for Bulk#result

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: sshaw

README.md

@@ -54,9 +54,12 @@ p operation.url
 # etc...
 
 if operation.completed?
-  operation.results[:data].each { }
-  operation.results[:errors].each { }
-  operation.results[:user_errors].each { }
+  operation.results.each do |result|
+    # Each element is a Hash with the appropriate response, if any
+    result.data.each { }
+    result.errors.each { }
+    result.user_errors.each { }
+  end
 end
 ```
 

lib/shopify_api/graphql/bulk/operation.rb

@@ -2,6 +2,8 @@
 
 require "time"
 
+require_relative "operation/result"
+
 module ShopifyAPI
   module GraphQL
     module Bulk
@@ -58,40 +60,11 @@ def parse_results(url)
 
           response.body.each_line do |line|
             row = JSON.parse(line)
-            entry = { :line => row["__lineNumber"] }
-
-            if row.include?("errors")
-              entry[:errors] = row["errors"].map { |e| { :message => e["message"] } }
-            end
-
-            if row["data"]
-              data = row["data"].values.first
-
-              if data
-                errors = data["userErrors"] || []
-                entry[:user_errors] = errors.map { |e| { :field => e["field"], :message => e["message"] } } if errors.any?
-                entry[:data] = snake_case_keys(data.reject { |k, _| k == "userErrors" })
-              end
-            end
-
-            results << entry
+            results << Operation::Result.new(row)
           end
 
           results
         end
-
-        def snake_case_keys(object)
-          case object
-          when Hash
-            object.each_with_object({}) do |(key, value), result|
-              result[Strings::Case.snakecase(key).to_sym] = snake_case_keys(value)
-            end
-          when Array
-            object.map { |value| snake_case_keys(value) }
-          else
-            object
-          end
-        end
       end
     end
   end

lib/shopify_api/graphql/bulk/operation/result.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module GraphQL
+    module Bulk
+      class Operation
+        class Result
+          attr_reader :line, :data, :errors, :user_errors
+
+          def initialize(row)
+            @errors = []
+            @user_errors = []
+
+            @line = row["__lineNumber"]
+
+            if row.include?("errors")
+              @errors = row["errors"].map { |e| { :message => e["message"] } }
+            end
+
+            if row["data"]
+              data = row["data"].values.first
+              if data
+                errors = data["userErrors"] || []
+                @user_errors = errors.map { |e| { :field => e["field"], :message => e["message"] } } if errors.any?
+                @data = snake_case_keys(data.reject { |k, _| k == "userErrors" })
+              end
+            end
+          end
+
+          private
+
+          def snake_case_keys(object)
+            case object
+            when Hash
+              object.each_with_object({}) do |(key, value), result|
+                result[Strings::Case.snakecase(key).to_sym] = snake_case_keys(value)
+              end
+            when Array
+              object.map { |value| snake_case_keys(value) }
+            else
+              object
+            end
+          end
+        end
+      end
+    end
+  end
+end

spec/shopify_api/graphql/bulk_spec.rb

@@ -122,9 +122,10 @@
         op = subject.result(ENV.fetch("BULK_FAILED_ID_USER_ERRORS"))
 
         expect(op.results.size).to eq 1
-        expect(op.results).to eq([
+        expect(op.results[0]).to have_attributes(
           :line => 0,
           :data => {},
+          :errors => [],
           :user_errors => [
             {
               :field => %w[query],
@@ -135,17 +136,19 @@
               :message =>"Variable $identifier of type ProductSetIdentifiers was provided invalid value"
             }
           ]
-        ])
+        )
       end
 
       it "returns parsed errors" do
         op = subject.result(ENV.fetch("BULK_FAILED_ID_ERRORS"))
 
         expect(op.results.size).to eq 1
-        expect(op.results).to eq([
+        expect(op.results[0]).to have_attributes(
           :line => 0,
-          :errors => [:message => "OptionSetInput requires at least one of id, name"]
-        ])
+          :data => nil,
+          :errors => [{ :message => "OptionSetInput requires at least one of id, name" }],
+          :user_errors => []
+        )
       end
     end
 
@@ -170,28 +173,30 @@
         op = subject.result(ENV.fetch("BULK_SUCCESS_ID"))
 
         expect(op.results.size).to eq 2
-        expect(op.results).to match([
-          {
-            :line => 0,
-            :data => {
-              :product => {
-                :id => match(%r{\Agid://shopify/Product/\d+\z}),
-                :handle => be_a(String),
-                :tags => []
-              }
+        expect(op.results[0]).to have_attributes(
+          :line => 0,
+          :data => {
+            :product => {
+              :id => match(%r{\Agid://shopify/Product/\d+\z}),
+              :handle => be_a(String),
+              :tags => []
             }
           },
-          {
-            :line => 1,
-            :data => {
-              :product => {
-                :id => match(%r{\Agid://shopify/Product/\d+\z}),
-                :handle => be_a(String),
-                :tags => []
-              }
+          :errors => [],
+          :user_errors => []
+        )
+        expect(op.results[1]).to have_attributes(
+          :line => 1,
+          :data => {
+            :product => {
+              :id => match(%r{\Agid://shopify/Product/\d+\z}),
+              :handle => be_a(String),
+              :tags => []
             }
-          }
-        ])
+          },
+          :errors => [],
+          :user_errors => []
+        )
       end
 
       it "returns an Operation that does not contain the parsed data" do