inigorb 0.27.8 → 0.28.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b76b4df84e9b306abc97e3db3e620d0adbd677c0e1d7c3ad281868a31f692f6
-  data.tar.gz: c4c409ead58fbea2f6802323c530b26b599d8e4fdacbc0187d7bea78d66fe759
+  metadata.gz: a8dd4aa6b5a222647cdeaca8bc0a812fff7ca4afa6402c3da8a182d5b87a1db1
+  data.tar.gz: 79e2b7554361eb3e170d63b7c07afa2d58870322b3790452b3ede1120b46732f
 SHA512:
-  metadata.gz: d6ce3a79ef32be887b9fd65580a8f10d8c4e6952d8defbdf3cfece54adcc4acabee37c367e81129c6c690a98bf1bbe731b42cbf6423f4adec4fe39687b2ab9ff
-  data.tar.gz: 2b69305cd787ffccd8c11f06b70e346781f0b20cfaf48181874d4d92c96296e9c82fe7b8ff095ca889e99c7fc35e7369c267a796de88be3574f116a87bfd9b0c
+  metadata.gz: cec390d985f84492c6a72f2232382f6f8a93043b9c067f3d30d71f7896bcaf12c6ec47b91afab59c8e1dbd4ac78d84d141a5ba1ce982e865a0012f9b0d00cfd3
+  data.tar.gz: a2a42ca4d67b9e6ad518cf2d748dd09a8123815c3c327aaf382cc8e3bbfee5f6cb9454c8e3a66c80392f5c63dad0d4276cadeeda552f695071e8a23e845fc9ff

data/lib/{ffimod.rb → inigorb/ffimod.rb}

@@ -56,11 +56,11 @@ module Inigo
 
       class Config < FFI::Struct
           layout :debug, :bool,
-                  :ingest, :pointer,
+                  :name, :pointer,
                   :service, :pointer,
                   :token, :pointer,
                   :schema, :pointer,
-                  :introspection, :pointer,
+                  :runtime, :pointer,
                   :egress_url, :pointer,
                   :gateway, :u_int64_t,
                   :disable_response_data, :bool
@@ -84,6 +84,7 @@ module Inigo
       attach_function :disposeHandle, [:u_int64_t], :void
       attach_function :disposeMemory, [:pointer], :void
       attach_function :check_lasterror, [], :string
+      attach_function :copy_querydata, [:u_int64_t], :u_int64_t
     rescue LoadError => e
       raise ::RuntimeError, "Unable to open Inigo shared library.\n\nPlease get in touch with us for support:\nemail: support@inigo.io\nslack: https://slack.inigo.io\n\nPlease share the below info with us:\nerror:    #{e.to_s}\nuname:    #{RbConfig::CONFIG['host_os']}\narch:     #{RbConfig::CONFIG['host_cpu']}"
     end  

data/lib/{query.rb → inigorb/query.rb}

@@ -1,8 +1,23 @@
 require 'json'
-require_relative 'ffimod'
+
+require 'inigorb/ffimod'
 
 module Inigo
+  # made to simplify user experience. just prepend Inigo::Data to your channel and it will work.
+  module Data
+    attr_accessor :querydata
+
+    def unsubscribed
+      if @querydata
+        Inigo.disposeHandle(@querydata.handle)
+      end
+      super
+    end
+  end
+
   class Query
+    attr_reader :handle
+
     def initialize(instance, request)
       @handle = 0
       @instance = instance
@@ -50,15 +65,21 @@ module Inigo
       [resp_dict, req_dict]
     end
 
-    def process_response(resp_body)
+    def process_response(resp_body, is_initial_subscription: false, copy: false)
       return nil if @handle.zero?
 
       output_ptr = FFI::MemoryPointer.new(:pointer)
       output_len = FFI::MemoryPointer.new(:int)
 
+      handle = @handle
+      if copy
+        # if it is subscription and not initial request - reuse existing querydata
+        handle = Inigo.copy_querydata(@handle)
+      end
+
       Inigo.process_response(
         @instance,
-        @handle,
+        handle,
         FFI::MemoryPointer.from_string(resp_body), resp_body.length,
         output_ptr, output_len
       )
@@ -66,7 +87,11 @@ module Inigo
       output_data = output_ptr.read_pointer.read_string(output_len.read_int)
 
       Inigo.disposeMemory(output_ptr.read_pointer)
-      Inigo.disposeHandle(@handle)
+
+      # if it is initial subscription request - do not dispose handle
+      if !is_initial_subscription
+        Inigo.disposeHandle(handle)
+      end
 
       output_data
     end

data/lib/inigorb/tracer.rb

@@ -0,0 +1,261 @@
+require 'json'
+require 'ffi'
+require 'graphql'
+
+require 'inigorb/ffimod'
+require 'inigorb/query'
+
+module Inigo
+  class Tracer < GraphQL::Tracing::PlatformTracing
+    @@instance = nil
+
+    def self.instance
+      @@instance
+    end
+
+    def self.instance=(value)
+      @@instance = value
+    end
+
+    def initialize(options = {})
+      super(options)
+      # add options like logger logic
+    end
+
+    def self.use(schema, **kwargs)
+      @@schema = schema
+      super
+    end
+
+    self.platform_keys = {
+      'lex' => 'lex',
+      'parse' => 'parse',
+      'validate' => 'validate',
+      'analyze_query' => 'analyze_query',
+      'analyze_multiplex' => 'analyze_multiplex',
+      'execute_multiplex' => 'execute_multiplex',
+      'execute_query' => 'execute_query',
+      'execute_query_lazy' => 'execute_query_lazy'
+    }
+
+    def platform_trace(platform_key, key, data)
+      # Ignore execution if Inigo is not initialized
+      if self.class.instance == 0
+        return yield
+      end
+
+      if platform_key != "execute_multiplex"
+        return yield
+      end
+
+      if !data[:multiplex] || !data[:multiplex].queries || data[:multiplex].queries.length == 0
+        return yield
+      end
+
+      queries = []
+      subscription_queries = {}
+      initial_subscriptions = {}
+      modified_responses = {}
+      cached_queries = {}
+
+      data[:multiplex].queries.each_with_index do |query, index|
+        is_subscription = query.context[:channel] != nil
+        is_init_subscription = is_subscription && !query.context[:subscription_id]
+
+        if is_subscription && !is_init_subscription
+          # retrieve querydata stored after initial subscription request
+          subscription_queries[index] = query.context[:channel].querydata
+          queries.append(query.context[:channel].querydata)
+          # no need to process request again, it will be copied
+          next
+        end
+
+        gReq = {
+          'query' => query.query_string,
+        }
+
+        gReq['operationName'] = query.operation_name if query.operation_name && query.operation_name != ''
+        gReq['variables'] = query.variables.to_h if query.variables
+
+        q = Query.new(self.class.instance, JSON.dump(gReq))
+
+        incoming_request = query.context['request']
+        if is_subscription
+          incoming_request = ActionDispatch::Request.new(query.context[:channel].connection.env)
+        end
+
+        resp, req = q.process_request(headers(incoming_request))
+
+        # Introspection or blocked query
+        if resp.any?
+          modified_responses[index]  = resp
+          cached_queries[index] = query
+
+          # trick not to execute actual query. we can't remove query from multiplex at all but we can fool it by modifying the query executed on the schema.
+          modified_query = GraphQL::Query.new(query.schema, 'query IntrospectionQuery { __schema { queryType { name } } }', context: query.context, operation_name: 'IntrospectionQuery')
+          modified_query.multiplex = query.multiplex
+          # TODO - verify works in all the cases. During the testing it works, simulate multiple queries at the same time to verify.
+          data[:multiplex].queries[index] = modified_query
+
+          queries.append(q)
+          next
+        end
+
+        # Modify query if required
+        if req.any?
+          modified_query = GraphQL::Query.new(query.schema, req['query'], context: query.context, operation_name: req['operationName'], variables: req['variables'])
+          modified_query.multiplex = query.multiplex
+          # TODO - verify works in all the cases. During the testing it works, simulate multiple queries at the same time to verify.
+          data[:multiplex].queries[index] = modified_query
+        end
+
+        if is_subscription
+          query.context[:channel].querydata = q
+          initial_subscriptions[index] = true
+        end
+
+        queries.append(q)
+      end
+
+      responses = yield
+
+      responses.each_with_index do |response, index|
+        if modified_responses[index]
+          # process_response is not called in this case
+          responses[index] = GraphQL::Query::Result.new(query: cached_queries[index], values: modified_responses[index])
+          next
+        end
+
+        # take a copy of the initial subscription request if it is subscription
+        needs_copy = subscription_queries[index] != nil
+        is_initial_subscription = initial_subscriptions[index] != nil
+        resp = {
+          'errors' => response['errors'],
+          'response_size' => 0,
+          'response_body_counts' => count_response_fields(response.to_h)
+        }
+        processed_response = queries[index].process_response(JSON.dump(resp), is_initial_subscription: is_initial_subscription, copy: needs_copy)
+        responses[index] = GraphQL::Query::Result.new(query: data[:multiplex].queries[index], values: mod_response(response.to_h, JSON.parse(processed_response)))
+      end
+
+      responses
+    end
+
+    # compat
+    def platform_authorized_key(type)
+      "#{type.graphql_name}.authorized.graphql"
+    end
+
+    # compat
+    def platform_resolve_type_key(type)
+      "#{type.graphql_name}.resolve_type.graphql"
+    end
+
+    # compat
+    def platform_field_key(type, field)
+      "graphql.#{type.name}.#{field.name}"
+    end
+
+    def count_response_fields(resp)
+      counts = {}
+
+      if resp['data']
+        count_response_fields_recursive(counts, 'data', resp['data'])
+      end
+
+      counts['data'] ||= 1
+      counts['errors'] = resp['errors'] ? resp['errors'].length : 0
+      counts
+    end
+
+    def count_response_fields_recursive(hm, prefix, val)
+      return unless val.is_a?(Hash) || val.is_a?(Array)
+
+      incr = lambda do |key, value|
+        unless count_response_fields_recursive(hm, key, value)
+          hm[key] = (hm[key] || 0) + 1
+        end
+      end
+
+      if val.is_a?(Array)
+        val.each do |item|
+          incr.call(prefix, item)
+        end
+
+        return true
+      end
+
+      val.each do |k, v|
+        incr.call("#{prefix}.#{k}", v)
+      end
+
+      return false
+    end
+
+    private
+
+    def self.initialize_tracer(schema)
+      @@schema = schema
+
+      # get all the inigo settings from env
+      settings = ENV.select { |k, v| k.start_with?('INIGO') }
+
+      if settings.fetch("INIGO_ENABLE", "").to_s.downcase == "false"
+        @@initialized = true #not to get to this method ever again
+        puts 'Inigo is disabled. Skipping middleware.'
+        return
+      end
+
+      config = Inigo::Config.new
+
+      config[:disable_response_data] = false
+      config[:debug] = settings.fetch("INIGO_DEBUG", "false").to_s.downcase == "true"
+      config[:token] = FFI::MemoryPointer.from_string(settings.fetch('INIGO_SERVICE_TOKEN', '').to_s.encode('UTF-8'))
+      config[:schema] = FFI::MemoryPointer.from_string(schema.to_s.encode('UTF-8'))
+      config[:name] = FFI::MemoryPointer.from_string("inigo-rb".to_s.encode('UTF-8'))
+      config[:runtime] = FFI::MemoryPointer.from_string("ruby".concat(RUBY_VERSION[/\d+\.\d+/]).to_s.encode('UTF-8'))
+
+      # Create Inigo instance
+      @@instance = Inigo.create(config.pointer.address)
+
+      error = Inigo.check_lasterror
+      if error.length != 0
+        puts "INIGO: #{error}"
+      end
+
+      if error.length == 0 && @@instance == 0
+        puts 'INIGO: error, instance cannot be created'
+      end
+    end
+
+    def headers(request)
+      headers = {}
+
+      request.env.each do |key, value|
+        if key.start_with?('HTTP_')
+          header_name = key[5..].split('_').map(&:capitalize).join('-')
+          headers[header_name] = value.split(',').map(&:strip)
+        elsif key == 'CONTENT_TYPE' || key == 'REMOTE_ADDR'
+          headers[key] = value.split(',').map(&:strip)
+        end
+      end
+
+      JSON.dump(headers)
+    end
+
+    def mod_response(response, extended)
+      if extended['extensions']
+        response['extensions'] ||= {}
+        response['extensions'].merge!(extended['extensions'])
+      end
+    
+      if extended['errors']
+        response['errors'] ||= []
+        response['errors'].concat(extended['errors'])
+      end
+
+      response
+    end
+
+  end
+end

data/lib/inigorb.rb

@@ -1,7 +1,9 @@
 require 'json'
 require 'ffi'
-require_relative 'ffimod'
-require_relative 'query'
+
+require 'inigorb/ffimod'
+require 'inigorb/query'
+require 'inigorb/tracer'
 
 module Inigo
   class Middleware
@@ -86,7 +88,7 @@ module Inigo
         # Read request from body
         request.body.each { |chunk| gReq += chunk }
 
-        if self.class.operation_store.present? && has_operation_id?(gReq)
+        if self.class.operation_store.present? && has_operation_id?(gReq) && !has_query?(gReq)
           parsed = JSON.parse(gReq)
           operationId = get_operation_id(parsed)
 
@@ -124,7 +126,7 @@ module Inigo
         request.body.rewind
       elsif request.get?
         operation_id = get_operation_id(request.params)
-        if operation_id && self.class.operation_store
+        if operation_id && self.class.operation_store && !request.params['query']
             parts = operation_id.split('/')
             # Query can't be resolved
             if parts.length != 2
@@ -211,6 +213,8 @@ module Inigo
 
       config = Inigo::Config.new
       config[:disable_response_data] = false
+      config[:name] = FFI::MemoryPointer.from_string("inigo-rb".to_s.encode('UTF-8'))
+      config[:runtime] = FFI::MemoryPointer.from_string("ruby".concat(RUBY_VERSION[/\d+\.\d+/]).to_s.encode('UTF-8'))
 
       if settings.fetch("INIGO_DEBUG", "false").to_s.downcase == "true"
         config[:debug] = true
@@ -279,6 +283,10 @@ module Inigo
       str_data.include?('operationId')
     end
 
+    def has_query?(str_data)
+      return str_data.include?('"query":') && str_data.match(/"query"\s*:\s*"\S+"/)
+    end
+
     # extracts operation id from parsed body hash
     def get_operation_id(json_data)
       # Relay / Apollo 1.x
@@ -291,6 +299,5 @@ module Inigo
         nil
       end
     end
-
-  end  
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: inigorb
 version: !ruby/object:Gem::Version
-  version: 0.27.8
+  version: 0.28.1
 platform: ruby
 authors:
 - Inigo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-30 00:00:00.000000000 Z
+date: 2023-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jwt
@@ -50,6 +50,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.15.5
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.24
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.24
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.24
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.24
 description: 
 email: eitan@inigo.io
 executables: []
@@ -57,15 +77,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
-- lib/ffimod.rb
-- lib/inigo-darwin-amd64.dylib
-- lib/inigo-darwin-arm64.dylib
-- lib/inigo-linux-amd64.so
-- lib/inigo-linux-arm64.so
-- lib/inigo-windows-amd64.dll
-- lib/inigo-windows-arm64.dll
 - lib/inigorb.rb
-- lib/query.rb
+- lib/inigorb/ffimod.rb
+- lib/inigorb/inigo-darwin-amd64.dylib
+- lib/inigorb/inigo-darwin-arm64.dylib
+- lib/inigorb/inigo-linux-amd64.so
+- lib/inigorb/inigo-linux-arm64.so
+- lib/inigorb/inigo-windows-amd64.dll
+- lib/inigorb/inigo-windows-arm64.dll
+- lib/inigorb/query.rb
+- lib/inigorb/tracer.rb
 homepage: https://inigo.io
 licenses:
 - MIT