graph_weaver 0.1.0 → 0.2.1

data/lib/graph_weaver/errors.rb

@@ -1,16 +1,27 @@
 # typed: true
 # frozen_string_literal: true
 
-require "set"
 require "sorbet-runtime"
 require_relative "inflect"
+require_relative "logging"
 
 module GraphWeaver
   # Base for every error GraphWeaver raises — rescue this to catch them
   # all. #message is the human-friendly side; #to_h is the machine side —
   # a JSON-ready Hash (string keys) for logging, agents, or surfacing
-  # structured failures to users. Subclasses merge in their specifics.
+  # structured failures to users. One subclass per failure site —
+  # {TransportError} (never reached the server), {ServerError} (non-2xx),
+  # {QueryError} (GraphQL-level errors), {TypeError} (response wouldn't
+  # cast), {ValidationError} (build time) — each merging its specifics
+  # into #to_h.
   class Error < StandardError
+    # every GraphWeaver error surfaces on the logger too (see
+    # GraphWeaver.logger) — construction here means a raise
+    def initialize(*args)
+      super
+      GraphWeaver.log(:warn) { "#{self.class.name}: #{message}" }
+    end
+
     def to_h
       { "error" => self.class.name, "message" => message }
     end
@@ -26,14 +37,14 @@ module GraphWeaver
   end
 
   class << self
-    # The exception classes the bundled executors reclassify as
+    # The exception classes the bundled transports reclassify as
     # TransportError — network-level failures where the request never
     # reached the server. A mutable Set: each transport contributes its own
     # on load (net/http adds Timeout/SSL, Faraday adds its ConnectionFailed,
     # …), and you can add more so they get the same handling:
     #
-    #   GraphWeaver.transport_errors << MyPool::TimeoutError
-    #   GraphWeaver.register_transport_error(Adapter::ResetError)
+    #      GraphWeaver.transport_errors << MyPool::TimeoutError
+    #      GraphWeaver.register_transport_error(Adapter::ResetError)
     #
     # SystemCallError covers every Errno::* (connection refused/reset, host
     # unreachable); SocketError covers DNS.
@@ -72,11 +83,12 @@ module GraphWeaver
   class GraphQLError
     attr_reader :message, :locations, :path, :extensions
 
-    def initialize(message:, locations: [], path: nil, extensions: {})
+    def initialize(message:, locations: [], path: nil, extensions: {}, type: nil)
       @message = message
       @locations = locations
       @path = path
       @extensions = extensions
+      @error_type = type
     end
 
     def self.from_h(hash)
@@ -85,13 +97,16 @@ module GraphWeaver
         locations: hash["locations"] || [],
         path: hash["path"],
         extensions: hash["extensions"] || {},
+        type: hash["type"],
       )
     end
 
     # The machine-readable error code, e.g. "THROTTLED" — the thing to
-    # branch on. nil when the server didn't set extensions.code.
+    # branch on. Read from extensions.code (the Apollo/spec-adjacent
+    # convention) or a top-level "type" (GitHub's dialect: NOT_FOUND,
+    # FORBIDDEN). nil when the server sent neither.
     def code
-      extensions["code"]
+      extensions["code"] || @error_type
     end
 
     # Message shapes servers use when they reject the *shape* of a query
@@ -166,8 +181,8 @@ module GraphWeaver
 
     # True when any error looks like the server rejected the query's
     # shape — the schema has likely changed since the module was
-    # generated. Regenerate (bin/generate) and/or refresh the schema
-    # cache (delete the cache: file, or wait out its ttl).
+    # generated. Refresh the schema dump and regenerate (rake
+    # graph_weaver:schema:refresh && rake graph_weaver:generate).
     def schema_stale?
       errors.any?(&:validation?)
     end
@@ -175,9 +190,9 @@ module GraphWeaver
     # Errors grouped by the field they point at (index-stripped dotted
     # path; nil key for global errors) — iterate with each_error:
     #
-    #   response.each_error do |field, errors|
-    #     form.add_error(field, errors.map(&:message))
-    #   end
+    #      response.each_error do |field, errors|
+    #        form.add_error(field, errors.map(&:message))
+    #      end
     def errors_by_field
       errors.group_by(&:field)
     end
@@ -213,8 +228,8 @@ module GraphWeaver
     # actual records that failed inlined — "the 3 in people.3.email is
     # useless to a user; people.email plus which people is the answer".
     #
-    #   { "people.email" => { "messages" => [...], "codes" => [...],
-    #     "entity_ids" => ["7", "9"], "errors" => [full to_h...] } }
+    #      { "people.email" => { "messages" => [...], "codes" => [...],
+    #        "entity_ids" => ["7", "9"], "errors" => [full to_h...] } }
     def report
       errors_by_field.to_h do |field, field_errors|
         [field, {
@@ -264,7 +279,7 @@ module GraphWeaver
     def summary
       first = errors.first
       more = errors.size > 1 ? " (and #{errors.size - 1} more)" : ""
-      drift = schema_stale? ? " — the server rejected the query shape: the schema may have changed since generation; regenerate modules (bin/generate) and/or refresh the schema cache" : ""
+      drift = schema_stale? ? " — the server rejected the query shape: the schema may have changed since generation; refresh the schema dump and regenerate (rake graph_weaver:schema:refresh && rake graph_weaver:generate)" : ""
       "GraphQL query failed: #{first}#{more}#{drift}"
     end
   end
@@ -288,10 +303,11 @@ module GraphWeaver
     end
   end
 
-  # Build-time: the query didn't validate against the schema. Kept an
-  # ArgumentError for source compatibility, but carries the structured
-  # validation errors (message + line/column) rather than a joined string.
-  class ValidationError < ArgumentError
+  # Build-time: the query didn't validate against the schema. Carries the
+  # structured validation errors (message + line/column) rather than a
+  # joined string. Under the Error umbrella like everything else raised
+  # here (through 0.1.0 it was an ArgumentError instead).
+  class ValidationError < Error
     attr_reader :errors
 
     def initialize(errors)
@@ -300,11 +316,7 @@ module GraphWeaver
     end
 
     def to_h
-      {
-        "error" => self.class.name,
-        "message" => message,
-        "errors" => errors.map { |e| e.transform_keys(&:to_s) },
-      }
+      super.merge("errors" => errors.map { |e| e.transform_keys(&:to_s) })
     end
   end
 end

data/lib/graph_weaver/hints.rb

@@ -0,0 +1,63 @@
+# typed: true
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+require_relative "inflect"
+
+module GraphWeaver
+  # Included in generated response structs. GraphQL's camelCase fields
+  # become snake_case props, and reaching for the wire name is a classic
+  # stumble — result.nameWithOwner instead of result.name_with_owner.
+  # Catch the miss and point at the prop that does exist ("use ..." when
+  # the mapping is exact, "did you mean ...?" for a near-miss typo).
+  # (Typed call sites get this hint earlier, from srb tc.)
+  module Hints
+    include Kernel # for sorbet: hosts are Objects
+
+    # Guard for generated input-struct .coerce: a hash key that matches
+    # no prop raises (spellchecked) instead of silently dropping — a
+    # typo'd filter key must not become "match everything" on the wire.
+    def self.validate_keys!(struct, hash)
+      known = struct.props.keys.map(&:to_s)
+      unknown = hash.keys.map(&:to_s) - known
+      return if unknown.empty?
+
+      hints = unknown.map do |key|
+        prop = GraphWeaver::Inflect.underscore(key)
+        suggestion = if known.include?(prop)
+          prop # a wire-cased key — the exact snake_case prop exists
+        elsif defined?(DidYouMean::SpellChecker)
+          DidYouMean::SpellChecker.new(dictionary: known).correct(prop).first
+        end
+        suggestion ? "#{key} (did you mean '#{suggestion}'?)" : key
+      end
+      raise ArgumentError, "unknown key(s) for #{struct}: #{hints.join(", ")}"
+    end
+
+    def method_missing(name, *args, &block)
+      if args.empty? && (hint = prop_hint(name.to_s))
+        raise NoMethodError, "undefined method '#{name}' for #{self.class} — #{hint}"
+      end
+
+      super
+    end
+
+    private
+
+    def prop_hint(name)
+      prop = GraphWeaver::Inflect.underscore(name)
+      if prop != name && respond_to?(prop)
+        return "GraphQL fields generate snake_case props; use '#{prop}'"
+      end
+
+      return unless defined?(DidYouMean::SpellChecker)
+
+      # a guess, not a mapping — spellcheck the (underscored) miss
+      # against the props that exist, so typos in either casing land
+      props = T.unsafe(self.class).props.keys.map(&:to_s)
+      suggestion = DidYouMean::SpellChecker.new(dictionary: props).correct(prop).first
+      "did you mean '#{suggestion}'?" if suggestion
+    end
+  end
+end

data/lib/graph_weaver/inflect.rb

@@ -12,7 +12,8 @@ module GraphWeaver
     end
 
     def camelize(name)
-      name.split("_").map { |part| "#{part[0].upcase}#{part[1..]}" }.join
+      # reject: leading underscores split into empty parts (_Service, _and)
+      name.split("_").reject(&:empty?).map { |part| "#{part[0].upcase}#{part[1..]}" }.join
     end
   end
 end

data/lib/graph_weaver/input_struct.rb

@@ -0,0 +1,59 @@
+# typed: true
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+require_relative "hints"
+
+module GraphWeaver
+  # Runtime for generated input structs. Each struct declares its typed
+  # consts plus a compact FIELDS table — (prop, wire name, requiredness,
+  # serializer, coercer) per field, with the conversions emitted as
+  # lambdas — and this module is the loop that drives it. One copy here
+  # instead of unrolled methods in every struct, which is the difference
+  # between ~2 lines and ~6 lines per field when a Hasura bool_exp pulls
+  # hundreds of input types into one module.
+  module InputStruct
+    include Kernel # for sorbet: hosts are T::Structs
+
+    # serializer/coercer are code-as-data from the generated file; nil
+    # means identity (the wire value passes through untouched)
+    Field = Struct.new(:prop, :wire, :required, :serializer, :coercer)
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # the wire hash — optional fields left nil stay off the wire
+    def serialize
+      self.class.const_get(:FIELDS).each_with_object({}) do |field, wire|
+        value = public_send(field.prop)
+        next if value.nil? && !field.required
+
+        wire[field.wire] = field.serializer && !value.nil? ? field.serializer.call(value) : value
+      end
+    end
+    alias_method :to_h, :serialize
+
+    module ClassMethods
+      include Kernel
+
+      # Build from a plain hash (underscored keys, Symbol or String):
+      # enums accept their wire values, nested inputs accept hashes; the
+      # struct's types are enforced on construction, and unknown keys
+      # raise with a spellchecked hint.
+      def coerce(value)
+        return value if value.is_a?(self)
+
+        # a typo'd key must not silently drop off the wire
+        GraphWeaver::Hints.validate_keys!(self, value)
+
+        fields = T.unsafe(self).const_get(:FIELDS)
+        T.unsafe(self).new(**fields.to_h do |field|
+          raw = value.key?(field.prop) ? value[field.prop] : value[field.prop.to_s]
+          [field.prop, raw.nil? || field.coercer.nil? ? raw : field.coercer.call(raw)]
+        end)
+      end
+    end
+  end
+end

data/lib/graph_weaver/logging.rb

@@ -0,0 +1,41 @@
+# typed: true
+# frozen_string_literal: true
+
+module GraphWeaver
+  class << self
+    # Where GraphWeaver narrates what it's doing — anything
+    # stdlib-Logger-compatible (Logger, Rails.logger, semantic_logger...).
+    # Silent by default; Rails apps get Rails.logger wired by the railtie.
+    #
+    #      GraphWeaver.logger = Logger.new($stdout, level: Logger::INFO)
+    #
+    # What logs where:
+    #   debug — full queries + variables on the wire, responses
+    #           (status/bytes/ms), connection lifecycle, parsed modules
+    #   info  — schema introspection and cache decisions, generated files
+    #           written, query modules loaded
+    #   warn  — every GraphWeaver error raised
+    #
+    # Queries, variables, and responses appear at debug ONLY — they can
+    # carry PII. Auth headers never log.
+    attr_accessor :logger
+
+    # Internal: level-gated and lazy — the block only runs when a logger
+    # is listening. Messages carry "graph_weaver" as progname.
+    def log(level, &block)
+      logger&.public_send(level, "graph_weaver", &block)
+    end
+
+    # Internal: run the block, logging "<label> (Nms)" at level — timing
+    # skipped entirely when no logger is set. Returns the block's value.
+    def log_timed(level, label)
+      return yield unless logger
+
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result = yield
+      ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round
+      log(level) { "#{label} (#{ms}ms)" }
+      result
+    end
+  end
+end

data/lib/graph_weaver/railtie.rb

@@ -0,0 +1,30 @@
+# typed: ignore — Rails::Railtie DSL
+# frozen_string_literal: true
+
+# Rails wiring, so the conventional layout needs no ceremony:
+#
+# - rake tasks: Rails.application.load_tasks collects every Railtie's
+#   rake_tasks block, so graph_weaver:* tasks appear with no Rakefile
+#   edit. (Outside Rails there is no task-discovery hook — add
+#   `require "graph_weaver/tasks"` to your Rakefile.)
+# - generated modules: required at boot when generated_path exists,
+#   after config/initializers (registrations and GraphWeaver.client=
+#   run first — block-built type helpers must exist before the files
+#   that include them load). load_generated! stays idempotent, so
+#   calling it yourself too is harmless.
+class GraphWeaver::Railtie < Rails::Railtie
+  rake_tasks do
+    require "graph_weaver/tasks"
+  end
+
+  # Rails.logger, unless the app already chose one (set
+  # GraphWeaver.logger = nil in an initializer to silence)
+  initializer "graph_weaver.logger" do
+    GraphWeaver.logger = Rails.logger if GraphWeaver.logger.nil?
+  end
+
+  initializer "graph_weaver.load_generated", after: :load_config_initializers do
+    # entries may be globs, so Dir[] rather than Dir.exist?
+    GraphWeaver.load_generated! if GraphWeaver.generated_paths.any? { |path| Dir[path].any? }
+  end
+end

data/lib/graph_weaver/retry.rb

@@ -0,0 +1,97 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "errors"
+
+# Wraps any client/transport with configurable retries — it satisfies
+# the same execute contract, so it layers over HTTP, Faraday, or
+# anything else:
+#
+#      client = GraphWeaver::Retry.new(
+#        GraphWeaver::Transport::HTTP.new(url),
+#        tries: 5,                        # total attempts, first included
+#        on: [GraphWeaver::TransportError, GraphWeaver::ServerError],
+#        backoff: :exponential,           # or :linear, or ->(attempt) { seconds }
+#        base: 0.5, max: 30,              # seconds; delays clamp at max:
+#        jitter: true,                    # randomize each delay by 50-100%
+#        retry_codes: ["THROTTLED"],      # also retry GraphQL errors by code
+#      )
+#
+# What retries, by default:
+#   - TransportError: always (the request never arrived)
+#   - ServerError: only 5xx — a 4xx is a bug in the request, retrying
+#     won't fix it. Override with retry_if: ->(error) { ... }
+#   - responses whose GraphQL error codes intersect retry_codes: (off by
+#     default — pass the codes your API uses for transient failures)
+#
+# Exhausting tries re-raises the last error (or returns the last
+# code-matched response).
+class GraphWeaver::Retry
+  BACKOFFS = {
+    exponential: ->(base, attempt) { base * (2**(attempt - 1)) },
+    linear: ->(base, attempt) { base * attempt },
+  }.freeze
+
+  # retry 5xx, not 4xx; everything else listed in on: retries
+  DEFAULT_RETRY_IF = lambda do |error|
+    !error.is_a?(GraphWeaver::ServerError) || error.status >= 500
+  end
+
+  def initialize(client, tries: 3, on: [GraphWeaver::TransportError, GraphWeaver::ServerError],
+    backoff: :exponential, base: 0.5, max: 30, jitter: true, retry_if: DEFAULT_RETRY_IF,
+    retry_codes: [], sleeper: nil)
+    raise ArgumentError, "tries: must be >= 1" unless tries >= 1
+
+    @client = client
+    @tries = tries
+    @on = on
+    @backoff = if backoff.is_a?(Proc)
+      ->(_base, attempt) { backoff.call(attempt) } # custom: ->(attempt) { seconds }
+    else
+      BACKOFFS.fetch(backoff) {
+        raise ArgumentError, "backoff: must be :exponential, :linear, or a Proc, got #{backoff.inspect}"
+      }
+    end
+    @base = base
+    @max = max
+    @jitter = jitter
+    @retry_if = retry_if
+    @retry_codes = retry_codes
+    @sleeper = sleeper || ->(seconds) { sleep(seconds) }
+  end
+
+  # surface the wrapped transport's endpoint (schema-dump provenance)
+  def url
+    @client.url if @client.respond_to?(:url)
+  end
+
+  def execute(query, variables: {})
+    attempt = 0
+
+    loop do
+      attempt += 1
+      begin
+        response = @client.execute(query, variables:)
+        return response unless attempt < @tries && retryable_response?(response)
+      rescue *@on => e
+        raise if attempt >= @tries || !@retry_if.call(e)
+      end
+
+      @sleeper.call(delay(attempt))
+    end
+  end
+
+  private
+
+  def retryable_response?(response)
+    return false if @retry_codes.empty?
+
+    codes = (response.to_h["errors"] || []).filter_map { |error| error.dig("extensions", "code") }
+    codes.intersect?(@retry_codes)
+  end
+
+  def delay(attempt)
+    seconds = [@backoff.call(@base, attempt), @max].min.to_f
+    @jitter ? seconds * (0.5 + rand * 0.5) : seconds
+  end
+end

data/lib/graph_weaver/rspec.rb

@@ -6,23 +6,26 @@ require_relative "testing"
 # RSpec integration — require from your spec helper instead of
 # "graph_weaver/testing":
 #
-#   require "graph_weaver/rspec"
+#      require "graph_weaver/rspec"
 #
-#   GraphWeaver::Testing.configure do |config|
-#     config.schema = MySchema
-#     config.auto_fake = true   # every example runs against a FakeExecutor
-#   end
+# Then opt in to per-example fakes (explicit on purpose — silently
+# swapping every example onto a fake is too surprising to be a default):
+#
+#      GraphWeaver::Testing.configure do |config|
+#        config.auto_fake = true      # every example runs against a fake
+#        # config.schema = MySchema   # optional: the committed dump auto-locates
+#      end
 #
 # What it wires up:
 #   - seed: defaults to rspec's --seed, so `rspec --seed 1234` reproduces
 #     fake data along with test order
-#   - auto_fake: when on (and schema is set), each example gets a fresh
-#     seeded FakeExecutor installed as GraphWeaver.executor — generated
-#     modules run in test mode with zero per-test setup. The prior
-#     executor is restored after each example.
+#   - auto_fake: when on (and a schema resolves), each example gets a
+#     fresh seeded FakeClient installed as GraphWeaver.client —
+#     generated modules run in test mode with zero per-test setup. The
+#     prior client is restored after each example.
 #
-# note: modules generated with a baked-in executor: constant don't consult
-# GraphWeaver.executor — generate without executor: to make them fakeable.
+# note: modules generated with a baked-in client: constant don't consult
+# GraphWeaver.client — generate without client: to make them fakeable.
 module GraphWeaver
   module Testing
     module RSpecIntegration
@@ -36,15 +39,15 @@ module GraphWeaver
           config = GraphWeaver::Testing.config
           next unless config.auto_fake && config.schema
 
-          @__graph_weaver_prior_executor = GraphWeaver.instance_variable_get(:@executor)
-          GraphWeaver.executor = FakeExecutor.new(schema: config.schema)
+          @__graph_weaver_prior_client = GraphWeaver.client
+          GraphWeaver.client = FakeClient.new(schema: config.schema)
         end
 
         rspec_config.after(:each) do
           config = GraphWeaver::Testing.config
           next unless config.auto_fake && config.schema
 
-          GraphWeaver.executor = @__graph_weaver_prior_executor
+          GraphWeaver.client = @__graph_weaver_prior_client
         end
       end
     end