lighthouse-graphql 0.1.1 → 0.2.1

data/sig/lighthouse/directives.rbs

@@ -0,0 +1,158 @@
+# The extension points for custom directives: the contracts a directive class
+# includes, the registry it is registered in, and the base classes it can
+# subclass. See docs/custom-directives.md.
+module Lighthouse
+  # What the registry asks a self-describing directive class: its SDL name
+  # (without the @) and its `directive @name(...) on ...` definition.
+  interface _DirectiveClass
+    def directive_name: () -> String
+    def definition: () -> String?
+  end
+
+  # Marker modules: the registry detects a class's capabilities by which of
+  # them it includes. Only FieldResolver and ArgBuilder change how a class is
+  # registered; the others document intent.
+  module Contracts
+    module Directive
+    end
+
+    # Its instances, built with (field_def, type_def, directive_node, opts),
+    # install the field's resolver in `define_resolver(target_type)`.
+    module FieldResolver
+      include Directive
+    end
+
+    # Its instances, built with (arg_node, directive_node), answer
+    # `handle_builder(relation, value)` with the constrained relation.
+    module ArgBuilder
+      include Directive
+    end
+
+    module FieldMiddleware
+      include Directive
+    end
+
+    module FieldManipulator
+      include Directive
+    end
+
+    module ArgManipulator
+      include Directive
+    end
+  end
+
+  class DirectiveRegistry
+    RESOLUTION_ORDER: Hash[String, Integer]
+    NAMED_RESOLVERS: Hash[String, Symbol]
+    SELF_DESCRIBING_RESOLVERS: Array[Symbol]
+    ARG_BUILDERS: Array[Symbol]
+    PASSIVE_DEFINITIONS: Hash[String, String]
+
+    def self.default: () -> DirectiveRegistry
+
+    # register(MyDirective) when the class answers `directive_name`, else
+    # register('name', MyDirective).
+    def self.register: (Class | String | Symbol name_or_klass, ?Class? klass) -> DirectiveRegistry
+
+    def initialize: () -> void
+    def register: (Class | String | Symbol name_or_klass, ?Class? klass) -> self
+    def register_defaults: () -> self
+    def register_definition: (String | Symbol name, String definition) -> self
+    def register_type_definition: (String | Symbol name, String definition) -> self
+    def register_manipulator: (_SdlManipulator manipulator) -> self
+
+    def resolution_class: (String | Symbol name) -> Class?
+    def resolution_order: (String | Symbol name) -> Integer
+    def wrapper?: (String | Symbol name) -> bool
+    def resolution_names: () -> Array[String]
+    def arg_builder_class: (String | Symbol name) -> Class?
+    def arg_builder_names: () -> Array[String]
+
+    # { "name" => "directive @name(...) on ..." }
+    def directive_definitions: () -> Hash[String, String]
+    # { "Name" => "enum Name { ... }" }
+    def type_definitions: () -> Hash[String, String]
+
+    attr_reader sdl_manipulators: Array[_SdlManipulator]
+    def manipulate_sdl: (String sdl) -> String
+  end
+
+  # Writes the SDL an IDE needs next to the app's own: `bin/rails lighthouse:ide_helper`.
+  module IdeHelper
+    DIRECTIVES_FILE: String
+    PROGRAMMATIC_TYPES_FILE: String
+
+    # Writes both files into `output_dir` and returns their paths.
+    def self?.write: (output_dir: path, ?sdl_folder: path?, ?registry: DirectiveRegistry) -> Array[String]
+    def self?.directives_sdl: (?String sdl, ?registry: DirectiveRegistry) -> String
+    def self?.programmatic_types_sdl: (String sdl, ?registry: DirectiveRegistry) -> String
+  end
+
+  module GraphQL
+    module DirectiveResolvers
+      # The base of the built-in field directives, and of a custom one:
+      # subclass it and implement `define_resolver`.
+      class BaseDirectiveResolver
+        # graphql-ruby's field and type definitions, and the directive's AST node.
+        @field_def: untyped
+        @type_def: untyped
+        @directive_node: untyped
+        @opts: Hash[Symbol, untyped]
+
+        def initialize: (untyped field_def, untyped type_def, untyped directive_node, ?Hash[Symbol, untyped] opts) -> void
+
+        # Install the field's resolver on `target_type_class` (a graphql-ruby type class).
+        def define_resolver: (untyped target_type_class) -> untyped
+
+        def apply_where_filters: (relation relation, untyped args) -> relation
+        def apply_arg_builders: (relation relation, arguments args_h) -> relation
+        def extract_relation_name_from_directive: (untyped arg_node) -> String?
+        def constantize_model: (String? name) -> Class?
+        def apply_scopes: (relation relation) -> relation
+
+        # The literal value of an argument of this directive.
+        def directive_arg: (String name) -> untyped
+        def resolver_method_name: () -> String
+        # The field's resolver so far, for a directive that wraps it.
+        def capture_inner: (untyped target_type_class) -> untyped
+        def install: (untyped target_type_class, untyped callable) -> untyped
+        # The model the directive acts on; raises DefinitionError when there is none.
+        def model_class: () -> Class
+      end
+
+      # Applies the field's @builder directives, in SDL order, to its relation.
+      class BuilderApplier
+        DEFINITION: String
+
+        def self.apply: (relation relation, untyped field_def_ast_node, arguments args, context ctx, untyped resolver_instance) -> relation
+        def self.apply_directive: (relation relation, untyped directive_node, arguments args, context ctx, untyped resolver_instance) -> relation
+        def self.extract_directive_arg: (untyped directive_node, String name) -> untyped
+      end
+    end
+
+    module Directives
+      module Arguments
+        # The base of the argument filters (@eq, @in, @orderBy, ...), and of a
+        # custom one: subclass it and implement `handle_builder`.
+        class Base
+          include Contracts::ArgBuilder
+
+          # graphql-ruby's AST nodes for the argument and the directive on it.
+          @arg_node: untyped
+          @directive_node: untyped
+
+          def initialize: (untyped arg_node, untyped directive_node) -> void
+
+          # Constrain the relation by the value the client gave the argument.
+          def handle_builder: (relation relation, untyped value) -> relation
+
+          private
+
+          # The directive's `key:`, else the argument's name in snake_case.
+          def column: () -> String
+          def arel_column: (relation relation) -> untyped
+        end
+      end
+    end
+  end
+end

data/sig/lighthouse/graphql.rbs

@@ -0,0 +1,78 @@
+# The entrypoints: building the schema from SDL and running operations.
+module Lighthouse
+  module GraphQL
+    VERSION: String
+
+    Config: singleton(Lighthouse::Config)
+
+    # A GraphQL::Schema subclass.
+    type schema = untyped
+
+    module RbLightHouse
+      # The schema built from the SDL in `sdl_folder` (default: Config.sdl_folder).
+      # `options` takes :base_types, :base_schema and the schema's own options.
+      def self.get_schema: (?sdl_folder: path?, ?options: Hash[Symbol, untyped]) -> schema
+      def self.configure: () ?{ (singleton(Lighthouse::Config) config) -> void } -> void
+    end
+
+    module SchemaFactory
+      def self?.build_base_schema: (?sdl_folder: path?, ?sdl: String?, ?base_types: Hash[untyped, untyped],
+                                    ?schema_options: Hash[Symbol, untyped], **untyped extra_options) -> schema
+      def self?.load_sdl: (path? sdl_folder) -> String
+    end
+
+    # Apollo's Automatic Persisted Queries, and a manifest of trusted operations.
+    module PersistedQueries
+      HASH: Regexp
+      NOT_FOUND: Array[String]
+      NOT_SUPPORTED: Array[String]
+      HASH_MISMATCH: Array[String]
+      NOT_IN_LIST: Array[String]
+
+      # A request the protocol rejects, rendered with Apollo's error codes.
+      class Error < StandardError
+        attr_reader code: String
+
+        def initialize: (String message, String code) -> void
+        def to_h: () -> Hash[String, untyped]
+      end
+
+      # `extensions` as the request carries it: a Hash, a JSON String (GET) or
+      # ActionController::Parameters.
+      #
+      # `schema.execute` with the query the request names: its result, or a
+      # protocol error as a ready-to-render { "errors" => [...] } Hash.
+      def self?.execute: (schema schema, query: String?, ?extensions: untyped, **untyped options) -> untyped
+      # The query text to run for a request's `query` and `extensions`.
+      def self?.resolve: (String? query, untyped extensions) -> String?
+      def self?.enabled?: () -> bool
+      def self?.digest: (String query) -> String
+      # Store a query ahead of time (e.g. from a deploy task); returns its hash.
+      def self?.register: (String query) -> String
+    end
+
+    # The Cache-Control header the selected fields' @cacheControl hints allow.
+    module CacheControl
+      DEFINITION: String
+      TYPE_DEFINITIONS: Hash[String, String]
+      CONTEXT_KEY: Symbol
+
+      # For an executed query (a GraphQL::Query::Result or GraphQL::Query);
+      # nil when the schema does not use @cacheControl.
+      def self?.header: (untyped result) -> String?
+      # Set the header on a Rails (or Rack) response, and return it.
+      def self?.apply: (untyped response, untyped result) -> String?
+    end
+
+    # The opt-in cache of the manipulated schema document, in tmp/cache.
+    module SchemaCache
+      PREFIX: String
+
+      def self?.enabled?: () -> bool
+      def self?.directory: () -> path
+      # Build the schema document now and return the cache file's path.
+      def self?.warm!: (?String? sdl) -> String
+      def self?.clear!: () -> void
+    end
+  end
+end

data/sig/lighthouse.rbs

@@ -0,0 +1,142 @@
+# Signatures for the parts of Lighthouse an application implements or calls:
+# the classes a schema names (builders, validators), the configuration, the
+# directive extension points and the entrypoints. Internals are left out.
+#
+# graphql-ruby and Active Record ship no RBS every app has, so the values that
+# come from them are aliases of untyped, named for what they hold.
+module Lighthouse
+  # An ActiveRecord::Relation, or anything with its query interface.
+  type relation = untyped
+
+  # A field's arguments, with snake_case Symbol keys as graphql-ruby passes them.
+  type arguments = Hash[Symbol, untyped]
+
+  # The request's GraphQL::Query::Context.
+  type context = untyped
+
+  # A path on disk: a String or a Pathname.
+  type path = String | _ToPath
+
+  # A class `@builder(class: "Name")` names, looked up in Config.namespaces[:builders].
+  # It refines the relation of a field resolved by @all, @paginate, @first,
+  # @count or @aggregate and returns the relation to use; nil keeps the one it
+  # was given. `@builder(method:)` names a method other than `call`, with the
+  # same signature. The class answers it, or else an instance built with no
+  # arguments does. A GraphQL::ExecutionError it raises reaches the client.
+  interface _Builder
+    def call: (relation relation, arguments args, context context) -> relation?
+  end
+
+  # A @validator contract other than a Dry::Validation::Contract: it gets the
+  # arguments (snake_case Symbol keys) and answers the errors by key,
+  # { title: ["is missing"] }, nested for input objects; empty when valid.
+  interface _Validator
+    def call: (Hash[Symbol, untyped] values) -> Hash[Symbol | String, untyped]
+  end
+
+  # Config.on_error: called with an error a directive or resolver swallowed.
+  interface _ErrorHandler
+    def call: (StandardError error, context? context) -> void
+  end
+
+  # Config.authenticated_user and Config.policy_user: the user of a request.
+  interface _UserReader
+    def call: (context? context) -> untyped
+  end
+
+  # Config.authorizer: may `user` perform `ability` on `record` (a model
+  # instance, or a model class for @canModel)? `args` are the @can* `args:`,
+  # after the field's arguments with `injectArgs: true`.
+  interface _Authorizer
+    def call: (untyped user, untyped record, String | Symbol ability, ?Array[untyped] args) -> boolish
+  end
+
+  # What DirectiveRegistry#register_manipulator takes: it transforms the SDL
+  # before the schema is built.
+  interface _SdlManipulator
+    def manipulate: (String sdl) -> String
+  end
+
+  def self.configure: () ?{ (singleton(Config) config) -> void } -> void
+
+  module Config
+    DEFAULT_NAMESPACES: Hash[Symbol, Array[String]]
+    SETTINGS: Array[Symbol]
+
+    def self.configure: () ?{ (singleton(Config) config) -> void } -> void
+    def self.[]: (Symbol | String key) -> untyped
+    def self.reset!: () -> void
+
+    def self.sdl_folder: () -> path?
+    def self.sdl_folder=: (path? folder) -> path?
+
+    # { queries:, mutations:, builders:, validators: } => [namespace, ...].
+    # Assigning a partial hash overrides only the kinds it names.
+    def self.namespaces: () -> Hash[Symbol, Array[String]]
+    def self.namespaces=: (Hash[Symbol | String, String | Array[String]] overrides) -> Hash[Symbol | String, String | Array[String]]
+
+    def self.resolver_namespaces: () -> Array[String]
+    def self.resolver_namespaces=: (Array[String] namespaces) -> Array[String]
+
+    def self.directive_map: () -> Hash[untyped, untyped]
+
+    # An ActiveSupport::Cache::Store; Rails.cache by default.
+    def self.cache_store: () -> untyped
+    def self.cache_store=: (untyped store) -> untyped
+
+    def self.transactional_mutations: () -> bool
+    def self.transactional_mutations=: (bool? enabled) -> bool?
+
+    def self.pagination_default_count: () -> Integer?
+    def self.pagination_default_count=: (Integer? count) -> Integer?
+    def self.pagination_max_count: () -> Integer?
+    def self.pagination_max_count=: (Integer? count) -> Integer?
+
+    def self.schema_cache: () -> bool
+    def self.schema_cache=: (bool? enabled) -> bool?
+    def self.schema_cache_path: () -> path?
+    def self.schema_cache_path=: (path? path) -> path?
+    def self.watch_sdl: () -> bool
+    def self.watch_sdl=: (bool? enabled) -> bool?
+
+    def self.persisted_queries: () -> bool
+    def self.persisted_queries=: (bool? enabled) -> bool?
+    def self.persisted_queries_store: () -> untyped
+    def self.persisted_queries_store=: (untyped store) -> untyped
+    def self.persisted_queries_ttl: () -> Numeric?
+    def self.persisted_queries_ttl=: (Numeric? seconds) -> Numeric?
+    def self.persisted_queries_manifest: () -> path?
+    def self.persisted_queries_manifest=: (path? path) -> path?
+    def self.persisted_queries_only: () -> bool
+    def self.persisted_queries_only=: (bool? enabled) -> bool?
+
+    def self.on_error: () -> _ErrorHandler
+    def self.on_error=: (_ErrorHandler? handler) -> _ErrorHandler?
+    def self.handle_error: (StandardError error, ?context? context) -> void
+
+    def self.authenticated_user: () -> _UserReader
+    def self.authenticated_user=: (_UserReader? reader) -> _UserReader?
+    def self.policy_user: () -> _UserReader
+    def self.policy_user=: (_UserReader? reader) -> _UserReader?
+    def self.authorizer: () -> _Authorizer
+    def self.authorizer=: (_Authorizer? authorizer) -> _Authorizer?
+  end
+
+  # The schema refers to something that does not exist or breaks a contract.
+  class DefinitionError < StandardError
+  end
+
+  # A GraphQL::ExecutionError (declared from StandardError, which it descends
+  # from, as graphql-ruby ships no RBS): the @can* family denied the ability.
+  class AuthorizationError < StandardError
+    def initialize: (?String message, **untyped options) -> void
+  end
+
+  # A GraphQL::ExecutionError: invalid arguments, keyed by argument path
+  # ({ "input.title" => ["Title can't be blank"] }) under extensions.validation.
+  class ValidationError < StandardError
+    attr_reader messages: Hash[String, Array[String]]
+
+    def initialize: (String | Symbol field_name, Hash[String, Array[String]] messages) -> void
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lighthouse-graphql
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Vaz Innovation
@@ -37,62 +37,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.5'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '6.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '6.0'
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.4'
-- !ruby/object:Gem::Dependency
-  name: apollo-federation
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
 description: |
   Lighthouse lets you build a GraphQL API for your Rails app primarily through
   schema (SDL) and server-side directives — @all, @find, @paginate, @hasMany,
@@ -111,14 +55,33 @@ files:
 - README.md
 - docs/authorization.md
 - docs/best-practices.md
+- docs/caching.md
 - docs/configuration.md
 - docs/custom-directives.md
 - docs/directives.md
 - docs/federation.md
 - docs/filtering-and-ordering.md
 - docs/getting-started.md
+- docs/motivation.md
+- docs/mutations.md
+- docs/performance.md
 - docs/relationships.md
+- docs/resolvers.md
+- docs/validation.md
+- lib/generators/lighthouse/builder_generator.rb
+- lib/generators/lighthouse/class_generator.rb
+- lib/generators/lighthouse/install/install_generator.rb
+- lib/generators/lighthouse/install/templates/graphql.config.yml.tt
+- lib/generators/lighthouse/install/templates/graphql_controller.rb.tt
+- lib/generators/lighthouse/install/templates/initializer.rb.tt
+- lib/generators/lighthouse/install/templates/schema.graphql.tt
+- lib/generators/lighthouse/install/templates/schema.rb.tt
+- lib/generators/lighthouse/mutation_generator.rb
+- lib/generators/lighthouse/query_generator.rb
+- lib/generators/lighthouse/validator_generator.rb
 - lib/lighthouse-graphql.rb
+- lib/lighthouse/cache_control.rb
+- lib/lighthouse/caching.rb
 - lib/lighthouse/config.rb
 - lib/lighthouse/contracts/arg_builder.rb
 - lib/lighthouse/contracts/arg_manipulator.rb
@@ -128,52 +91,81 @@ files:
 - lib/lighthouse/contracts/field_resolver.rb
 - lib/lighthouse/dataloader_sources/association_loader.rb
 - lib/lighthouse/dataloader_sources/model_loader.rb
+- lib/lighthouse/dataloader_sources/relation_count_loader.rb
+- lib/lighthouse/dataloader_sources/relation_page_loader.rb
 - lib/lighthouse/directive_resolvers/aggregate_resolver.rb
 - lib/lighthouse/directive_resolvers/all_resolver.rb
+- lib/lighthouse/directive_resolvers/association_resolvers.rb
 - lib/lighthouse/directive_resolvers/auth_resolver.rb
 - lib/lighthouse/directive_resolvers/base.rb
-- lib/lighthouse/directive_resolvers/belongs_to_many_resolver.rb
-- lib/lighthouse/directive_resolvers/belongs_to_resolver.rb
 - lib/lighthouse/directive_resolvers/builder_applier.rb
-- lib/lighthouse/directive_resolvers/can_resolver.rb
+- lib/lighthouse/directive_resolvers/cache_resolvers.rb
+- lib/lighthouse/directive_resolvers/can_resolvers.rb
+- lib/lighthouse/directive_resolvers/convention_resolver.rb
 - lib/lighthouse/directive_resolvers/count_resolver.rb
 - lib/lighthouse/directive_resolvers/field_resolver.rb
 - lib/lighthouse/directive_resolvers/find_resolver.rb
 - lib/lighthouse/directive_resolvers/first_resolver.rb
 - lib/lighthouse/directive_resolvers/guard_resolver.rb
-- lib/lighthouse/directive_resolvers/has_many_resolver.rb
-- lib/lighthouse/directive_resolvers/has_one_resolver.rb
 - lib/lighthouse/directive_resolvers/method_resolver.rb
+- lib/lighthouse/directive_resolvers/model_mutation_resolver.rb
 - lib/lighthouse/directive_resolvers/paginate_resolver.rb
 - lib/lighthouse/directive_resolvers/rename_resolver.rb
 - lib/lighthouse/directive_resolvers/resolution.rb
+- lib/lighthouse/directive_resolvers/validator_resolver.rb
 - lib/lighthouse/directive_resolvers/where_conditions_applier.rb
 - lib/lighthouse/directives/arguments/base.rb
 - lib/lighthouse/directives/arguments/filters.rb
 - lib/lighthouse/directives/arguments/order_by.rb
+- lib/lighthouse/directives/pagination_info_types.rb
+- lib/lighthouse/directives/pagination_manipulator.rb
 - lib/lighthouse/directives/registry.rb
-- lib/lighthouse/directives/relation_directive.rb
 - lib/lighthouse/directives/where_conditions_directive.rb
+- lib/lighthouse/errors.rb
+- lib/lighthouse/federation_directives.rb
+- lib/lighthouse/field_resolver_stack.rb
+- lib/lighthouse/generated_resolvers.rb
 - lib/lighthouse/graphql.rb
 - lib/lighthouse/graphql/version.rb
+- lib/lighthouse/graphql_ruby_patches.rb
+- lib/lighthouse/ide_helper.rb
+- lib/lighthouse/namespaces.rb
+- lib/lighthouse/nested_mutations.rb
+- lib/lighthouse/nested_mutations/belongs_to_operations.rb
+- lib/lighthouse/nested_mutations/executor.rb
+- lib/lighthouse/nested_mutations/has_operations.rb
+- lib/lighthouse/nested_mutations/many_to_many_operations.rb
+- lib/lighthouse/nested_mutations/partitioner.rb
+- lib/lighthouse/pagination.rb
+- lib/lighthouse/persisted_queries.rb
+- lib/lighthouse/railtie.rb
 - lib/lighthouse/rb_lighthouse.rb
 - lib/lighthouse/reference_resolver.rb
+- lib/lighthouse/relation_batch.rb
+- lib/lighthouse/resolver_dispatch.rb
+- lib/lighthouse/schema_cache.rb
 - lib/lighthouse/schema_factory.rb
 - lib/lighthouse/schema_generator.rb
 - lib/lighthouse/schema_implementation.rb
 - lib/lighthouse/sdl_loader.rb
+- lib/lighthouse/support/arguments.rb
 - lib/lighthouse/support/authorization.rb
+- lib/lighthouse/support/batching.rb
 - lib/lighthouse/support/directive_args.rb
 - lib/lighthouse/support/model_resolver.rb
 - lib/lighthouse/support/naming.rb
+- lib/lighthouse/tasks/lighthouse.rake
 - lib/lighthouse/where_conditions/operator_map.rb
+- sig/lighthouse.rbs
+- sig/lighthouse/directives.rbs
+- sig/lighthouse/graphql.rbs
 homepage: https://github.com/Vaz-Innovation/lighthouse-graphql
 licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/Vaz-Innovation/lighthouse-graphql
   changelog_uri: https://github.com/Vaz-Innovation/lighthouse-graphql/blob/main/CHANGELOG.md
-  documentation_uri: https://github.com/Vaz-Innovation/lighthouse-graphql/tree/main/docs
+  documentation_uri: https://vaz-innovation.github.io/lighthouse-graphql/
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:

data/lib/lighthouse/directive_resolvers/belongs_to_many_resolver.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class BelongsToManyDirectiveResolver < BaseDirectiveResolver
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          assoc_name = extract_relation_name || field_name
-
-          method_name = "resolve_field_#{field_name}"
-
-          target_type_class.define_singleton_method(method_name) do |obj, arguments, ctx|
-            # Use dataloader when available
-            if ctx && ctx.respond_to?(:dataloader) && ctx.dataloader
-              loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::AssociationLoader, obj.class, assoc_name)
-              return loader.load(obj)
-            end
-
-            # Fallback: call the association directly
-            if obj.respond_to?(assoc_name)
-              args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-              return obj.public_send(assoc_name)
-            end
-
-            nil
-          end
-
-          if @field_def.respond_to?(:resolve_proc=)
-            @field_def.resolve_proc = ->(obj, arguments, ctx) do
-              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)
-                args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-                obj.public_send(assoc_name)
-              else
-                nil
-              end
-            end
-          end
-        end
-
-        private
-
-        def extract_relation_name
-          arg = @directive_node.arguments&.find { |a| a.name == 'relation' }
-          return nil unless arg
-          arg.value.respond_to?(:value) ? arg.value.value : arg.value
-        end
-      end
-    end
-  end
-end

data/lib/lighthouse/directive_resolvers/belongs_to_resolver.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class BelongsToDirectiveResolver < BaseDirectiveResolver
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          assoc_name = extract_relation_name || field_name
-          method_name = "resolve_field_#{field_name}"
-
-          target_type_class.define_singleton_method(method_name) do |obj, _arguments, ctx|
-            if ctx && ctx.respond_to?(:dataloader) && ctx.dataloader
-              loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::AssociationLoader, obj.class, assoc_name)
-              return loader.load(obj)
-            end
-
-            obj.public_send(assoc_name) if obj.respond_to?(assoc_name)
-          end
-
-          if @field_def.respond_to?(:resolve_proc=)
-            @field_def.resolve_proc = ->(obj, _arguments, ctx) do
-              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)
-              else
-                nil
-              end
-            end
-          end
-        end
-
-        private
-
-        def extract_relation_name
-          arg = @directive_node.arguments&.find { |a| a.name == 'relation' }
-          return nil unless arg
-          arg.value.respond_to?(:value) ? arg.value.value : arg.value
-        end
-      end
-    end
-  end
-end