lighthouse-graphql 0.6.0 → 0.7.0

data/sig/lighthouse.rbs

@@ -92,8 +92,14 @@ module Lighthouse
     def self.[]: (Symbol | String key) -> untyped
     def self.reset!: () -> void
 
-    def self.sdl_folder: () -> path?
-    def self.sdl_folder=: (path? folder) -> path?
+    # The schema's entrypoint, which imports the other files (SchemaStitcher).
+    def self.schema_path: () -> path?
+    def self.schema_path=: (path? path) -> path?
+    def self.schema_directory: () -> String?
+
+    # Rewrite the IDE helper files on boot and every reload; nil: in development with a graphql.config.yml.
+    def self.ide_helper: () -> bool?
+    def self.ide_helper=: (bool? enabled) -> bool?
 
     # { queries:, mutations:, subscriptions:, builders:, validators:, events: } => [namespace, ...].
     # Assigning a partial hash overrides only the kinds it names.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lighthouse-graphql
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Vaz Innovation
@@ -70,6 +70,7 @@ files:
 - docs/relationships.md
 - docs/relay.md
 - docs/resolvers.md
+- docs/schema-organisation.md
 - docs/security.md
 - docs/subscriptions.md
 - docs/types.md
@@ -87,6 +88,7 @@ files:
 - lib/generators/lighthouse/subscription_generator.rb
 - lib/generators/lighthouse/validator_generator.rb
 - lib/lighthouse-graphql.rb
+- lib/lighthouse/ast_builder.rb
 - lib/lighthouse/async_mutation_job.rb
 - lib/lighthouse/broadcast_job.rb
 - lib/lighthouse/broadcasting.rb
@@ -98,6 +100,7 @@ files:
 - lib/lighthouse/contracts/arg_builder.rb
 - lib/lighthouse/contracts/arg_manipulator.rb
 - lib/lighthouse/contracts/directive.rb
+- lib/lighthouse/contracts/field_builder.rb
 - lib/lighthouse/contracts/field_manipulator.rb
 - lib/lighthouse/contracts/field_middleware.rb
 - lib/lighthouse/contracts/field_resolver.rb
@@ -143,7 +146,6 @@ files:
 - lib/lighthouse/directive_resolvers/throttle_resolver.rb
 - lib/lighthouse/directive_resolvers/type_method_resolver.rb
 - lib/lighthouse/directive_resolvers/validator_resolver.rb
-- lib/lighthouse/directive_resolvers/where_conditions_applier.rb
 - lib/lighthouse/directive_resolvers/with_count_resolver.rb
 - lib/lighthouse/directive_resolvers/with_resolver.rb
 - lib/lighthouse/directives/arguments/base.rb
@@ -151,7 +153,11 @@ files:
 - lib/lighthouse/directives/arguments/more_filters.rb
 - lib/lighthouse/directives/arguments/order_by.rb
 - lib/lighthouse/directives/arguments/soft_deletes.rb
+- lib/lighthouse/directives/arguments/where_conditions.rb
+- lib/lighthouse/directives/arguments/where_conditions_base.rb
+- lib/lighthouse/directives/arguments/where_has_conditions.rb
 - lib/lighthouse/directives/definitions.rb
+- lib/lighthouse/directives/generated_types.rb
 - lib/lighthouse/directives/model_directive.rb
 - lib/lighthouse/directives/node_directive.rb
 - lib/lighthouse/directives/pagination_info_types.rb
@@ -159,7 +165,7 @@ files:
 - lib/lighthouse/directives/registry.rb
 - lib/lighthouse/directives/soft_deletes_directive.rb
 - lib/lighthouse/directives/visibility_directive.rb
-- lib/lighthouse/directives/where_conditions_directive.rb
+- lib/lighthouse/document_ast.rb
 - lib/lighthouse/enum_directive.rb
 - lib/lighthouse/errors.rb
 - lib/lighthouse/events.rb
@@ -184,6 +190,7 @@ files:
 - lib/lighthouse/nested_mutations/many_to_many_operations.rb
 - lib/lighthouse/nested_mutations/partitioner.rb
 - lib/lighthouse/node_registry.rb
+- lib/lighthouse/order_by/types.rb
 - lib/lighthouse/pagination.rb
 - lib/lighthouse/persisted_queries.rb
 - lib/lighthouse/persisted_queries/batch.rb
@@ -201,7 +208,7 @@ files:
 - lib/lighthouse/schema_factory.rb
 - lib/lighthouse/schema_generator.rb
 - lib/lighthouse/schema_implementation.rb
-- lib/lighthouse/sdl_loader.rb
+- lib/lighthouse/schema_stitcher.rb
 - lib/lighthouse/subscription.rb
 - lib/lighthouse/support/arguments.rb
 - lib/lighthouse/support/authorization.rb
@@ -217,7 +224,11 @@ files:
 - lib/lighthouse/type_resolution.rb
 - lib/lighthouse/upload.rb
 - lib/lighthouse/upload_store.rb
+- lib/lighthouse/where_conditions/columns.rb
+- lib/lighthouse/where_conditions/handler.rb
+- lib/lighthouse/where_conditions/json_column.rb
 - lib/lighthouse/where_conditions/operator_map.rb
+- lib/lighthouse/where_conditions/types.rb
 - sig/lighthouse.rbs
 - sig/lighthouse/controller.rbs
 - sig/lighthouse/directives.rbs

data/lib/lighthouse/directive_resolvers/where_conditions_applier.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-class Lighthouse::GraphQL::DirectiveResolvers::WhereConditionsApplier
-  # Operator semantics live in Lighthouse::WhereConditions::OperatorMap so
-  # they can be shared with the simple argument-filter directives.
-  SUPPORTED_OPERATORS = Lighthouse::WhereConditions::OperatorMap::OPERATORS
-  # graphql-ruby hands input objects over with Ruby-style keys, so the
-  # generated input's AND/OR/HAS fields arrive as :and/:or/:has.
-  LOGICAL_KEYS = { and: :AND, or: :OR, has: :HAS }.freeze
-
-  class << self
-    def apply(relation, value)
-      return relation unless relation.respond_to?(:where)
-
-      condition = normalize_condition(value)
-      return relation unless condition
-
-      # AND narrows the incoming scope step by step; each OR branch starts
-      # from the incoming scope, and their union replaces it.
-      result = apply_all(relation, condition[:AND])
-      result = apply_any(relation, condition[:OR]) || result
-      result = apply_has_condition(result, condition[:HAS])
-      result = apply_single_condition(result, condition) if condition.key?(:column)
-      result
-    end
-
-    def apply_has(relation, has_cond)
-      relation_name = has_cond[:relation].to_s
-      return relation if relation_name.blank?
-
-      resolved_relation_name = resolve_relation_name(relation, relation_name)
-      return relation if resolved_relation_name.blank?
-
-      reflection = reflection_for(relation, resolved_relation_name)
-      return relation unless reflection&.klass
-
-      joined = relation.joins(resolved_relation_name.to_sym)
-      return joined.distinct if has_cond[:condition].blank?
-
-      # Use an EXISTS-style filter to safely apply conditions from the related model.
-      child_scope = apply(reflection.klass.all, has_cond[:condition])
-      joined.where(reflection.klass.table_name => { id: child_scope.select(:id) }).distinct
-    rescue StandardError
-      relation
-    end
-
-    def resolve_relation_name(relation, relation_name)
-      candidate_names = [relation_name.to_s, relation_name.to_s.singularize, relation_name.to_s.pluralize].uniq
-
-      candidate_names.each do |candidate|
-        next if candidate.blank?
-        return candidate if association_exists?(relation, candidate)
-      end
-
-      nil
-    rescue StandardError
-      nil
-    end
-
-    def association_exists?(relation, name)
-      reflection_for(relation, name).present?
-    rescue StandardError
-      false
-    end
-
-    def apply_has_argument(relation, arg_name, arg_value, relation_name = nil)
-      relation_name ||= derive_relation_name(arg_name)
-      return relation unless relation_name.present? && arg_value.present?
-
-      condition = arg_value.is_a?(Hash) ? arg_value : symbolized(arg_value)
-      has_payload = { relation: relation_name, condition: condition }
-      apply_has(relation, has_payload)
-    end
-
-    private
-
-    # The condition as a symbol-keyed Hash, or nil when there is none.
-    def normalize_condition(value)
-      return nil if value.nil?
-
-      condition = value.is_a?(Hash) ? value.deep_symbolize_keys : symbolized(value)
-      condition.transform_keys { |key| LOGICAL_KEYS.fetch(key, key) } if condition.is_a?(Hash)
-    end
-
-    def apply_all(relation, conditions)
-      Array(conditions).reduce(relation) { |acc, sub| apply(acc, sub) }
-    end
-
-    # The union of the branches, or nil when there are none.
-    def apply_any(relation, conditions)
-      Array(conditions).map { |sub| apply(relation, sub) }.reduce { |acc, sub_scope| acc.or(sub_scope) }
-    end
-
-    def apply_has_condition(relation, has_cond)
-      return relation unless has_cond.is_a?(Hash) && has_cond[:relation]
-
-      apply_has(relation, has_cond)
-    end
-
-    def reflection_for(relation, name)
-      klass = relation.respond_to?(:klass) ? relation.klass : relation
-      klass.reflect_on_association(name.to_sym) if klass.respond_to?(:reflect_on_association)
-    end
-
-    def derive_relation_name(arg_name)
-      Lighthouse::Support::Naming.derive_relation_name(arg_name)
-    end
-
-    def apply_single_condition(relation, condition)
-      return relation if condition[:column].blank? || !relation.respond_to?(:where)
-
-      column_name = resolve_column_name(condition[:column])
-      return relation if column_name.blank?
-
-      apply_operator(relation, column_name, operator_of(condition), condition[:value])
-    rescue StandardError
-      relation
-    end
-
-    def operator_of(condition)
-      condition[:operator]&.to_s&.upcase || 'EQ'
-    end
-
-    # Null and set operators are plain hash conditions; the rest need Arel.
-    def apply_operator(relation, column_name, operator, value)
-      case operator
-      when 'IS_NULL' then relation.where(column_name => nil)
-      when 'IS_NOT_NULL' then relation.where.not(column_name => nil)
-      when 'IN' then relation.where(column_name => Array(value))
-      when 'NIN' then relation.where.not(column_name => Array(value))
-      else apply_arel_operator(relation, column_name, operator, value)
-      end
-    end
-
-    # An unknown operator falls back to equality rather than failing the query.
-    def apply_arel_operator(relation, column_name, operator, value)
-      pattern = like_pattern(operator, value)
-      return relation.where(arel_table(relation)[column_name].matches(pattern)) if pattern
-
-      predicate = SUPPORTED_OPERATORS[operator]
-      return relation.where(column_name => value) unless predicate
-
-      relation.where(arel_table(relation)[column_name].public_send(predicate, value))
-    end
-
-    def like_pattern(operator, value)
-      case operator
-      when 'CONTAINS' then "%#{value}%"
-      when 'STARTS_WITH' then "#{value}%"
-      when 'ENDS_WITH' then "%#{value}"
-      end
-    end
-
-    def resolve_column_name(column)
-      Lighthouse::Support::Naming.column(column)
-    end
-
-    def arel_table(relation)
-      relation.klass.arel_table
-    end
-
-    def symbolized(obj)
-      if obj.respond_to?(:to_h)
-        obj.to_h.deep_symbolize_keys
-      else
-        {}
-      end
-    end
-  end
-end

data/lib/lighthouse/directives/where_conditions_directive.rb

@@ -1,244 +0,0 @@
-# frozen_string_literal: true
-
-require 'graphql'
-
-class Lighthouse::GraphQL::Directives::WhereConditionsDirective
-  SQLOPERATOR_TYPE_NAME = 'SQLOperator'
-  MIXED_SCALAR_NAME = 'Mixed'
-  PLACEHOLDER_SCALAR_NAME = '_'
-  DEFINITIONS = {
-    'whereConditions' =>
-      'directive @whereConditions(columns: [String!], columnsEnum: String) on ARGUMENT_DEFINITION',
-    'whereHasConditions' =>
-      'directive @whereHasConditions(relation: String, columns: [String!], columnsEnum: String) on ARGUMENT_DEFINITION'
-  }.freeze
-
-  # Default description of an undocumented argument, per directive.
-  ARGUMENT_DESCRIPTIONS = {
-    'whereConditions' => 'Filter results by field conditions.',
-    'whereHasConditions' => 'Filter results by related records conditions.'
-  }.freeze
-
-  # Types whose field arguments may carry the directives.
-  OBJECT_DEFINITIONS = [
-    ::GraphQL::Language::Nodes::ObjectTypeDefinition,
-    ::GraphQL::Language::Nodes::InterfaceTypeDefinition
-  ].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
-
-  # `definitions` maps every type name to its generated SDL. Names the schema
-  # already declares are seeded with nil, so they are never generated again
-  # and drop out of the output.
-  def self.manipulate(sdl)
-    return sdl unless sdl.is_a?(String) && !sdl.empty?
-
-    ast = parse(sdl)
-    return sdl unless ast
-
-    definitions = ast.definitions.filter_map { |defn| defn.respond_to?(:name) ? defn.name : nil }.index_with(nil)
-    each_where_argument(ast) do |type_def, field, arg, directive|
-      expand_argument(type_def, field, arg, directive, definitions)
-    end
-    define_utility_types(ast, definitions)
-
-    generated = definitions.values.compact
-    return sdl if generated.empty?
-
-    modified_sdl = ::GraphQL::Language::Printer.new.print(ast)
-    "#{modified_sdl}\n\n#{generated.join("\n\n")}"
-  end
-
-  def self.parse(sdl)
-    ::GraphQL::Language::Parser.parse(sdl)
-  rescue StandardError => e
-    warn("Lighthouse::GraphQL::Directives::WhereConditionsDirective: parse failed: #{e.class}: #{e.message}")
-    nil
-  end
-
-  # Yields every object/interface field argument carrying @whereConditions or
-  # @whereHasConditions, along with that directive.
-  def self.each_where_argument(ast)
-    each_field(ast) do |type_def, field|
-      (field.arguments || []).each do |arg|
-        directive = arg.directives&.find { |d| DEFINITIONS.key?(d.name) }
-        yield type_def, field, arg, directive if directive
-      end
-    end
-  end
-
-  def self.each_field(ast)
-    ast.definitions.each do |type_def|
-      next unless OBJECT_DEFINITIONS.any? { |kind| type_def.is_a?(kind) }
-
-      (type_def.fields || []).each { |field| yield type_def, field }
-    end
-  end
-
-  # Points the argument at its generated input type and defines the types it
-  # needs: the conditions input, its HAS relation input and the column enum.
-  def self.expand_argument(type_def, field, arg, directive, definitions)
-    describe_argument(arg, directive)
-
-    prefix = "#{camelize(type_def.name)}#{camelize(field.name)}#{camelize(arg.name)}"
-    input_type_name = "#{prefix}WhereConditions"
-    column_enum_name = "#{prefix}Column"
-    relation_input_name = "#{input_type_name}Relation"
-
-    apply_arg_type_replacement(arg, input_type_name)
-
-    # Build input type if needed.
-    define_once(definitions, input_type_name) do
-      build_where_condition_input(input_type_name, column_enum_name, relation_input_name, directive)
-    end
-
-    # Build relation type for HAS support in whereConditions
-    if directive.name == 'whereConditions'
-      define_once(definitions, relation_input_name) { build_where_condition_relation_input(relation_input_name, input_type_name) }
-    end
-
-    define_column_enum(definitions, column_enum_name, directive)
-  end
-
-  def self.describe_argument(arg, directive)
-    return if arg.description.present?
-
-    arg.instance_variable_set(:@description, ARGUMENT_DESCRIPTIONS.fetch(directive.name))
-  end
-
-  # Build column enum type unless columnsEnum is provided.
-  def self.define_column_enum(definitions, column_enum_name, directive)
-    return unless directive_argument_value(directive, 'columnsEnum').nil?
-
-    columns = directive_argument_value(directive, 'columns')
-    return if Array(columns).empty?
-
-    define_once(definitions, column_enum_name) { build_column_enum(column_enum_name, columns) }
-  end
-
-  def self.define_utility_types(ast, definitions)
-    # Append base utility types only once
-    define_once(definitions, SQLOPERATOR_TYPE_NAME) { build_sql_operator_enum }
-    define_once(definitions, MIXED_SCALAR_NAME) { "scalar #{MIXED_SCALAR_NAME}" }
-
-    # 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.
-    return unless contains_placeholder_type?(ast)
-
-    define_once(definitions, PLACEHOLDER_SCALAR_NAME) { "scalar #{PLACEHOLDER_SCALAR_NAME}" }
-  end
-
-  def self.define_once(definitions, name)
-    definitions[name] = yield unless definitions.key?(name)
-  end
-
-  def self.apply_arg_type_replacement(arg, input_type_name)
-    case arg.type
-    when ::GraphQL::Language::Nodes::TypeName
-      arg.instance_variable_set(:@type, ::GraphQL::Language::Nodes::TypeName.new(name: input_type_name)) if arg.type.name == '_'
-    when ::GraphQL::Language::Nodes::NonNullType
-      inner = arg.type.of_type
-      return unless inner.is_a?(::GraphQL::Language::Nodes::TypeName) && inner.name == '_'
-
-      new_type = ::GraphQL::Language::Nodes::NonNullType.new(of_type: ::GraphQL::Language::Nodes::TypeName.new(name: input_type_name))
-      arg.instance_variable_set(:@type, new_type)
-    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).filter_map do |column|
-      value = column.to_s
-      key = value.gsub(/[^0-9A-Za-z]/, '_').upcase
-      "  #{key}"
-    end.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
-
-    value = unwrap_value(arg.value)
-    name == 'columns' && value.is_a?(Array) ? value.map { |item| unwrap_value(item) } : value
-  end
-
-  # Supports both Babel-style AST and raw Ruby value.
-  def self.unwrap_value(node)
-    node.respond_to?(:value) ? node.value : node
-  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? { |field| placeholder_argument?(field) }
-    end
-  rescue StandardError
-    false
-  end
-
-  def self.placeholder_argument?(field)
-    arguments = (field.respond_to?(:arguments) && field.arguments) || []
-    arguments.any? { |arg| type_references_placeholder?(arg.type) }
-  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

data/lib/lighthouse/sdl_loader.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Lighthouse::GraphQL::SDLLoader
-  module_function
-
-  def load_from_folder(folder)
-    files = Dir[File.join(folder, '**', '*.graphql')]
-    if files.empty?
-      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