graphql_grpc 0.1.0

data/lib/graphql_grpc/graphql.rb

@@ -0,0 +1,114 @@
+# MIT License
+#
+# Copyright (c) 2018, Zane Claes
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+require 'graphql'
+module GraphqlGrpc
+  class Graphql
+    OP_FIELD = ::GraphQL::Language::Nodes::OperationDefinition
+
+    def initialize(proxy, error_presenter)
+      @error_presenter = error_presenter
+      @proxy = proxy
+      @output = { 'data' => {} }
+    end
+
+    # Given a graphQL document, execute those OperationDefinitions which map to a RPC
+    # The document will be modified to not include those fields / selections which were executed.
+    def execute(document, variables = {}, metadata = {})
+      @variables = variables || {}
+      @metadata = metadata || {}
+      document.definitions.reject! do |d|
+        # Filter out fields handled by GRPC...
+        d.selections.reject! { |s| graphql(s) } if d.is_a?(OP_FIELD)
+        d.selections.empty? # Filter the empty operations.
+      end
+      @output
+    end
+
+    private
+
+    # Execute a GraphQL field as an RPC on the proxy.
+    # @param field [GraphQL::Language::Nodes::GraphqlSelection] the RPC field.
+    # @param block [Proc] the presenter for the error handler.
+    def graphql(field)
+      return false unless @proxy.respond_to?(field.name)
+
+      key = (field.alias || field.name).to_s
+      resp = @proxy.rpc(field.name, vars_from(field), @metadata)
+      @output['data'][key] = present(field, resp)
+      true
+    rescue StandardError => e
+      @output['errors'] ||= []
+      @output['errors'] << @error_presenter.call(e)
+      true
+    end
+
+    # Filter the response down to the selected fields.
+    # n.b., the GRPC server should not include unselected fields, but those fields will appear
+    # as blank/empty in the response unless we actually filter the keys.
+    def present(field, resp)
+      return resp unless field.selections
+
+      if resp.is_a?(Hash)
+        return Time.at(resp[:seconds]).to_datetime if resp.keys == %i[seconds nanos] # TODO: find better way to detect timestamps...
+
+        result = field.selections.each_with_object({}) do |s, out|
+          out[(s.alias || s.name).to_s] = present(s, resp[s.name.to_sym])
+        end
+        result
+      elsif resp.is_a?(Array)
+        resp.map { |r| present(field, r) }
+      else
+        resp
+      end
+    end
+
+    # Extract the variables from a field.
+    def vars_from(field)
+      vars = {}
+      vars[:selections] = graphql_selections_array(field)
+      field.arguments.each do |arg|
+        val = if arg.value.is_a?(::GraphQL::Language::Nodes::VariableIdentifier)
+                @variables[arg.value.name.to_s]
+              elsif arg.value.is_a?(::GraphQL::Language::Nodes::Enum)
+                arg.value.name
+              else
+                arg.value
+              end
+        vars[arg.name] = val
+      end
+      vars
+    end
+
+    # Turn a field into a selections object for the RPC.
+    def graphql_selections_array(field)
+      return nil unless field && field.selections.any?
+
+      field.selections.map do |sel|
+        {
+          name: sel.name,
+          selections: graphql_selections_array(sel)
+        }
+      end
+    end
+  end
+end

data/lib/graphql_grpc/proxy.rb

@@ -0,0 +1,105 @@
+# MIT License
+#
+# Copyright (c) 2018, Zane Claes
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+require 'active_support/core_ext/string'
+module GraphqlGrpc
+  class GrpcGatewayError < StandardError; end
+  class HealthError < GrpcGatewayError; end
+  class ConfigurationError < GrpcGatewayError; end
+  class RpcNotFoundError < GrpcGatewayError; end
+
+  class Proxy
+    include GraphqlGrpc::Schema
+    attr_reader :services
+
+    # @param stub_services [Hash] mapping of a service_name to an instance of a stub service.
+    # @param error_presenter [Proc] a method that turns exceptions into a hash.
+    def initialize(stub_services = {}, &block)
+      @function_map = {} # func name => hash containing details
+      @services = {}
+      @error_presenter = block
+      map_functions(stub_services)
+    end
+
+    # Return a hash of all the healthchecks from all the services.
+    def healthcheck
+      Hash[@services.map do |service_name, stub|
+        hc = stub.send(:healthcheck, ::Google::Protobuf::Empty.new)
+        raise HealthError, "#{service_name} is not healthy." unless hc && hc.processID > 0
+
+        [service_name, hc]
+      end]
+    end
+
+    def function(function_name, noisy = true)
+      # function_name is a symbol; calling #to_s and #underscore calls #gsub! on it
+      # and it is frozen; so #dup first.
+      func = @function_map[::GRPC::GenericService.underscore(function_name.to_s.dup).to_sym]
+      raise RpcNotFoundError, "#{function_name} does not exist." if noisy && !func
+
+      func
+    end
+
+    def graphql
+      @graphql ||= ::GraphqlGrpc::Graphql.new(self, @error_presenter)
+    end
+
+    # Execute a function with given params.
+    def rpc(function_name, params = {}, metadata = {})
+      function(function_name).call(params, metadata || {})
+    end
+
+    def respond_to_missing?(method, _include_private = false)
+      !!function(method, false)
+    end
+
+    # Proxy methods through to the services, instead of calling rpc()
+    def method_missing(method, *args, &block)
+      return rpc(method, args.first, args[1]) if function(method)
+
+      super
+    end
+
+    private
+
+    # Add to the function_map by inspecting each service for the RPCs it provides.
+    def map_functions(stub_services)
+      return @function_map unless @function_map.empty?
+
+      stub_services.keys.each do |service_name|
+        stub = @services[service_name] = stub_services[service_name]
+        stub.class.to_s.gsub('::Stub', '::Service').constantize.rpc_descs.values.each do |d|
+          next if d.name.to_sym == :Healthcheck
+
+          grpc_func = ::GraphqlGrpc::Function.new(service_name, stub, d)
+          if @function_map.key?(grpc_func.name)
+            sn = @function_map[grpc_func.name].service_name
+            STDERR.puts "Skipping method #{grpc_func.name}; it was already defined on #{sn}"
+            # raise ConfigurationError, "#{grpc_func.name} was already defined on #{sn}."
+          end
+          @function_map[grpc_func.name] = grpc_func
+        end
+      end
+      @function_map
+    end
+  end
+end

data/lib/graphql_grpc/schema.rb

@@ -0,0 +1,84 @@
+# MIT License
+#
+# Copyright (c) 2018, Dane Avilla
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+module GraphqlGrpc
+  module Schema
+    def gql_mutations
+      # TODO: Find better way to detect mutations
+      @function_map.reject do |name_sym, _rpc_des|
+        name_sym.to_s.start_with?('get') ||
+          _rpc_des.rpc_desc.input == Google::Protobuf::Empty
+      end
+    end
+
+    def gql_queries
+      # TODO: Find better way to detect queries
+      # Currently look for methods named 'get' or with no args
+      @function_map.select do |name_sym, _rpc_des|
+        name_sym.to_s.start_with?('get') ||
+          _rpc_des.rpc_desc.input == Google::Protobuf::Empty
+      end
+    end
+
+    def to_schema_types
+      function_output_types = @function_map.values.map do |function|
+        function.rpc_desc.output
+      end.flatten.uniq
+      output_types = TypeLibrary.new(function_output_types)
+      function_input_types = @function_map.values.map do |function|
+        function.rpc_desc.input
+      end.flatten.uniq
+      input_types = InputTypeLibrary.new(function_input_types)
+      input_types.to_schema_types + "\nscalar Url\n" + output_types.to_schema_types
+    end
+
+    def to_function_types(ggg_function_hash)
+      ggg_function_hash.values.sort_by(&:name).map(&:to_query_type).join("\n  ")
+    end
+
+    def to_schema_query
+      "type Query {
+  #{to_function_types(gql_queries)}
+  }"
+    end
+
+    def to_schema_mutations
+      return '' if gql_mutations.empty?
+
+      "type Mutation {
+  #{to_function_types(gql_mutations)}
+  }"
+    end
+
+    def to_gql_schema
+      <<EOF
+  #{to_schema_types}
+  #{to_schema_query}
+  #{to_schema_mutations}
+  schema {
+  query: Query
+  #{gql_mutations.empty? ? '' : 'mutation: Mutation'}
+  }
+EOF
+    end
+  end
+end

data/lib/graphql_grpc/type_library.rb

@@ -0,0 +1,232 @@
+# MIT License
+#
+# Copyright (c) 2018, Dane Avilla
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+module GraphqlGrpc
+  module DescriptorExt
+    def <=>(b)
+      name <=> b.name
+    end
+
+    def types(prefix)
+      # Iterate through the Google::Protobuf::FieldDescriptor list
+      entries.sort.map { |fd| fd.to_gql_type(prefix) }
+    end
+
+    #
+    # Return an array of all (recursive) types known within this type
+    #
+    def sub_types
+      # Iterate through the Google::Protobuf::FieldDescriptor list
+      entries.map do |fd|
+        # fd.name = 'current_entity_to_update'
+        # fd.number = 1
+        # fd.label = :optional
+        # fd.submsg_name = "com.foo.bar.Baz"
+        # fd.subtype = #<Google::Protobuf::Descriptor:0x007fabb3947f08>
+        if fd.subtype.class == Google::Protobuf::Descriptor
+          # There is a subtype; recurse
+          [name, fd.submsg_name] + fd.subtype.sub_types
+        else
+          [name, fd.submsg_name]
+        end
+      end.flatten.compact
+    end
+
+    def type_name
+      name.split('::').last.split('.').last
+    end
+
+    #
+    # Decide whether this is a GraphQL 'type' or 'input'
+    #
+    def input_or_type(prefix)
+      return :input unless prefix.empty?
+
+      :type
+    end
+
+    def to_gql_type(prefix = '')
+      <<EOF
+#{input_or_type(prefix)} #{prefix}#{type_name} {
+  #{types(prefix).join("\n  ")}
+}
+EOF
+    end
+  end
+
+  module FieldDescriptorExt
+    def <=>(b)
+      name <=> b.name
+    end
+
+    def to_gql_type_field(prefix)
+      t = case type
+          when :int64, :int32, :uint32, :uint64
+            'Int'
+          when :string
+            'String'
+          when :bool, :boolean
+            'Boolean'
+          when :double
+            'Float'
+          when :message
+            prefix + submsg_name.to_s.split('.').last
+          when :enum
+            # Enums are interesting; for Google::Protobuf::FieldDescriptor fd
+            # fd.type        = :enum
+            # fd.subtype.    = Google::Protobuf::EnumDescriptor
+            # fd.submsg_name = 'com.foo.bar.Baz
+            # ed             = fd.subtype
+            # ed.entries.    = [[:OUT, 0], [:IN, 1]]
+            #
+            prefix + submsg_name.to_s.split('.')[-2..-1].join('_')
+          else
+            type.to_s + '--Unknown'
+      end
+      return "[#{t}]" if repeated?
+      return "#{t}!" unless optional?
+
+      t
+    end
+
+    def optional?
+      label == :optional
+    end
+
+    def repeated?
+      label == :repeated
+    end
+
+    def to_gql_type(prefix)
+      "#{name}: #{to_gql_type_field(prefix)}"
+    end
+  end
+
+  module EnumDescriptorExt
+    def type_name
+      # Take the last 2
+      name.split('.')[-2..-1].join('_')
+    end
+
+    def to_gql_type(prefix)
+      "enum #{prefix}#{type_name} {
+  #{entries.map(&:first).join("\n  ")}
+}"
+    end
+  end
+end
+
+require 'google/protobuf'
+Google::Protobuf::Descriptor.include(GraphqlGrpc::DescriptorExt)
+Google::Protobuf::FieldDescriptor.include(GraphqlGrpc::FieldDescriptorExt)
+Google::Protobuf::EnumDescriptor.include(GraphqlGrpc::EnumDescriptorExt)
+
+module GraphqlGrpc
+  class TypeLibrary
+    def initialize(top_level_types)
+      build_descriptors(top_level_types)
+    end
+
+    def build_descriptors(some_types)
+      # Keep track of known types to avoid infinite loops when there
+      # are circular dependencies between gRPC types
+      @descriptors ||= {}
+      some_types.each do |java_class_name|
+        next unless @descriptors[java_class_name].nil?
+
+        # Store a reference to this type
+        descriptor = descriptor_for(java_class_name)
+        @descriptors[java_class_name] ||= descriptor
+        # Recurse
+        build_descriptors(descriptor.sub_types) if descriptor.respond_to?(:sub_types)
+      end
+    end
+
+    #
+    # generated_klass - a class created by the 'proto' compiler; maps
+    # to a Descriptor in the generated pool.
+    #
+    def self.descriptor_for(klass_str)
+      klass_str = klass_str.to_s
+      # If given a ruby class reference, convert to "java package" string
+      # Pull the Google::Protobuf::Descriptor out of the pool and return it
+      # with the name
+      Google::Protobuf::DescriptorPool.generated_pool.lookup(
+        ruby_class_to_underscore(klass_str)
+      ) || Google::Protobuf::DescriptorPool.generated_pool.lookup(
+        ruby_class_to_dotted(klass_str)
+      )
+    end
+
+    def self.ruby_class_to_underscore(klass_str)
+      if klass_str.to_s.include?('::')
+       java_name = klass_str.to_s.split('::')
+       camel_case = java_name.pop
+       java_package = java_name.map(&:underscore)
+       # Put the name back together
+       (java_package + [camel_case]).join('.')
+     else
+       klass_str
+      end
+    end
+
+    def self.ruby_class_to_dotted(klass_str)
+      klass_str.gsub('::', '.')
+    end
+
+    def descriptor_for(klass_str)
+      TypeLibrary.descriptor_for(klass_str)
+    end
+
+    def types
+      @descriptors
+    end
+
+    def type_prefix
+      ''
+    end
+
+    def to_schema_types
+      @descriptors.values.map do |t|
+        t.to_gql_type(type_prefix)
+      end.compact.sort.uniq.join("\n")
+    end
+  end
+
+  class InputTypeLibrary < TypeLibrary
+    PREFIX = 'i_'.freeze
+    def type_prefix
+      PREFIX
+    end
+
+    def build_descriptors(some_types)
+      super
+      # Edge case: remove any input types with empty sub_types, such
+      # as is the case when a google.protobuf.Empty object is declared
+      # as the argument for a gRPC call that is being mapped to a
+      # GraphQL query.
+      @descriptors.delete_if do |key, descriptor|
+        descriptor.respond_to?(:sub_types) and descriptor.sub_types.empty?
+      end
+    end
+  end
+end

data/lib/graphql_grpc/version.rb

@@ -0,0 +1,3 @@
+module GraphqlGrpc
+  VERSION = '0.1.0'.freeze
+end

data/lib/graphql_grpc.rb

@@ -0,0 +1,14 @@
+require 'grpc'
+require 'graphql_grpc/version'
+require 'graphql_grpc/arrayify'
+require 'graphql_grpc/function'
+require 'graphql_grpc/graphql'
+require 'graphql_grpc/schema'
+require 'graphql_grpc/proxy'
+require 'graphql_grpc/type_library'
+
+module GraphqlGrpc
+  # Your code goes here...
+end
+
+GraphqlGrpc::Function.include GraphqlGrpc::Arrayify