lighthouse-graphql 0.1.1 → 0.2.0

data/lib/lighthouse/support/arguments.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# Field-argument plumbing shared by resolvers: plain-Ruby conversion, @inject,
+# @spread, and dot paths ("input.id", "*.id") into arguments and results.
+module Lighthouse::Support::Arguments
+  module_function
+
+  # The arguments a resolver class receives: @inject applied, then @spread.
+  # Values keep their GraphQL input-object form except where spread.
+  def prepare(field_def, args, context)
+    values = inject(field_def.ast_node, shallow(args), context)
+    spread(field_def.arguments, values)
+  end
+
+  # Arguments / input objects as a Hash with symbol keys, one level deep.
+  def shallow(value)
+    case value
+    when ::GraphQL::Schema::InputObject then value.to_h.transform_keys(&:to_sym)
+    when ::GraphQL::Execution::Interpreter::Arguments then value.keyword_arguments.dup
+    when Hash then value.transform_keys(&:to_sym)
+    else {}
+    end
+  end
+
+  # Input objects, arguments and nested collections as plain Ruby values.
+  def plain(value)
+    case value
+    when ::GraphQL::Schema::InputObject then plain(value.to_h)
+    when ::GraphQL::Execution::Interpreter::Arguments then plain(value.keyword_arguments)
+    when Hash then value.to_h { |k, v| [k.to_sym, plain(v)] }
+    when Array then value.map { |v| plain(v) }
+    else value
+    end
+  end
+
+  # @inject(context: "current_user.id", name: "user_id"): server-side values
+  # written into the arguments, so clients cannot set them.
+  def inject(field_ast_node, values, context)
+    directives = (field_ast_node&.directives || []).select { |d| d.name == 'inject' }
+    directives.reduce(values) do |acc, directive|
+      from = Lighthouse::Support::DirectiveArgs.literal(directive, 'context').to_s
+      to = Lighthouse::Support::DirectiveArgs.literal(directive, 'name').to_s
+      set_path(acc, to.split('.'), dig(context, from).first)
+    end
+  end
+
+  # Merge every @spread argument's input object into its parent, recursively.
+  def spread(argument_defs, values)
+    by_keyword = keyword_index(argument_defs)
+    values.each_with_object({}) do |(key, value), out|
+      argument = by_keyword[key.to_sym]
+      if argument && spread?(argument) && !value.nil?
+        out.merge!(spread(argument.type.unwrap.arguments, shallow(value)))
+      else
+        out[key] = value
+      end
+    end
+  end
+
+  def spread?(argument)
+    (argument.ast_node&.directives || []).any? { |d| d.name == 'spread' }
+  end
+
+  def keyword_index(argument_defs)
+    (argument_defs || {}).values.index_by(&:keyword)
+  end
+
+  # Every value at a dot `path` under `root`; `*` walks each list element.
+  # GraphQL names are matched in their snake_case form. Always an Array.
+  def dig(root, path)
+    path.to_s.split('.').reduce([root]) do |nodes, segment|
+      nodes.flat_map do |node|
+        next [] if node.nil?
+        next list(node) || [node] if segment == '*'
+
+        [read(node, segment)]
+      end
+    end.compact
+  end
+
+  # The items of a collection (Array, Set, relation), or nil for a single
+  # object — records and Structs answer #to_a too, so that test won't do.
+  def list(value)
+    case value
+    when Array then value
+    when Set then value.to_a
+    else value.to_a if defined?(::ActiveRecord::Relation) && value.is_a?(::ActiveRecord::Relation)
+    end
+  end
+
+  def read(node, segment)
+    keys = [segment, segment.underscore].uniq
+    if node.respond_to?(:key?)
+      stored = stored_key(node, keys)
+      return node[stored] unless stored.nil?
+      return nil if node.is_a?(Hash)
+    end
+    method = keys.reverse.find { |key| node.respond_to?(key) }
+    method ? node.public_send(method) : nil
+  end
+
+  # The key a keyed node holds the first of `keys` under — Symbol before
+  # String — or nil when it holds none of them.
+  def stored_key(node, keys)
+    keys.each do |key|
+      return key.to_sym if node.key?(key.to_sym)
+      return key if node.key?(key)
+    end
+    nil
+  end
+
+  def set_path(values, segments, value)
+    key, *rest = segments
+    key = key.underscore.to_sym
+    copy = values.dup
+    copy[key] = rest.empty? ? value : set_path(shallow(copy[key]), rest, value)
+    copy
+  end
+end

data/lib/lighthouse/support/authorization.rb

@@ -1,26 +1,25 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module Support
-    # Thin wrapper over the configurable authorization seams, used by the @guard
-    # and @can directives so they stay framework-agnostic.
-    module Authorization
-      module_function
+# Thin wrapper over the configurable authorization seams, used by the @guard
+# and @can directives so they stay framework-agnostic.
+module Lighthouse::Support::Authorization
+  module_function
 
-      def authenticated_user(context)
-        Lighthouse::Config.authenticated_user.call(context)
-      end
+  def authenticated_user(context)
+    Lighthouse::Config.authenticated_user.call(context)
+  end
 
-      def authenticated?(context)
-        !authenticated_user(context).nil?
-      end
+  def authenticated?(context)
+    !authenticated_user(context).nil?
+  end
 
-      # Returns true/false for `ability` against `record` for the current policy
-      # user. Defaults to Pundit (see Config#authorizer).
-      def authorized?(context, record, ability)
-        user = Lighthouse::Config.policy_user.call(context)
-        Lighthouse::Config.authorizer.call(user, record, ability)
-      end
-    end
+  # Returns true/false for `ability` against `record` (an instance, or a model
+  # class) for the current policy user. Defaults to Pundit (see
+  # Config#authorizer). `args` reach the authorizer only when given, so a
+  # three-argument authorizer keeps working for checks without them.
+  def authorized?(context, record, ability, args = [])
+    user = Lighthouse::Config.policy_user.call(context)
+    authorizer = Lighthouse::Config.authorizer
+    args.empty? ? authorizer.call(user, record, ability) : authorizer.call(user, record, ability, args)
   end
 end

data/lib/lighthouse/support/batching.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Access to the query's GraphQL::Dataloader. graphql-ruby hands every query a
+# dataloader — a NullDataloader, whose sources refuse to run, when the schema
+# does not `use GraphQL::Dataloader` — so "is there one" needs this check.
+module Lighthouse::Support::Batching
+  module_function
+
+  def dataloader(context)
+    dataloader = context.respond_to?(:dataloader) ? context.dataloader : nil
+    return nil if dataloader.nil?
+    return nil if defined?(::GraphQL::Dataloader::NullDataloader) && dataloader.is_a?(::GraphQL::Dataloader::NullDataloader)
+
+    dataloader
+  end
+end

data/lib/lighthouse/support/directive_args.rb

@@ -1,33 +1,35 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module Support
-    # Extracts argument values from a GraphQL directive AST node, unwrapping the
-    # various value-node shapes (scalar literals, enums, lists) into plain Ruby
-    # values. Consolidates the repeated
-    # `arg.value.respond_to?(:value) ? arg.value.value : arg.value` pattern.
-    module DirectiveArgs
-      module_function
+# Extracts argument values from a GraphQL directive AST node, unwrapping the
+# various value-node shapes (scalar literals, enums, lists) into plain Ruby
+# values. Consolidates the repeated
+# `arg.value.respond_to?(:value) ? arg.value.value : arg.value` pattern.
+module Lighthouse::Support::DirectiveArgs
+  module_function
 
-      # Return the literal value of directive argument `name`, or nil.
-      def literal(directive_node, name)
-        return nil unless directive_node.respond_to?(:arguments)
+  # Return the literal value of directive argument `name`, or nil.
+  def literal(directive_node, name)
+    return nil unless directive_node.respond_to?(:arguments)
 
-        arg = directive_node.arguments&.find { |a| a.name == name.to_s }
-        return nil unless arg
+    arg = directive_node.arguments&.find { |a| a.name == name.to_s }
+    return nil unless arg
 
-        unwrap(arg.value)
-      end
+    unwrap(arg.value)
+  end
+
+  def unwrap(value)
+    case value
+    when ::GraphQL::Language::Nodes::Enum then return value.name
+    when ::GraphQL::Language::Nodes::NullValue then return nil
+    when ::GraphQL::Language::Nodes::InputObject then return value.to_h
+    end
 
-      def unwrap(value)
-        if value.respond_to?(:value)
-          value.value
-        elsif value.is_a?(Array)
-          value.map { |item| unwrap(item) }
-        else
-          value
-        end
-      end
+    if value.respond_to?(:value)
+      value.value
+    elsif value.is_a?(Array)
+      value.map { |item| unwrap(item) }
+    else
+      value
     end
   end
 end

data/lib/lighthouse/support/model_resolver.rb

@@ -1,61 +1,61 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module Support
-    # Resolves a class name string (from a directive argument such as
-    # `@field(resolver: "Resolvers::ContactPerson")` or `@all(model: "Contact")`)
-    # into an actual constant.
-    #
-    # The list of namespaces to try is configurable via
-    # `Lighthouse::Config.resolver_namespaces`, so the library does not need to
-    # know any app-specific namespace. This is a key seam for extracting the
-    # library into a standalone gem.
-    module ModelResolver
-      module_function
-
-      DEFAULT_NAMESPACES = ['App::Graphql'].freeze
-
-      def namespaces
-        if defined?(Lighthouse::Config) &&
-           Lighthouse::Config.respond_to?(:resolver_namespaces) &&
-           Lighthouse::Config.resolver_namespaces
-          Array(Lighthouse::Config.resolver_namespaces)
-        else
-          DEFAULT_NAMESPACES
-        end
-      end
-
-      def constantize(name)
-        return nil unless name
-
-        raw = name.to_s.strip
-        return nil if raw.empty?
-
-        candidates_for(raw).each do |candidate|
-          klass = try_constantize(candidate)
-          return klass if klass
-        end
-
-        nil
-      end
-
-      def candidates_for(raw)
-        if raw.include?('::')
-          [raw]
-        else
-          namespaces.map { |ns| "#{ns}::#{raw}" } + [raw]
-        end
-      end
-
-      def try_constantize(candidate)
-        ActiveSupport::Dependencies.constantize(candidate)
-      rescue NameError, LoadError
-        begin
-          Object.const_get(candidate)
-        rescue NameError
-          nil
-        end
-      end
+# Resolves a class name string (from a directive argument such as
+# `@field(resolver: "Resolvers::ContactPerson")` or `@all(model: "Contact")`)
+# into an actual constant.
+#
+# The list of namespaces to try is configurable via
+# `Lighthouse::Config.resolver_namespaces`, so the library does not need to
+# know any app-specific namespace. This is a key seam for extracting the
+# library into a standalone gem.
+module Lighthouse::Support::ModelResolver
+  module_function
+
+  DEFAULT_NAMESPACES = ['App::Graphql'].freeze
+
+  def namespaces
+    if defined?(Lighthouse::Config) &&
+       Lighthouse::Config.respond_to?(:resolver_namespaces) &&
+       Lighthouse::Config.resolver_namespaces
+      Array(Lighthouse::Config.resolver_namespaces)
+    else
+      DEFAULT_NAMESPACES
+    end
+  end
+
+  # `namespaces:` overrides the configured resolver_namespaces, e.g. with
+  # Config.namespaces[:builders] to look a builder class up.
+  # `fallback: false` skips the bare name, so `Queries::User` is never
+  # mistaken for the `User` model.
+  def constantize(name, namespaces: self.namespaces, fallback: true)
+    return nil unless name
+
+    raw = name.to_s.strip
+    return nil if raw.empty?
+
+    candidates_for(raw, namespaces, fallback: fallback).each do |candidate|
+      klass = try_constantize(candidate)
+      return klass if klass
+    end
+
+    nil
+  end
+
+  def candidates_for(raw, namespaces = self.namespaces, fallback: true)
+    if raw.include?('::')
+      [raw]
+    else
+      Array(namespaces).map { |ns| "#{ns}::#{raw}" } + (fallback ? [raw] : [])
+    end
+  end
+
+  def try_constantize(candidate)
+    ActiveSupport::Dependencies.constantize(candidate)
+  rescue NameError, LoadError
+    begin
+      Object.const_get(candidate)
+    rescue NameError
+      nil
     end
   end
 end

data/lib/lighthouse/support/naming.rb

@@ -1,71 +1,67 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module Support
-    # Central rule for translating GraphQL (camelCase) names into Rails
-    # (snake_case) attributes/columns, and for tolerant argument lookup.
-    #
-    # This is the single home for casing logic; every directive/resolver that
-    # needs to map a GraphQL name to a model attribute or DB column routes here
-    # instead of re-implementing `.underscore` fallbacks.
-    module Naming
-      module_function
+# Central rule for translating GraphQL (camelCase) names into Rails
+# (snake_case) attributes/columns, and for tolerant argument lookup.
+#
+# This is the single home for casing logic; every directive/resolver that
+# needs to map a GraphQL name to a model attribute or DB column routes here
+# instead of re-implementing `.underscore` fallbacks.
+module Lighthouse::Support::Naming
+  module_function
 
-      # GraphQL field name -> Rails attribute/method name.
-      # e.g. "customAttributes" -> "custom_attributes"
-      #
-      # This is the default field-reader rule and the basis for relation method
-      # name derivation. The `@rename(attribute:)` directive is the explicit
-      # override that bypasses this.
-      def attribute(graphql_name)
-        graphql_name.to_s.underscore
-      end
+  # GraphQL field name -> Rails attribute/method name.
+  # e.g. "customAttributes" -> "custom_attributes"
+  #
+  # This is the default field-reader rule and the basis for relation method
+  # name derivation. The `@rename(attribute:)` directive is the explicit
+  # override that bypasses this.
+  def attribute(graphql_name)
+    graphql_name.to_s.underscore
+  end
 
-      # Resolve a GraphQL "column" token (often an ALLCAPS enum key, or a raw
-      # string) to a usable column name.
-      #
-      # NOTE: kept behavior-compatible with the historical `resolve_column_name`
-      # so existing whereConditions queries are unaffected. Word-boundary
-      # recovery for enum keys is handled separately by generating column enums
-      # with explicit `@enum(value:)` mappings.
-      def column(graphql_name, _relation = nil)
-        name = graphql_name.to_s
-        name = name.downcase if name == name.upcase
-        name = name.tr('-', '_')
-        name = name.underscore if name.include?(' ')
-        name
-      end
+  # Resolve a GraphQL "column" token (often an ALLCAPS enum key, or a raw
+  # string) to a usable column name.
+  #
+  # NOTE: kept behavior-compatible with the historical `resolve_column_name`
+  # so existing whereConditions queries are unaffected. Word-boundary
+  # recovery for enum keys is handled separately by generating column enums
+  # with explicit `@enum(value:)` mappings.
+  def column(graphql_name, _relation = nil)
+    name = graphql_name.to_s
+    name = name.downcase if name == name.upcase
+    name = name.tr('-', '_')
+    name = name.underscore if name.include?(' ')
+    name
+  end
 
-      # Fetch an argument value from a hash tolerant of camelCase/snake_case and
-      # string/symbol keys. Replaces the ad-hoc `args[:x] || args['x'] || ...`
-      # chains scattered across resolvers.
-      def fetch_arg(args_h, name)
-        return nil if args_h.nil?
+  # Fetch an argument value from a hash tolerant of camelCase/snake_case and
+  # string/symbol keys. Replaces the ad-hoc `args[:x] || args['x'] || ...`
+  # chains scattered across resolvers.
+  def fetch_arg(args_h, name)
+    return nil if args_h.nil?
 
-        candidate_keys(name).each do |key|
-          value = args_h[key]
-          return value unless value.nil?
-        end
-        nil
-      end
+    candidate_keys(name).each do |key|
+      value = args_h[key]
+      return value unless value.nil?
+    end
+    nil
+  end
 
-      def candidate_keys(name)
-        raw = name.to_s
-        snake = raw.underscore
-        [raw.to_sym, raw, snake.to_sym, snake].uniq
-      end
+  def candidate_keys(name)
+    raw = name.to_s
+    snake = raw.underscore
+    [raw.to_sym, raw, snake.to_sym, snake].uniq
+  end
 
-      # Derive an Eloquent-style relation name from a `has<Relation>` argument
-      # name, e.g. "hasContact" -> "contacts". Returns nil when the argument does
-      # not follow the `has` convention.
-      def derive_relation_name(arg_name)
-        return nil unless arg_name.to_s.match?(/^has/i)
+  # Derive an Eloquent-style relation name from a `has<Relation>` argument
+  # name, e.g. "hasContact" -> "contacts". Returns nil when the argument does
+  # not follow the `has` convention.
+  def derive_relation_name(arg_name)
+    return nil unless arg_name.to_s.match?(/^has/i)
 
-        trailing = arg_name.to_s.sub(/^has/i, '')
-        return nil if trailing.empty?
+    trailing = arg_name.to_s.sub(/^has/i, '')
+    return nil if trailing.empty?
 
-        trailing.underscore.pluralize
-      end
-    end
+    trailing.underscore.pluralize
   end
 end

data/lib/lighthouse/tasks/lighthouse.rake

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+namespace :lighthouse do
+  desc 'Write schema-directives.graphql and programmatic-types.graphql for IDE support (OUTPUT=dir, default Rails.root)'
+  task ide_helper: :environment do
+    output_dir = ENV.fetch('OUTPUT') { Rails.root.to_s }
+    Lighthouse::IdeHelper.write(output_dir: output_dir).each { |path| puts "Wrote #{path}" }
+  end
+
+  desc 'Build the schema cache in tmp/cache (for config.schema_cache; e.g. during a Docker build)'
+  task cache: :environment do
+    puts "Wrote #{Lighthouse::GraphQL::SchemaCache.warm!}"
+  end
+
+  desc 'Delete the schema cache'
+  task clear_cache: :environment do
+    Lighthouse::GraphQL::SchemaCache.clear!
+    puts "Cleared #{Lighthouse::GraphQL::SchemaCache.directory}"
+  end
+
+  namespace :persisted_queries do
+    desc 'Validate every operation of the persisted query manifest against the schema (SCHEMA=AppSchema)'
+    task verify: :environment do
+      schema = Object.const_get(ENV.fetch('SCHEMA', 'AppSchema'))
+      failures = Lighthouse::GraphQL::PersistedQueries.manifest.filter_map do |hash, body|
+        errors = schema.validate(body)
+        "#{hash}: #{errors.map(&:message).join('; ')}" if errors.any?
+      end
+      abort("Operations the schema no longer accepts:\n#{failures.join("\n")}") if failures.any?
+      puts "#{Lighthouse::GraphQL::PersistedQueries.manifest.size} persisted operations are valid."
+    end
+  end
+end

data/lib/lighthouse/where_conditions/operator_map.rb

@@ -1,35 +1,31 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module WhereConditions
-    # Maps the GraphQL SQLOperator enum values to Arel predicate methods.
-    # Extracted from WhereConditionsApplier so that simple argument-filter
-    # directives (@eq, @neq, @in, @notIn, @like, @where) can share the same
-    # operator semantics.
-    module OperatorMap
-      OPERATORS = {
-        'EQ' => :eq,
-        'NEQ' => :not_eq,
-        'GT' => :gt,
-        'GTE' => :gteq,
-        'LT' => :lt,
-        'LTE' => :lteq,
-        'IN' => :in,
-        'NIN' => :not_in,
-        'CONTAINS' => :matches,
-        'STARTS_WITH' => :matches,
-        'ENDS_WITH' => :matches,
-        'IS_NULL' => :eq,
-        'IS_NOT_NULL' => :not_eq
-      }.freeze
+# Maps the GraphQL SQLOperator enum values to Arel predicate methods.
+# Extracted from WhereConditionsApplier so that simple argument-filter
+# directives (@eq, @neq, @in, @notIn, @like, @where) can share the same
+# operator semantics.
+module Lighthouse::WhereConditions::OperatorMap
+  OPERATORS = {
+    'EQ' => :eq,
+    'NEQ' => :not_eq,
+    'GT' => :gt,
+    'GTE' => :gteq,
+    'LT' => :lt,
+    'LTE' => :lteq,
+    'IN' => :in,
+    'NIN' => :not_in,
+    'CONTAINS' => :matches,
+    'STARTS_WITH' => :matches,
+    'ENDS_WITH' => :matches,
+    'IS_NULL' => :eq,
+    'IS_NOT_NULL' => :not_eq
+  }.freeze
 
-      def self.[](operator)
-        OPERATORS[operator]
-      end
+  def self.[](operator)
+    OPERATORS[operator]
+  end
 
-      def self.supported?(operator)
-        OPERATORS.key?(operator)
-      end
-    end
+  def self.supported?(operator)
+    OPERATORS.key?(operator)
   end
 end