graph_weaver 0.2.0 → 0.2.2

data/lib/graph_weaver/codegen/emit.rb

@@ -5,10 +5,244 @@
 # Mixed into Codegen — methods run with the generator instance state.
 class GraphWeaver::Codegen
   module Emit
+    include Kernel # for sorbet: hosts are Objects
     include GraphWeaver::Inflect
 
     private
 
+    # The Relay convention — an operation whose only variable is a required
+    # input object — reads better flattened: the input's fields become
+    # execute's kwargs directly, and the wrapping level is rebuilt on the
+    # wire. Multi-variable (or nullable-input) operations keep the
+    # variable-per-kwarg surface.
+    def flatten_input(variables)
+      return unless variables.size == 1
+
+      var = variables.first
+      return unless var.required && var.node.is_a?(NonNull)
+
+      input = var.node.of
+      input if input.is_a?(InputNode)
+    end
+
+    def input_references(node)
+      node.fields.filter_map do |field|
+        child = field.node
+        child = child.of while child.respond_to?(:of)
+        child if child.is_a?(InputNode)
+      end
+    end
+
+    # Input structs in dependency order (referenced types before their
+    # referrers) so each emitted const names an already-defined class.
+    # Cycles make that impossible — flagged so emission can forward-declare
+    # every input class first, then reopen each to add its props.
+    def ordered_inputs
+      ordered = []
+      seen = {} # node => :done | :visiting (bool_exp graphs get big)
+      cyclic = T.let(false, T::Boolean)
+
+      visit = lambda do |node|
+        next if seen[node] == :done
+
+        if seen[node] == :visiting
+          cyclic = true
+          next
+        end
+
+        seen[node] = :visiting
+        input_references(node).each(&visit)
+        seen[node] = :done
+        ordered << node
+      end
+      @variable_inputs.each_value(&visit)
+
+      [ordered, cyclic]
+    end
+
+      # Mapped-enum tables, generated enums, and input structs
+      # (dependency-ordered, forward-declared when cyclic) — inline in the
+      # module that needs them, or once in the shared inputs module.
+      def emit_variable_types(out)
+          @mapped_enums.each_value do |mapped|
+            emit_mapped_enum(mapped, out, 1)
+            out << ""
+          end
+          @variable_enums.each_value do |enum|
+            emit_enum(enum, out, 1)
+            out << ""
+          end
+          inputs, cyclic = ordered_inputs
+          if cyclic
+            # Recursive input types (Hasura bool_exp et al) reference each other,
+            # so no definition order satisfies the runtime — forward-declare every
+            # class empty, then let the full definitions below reopen with props.
+            # eval'd so srb sees only the full bodies (reopening a T::Struct to
+            # add props is a static error; adding them at runtime is fine).
+            out << "  # runtime-only forward declarations: these input types reference"
+            out << "  # each other, so the full definitions below need the constants"
+            out << "  eval(<<~RUBY, binding, __FILE__, __LINE__ + 1)"
+            inputs.each { |input| out << "    class #{input.class_name} < T::Struct; end" }
+            out << "  RUBY"
+            out << ""
+          end
+          inputs.each do |input|
+            emit_input(input, out, 1)
+            out << ""
+          end
+        end
+
+      # In the shared-inputs workflow the variable types live once in the
+      # inputs module; the query module aliases what it uses, so
+      # AdoptQuery::AdoptionInput stays a real constant — and shared types
+      # keep ONE identity across every module that touches them.
+      # Only the shared names THIS module's emission references: variable
+      # root types (and, when flattened, the root input's field types)
+      # plus every mapped-enum table (result casting reads them too).
+      # Nested types stay un-aliased — they live in the inputs module.
+      def shared_alias_names(variables, flatten)
+        nodes = variables.map(&:node)
+        nodes += flatten.fields.map(&:node) if flatten
+
+        names = @mapped_enums.each_value.flat_map { |m| ["#{m.const_prefix}_FROM_WIRE", "#{m.const_prefix}_TO_WIRE"] }
+        nodes.each do |wrapped|
+          node = T.let(wrapped, T.untyped)
+          node = node.of while node.is_a?(NonNull) || node.is_a?(List)
+          case node
+          when EnumNode, InputNode then names << node.class_name
+          end
+        end
+        names.uniq
+      end
+
+      def emit_shared_aliases(out, names)
+        return if names.empty?
+
+        names.each { |name| out << "  #{name} = #{@inputs_namespace}::#{name}" }
+        out << ""
+      end
+
+      # The shared inputs artifact as files: inputs.rb (the manifest —
+      # requires, forward declarations for every struct so definition
+      # order never matters, then one require per type file) plus
+      # inputs/<type>.rb per enum/mapped-table/input struct.
+      def emit_inputs_files
+        files = {}
+        enum_files = []
+        struct_files = []
+
+        @mapped_enums.each do |graphql_name, mapped|
+          enum_files << inputs_file(files, graphql_name) { |out| emit_mapped_enum(mapped, out, 1) }
+        end
+        @variable_enums.each do |graphql_name, enum|
+          enum_files << inputs_file(files, graphql_name) { |out| emit_enum(enum, out, 1) }
+        end
+        inputs, = ordered_inputs
+        inputs.each do |input|
+          struct_files << inputs_file(files, input.class_name) { |out| emit_input(input, out, 1) }
+        end
+
+        manifest = []
+        manifest << "# typed: strict"
+        manifest << "# frozen_string_literal: true"
+        manifest << ""
+        manifest << "# Generated by GraphWeaver — do not edit. Shared variable types for"
+        manifest << "# this schema, one file per type; query modules alias what they use."
+        manifest << ""
+        requires = @requires.uniq.sort
+        if requires.any?
+          requires.each { |req| manifest << "require #{req.inspect}" }
+          manifest << ""
+        end
+        manifest << "module #{@module_name}; end"
+        manifest << ""
+        enum_files.sort.each { |file| manifest << "require_relative #{file.delete_suffix(".rb").inspect}" }
+        if inputs.any?
+          manifest << ""
+          manifest << "# runtime-only forward declarations: input types reference each"
+          manifest << "# other across files, so every constant must exist before any"
+          manifest << "# definition loads (srb sees only the full bodies)"
+          manifest << "module #{@module_name}"
+          manifest << "  eval(<<~RUBY, binding, __FILE__, __LINE__ + 1)"
+          inputs.each { |input| manifest << "    class #{input.class_name} < T::Struct; end" }
+          manifest << "  RUBY"
+          manifest << "end"
+          manifest << ""
+          struct_files.sort.each { |file| manifest << "require_relative #{file.delete_suffix(".rb").inspect}" }
+        end
+
+        files["inputs.rb"] = manifest.join("\n") + "\n"
+        files
+      end
+
+      # one type per file, wrapped in the namespace so bare sibling
+      # references resolve lexically
+      def inputs_file(files, name)
+        out = []
+        out << "# typed: strict"
+        out << "# frozen_string_literal: true"
+        out << ""
+        out << "# Generated by GraphWeaver — do not edit."
+        out << ""
+        out << "module #{@module_name}"
+        yield(out)
+        out << "end"
+
+        file = "inputs/#{GraphWeaver::Inflect.underscore(name)}.rb"
+        files[file] = out.join("\n") + "\n"
+        file
+      end
+
+    # The whole generated file: header, requires, the QUERY heredoc,
+    # enum tables, input structs (dependency-ordered, forward-declared
+    # when cyclic), the Result tree, and execute — assembled from the
+    # generator's walked state.
+    def emit_module(root, variables)
+      flatten = flatten_input(variables)
+      aliases = @inputs_namespace ? shared_alias_names(variables, flatten) : []
+
+      out = []
+      out << "# typed: strict"
+      out << "# frozen_string_literal: true"
+      out << ""
+      out << "# Generated by GraphWeaver — do not edit."
+      out << ""
+      requires = @requires.uniq.sort
+      if requires.any?
+        requires.each { |req| out << "require #{req.inspect}" }
+        out << ""
+      end
+      if aliases.any?
+        # the aliases below need the shared module loaded (same directory
+        # by the generate! convention)
+        out << "require_relative \"inputs\""
+        out << ""
+      end
+      out << "module #{@module_name}"
+      out << "  extend T::Sig"
+      out << ""
+      # a GraphQL block string could contain a bare GRAPHQL line, which
+      # would terminate the heredoc early — pick a delimiter the query
+      # can't collide with
+      delimiter = "GRAPHQL"
+      delimiter += "_" while @query.match?(/^\s*#{delimiter}\s*$/)
+      out << "  QUERY = T.let(<<~'#{delimiter}', String)"
+      @query.each_line { |line| out << "    #{line}".rstrip }
+      out << "  #{delimiter}"
+      out << ""
+      if @inputs_namespace
+        emit_shared_aliases(out, aliases)
+      else
+        emit_variable_types(out)
+      end
+      emit_nested(root, out, 1)
+      out << ""
+      emit_execute(out, variables, flatten:)
+      out << "end"
+
+      out.join("\n") + "\n"
+    end
+
     def emit_nested(node, out, indent)
       case node
       when UnionNode then emit_union(node, out, indent)
@@ -175,7 +409,30 @@ class GraphWeaver::Codegen
 
       out << ""
       out << "    transport = GraphWeaver.resolve_transport(client || self.client)"
-      out << "    raw = transport.execute(QUERY, variables: variables).to_h"
+      out << "    from_response(transport.execute(QUERY, variables: variables))"
+      out << "  end"
+      out << ""
+      out << "  sig { params(#{sig_params.join(", ")}).returns(Result) }"
+      out << "  def self.execute!(#{kwargs.join(", ")})"
+      out << "    execute(#{forward}).data!"
+      out << "  end"
+      out << ""
+      emit_from_response(out)
+    end
+
+    # The network-free half of execute: deserialize a raw GraphQL response
+    # into the typed envelope. For responses fetched by any other client —
+    # execute delegates here after the transport call. Accepts the response
+    # hash (or anything with #to_h, e.g. a schema result): {"data" => ...,
+    # "errors" => ..., "extensions" => ...} with wire-cased string keys.
+    def emit_from_response(out)
+      out << "  # Deserialize a raw GraphQL response into the typed envelope — the"
+      out << "  # network-free half of execute, for responses fetched by any client."
+      out << "  # Takes the response hash (or anything with #to_h): {\"data\" => ...,"
+      out << "  # \"errors\" => ..., \"extensions\" => ...} with wire-cased string keys."
+      out << "  sig { params(response: T.untyped).returns(GraphWeaver::Response[Result]) }"
+      out << "  def self.from_response(response)"
+      out << "    raw = response.to_h"
       out << "    GraphWeaver::Response[Result].new("
       out << "      data: (Result.from_h(raw[\"data\"]) if raw[\"data\"]),"
       out << "      errors: (raw[\"errors\"] || []).map { |e| GraphWeaver::GraphQLError.from_h(e) },"
@@ -183,9 +440,10 @@ class GraphWeaver::Codegen
       out << "    )"
       out << "  end"
       out << ""
-      out << "  sig { params(#{sig_params.join(", ")}).returns(Result) }"
-      out << "  def self.execute!(#{kwargs.join(", ")})"
-      out << "    execute(#{forward}).data!"
+      out << "  # from_response + data! — the typed result, or a raised QueryError."
+      out << "  sig { params(response: T.untyped).returns(Result) }"
+      out << "  def self.from_response!(response)"
+      out << "    from_response(response).data!"
       out << "  end"
     end
 
@@ -212,74 +470,30 @@ class GraphWeaver::Codegen
       end
     end
 
-    # a module-level T::Struct per input type; serialize builds the wire
-    # hash, omitting optional fields left nil
+    # A module-level T::Struct per input type: typed consts plus a FIELDS
+    # table the GraphWeaver::InputStruct runtime drives — serialize/to_h/
+    # coerce live once in the gem, not unrolled per struct (bool_exp
+    # schemas pull hundreds of inputs into one module).
     def emit_input(node, out, indent)
       pad = "  " * indent
 
       out << "#{pad}class #{node.class_name} < T::Struct"
-      out << "#{pad}  extend T::Sig"
+      out << "#{pad}  include GraphWeaver::InputStruct"
+      out << "#{pad}  extend GraphWeaver::InputStruct::ClassMethods"
       out << ""
       node.fields.each do |field|
         default = field.required ? "" : ", default: nil"
         out << "#{pad}  const :#{field.prop}, #{field.node.prop_type}#{default}"
       end
       out << ""
-      # locals wear the reserved __gw prefix: prop readers are bare method
-      # calls here, and a prop named "result" or "value" would otherwise
-      # be shadowed — GraphQL reserves __-names, so no field can collide
-      out << "#{pad}  sig { returns(T::Hash[String, T.untyped]) }"
-      out << "#{pad}  def serialize"
-      out << "#{pad}    __gw_result = T.let({}, T::Hash[String, T.untyped])"
-      node.fields.each do |field|
-        if field.required || field.node.serialize_identity?
-          value = field.node.serialize_identity? ? field.prop.to_s : field.node.serialize(field.prop.to_s, 1)
-          line = "__gw_result[#{field.wire.inspect}] = #{value}"
-          line += " unless #{field.prop}.nil?" unless field.required
-          out << "#{pad}    #{line}"
-        else
-          # bind a local so sorbet's flow-sensitivity narrows the nilable
-          out << "#{pad}    unless (__gw_value = #{field.prop}).nil?"
-          out << "#{pad}      __gw_result[#{field.wire.inspect}] = #{field.node.serialize("__gw_value", 1)}"
-          out << "#{pad}    end"
-        end
-      end
-      out << "#{pad}    __gw_result"
-      out << "#{pad}  end"
-      out << ""
-      out << "#{pad}  # serialize, under the conventional name"
-      out << "#{pad}  sig { returns(T::Hash[String, T.untyped]) }"
-      out << "#{pad}  def to_h = serialize"
-      out << ""
-      out << "#{pad}  # Build from a plain hash (underscored keys, Symbol or String):"
-      out << "#{pad}  # enums accept their wire values, nested inputs accept hashes;"
-      out << "#{pad}  # the struct's types are enforced on construction."
-      out << "#{pad}  sig { params(value: T.any(#{node.class_name}, T::Hash[T.untyped, T.untyped])).returns(#{node.class_name}) }"
-      out << "#{pad}  def self.coerce(value)"
-      out << "#{pad}    return value if value.is_a?(#{node.class_name})"
-      out << ""
-      out << "#{pad}    # a typo'd key must not silently drop off the wire"
-      out << "#{pad}    GraphWeaver::Hints.validate_keys!(self, value)"
-      out << ""
-      out << "#{pad}    new("
+      out << "#{pad}  # (prop, wire, required, serializer, coercer) per field"
+      out << "#{pad}  FIELDS = T.let(["
       node.fields.each do |field|
-        raw = "value_at(value, :#{field.prop})"
-        expr = if field.node.hash_coerce_identity?
-          raw
-        elsif field.required
-          "#{raw}.then { |v1| #{field.node.hash_coerce("v1", 2)} }"
-        else
-          "#{raw}&.then { |v1| #{field.node.hash_coerce("v1", 2)} }"
-        end
-        out << "#{pad}      #{field.prop}: #{expr},"
+        serializer = field.node.serialize_identity? ? "nil" : "->(v) { #{field.node.serialize("v", 1)} }"
+        coercer = field.node.hash_coerce_identity? ? "nil" : "->(v) { #{field.node.hash_coerce("v", 1)} }"
+        out << "#{pad}    GraphWeaver::InputStruct::Field.new(:#{field.prop}, #{field.wire.inspect}, #{field.required}, #{serializer}, #{coercer}),"
       end
-      out << "#{pad}    )"
-      out << "#{pad}  end"
-      out << ""
-      out << "#{pad}  sig { params(hash: T::Hash[T.untyped, T.untyped], key: Symbol).returns(T.untyped) }"
-      out << "#{pad}  private_class_method def self.value_at(hash, key)"
-      out << "#{pad}    hash.key?(key) ? hash[key] : hash[key.to_s]"
-      out << "#{pad}  end"
+      out << "#{pad}  ].freeze, T::Array[GraphWeaver::InputStruct::Field])"
       out << "#{pad}end"
     end
   end

data/lib/graph_weaver/codegen/nodes.rb

@@ -1,11 +1,29 @@
 # typed: true
 # frozen_string_literal: true
 
+require "forwardable"
+
 # The typed intermediate representation of a query selection: one node
 # per GraphQL type shape, each knowing its Sorbet prop type and the
 # cast/serialize code to emit.
 class GraphWeaver::Codegen
-  class Scalar
+  # Protocol defaults — subclasses override what differs. The full node
+  # protocol: bare_type, prop_type, cast(expr, depth), identity?,
+  # serialize(expr, depth), serialize_identity?, coerce?, coerce(expr),
+  # coerce_input_type, hash_coerce(expr, depth), hash_coerce_identity?,
+  # non_null?, nested.
+  class Node
+    def bare_type = raise(GraphWeaver::Error, "#{self.class} must define bare_type")
+    def prop_type = "T.nilable(#{bare_type})"
+    def identity? = false
+    def serialize_identity? = false
+    def coerce? = false
+    def hash_coerce_identity? = false
+    def non_null? = false
+    def nested = nil
+  end
+
+  class Scalar < Node
     # takes a resolved ScalarType — the generator picks it from the
     # client-scoped overlay or the global registry
     def initialize(scalar_type)
@@ -52,34 +70,27 @@ class GraphWeaver::Codegen
     end
 
     def hash_coerce_identity? = !@scalar.coerce?
-
-    def non_null? = false
-    def nested = nil
   end
 
-  class NonNull
+  # NonNull is its inner node with the nilability stripped — everything
+  # else passes through.
+  class NonNull < Node
+    extend Forwardable
+
     attr_reader :of
 
+    def_delegators :@of, :bare_type, :cast, :identity?, :serialize, :serialize_identity?,
+      :coerce?, :coerce, :coerce_input_type, :hash_coerce, :hash_coerce_identity?, :nested
+
     def initialize(of)
       @of = of
     end
 
-    def bare_type = @of.bare_type
     def prop_type = bare_type
-    def cast(expr, depth) = @of.cast(expr, depth)
-    def identity? = @of.identity?
-    def serialize(expr, depth) = @of.serialize(expr, depth)
-    def serialize_identity? = @of.serialize_identity?
-    def coerce? = @of.coerce?
-    def coerce(expr) = @of.coerce(expr)
-    def coerce_input_type = @of.coerce_input_type
-    def hash_coerce(expr, depth) = @of.hash_coerce(expr, depth)
-    def hash_coerce_identity? = @of.hash_coerce_identity?
     def non_null? = true
-    def nested = @of.nested
   end
 
-  class List
+  class List < Node
     attr_reader :of
 
     def initialize(of)
@@ -90,10 +101,6 @@ class GraphWeaver::Codegen
       "T::Array[#{@of.prop_type}]"
     end
 
-    def prop_type
-      "T.nilable(#{bare_type})"
-    end
-
     def cast(expr, depth)
       var = "v#{depth}"
       element = if @of.non_null? || @of.identity?
@@ -119,7 +126,6 @@ class GraphWeaver::Codegen
     end
 
     def serialize_identity? = @of.serialize_identity?
-    def coerce? = false
 
     def hash_coerce(expr, depth)
       var = "v#{depth}"
@@ -133,11 +139,10 @@ class GraphWeaver::Codegen
     end
 
     def hash_coerce_identity? = @of.hash_coerce_identity?
-    def non_null? = false
     def nested = @of.nested
   end
 
-  class ObjectNode
+  class ObjectNode < Node
     Field = Struct.new(:prop, :key, :node)
 
     attr_reader :class_name, :fields
@@ -153,20 +158,14 @@ class GraphWeaver::Codegen
 
     def bare_type = class_name
 
-    def prop_type
-      "T.nilable(#{bare_type})"
-    end
-
     def cast(expr, _depth)
       "#{class_name}.from_h(#{expr})"
     end
 
-    def identity? = false
-    def non_null? = false
     def nested = self
   end
 
-  class EnumNode
+  class EnumNode < Node
     attr_reader :class_name, :values
 
     def initialize(class_name, values)
@@ -176,22 +175,14 @@ class GraphWeaver::Codegen
 
     def bare_type = class_name
 
-    def prop_type
-      "T.nilable(#{bare_type})"
-    end
-
     def cast(expr, _depth)
       "#{class_name}.deserialize(#{expr})"
     end
 
-    def identity? = false
-
     def serialize(expr, _depth)
       "#{expr}.serialize"
     end
 
-    def serialize_identity? = false
-
     # enums always coerce: a kwarg or hash field accepts the T::Enum or
     # its wire value (deserialize raises on anything else)
     def coerce? = true
@@ -202,8 +193,6 @@ class GraphWeaver::Codegen
 
     def coerce_input_type = "T.any(#{class_name}, String)"
     def hash_coerce(expr, _depth) = coerce(expr)
-    def hash_coerce_identity? = false
-    def non_null? = false
     def nested = self
   end
 
@@ -211,7 +200,7 @@ class GraphWeaver::Codegen
   # generated enum class — instead module-level <NAME>_FROM_WIRE /
   # <NAME>_TO_WIRE constants translate at the boundary. fallback: makes
   # casting absorb unknown wire values (inputs stay strict).
-  class MappedEnum
+  class MappedEnum < Node
     attr_reader :graphql_name, :mapping
 
     def initialize(enum_type, wire_values)
@@ -226,10 +215,6 @@ class GraphWeaver::Codegen
 
     def bare_type = @type_name
 
-    def prop_type
-      "T.nilable(#{bare_type})"
-    end
-
     def cast(expr, _depth)
       if @fallback
         "#{const_prefix}_FROM_WIRE.fetch(#{expr}) { #{fallback_const} }"
@@ -238,14 +223,10 @@ class GraphWeaver::Codegen
       end
     end
 
-    def identity? = false
-
     def serialize(expr, _depth)
       "#{const_prefix}_TO_WIRE.fetch(#{expr})"
     end
 
-    def serialize_identity? = false
-
     # kwargs and hash fields accept the member or its wire value; unlike
     # casting, bad input raises even with a fallback (a typo'd input is
     # our bug, not server drift)
@@ -257,9 +238,6 @@ class GraphWeaver::Codegen
 
     def coerce_input_type = "T.any(#{@type_name}, String)"
     def hash_coerce(expr, _depth) = coerce(expr)
-    def hash_coerce_identity? = false
-    def non_null? = false
-    def nested = nil
   end
 
   # A single-condition narrowing of an abstract field (`... on Pet { ... }`
@@ -267,7 +245,7 @@ class GraphWeaver::Codegen
   # nil when it doesn't — a non-match's response object carries no
   # matching fields, so the hash arrives empty. Always nilable, whatever
   # the schema's nullability, because narrowing filters.
-  class NarrowedNode
+  class NarrowedNode < Node
     def initialize(of)
       @of = of
     end
@@ -275,20 +253,14 @@ class GraphWeaver::Codegen
     def class_name = @of.class_name
     def bare_type = @of.bare_type
 
-    def prop_type
-      "T.nilable(#{bare_type})"
-    end
-
     def cast(expr, depth)
       "(#{expr}.empty? ? nil : #{@of.cast(expr, depth)})"
     end
 
-    def identity? = false
-    def non_null? = false
     def nested = @of
   end
 
-  class UnionNode
+  class UnionNode < Node
     attr_reader :class_name, :members # graphql type name => ObjectNode
 
     def initialize(class_name, members)
@@ -298,16 +270,10 @@ class GraphWeaver::Codegen
 
     def bare_type = "#{class_name}::Type"
 
-    def prop_type
-      "T.nilable(#{bare_type})"
-    end
-
     def cast(expr, _depth)
       "#{class_name}.from_h(#{expr})"
     end
 
-    def identity? = false
-    def non_null? = false
     def nested = self
   end
 
@@ -315,7 +281,7 @@ class GraphWeaver::Codegen
   # serialize produces the wire hash. Inputs never cast FROM the wire.
   # Joins the coerce protocol so execute kwargs accept plain hashes,
   # normalized (and type-checked) through the generated .coerce.
-  class InputNode
+  class InputNode < Node
     Field = Struct.new(:prop, :wire, :node, :required)
 
     attr_reader :class_name, :fields
@@ -327,18 +293,12 @@ class GraphWeaver::Codegen
 
     def bare_type = class_name
 
-    def prop_type
-      "T.nilable(#{bare_type})"
-    end
-
     def serialize(expr, _depth)
       "#{expr}.serialize"
     end
 
-    def serialize_identity? = false
-
     def cast(_expr, _depth)
-      raise NotImplementedError, "input objects are never cast from responses"
+      raise GraphWeaver::Error, "input objects are never cast from responses"
     end
 
     def coerce? = true
@@ -347,10 +307,5 @@ class GraphWeaver::Codegen
 
     # building a struct field from a caller-supplied plain hash value
     def hash_coerce(expr, _depth) = "#{class_name}.coerce(#{expr})"
-    def hash_coerce_identity? = false
-
-    def identity? = false
-    def non_null? = false
-    def nested = nil
   end
 end