insights-api-common 3.0.0

data/lib/insights/api/common/engine.rb

@@ -0,0 +1,20 @@
+module Insights
+  module API
+    module Common
+      class Engine < ::Rails::Engine
+        isolate_namespace Insights::API::Common
+
+        config.autoload_paths << root.join("lib").to_s
+
+        initializer :load_inflections do
+          Insights::API::Common::Inflections.load_inflections
+        end
+
+        initializer :patch_option_redirect_routing do
+          require 'action_dispatch/routing/redirection'
+          ActionDispatch::Routing::OptionRedirect.prepend(Insights::API::Common::OptionRedirectEnhancements)
+        end
+      end
+    end
+  end
+end

data/lib/insights/api/common/entitlement.rb

@@ -0,0 +1,37 @@
+module Insights
+  module API
+    module Common
+      class EntitlementError < StandardError; end
+
+      class Entitlement
+        def initialize(identity)
+          @identity = identity
+        end
+
+        %w[
+          ansible
+          hybrid_cloud
+          insights
+          migrations
+          openshift
+          smart_management
+        ].each do |m|
+          define_method("#{m}?") do
+            find_entitlement_key(m)
+          end
+        end
+
+        private
+
+        attr_reader :identity
+
+        def find_entitlement_key(key)
+          result = identity.dig('entitlements', key.to_s)
+          # TODO: Always force entitlements key
+          return true unless result
+          result['is_entitled']
+        end
+      end
+    end
+  end
+end

data/lib/insights/api/common/error_document.rb

@@ -0,0 +1,29 @@
+module Insights
+  module API
+    module Common
+      class ErrorDocument
+        def add(status = 400, message)
+          @status = status
+          errors << {"status" => status, "detail" => message}
+          self
+        end
+
+        def errors
+          @errors ||= []
+        end
+
+        def status
+          @status
+        end
+
+        def blank?
+          errors.blank?
+        end
+
+        def to_h
+          {"errors" => errors}
+        end
+      end
+    end
+  end
+end

data/lib/insights/api/common/filter.rb

@@ -0,0 +1,175 @@
+module Insights
+  module API
+    module Common
+      class Filter
+        INTEGER_COMPARISON_KEYWORDS = ["eq", "gt", "gte", "lt", "lte", "nil", "not_nil"].freeze
+        STRING_COMPARISON_KEYWORDS  = ["contains", "contains_i", "eq", "eq_i", "starts_with", "starts_with_i", "ends_with", "ends_with_i", "nil", "not_nil"].freeze
+
+        attr_reader :apply, :arel_table, :api_doc_definition
+
+        def initialize(model, raw_filter, api_doc_definition)
+          self.query          = model
+          @arel_table         = model.arel_table
+          @raw_filter         = raw_filter
+          @api_doc_definition = api_doc_definition
+        end
+
+        def apply
+          return query if @raw_filter.blank?
+          @raw_filter.each do |k, v|
+            next unless attribute = attribute_for_key(k)
+
+            if attribute["type"] == "string"
+              type = determine_string_attribute_type(attribute)
+              send(type, k, v)
+            else
+              errors << "unsupported attribute type for: #{k}"
+            end
+          end
+
+          raise(Insights::API::Common::Filter::Error, errors.join(", ")) unless errors.blank?
+          query
+        end
+
+        private
+
+        attr_accessor :query
+
+        class Error < ArgumentError; end
+
+        def attribute_for_key(key)
+          attribute = api_doc_definition.properties[key.to_s]
+          return attribute if attribute
+          errors << "found unpermitted parameter: #{key}"
+          nil
+        end
+
+        def determine_string_attribute_type(attribute)
+          return :timestamp if attribute["format"] == "date-time"
+          return :integer if attribute["pattern"] == /^\d+$/
+          :string
+        end
+
+        def errors
+          @errors ||= []
+        end
+
+        def string(k, val)
+          if val.kind_of?(ActionController::Parameters)
+            val.each do |comparator, value|
+              add_filter(comparator, STRING_COMPARISON_KEYWORDS, k, value)
+            end
+          else
+            add_filter("eq", STRING_COMPARISON_KEYWORDS, k, val)
+          end
+        end
+
+        def add_filter(requested_comparator, allowed_comparators, key, value)
+          return unless attribute = attribute_for_key(key)
+          type = determine_string_attribute_type(attribute)
+
+          if requested_comparator.in?(["nil", "not_nil"])
+            send("comparator_#{requested_comparator}", key, value)
+          elsif requested_comparator.in?(allowed_comparators)
+            value = parse_datetime(value) if type == :datetime
+            return if value.nil?
+            send("comparator_#{requested_comparator}", key, value)
+          else
+            errors << "unsupported #{type} comparator: #{requested_comparator}"
+          end
+        end
+
+        def timestamp(k, val)
+          if val.kind_of?(ActionController::Parameters)
+            val.each do |comparator, value|
+              add_filter(comparator, INTEGER_COMPARISON_KEYWORDS, k, value)
+            end
+          else
+            add_filter("eq", INTEGER_COMPARISON_KEYWORDS, k, val)
+          end
+        end
+
+        def parse_datetime(value)
+          return value.collect { |i| parse_datetime(i, ) } if value.kind_of?(Array)
+
+          DateTime.parse(value)
+        rescue ArgumentError
+          errors << "invalid timestamp: #{value}"
+          return nil
+        end
+
+        def integer(k, val)
+          if val.kind_of?(ActionController::Parameters)
+            val.each do |comparator, value|
+              add_filter(comparator, INTEGER_COMPARISON_KEYWORDS, k, value)
+            end
+          else
+            add_filter("eq", INTEGER_COMPARISON_KEYWORDS, k, val)
+          end
+        end
+
+        def comparator_contains(key, value)
+          return value.each { |v| comparator_contains(key, v) } if value.kind_of?(Array)
+
+          self.query = query.where(arel_table[key].matches("%#{query.sanitize_sql_like(value)}%", nil, true))
+        end
+
+        def comparator_contains_i(key, value)
+          return value.each { |v| comparator_contains_i(key, v) } if value.kind_of?(Array)
+
+          self.query = query.where(arel_table[key].lower.matches("%#{query.sanitize_sql_like(value.downcase)}%", nil, true))
+        end
+
+        def comparator_starts_with(key, value)
+          self.query = query.where(arel_table[key].matches("#{query.sanitize_sql_like(value)}%", nil, true))
+        end
+
+        def comparator_starts_with_i(key, value)
+          self.query = query.where(arel_table[key].lower.matches("#{query.sanitize_sql_like(value.downcase)}%", nil, true))
+        end
+
+        def comparator_ends_with(key, value)
+          self.query = query.where(arel_table[key].matches("%#{query.sanitize_sql_like(value)}", nil, true))
+        end
+
+        def comparator_ends_with_i(key, value)
+          self.query = query.where(arel_table[key].lower.matches("%#{query.sanitize_sql_like(value.downcase)}", nil, true))
+        end
+
+        def comparator_eq(key, value)
+          self.query = query.where(key => value)
+        end
+
+        def comparator_eq_i(key, value)
+          values = Array(value).map { |v| query.sanitize_sql_like(v.downcase) }
+
+          self.query = query.where(arel_table[key].lower.matches_any(values))
+        end
+
+        def comparator_gt(key, value)
+          self.query = query.where(arel_table[key].gt(value))
+        end
+
+        def comparator_gte(key, value)
+          self.query = query.where(arel_table[key].gteq(value))
+        end
+
+        def comparator_lt(key, value)
+          self.query = query.where(arel_table[key].lt(value))
+        end
+
+        def comparator_lte(key, value)
+          self.query = query.where(arel_table[key].lteq(value))
+        end
+
+        def comparator_nil(key, _value = nil)
+          self.query = query.where(key => nil)
+        end
+
+        def comparator_not_nil(key, _value = nil)
+          self.query = query.where.not(key => nil)
+        end
+      end
+    end
+  end
+end

data/lib/insights/api/common/graphql.rb

@@ -0,0 +1,127 @@
+require "graphql"
+require "graphql/batch"
+require "graphql/preload"
+
+require "insights/api/common/graphql/association_loader"
+require "insights/api/common/graphql/associated_records"
+require "insights/api/common/graphql/generator"
+require "insights/api/common/graphql/types/big_int"
+require "insights/api/common/graphql/types/date_time"
+require "insights/api/common/graphql/types/query_filter"
+require "insights/api/common/graphql/types/query_sort_by"
+
+module Insights
+  module API
+    module Common
+      module GraphQL
+        module Api
+        end
+
+        def self.version(request)
+          /\/?\w+\/v(?<major>\d+)[x\.]?(?<minor>\d+)?\// =~ request.original_url
+          [major, minor].compact.join(".")
+        end
+
+        def self.openapi_graphql_description
+          {
+            "summary"     => "Perform a GraphQL Query",
+            "operationId" => "postGraphQL",
+            "description" => "Performs a GraphQL Query",
+            "requestBody" => {
+              "content"     => {
+                "application/json" => {
+                  "schema" => {
+                    "$ref" => "#/components/schemas/GraphQLRequest"
+                  }
+                }
+              },
+              "description" => "GraphQL Query Request",
+              "required"    => true
+            },
+            "responses"   => {
+              "200" => {
+                "description" => "GraphQL Query Response",
+                "content"     => {
+                  "application/json" => {
+                    "schema" => {
+                      "$ref" => "#/components/schemas/GraphQLResponse"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        end
+
+        def self.openapi_graphql_request
+          {
+            "type"       => "object",
+            "properties" => {
+              "query"         => {
+                "type"        => "string",
+                "description" => "The GraphQL query",
+                "default"     => "{}"
+              },
+              "operationName" => {
+                "type"        => "string",
+                "description" => "If the Query contains several named operations, the operationName controls which one should be executed",
+                "default"     => ""
+              },
+              "variables"     => {
+                "type"        => "object",
+                "description" => "Optional Query variables",
+                "nullable"    => true
+              }
+            },
+            "required"   => [
+              "query"
+            ]
+          }
+        end
+
+        def self.openapi_graphql_response
+          {
+            "type"       => "object",
+            "properties" => {
+              "data"   => {
+                "type"        => "object",
+                "description" => "Results from the GraphQL query"
+              },
+              "errors" => {
+                "type"        => "array",
+                "description" => "Errors resulting from the GraphQL query",
+                "items"       => {
+                  "type" => "object"
+                }
+              }
+            }
+          }
+        end
+
+        def self.search_options(scope, args)
+          args[:id] ? scope.where(:id => args[:id]) : scope
+        end
+
+        # Following code is auto-generated via rails generate graphql:install
+        #
+        # Handle form data, JSON body, or a blank value
+        def self.ensure_hash(ambiguous_param)
+          case ambiguous_param
+          when String
+            if ambiguous_param.present?
+              ensure_hash(JSON.parse(ambiguous_param))
+            else
+              {}
+            end
+          when Hash, ActionController::Parameters
+            ambiguous_param
+          when nil
+            {}
+          else
+            raise ArgumentError, "Unexpected parameter: #{ambiguous_param}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/insights/api/common/graphql/associated_records.rb

@@ -0,0 +1,44 @@
+require "query_relation"
+
+module Insights
+  module API
+    module Common
+      module GraphQL
+        class AssociatedRecords
+          include Enumerable
+          include QueryRelation::Queryable
+
+          def initialize(collection)
+            @collection = collection
+          end
+
+          private
+
+          def search(mode, options)
+            res = filter_collection_by_options(options)
+
+            case mode
+            when :first then res.first
+            when :last  then res.last
+            when :all   then res
+            end
+          end
+
+          def filter_collection_by_options(options)
+            res = @collection
+            if options[:where].present?
+              options[:where].each_pair { |k, v| res = res.select { |rec| rec[k].to_s == v.to_s } }
+            end
+            if options[:order].present?
+              order_by = options[:order].first
+              res = res.sort_by { |rec| rec[order_by] }
+            end
+            res = res.drop(options[:offset]) if options[:offset]
+            res = res.take(options[:limit])  if options[:limit]
+            res
+          end
+        end
+      end
+    end
+  end
+end

data/lib/insights/api/common/graphql/association_loader.rb

@@ -0,0 +1,35 @@
+module Insights
+  module API
+    module Common
+      module GraphQL
+        class AssociationLoader < ::GraphQL::Batch::Loader
+          attr_reader :args, :association_name, :model
+
+          def initialize(model, association_name, args = {})
+            @model            = model
+            @association_name = association_name
+            @args             = args
+          end
+
+          def cache_key(record)
+            record.object_id
+          end
+
+          def perform(records)
+            records.each { |record| fulfill(record, read_association(record)) }
+          end
+
+          private
+
+          def read_association(record)
+            recs = GraphQL::AssociatedRecords.new(record.public_send(association_name))
+            recs = GraphQL.search_options(recs, args)
+            PaginatedResponse.new(
+              :base_query => recs, :request => nil, :limit => args[:limit], :offset => args[:offset]
+            ).records
+          end
+        end
+      end
+    end
+  end
+end