lighthouse-graphql 0.1.0

data/lib/lighthouse/directives/registry.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Lighthouse
+  # Maps directive names to the classes that implement them, so the
+  # SchemaGenerator can dispatch by iterating the registry instead of a
+  # hardcoded `case` statement. Adding a directive is "write one class and
+  # register it" — no generator edits.
+  #
+  # Two registration styles are supported during the migration to clean,
+  # self-describing directive classes:
+  #
+  #   register('hasMany', SomeLegacyResolverClass)   # explicit name
+  #   register(MyDirectiveClass)                      # class responds to .directive_name
+  #
+  # A registered class is classified as a field resolver when it includes
+  # Contracts::FieldResolver OR responds to the legacy `#define_resolver`
+  # instance method.
+  class DirectiveRegistry
+    class << self
+      def default
+        @default ||= new.tap(&:register_defaults)
+      end
+
+      # Allow the host app to extend the default registry from an initializer.
+      def register(name_or_klass, klass = nil)
+        default.register(name_or_klass, klass)
+      end
+    end
+
+    def initialize
+      @resolution = {}
+      @arg_builders = {}
+      @sdl_manipulators = []
+    end
+
+    def register(name_or_klass, klass = nil)
+      if klass.nil? && name_or_klass.respond_to?(:directive_name)
+        klass = name_or_klass
+        name = klass.directive_name
+      else
+        name = name_or_klass
+      end
+
+      if arg_builder?(klass)
+        @arg_builders[name.to_s] = klass
+      elsif resolver?(klass)
+        @resolution[name.to_s] = klass
+      end
+      self
+    end
+
+    def resolution_class(name)
+      @resolution[name.to_s]
+    end
+
+    # Application order for wrapping/resolution directives on a field. Lower is
+    # applied first (innermost, closest to the data); higher is applied last
+    # (outermost, so it executes first). Authentication guards run outermost;
+    # @can wraps the resolver to authorize its result.
+    def resolution_order(name)
+      case name.to_s
+      when 'guard', 'auth' then 2
+      when 'can' then 1
+      else 0
+      end
+    end
+
+    def resolution_names
+      @resolution.keys
+    end
+
+    # Argument-builder directives (@eq, @neq, @in, @notIn, @like, @where,
+    # @orderBy) compose constraints onto a relation at resolve time.
+    def arg_builder_class(name)
+      @arg_builders[name.to_s]
+    end
+
+    def arg_builder_names
+      @arg_builders.keys
+    end
+
+    # SDL `directive @name(...) on ...` definitions contributed by registered,
+    # self-describing directive classes. The generator injects these so the app
+    # does not have to hand-declare every directive it uses.
+    # Returns { "name" => "directive @name(...) on ..." }.
+    def directive_definitions
+      definitions = {}
+      (@resolution.values + @arg_builders.values).uniq.each do |klass|
+        next unless klass.respond_to?(:directive_name) && klass.respond_to?(:definition)
+
+        text = safe_definition(klass)
+        definitions[klass.directive_name.to_s] = text if text
+      end
+      definitions
+    end
+
+    # Register an SDL manipulator: any object responding to `manipulate(sdl)` and
+    # returning the (possibly transformed) SDL string. These run before the
+    # schema is built to inject Connection/Paginator types, whereConditions
+    # inputs, orderBy enums, etc. Order of registration is preserved.
+    def register_manipulator(manipulator)
+      @sdl_manipulators << manipulator unless @sdl_manipulators.include?(manipulator)
+      self
+    end
+
+    def sdl_manipulators
+      @sdl_manipulators
+    end
+
+    # Fold every registered manipulator over the SDL string.
+    def manipulate_sdl(sdl)
+      @sdl_manipulators.reduce(sdl) { |acc, manipulator| manipulator.manipulate(acc) }
+    end
+
+    def register_defaults
+      dr = Lighthouse::GraphQL::DirectiveResolvers
+      {
+        'hasMany' => dr::HasManyDirectiveResolver,
+        'belongsTo' => dr::BelongsToDirectiveResolver,
+        'belongsToMany' => dr::BelongsToManyDirectiveResolver,
+        'hasOne' => dr::HasOneDirectiveResolver,
+        'all' => dr::AllDirectiveResolver,
+        'find' => dr::FindDirectiveResolver,
+        'first' => dr::FirstDirectiveResolver,
+        'paginate' => dr::PaginateDirectiveResolver,
+        'aggregate' => dr::AggregateDirectiveResolver,
+        'count' => dr::CountDirectiveResolver,
+        'field' => dr::FieldDirectiveResolver,
+        'rename' => dr::RenameDirectiveResolver,
+        'method' => dr::MethodDirectiveResolver,
+        'auth' => dr::AuthDirectiveResolver,
+        'guard' => dr::GuardDirectiveResolver,
+        'can' => dr::CanDirectiveResolver
+      }.each { |name, k| register(name, k) }
+
+      # Argument-builder filter/sort directives.
+      args = Lighthouse::GraphQL::Directives::Arguments
+      [args::Eq, args::Neq, args::In, args::NotIn, args::Like, args::Where, args::OrderBy]
+        .each { |k| register(k) }
+
+      # SDL manipulators run in registration order during the manipulation phase.
+      register_manipulator(Lighthouse::GraphQL::Directives::RelationDirective)
+      register_manipulator(Lighthouse::GraphQL::Directives::WhereConditionsDirective)
+
+      self
+    end
+
+    private
+
+    def safe_definition(klass)
+      klass.definition
+    rescue StandardError
+      nil
+    end
+
+    def arg_builder?(klass)
+      klass.respond_to?(:include?) && klass.include?(Lighthouse::Contracts::ArgBuilder)
+    end
+
+    def resolver?(klass)
+      return false unless klass
+
+      (klass.respond_to?(:include?) && klass.include?(Lighthouse::Contracts::FieldResolver)) ||
+        klass.method_defined?(:define_resolver) ||
+        klass.method_defined?(:resolve_field)
+    end
+  end
+end

data/lib/lighthouse/directives/relation_directive.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+module Lighthouse
+  module GraphQL
+    module Directives
+      # AST transformer that converts list-typed relationship fields annotated
+      # with relationship directives (e.g. @hasMany, @paginate) into
+      # Connection/Paginator return types and injects pagination arguments.
+      class RelationDirective
+        DIRECTIVE_NAMES = %w[hasMany belongsToMany hasManyThrough paginate all].freeze
+
+        def self.manipulate(sdl)
+          return sdl unless sdl.is_a?(String) && !sdl.empty?
+
+          begin
+            document = ::GraphQL::Language::Parser.parse(sdl)
+          rescue StandardError => e
+            warn("Lighthouse::GraphQL::Directives::RelationDirective: parse failed: #{e.class}: #{e.message}")
+            return sdl
+          end
+
+          existing_def_names = document.definitions.filter_map { |d| d.respond_to?(:name) ? d.name : nil }
+          produced_inner_types = []
+
+          document.definitions.each do |definition|
+            next unless definition.is_a?(::GraphQL::Language::Nodes::ObjectTypeDefinition)
+
+            definition.fields.each do |field|
+              next unless field.type
+              next if field.directives.nil? || field.directives.empty?
+              next unless field.directives.any? { |d| DIRECTIVE_NAMES.include?(d.name) }
+
+              list_inner = list_inner_named_type(field.type)
+              next unless list_inner
+
+              produce_connection, produce_paginator = pagination_kind_for(field.directives)
+              next unless produce_connection || produce_paginator
+
+              produced_inner_types << list_inner unless produced_inner_types.include?(list_inner)
+
+              # Replace list type with Connection/Paginator return type, preserving outer nullability.
+              new_named_type =
+                if produce_connection
+                  "#{list_inner}Connection"
+                else
+                  "#{list_inner}Paginator"
+                end
+
+              field.instance_variable_set(:@type, replace_with_named_type(field.type, new_named_type))
+
+              if produce_connection
+                field.instance_variable_set(:@arguments, ensure_connection_arguments(field.arguments || []))
+              end
+            end
+          end
+
+          return sdl if produced_inner_types.empty?
+
+          # Add Connection/Edge/Paginator utility types where missing.
+          new_defs = []
+          produced_inner_types.each do |inner|
+            conn_name = "#{inner}Connection"
+            edge_name = "#{inner}Edge"
+            paginator_name = "#{inner}Paginator"
+
+            unless existing_def_names.include?(conn_name)
+              new_defs << build_connection_type(conn_name, edge_name, inner)
+              existing_def_names << conn_name
+            end
+
+            unless existing_def_names.include?(edge_name)
+              new_defs << build_edge_type(edge_name, inner)
+              existing_def_names << edge_name
+            end
+
+            unless existing_def_names.include?(paginator_name)
+              new_defs << build_paginator_type(paginator_name, inner)
+              existing_def_names << paginator_name
+            end
+          end
+
+          unless existing_def_names.include?('PaginatorInfo')
+            new_defs << build_paginator_info_type
+            existing_def_names << 'PaginatorInfo'
+          end
+
+          unless existing_def_names.include?('PageInfo')
+            new_defs << build_page_info_type
+            existing_def_names << 'PageInfo'
+          end
+
+          modified_sdl = ::GraphQL::Language::Printer.new.print(document)
+          modified_sdl + "\n\n" + new_defs.map { |d| ::GraphQL::Language::Printer.new.print(d) }.join("\n\n")
+        end
+
+        def self.pagination_kind_for(directives)
+          # For relation directives, always use Connection.
+          if directives.any? { |d| d.name != 'paginate' && DIRECTIVE_NAMES.include?(d.name) }
+            return [true, false]
+          end
+
+          paginate = directives.find { |d| d.name == 'paginate' }
+          return [false, false] unless paginate
+
+          type_arg = directive_arg_literal(paginate, 'type')&.to_s&.upcase
+          if %w[CONNECTION CURSOR].include?(type_arg)
+            [true, false]
+          else
+            [false, true]
+          end
+        end
+
+        def self.directive_arg_literal(directive, name)
+          arg = directive.arguments&.find { |a| a.name == name }
+          return nil unless arg
+          arg.value.respond_to?(:value) ? arg.value.value : arg.value
+        end
+
+        def self.list_inner_named_type(type_node)
+          case type_node
+          when ::GraphQL::Language::Nodes::NonNullType
+            list_inner_named_type(type_node.of_type)
+          when ::GraphQL::Language::Nodes::ListType
+            unwrap_named_type(type_node.of_type)
+          else
+            nil
+          end
+        end
+
+        def self.unwrap_named_type(type_node)
+          case type_node
+          when ::GraphQL::Language::Nodes::NonNullType
+            unwrap_named_type(type_node.of_type)
+          when ::GraphQL::Language::Nodes::TypeName
+            type_node.name
+          else
+            nil
+          end
+        end
+
+        def self.replace_with_named_type(type_node, new_name)
+          new_type = ::GraphQL::Language::Nodes::TypeName.new(name: new_name)
+          if type_node.is_a?(::GraphQL::Language::Nodes::NonNullType)
+            ::GraphQL::Language::Nodes::NonNullType.new(of_type: new_type)
+          else
+            new_type
+          end
+        end
+
+        def self.ensure_connection_arguments(existing_args)
+          existing_names = existing_args.map(&:name)
+          args = existing_args.map do |arg|
+            next arg unless %w[after before first last].include?(arg.name)
+            next arg if arg.description && !arg.description.empty?
+
+            ::GraphQL::Language::Nodes::InputValueDefinition.new(
+              name: arg.name,
+              type: arg.type,
+              directives: arg.directives || [],
+              default_value: arg.default_value,
+              description: connection_arg_description(arg.name)
+            )
+          end
+
+          %w[after before first last].each do |name|
+            next if existing_names.include?(name)
+
+            type =
+              if %w[first last].include?(name)
+                ::GraphQL::Language::Nodes::TypeName.new(name: 'Int')
+              else
+                ::GraphQL::Language::Nodes::TypeName.new(name: 'String')
+              end
+
+            args << ::GraphQL::Language::Nodes::InputValueDefinition.new(
+              name: name,
+              type: type,
+              directives: [],
+              default_value: nil,
+              description: connection_arg_description(name)
+            )
+          end
+
+          args
+        end
+
+        def self.build_connection_type(conn_name, edge_name, node_name)
+          ::GraphQL::Language::Nodes::ObjectTypeDefinition.new(
+            name: conn_name,
+            interfaces: [],
+            directives: [],
+            description: "The connection type for #{node_name}.",
+            fields: [
+              ::GraphQL::Language::Nodes::FieldDefinition.new(
+                name: 'edges',
+                type: ::GraphQL::Language::Nodes::ListType.new(of_type: ::GraphQL::Language::Nodes::TypeName.new(name: edge_name)),
+                arguments: [],
+                directives: [],
+                description: 'A list of edges.'
+              ),
+              ::GraphQL::Language::Nodes::FieldDefinition.new(
+                name: 'nodes',
+                type: ::GraphQL::Language::Nodes::ListType.new(of_type: ::GraphQL::Language::Nodes::TypeName.new(name: node_name)),
+                arguments: [],
+                directives: [],
+                description: 'A list of nodes.'
+              ),
+              ::GraphQL::Language::Nodes::FieldDefinition.new(
+                name: 'pageInfo',
+                type: ::GraphQL::Language::Nodes::NonNullType.new(of_type: ::GraphQL::Language::Nodes::TypeName.new(name: 'PageInfo')),
+                arguments: [],
+                directives: [],
+                description: 'Information to aid in pagination.'
+              )
+            ]
+          )
+        end
+
+        def self.build_edge_type(edge_name, node_name)
+          ::GraphQL::Language::Nodes::ObjectTypeDefinition.new(
+            name: edge_name,
+            interfaces: [],
+            directives: [],
+            description: 'An edge in a connection.',
+            fields: [
+              ::GraphQL::Language::Nodes::FieldDefinition.new(
+                name: 'cursor',
+                type: ::GraphQL::Language::Nodes::NonNullType.new(of_type: ::GraphQL::Language::Nodes::TypeName.new(name: 'String')),
+                arguments: [],
+                directives: [],
+                description: 'A cursor for use in pagination.'
+              ),
+              ::GraphQL::Language::Nodes::FieldDefinition.new(
+                name: 'node',
+                type: ::GraphQL::Language::Nodes::TypeName.new(name: node_name),
+                arguments: [],
+                directives: [],
+                description: 'The item at the end of the edge.'
+              )
+            ]
+          )
+        end
+
+        def self.build_paginator_type(paginator_name, inner_name)
+          ::GraphQL::Language::Nodes::ObjectTypeDefinition.new(
+            name: paginator_name,
+            interfaces: [],
+            directives: [],
+            description: "A paginated list of #{inner_name} items.",
+            fields: [
+              ::GraphQL::Language::Nodes::FieldDefinition.new(
+                name: 'paginatorInfo',
+                type: ::GraphQL::Language::Nodes::NonNullType.new(of_type: ::GraphQL::Language::Nodes::TypeName.new(name: 'PaginatorInfo')),
+                arguments: [],
+                directives: [],
+                description: 'Pagination information about the list of items.'
+              ),
+              ::GraphQL::Language::Nodes::FieldDefinition.new(
+                name: 'data',
+                type: ::GraphQL::Language::Nodes::ListType.new(of_type: ::GraphQL::Language::Nodes::TypeName.new(name: inner_name)),
+                arguments: [],
+                directives: [],
+                description: "A list of #{inner_name} items."
+              )
+            ]
+          )
+        end
+
+        def self.build_paginator_info_type
+          ::GraphQL::Language::Nodes::ObjectTypeDefinition.new(
+            name: 'PaginatorInfo',
+            interfaces: [],
+            directives: [],
+            description: 'Information about pagination in a paginator.',
+            fields: [
+              field_def('count', 'Int', non_null: true),
+              field_def('currentPage', 'Int', non_null: true),
+              field_def('firstItem', 'Int'),
+              field_def('hasMorePages', 'Boolean', non_null: true),
+              field_def('lastItem', 'Int'),
+              field_def('lastPage', 'Int', non_null: true),
+              field_def('perPage', 'Int', non_null: true),
+              field_def('total', 'Int', non_null: true)
+            ]
+          )
+        end
+
+        def self.build_page_info_type
+          # Minimal Relay PageInfo. GraphQL-Ruby can also supply this via Relay,
+          # but SDL-first apps may not include it.
+          ::GraphQL::Language::Nodes::ObjectTypeDefinition.new(
+            name: 'PageInfo',
+            interfaces: [],
+            directives: [],
+            description: nil,
+            fields: [
+              field_def('hasNextPage', 'Boolean', non_null: true),
+              field_def('hasPreviousPage', 'Boolean', non_null: true),
+              field_def('startCursor', 'String'),
+              field_def('endCursor', 'String')
+            ]
+          )
+        end
+
+        def self.field_def(name, type_name, non_null: false)
+          type = ::GraphQL::Language::Nodes::TypeName.new(name: type_name)
+          type = ::GraphQL::Language::Nodes::NonNullType.new(of_type: type) if non_null
+          ::GraphQL::Language::Nodes::FieldDefinition.new(
+            name: name,
+            type: type,
+            arguments: [],
+            directives: [],
+            description: nil
+          )
+        end
+
+        def self.connection_arg_description(name)
+          case name
+          when 'after'
+            'Returns the elements in the list that come after the specified cursor.'
+          when 'before'
+            'Returns the elements in the list that come before the specified cursor.'
+          when 'first'
+            'Returns the first _n_ elements from the list.'
+          when 'last'
+            'Returns the last _n_ elements from the list.'
+          end
+        end
+      end
+    end
+  end
+end