rails-graphql 0.1.0

data/lib/rails/graphql/type/scalar.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # = GraphQL ScalarType
+      #
+      # Scalar types represent primitive leaf values in a GraphQL type system.
+      # See http://spec.graphql.org/June2018/#ScalarTypeDefinition
+      #
+      # This class works very similarly to ActiveModel::Type::Value, but instead
+      # of working with instances, we operate in the singleton way.
+      #
+      # The +ar_type+ defines to which ActiveRecord type the value is casted
+      # when serializing to hash, which indicates if a cast is necessary or not.
+      class Scalar < Type
+        extend ActiveSupport::Autoload
+
+        setup! leaf: true, input: true, output: true
+
+        eager_autoload do
+          # Load all the default scalar types
+          autoload :IntScalar
+          autoload :FloatScalar
+          autoload :StringScalar
+          autoload :BooleanScalar
+          autoload :IdScalar
+
+          # Load all additional scalar types
+          autoload :BigintScalar
+          autoload :BinaryScalar
+          autoload :DateScalar
+          autoload :DateTimeScalar
+          autoload :DecimalScalar
+          autoload :TimeScalar
+        end
+
+        class << self
+          # Check if a given value is a valid non-deserialized input
+          def valid_input?(value)
+            value.is_a?(String)
+          end
+
+          # Check if a given value is a valid non-serialized output
+          def valid_output?(value)
+            value.respond_to?(:to_s)
+          end
+
+          # Transforms the given value to its representation in a JSON string
+          def to_json(value)
+            as_json(value)&.inspect
+          end
+
+          # Transforms the given value to its representation in a Hash object
+          def as_json(value)
+            value.to_s
+          end
+
+          # Turn a user input of this given type into an ruby object
+          def deserialize(value)
+            value
+          end
+
+          def inspect # :nodoc:
+            "#<GraphQL::Scalar #{gql_name}>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/scalar/bigint_scalar.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # Bigint basically removes the limit of the value, but it serializes as
+      # a string so it won't go against the spec
+      class Scalar::BigintScalar < Scalar
+        desc <<~DESC
+          The Bigint scalar type represents a signed numeric non‐fractional value.
+          It can go beyond the Int 32‐bit limit, but it's exchanged as a string.
+        DESC
+
+        class << self
+          def valid_input?(value)
+            super && value.match?(/\A[+-]?\d+\z/)
+          end
+
+          def valid_output?(value)
+            value.respond_to?(:to_i)
+          end
+
+          def as_json(value)
+            value.to_i.to_s
+          end
+
+          def deserialize(value)
+            value.to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/scalar/binary_scalar.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # Binary basically allows binary data to be shared using Base64 strings,
+      # ensuring the UTF-8 encoding and performing the necessary conversion.
+      #
+      # It also rely on ActiveModel so it can easily share the same Data object.
+      class Scalar::BinaryScalar < Scalar
+        aliases :file
+
+        desc <<~DESC
+          The Binary scalar type represents a Base64 string.
+          Normally used to share files and uploads.
+        DESC
+
+        class << self
+          def as_json(value)
+            Base64.encode64(value.to_s).chomp
+          end
+
+          def deserialize(value)
+            ActiveModel::Type::Binary::Data.new(Base64.decode64(value))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/scalar/boolean_scalar.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # The Boolean scalar type represents +true+ or +false+.
+      #
+      # See http://spec.graphql.org/June2018/#sec-Boolean
+      class Scalar::BooleanScalar < Scalar
+        self.spec_object = true
+        aliases :bool
+
+        desc 'The Boolean scalar type represents true or false.'
+
+        FALSE_VALUES = ::ActiveModel::Type::Boolean::FALSE_VALUES
+
+        class << self
+          def valid_input?(value)
+            value === true || value === false
+          end
+
+          def valid_output?(value)
+            value.respond_to?(:present?)
+          end
+
+          def as_json(value)
+            value.present?
+          end
+
+          def deserialize(value)
+            !FALSE_VALUES.include?(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/scalar/date_scalar.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # Date uses a ISO 8601 string to exchange the value.
+      class Scalar::DateScalar < Scalar
+        desc 'The Date scalar type represents a ISO 8601 string value.'
+
+        class << self
+          def valid_input?(value)
+            super && !!Date.iso8601(value)
+          rescue Date::Error
+            false
+          end
+
+          def valid_output?(value)
+            value.respond_to?(:to_date) && !!value.to_date
+          rescue Date::Error
+            false
+          end
+
+          def as_json(value)
+            value.to_date.iso8601
+          end
+
+          def deserialize(value)
+            Date.iso8601(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/scalar/date_time_scalar.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # DateTime uses a ISO 8601 string to exchange the value.
+      class Scalar::DateTimeScalar < Scalar
+        aliases :datetime
+
+        desc 'The DateTime scalar type represents a ISO 8601 string value.'
+
+        class << self
+          def valid_input?(value)
+            super && !!(Time.iso8601(value) rescue false)
+          end
+
+          def valid_output?(value)
+            value.respond_to?(:to_time) && !!value.to_time
+          end
+
+          def as_json(value)
+            value.to_time.iso8601
+          end
+
+          def deserialize(value)
+            Time.iso8601(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/scalar/decimal_scalar.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # Similar to float, but implies extra precision, making sure that all the
+      # decimal-point numbers are kept. As Bigint, it uses a string so it won't
+      # go against the spec.
+      class Scalar::DecimalScalar < Scalar
+        desc <<~DESC
+          The Decimal scalar type represents signed fractional values with extra precision.
+          The values are exchange as string.
+        DESC
+
+        class << self
+          def valid_input?(value)
+            super && value.match?(/\A[+-]?\d+\.\d+\z/)
+          end
+
+          def valid_output?(value)
+            value.respond_to?(:to_d)
+          end
+
+          def as_json(value)
+            value.to_d.to_s
+          end
+
+          def deserialize(value)
+            value.to_d
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/scalar/float_scalar.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # The Float scalar type represents signed double-precision fractional
+      # values as specified by
+      # {IEEE 754}[http://en.wikipedia.org/wiki/IEEE_floating_point].
+      #
+      # See http://spec.graphql.org/June2018/#sec-Float
+      class Scalar::FloatScalar < Scalar
+        self.spec_object = true
+
+        desc 'The Float scalar type represents signed double‐precision fractional values.'
+
+        class << self
+          def valid_input?(value)
+            value.is_a?(Float)
+          end
+
+          def valid_output?(value)
+            value.respond_to?(:to_f)
+          end
+
+          def as_json(value)
+            value.to_f
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/scalar/id_scalar.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # The ID scalar type represents a unique identifier, often used to
+      # refetch an object or as the key for a cache. The ID type is serialized
+      # in the same way as a +StringScalar+.
+      #
+      # See http://spec.graphql.org/June2018/#sec-ID
+      class Scalar::IdScalar < Scalar
+        self.spec_object = true
+
+        rename! 'ID'
+
+        desc <<~DESC
+          The ID scalar type represents a unique identifier and it is serialized in the same
+          way as a String but it accepts both numeric and string based values as input.
+        DESC
+
+        class << self
+          def valid_input?(value)
+            super || value.is_a?(Integer)
+          end
+
+          def as_json(value)
+            value = value.to_s unless value.is_a?(String)
+            value = value.encode(Encoding::UTF_8) unless value.encoding.eql?(Encoding::UTF_8)
+            value
+          end
+
+          def deserialize(value)
+            value.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/scalar/int_scalar.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # The Int scalar type represents a signed 32-bit numeric
+      # non-fractional value.
+      #
+      # See http://spec.graphql.org/June2018/#sec-Int
+      class Scalar::IntScalar < Scalar
+        self.spec_object = true
+        aliases :integer
+
+        desc 'The Int scalar type represents a signed 32‐bit numeric non‐fractional value.'
+
+        max_value = (1 << 31)
+        RANGE = (-max_value...max_value).freeze
+
+        class << self
+          def valid_input?(value)
+            value.is_a?(Integer) && RANGE.cover?(value)
+          end
+
+          def valid_output?(value)
+            value.respond_to?(:to_i) && RANGE.cover?(value.to_i)
+          end
+
+          def as_json(value)
+            value = value.to_i
+            value if RANGE.cover?(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/scalar/string_scalar.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # The String scalar type represents textual data, represented as UTF-8
+      # character sequences.
+      #
+      # See http://spec.graphql.org/June2018/#sec-String
+      class Scalar::StringScalar < Scalar
+        self.spec_object = true
+
+        desc <<~DESC
+          The String scalar type represents textual data, represented as UTF‐8 character
+          sequences.
+        DESC
+
+        class << self
+          def as_json(value)
+            value = value.to_s unless value.is_a?(String)
+            value = value.encode(Encoding::UTF_8) unless value.encoding.eql?(Encoding::UTF_8)
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/scalar/time_scalar.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # Uses as a float extension in order to transmit times (hours, minutes,
+      # and seconds) as a numeric representation of seconds and milliseconds.
+      class Scalar::TimeScalar < Scalar::FloatScalar
+        EPOCH = Time.utc(2000, 1, 1)
+
+        desc <<~MSG
+          The Time scalar type that represents a distance in time using hours,
+          minutes, seconds, and miliseconds.
+        MSG
+
+        # A +base_object+ helps to identify what methods are actually available
+        # to work as resolvers
+        class_attribute :precision, instance_writer: false, default: 6
+
+        class << self
+          def valid_input?(value)
+            value.match?(/\d+:\d\d(:\d\d(\.\d+)?)?/)
+          end
+
+          def valid_output?(value)
+            value.respond_to?(:to_time)
+          end
+
+          def as_json(value)
+            value.to_time.strftime(format('%%T.%%%dN', precision))
+          end
+
+          def deserialize(value)
+            "#{EPOCH.to_date.iso8601} #{value} UTC".to_time
+          end
+        end
+      end
+    end
+  end
+end