lighthouse-graphql 0.5.0 → 0.7.0

data/lib/lighthouse/schema_generator.rb

@@ -47,7 +47,7 @@ module Lighthouse::GraphQL::SchemaGenerator
     impl = default_implementation
     # base_types' resolver / mutation / subscription are Lighthouse's, not graphql-ruby's.
     bases = Lighthouse::GraphQL::ResolverBases.extract!(opts)
-    schema = from_document(document, impl, opts)
+    schema = Lighthouse::GraphQL::RootTypes.build(document, bases[:roots]) { from_document(document, impl, opts) }
 
     delegate_to_federation_sdl(schema)
     Lighthouse::GraphQL::GeneratedResolvers.install_dispatcher(schema)
@@ -122,10 +122,11 @@ module Lighthouse::GraphQL::SchemaGenerator
   end
 
   # The SDL as the schema is built from it: directive definitions injected
-  # (so apps don't hand-declare Lighthouse's directives), then every
-  # registered manipulator run (pagination types, whereConditions inputs, ...).
+  # (so apps don't hand-declare Lighthouse's directives), then the
+  # manipulation phase (ASTBuilder: type extensions merged, pagination types,
+  # whereConditions / orderBy inputs, ...).
   def manipulate(sdl)
-    augment_sdl_with_connections(inject_directive_definitions(sdl))
+    Lighthouse::GraphQL::ASTBuilder.build(inject_directive_definitions(sdl))
   end
 
   # `bases`: { root kind => the base class its fields' classes inherit from } (ResolverBases).
@@ -140,8 +141,9 @@ module Lighthouse::GraphQL::SchemaGenerator
       # Apollo Federation helper can detect entities and add _entities.
       Lighthouse::GraphQL::FederationDirectives.apply(type)
       root_kind = root_kinds[type.graphql_name]
-      type_class = root_kind ? nil : Lighthouse::GraphQL::DirectiveResolvers::TypeMethodResolver.type_class(type.graphql_name, bases)
-      type.fields.each_value { |field_def| process_field(type, field_def, root_kind, bases, type_class) }
+      type_class = Lighthouse::GraphQL::DirectiveResolvers::TypeMethodResolver.type_class(type.graphql_name, bases, root_kind)
+      # A field a code-first base declares (RootTypes) resolves as graphql-ruby resolves it.
+      type.fields.each_value { |field_def| process_field(type, field_def, root_kind, bases, type_class) if field_def.owner == type }
     end
 
     # @complexity, and paginated fields, give graphql-ruby's complexity analysis their cost.
@@ -193,18 +195,6 @@ module Lighthouse::GraphQL::SchemaGenerator
     # ignore failures during post-processing
   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).

data/lib/lighthouse/schema_stitcher.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# Reads the schema from one entrypoint (Config.schema_path,
+# graphql/schema.graphql by default) and pastes in the files it imports, as PHP
+# Lighthouse's SchemaStitcher does:
+#
+#   type Query
+#
+#   #import user.graphql
+#   #import blog/*.graphql
+#
+# An import names a path relative to the file it is in, and may be a glob.
+# Imported files are read the same way, so they can import others. A file is
+# read once: importing it again, or importing a file that imports it back,
+# adds nothing. Only the files reached from the entrypoint are in the schema.
+class Lighthouse::GraphQL::SchemaStitcher
+  IMPORT = '#import '
+
+  attr_reader :root_schema_path
+
+  def initialize(root_schema_path)
+    path = File.expand_path(root_schema_path.to_s)
+    unless File.file?(path)
+      raise Lighthouse::DefinitionError,
+            "Failed to find a GraphQL schema file at #{path}. Set config.schema_path, or run bin/rails generate lighthouse:install."
+    end
+
+    @root_schema_path = File.realpath(path)
+  end
+
+  # The stitched schema: the entrypoint with every import replaced by the file's content.
+  def schema_string
+    gather(@root_schema_path, Set.new)
+  end
+
+  # Every file the schema is read from, the entrypoint first.
+  def files
+    visited = Set.new
+    gather(@root_schema_path, visited)
+    visited.to_a
+  end
+
+  private
+
+  def gather(path, visited)
+    return '' unless visited.add?(path)
+
+    File.readlines(path, chomp: true).map { |line| import_line?(line) ? import(path, line, visited) : "#{line}\n" }.join
+  end
+
+  def import_line?(line)
+    line.strip.start_with?(IMPORT)
+  end
+
+  def import(path, line, visited)
+    name = line.strip.delete_prefix(IMPORT).strip
+    import_path = File.join(File.dirname(path), name)
+    return Dir.glob(import_path).map { |file| gather(File.realpath(file), visited) }.join if name.include?('*')
+
+    raise Lighthouse::DefinitionError, "Did not find GraphQL schema import at #{import_path}." unless File.file?(import_path)
+
+    gather(File.realpath(import_path), visited)
+  end
+end

data/lib/lighthouse/support/naming.rb

@@ -52,16 +52,4 @@ module Lighthouse::Support::Naming
     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

data/lib/lighthouse/upload.rb

@@ -13,11 +13,13 @@ class Lighthouse::GraphQL::Upload < GraphQL::Schema::Scalar
   def self.coerce_input(value, _context)
     return value if file?(value)
 
-    raise ::GraphQL::CoercionError, 'Could not get uploaded file, be sure to conform to the GraphQL multipart request specification.'
+    raise ::GraphQL::CoercionError,
+          'Could not get uploaded file, be sure to conform to GraphQL multipart request specification: ' \
+          "https://github.com/jaydenseric/graphql-multipart-request-spec. Instead got: #{value.inspect}."
   end
 
   def self.coerce_result(_value, _context)
-    raise ::GraphQL::Error, 'The Upload scalar can only be used as an argument, not returned.'
+    raise ::GraphQL::Error, '"Upload" cannot be serialized, it can only be used as an argument.'
   end
 
   def self.file?(value)

data/lib/lighthouse/upload_store.rb

@@ -1,32 +1,57 @@
 # frozen_string_literal: true
 
-require 'securerandom'
-
-# Where @upload puts a file, by default: an ActiveStorage blob, on the service
-# `disk` names (the default service without it), its key under `path`. The
-# argument then holds the blob's signed id, which a has_one_attached /
-# has_many_attached attribute attaches, and which ActiveStorage::Blob.find_signed
-# finds. Config.upload_store takes another `call(file, disk:, path:, public:)`.
+# Where @upload puts a file, as PHP Lighthouse's @upload puts it on one of the
+# app's Laravel disks: an ActiveStorage blob on one of the app's services
+# (config/storage.yml). `disk` names the service (config.active_storage.service
+# without it), `path` prefixes the blob's key. ActiveStorage sets visibility per
+# service (`public: true` in storage.yml), not per file, so `public` must agree
+# with the service's: the schema never says a file is private that anyone can
+# read, or public that no one can. The argument then holds the blob's signed id,
+# which a has_one_attached / has_many_attached attribute attaches (where Laravel
+# hands the stored path, for a model to keep). To store files elsewhere, declare
+# an ActiveStorage service for it, as a Laravel app declares a disk.
 module Lighthouse::GraphQL::UploadStore
   module_function
 
-  def call(file, disk: nil, path: nil, public: false) # rubocop:disable Lint/UnusedMethodArgument -- public is the service's setting
+  def call(file, argument:, disk: nil, path: nil, public: nil)
     unless defined?(::ActiveStorage::Blob)
-      raise Lighthouse::DefinitionError,
-            '@upload stores files with ActiveStorage: install it (bin/rails active_storage:install), or set Config.upload_store.'
+      raise Lighthouse::DefinitionError, '@upload stores files with ActiveStorage: install it (bin/rails active_storage:install).'
+    end
+    unless Lighthouse::GraphQL::Upload.file?(file)
+      raise Lighthouse::DefinitionError, "Expected argument `#{argument}` to be an uploaded file (Upload)."
     end
 
-    attributes = { io: file, filename: filename(file), content_type: file.try(:content_type), key: key(path) }
-    attributes[:service_name] = disk if disk
-    ::ActiveStorage::Blob.create_and_upload!(**attributes.compact).signed_id
+    service = service(argument, disk, public == true)
+    file.rewind if file.respond_to?(:rewind) # a @validator, or another argument the multipart map sent it to, may have read it
+    ::ActiveStorage::Blob.create_and_upload!(
+      io: file, filename: filename(file), content_type: file.try(:content_type), key: key(path), service_name: service.name
+    ).signed_id
+  end
+
+  # The service `disk` names, or the default one, checked to be as public as asked.
+  def service(argument, disk, public)
+    service = disk ? ::ActiveStorage::Blob.services.fetch(disk) : ::ActiveStorage::Blob.service
+    return service if (service.public? == true) == public
+
+    raise Lighthouse::DefinitionError, visibility_mismatch(argument, service.name, public)
+  rescue KeyError => e
+    raise Lighthouse::DefinitionError, "@upload on `#{argument}`: #{e.message}"
+  end
+
+  def visibility_mismatch(argument, service_name, public)
+    fix = public ? 'name a public one (public: true in config/storage.yml) with disk:' : 'pass public: true, or name a private one with disk:'
+    "@upload#{'(public: true)' if public} on `#{argument}` stores on the ActiveStorage service `#{service_name}`, " \
+      "which is #{'not ' if public}public: #{fix}."
   end
 
   def filename(file)
     file.respond_to?(:original_filename) ? file.original_filename : File.basename(file.path)
   end
 
+  # `path`'s directory, then a fresh token, as Laravel's `storeAs(path, hashName)`;
+  # under the root ("/", the default), ActiveStorage's own key.
   def key(path)
     prefix = path.to_s.delete_prefix('/').delete_suffix('/')
-    prefix.empty? ? nil : "#{prefix}/#{SecureRandom.base36(28)}"
+    prefix.empty? ? nil : "#{prefix}/#{::ActiveStorage::Blob.generate_unique_secure_token}"
   end
 end

data/lib/lighthouse/where_conditions/columns.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# The column a client names in @whereConditions or @orderBy, as an Arel node.
+# Enum values (`CREATED_AT`, or the column an @enum(value:) gives) map onto
+# columns as everywhere (Support::Naming). A column of an unrestricted input
+# (`column: String`) comes from the client as is, so it must be an identifier,
+# `table.column`, or either with a path into a JSON document (`meta->tags`,
+# JsonColumn), as PHP Lighthouse checks it.
+module Lighthouse::WhereConditions::Columns
+  IDENTIFIER = /\A[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?\z/
+
+  module_function
+
+  # The column on `klass`'s table, or `table.column`. A JSON path's value is
+  # compiled `as` JsonColumn.node says: :sort to order by, :text, :numeric or
+  # :boolean to compare with.
+  def attribute(klass, column, as: :sort)
+    json = Lighthouse::WhereConditions::JsonColumn
+    if json.json?(column)
+      raise ::GraphQL::ExecutionError, invalid_column_name(column) unless json.valid?(column)
+
+      return json.node(klass, column, as: as)
+    end
+
+    name = Lighthouse::Support::Naming.column(column)
+    raise ::GraphQL::ExecutionError, invalid_column_name(column) unless IDENTIFIER.match?(name)
+
+    table, name = name.split('.', 2) if name.include?('.')
+    table ? ::Arel::Table.new(table)[name] : klass.arel_table[name]
+  end
+
+  def invalid_column_name(column)
+    'Column names may contain only alphanumerics or underscores, optionally a table and a JSON path ' \
+      "(posts.meta->tags), and may not begin with a digit, got: #{column}"
+  end
+end

data/lib/lighthouse/where_conditions/handler.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+# Applies a @whereConditions value to a relation, as PHP Lighthouse's
+# WhereConditionsHandler: the conditions of one level all hold, an AND list is
+# a nested group whose conditions all hold, an OR list one where at least one
+# does, and HAS checks how many related records match a condition.
+#
+#   { column: AGE, operator: GT, value: 37, OR: [{ column: TYPE, value: "Actor" }, ...] }
+#   -> age > 37 AND (type = 'Actor' OR ...)
+#
+#   { HAS: { relation: "posts", amount: 3, condition: { column: "published", value: true } } }
+#   -> users with at least 3 published posts
+#
+# A column the client names (an unrestricted WhereConditions takes any) must
+# be an identifier, `table.column` at most (Columns). The columns of a HAS
+# condition are those of the related model's table.
+#
+# A custom handler (`@whereConditions(handler: "...")`) is any object or
+# class answering `call(relation, conditions)` with the relation.
+module Lighthouse::WhereConditions::Handler
+  Types = Lighthouse::WhereConditions::Types
+
+  # How a HAS operator compares the number of related records with `amount`.
+  COUNT_COMPARISONS = { 'EQ' => :eq, 'NEQ' => :not_eq, 'GT' => :gt, 'GTE' => :gteq, 'LT' => :lt, 'LTE' => :lteq }.freeze
+  RUBY_COMPARISONS = { 'EQ' => :==, 'NEQ' => :!=, 'GT' => :>, 'GTE' => :>=, 'LT' => :<, 'LTE' => :<= }.freeze
+
+  # The Arel predicate of each operator that takes a value: [method, how the value is passed].
+  PREDICATES = {
+    'LIKE' => [:matches, :pattern], 'NOT_LIKE' => [:does_not_match, :pattern],
+    'IN' => [:in, :list], 'NOT_IN' => [:not_in, :list],
+    'BETWEEN' => [:between, :range], 'NOT_BETWEEN' => [:not_between, :range]
+  }.merge(COUNT_COMPARISONS.transform_values { |method| [method, :value] }).freeze
+
+  module_function
+
+  def call(relation, conditions)
+    predicate = predicate(relation.klass, normalize(conditions))
+    predicate ? relation.where(predicate) : relation
+  end
+
+  # The conditions as a Hash of :column, :operator, :value, :and, :or, :has
+  # (and :relation, :amount, :condition in a HAS), leaving the value as given.
+  def normalize(conditions)
+    return nil if conditions.nil?
+
+    hash = conditions.respond_to?(:to_h) ? conditions.to_h : conditions
+    hash.each_with_object({}) do |(key, value), normalized|
+      key = key.to_s.underscore.to_sym
+      normalized[key] =
+        case key
+        when :and, :or then Array(value).map { |condition| normalize(condition) }
+        when :has, :condition then normalize(value)
+        else value
+        end
+    end
+  end
+
+  # The Arel predicate of one level of conditions, or nil when it has none.
+  def predicate(klass, conditions)
+    return nil if conditions.blank?
+
+    nodes = [
+      group(klass, conditions[:and], :and),
+      group(klass, conditions[:or], :or),
+      conditions[:has] && has(klass, conditions[:has]),
+      conditions[:column] && column_condition(klass, conditions)
+    ].compact
+    nodes.empty? ? nil : nodes.reduce { |left, right| left.and(right) }
+  end
+
+  def group(klass, conditions, boolean)
+    nodes = Array(conditions).filter_map { |condition| predicate(klass, condition) }
+    return nil if nodes.empty?
+
+    boolean == :and ? ::Arel::Nodes::Grouping.new(::Arel::Nodes::And.new(nodes)) : nodes.reduce { |left, right| left.or(right) }
+  end
+
+  def column_condition(klass, conditions)
+    operator = (conditions[:operator] || Types::DEFAULT_OPERATOR).to_s.upcase
+    compared_as = Lighthouse::WhereConditions::JsonColumn.compared_as(operator, conditions[:value])
+    attribute = Lighthouse::WhereConditions::Columns.attribute(klass, conditions[:column], as: compared_as)
+    return attribute.eq(nil) if operator == 'IS_NULL'
+    return attribute.not_eq(nil) if operator == 'IS_NOT_NULL'
+
+    unless conditions.key?(:value)
+      raise ::GraphQL::ExecutionError, "Did not receive a value to match the WhereConditions for column #{conditions[:column]}."
+    end
+
+    compare(attribute, operator, conditions[:value])
+  end
+
+  def compare(attribute, operator, value)
+    method, kind = PREDICATES[operator]
+    raise ::GraphQL::ExecutionError, "Unknown SQLOperator #{operator}." unless method
+
+    case kind
+    when :pattern then attribute.public_send(method, value, nil, true) # LIKE, case-sensitive as SQL's
+    when :list then attribute.public_send(method, Array(value))
+    when :range then attribute.public_send(method, range(value))
+    else attribute.public_send(method, value)
+    end
+  end
+
+  def range(value)
+    values = Array(value)
+    raise ::GraphQL::ExecutionError, 'BETWEEN needs a value of two elements: [from, to].' unless values.size == 2
+
+    values.first..values.last
+  end
+
+  # Records of `klass` with `amount` (compared by `operator`) related records
+  # matching the condition: an IN over the records that have them, and, when
+  # having none satisfies the comparison, the records that have none too.
+  def has(klass, has)
+    reflection = reflection(klass, has[:relation])
+    operator = (has[:operator] || Types::DEFAULT_HAS_OPERATOR).to_s.upcase
+    amount = (has[:amount] || Types::DEFAULT_HAS_AMOUNT).to_i
+    raise ::GraphQL::ExecutionError, "HAS can not compare the amount with #{operator}." unless COUNT_COMPARISONS.key?(operator)
+
+    key = klass.arel_table[klass.primary_key]
+    related = related_scope(klass, reflection, has[:condition])
+    predicate = key.in(owners(related, key, reflection.klass, operator, amount).arel)
+    0.public_send(RUBY_COMPARISONS.fetch(operator), amount) ? predicate.or(key.not_in(related.select(key).arel)) : predicate
+  end
+
+  # `klass` joined to its related records that match the condition.
+  def related_scope(klass, reflection, condition)
+    scope = klass.unscoped.joins(reflection.name)
+    predicate = predicate(reflection.klass, condition)
+    predicate ? scope.where(predicate) : scope
+  end
+
+  # The keys of the records with `amount` related records, by `operator`. At
+  # least one is any join; another amount needs them counted.
+  def owners(related_scope, key, related, operator, amount)
+    return related_scope.select(key) if (operator == 'GTE' && amount == 1) || (operator == 'GT' && amount.zero?)
+
+    counted = related.primary_key ? related.arel_table[related.primary_key] : ::Arel.star
+    count = ::Arel::Nodes::Count.new([counted], true)
+    related_scope.group(key).having(count.public_send(COUNT_COMPARISONS.fetch(operator), amount)).select(key)
+  end
+
+  # The association `name` names on `klass`: as written, snake_cased, singular or plural.
+  def reflection(klass, name)
+    candidates = [name.to_s, name.to_s.underscore, name.to_s.underscore.singularize, name.to_s.underscore.pluralize].uniq
+    reflection = candidates.lazy.filter_map { |candidate| klass.reflect_on_association(candidate.to_sym) }.first
+    raise ::GraphQL::ExecutionError, "#{klass.name} has no relation #{name}." unless reflection
+    raise ::GraphQL::ExecutionError, "HAS can not check the polymorphic relation #{name}." if reflection.polymorphic?
+
+    reflection
+  end
+end

data/lib/lighthouse/where_conditions/json_column.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# A column with a path into its JSON document, as Laravel names one and PHP
+# Lighthouse's @whereConditions and @orderBy take it: `meta->tags`,
+# `posts.meta->author->name`, `meta->tags->0` (an array index). The value at
+# the path is compiled for the database, as Laravel's query grammars do:
+#
+#   PostgreSQL  "posts"."meta"->'author'->>'name'
+#   MySQL       JSON_UNQUOTE(JSON_EXTRACT(`posts`.`meta`, '$."author"."name"'))
+#   SQLite      json_extract("posts"."meta", '$."author"."name"')
+#
+# Unlike Laravel, it compares numbers and booleans as such, and orders by the
+# JSON value (numbers numerically), on every database. The result is an Arel
+# node: a condition calls its predicates (`eq`, `in`, `matches`, ...) and an
+# order its `asc` / `desc`.
+module Lighthouse::WhereConditions::JsonColumn
+  PATH = /\A(?:(?<table>[A-Za-z_]\w*)\.)?(?<column>[A-Za-z_]\w*)(?<path>(?:->[A-Za-z0-9_-]+)+)\z/
+
+  module_function
+
+  def json?(name)
+    name.to_s.include?('->')
+  end
+
+  def valid?(name)
+    PATH.match?(name.to_s)
+  end
+
+  # The value at the path, as `as` says: :text, :numeric, :boolean, :null (NULL
+  # when the path is missing or holds JSON null), or :sort (the JSON value,
+  # ordered by type, numbers numerically).
+  def node(klass, name, as: :text)
+    match = PATH.match(name.to_s) or raise ArgumentError, "not a JSON column: #{name}"
+    connection = klass.connection
+    target = [match[:table] || klass.table_name, match[:column]].then do |table, column|
+      "#{connection.quote_table_name(table)}.#{connection.quote_column_name(column)}"
+    end
+    segments = match[:path].split('->').drop(1)
+
+    ::Arel.sql(public_send(dialect(connection), target, segments, as))
+  end
+
+  # How a condition with `operator` compares the value at the path: patterns as
+  # text, nulls as JSON null too, the rest as the value is.
+  def compared_as(operator, value)
+    case operator
+    when 'LIKE', 'NOT_LIKE' then :text
+    when 'IS_NULL', 'IS_NOT_NULL' then :null
+    else kind_of_value(value)
+    end
+  end
+
+  # What a value compares as: numbers as numbers, booleans as booleans, the rest as text.
+  def kind_of_value(value)
+    sample = value.is_a?(Array) ? value.first : value
+    case sample
+    when Numeric then :numeric
+    when true, false then :boolean
+    else :text
+    end
+  end
+
+  def dialect(connection)
+    case connection.adapter_name
+    when /postg/i then :postgresql
+    when /mysql|trilogy/i then :mysql
+    else :sqlite
+    end
+  end
+
+  def postgresql(target, segments, as)
+    keys = segments.map { |segment| segment.match?(/\A\d+\z/) ? segment : "'#{segment}'" }
+    return "(#{target}->#{keys.join('->')})::jsonb" if as == :sort
+
+    text = keys.size == 1 ? "#{target}->>#{keys.first}" : "#{target}->#{keys[0...-1].join('->')}->>#{keys.last}"
+    { numeric: "(#{text})::numeric", boolean: "(#{text})::boolean" }.fetch(as, text) # :text, :null
+  end
+
+  def mysql(target, segments, as)
+    extract = "JSON_EXTRACT(#{target}, '#{json_path(segments)}')"
+    case as
+    when :text then "JSON_UNQUOTE(#{extract})"
+    when :numeric then "CAST(JSON_UNQUOTE(#{extract}) AS DECIMAL(65, 10))"
+    when :boolean then "(#{extract} = CAST('true' AS JSON))"
+    when :null then "NULLIF(JSON_TYPE(#{extract}), 'NULL')"
+    else extract
+    end
+  end
+
+  # json_extract answers SQLite's own types: numbers compare and order as numbers,
+  # booleans are 1 and 0.
+  def sqlite(target, segments, _as)
+    "json_extract(#{target}, '#{json_path(segments)}')"
+  end
+
+  def json_path(segments)
+    "$#{segments.map { |segment| segment.match?(/\A\d+\z/) ? "[#{segment}]" : %(."#{segment}") }.join}"
+  end
+end

data/lib/lighthouse/where_conditions/operator_map.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
-# 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.
+# Maps the operators @where(operator:) takes to Arel predicate methods.
 module Lighthouse::WhereConditions::OperatorMap
   OPERATORS = {
     'EQ' => :eq,

data/lib/lighthouse/where_conditions/types.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+# The types @whereConditions and @whereHasConditions generate, as PHP
+# Lighthouse's WhereConditionsServiceProvider defines them. For an argument
+# whose input is named N:
+#
+#   N               column, operator, value, AND, OR, HAS: the conditions
+#   NRelation       HAS: a relation, how many of its records (operator, amount), and a condition on them
+#   NHasCondition   the condition on the related records: as N, but on any column
+#
+# Without `columns:` / `columnsEnum:` the argument shares the unrestricted
+# WhereConditions (and its WhereConditionsRelation / WhereConditionsHasCondition).
+module Lighthouse::WhereConditions::Types
+  DEFAULT = 'WhereConditions'
+  SQL_OPERATOR = 'SQLOperator'
+  MIXED = 'Mixed'
+
+  # The SQLOperator enum: what a condition compares the column with.
+  OPERATORS = {
+    'EQ' => 'Equal operator (`=`)',
+    'NEQ' => 'Not equal operator (`!=`)',
+    'GT' => 'Greater than operator (`>`)',
+    'GTE' => 'Greater than or equal operator (`>=`)',
+    'LT' => 'Less than operator (`<`)',
+    'LTE' => 'Less than or equal operator (`<=`)',
+    'LIKE' => 'Simple pattern matching (`LIKE`)',
+    'NOT_LIKE' => 'Negation of simple pattern matching (`NOT LIKE`)',
+    'IN' => 'Whether a value is within a set of values (`IN`)',
+    'NOT_IN' => 'Whether a value is not within a set of values (`NOT IN`)',
+    'BETWEEN' => 'Whether a value is within a range of values (`BETWEEN`)',
+    'NOT_BETWEEN' => 'Whether a value is not within a range of values (`NOT BETWEEN`)',
+    'IS_NULL' => 'Whether a value is null (`IS NULL`)',
+    'IS_NOT_NULL' => 'Whether a value is not null (`IS NOT NULL`)'
+  }.freeze
+
+  DEFAULT_OPERATOR = 'EQ'
+  DEFAULT_HAS_OPERATOR = 'GTE'
+  DEFAULT_HAS_AMOUNT = 1
+
+  module_function
+
+  # Defines N, NHasCondition and NRelation, and the SQLOperator and Mixed they use.
+  def define(document_ast, name, column_type, path)
+    document_ast.define_type(SQL_OPERATOR) { sql_operator }
+    document_ast.define_type(MIXED, 'scalar Mixed')
+    document_ast.define_type(name) { conditions(name, "Dynamic WHERE conditions for #{path}.", column_type) }
+    document_ast.define_type("#{name}HasCondition") do
+      conditions("#{name}HasCondition", "Dynamic WHERE HAS conditions for #{path}.", 'String')
+    end
+    document_ast.define_type("#{name}Relation") { relation(name, "Dynamic HAS conditions for WHERE conditions for #{path}.") }
+  end
+
+  def define_default(document_ast)
+    define(document_ast, DEFAULT, 'String', 'any column')
+  end
+
+  def conditions(name, description, column_type)
+    <<~GRAPHQL
+      "#{description}"
+      input #{name} {
+        "The column that is used for the condition."
+        column: #{column_type}
+
+        "The operator that is used for the condition."
+        operator: #{SQL_OPERATOR} = #{DEFAULT_OPERATOR}
+
+        "The value that is used for the condition."
+        value: #{MIXED}
+
+        "A set of conditions that requires all conditions to match."
+        AND: [#{name}!]
+
+        "A set of conditions that requires at least one condition to match."
+        OR: [#{name}!]
+
+        "Check whether a relation exists. Extra conditions or a minimum amount can be applied."
+        HAS: #{name.delete_suffix('HasCondition')}Relation
+      }
+    GRAPHQL
+  end
+
+  def relation(name, description)
+    <<~GRAPHQL
+      "#{description}"
+      input #{name}Relation {
+        "The relation that is checked."
+        relation: String!
+
+        "The comparison operator to test against the amount."
+        operator: #{SQL_OPERATOR} = #{DEFAULT_HAS_OPERATOR}
+
+        "The amount to test."
+        amount: Int = #{DEFAULT_HAS_AMOUNT}
+
+        "Additional condition logic."
+        condition: #{name}HasCondition
+      }
+    GRAPHQL
+  end
+
+  def sql_operator
+    values = OPERATORS.map { |value, description| %(  "#{description}"\n  #{value}) }
+    <<~GRAPHQL
+      "The available SQL operators that are used to filter query results."
+      enum #{SQL_OPERATOR} {
+      #{values.join("\n\n")}
+      }
+    GRAPHQL
+  end
+end