autographql 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b3d3b5ac363dd52787ecb2b37909b9d4b54d3220
-  data.tar.gz: b99a0e6d238f0fd26d35e306ca85cbb3cbd88845
+  metadata.gz: 2a344ec93114c212ee1fd878531ebac02deb094b
+  data.tar.gz: f4ada4a255109550cb3f35a56ec7197419a0b2e5
 SHA512:
-  metadata.gz: 69216651bc19b711674130fc03bdbb245b14a6326c5d9a7f0406e401d842d9deebdfd9f1a83df53d614249a980b09f988f402493b7ed5f6a8f8464625b9f1b32
-  data.tar.gz: 24683a0bb35dc5e79e76feaf15cc50a9e448524984bcc86b95690376864f4cdcf2fc69c88230e470b6d0430cf8b83d5d98cc9af867d787ce523f5fba4293edeb
+  metadata.gz: 6f786b1fee44164b78d3528fd43d36c982c59988022b160a1a7e6e3a851bb1c8c33ac878347a5ab0d158d7bfc5e03a799db078180cb1f016142a8135e32f3b67
+  data.tar.gz: 9e55f2c354eb9093eb338f7c7ad3e8cba4b33915ade4d5f9948f78fece6ee9d637e78a8a5fc7a627e04cf1c91ab143589910504d90d14b2e88c854370b2f6c0c

data/lib/autographql.rb

@@ -1,10 +1,11 @@
 require 'active_record'
 
 require_relative 'autographql/autographql'
+require_relative 'autographql/object_type'
 
 
 module AutoGraphQL
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end
 
 

data/lib/autographql/autographql.rb

@@ -1,49 +1,61 @@
-require 'set'
-
-require_relative 'object_type'
+require_relative 'query_builder'
 
 
 module AutoGraphQL
   extend self
 
-  @@models = Set.new
+  @@models = {}
 
 
-  # dynamically generate ::QueryType and ::ObjectTypes
-  def const_missing const
-    super unless [ :QueryType, :ObjectTypes ].include? const
+  def register model, options = {}
+    # sanitize options
 
-    if :ObjectTypes == const
-      return @@models.map(&:graphql)
-    end
+    name = options.fetch(:name, model.name)
+    name.gsub! /:/, '_'
 
-    Class.new GraphQL::Schema::Object do
-      def self.name
-        'AutoGraphQL::QueryType'
-      end
+    exclude = options.fetch(:exclude, []).map(&:to_sym)
+
+    # add `id' column by default
+    fields = [ :id ]
 
-      @@models.each do |model|
-        type = model.graphql
+    # either use user specified fields or default to all
+    fields += options.fetch(:fields) do
+      res = model.columns_hash.keys
 
-        # define field for this type
-        field type.name.downcase, type, null: true do
-          argument :id, GraphQL::Types::ID, required: true
-        end
+      # add relationships
+      res += [ :has_one, :has_many, :belongs_to ].map do |type|
+        model.reflect_on_all_associations(type).map &:name
+      end.flatten
+    end.map(&:to_sym) - exclude
 
-        # create loader
-        define_method(type.name.downcase) do |id:|
-          model.find id
-        end
+    model_methods = options.fetch(:methods, {})
+    # ensure methods actually exist
+    model_methods.each do |name, type|
+      unless model.method_defined? name
+        raise NoMethodError.new(
+          "undefined method `#{name}' for #{model}"
+        )
       end
     end
-  end
 
+    @@models[model] = {
+      name: name,
+      description: options.fetch(:description, ''),
+      fields: fields,
+      methods: model_methods,
+    }
+  end
 
-  ## private
 
-  def register model
-    @@models << model
+  # dynamically generate ::QueryType
+  def const_missing const
+    case const
+    when :QueryType
+      AutoGraphQL::QueryBuilder.build @@models
+    else
+      super
+    end
   end
-  private_class_method :register
+
 
 end

data/lib/autographql/object_type.rb

@@ -6,65 +6,12 @@ module AutoGraphQL
   module ObjectType
     protected
 
-    def graphql name: self.name, description: '', fields: [], exclude: []
-      columns = Hash[columns_hash.map {|k,v| [k.to_sym, v] }]
-      belongs_to = reflect_on_all_associations(:belongs_to)
-      # has_many = reflect_on_all_associations(:has_many)
+    def graphql options = {}
+      # register Active Record model.  delay schema generation
+      # until class and associations have been fully defined
 
-      # figure out which active record fields to expose
-      fields = Set.new(
-        (fields.empty? ? columns.keys : fields).map(&:to_sym)
-      )
-
-      # remove blacklisted fields
-      fields -= exclude.map(&:to_sym)
-
-      # remove relationships for now
-      fields -= belongs_to.map(&:association_foreign_key).map(&:to_sym)
-      # exclude += belongs_to.map(&:association_primary_key).map(&:to_sym)
-
-
-      gql_obj = GraphQL::ObjectType.define do
-        name name
-        description description
-
-        fields.each do |f|
-          type = AutoGraphQL::ObjectType.send :convert_type, columns[f].type
-          field f, type
-        end
-      end
-
-      # redefine method to return result
-      define_singleton_method(:graphql) do
-        gql_obj
-      end
-
-      # make publically available
-      singleton_class.send :public, :graphql
-
-      # register new GraphQL::ObjectType
-      AutoGraphQL.send :register, self
-    end
-
-
-    ## private
-
-    def self.convert_type type
-      # convert Active Record type to GraphQL type
-      case type
-      when :boolean
-        GraphQL::BOOLEAN_TYPE
-      when :integer
-        GraphQL::INT_TYPE
-      when :float
-        GraphQL::FLOAT_TYPE
-      when :string
-        GraphQL::STRING_TYPE
-      else
-        raise TypeError.new "unsupported type: #{type}"
-      end
+      AutoGraphQL.register self, options
     end
-    private_class_method :convert_type
 
   end
 end

data/lib/autographql/query_builder.rb

@@ -0,0 +1,38 @@
+require 'graphql'
+require 'set'
+
+require_relative 'type_builder.rb'
+
+
+module AutoGraphQL
+  module QueryBuilder
+    extend self
+
+
+    def build models_and_opts
+      # dynamically create a QueryType subclass
+      Class.new GraphQL::Schema::Object do
+        def self.name
+          'AutoGraphQL::QueryType'
+        end
+
+        type_map = AutoGraphQL::TypeBuilder.build(models_and_opts)
+
+        type_map.each do |model, type|
+          # define field for this type
+          field type.name.downcase, type, null: true do
+            argument :id, GraphQL::Types::ID, required: true
+          end
+
+          # create loader
+          define_method(type.name.downcase) do |id:|
+            model.find id
+          end
+        end
+      end
+
+    end
+
+
+  end
+end

data/lib/autographql/type_builder.rb

@@ -0,0 +1,125 @@
+require 'graphql'
+require 'set'
+
+require_relative 'types/date'
+require_relative 'types/decimal'
+require_relative 'types/json'
+
+
+module AutoGraphQL
+  module TypeBuilder
+    extend self
+
+
+    def build models_and_opts
+      # first build all objects
+      type_map = {}
+
+      models_and_opts.each do |model, opts|
+        type_map[model] = build_type model, opts
+      end
+
+      models_and_opts.each do |model, opts|
+        build_type_methods type_map[model], opts[:methods], type_map
+      end
+
+      # build relationships between objects
+      type_map.each do |model, type|
+        relate type, models_and_opts[model][:fields], type_map
+      end
+
+      type_map
+    end
+
+
+    private
+
+    def build_type model, opts
+      column_types = Hash[model.columns_hash.map do |name, column|
+        next nil unless opts[:fields].include? name.to_sym
+        [ name.to_sym, convert_type(model, column) ]
+      end.compact]
+
+      # create type
+      GraphQL::ObjectType.define do
+        name opts[:name]
+        description opts[:description]
+
+        opts[:fields].each do |f|
+          # skip relationships
+          next unless column_types[f]
+
+          field f, column_types[f]
+        end
+      end
+    end
+
+
+    def build_type_methods gql_type, methods, type_map
+      methods.each do |name, type|
+        name = name.to_s
+
+        if type_map.include? type
+          type = type_map[type]
+        end
+
+        field = GraphQL::Field.define do
+          name name
+          type type
+        end
+
+        gql_type.fields[name] = field
+      end
+    end
+
+
+    def relate type, fields, type_map
+      model = type_map.key type
+
+      belongs_to = model.reflect_on_all_associations(:belongs_to)
+      has_one = model.reflect_on_all_associations(:has_one)
+      has_many = model.reflect_on_all_associations(:has_many)
+
+      (belongs_to + has_one + has_many).each do |field|
+        next unless fields.include? field.name.to_sym
+        next unless type_map[field.klass]
+
+        field_type = type_map[field.klass]
+        if has_many.include? field
+          # make into a list
+          field_type = field_type.to_list_type.to_non_null_type
+        end
+
+        # create relationship field
+        gql_field = GraphQL::Field.define do
+          name field.name.to_s
+          type field_type
+        end
+
+        type.fields[field.name.to_s] = gql_field
+      end
+    end
+
+
+    # convert Active Record type to GraphQL type
+    def convert_type model, column
+      {
+        boolean: GraphQL::BOOLEAN_TYPE,
+        date: GraphQL::Types::DATE,
+        datetime: GraphQL::Types::ISO8601DateTime,
+        decimal: GraphQL::Types::DECIMAL,
+        float: GraphQL::FLOAT_TYPE,
+        integer: GraphQL::INT_TYPE,
+        json: GraphQL::Types::JSON,
+        string: GraphQL::STRING_TYPE,
+        text: GraphQL::STRING_TYPE,
+      }.fetch column.type do
+        raise TypeError.new(
+          "unsupported type: '#{column.type}' for #{model.name}::#{column.name}"
+        )
+      end
+    end
+
+
+  end
+end

data/lib/autographql/types/date.rb

@@ -0,0 +1,16 @@
+GraphQL::Types::DATE = GraphQL::ScalarType.define do
+  name 'DATE'
+  description 'Date formatted as YYYY-MM-DD  (ISO 8601)'
+
+  coerce_result ->(value, ctx) do
+    value.to_s
+  end
+
+  coerce_input ->(value, ctx) do
+    begin
+      Date.parse(value)
+    rescue ArgumentError => e
+      nil
+    end
+  end
+end

data/lib/autographql/types/decimal.rb

@@ -0,0 +1,17 @@
+GraphQL::Types::DECIMAL = GraphQL::ScalarType.define do
+  name 'DECIMAL'
+
+  coerce_result ->(value, ctx) do
+    value.to_s
+  end
+
+  coerce_input ->(value, ctx) do
+    begin
+      BigDecimal(value)
+    rescue TypeError => e
+      nil
+    end
+  end
+end
+
+# TODO: include precision

data/lib/autographql/types/json.rb

@@ -0,0 +1,16 @@
+GraphQL::Types::JSON = GraphQL::ScalarType.define do
+  name 'JSON'
+
+  coerce_result ->(value, ctx) do
+    # TODO: handle nil case, which doesn't call coerce
+    JSON.dump value
+  end
+
+  coerce_input ->(value, ctx) do
+    begin
+      JSON.parse value
+    rescue JSON::ParserError => e
+      raise GraphQL::CoercionError, e.message
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: autographql
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-03 00:00:00.000000000 Z
+date: 2018-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -103,6 +103,11 @@ files:
 - lib/autographql.rb
 - lib/autographql/autographql.rb
 - lib/autographql/object_type.rb
+- lib/autographql/query_builder.rb
+- lib/autographql/type_builder.rb
+- lib/autographql/types/date.rb
+- lib/autographql/types/decimal.rb
+- lib/autographql/types/json.rb
 - test/test_auto.rb
 - test/test_basic_graphql.rb
 - test/test_models.rb