graph_weaver 0.1.0 → 0.2.0

data/lib/graph_weaver/codegen/scalar_type.rb

@@ -1,6 +1,8 @@
 # typed: true
 # frozen_string_literal: true
 
+require "date"
+
 class GraphWeaver::Codegen
 
   # How one GraphQL scalar maps to Ruby: the Sorbet prop type, the
@@ -15,17 +17,17 @@ class GraphWeaver::Codegen
   # from the Ruby type when it is a real class, by probing for a known
   # deserializer and pairing its serializer (see CODECS) — so the common
   # case needs no more than a class:
-  #   type: Money   (defines .parse)   => Money.parse(expr) / expr.to_s
-  #   type: Blob    (defines .load)    => Blob.load(expr)   / Blob.dump(expr)
+  #      type: Money   (defines .parse)   => Money.parse(expr) / expr.to_s
+  #      type: Blob    (defines .load)    => Blob.load(expr)   / Blob.dump(expr)
   # Probing the *deserialize* side is deliberate: every object has #to_s,
   # so inferring a serializer off it would wrongly wrap plain types (String,
   # Integer) — pairing off a deserializer the type actually defines avoids
   # that. Override with an explicit value:
   #   - a Symbol names a method, so there is no string to misspell:
-  #       cast: :load        => "Blob.load(expr)"    (class method on type)
-  #       serialize: :to_json => "expr.to_json"      (instance method)
+  #           cast: :load        => "Blob.load(expr)"    (class method on type)
+  #           serialize: :to_json => "expr.to_json"      (instance method)
   #   - a Proc handles anything a Symbol can't express:
-  #       cast: ->(e) { "Money.new(#{e})" }
+  #           cast: ->(e) { "Money.new(#{e})" }
   #   - :itself opts out — force identity pass-through even when a codec
   #     would otherwise match (rare)
   # requires: a String or Array of paths emitted as `require`s atop the
@@ -56,23 +58,44 @@ class GraphWeaver::Codegen
 
     attr_reader :graphql_name, :type, :requires
 
-    def initialize(graphql_name, type:, cast: nil, serialize: nil, requires: nil, coerce: false)
+    def initialize(graphql_name, type, cast: nil, serialize: nil, requires: nil, coerce: nil)
       @graphql_name = graphql_name.to_s
       @klass = type.is_a?(Module) ? type : nil
       @type = type_name(type)
+      # requires: load BEFORE codec probing — the probe method may come
+      # from the required file (core Time has no .parse until the "time"
+      # stdlib loads)
+      @requires = normalize_requires(requires)
       codec = @klass && CODECS.find { |c| @klass.respond_to?(c.probe) }
       @cast = normalize_cast(cast, codec&.cast)
       @serialize = normalize_serialize(serialize, codec&.serialize)
-      @requires = normalize_requires(requires)
       @coerce = coerce
       validate_coerce!
     end
 
+    # conversions applied to the four convertible built-ins when the
+    # global GraphWeaver.auto_coerce is on and no explicit coerce: given
+    AUTO_CONVERSIONS = {
+      "ID" => :to_s, "String" => :to_s, "Int" => :to_i, "Float" => :to_f,
+    }.freeze
+
     def cast(expr) = @cast&.call(expr)
     def cast? = !@cast.nil?
     def serialize(expr) = @serialize&.call(expr)
     def serialize? = !@serialize.nil?
-    def coerce? = !!@coerce
+    def coerce? = !!effective_coerce
+
+    # Explicit coerce: always wins (false means never). Left unset, the
+    # global GraphWeaver.auto_coerce decides — resolved HERE, at
+    # generation time, so registration order doesn't matter: convertible
+    # built-ins get their conversion, anything with a full cast/serialize
+    # pair gets parse-style coercion.
+    def effective_coerce
+      return @coerce unless @coerce.nil?
+      return false unless GraphWeaver.auto_coerce
+
+      AUTO_CONVERSIONS.fetch(@graphql_name) { (cast? && serialize?) || nil }
+    end
 
     # The code that normalizes a variable input before it's serialized. Two
     # shapes: coerce: true parses a raw value into the rich type via the cast
@@ -82,17 +105,17 @@ class GraphWeaver::Codegen
     # afterward, but is identity for the conversion built-ins, so the
     # converted value goes on the wire natively (a Float, not "5.0").
     def coerce_input(expr)
-      case @coerce
+      case effective_coerce
       when true then "(#{expr}.is_a?(#{@type}) ? #{expr} : #{cast(expr)})"
-      when Symbol then "#{expr}.#{@coerce}"
+      when Symbol then "#{expr}.#{effective_coerce}"
       end
     end
 
     # the accepted Sorbet type for a coercible variable kwarg
     def coerce_type
-      case @coerce
+      case effective_coerce
       when true then "T.any(#{@type}, String)"
-      when Symbol then CONVERT_INPUTS.fetch(@coerce, "T.untyped")
+      when Symbol then CONVERT_INPUTS.fetch(effective_coerce, "T.untyped")
       end
     end
 
@@ -175,9 +198,9 @@ 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: false)
+    def register_scalar(graphql_name, type, cast: nil, serialize: nil, requires: nil, coerce: nil)
       scalar_registry[graphql_name.to_s] =
-        ScalarType.new(graphql_name, type:, cast:, serialize:, requires:, coerce:)
+        ScalarType.new(graphql_name, type, cast:, serialize:, requires:, coerce:)
     end
 
     # The ScalarType for a scalar name; unknown scalars fall back to an
@@ -185,7 +208,7 @@ class GraphWeaver::Codegen
     # scalars outside the table.
     def scalar(graphql_name)
       scalar_registry.fetch(graphql_name.to_s) do
-        ScalarType.new(graphql_name, type: "T.untyped")
+        ScalarType.new(graphql_name, "T.untyped")
       end
     end
 
@@ -201,14 +224,12 @@ 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. Pass
-    # coerce: true to reload the built-ins with input coercion enabled
-    # (Float accepts 5/"5" and .to_f's it, etc.), then register your own
-    # scalars on top — a one-liner alternative to re-registering each
-    # built-in by hand.
-    def reset_scalars!(coerce: false)
+    # 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.)
+    def reset_scalars!
       clear_scalars!
-      register_builtin_scalars!(coerce:)
+      register_builtin_scalars!
       self
     end
 
@@ -218,19 +239,16 @@ class GraphWeaver::Codegen
     # 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).
-    #
-    # coerce: true opts the convertible scalars into input coercion via a
-    # plain conversion method (to_f/to_i/to_s); the wire value stays native
-    # (a Float, not "5.0"). Boolean and Date have no lossless one-method
-    # conversion, so they stay strict either way.
-    def register_builtin_scalars!(coerce: false)
-      register_scalar "ID", type: String, coerce: (:to_s if coerce)
-      register_scalar "String", type: String, coerce: (:to_s if coerce)
-      register_scalar "Int", type: Integer, coerce: (:to_i if coerce)
-      register_scalar "Float", type: Float, coerce: (:to_f if coerce)
-      register_scalar "Boolean", type: "T::Boolean"
-      register_scalar "Date", type: Date, cast: :iso8601, serialize: :iso8601, requires: "date"
+    # so it's explicit). Input coercion is a generation-time concern:
+    # GraphWeaver.auto_coerce gives the convertible built-ins their
+    # conversion (see ScalarType::AUTO_CONVERSIONS).
+    def register_builtin_scalars!
+      register_scalar "ID", String
+      register_scalar "String", String
+      register_scalar "Int", Integer
+      register_scalar "Float", Float
+      register_scalar "Boolean", "T::Boolean"
+      register_scalar "Date", Date, cast: :iso8601, serialize: :iso8601, requires: "date"
     end
   end