lighthouse-graphql 0.1.1 → 0.2.1

data/lib/lighthouse/directive_resolvers/can_resolver.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      # @can — authorize access to a field using a policy ability (Pundit by
-      # default; configurable via Config.authorizer). Mirrors PHP Lighthouse's
-      # @can* family. Repeatable.
-      #
-      #   contact(id: ID!): Contact @field(resolver: "...") @can(ability: "show")
-      #
-      # Modes:
-      #   * default          — resolve the field, then authorize the resolved
-      #                        record (skips nil; passes collections through —
-      #                        use scoping for lists).
-      #   * root: true       — authorize the parent object before resolving.
-      #   * find / model     — look the model up by an argument and authorize it
-      #                        before resolving.
-      class CanDirectiveResolver < BaseDirectiveResolver
-        def self.directive_name = 'can'
-        def self.definition
-          'directive @can(ability: String!, find: String, model: String, root: Boolean) repeatable on FIELD_DEFINITION'
-        end
-
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          method_name = "resolve_field_#{field_name}"
-          ability = directive_arg('ability')
-          return if ability.nil?
-
-          find_arg = directive_arg('find')
-          model_name = directive_arg('model')
-          root = directive_arg('root')
-          inner = Resolution.capture(target_type_class, method_name, @field_def, field_name)
-          resolver_instance = self
-
-          wrapper = lambda do |obj, arguments, ctx|
-            if root
-              resolver_instance.send(:authorize_or_raise, ctx, obj, ability)
-              next inner.call(obj, arguments, ctx)
-            end
-
-            if find_arg && model_name
-              args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-              id = Lighthouse::Support::Naming.fetch_arg(args_h, find_arg)
-              model_class = resolver_instance.send(:constantize_model, model_name)
-              record = model_class&.find_by(id: id)
-              resolver_instance.send(:authorize_or_raise, ctx, record, ability)
-              next inner.call(obj, arguments, ctx)
-            end
-
-            result = inner.call(obj, arguments, ctx)
-            resolver_instance.send(:authorize_resolved, ctx, result, ability)
-          end
-
-          target_type_class.define_singleton_method(method_name, &wrapper)
-          @field_def.resolve_proc = wrapper if @field_def.respond_to?(:resolve_proc=)
-        end
-
-        private
-
-        def directive_arg(name)
-          Lighthouse::Support::DirectiveArgs.literal(@directive_node, name)
-        end
-
-        def authorize_resolved(ctx, result, ability)
-          return result if result.nil?
-          # Collections are filtered with scoping, not item-by-item authorization.
-          return result if result.respond_to?(:each) && !result.respond_to?(:id)
-
-          authorize_or_raise(ctx, result, ability)
-          result
-        end
-
-        def authorize_or_raise(ctx, record, ability)
-          return if record.nil?
-
-          authorized = Lighthouse::Support::Authorization.authorized?(ctx, record, ability)
-          raise(::GraphQL::ExecutionError, 'You are not authorized to perform this action.') unless authorized
-        end
-      end
-    end
-  end
-end

data/lib/lighthouse/directive_resolvers/has_many_resolver.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class HasManyDirectiveResolver < BaseDirectiveResolver
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          assoc_name = extract_relation_name || field_name
-          is_connection = @field_def.respond_to?(:connection?) ? @field_def.connection? : false
-
-          resolver_instance = self
-
-          # Keep compatibility with SchemaImplementation-based resolution by
-          # defining a singleton method on the owner type (e.g. Inbox.resolve_field_conversations).
-          method_name = "resolve_field_#{field_name}"
-
-          target_type_class.define_singleton_method(method_name) do |*args|
-            # Support both batch and single resolution modes.
-            # Batch mode signature: (objects_array, ctx)
-            # Single mode signature: (obj, arguments, ctx)
-            if args.length == 2 && args[0].is_a?(Array)
-              parents, ctx = args
-
-              if ctx && ctx.respond_to?(:dataloader) && ctx.dataloader
-                loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::AssociationLoader, parents.first.class, assoc_name)
-                parents.map do |p|
-                  promise = loader.load(p)
-                  if is_connection
-                    promise.then { |value| ::GraphQL::Pagination::ArrayConnection.new(value, context: ctx, parent: nil, field: nil, arguments: {}) }
-                  else
-                    promise
-                  end
-                end
-              else
-                parents.map do |p|
-                  value = p.respond_to?(assoc_name) ? p.public_send(assoc_name) : nil
-                  is_connection && value ? ::GraphQL::Pagination::ArrayConnection.new(value, context: ctx, parent: nil, field: nil, arguments: {}) : value
-                end
-              end
-            else
-              obj, arguments, ctx = args
-
-              # Use dataloader when available
-              if ctx && ctx.respond_to?(:dataloader) && ctx.dataloader
-                args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-                loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::AssociationLoader, obj.class, assoc_name)
-                value = loader.load(obj)
-                if is_connection
-                  value.then do |v|
-                    filtered = resolver_instance.apply_where_filters(v, args_h)
-                    ::GraphQL::Pagination::ArrayConnection.new(filtered, context: ctx, parent: nil, field: nil, arguments: {})
-                  end
-                else
-                  value.then { |v| resolver_instance.apply_where_filters(v, args_h) }
-                end
-              elsif obj.respond_to?(assoc_name)
-                args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-                value = obj.public_send(assoc_name)
-                value = resolver_instance.apply_where_filters(value, args_h)
-                is_connection && value ? ::GraphQL::Pagination::ArrayConnection.new(value, context: ctx, parent: nil, field: nil, arguments: {}) : value
-              else
-                nil
-              end
-            end
-          end
-
-          # Also attach a resolve proc where supported by the GraphQL runtime.
-          if @field_def.respond_to?(:resolve_proc=)
-            @field_def.resolve_proc = ->(obj, arguments, ctx) do
-              if ctx && ctx.respond_to?(:dataloader) && ctx.dataloader
-                args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-                loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::AssociationLoader, obj.class, assoc_name)
-                result = loader.load(obj)
-                if is_connection
-                  result.then do |value|
-                    filtered = resolver_instance.apply_where_filters(value, args_h)
-                    ::GraphQL::Pagination::ArrayConnection.new(filtered, context: ctx, parent: nil, field: nil, arguments: {})
-                  end
-                else
-                  result.then { |value| resolver_instance.apply_where_filters(value, args_h) }
-                end
-              elsif obj.respond_to?(assoc_name)
-                args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-                value = obj.public_send(assoc_name)
-                value = resolver_instance.apply_where_filters(value, args)
-                is_connection && value ? ::GraphQL::Pagination::ArrayConnection.new(value, context: ctx, parent: nil, field: nil, arguments: {}) : value
-              else
-                nil
-              end
-            end
-          end
-        end
-
-        private
-
-        def extract_relation_name
-          # directive syntax: @hasMany(relation: "name")
-          arg = @directive_node.arguments&.find { |a| a.name == 'relation' }
-          return nil unless arg
-          # value is AST literal node; use its value method if present
-          arg.value.respond_to?(:value) ? arg.value.value : arg.value
-        end
-      end
-    end
-  end
-end

data/lib/lighthouse/directive_resolvers/has_one_resolver.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      # @hasOne(relation: "name") — resolve a one-to-one association on the parent
-      # object. Mirrors @belongsTo (single record) and batch-loads through the
-      # AssociationLoader when a dataloader is available.
-      class HasOneDirectiveResolver < BaseDirectiveResolver
-        def self.directive_name = 'hasOne'
-        def self.definition = 'directive @hasOne(relation: String, scopes: [String!]) on FIELD_DEFINITION'
-
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          assoc_name = directive_arg('relation') || field_name
-          method_name = "resolve_field_#{field_name}"
-
-          resolver = lambda do |obj, _arguments, ctx|
-            next nil if obj.nil?
-
-            if ctx && ctx.respond_to?(:dataloader) && ctx.dataloader
-              loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::AssociationLoader, obj.class, assoc_name)
-              loader.load(obj)
-            elsif obj.respond_to?(assoc_name)
-              obj.public_send(assoc_name)
-            end
-          end
-
-          target_type_class.define_singleton_method(method_name, &resolver)
-          @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
-        end
-
-        private
-
-        def directive_arg(name)
-          Lighthouse::Support::DirectiveArgs.literal(@directive_node, name)
-        end
-      end
-    end
-  end
-end

data/lib/lighthouse/directives/relation_directive.rb

@@ -1,332 +0,0 @@
-# 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