ecoportal-api-graphql 1.3.5 → 1.3.17

data/lib/ecoportal/api/common/graphql/hash_helpers.rb

@@ -1,105 +1,105 @@
-module Ecoportal
-  module API
-    module Common
-      module GraphQL
-        module HashHelpers
-          class << self
-            def included(base)
-              base.send(:include, InstanceMethods)
-            end
-          end
-
-          module InstanceMethods
-            def keys_to_sym_deep(value)
-              transform_keys_deep(value, &:to_sym)
-            end
-
-            def keys_to_s_deep(value)
-              transform_keys_deep(value, &:to_s)
-            end
-
-            def except_keys(value, *keys)
-              return value unless value.is_a?(Hash)
-
-              deep_dup(value).tap do |out|
-                keys.each {|key| out.delete(key)}
-              end
-            end
-
-            # Targetted removal of keys in `target` that are `nil`
-            def remove_nil_keys_deep(value, target: [])
-              remove_keys_deep_if(value, target: target, &:nil?)
-            end
-
-            # Based on Rails support.
-            def deep_dup(data)
-              case data
-              when Hash
-                data.each_with_object({}) do |(k, v), copy|
-                  if k.is_a?(::String) || k.is_a?(::Symbol)
-                    copy[k] = deep_dup(v)
-                  else
-                    copy.delete(k)
-                    copy[deep_dup(k)] = deep_dup(v)
-                  end
-                end
-              when Enumerable
-                data.map {|d| deep_dup(d)}
-              else
-                data.dup
-              end
-            end
-
-            private
-
-            # Iterator
-            # @param value [Variadic]
-            # @return [value.class]
-            def transform_keys_deep(value, &block)
-              case value
-              when Hash
-                value.dup.each_with_object({}) do |(k, v), out|
-                  k_val      = block_given?? yield(k) : k
-                  out[k_val] = transform_keys_deep(v, &block)
-                end
-              when Enumerable
-                value.map {|v| transform_keys_deep(v, &block)}
-              else
-                value
-              end
-            end
-
-            # Targetted removal of keys in `target` that meet
-            # the `block` condition.
-            # @param value [Variadic]
-            # @param target [Array<String>, Array<Symbol>] the target
-            #   `keys` to yield `block` onto.
-            # @return [value.class]
-            def remove_keys_deep_if(value, target: [], &block)
-              msg = 'Expected block. None given.'
-              raise ArgumentError, msg unless block_given?
-
-              target = [target].flatten.compact
-              return value if target.empty?
-
-              case value
-              when Hash
-                value.dup.each_with_object({}) do |(k, v), out|
-                  next if yield(v) && target.include?(k) # skip
-
-                  out[k] = remove_nil_keys_deep(v, target: target, &block)
-                end
-              when Enumerable
-                value.map {|v| remove_nil_keys_deep(v, target: target, &block)}
-              else
-                value
-              end
-            end
-          end
-
-          extend InstanceMethods
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    module Common
+      module GraphQL
+        module HashHelpers
+          class << self
+            def included(base)
+              base.send(:include, InstanceMethods)
+            end
+          end
+
+          module InstanceMethods
+            def keys_to_sym_deep(value)
+              transform_keys_deep(value, &:to_sym)
+            end
+
+            def keys_to_s_deep(value)
+              transform_keys_deep(value, &:to_s)
+            end
+
+            def except_keys(value, *keys)
+              return value unless value.is_a?(Hash)
+
+              deep_dup(value).tap do |out|
+                keys.each {|key| out.delete(key)}
+              end
+            end
+
+            # Targetted removal of keys in `target` that are `nil`
+            def remove_nil_keys_deep(value, target: [])
+              remove_keys_deep_if(value, target: target, &:nil?)
+            end
+
+            # Based on Rails support.
+            def deep_dup(data)
+              case data
+              when Hash
+                data.each_with_object({}) do |(k, v), copy|
+                  if k.is_a?(::String) || k.is_a?(::Symbol)
+                    copy[k] = deep_dup(v)
+                  else
+                    copy.delete(k)
+                    copy[deep_dup(k)] = deep_dup(v)
+                  end
+                end
+              when Enumerable
+                data.map {|d| deep_dup(d)}
+              else
+                data.dup
+              end
+            end
+
+            private
+
+            # Iterator
+            # @param value [Variadic]
+            # @return [value.class]
+            def transform_keys_deep(value, &block)
+              case value
+              when Hash
+                value.dup.each_with_object({}) do |(k, v), out|
+                  k_val      = block_given?? yield(k) : k
+                  out[k_val] = transform_keys_deep(v, &block)
+                end
+              when Enumerable
+                value.map {|v| transform_keys_deep(v, &block)}
+              else
+                value
+              end
+            end
+
+            # Targetted removal of keys in `target` that meet
+            # the `block` condition.
+            # @param value [Variadic]
+            # @param target [Array<String>, Array<Symbol>] the target
+            #   `keys` to yield `block` onto.
+            # @return [value.class]
+            def remove_keys_deep_if(value, target: [], &block)
+              msg = 'Expected block. None given.'
+              raise ArgumentError, msg unless block_given?
+
+              target = [target].flatten.compact
+              return value if target.empty?
+
+              case value
+              when Hash
+                value.dup.each_with_object({}) do |(k, v), out|
+                  next if yield(v) && target.include?(k) # skip
+
+                  out[k] = remove_nil_keys_deep(v, target: target, &block)
+                end
+              when Enumerable
+                value.map {|v| remove_nil_keys_deep(v, target: target, &block)}
+              else
+                value
+              end
+            end
+          end
+
+          extend InstanceMethods
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/common/graphql/http_client.rb

@@ -1,145 +1,195 @@
-module Ecoportal
-  module API
-    module Common
-      module GraphQL
-        class HttpClient < Common::Client
-          class << self
-            def base_url(host)
-              "#{protocol(host)}://#{host}"
-            end
-
-            def protocol(host)
-              host.match(/^localhost|^127\.0\.0\.1/)? 'http' : 'https'
-            end
-          end
-
-          READ_TIMEOUT  = 90
-          WRITE_TIMEOUT = 90
-
-          attr_reader :host, :version
-
-          include Ecoportal::API::Common::GraphQL::AuthService
-
-          def initialize(
-            email:        nil,
-            pass:         nil,
-            org_id:       nil,
-            api_key:      nil,
-            version:      'graphql',
-            host:         'live.ecoportal.com',
-            logger:       ::Logger.new(IO::NULL),
-            deep_logging: false,
-            no_schema:    true
-          )
-            @org_id      = org_id
-            @user_email  = email
-            @user_pass   = pass
-            @no_schema   = no_schema
-            @version     = version
-
-            super(
-              api_key:      api_key,
-              host:         host,
-              logger:       logger,
-              deep_logging: deep_logging
-            )
-          end
-
-          # Creates a HTTP object adding the `X-ApiKey` or `X-ECOPORTAL-API-KEY` param to the header, depending on the API version.
-          # @note It configures HTTP so it only allows body data in json format.
-          # @return [HTTP] HTTP object.
-          def base_request
-            @base_request ||=
-              case @version
-              when NilClass, 'http'
-                HTTP
-              when 'v1', 'v0'
-                HTTP.headers('X-ApiKey' => key_token)
-              when 'v2', 'v3'
-                HTTP.headers('X-ECOPORTAL-API-KEY' => key_token)
-              when 'graphql'
-                HTTP.headers('Authorization' => "Bearer #{key_token}")
-              end.then do |request|
-                request.accept(:json).timeout(
-                  read:  READ_TIMEOUT,
-                  write: WRITE_TIMEOUT
-                )
-              end
-          end
-
-          def org_id
-            @org_id || fetch_env_required('ORGANIZATION_ID')
-          end
-
-          # Full URl builder of the request
-          # @param path [String] the tail that completes the url of the request.
-          # @return [String] the final url.
-          def url_for(path)
-            "#{api_url}#{path}"
-          end
-
-          private
-
-          def key_token
-            return                           if http?
-            return session_token(host: host) if graphql?
-            return @api_key                  if api_key?
-            return ENV['ORG_INT_KEY']        if v0?
-
-            puts 'Api-key missing!'
-          end
-
-          def api_url
-            base_url.then do |url|
-              next "#{url}/api/#{version}"        if v1_0? || v2_3?
-              next "#{url}/api/#{org_id}/graphql" if graphql?
-
-              url
-            end
-          end
-
-          def base_url
-            @base_url ||= self.class.base_url(host)
-          end
-
-          def protocol
-            @protocol ||= self.class.protocol(host)
-          end
-
-          def http?
-            return true if @version.nil?
-
-            @version == 'http'
-          end
-
-          def api_key?
-            @api_key && !@api_key.match(/\A\W*\z/)
-          end
-
-          def v1_0?
-            v1? || v0?
-          end
-
-          def v1?
-            @version == 'v1'
-          end
-
-          def v0?
-            @version == 'v0'
-          end
-
-          def v2_3?
-            return true if @version == 'v2'
-            return true if @version == 'v3'
-
-            false
-          end
-
-          def graphql?
-            @version == 'graphql'
-          end
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    module Common
+      module GraphQL
+        class ResponseError < StandardError; end
+
+        class HttpClient < Common::Client
+          class << self
+            def base_url(host)
+              "#{protocol(host)}://#{host}"
+            end
+
+            def protocol(host)
+              host.match(/^localhost|^127\.0\.0\.1/)? 'http' : 'https'
+            end
+          end
+
+          ENDPOINT_PATH = 'external/graphql'.freeze
+          READ_TIMEOUT  = 90
+          WRITE_TIMEOUT = 90
+
+          attr_reader :host, :version
+
+          # Publicly exposes the configured api_key (inherited as `private` from
+          # `Common::Client`) — `FileUpload::Client` needs it directly to authenticate
+          # against the v2 REST endpoints, independent of this client's own `@version`
+          # (which stays `'graphql'` and therefore always builds a Bearer `key_token`).
+          public :api_key
+
+          include Ecoportal::API::Common::GraphQL::AuthService
+
+          def initialize(
+            email:        nil,
+            pass:         nil,
+            org_id:       nil,
+            api_key:      nil,
+            version:      'graphql',
+            host:         'live.ecoportal.com',
+            logger:       ::Logger.new(IO::NULL),
+            deep_logging: false,
+            no_schema:    true
+          )
+            @org_id      = org_id
+            @user_email  = email
+            @user_pass   = pass
+            @no_schema   = no_schema
+            @version     = version
+
+            super(
+              api_key:      api_key,
+              host:         host,
+              logger:       logger,
+              deep_logging: deep_logging
+            )
+          end
+
+          # Creates a HTTP object adding the `X-ApiKey` or `X-ECOPORTAL-API-KEY` param to the header, depending on the API version.
+          # @note It configures HTTP so it only allows body data in json format.
+          # @return [HTTP] HTTP object.
+          def base_request
+            @base_request ||=
+              case @version
+              when NilClass, 'http'
+                HTTP
+              when 'v1', 'v0'
+                HTTP.headers('X-ApiKey' => key_token)
+              when 'v2', 'v3'
+                HTTP.headers('X-ECOPORTAL-API-KEY' => key_token)
+              when 'graphql'
+                HTTP.headers('Authorization' => "Bearer #{session_token(host: host)}")
+              end.then do |request|
+                request ||= HTTP
+                request.accept(:json).timeout(
+                  read:  READ_TIMEOUT,
+                  write: WRITE_TIMEOUT
+                )
+              end
+          end
+
+          def org_id
+            @org_id || fetch_env_required('ORGANIZATION_ID')
+          end
+
+          # Executes a GraphQL query or mutation over HTTP.
+          # @param query_string [String] full GraphQL query document.
+          # @param variables [Hash] variable values to pass to the operation.
+          # @param operation_name [String, nil] when the document has multiple operations.
+          # @return [Hash] parsed response body (string-keyed, includes 'data' and optionally 'errors').
+          # @raise [Ecoportal::API::Common::Client::Error::UnexpectedServerError] on non-2xx HTTP status.
+          # @raise [Ecoportal::API::Common::GraphQL::ResponseError] when the response body contains GraphQL errors.
+          def execute(query_string, variables: {}, operation_name: nil)
+            body = { query: query_string, variables: variables }
+            body[:operationName] = operation_name if operation_name
+
+            # Route through the inherited `Common::Client` pipeline
+            # (`instrument` -> `with_retry` { `rate_throttling` }) so GraphQL requests
+            # inherit the SAME battle-tested contingencies as the REST clients:
+            # rate-limit backoff (429 / Cloudflare 1015), 5xx + connection-error retries,
+            # timeouts, and instrumentation. Do NOT re-issue the request raw here — that
+            # bypasses all of the above and is what let live runs die on the first 429.
+            response = instrument('POST', ENDPOINT_PATH, body) do
+              request { |http| http.post(url_for(''), json: body) }
+            end
+
+            handle_http_response(response)
+          end
+
+          # Full URl builder of the request
+          # @param path [String] the tail that completes the url of the request.
+          # @return [String] the final url.
+          def url_for(path)
+            "#{api_url}#{path}"
+          end
+
+          private
+
+          def key_token
+            return                           if http?
+            return session_token(host: host) if graphql?
+            return @api_key                  if api_key?
+            return ENV['ORG_INT_KEY']        if v0?
+
+            puts 'Api-key missing!'
+          end
+
+          def api_url
+            base_url.then do |url|
+              next "#{url}/api/#{version}"                 if v1_0? || v2_3?
+              next "#{url}/api/#{org_id}/#{ENDPOINT_PATH}" if graphql?
+
+              url
+            end
+          end
+
+          def base_url
+            @base_url ||= self.class.base_url(host)
+          end
+
+          def protocol
+            @protocol ||= self.class.protocol(host)
+          end
+
+          def http?
+            return true if @version.nil?
+
+            @version == 'http'
+          end
+
+          def api_key?
+            @api_key && !@api_key.match(/\A\W*\z/)
+          end
+
+          def v1_0?
+            v1? || v0?
+          end
+
+          def v1?
+            @version == 'v1'
+          end
+
+          def v0?
+            @version == 'v0'
+          end
+
+          def v2_3?
+            return true if @version == 'v2'
+            return true if @version == 'v3'
+
+            false
+          end
+
+          def graphql?
+            @version == 'graphql'
+          end
+
+          # @param response [Ecoportal::API::Common::Response] the wrapped response
+          #   produced by the inherited pipeline (body already JSON-parsed).
+          def handle_http_response(response)
+            unless response.success?
+              raise Ecoportal::API::Common::Client::Error::UnexpectedServerError.new(
+                response.src_body, code: response.status.code
+              )
+            end
+
+            parsed = response.body
+            errors = parsed && parsed['errors']
+            raise ResponseError, errors.map { |e| e['message'] }.join('; ') if errors&.any?
+
+            parsed
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/common/graphql/model/as_input.rb

@@ -1,51 +1,54 @@
-module Ecoportal
-  module API
-    module Common
-      module GraphQL
-        class Model
-          # @todo
-          #   1. `#as_input` vs `#to_input` **or** named argument `klass`
-          #     One gets the `input` to be already used in a mutation query.
-          #     The other gets the `Input` class object out of the `Base/Model`.
-          #     - To figure out when `as_update` should be called.
-          #   2. Each Base/Model should have its `Input` class counterpart.
-          #     This could be auto-inflected (via namespace constant lookup)
-          #     at some point.
-          #   3. Think if a service class can be used to this purpose
-          #     (i.e. decorator of DiffService).
-          module AsInput
-            class << self
-              def included(base)
-                super
-
-                base.send(:include, Model::Diffable)
-                base.extend ClassMethods
-              end
-            end
-
-            module ClassMethods
-              def as_input(hash, clientMutationId: '')
-                hash_input = Ecoportal::API::Common::GraphQL::HashHelpers.
-                  keys_to_sym_deep(hash)
-
-                hash_input.merge!(clientMutationId: clientMutationId)
-
-                Ecoportal::API::Common::GraphQL::HashHelpers.
-                  remove_nil_keys_deep(hash_input, target: :id)
-              end
-            end
-
-            # INSTANCE METHODS
-
-            def as_input(clientMutationId: '')
-              self.class.as_input(
-                as_update,
-                clientMutationId: clientMutationId
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    module Common
+      module GraphQL
+        class Model
+          # @todo
+          #   1. `#as_input` vs `#to_input` **or** named argument `klass`
+          #     One gets the `input` to be already used in a mutation query.
+          #     The other gets the `Input` class object out of the `Base/Model`.
+          #     - To figure out when `as_update` should be called.
+          #   2. Each Base/Model should have its `Input` class counterpart.
+          #     This could be auto-inflected (via namespace constant lookup)
+          #     at some point.
+          #   3. Think if a service class can be used to this purpose
+          #     (i.e. decorator of DiffService).
+          module AsInput
+            class << self
+              def included(base)
+                super
+
+                base.send(:include, Model::Diffable)
+                base.extend ClassMethods
+              end
+            end
+
+            module ClassMethods
+              def as_input(hash, clientMutationId: '')
+                hash_input = Ecoportal::API::Common::GraphQL::HashHelpers.
+                  keys_to_sym_deep(hash)
+
+                hash_input.merge!(clientMutationId: clientMutationId)
+
+                Ecoportal::API::Common::GraphQL::HashHelpers.
+                  remove_nil_keys_deep(hash_input, target: :id)
+              end
+            end
+
+            # INSTANCE METHODS
+
+            def as_input(target_class: nil, clientMutationId: '')
+              return target_class.from_model(self, client_mutation_id: clientMutationId) if target_class
+
+              diff = as_update
+              return nil if diff.nil?
+
+              diff[:patchVer] = patchVer if respond_to?(:patchVer) && !patchVer.nil?
+              self.class.as_input(diff, clientMutationId: clientMutationId)
+            end
+          end
+        end
+      end
+    end
+  end
+end