lighthouse-graphql 0.1.0

data/lib/lighthouse/schema_implementation.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# Minimal SchemaImplementation used when the app doesn't provide one.
+# It delegates runtime resolution to either:
+# - singleton resolver methods attached to schema types (e.g. `Inbox.resolve_field_conversations`),
+# - the field's resolve proc (if present),
+# - or the object's method matching the field name.
+class SchemaImplementation
+  attr_accessor :schema
+
+  def initialize
+    @schema = nil
+  end
+
+  # Called by graphql-ruby as the default resolver: (type, field, obj, args, ctx)
+  def call(type, field, obj, args, ctx)
+    field_name = extract_field_name(field)
+
+    # Prefer singleton resolver methods attached during post_process
+    owner_candidates = [type]
+    if type.respond_to?(:metadata) && type.metadata.is_a?(Hash) && type.metadata[:type_class]
+      owner_candidates << type.metadata[:type_class]
+    end
+    owner_candidates << lookup_owner_type(type)
+
+    resolver_method_name = "resolve_field_#{field_name}"
+    owner = owner_candidates.compact.find do |cand|
+      next false unless cand.respond_to?(resolver_method_name)
+      m = cand.method(resolver_method_name)
+      source_file, = m.source_location
+      source_file && source_file.include?('/lib/lighthouse/')
+    end
+
+    if owner
+      resolver = owner.method(resolver_method_name)
+      param_count = resolver.parameters.length
+      return resolver.call(obj, args) if param_count == 2
+      resolver.call(obj, args, ctx)
+    end
+
+    # Use field-level resolve proc if available
+    if field.respond_to?(:resolve_proc) && field.resolve_proc
+      return field.resolve_proc.call(obj, args, ctx)
+    end
+
+    if obj.is_a?(Hash)
+      return obj[field_name.to_s] if obj.key?(field_name.to_s)
+      return obj[field_name.to_sym] if obj.key?(field_name.to_sym)
+
+      snake = naming_attribute(field_name)
+      return obj[snake] if obj.key?(snake)
+      return obj[snake.to_sym] if obj.key?(snake.to_sym)
+
+      return nil
+    end
+
+    # Fallback to reading the attribute off the Ruby object. Map the GraphQL
+    # field name (camelCase) to the Rails attribute (snake_case) when the object
+    # does not respond to the literal name, so e.g. `customAttributes` resolves
+    # to `custom_attributes` without a per-field resolver.
+    return obj.public_send(field_name) if obj.respond_to?(field_name)
+
+    snake = naming_attribute(field_name)
+    return obj.public_send(snake) if snake != field_name.to_s && obj.respond_to?(snake)
+
+    nil
+  end
+
+  def resolve_type(abstract_type, obj, ctx)
+    # Try to resolve to a Ruby type class under Types::<Name>Type
+    type_name = abstract_type.respond_to?(:name) ? abstract_type.name : abstract_type.to_s
+    begin
+      Object.const_get("Types::#{type_name}Type")
+    rescue StandardError
+      nil
+    end
+  end
+
+  def coerce_input(type, value, ctx)
+    value
+  end
+
+  def coerce_result(type, value, ctx)
+    value
+  end
+
+  private
+
+  def naming_attribute(field_name)
+    if defined?(Lighthouse::Support::Naming)
+      Lighthouse::Support::Naming.attribute(field_name)
+    else
+      field_name.to_s.underscore
+    end
+  end
+
+  def extract_field_name(field)
+    if field.respond_to?(:graphql_name)
+      field.graphql_name.to_s
+    elsif field.respond_to?(:name)
+      field.name.to_s
+    else
+      field.to_s
+    end
+  end
+
+  def lookup_owner_type(type)
+    return nil unless @schema
+    type_name = if type.respond_to?(:graphql_name)
+                  type.graphql_name
+                elsif type.respond_to?(:name)
+                  type.name.to_s
+                else
+                  type.to_s
+                end
+
+    @schema.types[type_name]
+  end
+end

data/lib/lighthouse/sdl_loader.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Lighthouse
+  module GraphQL
+    module SDLLoader
+      module_function
+
+      def load_from_folder(folder)
+        files = Dir[File.join(folder, '**', '*.graphql')].sort
+        if files.empty?
+          # fallback to the monolithic schema.graphql in apps/chatwoot
+          # schema.graphql is located at apps/chatwoot/schema.graphql
+          default = File.expand_path('../../..//schema.graphql', __dir__)
+          return File.read(default) if File.exist?(default)
+          return ''
+        end
+
+        files.map! { |f| File.read(f) }
+        files.join("\n\n")
+      end
+
+      def load_from_file(path)
+        File.read(path)
+      end
+    end
+  end
+end

data/lib/lighthouse/support/authorization.rb

@@ -0,0 +1,26 @@
+# 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
+
+      def authenticated_user(context)
+        Lighthouse::Config.authenticated_user.call(context)
+      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
+  end
+end

data/lib/lighthouse/support/directive_args.rb

@@ -0,0 +1,33 @@
+# 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
+
+      # 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
+
+        unwrap(arg.value)
+      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
+    end
+  end
+end

data/lib/lighthouse/support/model_resolver.rb

@@ -0,0 +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
+    end
+  end
+end

data/lib/lighthouse/support/naming.rb

@@ -0,0 +1,71 @@
+# 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
+
+      # 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
+
+      # 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
+
+      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)
+
+        trailing = arg_name.to_s.sub(/^has/i, '')
+        return nil if trailing.empty?
+
+        trailing.underscore.pluralize
+      end
+    end
+  end
+end

data/lib/lighthouse/where_conditions/operator_map.rb

@@ -0,0 +1,35 @@
+# 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
+
+      def self.[](operator)
+        OPERATORS[operator]
+      end
+
+      def self.supported?(operator)
+        OPERATORS.key?(operator)
+      end
+    end
+  end
+end

data/lib/lighthouse-graphql.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Canonical entrypoint for the `lighthouse-graphql` gem.
+#
+#   require 'lighthouse-graphql'
+#
+# Lighthouse brings PHP Lighthouse's SDL-first, directive-driven approach to
+# building GraphQL APIs to Ruby on Rails. See docs/ for the full guide.
+require_relative 'lighthouse/graphql/version'
+require_relative 'lighthouse/rb_lighthouse'

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification
+name: lighthouse-graphql
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vaz Innovation
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !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,
+  @belongsTo, @whereConditions, @orderBy, @field, @auth and more — instead of
+  hand-writing a resolver for every field. It is a Ruby adaptation of the PHP
+  Lighthouse library (nuwave/lighthouse) built on top of graphql-ruby, with
+  first-class Apollo Federation support so a Rails service can act as a subgraph.
+email:
+- engineering@vazinnovation.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- docs/authorization.md
+- docs/best-practices.md
+- docs/configuration.md
+- docs/custom-directives.md
+- docs/directives.md
+- docs/federation.md
+- docs/filtering-and-ordering.md
+- docs/getting-started.md
+- docs/relationships.md
+- lib/lighthouse-graphql.rb
+- lib/lighthouse/config.rb
+- lib/lighthouse/contracts/arg_builder.rb
+- lib/lighthouse/contracts/arg_manipulator.rb
+- lib/lighthouse/contracts/directive.rb
+- lib/lighthouse/contracts/field_manipulator.rb
+- lib/lighthouse/contracts/field_middleware.rb
+- lib/lighthouse/contracts/field_resolver.rb
+- lib/lighthouse/dataloader_sources/association_loader.rb
+- lib/lighthouse/dataloader_sources/model_loader.rb
+- lib/lighthouse/directive_resolvers/aggregate_resolver.rb
+- lib/lighthouse/directive_resolvers/all_resolver.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/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/paginate_resolver.rb
+- lib/lighthouse/directive_resolvers/rename_resolver.rb
+- lib/lighthouse/directive_resolvers/resolution.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/registry.rb
+- lib/lighthouse/directives/relation_directive.rb
+- lib/lighthouse/directives/where_conditions_directive.rb
+- lib/lighthouse/graphql.rb
+- lib/lighthouse/graphql/version.rb
+- lib/lighthouse/rb_lighthouse.rb
+- lib/lighthouse/reference_resolver.rb
+- lib/lighthouse/schema_factory.rb
+- lib/lighthouse/schema_generator.rb
+- lib/lighthouse/schema_implementation.rb
+- lib/lighthouse/sdl_loader.rb
+- lib/lighthouse/support/authorization.rb
+- lib/lighthouse/support/directive_args.rb
+- lib/lighthouse/support/model_resolver.rb
+- lib/lighthouse/support/naming.rb
+- lib/lighthouse/where_conditions/operator_map.rb
+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
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: SDL-first, directive-driven GraphQL for Ruby on Rails — a port of PHP Lighthouse.
+test_files: []