write documents using string buffers.

Author: gmac

lib/graphql/stitching/executor/root_source.rb

@@ -44,24 +44,28 @@ def fetch(ops)
       # Builds root source documents
       # "query MyOperation_1($var:VarType) { rootSelections ... }"
       def build_document(op, operation_name = nil, operation_directives = nil)
-        doc = String.new
-        doc << op.operation_type
+        doc_buffer = String.new
+        doc_buffer << op.operation_type
 
         if operation_name
-          doc << " #{operation_name}_#{op.step}"
+          doc_buffer << " " << operation_name << "_" << op.step.to_s
         end
 
-        if op.variables.any?
-          variable_defs = op.variables.map { |k, v| "$#{k}:#{v}" }.join(",")
-          doc << "(#{variable_defs})"
+        unless op.variables.empty?
+          doc_buffer << "("
+          op.variables.each_with_index do |(k, v), i|
+            doc_buffer << "," unless i.zero?
+            doc_buffer << "$" << k << ":" << v
+          end
+          doc_buffer << ")"
         end
 
         if operation_directives
-          doc << " #{operation_directives} "
+          doc_buffer << " " << operation_directives << " "
         end
 
-        doc << op.selections
-        doc
+        doc_buffer << op.selections
+        doc_buffer
       end
 
       # Format response errors without a document location (because it won't match the request doc),

lib/graphql/stitching/executor/type_resolver_source.rb

@@ -51,66 +51,76 @@ def fetch(ops)
       # }"
       def build_document(origin_sets_by_operation, operation_name = nil, operation_directives = nil)
         variable_defs = {}
-        query_fields = origin_sets_by_operation.map.with_index do |(op, origin_set), batch_index|
+        fields_buffer = String.new
+
+        origin_sets_by_operation.each_with_index do |(op, origin_set), batch_index|
           variable_defs.merge!(op.variables)
           resolver = @executor.request.supergraph.resolvers_by_version[op.resolver]
+          fields_buffer << " " unless batch_index.zero?
 
           if resolver.list?
-            arguments = resolver.arguments.map.with_index do |arg, i|
+            fields_buffer << "_" << batch_index.to_s << "_result: " << resolver.field << "("
+
+            resolver.arguments.each_with_index do |arg, i|
+              fields_buffer << "," unless i.zero?
               if arg.key?
                 variable_name = "_#{batch_index}_key_#{i}".freeze
                 @variables[variable_name] = origin_set.map { arg.build(_1) }
                 variable_defs[variable_name] = arg.to_type_signature
-                "#{arg.name}:$#{variable_name}"
+                fields_buffer << arg.name << ":$" << variable_name
               else
-                "#{arg.name}:#{arg.value.print}"
+                fields_buffer << arg.name << ":" << arg.value.print
               end
             end
 
-            "_#{batch_index}_result: #{resolver.field}(#{arguments.join(",")}) #{op.selections}"
+            fields_buffer << ") " << op.selections
           else
-            origin_set.map.with_index do |origin_obj, index|
-              arguments = resolver.arguments.map.with_index do |arg, i|
+            origin_set.each_with_index do |origin_obj, index|
+              fields_buffer << " " unless index.zero?
+              fields_buffer << "_" << batch_index.to_s << "_" << index.to_s << "_result: " << resolver.field << "("
+
+              resolver.arguments.each_with_index do |arg, i|
+                fields_buffer << "," unless i.zero?
                 if arg.key?
                   variable_name = "_#{batch_index}_#{index}_key_#{i}".freeze
                   @variables[variable_name] = arg.build(origin_obj)
                   variable_defs[variable_name] = arg.to_type_signature
-                  "#{arg.name}:$#{variable_name}"
+                  fields_buffer << arg.name << ":$" << variable_name
                 else
-                  "#{arg.name}:#{arg.value.print}"
+                  fields_buffer << arg.name << ":" << arg.value.print
                 end
               end
 
-              "_#{batch_index}_#{index}_result: #{resolver.field}(#{arguments.join(",")}) #{op.selections}"
+              fields_buffer << ") " << op.selections
             end
           end
         end
 
-        doc = String.new(QUERY_OP) # << resolver fulfillment always uses query
+        doc_buffer = String.new(QUERY_OP) # << resolver fulfillment always uses query
 
         if operation_name
-          doc << " " << operation_name
+          doc_buffer << " " << operation_name
           origin_sets_by_operation.each_key do |op|
-            doc << "_" << op.step.to_s
+            doc_buffer << "_" << op.step.to_s
           end
         end
 
         if variable_defs.any?
-          doc << "("
+          doc_buffer << "("
           variable_defs.each_with_index do |(k, v), i|
-            doc << "," unless i.zero?
-            doc << "$" << k << ":" << v
+            doc_buffer << "," unless i.zero?
+            doc_buffer << "$" << k << ":" << v
           end
-          doc << ")"
+          doc_buffer << ")"
         end
 
         if operation_directives
-          doc << " " << operation_directives << " "
+          doc_buffer << " " << operation_directives << " "
         end
 
-        doc << "{ " << query_fields.join(" ") << " }"
+        doc_buffer << "{ " << fields_buffer << " }"
 
-        return doc, variable_defs.keys.tap do |names|
+        return doc_buffer, variable_defs.keys.tap do |names|
           names.reject! { @variables.key?(_1) }
         end
       end