lighthouse-graphql 0.1.0

data/lib/lighthouse/directives/where_conditions_directive.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'graphql'
+
+module Lighthouse
+  module GraphQL
+    module Directives
+      class WhereConditionsDirective
+        SQLOPERATOR_TYPE_NAME = 'SQLOperator'.freeze
+        MIXED_SCALAR_NAME = 'Mixed'.freeze
+        PLACEHOLDER_SCALAR_NAME = '_'.freeze
+
+        # Supported operators in the generated GraphQL input type performance.
+        SUPPORTED_OPERATORS = %w[EQ NEQ GT GTE LT LTE IN NIN CONTAINS STARTS_WITH ENDS_WITH IS_NULL IS_NOT_NULL].freeze
+
+        def self.manipulate(sdl)
+          return sdl unless sdl.is_a?(String) && !sdl.empty?
+          begin
+            ast = ::GraphQL::Language::Parser.parse(sdl)
+          rescue => e
+            warn("Lighthouse::GraphQL::Directives::WhereConditionsDirective: parse failed: #{e.class}: #{e.message}")
+            return sdl
+          end
+          existing_defs = ast.definitions.map { |defn| defn.respond_to?(:name) ? defn.name : nil }.compact
+
+          generated = []
+
+          object_types = ast.definitions.select do |defn|
+            defn.is_a?(::GraphQL::Language::Nodes::ObjectTypeDefinition) || defn.is_a?(::GraphQL::Language::Nodes::InterfaceTypeDefinition)
+          end
+
+          object_types.each do |type_def|
+            (type_def.fields || []).each do |field|
+              (field.arguments || []).each do |arg|
+                directive = arg.directives&.find { |d| %w[whereConditions whereHasConditions].include?(d.name) }
+                next unless directive
+
+                if arg.description.nil? || arg.description.empty?
+                  arg.instance_variable_set(
+                    :@description,
+                    directive.name == 'whereHasConditions' ? 'Filter results by related records conditions.' : 'Filter results by field conditions.'
+                  )
+                end
+
+                input_type_name = "#{camelize(type_def.name)}#{camelize(field.name)}#{camelize(arg.name)}WhereConditions"
+                column_enum_name = "#{camelize(type_def.name)}#{camelize(field.name)}#{camelize(arg.name)}Column"
+                relation_input_name = "#{input_type_name}Relation"
+
+                apply_arg_type_replacement(arg, input_type_name)
+
+                # Build input type if needed.
+                unless existing_defs.include?(input_type_name)
+                  generated << build_where_condition_input(input_type_name, column_enum_name, relation_input_name, directive)
+                  existing_defs << input_type_name
+                end
+
+                # Build relation type for HAS support in whereConditions
+                if directive.name == 'whereConditions' && !existing_defs.include?(relation_input_name)
+                  generated << build_where_condition_relation_input(relation_input_name, input_type_name)
+                  existing_defs << relation_input_name
+                end
+
+                # Build column enum type unless columnsEnum is provided.
+                columns_enum = directive_argument_value(directive, 'columnsEnum')
+                columns = directive_argument_value(directive, 'columns')
+                if columns_enum.nil? && columns && !columns.empty? && !existing_defs.include?(column_enum_name)
+                  generated << build_column_enum(column_enum_name, columns)
+                  existing_defs << column_enum_name
+                end
+              end
+            end
+          end
+
+          # Append base utility types only once
+          unless existing_defs.include?(SQLOPERATOR_TYPE_NAME)
+            generated << build_sql_operator_enum
+            existing_defs << SQLOPERATOR_TYPE_NAME
+          end
+
+          unless existing_defs.include?(MIXED_SCALAR_NAME)
+            generated << "scalar #{MIXED_SCALAR_NAME}"
+            existing_defs << MIXED_SCALAR_NAME
+          end
+
+          # Some SDL files use `_` as a placeholder input type, even when no
+          # whereConditions directive is attached (e.g. WIP schema pieces). If we
+          # don't define it, GraphQL-Ruby raises UnresolvedLateBoundTypeError.
+          if contains_placeholder_type?(ast) && !existing_defs.include?(PLACEHOLDER_SCALAR_NAME)
+            generated << "scalar #{PLACEHOLDER_SCALAR_NAME}"
+            existing_defs << PLACEHOLDER_SCALAR_NAME
+          end
+
+          return sdl if generated.empty?
+
+          modified_sdl = ::GraphQL::Language::Printer.new.print(ast)
+          modified_sdl + "\n\n" + generated.join("\n\n")
+        end
+
+        def self.apply_arg_type_replacement(arg, input_type_name)
+          case arg.type
+          when ::GraphQL::Language::Nodes::TypeName
+            if arg.type.name == '_'
+              new_type = ::GraphQL::Language::Nodes::TypeName.new(name: input_type_name)
+              arg.instance_variable_set(:@type, new_type)
+            end
+          when ::GraphQL::Language::Nodes::NonNullType
+            inner = arg.type.of_type
+            if inner.is_a?(::GraphQL::Language::Nodes::TypeName) && inner.name == '_'
+              arg.instance_variable_set(:@type, ::GraphQL::Language::Nodes::NonNullType.new(of_type: ::GraphQL::Language::Nodes::TypeName.new(name: input_type_name)))
+            end
+          end
+        end
+
+        def self.build_where_condition_input(type_name, column_enum_name, relation_type_name, directive)
+          column_type = directive_argument_value(directive, 'columnsEnum') || column_enum_name
+
+          fields = []
+          fields << "  column: #{column_type}"
+          fields << "  operator: #{SQLOPERATOR_TYPE_NAME} = EQ"
+          fields << "  value: #{MIXED_SCALAR_NAME}"
+          fields << "  AND: [#{type_name}!]"
+          fields << "  OR: [#{type_name}!]"
+          fields << "  HAS: #{relation_type_name}" if directive.name == 'whereConditions'
+
+          <<~TEXT.strip
+            input #{type_name} {
+            #{fields.join("\n")}
+            }
+          TEXT
+        end
+
+        def self.build_where_condition_relation_input(type_name, condition_type_name)
+          <<~TEXT.strip
+            input #{type_name} {
+              relation: String!
+              operator: #{SQLOPERATOR_TYPE_NAME} = GTE
+              amount: Int = 1
+              condition: #{condition_type_name}
+            }
+          TEXT
+        end
+
+        def self.build_column_enum(name, columns)
+          values = Array(columns).map do |column|
+            value = column.to_s
+            key = value.gsub(/[^0-9A-Za-z]/, '_').upcase
+            "  #{key}"
+          end.compact.uniq
+
+          <<~TEXT.strip
+            enum #{name} {
+            #{values.join("\n")}
+            }
+          TEXT
+        end
+
+        def self.build_sql_operator_enum
+          values = SUPPORTED_OPERATORS.map { |op| "  #{op}" }
+          <<~TEXT.strip
+            enum #{SQLOPERATOR_TYPE_NAME} {
+            #{values.join("\n")}
+            }
+          TEXT
+        end
+
+        def self.directive_argument_value(directive, name)
+          arg = directive.arguments&.find { |a| a.name == name }
+          return nil unless arg
+
+          # Supports both Babel-style AST and raw Ruby value.
+          value = arg.value.respond_to?(:value) ? arg.value.value : arg.value
+
+          if name == 'columns' && value.is_a?(Array)
+            value.map { |it| it.respond_to?(:value) ? it.value : it }
+          else
+            value
+          end
+        end
+
+        def self.contains_placeholder_type?(document)
+          document.definitions.any? do |defn|
+            next false unless defn.respond_to?(:fields) && defn.fields.respond_to?(:any?)
+            (defn.fields || []).any? do |field|
+              (field.respond_to?(:arguments) ? field.arguments || [] : []).any? { |arg| type_references_placeholder?(arg.type) }
+            end
+          end
+        rescue StandardError
+          false
+        end
+
+        def self.type_references_placeholder?(type_node)
+          case type_node
+          when ::GraphQL::Language::Nodes::TypeName
+            type_node.name == PLACEHOLDER_SCALAR_NAME
+          when ::GraphQL::Language::Nodes::NonNullType, ::GraphQL::Language::Nodes::ListType
+            type_references_placeholder?(type_node.of_type)
+          else
+            false
+          end
+        end
+
+        def self.camelize(value)
+          value.to_s.split(/[_\s]+/).map { |part| part.slice(0,1).upcase + part.slice(1..).to_s }.join
+        end
+      end
+    end
+  end
+end

data/lib/lighthouse/graphql/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Lighthouse
+  module GraphQL
+    VERSION = '0.1.0'
+  end
+end

data/lib/lighthouse/graphql.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Alternate entrypoint matching the namespace:
+#
+#   require 'lighthouse/graphql'
+#
+require_relative 'graphql/version'
+require_relative 'rb_lighthouse'

data/lib/lighthouse/rb_lighthouse.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# ActiveSupport core extensions the library relies on (underscore, pluralize,
+# blank?/present?, deep_symbolize_keys). In a Rails host these are already
+# loaded; requiring them here keeps the gem usable standalone.
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/keys'
+
+## Load internal dependencies individually so a single missing file
+## doesn't prevent the rest from loading. Failures are logged but not
+## raised so callers can require specific files if needed.
+%w[
+  config
+  reference_resolver
+  support/naming
+  support/directive_args
+  support/model_resolver
+  support/authorization
+  where_conditions/operator_map
+  contracts/directive
+  contracts/field_resolver
+  contracts/field_middleware
+  contracts/field_manipulator
+  contracts/arg_manipulator
+  contracts/arg_builder
+  sdl_loader
+  schema_generator
+  schema_factory
+  schema_implementation
+  directives/relation_directive
+  directives/where_conditions_directive
+  directive_resolvers/has_many_resolver
+  directive_resolvers/aggregate_resolver
+  directive_resolvers/field_resolver
+  directive_resolvers/where_conditions_applier
+  directive_resolvers/belongs_to_resolver
+  directive_resolvers/all_resolver
+  directive_resolvers/find_resolver
+  directive_resolvers/paginate_resolver
+  directive_resolvers/auth_resolver
+  directive_resolvers/belongs_to_many_resolver
+  directive_resolvers/has_one_resolver
+  directive_resolvers/first_resolver
+  directive_resolvers/count_resolver
+  directive_resolvers/rename_resolver
+  directive_resolvers/method_resolver
+  directive_resolvers/base
+  directive_resolvers/resolution
+  directive_resolvers/guard_resolver
+  directive_resolvers/can_resolver
+  directives/arguments/base
+  directives/arguments/filters
+  directives/arguments/order_by
+  directives/registry
+  dataloader_sources/association_loader
+  dataloader_sources/model_loader
+].each do |rel|
+  begin
+    require_relative rel
+  rescue LoadError => e
+    warn("Lighthouse: could not require #{rel}: #{e.message}")
+  end
+end
+
+module Lighthouse
+  module GraphQL
+    module RbLightHouse
+      class << self
+        def get_schema(sdl_folder: nil, options: {})
+          base_types = options.delete(:base_types) || {}
+          schema_class = options.delete(:base_schema)
+
+          Lighthouse::GraphQL::SchemaFactory.build_base_schema(
+            sdl_folder: sdl_folder,
+            base_types: base_types,
+            schema_options: options.merge(schema_class: schema_class)
+          )
+        end
+
+        def configure(&block)
+          Lighthouse::GraphQL::Config.configure(&block) if defined?(Lighthouse::GraphQL::Config)
+        end
+      end
+    end
+  end
+end

data/lib/lighthouse/reference_resolver.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Lighthouse
+  class ReferenceResolver
+    @resolvers = {}
+
+    class << self
+      def register(typename, &block)
+        @resolvers[typename.to_s] = block
+      end
+
+      def resolve(typename, reference, context)
+        resolver = @resolvers[typename.to_s]
+        return nil unless resolver
+
+        resolver.call(reference, context)
+      end
+
+      def clear!
+        @resolvers.clear
+      end
+    end
+  end
+end

data/lib/lighthouse/schema_factory.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Lighthouse
+  module GraphQL
+    # Public entrypoint for building an executable schema from SDL.
+    #
+    # The returned value is a GraphQL-Ruby schema class (from `GraphQL::Schema.from_definition`)
+    # intended to be subclassed by the application schema class.
+    module SchemaFactory
+      module_function
+
+      def build_base_schema(sdl_folder: nil, sdl: nil, base_types: {}, schema_options: {}, **extra_options)
+        # Absorb any extra keyword options (e.g. `federation: true`) into the
+        # schema options bag so callers can pass schema-level flags directly
+        # without the factory needing to enumerate every one.
+        schema_options = extra_options.merge(schema_options)
+
+        sdl_string =
+          if sdl
+            sdl
+          else
+            folder = sdl_folder || (Lighthouse::GraphQL::Config.sdl_folder if defined?(Lighthouse::GraphQL::Config))
+            if folder && Dir.exist?(folder)
+              Lighthouse::GraphQL::SDLLoader.load_from_folder(folder)
+            else
+              # fallback to apps/chatwoot/schema.graphql
+              path = File.expand_path('../../schema.graphql', __dir__)
+              File.read(path)
+            end
+          end
+
+        schema_class = schema_options.delete(:schema_class)
+
+        schema = Lighthouse::GraphQL::SchemaGenerator.build(
+          sdl_string,
+          base_types: base_types,
+          schema_class: schema_class,
+          **schema_options
+        )
+
+        schema
+      end
+    end
+  end
+end
+

data/lib/lighthouse/schema_generator.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module Lighthouse
+  module GraphQL
+    module SchemaGenerator
+      module_function
+
+      def build(sdl_string, **opts)
+        # Contribute SDL definitions for any registered directive the schema uses
+        # but hasn't declared, so the app doesn't hand-declare every directive.
+        sdl_string = inject_directive_definitions(sdl_string)
+        # Augment SDL: convert list-typed fields with relationship directives
+        # (e.g. `roles: [Role!]! @belongsToMany`) into connection types
+        # (`roles: RoleConnection!`) and generate missing Connection/Edge types.
+        sdl_string = augment_sdl_with_connections(sdl_string)
+        impl =
+          if defined?(::SchemaImplementation)
+            ::SchemaImplementation.new
+          else
+            # Minimal fallback when SchemaImplementation isn't available.
+            # Keep the same dispatch semantics so directive resolvers work.
+            Class.new do
+              attr_accessor :schema
+
+              def call(type, field, obj, args, ctx)
+                field_name = field.respond_to?(:graphql_name) ? field.graphql_name.to_s : field.name.to_s
+                owner = schema && schema.types[type.respond_to?(:graphql_name) ? type.graphql_name : type.name.to_s]
+
+                if owner && owner.respond_to?("resolve_field_#{field_name}")
+                  resolver = owner.method("resolve_field_#{field_name}")
+                  param_count = resolver.parameters.length
+                  return resolver.call(obj, args) if param_count == 2
+
+                  return resolver.call(obj, args, ctx)
+                end
+
+                return field.resolve_proc.call(obj, args, ctx) if field.respond_to?(:resolve_proc) && field.resolve_proc
+
+                obj.respond_to?(field_name) ? obj.public_send(field_name) : nil
+              end
+
+              def resolve_type(_abstract_type, _obj, _ctx)
+                nil
+              end
+
+              def coerce_input(_type, value, _ctx)
+                value
+              end
+
+              def coerce_result(_type, value, _ctx)
+                value
+              end
+            end.new
+          end
+
+        final_sdl = sdl_string
+        base_types = opts.delete(:base_types) || {}
+        using = opts.delete(:using) || {}
+        schema_class = opts.delete(:schema_class) || ::GraphQL::Schema
+
+        # Build using the provided base class so federation / custom schema behavior
+        # is preserved through class hierarchy.
+        schema = schema_class.from_definition(final_sdl, default_resolve: impl, base_types: base_types, using: using)
+
+        # Make to_definition delegate to federation_sdl when available.
+        if schema.respond_to?(:federation_sdl)
+          schema.define_singleton_method(:to_definition) do
+            federation_sdl
+          end
+        end
+        # GraphQL-Ruby caches field resolution procs during schema build; rather
+        # than trying to override per-field `resolve_<field>` methods post-hoc,
+        # we install a single dispatcher here that prefers our generated
+        # `resolve_field_<name>` singletons.
+        if schema.respond_to?(:definition_default_resolve=) && schema.respond_to?(:definition_default_resolve)
+          previous_default = schema.definition_default_resolve
+          schema.definition_default_resolve = proc do |type, field, obj, arguments, ctx|
+            owner =
+              if type.respond_to?(:graphql_name)
+                schema.types[type.graphql_name]
+              elsif type.respond_to?(:name)
+                schema.types[type.name.to_s]
+              end
+
+            field_name = field.respond_to?(:graphql_name) ? field.graphql_name.to_s : field.name.to_s
+
+            if owner && owner.respond_to?("resolve_field_#{field_name}")
+              resolver = owner.method("resolve_field_#{field_name}")
+              source_file, = resolver.source_location
+              # GraphQL-Ruby's SDL builder also defines `resolve_field_*` methods
+              # internally. Only invoke ours (defined under `lib/lighthouse/`),
+              # otherwise we may call an internal resolver with the wrong arity.
+              if source_file && source_file.include?('/lib/lighthouse/')
+                param_count = resolver.parameters.length
+                next resolver.call(obj, arguments) if param_count == 2
+
+                next resolver.call(obj, arguments, ctx)
+              end
+            end
+
+            previous_default.call(type, field, obj, arguments, ctx)
+          end
+        end
+
+        # Give the implementation object access to the built schema so its
+        # runtime dispatcher can look up generated singleton resolvers.
+        begin
+          impl.schema = schema if impl.respond_to?(:schema=)
+        rescue StandardError
+          # ignore
+        end
+
+        post_process(schema, impl, **opts)
+
+        schema
+      end
+
+      def post_process(schema, impl, **_opts)
+        # Inspect types and fields for directives and attach generated resolvers
+        schema.types.each_value do |t|
+          next unless t.kind.object?
+
+          # Apply object-level federation directives to generated types so the
+          # Apollo Federation helper can detect entities and add _entities.
+          if t.ast_node && t.respond_to?(:key)
+            t.ast_node.directives.each do |dnode|
+              case dnode.name
+              when 'key'
+                arg = dnode.arguments.find { |a| a.name == 'fields' }
+                t.key(fields: arg.value) if arg && arg.respond_to?(:value)
+
+                # Setup federation resolve_reference: prefer a custom resolver
+                # registered with ReferenceResolver, but fall back to the base
+                # type's own resolve_reference (e.g. BaseObject's default model
+                # lookup) so direct-model entities resolve without a custom
+                # handler. Capture the inherited implementation before shadowing.
+                default_resolve_reference =
+                  t.respond_to?(:resolve_reference) ? t.method(:resolve_reference) : nil
+
+                t.define_singleton_method(:resolve_reference) do |reference, context|
+                  resolved = ::Lighthouse::ReferenceResolver.resolve(t.graphql_name, reference, context)
+                  next resolved unless resolved.nil?
+
+                  default_resolve_reference ? default_resolve_reference.call(reference, context) : nil
+                end
+              when 'extends'
+                t.extend_type if t.respond_to?(:extend_type)
+              when 'shareable'
+                t.shareable if t.respond_to?(:shareable)
+              when 'inaccessible'
+                t.inaccessible if t.respond_to?(:inaccessible)
+              when 'interfaceObject'
+                t.interface_object if t.respond_to?(:interface_object)
+              end
+            end
+          end
+
+          t.fields.each do |fname, field_def|
+            next unless field_def.ast_node
+
+            directives = field_def.ast_node.directives || []
+            registry = Lighthouse::DirectiveRegistry.default
+            # Apply wrapping directives in resolution order: data resolvers first
+            # (innermost), then @can (wraps to authorize the result), then guards
+            # (outermost, so authentication runs before anything else).
+            sorted = directives.sort_by { |d| registry.resolution_order(d.name) }
+
+            # Dispatch each directive to its registered resolver class. The
+            # registry replaces the previous hardcoded `case dnode.name` so that
+            # adding a directive is "register a class", not "edit the generator".
+            sorted.each do |dnode|
+              resolver_class = registry.resolution_class(dnode.name)
+              next unless resolver_class
+
+              resolver_class.new(field_def, t, dnode).define_resolver(t)
+            end
+
+            # GraphQL-Ruby's SDL builder defines `resolve_<field>` methods that call
+            # the schema's `definition_default_resolve`. Override `resolve_<field>`
+            # to delegate to our generated `resolve_field_<field>` when present, so
+            # runtime resolution consistently reaches our directive resolvers.
+            begin
+              method_name = "resolve_field_#{field_def.name}"
+              runtime_name = "resolve_#{field_def.name}"
+              if t.respond_to?(method_name)
+                t.define_singleton_method(runtime_name) do |obj, arguments, ctx|
+                  public_send(method_name, obj, arguments, ctx)
+                end
+              end
+            rescue StandardError
+              # ignore override failures
+            end
+
+            # Ensure GraphQL-Ruby's ConnectionExtension is applied for SDL-built
+            # connection fields so the runtime will wrap returned values into
+            # Connection objects (populate_connection will be invoked).
+            begin
+              # Avoid adding the ConnectionExtension if pagination args were
+              # already added by SDL augmentation (to prevent duplicate arg
+              # collisions).
+              if field_def.connection? && !(field_def.extensions.any? do |e|
+                e.is_a?(::GraphQL::Schema::Field::ConnectionExtension)
+              end) && !((field_def.arguments || {}).key?(:after) || (field_def.arguments || {}).key?('after'))
+                field_def.extension(::GraphQL::Schema::Field::ConnectionExtension,
+                                    call_after_define: false)
+              end
+            rescue StandardError
+              # ignore failures during post-processing
+            end
+          end
+        end
+
+        # return schema for convenience
+        schema
+      end
+
+      # Scan SDL string for list-typed fields that carry relationship directives
+      # and produce Connection/Edge types where missing. This is a lightweight
+      # transformation that mirrors Lighthouse behavior: clients can declare
+      # `roles: [Role!]! @belongsToMany` and the builder will expose a
+      # `RoleConnection` type and swap the field to return that connection.
+      def augment_sdl_with_connections(sdl)
+        # Drive SDL manipulation through the registry so each directive owns its
+        # manipulation behavior and new manipulators can be added by registering
+        # a class (no edits here).
+        Lighthouse::DirectiveRegistry.default.manipulate_sdl(sdl)
+      end
+
+      # Prepend `directive @name(...) on ...` definitions for registered,
+      # self-describing directives that the SDL uses but has not declared.
+      # Already-declared directives are left untouched (no duplicates).
+      def inject_directive_definitions(sdl)
+        return sdl unless sdl.is_a?(String)
+
+        declared = sdl.scan(/directive\s+@(\w+)/).flatten.to_set
+        missing = Lighthouse::DirectiveRegistry.default.directive_definitions
+                                               .reject { |name, _| declared.include?(name) }
+        return sdl if missing.empty?
+
+        "#{missing.values.join("\n")}\n\n#{sdl}"
+      end
+    end
+  end
+end