lighthouse-graphql 0.1.0

data/lib/lighthouse/directive_resolvers/has_one_resolver.rb

@@ -0,0 +1,43 @@
+# 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/directive_resolvers/method_resolver.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Lighthouse
+  module GraphQL
+    module DirectiveResolvers
+      # @method(name: "someMethod") — resolve the field by calling a method on the
+      # parent object. Mirrors PHP Lighthouse's @method. Defaults to the field's
+      # own (snake_cased) name when `name` is omitted.
+      #
+      #   labels: [String!]! @method(name: "label_list")
+      #   canReply: Boolean   @method(name: "can_reply?")
+      class MethodDirectiveResolver < BaseDirectiveResolver
+        def self.directive_name = 'method'
+        def self.definition = 'directive @method(name: String) on FIELD_DEFINITION'
+
+        def define_resolver(target_type_class)
+          resolver_method = "resolve_field_#{@field_def.name}"
+          target_method = (Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'name') ||
+                           Lighthouse::Support::Naming.attribute(@field_def.name)).to_s
+
+          resolver = lambda do |obj, _arguments, _ctx|
+            next nil if obj.nil?
+
+            obj.respond_to?(target_method) ? obj.public_send(target_method) : nil
+          end
+
+          target_type_class.define_singleton_method(resolver_method, &resolver)
+          @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
+        end
+      end
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/paginate_resolver.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+require_relative 'base'
+require_relative 'builder_applier'
+
+module Lighthouse
+  module GraphQL
+    module DirectiveResolvers
+      class PaginateDirectiveResolver < BaseDirectiveResolver
+        class PaginatorResult
+          attr_reader :paginator_info, :data
+
+          def initialize(paginator_info:, data:)
+            @paginator_info = paginator_info
+            @data = data
+          end
+
+          def paginatorInfo
+            @paginator_info
+          end
+        end
+
+        def define_resolver(target_type_class)
+          field_name = @field_def.name
+          method_name = "resolve_field_#{field_name}"
+
+          # Resolve model name now, but constantize lazily at call time so
+          # Rails autoloading (Zeitwerk) can load the model after startup.
+          model_name_static = extract_model_name || extract_model_name_from_field_type
+          # If the field was transformed to a Paginator type (e.g. InboxPaginator),
+          # derive the underlying model name by stripping a trailing "Paginator".
+          model_name_static = model_name_static.to_s.sub(/Paginator\z/, '')
+          # Closure to lookup the model class lazily
+          model_lookup = proc { constantize_model(model_name_static) }
+
+
+
+          # Determine whether this paginate directive requested a cursor/connection
+          type_arg = extract_type_name
+          is_connection_type = type_arg && %w[CONNECTION CURSOR].include?(type_arg.to_s.upcase)
+
+          # Paginator object builder (responds to both `paginatorInfo` and `paginator_info`)
+          paginator_builder = proc do |pinfo, data|
+            paginator_info_object = OpenStruct.new(pinfo)
+            # Ensure both camelCase and underscored-methods can be resolved by fallback
+            if pinfo.is_a?(Hash)
+              underscored = {}
+              pinfo.each_key do |k|
+                key = k.to_s
+                snake = key.underscore
+                underscored[snake] = pinfo[k] unless pinfo.key?(snake)
+              end
+              underscored.each { |kk, vv| paginator_info_object[kk] = vv }
+            end
+
+            PaginatorResult.new(paginator_info: paginator_info_object, data: data)
+          end
+
+          # Define owner singleton method to support graphql-ruby's execution
+          resolver_instance = self
+          field_ast_node = @field_def.ast_node
+          target_type_class.define_singleton_method(method_name) do |obj, arguments, ctx|
+            model_class = model_lookup.call
+            return [] unless model_class
+
+            args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
+
+            limit = args_h[:first]
+            offset = 0
+            if args_h[:after]
+              begin
+                decoded = Base64.decode64(args_h[:after])
+                if decoded.start_with?('offset:')
+                  offset = decoded.split(':', 2)[1].to_i
+                end
+              rescue StandardError
+                offset = 0
+              end
+            end
+
+            relation = model_class.all
+
+            relation = DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args_h, ctx, resolver_instance)
+
+            relation = DirectiveResolvers::WhereConditionsApplier.apply(relation, args_h[:where] || args_h['where'])
+            relation = relation.offset(offset) if offset > 0
+            relation = relation.limit(limit) if limit
+
+            if is_connection_type
+              ::GraphQL::Pagination::ArrayConnection.new(relation, context: ctx, parent: nil, field: nil, arguments: {})
+            else
+              data = relation.to_a
+              per_page = limit
+              total = relation.count
+              paginator_info = {
+                count: data.size,
+                currentPage: 1,
+                firstItem: data.any? ? (offset + 1) : nil,
+                hasMorePages: (offset + data.size) < total,
+                lastItem: data.any? ? (offset + data.size) : nil,
+                lastPage: per_page && per_page > 0 ? (total.to_f / per_page).ceil : 1,
+                perPage: per_page || data.size,
+                total: total
+              }
+
+              paginator_builder.call(paginator_info, data)
+            end
+          end
+
+          # Attach a field-level resolve_proc that delegates to the generated
+          # singleton resolver. This keeps runtime dispatch consistent with
+          # SchemaImplementation (which checks for resolve_field_* first).
+          if @field_def.respond_to?(:resolve_proc=)
+            @field_def.resolve_proc = ->(obj, arguments, ctx) do
+              target_type_class.public_send(method_name, obj, arguments, ctx)
+            end
+          end
+        end
+
+        private
+
+        def extract_model_name
+          arg = @directive_node.arguments&.find { |a| a.name == 'model' }
+          return nil unless arg
+          arg.value.respond_to?(:value) ? arg.value.value : arg.value
+        end
+
+
+        def extract_type_name
+          arg = @directive_node.arguments&.find { |a| a.name == 'type' }
+          return nil unless arg
+          arg.value.respond_to?(:value) ? arg.value.value : arg.value
+        end
+
+        def extract_model_name_from_field_type
+          unwrapped = @field_def.type.respond_to?(:unwrap) ? @field_def.type.unwrap : @field_def.type
+          return unwrapped.graphql_name if unwrapped.respond_to?(:graphql_name) && unwrapped.graphql_name
+          return unwrapped.name if unwrapped.respond_to?(:name) && unwrapped.name
+
+          # fallback for late-bound signatures like "InboxPaginator!"
+          @field_def.type.to_type_signature.to_s.gsub(/[!\[\]]/, '')
+        end
+      end
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/rename_resolver.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Lighthouse
+  module GraphQL
+    module DirectiveResolvers
+      # @rename(attribute: "snake_case_name") — explicit override of the default
+      # field reader. Reads the named attribute off the parent object regardless
+      # of the GraphQL field name.
+      class RenameDirectiveResolver < BaseDirectiveResolver
+        def self.directive_name = 'rename'
+        def self.definition = 'directive @rename(attribute: String!) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION'
+
+        def define_resolver(target_type_class)
+          method_name = "resolve_field_#{@field_def.name}"
+          attribute = Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'attribute').to_s
+
+          resolver = lambda do |obj, _arguments, _ctx|
+            next nil if obj.nil?
+
+            if obj.is_a?(Hash)
+              obj[attribute] || obj[attribute.to_sym]
+            elsif obj.respond_to?(attribute)
+              obj.public_send(attribute)
+            end
+          end
+
+          target_type_class.define_singleton_method(method_name, &resolver)
+          @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
+        end
+      end
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/resolution.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Lighthouse
+  module GraphQL
+    module DirectiveResolvers
+      # Helper for "middleware" directives (@guard, @can) that need to wrap a
+      # field's existing resolver.
+      module Resolution
+        module_function
+
+        # Capture the field's current resolver (generated singleton method,
+        # resolve_proc, or the default attribute reader) as a callable
+        # (obj, args, ctx) -> value, so it can be wrapped. The returned callable
+        # is unaffected by subsequently redefining the singleton method.
+        def capture(target_type_class, method_name, field_def, field_name)
+          original_singleton = target_type_class.method(method_name) if target_type_class.respond_to?(method_name)
+          original_proc = field_def.resolve_proc if field_def.respond_to?(:resolve_proc) && field_def.resolve_proc
+
+          lambda do |obj, arguments, ctx|
+            if original_singleton
+              original_singleton.call(obj, arguments, ctx)
+            elsif original_proc
+              original_proc.call(obj, arguments, ctx)
+            elsif obj.respond_to?(field_name)
+              obj.public_send(field_name)
+            else
+              snake = Lighthouse::Support::Naming.attribute(field_name)
+              obj.respond_to?(snake) ? obj.public_send(snake) : nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/where_conditions_applier.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Lighthouse
+  module GraphQL
+    module DirectiveResolvers
+      class WhereConditionsApplier
+        # Operator semantics live in Lighthouse::WhereConditions::OperatorMap so
+        # they can be shared with the simple argument-filter directives.
+        SUPPORTED_OPERATORS = Lighthouse::WhereConditions::OperatorMap::OPERATORS
+
+        class << self
+          def apply(relation, value)
+            return relation unless relation.respond_to?(:where)
+            return relation if value.nil?
+
+            condition = value.is_a?(Hash) ? value.deep_symbolize_keys : symbolized(value)
+            return relation unless condition.is_a?(Hash)
+
+            result = relation
+
+            if condition.key?(:AND)
+              Array(condition[:AND]).each do |sub|
+                result = apply(result, sub)
+              end
+            end
+
+            if condition.key?(:OR)
+              or_rel = nil
+              Array(condition[:OR]).each do |sub|
+                sub_scope = apply(relation, sub)
+                or_rel = or_rel ? or_rel.or(sub_scope) : sub_scope
+              end
+              result = or_rel if or_rel
+            end
+
+            if condition.key?(:HAS)
+              has_cond = condition[:HAS]
+              if has_cond.is_a?(Hash) && has_cond[:relation]
+                result = apply_has(result, has_cond)
+              end
+            end
+
+            if condition.key?(:column)
+              result = apply_single_condition(result, condition)
+            end
+
+            result
+          end
+
+          def apply_has(relation, has_cond)
+            relation_name = has_cond[:relation].to_s
+            return relation unless relation_name.present?
+
+            resolved_relation_name = resolve_relation_name(relation, relation_name)
+            return relation unless resolved_relation_name.present?
+
+            source_klass = relation.respond_to?(:klass) ? relation.klass : relation
+            reflection = source_klass.respond_to?(:reflect_on_association) ? source_klass.reflect_on_association(resolved_relation_name.to_sym) : nil
+            return relation unless reflection&.klass
+
+            if has_cond[:condition].present?
+              child_scope = reflection.klass.all
+              child_scope = apply(child_scope, has_cond[:condition])
+
+              # Use an EXISTS-style filter to safely apply conditions from the related model.
+              table_name = reflection.klass.table_name
+              relation.joins(resolved_relation_name.to_sym)
+                      .where(table_name => { id: child_scope.select(:id) })
+                      .distinct
+            else
+              relation.joins(resolved_relation_name.to_sym).distinct
+            end
+          rescue StandardError
+            relation
+          end
+
+          def resolve_relation_name(relation, relation_name)
+            candidate_names = [relation_name.to_s, relation_name.to_s.singularize, relation_name.to_s.pluralize].uniq
+
+            candidate_names.each do |candidate|
+              next if candidate.blank?
+              return candidate if association_exists?(relation, candidate)
+            end
+
+            nil
+          rescue StandardError
+            nil
+          end
+
+          def association_exists?(relation, name)
+            klass = relation.respond_to?(:klass) ? relation.klass : relation
+            return false unless klass.respond_to?(:reflect_on_association)
+
+            klass.reflect_on_association(name.to_sym).present?
+          rescue StandardError
+            false
+          end
+
+          def apply_has_argument(relation, arg_name, arg_value, relation_name = nil)
+            relation_name ||= derive_relation_name(arg_name)
+            return relation unless relation_name.present? && arg_value.present?
+
+            condition = arg_value.is_a?(Hash) ? arg_value : symbolized(arg_value)
+            has_payload = { relation: relation_name, condition: condition }
+            apply_has(relation, has_payload)
+          end
+
+          private
+
+          def derive_relation_name(arg_name)
+            Lighthouse::Support::Naming.derive_relation_name(arg_name)
+          end
+
+          def apply_single_condition(relation, condition)
+            col = condition[:column]
+            op = condition[:operator]&.to_s&.upcase || 'EQ'
+            value = condition[:value]
+
+            return relation if col.blank? || !relation.respond_to?(:where)
+
+            column_name = resolve_column_name(col)
+            return relation if column_name.blank?
+
+            case op
+            when 'IS_NULL'
+              relation.where(column_name => nil)
+            when 'IS_NOT_NULL'
+              relation.where.not(column_name => nil)
+            when 'IN'
+              relation.where(column_name => Array(value))
+            when 'NIN'
+              relation.where.not(column_name => Array(value))
+            when 'CONTAINS'
+              relation.where(arel_table(relation)[column_name].matches("%#{value}%"))
+            when 'STARTS_WITH'
+              relation.where(arel_table(relation)[column_name].matches("#{value}%"))
+            when 'ENDS_WITH'
+              relation.where(arel_table(relation)[column_name].matches("%#{value}"))
+            else
+              if SUPPORTED_OPERATORS[op]
+                relation.where(arel_table(relation)[column_name].public_send(SUPPORTED_OPERATORS[op], value))
+              else
+                relation.where(column_name => value)
+              end
+            end
+          rescue StandardError
+            relation
+          end
+
+          def resolve_column_name(column)
+            Lighthouse::Support::Naming.column(column)
+          end
+
+          def arel_table(relation)
+            relation.klass.arel_table
+          end
+
+          def symbolized(obj)
+            if obj.respond_to?(:to_h)
+              obj.to_h.deep_symbolize_keys
+            else
+              {}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lighthouse/directives/arguments/base.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Lighthouse
+  module GraphQL
+    module Directives
+      module Arguments
+        # Base class for argument-builder directives (@eq, @neq, @in, @notIn,
+        # @like, @where, @orderBy). Each receives the argument AST node and the
+        # directive AST node, and composes a constraint onto an ActiveRecord
+        # relation given the client-supplied value for that argument.
+        class Base
+          include Lighthouse::Contracts::ArgBuilder
+
+          def initialize(arg_node, directive_node)
+            @arg_node = arg_node
+            @directive_node = directive_node
+          end
+
+          # @return relation
+          def handle_builder(_relation, _value)
+            raise NotImplementedError
+          end
+
+          private
+
+          # Column to filter on: the directive's `key:` argument if present,
+          # otherwise the snake_case form of the GraphQL argument name.
+          def column
+            Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'key') ||
+              Lighthouse::Support::Naming.attribute(@arg_node.name)
+          end
+
+          def arel_column(relation)
+            relation.klass.arel_table[column]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lighthouse/directives/arguments/filters.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Lighthouse
+  module GraphQL
+    module Directives
+      module Arguments
+        # @eq — equality filter (the default). `field(status: String @eq)`
+        class Eq < Base
+          def self.directive_name = 'eq'
+          def self.definition = 'directive @eq(key: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
+
+          def handle_builder(relation, value)
+            return relation if value.nil?
+
+            relation.where(column => value)
+          end
+        end
+
+        # @neq — inequality filter.
+        class Neq < Base
+          def self.directive_name = 'neq'
+          def self.definition = 'directive @neq(key: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
+
+          def handle_builder(relation, value)
+            return relation if value.nil?
+
+            relation.where.not(column => value)
+          end
+        end
+
+        # @in — value is one of a list.
+        class In < Base
+          def self.directive_name = 'in'
+          def self.definition = 'directive @in(key: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
+
+          def handle_builder(relation, value)
+            return relation if value.nil?
+
+            relation.where(column => Array(value))
+          end
+        end
+
+        # @notIn — value is none of a list.
+        class NotIn < Base
+          def self.directive_name = 'notIn'
+          def self.definition = 'directive @notIn(key: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
+
+          def handle_builder(relation, value)
+            return relation if value.nil?
+
+            relation.where.not(column => Array(value))
+          end
+        end
+
+        # @like — SQL LIKE with the value wrapped in wildcards.
+        class Like < Base
+          def self.directive_name = 'like'
+          def self.definition = 'directive @like(key: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
+
+          def handle_builder(relation, value)
+            return relation if value.nil?
+
+            relation.where(arel_column(relation).matches("%#{value}%"))
+          end
+        end
+
+        # @where — generic operator filter, sharing the SQLOperator semantics with
+        # the @whereConditions extension. `field(age: Int @where(operator: "GT"))`
+        class Where < Base
+          def self.directive_name = 'where'
+          def self.definition = 'directive @where(key: String, operator: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
+
+          def handle_builder(relation, value)
+            return relation if value.nil?
+
+            op = (Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'operator') || 'EQ').to_s.upcase
+
+            case op
+            when 'IN' then relation.where(column => Array(value))
+            when 'NIN' then relation.where.not(column => Array(value))
+            when 'IS_NULL' then relation.where(column => nil)
+            when 'IS_NOT_NULL' then relation.where.not(column => nil)
+            when 'CONTAINS' then relation.where(arel_column(relation).matches("%#{value}%"))
+            when 'STARTS_WITH' then relation.where(arel_column(relation).matches("#{value}%"))
+            when 'ENDS_WITH' then relation.where(arel_column(relation).matches("%#{value}"))
+            else
+              arel_method = Lighthouse::WhereConditions::OperatorMap[op]
+              if arel_method
+                relation.where(arel_column(relation).public_send(arel_method, value))
+              else
+                relation.where(column => value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lighthouse/directives/arguments/order_by.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Lighthouse
+  module GraphQL
+    module Directives
+      module Arguments
+        # @orderBy — sort the result by one or more columns.
+        #
+        # The client value is a list of clauses, each `{ column:, order: }`
+        # (also accepts `{ field:, direction: }`). Clauses apply in order, so
+        # `[{column: NAME, order: ASC}, {column: AGE, order: DESC}]` sorts by
+        # name then age.
+        class OrderBy < Base
+          def self.directive_name = 'orderBy'
+          def self.definition = 'directive @orderBy(columns: [String!], relations: [String!]) on ARGUMENT_DEFINITION | FIELD_DEFINITION'
+
+          def handle_builder(relation, value)
+            normalize(value).reduce(relation) do |rel, clause|
+              col = Lighthouse::Support::Naming.column(clause[:column], rel)
+              next rel if col.nil? || col.empty?
+
+              direction = clause[:order].to_s.downcase == 'desc' ? :desc : :asc
+              rel.order(col => direction)
+            end
+          end
+
+          private
+
+          def normalize(value)
+            list = value.is_a?(Array) ? value : [value]
+            list.filter_map do |item|
+              hash = item.respond_to?(:to_h) ? item.to_h : item
+              next nil unless hash.is_a?(Hash)
+
+              symbolized = hash.transform_keys { |k| k.to_s.to_sym }
+              col = symbolized[:column] || symbolized[:field]
+              next nil if col.nil?
+
+              { column: col, order: symbolized[:order] || symbolized[:direction] || 'ASC' }
+            end
+          end
+        end
+      end
+    end
+  end
+end