graphiti_gql 0.1.0

data/lib/graphiti_gql/schema/list_arguments.rb

@@ -0,0 +1,127 @@
+module GraphitiGql
+  class Schema
+    class ListArguments
+      class SortDirType < GraphQL::Schema::Enum
+        graphql_name "SortDir"
+        value "asc", "Ascending"
+        value "desc", "Descending"
+      end
+
+      def initialize(resource, sideload = nil)
+        @resource = resource
+        @sideload = sideload
+      end
+
+      def apply(field)
+        define_filters(field) unless @resource.filters.empty?
+        define_sorts(field) unless @resource.sorts.empty?
+      end
+
+      private
+
+      def registry
+        Registry.instance
+      end
+
+      def define_filters(field)
+        filter_type = generate_filter_type(field)
+        required = @resource.filters.any? { |name, config|
+          value = !!config[:required]
+          if @sideload
+            value && @sideload.foreign_key != name
+          else
+            value
+          end
+        }
+        field.argument :filter, filter_type, required: required
+      end
+    
+      def generate_filter_type(field)
+        type_name = "#{registry.key_for(@resource)}Filter"
+        if (registered = registry[type_name])
+          return registered[:type]
+        end
+        klass = Class.new(GraphQL::Schema::InputObject)
+        klass.graphql_name type_name
+        @resource.filters.each_pair do |name, config|
+          attr_type = generate_filter_attribute_type(type_name, name, config)
+          klass.argument name.to_s.camelize(:lower),
+            attr_type,
+            required: !!config[:required]
+        end
+        registry[type_name] = { type: klass }
+        klass
+      end
+    
+      def generate_filter_attribute_type(type_name, filter_name, filter_config)
+        klass = Class.new(GraphQL::Schema::InputObject)
+        filter_graphql_name = "#{type_name}Filter#{filter_name.to_s.camelize(:lower)}"
+        klass.graphql_name(filter_graphql_name)
+        filter_config[:operators].keys.each do |operator|
+          canonical_graphiti_type = Graphiti::Types
+            .name_for(filter_config[:type])
+          type = GQL_TYPE_MAP[canonical_graphiti_type]
+          type = String if filter_name == :id
+          required = !!filter_config[:required] && operator == "eq"
+  
+          if (allowlist = filter_config[:allow])
+            type = define_allowlist_type(filter_graphql_name, allowlist)
+          end
+  
+          type = [type] unless !!filter_config[:single]
+          klass.argument operator, type, required: required
+        end
+        klass
+      end
+    
+      def define_allowlist_type(filter_graphql_name, allowlist)
+        name = "#{filter_graphql_name}Allow"
+        if (registered = registry[name])
+          return registered[:type]
+        end
+        klass = Class.new(GraphQL::Schema::Enum)
+        klass.graphql_name(name)
+        allowlist.each do |allowed|
+          klass.value(allowed)
+        end
+        registry[name] = { type: klass }
+        klass
+      end
+
+      def define_sorts(field)
+        sort_type = generate_sort_type
+        field.argument :sort, [sort_type], required: false
+      end
+
+      def generate_sort_att_type
+        type_name = "#{registry.key_for(@resource)}SortAtt"
+        if (registered = registry[type_name])
+          return registered[:type]
+        end
+        klass = Class.new(GraphQL::Schema::Enum) {
+          graphql_name(type_name)
+        }
+        @resource.sorts.each_pair do |name, config|
+          klass.value name.to_s.camelize(:lower), "Sort by #{name}"
+        end
+        registry[type_name] = { type: klass }
+        klass
+      end
+  
+      def generate_sort_type
+        type_name = "#{registry.key_for(@resource)}Sort"
+        if (registered = registry[type_name])
+          return registered[:type]
+        end
+        att_type = generate_sort_att_type
+        klass = Class.new(GraphQL::Schema::InputObject) {
+          graphql_name type_name
+          argument :att, att_type, required: true
+          argument :dir, SortDirType, required: true
+        }
+        registry[type_name] = { type: klass }
+        klass
+      end
+    end
+  end
+end

data/lib/graphiti_gql/schema/polymorphic_belongs_to_interface.rb

@@ -0,0 +1,35 @@
+module GraphitiGql
+  class Schema
+    class PolymorphicBelongsToInterface
+      def initialize(resource, sideload)
+        @resource = resource
+        @sideload = sideload
+      end
+
+      def build
+        return registry[name][:type] if registry[name]
+
+        klass = Module.new
+        klass.send :include, ResourceType::BaseInterface
+        klass.field :id, String, null: false
+        klass.field :_type, String, null: false
+        klass.graphql_name(name)
+        @sideload.children.values.each do |child|
+          registry.get(child.resource.class)[:type].implements(klass)
+        end
+        registry[name] = { type: klass }
+        registry[name]
+      end
+
+      private
+
+      def registry
+        Registry.instance
+      end
+
+      def name
+        "#{registry.key_for(@resource)}__#{@sideload.name}"
+      end
+    end
+  end
+end

data/lib/graphiti_gql/schema/query.rb

@@ -0,0 +1,62 @@
+module GraphitiGql
+  class Schema
+    class Query
+      def initialize(resources, existing_query: nil)
+        @resources = resources
+        @query_class = Class.new(existing_query || ::GraphQL::Schema::Object)
+        @query_class.graphql_name "Query"
+        @query_class.field_class ::GraphQL::Schema::Field
+      end
+
+      def build
+        @resources.each { |resource| ResourceType.new(resource).build }
+        define_entrypoints
+        add_relationships
+        @query_class
+      end
+
+      private
+
+      def registry
+        Registry.instance
+      end
+
+      def define_entrypoints
+        registry.resource_types.each do |registered|
+          if GraphitiGql.entrypoint?(registered[:resource])
+            Fields::Index.new(registered).apply(@query_class)
+            Fields::Show.new(registered).apply(@query_class)
+          end
+        end
+      end
+
+      def add_relationships
+        each_relationship do |type, sideload_type, sideload|
+          if [:has_many, :many_to_many].include?(sideload.type)
+            Fields::ToMany.new(sideload, sideload_type).apply(type)
+          else
+            Fields::ToOne.new(sideload, sideload_type).apply(type)
+          end
+        end
+      end
+
+      def each_relationship
+        registry.resource_types.each do |registered|
+          registered[:resource].sideloads.each do |name, sl|
+            next unless sl.readable?
+
+            registered_sl = if sl.type == :polymorphic_belongs_to
+              PolymorphicBelongsToInterface
+                .new(registered[:resource], sl)
+                .build
+            else
+              registry.get(sl.resource.class)
+            end
+
+            yield registered[:type], registered_sl[:type], sl
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_gql/schema/registry.rb

@@ -0,0 +1,67 @@
+module GraphitiGql
+  class Schema
+    class Registry
+      include Singleton
+
+      def initialize
+        clear
+      end
+
+      def get(object, interface: true)
+        @data[key_for(object, interface: interface)]
+      end
+
+      def set(resource, type, interface: true)
+        @data[key_for(resource, interface: interface)] = { resource: resource, type: type, interface: interface }
+      end
+
+      def key_for(object, interface: true)
+        if object.ancestors.include?(Graphiti::Resource) 
+          key = key_for_resource(object)
+          if object.polymorphic?
+            if !object.polymorphic_child? && interface
+              key = "I#{key}"
+            end
+          end
+          key
+        else
+          raise 'unknown object!'
+        end
+      end
+
+      def clear
+        @data = {}
+      end
+
+      def []=(key, value)
+        @data[key] = value
+      end
+
+      def [](key)
+        @data[key]
+      end
+
+      def key?(key)
+        @data.key?(key)
+      end
+
+      def values
+        @data.values
+      end
+
+      # When polymorphic parent, returns the Interface not the Class
+      def resource_types
+        values
+          .select { |v| v.key?(:resource) && !v[:interface] }
+          .map { |registered| get(registered[:resource]) }
+      end
+
+      private
+
+      def key_for_resource(resource)
+        resource.graphql_name ||
+          resource.name.gsub('Resource', '').gsub('::', '')
+      end
+    end
+  end
+end

data/lib/graphiti_gql/schema/resource_type.rb

@@ -0,0 +1,100 @@
+module GraphitiGql
+  class Schema
+    class ResourceType
+      module BaseInterface
+        include GraphQL::Schema::Interface
+
+        definition_methods do
+          # Optional: if this method is defined, it overrides `Schema.resolve_type`
+          def resolve_type(object, context)
+            return object.type if object.is_a?(Loaders::FakeRecord)
+            resource = object.instance_variable_get(:@__graphiti_resource)
+            Registry.instance.get(resource.class)[:type]
+          end
+        end
+      end
+
+      def initialize(resource, implements: nil)
+        @resource = resource
+        @implements = implements
+      end
+
+      def build
+        return registry.get(@resource)[:type] if registry.get(@resource)
+        type = build_base_type
+        registry_name = registry.key_for(@resource, interface: poly_parent?)
+        type.connection_type_class(build_connection_class)
+        type.graphql_name(registry_name)
+        type.implements(@implements) if @implements
+        add_fields(type, @resource)
+        registry.set(@resource, type, interface: poly_parent?)
+        process_polymorphic_parent(type) if poly_parent?
+        type
+      end
+
+      private
+
+      def process_polymorphic_parent(type)
+        # Define the actual class that implements the interface
+        registry.set(@resource, type, interface: false)
+        @resource.children.each do |child|
+          if (registered = registry.get(child))
+            registered[:type].implements(type)
+          else
+            self.class.new(child, implements: type).build
+          end
+        end
+      end
+
+      def poly_parent?
+        @resource.polymorphic? && !@resource.polymorphic_child?
+      end
+
+      def build_base_type
+        klass = nil
+        if poly_parent?
+          type_name = "I#{name}"
+          klass = Module.new
+          klass.send(:include, BaseInterface)
+          ctx = nil
+          klass.definition_methods { ctx = self }
+          ctx.define_method :resolve_type do |object, context|
+            resource = object.instance_variable_get(:@__graphiti_resource)
+            registry_name = Registry.instance.key_for(resource.class)
+            if resource.polymorphic?
+              resource = resource.class.resource_for_model(object)
+              registry_name = Registry.instance.key_for(resource)
+            end
+            Registry.instance[registry_name][:type]
+          end
+        else
+          klass = Class.new(GraphQL::Schema::Object)
+        end
+
+        klass
+      end
+
+      def registry
+        Registry.instance
+      end
+
+      def name
+        registry.key_for(@resource)
+      end
+  
+      def add_fields(type, resource)
+        resource.attributes.each_pair do |name, config|
+          if config[:readable]
+            Fields::Attribute.new(name, config).apply(type)
+          end
+        end
+      end
+
+      def build_connection_class
+        klass = Class.new(GraphQL::Types::Relay::BaseConnection)
+        Fields::Stats.new(@resource).apply(klass)
+        klass
+      end
+    end
+  end
+end

data/lib/graphiti_gql/schema/util.rb

@@ -0,0 +1,74 @@
+module GraphitiGql
+  class Schema
+    class Util
+      def self.params_from_args(arguments)
+        lookahead = arguments.delete(:lookahead)
+        params = arguments.as_json.deep_transform_keys { |key| key.to_s.underscore.to_sym }
+        if params[:sort]
+          params[:sort] = Util.transform_sort_param(params[:sort])
+        end
+
+        if (first = params.delete(:first))
+          params[:page] ||= {}
+          params[:page][:size] = first
+        end
+
+
+        if (last = params.delete(:last))
+          params[:page] ||= {}
+          params[:page][:size] = last
+          params[:reverse] = true
+        end
+
+        if (after = params.delete(:after))
+          params[:page] ||= {}
+          params[:page][:after] = after
+       end
+
+        if (before = params.delete(:before))
+          params[:page] ||= {}
+          params[:page][:before] = before
+        end
+
+        if (id = params.delete(:id))
+          params[:filter] ||= {}
+          params[:filter][:id] = { eq: id }
+        end
+
+        if lookahead.selects?(:stats)
+          stats = lookahead.selection(:stats)
+          payload = {}
+          stats.selections.map(&:name).each do |name|
+            payload[name] = stats.selection(name).selections.map(&:name)
+          end
+          params[:stats] = payload
+
+          # only requesting stats
+          if lookahead.selections.map(&:name) == [:stats]
+            params[:page] = { size: 0 }
+          end
+        end
+
+        params
+      end
+
+      def self.transform_sort_param(sorts)
+        sorts.map do |sort_param|
+          sort = sort_param[:att].underscore
+          sort = "-#{sort}" if sort_param[:dir] == "desc"
+          sort
+        end.join(",")
+      end
+
+      def self.is_readable_sideload!(sideload)
+        readable = sideload.instance_variable_get(:@readable)
+        if readable.is_a?(Symbol)
+          path = Graphiti.context[:object][:current_path].join(".")
+          unless sideload.parent_resource.send(readable)
+            raise Errors::UnauthorizedField.new(path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_gql/schema.rb

@@ -0,0 +1,46 @@
+module GraphitiGql
+  class Schema
+    GQL_TYPE_MAP = {
+      integer_id: String,
+      string: String,
+      uuid: String,
+      integer: Integer,
+      float: Float,
+      boolean: GraphQL::Schema::Member::GraphQLTypeNames::Boolean,
+      date: GraphQL::Types::ISO8601Date,
+      datetime: GraphQL::Types::ISO8601DateTime,
+      hash: GraphQL::Types::JSON,
+      array: [GraphQL::Types::JSON],
+      array_of_strings: [String],
+      array_of_integers: [Integer],
+      array_of_floats: [Float],
+      array_of_dates: [GraphQL::Types::ISO8601Date],
+      array_of_datetimes: [GraphQL::Types::ISO8601DateTime]
+    }
+
+    class RelayConnectionExtension < GraphQL::Schema::Field::ConnectionExtension
+      def resolve(object:, arguments:, context:)
+        next_args = arguments.dup
+        yield(object, next_args, arguments)
+      end
+    end
+
+    def initialize(resources)
+      @resources = resources
+    end
+
+    def generate
+      klass = Class.new(::GraphQL::Schema)
+      klass.query(Query.new(@resources).build)
+      klass.use(GraphQL::Batch)
+      klass.connections.add(ResponseShim, Connection)
+      klass.connections.add(Array, ToManyConnection)
+      klass
+    end
+  end
+end
+
+
+
+
+

data/lib/graphiti_gql/version.rb

@@ -0,0 +1,3 @@
+module GraphitiGql
+  VERSION = "0.1.0"
+end

data/lib/graphiti_gql.rb

@@ -0,0 +1,62 @@
+require "active_support/core_ext/object/json"
+require "graphql"
+require 'graphql/batch'
+require "graphiti_gql/graphiti_hax"
+require "graphiti_gql/version"
+require "graphiti_gql/errors"
+require "graphiti_gql/loaders/many"
+require "graphiti_gql/loaders/has_many"
+require "graphiti_gql/loaders/many_to_many"
+require "graphiti_gql/loaders/polymorphic_has_many"
+require "graphiti_gql/loaders/belongs_to"
+require "graphiti_gql/response_shim"
+require "graphiti_gql/schema"
+require "graphiti_gql/schema/connection"
+require "graphiti_gql/schema/registry"
+require "graphiti_gql/schema/util"
+require "graphiti_gql/schema/query"
+require "graphiti_gql/schema/resource_type"
+require "graphiti_gql/schema/polymorphic_belongs_to_interface"
+require "graphiti_gql/schema/list_arguments"
+require "graphiti_gql/schema/fields/show"
+require "graphiti_gql/schema/fields/index"
+require "graphiti_gql/schema/fields/to_many"
+require "graphiti_gql/schema/fields/to_one"
+require "graphiti_gql/schema/fields/attribute"
+require "graphiti_gql/schema/fields/stats"
+require "graphiti_gql/engine" if defined?(Rails)
+
+module GraphitiGql
+  class Error < StandardError; end
+
+  def self.schema!
+    Schema::Registry.instance.clear
+    resources ||= Graphiti.resources.reject(&:abstract_class?)
+    @schema = Schema.new(resources).generate
+  end
+
+  def self.schema
+    @schema
+  end
+
+  def self.entrypoints=(val)
+    @entrypoints = val
+  end
+
+  def self.entrypoints
+    @entrypoints
+  end
+
+  def self.entrypoint?(resource)
+    @entrypoints.nil? || @entrypoints.include?(resource)
+  end
+
+  def self.run(query_string, variables = {}, context = {})
+    Graphiti.with_context(context) do
+      result = schema.execute query_string,
+        variables: variables,
+        context: context
+      result.to_h
+    end
+  end
+end