graph_weaver 0.5.0 → 0.6.0

data/lib/graph_weaver/codegen/scalar_type.rb

@@ -34,29 +34,36 @@ class GraphWeaver::Codegen
   class ScalarType
     # Inferred (deserialize, serialize) codecs, tried in order; the first
     # whose probe the Ruby type defines as a class method wins, and its
-    # serialize is paired with it. Builders take (type_name, expr) => code.
-    Codec = Struct.new(:probe, :cast, :serialize)
+    # serialize is paired with it. Builders take (type_name, expr) => code;
+    # `call` is the same serialization run rather than emitted, for the
+    # testing harness (see #serialize_value).
+    Codec = Struct.new(:probe, :cast, :serialize, :call)
     CODECS = [
       Codec.new(:parse, # Type.parse(wire) <-> value.to_s
         ->(type, expr) { "#{type}.parse(#{expr})" },
-        ->(_type, expr) { "#{expr}.to_s" }),
+        ->(_type, expr) { "#{expr}.to_s" },
+        ->(_klass, value) { value.to_s }),
       Codec.new(:load, # Type.load(wire) <-> Type.dump(value)
         ->(type, expr) { "#{type}.load(#{expr})" },
-        ->(type, expr) { "#{type}.dump(#{expr})" }),
+        ->(type, expr) { "#{type}.dump(#{expr})" },
+        ->(klass, value) { klass.dump(value) }),
     ].freeze
 
-    # How a built-in converts a loose variable input, and the widened kwarg
-    # it then accepts. Only the numerics can: a String/ID/Boolean input is
-    # already its own Ruby type, so there is nothing to convert.
-    Conversion = Struct.new(:via, :input_type)
-    CONVERSIONS = {
-      "Int" => Conversion.new(:to_i, "T.any(Integer, Float, String)"),
-      "Float" => Conversion.new(:to_f, "T.any(Float, Integer, String)"),
+    # A scalar with no `cast:` to run input through: its Ruby type is the
+    # whole rule, so key on that — a custom scalar registered as a plain
+    # String gets the same check. ID is the exception GraphQL itself names
+    # (see Coerce.id), matched by GraphQL name in #coercer.
+    COERCERS = {
+      "Integer" => "integer",
+      "Float" => "float",
+      "String" => "string",
+      "T::Boolean" => "boolean",
     }.freeze
+    private_constant :Codec, :CODECS, :COERCERS
 
     attr_reader :graphql_name, :type, :requires
 
-    def initialize(graphql_name, type, cast: nil, serialize: nil, requires: nil, coerce: nil)
+    def initialize(graphql_name, type, cast: nil, serialize: nil, requires: nil)
       @graphql_name = graphql_name.to_s
       @klass = type.is_a?(Module) ? type : nil
       @type = type_name(type)
@@ -67,52 +74,47 @@ class GraphWeaver::Codegen
       codec = @klass && CODECS.find { |c| @klass.respond_to?(c.probe) }
       @cast = normalize_cast(cast, codec&.cast)
       @serialize = normalize_serialize(serialize, codec&.serialize)
-      @coerce = coerce
-      validate_coerce!
+      @serialize_value = runtime_serialize(serialize, codec)
     end
 
     def cast(expr) = @cast&.call(expr)
     def cast? = !@cast.nil?
     def serialize(expr) = @serialize&.call(expr)
     def serialize? = !@serialize.nil?
-    def coerce? = !!coercion
+    def coerce? = !coerce_input("v").nil?
 
-    # How this scalar coerces a variable input, or nil for not at all.
-    # coerce: says WHETHER (explicit always wins); left unset the global
-    # GraphWeaver.auto_coerce decides — resolved HERE, at generation time,
-    # so registration order doesn't matter. The scalar itself says HOW: a
-    # convertible built-in converts, anything with a full cast/serialize
-    # pair parses. Nothing left to try means it can't coerce.
-    def coercion
-      return if @coerce == false
-      return if @coerce.nil? && !GraphWeaver.auto_coerce
+    # #serialize run rather than emitted: the wire value for a Ruby one. The
+    # testing harness reads app objects — a Time, a Money — off an object pin
+    # and has to write what the server would. A `serialize:` proc builds code
+    # and can't be run, so its value passes through and the cast complains.
+    def serialize_value(value)
+      return value if value.nil? || @serialize_value.nil?
 
-      CONVERSIONS[@graphql_name] || (:parse if cast? && serialize?)
+      @serialize_value.call(value)
     end
 
-    # The code that normalizes a variable input before it's serialized.
-    # Parsing runs a raw value through the cast, guarded so an already-typed
-    # value passes through; a conversion just calls the method (5, "5" ->
-    # 5.0). serialize still runs afterward, but is identity for the
-    # convertible built-ins, so the converted value goes on the wire
-    # natively (a Float, not "5.0").
+    # The code that normalizes a loose input — a Rails param — into this
+    # scalar's Ruby type before it is serialized, or nil for nothing to do.
+    # `cast:` is the how: it already knows how to build the Ruby object from
+    # a wire value, guarded so an already-typed value passes through. A
+    # scalar without one falls back to its Ruby type's check, which is what
+    # `.checked(:never)` on the generated sig gives up.
     def coerce_input(expr)
-      case (how = coercion)
-      when :parse then "(#{expr}.is_a?(#{@type}) ? #{expr} : #{cast(expr)})"
-      when Conversion then "#{expr}.#{how.via}"
-      end
-    end
-
-    # the accepted Sorbet type for a coercible variable kwarg
-    def coerce_type
-      case (how = coercion)
-      when :parse then "T.any(#{@type}, String)"
-      when Conversion then how.input_type
+      if cast?
+        "(#{expr}.is_a?(#{@type}) ? #{expr} : #{cast(expr)})"
+      elsif (fn = coercer)
+        "GraphWeaver::Coerce.#{fn}(#{expr})"
       end
     end
 
     private
 
+    def coercer
+      return "id" if @graphql_name == "ID" && @type == "String"
+
+      COERCERS[@type]
+    end
+
     def type_name(type)
       case type
       when Module
@@ -148,33 +150,23 @@ class GraphWeaver::Codegen
       end
     end
 
+    # The runnable half of normalize_serialize: a Symbol names a method
+    # (:itself included, which is identity either way), an inferred codec
+    # knows its own call, and a Proc emits code there is no way to run.
+    def runtime_serialize(serialize, codec)
+      case serialize
+      when Symbol then ->(value) { value.public_send(serialize) }
+      when nil then codec && ->(value) { codec.call.call(@klass, value) }
+      end
+    end
+
     # With only a type-name string we can't assume the lib is installed at
     # codegen time, so the paths aren't loaded — only shape-checked.
     def normalize_requires(requires)
       GraphWeaver::Codegen.normalize_requires!(requires, load: !@klass.nil?)
     end
-
-    # coerce: true asks for something the scalar has to know how to do, so
-    # refuse a pass-through one now rather than emit a silent no-op.
-    def validate_coerce!
-      case @coerce
-      when false, nil then nil
-      when true
-        return if coercion
-
-        raise ArgumentError,
-          "coerce: true needs a cast and a serialize (#{@graphql_name} has neither, " \
-          "so there is nothing to coerce)"
-      else
-        raise ArgumentError, "coerce: must be true or false, got #{@coerce.inspect}"
-      end
-    end
   end
 
-  # Pre-registered rather than user intent (see register_builtin_scalars!), so
-  # generation doesn't hold a schema to them.
-  BUILTIN_SCALARS = %w[ID String Int Float Boolean Date].freeze
-
   class << self
     # requires: is a require path or list of them; each must be a non-empty
     # String (it is emitted verbatim as `require "..."` atop the generated
@@ -204,18 +196,19 @@ class GraphWeaver::Codegen
     # the accepted cast:/serialize:/requires: forms. Later registrations
     # win, so an app can override a built-in (e.g. map Date onto its own
     # type).
-    def register_scalar(graphql_name, type, cast: nil, serialize: nil, requires: nil, coerce: nil)
+    def register_scalar(graphql_name, type, cast: nil, serialize: nil, requires: nil)
       scalar_registry[graphql_name.to_s] =
-        ScalarType.new(graphql_name, type, cast:, serialize:, requires:, coerce:)
+        ScalarType.new(graphql_name, type, cast:, serialize:, requires:)
     end
 
-    # The ScalarType for a scalar name; unknown scalars fall back to an
-    # untyped pass-through (T.untyped, no cast) — the prior behavior for
-    # scalars outside the table.
-    def scalar(graphql_name)
-      scalar_registry.fetch(graphql_name.to_s) do
-        ScalarType.new(graphql_name, "T.untyped")
-      end
+    # The ScalarType in play for a scalar, most specific first: the
+    # `Type.field` registration when `coordinate` names one, then the
+    # scalar-name registration. Unknown scalars fall back to an untyped
+    # pass-through (T.untyped, no cast) — the prior behavior for scalars
+    # outside the table.
+    def scalar(graphql_name, coordinate = nil)
+      (coordinate && scalar_registry[coordinate.to_s]) ||
+        scalar_registry.fetch(graphql_name.to_s) { ScalarType.new(graphql_name, "T.untyped") }
     end
 
     def scalar_registry
@@ -230,32 +223,43 @@ class GraphWeaver::Codegen
     end
 
     # Drop every custom registration and restore the built-in scalars — the
-    # clean slate to reach for between tests, or to undo overrides. (Want
-    # the built-ins to coerce loose input? That's GraphWeaver.auto_coerce,
-    # resolved at generation time — no re-registering.)
+    # clean slate to reach for between tests, or to undo overrides.
     def reset_scalars!
       clear_scalars!
       register_builtin_scalars!
       self
     end
 
-    # Built-in scalars — pre-registered entries in the one registry. The
-    # standard scalars stay pass-through: their Ruby classes (String,
-    # Integer, Float) define neither .parse nor .load, so codec inference
-    # matches nothing and leaves them identity — which is exactly why we
-    # can name them with the real class constants. Date deserializes via
-    # ISO-8601 (it *does* define .parse, but we want iso8601 specifically,
-    # so it's explicit). Whether a variable of one accepts loose input is a
-    # separate, generation-time question — see coercion.
+    # Built-in scalars — pre-registered entries in the one registry. Most stay
+    # pass-through: their Ruby classes (String, Integer) define neither .parse
+    # nor .load, so codec inference matches nothing and leaves them identity —
+    # which is exactly why we can name them with the real class constants.
+    # Float is the exception: JSON has one number type, so a whole Float
+    # arrives as `1` from every encoder that drops the trailing zero
+    # (graphql-js and Go both do), and Coerce.float widens that without
+    # accepting the garbage `.to_f` would silently turn into 0.0. Date
+    # deserializes via ISO-8601 (it *does* define .parse, but we want iso8601
+    # specifically, so it's explicit). The rest carry no cast and coerce
+    # input by their Ruby type — see coerce_input.
     def register_builtin_scalars!
       register_scalar "ID", String
       register_scalar "String", String
       register_scalar "Int", Integer
-      register_scalar "Float", Float
+      register_scalar "Float", Float, cast: ->(expr) { "GraphWeaver::Coerce.float(#{expr})" }
       register_scalar "Boolean", "T::Boolean"
       register_scalar "Date", Date, cast: :iso8601, serialize: :iso8601, requires: "date"
     end
+    private :register_builtin_scalars!
   end
 
+  # codegen's own record of a registration; users get one back from
+  # `.scalar` but never name the class
+  private_constant :ScalarType
+
   register_builtin_scalars!
+
+  # Pre-registered rather than user intent, so generation doesn't hold a schema
+  # to them (validate_registration! skips these). Read off the registry the line
+  # above just filled: a seventh built-in shouldn't have to be named twice.
+  BUILTIN_SCALARS = scalar_registry.keys.freeze
 end

data/lib/graph_weaver/codegen/type_helpers.rb

@@ -54,9 +54,7 @@ class GraphWeaver::Codegen
         # won't resolve yet — see EnumType for why that's a Rails initializer
         if mixin.is_a?(String)
           raise ArgumentError, "type helpers are the modules themselves, not their names — " \
-            "extend_type(#{graphql_name.to_s.inspect}, #{mixin}). An autoloaded constant isn't " \
-            "resolvable while config/initializers run; register from a " \
-            "Rails.application.config.to_prepare block, which generation also runs first."
+            "extend_type(#{graphql_name.to_s.inspect}, #{mixin}). #{GraphWeaver::Codegen::AUTOLOAD_HINT}"
         end
         unless mixin.is_a?(Module) && mixin.name
           raise ArgumentError, "type helpers must be named modules, got #{mixin.inspect}"
@@ -84,6 +82,7 @@ class GraphWeaver::Codegen
     # arbitrary text that could inject code
     ALIAS_NAME = /\A[a-zA-Z_]\w*[?!]?\z/
     ALIAS_SEGMENT = /\A[a-zA-Z_]\w*\z/
+    private_constant :ALIAS_NAME, :ALIAS_SEGMENT
 
     # { accessor => { segments:, optional: } } from a path string (accessor
     # named after the last segment), an array of such, or an { accessor => path }