lighthouse-graphql 0.1.1 → 0.2.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lighthouse-graphql
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 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,32 @@ 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/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,44 +90,70 @@ 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
 homepage: https://github.com/Vaz-Innovation/lighthouse-graphql
 licenses:

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

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