graph_weaver 0.5.0 → 0.6.0

data/lib/graph_weaver/schemas.rb

@@ -1,46 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "graphql"
-
-module GraphWeaver
-  # The graphql-ruby schema classes already in this process, and what each
-  # one defines. Where {SchemaLoader} *builds* a schema from a source — a
-  # path, SDL, an introspection dump — this reads classes the app loaded
-  # itself.
-  #
-  # Two features ask exactly these two questions, and match a schema on the
-  # coordinates it defines rather than on its class name: {Testing::Subgraphs}
-  # (which schema serves which subgraph) and {Federation::Drift} (has a
-  # subgraph changed without a recompose). They share the answers so the two
-  # can't drift apart.
-  module Schemas
-    class << self
-      # Every named GraphQL::Schema in the process. An anonymous one is
-      # graphql-ruby building from SDL — the router's own view of the
-      # supergraph is one — and never an app's subgraph.
-      def loaded
-        descendants(GraphQL::Schema).select(&:name)
-      end
-
-      # Does this schema carry the coordinate — "Type", or "Type.field"?
-      def defines?(schema, coordinate)
-        type_name, field_name = coordinate.split(".", 2)
-        type = schema.get_type(type_name) or return false
-        return true unless field_name
-
-        return type.fields.key?(field_name) if type.respond_to?(:fields)
-        # an input object's members are arguments, not fields
-        return type.arguments.key?(field_name) if type.respond_to?(:arguments)
-
-        false
-      end
-
-      private
-
-      def descendants(klass)
-        klass.subclasses.flat_map { |subclass| [subclass] + descendants(subclass) }
-      end
-    end
-  end
-end

data/lib/graph_weaver/selection.rb

@@ -1,120 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "graphql"
-
-module GraphWeaver
-  # Shared query-selection walking — the rules Codegen, FakeClient, and
-  # the cassette Anonymizer all follow, in one place so they can't drift:
-  # how fragments flatten into selections, and when a type condition
-  # applies. Hosts set @schema and call load_operation before walking.
-  module Selection
-    include Kernel # for sorbet: hosts are Objects
-
-    # Parse a query, stash its fragment definitions for the walk, and
-    # return the operation.
-    def load_operation(query)
-      doc = GraphQL.parse(query)
-      @fragments = doc.definitions
-        .grep(GraphQL::Language::Nodes::FragmentDefinition)
-        .to_h { |fragment| [fragment.name, fragment] }
-
-      operations = doc.definitions.grep(GraphQL::Language::Nodes::OperationDefinition)
-      # One file, one operation. Requests do carry operationName now, so a
-      # second operation would run fine on the wire — what has no answer is
-      # naming: a module is named after its FILE (person.graphql =>
-      # PersonQuery), and one file can't name two. A convention, not a limit.
-      if operations.size > 1
-        names = operations.map { |op| op.name ? "'#{op.name}'" : "an anonymous operation" }
-        raise GraphWeaver::Error,
-          "document defines #{operations.size} operations (#{names.join(", ")}) — " \
-          "split them into one file each, since a module is named after its file"
-      end
-
-      operations.first
-    end
-
-    # The schema type an operation's selections start from.
-    def operation_root_type(operation)
-      case operation&.operation_type
-      when "query", nil then @schema.query
-      when "mutation" then @schema.mutation
-      else raise GraphWeaver::Error, "unsupported operation: #{operation.operation_type}"
-      end
-    end
-
-    # Flatten a selection set as seen by `type`, yielding (result_key,
-    # field_node, conditional) per field: plain fields yield directly; inline
-    # fragments and named spreads recurse when their type condition applies.
-    # `conditional` is true when any fragment on the way down carried
-    # @skip/@include — the whole block may be absent from the response, so
-    # everything under it is as optional as a directly-skipped field.
-    def each_field(type, selections, visiting = Set.new, conditional: false, &block)
-      selections.each do |selection|
-        case selection
-        when GraphQL::Language::Nodes::Field
-          yield(selection.alias || selection.name, selection, conditional)
-        when GraphQL::Language::Nodes::InlineFragment
-          next unless applies?(selection.type&.name, type)
-
-          each_field(type, selection.selections, visiting,
-            conditional: conditional || conditional?(selection), &block)
-        when GraphQL::Language::Nodes::FragmentSpread
-          fragment = @fragments.fetch(selection.name) do
-            raise ArgumentError, "unknown fragment: #{selection.name}"
-          end
-          if visiting.include?(selection.name)
-            raise GraphWeaver::Error, "fragment cycle through #{selection.name}"
-          end
-
-          if applies?(fragment.type.name, type)
-            # the directive rides on the SPREAD, not the definition it names
-            each_field(type, fragment.selections, visiting | [selection.name],
-              conditional: conditional || conditional?(selection), &block)
-          end
-        else
-          raise GraphWeaver::Error, "unsupported selection: #{selection.class}"
-        end
-      end
-    end
-
-    # each_field grouped by result key: repeated selections of one field
-    # (`a { x } a { y }`, or the same field reached through two fragments)
-    # collect together, so callers MERGE their sub-selections rather than
-    # last-writer-wins. Codegen relies on this; FakeClient/Anonymizer must too,
-    # or they'd fabricate/keep a shape the generated struct can't cast.
-    def gather(type, selections)
-      gather_conditional(type, selections).transform_values { |occurrences| occurrences.map(&:first) }
-    end
-
-    # gather, keeping each occurrence's [field_node, conditional] — the wire
-    # key is guaranteed only when SOME occurrence is unconditional.
-    def gather_conditional(type, selections)
-      out = {}
-      each_field(type, selections) { |key, node, conditional| (out[key] ||= []) << [node, conditional] }
-      out
-    end
-
-    # Directives that can drop a selection from the response whatever the
-    # schema says — the reason a conditional field's generated type is nilable.
-    CONDITIONAL_DIRECTIVES = %w[skip include].freeze
-
-    # Is this AST node (field, inline fragment, or spread) behind @skip/@include?
-    def conditional?(node)
-      node.directives.any? { |directive| CONDITIONAL_DIRECTIVES.include?(directive.name) }
-    end
-
-    # A fragment's type condition applies when it names this type exactly,
-    # or an interface/union this type belongs to (`... on Named { ... }`).
-    def applies?(condition, type)
-      return true if condition.nil? || condition == type.graphql_name
-
-      condition_type = @schema.get_type(condition)
-      return false unless condition_type
-
-      kind = condition_type.kind.name
-      (kind == "INTERFACE" || kind == "UNION") &&
-        @schema.possible_types(condition_type).include?(type)
-    end
-  end
-end

data/lib/graph_weaver/testing/values.rb

@@ -1,98 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "date"
-
-# The value engine behind FakeClient and Cassette#anonymize!: seeded,
-# type-correct scalar generation with optional faker-backed semantics
-# matched on field names — strings (name/email/url/...) and numbers
-# (age/price/count/latitude/...) alike. Keeps a consistent id mapping so
-# the same original id always anonymizes to the same fake id.
-class GraphWeaver::Testing::Values
-  include GraphWeaver::Inflect
-
-  STRING_SEMANTICS = {
-    /email/ => -> { ::Faker::Internet.email },
-    /(^|_)first_name$/ => -> { ::Faker::Name.first_name },
-    /(^|_)last_name$/ => -> { ::Faker::Name.last_name },
-    /(^|_)(full_)?name$/ => -> { ::Faker::Name.name },
-    /(^|_)(url|website|link)$/ => -> { ::Faker::Internet.url },
-    /phone/ => -> { ::Faker::PhoneNumber.phone_number },
-    /(^|_)address$/ => -> { ::Faker::Address.full_address },
-    /(^|_)(city)$/ => -> { ::Faker::Address.city },
-    /(^|_)(title|description)$/ => -> { ::Faker::Lorem.sentence(word_count: 3) },
-  }.freeze
-
-  NUMBER_SEMANTICS = {
-    /(^|_)age$/ => ->(rng) { rng.rand(1..99) },
-    /(^|_)(price|amount|cost|total)(_cents)?$/ => ->(rng) { (rng.rand(1.0..10_000.0) * 100).round / 100.0 },
-    /(^|_)(count|quantity|size)$/ => ->(rng) { rng.rand(0..100) },
-    /latitude/ => ->(rng) { rng.rand(-90.0..90.0).round(6) },
-    /longitude/ => ->(rng) { rng.rand(-180.0..180.0).round(6) },
-    /(^|_)year$/ => ->(rng) { rng.rand(1970..2030) },
-  }.freeze
-
-  attr_reader :rng
-
-  def initialize(seed: nil, mode: nil)
-    config = GraphWeaver::Testing.config
-    @rng = Random.new(seed || config.seed || Random.new_seed)
-    @mode = resolve_mode(mode || config.mode)
-    @sequence = 0
-    @id_map = {}
-  end
-
-  def scalar(type_name, field_name)
-    prop = underscore(field_name)
-
-    if @mode == :faker
-      # rebind per call: several Values instances may interleave (e.g. two
-      # seeded fakes), and faker's rng is global
-      ::Faker::Config.random = @rng
-      case type_name
-      when "String"
-        STRING_SEMANTICS.each { |pattern, faker| return faker.call if pattern.match?(prop) }
-      when "Int", "Float"
-        NUMBER_SEMANTICS.each do |pattern, gen|
-          next unless pattern.match?(prop)
-
-          value = gen.call(@rng)
-          return type_name == "Int" ? value.to_i : value.to_f
-        end
-      end
-    end
-
-    case type_name
-    when "ID" then (@sequence += 1).to_s
-    when "String" then "#{field_name}-#{@sequence += 1}"
-    when "Int" then @rng.rand(0..1_000)
-    when "Float" then @rng.rand(0.0..1_000.0).round(2)
-    when "Boolean" then [true, false].sample(random: @rng)
-    when "Date" then (Date.new(2020, 1, 1) + @rng.rand(0..2_000)).iso8601
-    when "DateTime", "Time", "ISO8601DateTime" then Time.at(1_600_000_000 + @rng.rand(0..100_000_000)).utc.iso8601
-    else "#{type_name}-#{@sequence += 1}" # unknown custom scalar: override it
-    end
-  end
-
-  # same original id => same fake id, so relationships survive anonymization
-  def mapped_id(original)
-    @id_map[original] ||= (@sequence += 1).to_s
-  end
-
-  private
-
-  # :faker is an explicit ask — fail loudly when the gem is missing; auto
-  # (nil) quietly falls back to :literal
-  def resolve_mode(mode)
-    case mode
-    when :faker
-      raise ArgumentError, "mode: :faker requires the faker gem (add it to your Gemfile's test group)" unless defined?(::Faker)
-
-      :faker
-    when :literal then :literal
-    when nil then defined?(::Faker) ? :faker : :literal
-    else
-      raise ArgumentError, "mode: must be one of #{GraphWeaver::Testing::MODES.inspect} (or nil for auto), got #{mode.inspect}"
-    end
-  end
-end