graphiti_gql 0.1.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85aecb8badace989fe7f60f3187c189a2d73ce0e99fd4725a8388ed01f2a9cd0
-  data.tar.gz: 488756eb837219bde85b23a015bd6b6081fa2857c753c3e1837ab0fb7c758dc8
+  metadata.gz: 899580a6d3577a31dc7356d894eab26756c2c9876636db69ce5ece2d5eeee3ce
+  data.tar.gz: faf261a7614a0565c9dc3e45b4a9d14d75962aa6665b7302752733584abb5bdc
 SHA512:
-  metadata.gz: ef8b222b5b932bbcb6f21cb8a9480341499086b3daffbb85657af89e208c7b639c4b75fc1ec7f432edb818673ae1e971689fc3f940d11176721a651220f60325
-  data.tar.gz: 867db73b474375ab9189aa421c953f1ebb008f94ea906d163a4e70f6059ec7df3a699199322cd276f0227d6eebb80d15958587530a8e9e2282ad010139e8e926
+  metadata.gz: becebe36d5aabea0a75ba3e617f9f62d0830d3f4a35e5becdacef1fbe10f4991621f061521f10bc4c0e527bdc834d5380e9f38ff0b9cc2388a66a7cf25bb33b8
+  data.tar.gz: 37a9a4221261f112100e32f06832a948c30cbef5a06ffcb786f080538c1b9f3894bd3f7f8fc32394f0c2cb122e94c1b1e58cd6b8c38b6e0feab08a30d55bbfb5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphiti_gql (0.1.0)
+    graphiti_gql (0.2.1)
       graphiti (~> 1.3.9)
       graphql (~> 2.0)
       graphql-batch (~> 0.5)

data/README.md

@@ -1,3 +1,90 @@
 # GraphitiGql
 
-asdf
+GraphQL bindings for [Graphiti](www.graphiti.dev).
+
+Write code like this:
+
+```ruby
+class EmployeeResource < ApplicationResource
+  attribute :first_name, :string
+  attribute :age, :integer
+  
+  has_many :positions
+end
+```
+
+Get an API like this:
+
+```gql
+query {
+  employees(
+    filter: { firstName: { match: "arha" } },
+    sort: [{ att: age, dir: desc }],
+    first: 10,
+    after: "abc123"
+  ) {
+    edges {
+      node {
+        id
+        firstName
+        age
+        positions {
+          nodes {
+            title
+          }
+        }
+      }
+      cursor
+    }
+    stats {
+      total {
+        count
+      }
+    }
+  }
+}
+```
+
+### Getting Started
+
+```ruby
+# Gemfile
+gem 'graphiti'
+gem "graphiti-rails"
+gem 'graphiti_gql'
+```
+
+```ruby
+# config/routes.rb
+
+Rails.application.routes.draw do
+  scope path: ApplicationResource.endpoint_namespace do
+    mount GraphitiGql::Engine, at: "/gql"
+  end
+end
+```
+
+Write your Graphiti code as normal, omit controllers.
+
+### How does it work?
+
+This autogenerates `graphql-ruby` code by introspecting Graphiti Resources. Something like this happens under-the-hood:
+
+```ruby
+field :employees, [EmployeeType], null: false do
+  argument :filter, EmployeeFilter, required: false
+  # ... etc ...
+end
+
+def employees(**arguments)
+  EmployeeResource.all(**arguments).to_a
+end
+```
+
+In practice it's more complicated, but this is the basic premise - use Graphiti resources to handle query and persistence operations; autogenerate `graphql-ruby` code to expose those Resources as an API. This means we play nicely with e.g. telemetry and error-handling libraries because it's all `graphql-ruby` under-the-hood...except for actually **performing** the operations, which is really more a Ruby thing than a GraphQL thing.
+
+### Caveats
+
+This rethinks the responsibilities of Graphiti, coupling the execution cycle to `graphql-ruby`. We do this so we can play nicely with other gems in the GQL ecosystem, and saves on development time by offloading responsibilities. The downside is we can no longer run a `JSON:API` with the same codebase, and certain documentation may be out of date.
+
+Longer-term, we should rip out only the parts of Graphiti we really need and redocument.

data/lib/graphiti_gql/active_resource.rb

@@ -0,0 +1,210 @@
+module GraphitiGql
+  module ActiveResource
+    extend ActiveSupport::Concern
+
+    class Node < OpenStruct
+      def initialize(resource, hash)
+        @resource = resource
+        hash.each_pair do |key, value|
+          if value.is_a?(Hash)
+            if (sideload = resource.sideload(key))
+              if value.key?(:edges) 
+                hash[key] = value[:edges].map { |v| Node.new(sideload.resource.class, v[:node]) }
+              else
+                hash[key] = Node.new(sideload.resource.class, value)
+              end
+            end
+          end
+        end
+        super(hash)
+      end
+
+      def decoded_id
+        Base64.decode64(self.id)
+      end
+
+      def int_id
+        decoded_id.to_i
+      end
+    end
+
+    class Proxy
+      def initialize(resource, params, ctx)
+        @resource = resource
+        @ctx = ctx
+        @params = params.deep_transform_keys { |key| key.to_s.camelize(:lower).to_sym }
+        (@params[:sort] || []).each do |sort|
+          sort[:att] = sort[:att].to_s.camelize(:lower)
+          sort[:dir] = sort[:dir].to_s
+        end
+      end
+
+      def to_h(symbolize_keys: true)
+        result = GraphitiGql.run(query, @params, @ctx)
+        result = result.deep_symbolize_keys if symbolize_keys
+        @response = result
+        result
+      end
+
+      def nodes
+        return [] unless data
+        nodes = edges.map { |e| underscore(e[:node]) }
+        nodes.map { |n| Node.new(@resource, n) }
+      end
+      alias :to_a :nodes
+
+      def response
+        @response ||= to_h
+      end
+
+      def data
+        if response.key?(:data)
+          response[:data]
+        else
+          raise "Tried to access 'data', but these errors were returned instead: #{error_messages.join(". ")}."
+        end
+      end
+
+      def errors
+        response[:errors]
+      end
+  
+      def error_messages
+        response[:errors].map { |e| e[:message] }
+      end
+
+      def edges
+        data[data.keys.first][:edges]
+      end
+  
+      def stats
+        underscore(data[data.keys.first][:stats])
+      end
+  
+      def page_info
+        underscore(data[data.keys.first][:pageInfo])
+      end
+
+      def query
+        name = Schema.registry.key_for(@resource)
+        filter_bang = "!" if @resource.filters.values.any? { |f| f[:required] }
+        sortvar = "$sort: [#{name}Sort!]," if @resource.sorts.any?
+
+        if !(fields = @params[:fields])
+          fields = []
+          @resource.attributes.each_pair do |name, config|
+            (fields << name) if config[:readable]
+          end
+        end
+
+        q = %|
+          query #{name} (
+            $filter: #{name}Filter#{filter_bang},
+            #{sortvar}
+            $first: Int,
+            $last: Int,
+            $before: String,
+            $after: String,
+          ) {
+            #{@resource.graphql_entrypoint} (
+              filter: $filter,
+              #{ 'sort: $sort,' if sortvar }
+              first: $first,
+              last: $last,
+              before: $before,
+              after: $after,
+            ) {
+              edges {
+                node {|
+
+        fields.each do |name|
+          q << %|
+                  #{name.to_s.camelize(:lower)}|
+        end
+
+        if @params[:include]
+          includes = Array(@params[:include])
+          # NB HASH (?)
+          includes.each do |inc|
+            sideload = @resource.sideload(inc.to_sym)
+            to_one = [:belongs_to, :has_one, :polymorphic_belongs_to].include?(sideload.type)
+            indent = "    " if !to_one
+            q << %|
+                  #{inc.to_s.camelize(:lower)} {|
+            if !to_one
+              q << %|
+                    edges {
+                      node {|
+            end
+
+            r = @resource.sideload(inc.to_sym).resource
+            r.attributes.each_pair do |name, config|
+              next unless config[:readable]
+              q << %|
+                    #{indent}#{name.to_s.camelize(:lower)}|
+            end
+
+            if to_one
+              q << %|
+                  }|
+            else
+              q << %|
+                      }
+                    }
+                  }|
+            end
+          end
+        end
+  
+        q << %|
+                }
+              }
+              pageInfo {
+                startCursor
+                endCursor
+                hasNextPage
+                hasPreviousPage
+              }|
+
+        if @params[:stats]
+          q << %|
+              stats {|
+          @params[:stats].each_pair do |name, calculations|
+            q << %|
+                #{name.to_s.camelize(:lower)} {|
+            Array(calculations).each do |calc|
+              q << %|
+                  #{calc.to_s.camelize(:lower)}|
+            end
+    
+            q << %|
+                }|
+          end
+          q << %|
+              }|          
+        end
+
+        q << %|
+            }
+          }
+        |
+
+        q
+      end
+
+      private
+
+      def underscore(hash)
+        hash.deep_transform_keys { |k| k.to_s.underscore.to_sym }
+      end
+    end
+
+    class_methods do
+      def gql(params = {}, ctx = {})
+        Proxy.new(self, params, ctx)
+      end
+    end
+  end
+end
+
+Graphiti::Resource.send(:include, GraphitiGql::ActiveResource)

data/lib/graphiti_gql/engine.rb

@@ -2,27 +2,42 @@ module GraphitiGql
   class Engine < ::Rails::Engine
     isolate_namespace GraphitiGql
 
+    # TODO improvable?
     config.after_initialize do
     # initializer "graphiti_gql.generate_schema" do
       Dir.glob("#{Rails.root}/app/resources/**/*").each { |f| require(f) }
       GraphitiGql.schema!
     end
 
+    module ControllerContext
+      def graphql_context
+        ctx = { controller: self }
+        ctx[:current_user] = current_user if respond_to?(:current_user)
+        ctx
+      end
+    end
+
     initializer "graphiti_gql.define_controller" do
       require "#{Rails.root}/app/controllers/application_controller"
-      app_controller = ::ApplicationController # todo
+      app_controller = GraphitiGql.config.application_controller || ::ApplicationController
+      app_controller.send(:include, ControllerContext)
 
       # rubocop:disable Lint/ConstantDefinitionInBlock(Standard)
       class GraphitiGql::ExecutionController < app_controller
-        # register_exception Graphiti::Errors::UnreadableAttribute, message: true
         def execute
           params = request.params # avoid strong_parameters
           variables = params[:variables] || {}
           result = GraphitiGql.run params[:query],
             params[:variables],
-            { current_user: current_user }
+            graphql_context
           render json: result
         end
+
+        private
+
+        def default_context
+          defined?(:current_user)
+        end
       end
     end
   end

data/lib/graphiti_gql/errors.rb

@@ -17,5 +17,21 @@ module GraphitiGql
         "You are not authorized to read field #{@field}"
       end
     end
+
+    class NullFilter < Base
+      def initialize(name)
+        @name = name
+      end
+
+      def message
+        "Filter '#{@name}' does not support null"
+      end
+    end
+
+    class UnsupportedLast < Base
+      def message
+        "We do not currently support combining 'last' with 'before' or 'after'"
+      end
+    end
   end
 end

data/lib/graphiti_gql/graphiti_hax.rb

@@ -1,71 +1,251 @@
 # These should be in Graphiti itself, but can't do it quite yet b/c GQL coupling.
 # Ideally we eventually rip out the parts of Graphiti we need and roll this into
 # that effort.
-module ResourceExtras
-  extend ActiveSupport::Concern
+module GraphitiGql
+  module ResourceExtras
+    extend ActiveSupport::Concern
 
-  included do
-    class << self
-      attr_accessor :graphql_name
+    included do
+      class << self
+        attr_accessor :graphql_name
+      end
+    end
+
+    class_methods do
+      def attribute(*args)
+        super(*args).tap do
+          opts = args.extract_options!
+          att = config[:attributes][args[0]]
+          att[:deprecation_reason] = opts[:deprecation_reason]
+          att[:null] = opts.key?(:null) ? opts[:null] : args[0] != :id
+          att[:name] = args.first # for easier lookup
+        end
+      end
+    end
+  end
+  Graphiti::Resource.send(:include, ResourceExtras)
+
+  module FilterExtras
+    def filter_param
+      default_filter = resource.default_filter if resource.respond_to?(:default_filter)
+      default_filter ||= {}
+      default_filter.merge(super)
+    end
+
+    def each_filter
+      super do |filter, operator, value|
+        unless filter.values[0][:allow_nil]
+          has_nil = value.nil? || value.is_a?(Array) && value.any?(&:nil?)
+          raise Errors::NullFilter.new(filter.keys.first) if has_nil
+        end
+        yield filter, operator, value
+      end
+    end
+
+    # Only for alias, tiny diff
+    def filter_via_adapter(filter, operator, value)
+      type_name = ::Graphiti::Types.name_for(filter.values.first[:type])
+      method = :"filter_#{type_name}_#{operator}"
+      name = filter.keys.first
+      name = resource.all_attributes[name][:alias] || name
+
+      if resource.adapter.respond_to?(method)
+        resource.adapter.send(method, @scope, name, value)
+      else
+        raise ::Graphiti::Errors::AdapterNotImplemented.new \
+          resource.adapter, name, method
+      end
+    end
+  end
+  Graphiti::Scoping::Filter.send(:prepend, FilterExtras)
+
+  module SortAliasExtras
+    def each_sort
+      sort_param.each do |sort_hash|
+        name = sort_hash.keys.first
+        name = resource.all_attributes[name][:alias] || name
+        direction = sort_hash.values.first
+        yield name, direction
+      end
+    end
+  end
+  Graphiti::Scoping::Sort.send(:prepend, SortAliasExtras)
+
+  module PaginateExtras
+    def apply
+      if query_hash[:reverse] && (before_cursor || after_cursor)
+        raise ::GraphitiGql::Errors::UnsupportedLast
+      end
+      super
+    end
+
+    def offset
+      offset = 0
+
+      if (value = page_param[:offset])
+        offset = value.to_i
+      end
+
+      if before_cursor&.key?(:offset)
+        if page_param.key?(:number)
+          raise Errors::UnsupportedBeforeCursor
+        end
+
+        offset = before_cursor[:offset] - (size * number) - 1
+        offset = 0 if offset.negative?
+      end
+
+      if after_cursor&.key?(:offset)
+        offset = after_cursor[:offset]
+      end
+
+      offset
     end
+
+    # TODO memoize
+    def size
+      size = super
+      if before_cursor && after_cursor
+        diff = before_cursor[:offset] - after_cursor[:offset] - 1
+        size = [size, diff].min
+      elsif before_cursor
+        comparator = query_hash[:reverse] ? :>= : :<=
+        if before_cursor[:offset].send(comparator, size)
+          diff = before_cursor[:offset] - size
+          size = [size, diff].min
+          size = 1 if size.zero?
+        end
+      end
+      size
+    end
+  end
+  Graphiti::Scoping::Paginate.send(:prepend, PaginateExtras)
+
+  module ManyToManyExtras
+    extend ActiveSupport::Concern
+
+    class_methods do
+      attr_accessor :edge_resource
+
+      def attribute(*args, &blk)
+        @edge_resource = Class.new(Graphiti::Resource) do
+          def self.abstract_class?
+            true
+          end
+        end
+        @edge_resource.attribute(*args, &blk)
+      end
+    end
+  end
+  Graphiti::Sideload::ManyToMany.send(:include, ManyToManyExtras)
+
+  module StatsExtras
+    def calculate_stat(name, function)
+      config = @resource.all_attributes[name] || {}
+      name = config[:alias] || name
+      super(name, function)
+    end
+  end
+  Graphiti::Stats::Payload.send(:prepend, StatsExtras)
+
+  Graphiti::Types[:big_integer] = Graphiti::Types[:integer].dup
+  Graphiti::Types[:big_integer][:graphql_type] = ::GraphQL::Types::BigInt
+
+  ######## support precise_datetime ###########
+  #############################################
+  definition = Dry::Types::Nominal.new(String)
+  _out = definition.constructor do |input|
+    input.utc.round(10).iso8601(6)
+  end
+
+  _in = definition.constructor do |input|
+    Time.zone.parse(input)
   end
 
-  class_methods do
-    def attribute(*args)
-      super(*args).tap do
-        opts = args.extract_options!
-        att = config[:attributes][args[0]]
-        att[:deprecation_reason] = opts[:deprecation_reason]
-        att[:null] = opts.key?(:null) ? opts[:null] : args[0] != :id
+  # Register it with Graphiti
+  Graphiti::Types[:precise_datetime] = {
+    params: _in,
+    read: _out,
+    write: _in,
+    kind: 'scalar',
+    canonical_name: :precise_datetime,
+    description: 'Datetime with milliseconds'
+  }
+
+  module ActiveRecordAdapterExtras
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method :filter_precise_datetime_lt, :filter_lt
+      alias_method :filter_precise_datetime_lte, :filter_lte
+      alias_method :filter_precise_datetime_gt, :filter_gt
+      alias_method :filter_precise_datetime_gte, :filter_gte
+      alias_method :filter_precise_datetime_eq, :filter_eq
+      alias_method :filter_precise_datetime_not_eq, :filter_not_eq
+    end
+  end
+  if defined?(Graphiti::Adapters::ActiveRecord)
+    Graphiti::Adapters::ActiveRecord.send(:include, ActiveRecordAdapterExtras)
+  end
+
+  Graphiti::Adapters::Abstract.class_eval do
+    class << self
+      alias :old_default_operators :default_operators
+      def default_operators
+        old_default_operators.merge(precise_datetime: numerical_operators)
       end
     end
   end
-end
-
-Graphiti::Resource.send(:include, ResourceExtras)
-
-module FilterExtras
-  def filter_param
-    default_filter = resource.default_filter if resource.respond_to?(:default_filter)
-    default_filter ||= {}
-    default_filter.merge(super)
-  end
-end
-Graphiti::Scoping::Filter.send(:prepend, FilterExtras)
-
-# ==================================================
-# Below is all to support pagination argument 'last'
-# ==================================================
-module SortExtras
-  def sort_param
-    param = super
-    if query_hash[:reverse]
-      param = [{ id: :asc }] if param == []
-      param = param.map do |p|
-        {}.tap do |hash|
-          dir = p[p.keys.first]
-          dir = dir == :asc ? :desc : :asc
-          hash[p.keys.first] = dir
+  ########## end support precise_datetime ############
+
+  # ==================================================
+  # Below is all to support pagination argument 'last'
+  # ==================================================
+  module SortExtras
+    def sort_param
+      param = super
+      if query_hash[:reverse]
+        param = [{ id: :asc }] if param == []
+        param = param.map do |p|
+          {}.tap do |hash|
+            dir = p[p.keys.first]
+            dir = dir == :asc ? :desc : :asc
+            hash[p.keys.first] = dir
+          end
         end
       end
+      param
     end
-    param
-  end
-end
-Graphiti::Scoping::Sort.send(:prepend, SortExtras)
-module QueryExtras
-  def hash
-    hash = super
-    hash[:reverse] = true if @params[:reverse]
-    hash
-  end
-end
-Graphiti::Query.send(:prepend, QueryExtras)
-module ScopeExtras
-  def resolve(*args)
-    results = super
-    results.reverse! if @query.hash[:reverse]
-    results
-  end
-end
-Graphiti::Scope.send(:prepend, ScopeExtras)
+  end
+  Graphiti::Scoping::Sort.send(:prepend, SortExtras)
+  module QueryExtras
+    def hash
+      hash = super
+      hash[:reverse] = true if @params[:reverse]
+      hash
+    end
+  end
+  
+  Graphiti::Query.send(:prepend, QueryExtras)
+  module ScopeExtras
+    def resolve(*args)
+      results = super
+      results.reverse! if @query.hash[:reverse]
+      results
+    end
+  end
+  Graphiti::Scope.send(:prepend, ScopeExtras)
+
+  module ActiveRecordManyToManyExtras
+    # flipping .includes to .joins
+    def belongs_to_many_filter(scope, value)
+      scope
+        .joins(through_relationship_name)
+        .where(belongs_to_many_clause(value, type))
+    end
+  end
+  if defined?(ActiveRecord)
+    ::Graphiti::Adapters::ActiveRecord::ManyToManySideload
+      .send(:prepend, ActiveRecordManyToManyExtras)
+  end
+end

data/lib/graphiti_gql/loaders/many_to_many.rb

@@ -2,15 +2,32 @@ module GraphitiGql
   module Loaders
     class ManyToMany < Many
       def assign(ids, proxy)
-        records = proxy.data
         thru = @sideload.foreign_key.keys.first
         fk = @sideload.foreign_key[thru]
+        add_join_table_magic(proxy)
+        records = proxy.data
         ids.each do |id|
-          match = ->(thru) { thru.send(fk) == id }
-          corresponding = records.select { |record| record.send(thru).any?(&match) }
+          corresponding = records.select do |record|
+            record.send(:"_edge_#{fk}") == id
+          end
           fulfill(id, [corresponding, proxy])
         end
       end
+
+      private
+
+      def add_join_table_magic(proxy)
+        if defined?(ActiveRecord) && proxy.resource.model.ancestors.include?(ActiveRecord::Base)
+          thru = @sideload.foreign_key.keys.first
+          thru_model = proxy.resource.model.reflect_on_association(thru).klass
+          names = thru_model.column_names.map do |n|
+            "#{thru_model.table_name}.#{n} as _edge_#{n}"
+          end
+          scope = proxy.scope.object
+          scope = scope.select(["#{proxy.resource.model.table_name}.*"] + names)
+          proxy.scope.object = scope
+        end
+      end
     end
   end
 end

data/lib/graphiti_gql/schema/fields/attribute.rb

@@ -2,29 +2,52 @@ module GraphitiGql
   class Schema
     module Fields
       class Attribute
-        def initialize(name, config)
-          @name = name
+        # If sideload is present, we're applying m2m metadata to an edge
+        def initialize(name, config, sideload = nil)
           @config = config
+          @name = name
+          @alias = config[:alias]
+          @sideload = sideload # is_edge: true
         end
 
         def apply(type)
           is_nullable = !!@config[:null]
           _config = @config
           _name = @name
+          _alias = @alias 
+          _sideload = @sideload
           opts = @config.slice(:null, :deprecation_reason)
-          type.field(@name, field_type, **opts)
-          type.define_method @name do
+          type.field(_name, field_type, **opts)
+          type.define_method _name do
             if (readable = _config[:readable]).is_a?(Symbol)
-              resource = object.instance_variable_get(:@__graphiti_resource)
+              obj = object
+              obj = object.node if _sideload
+              resource = obj.instance_variable_get(:@__graphiti_resource)
               unless resource.send(readable)
                 path = Graphiti.context[:object][:current_path].join(".")
                 raise Errors::UnauthorizedField.new(path)
               end
             end
+
+            edge_attrs = nil
+            if _sideload
+              edge_attrs = object.node.attributes
+                .select { |k, v| k.to_s.starts_with?("_edge_") }
+              edge_attrs.transform_keys! { |k| k.to_s.gsub("_edge_", "").to_sym }
+            end
+
             value = if _config[:proc]
-              instance_eval(&_config[:proc])
+              if _sideload
+                instance_exec(edge_attrs, &_config[:proc])
+              else
+                instance_eval(&_config[:proc])
+              end
             else
-              object.send(_name)
+              if _sideload
+                edge_attrs[_alias || _name]
+              else
+                object.send(_alias || _name)
+              end
             end
             return if value.nil?
             Graphiti::Types[_config[:type]][:read].call(value)
@@ -34,9 +57,12 @@ module GraphitiGql
         private
 
         def field_type
-          canonical_graphiti_type = Graphiti::Types.name_for(@config[:type])
-          field_type = GQL_TYPE_MAP[canonical_graphiti_type.to_sym]
-          field_type = String if @name == :id
+          field_type = Graphiti::Types[@config[:type]][:graphql_type]
+          if !field_type
+            canonical_graphiti_type = Graphiti::Types.name_for(@config[:type])
+            field_type = GQL_TYPE_MAP[canonical_graphiti_type.to_sym]
+            field_type = String if @name == :id
+          end
           field_type = [field_type] if @config[:type].to_s.starts_with?("array_of")
           field_type
         end

data/lib/graphiti_gql/schema/fields/stats.rb

@@ -29,7 +29,7 @@ module GraphitiGql
           name = Registry.instance.key_for(@resource)
           stat_graphql_name = "#{name}Stats"
           return Registry.instance[stat_graphql_name][:type] if Registry.instance[stat_graphql_name]
-          klass = Class.new(GraphQL::Schema::Object)
+          klass = Class.new(Schema.base_object)
           klass.graphql_name(stat_graphql_name)
           @resource.stats.each_pair do |name, config|
             calc_class = build_calc_class(stat_graphql_name, name, config.calculations.keys)
@@ -41,7 +41,7 @@ module GraphitiGql
     
         def build_calc_class(stat_graphql_name, stat_name, calculations)
           name = "#{stat_graphql_name}#{stat_name}Calculations"
-          klass = Class.new(GraphQL::Schema::Object)
+          klass = Class.new(Schema.base_object)
           klass.graphql_name(name)
           calculations.each do |calc|
             klass.field calc, Float, null: false

data/lib/graphiti_gql/schema/fields/to_many.rb

@@ -4,7 +4,11 @@ module GraphitiGql
       class ToMany
         def initialize(sideload, sideload_type)
           @sideload = sideload
-          @sideload_type = sideload_type
+          @sideload_type = if customized_edge?
+              build_customized_edge_type(sideload_type)
+            else
+              sideload_type
+            end
         end
 
         def apply(type)
@@ -31,6 +35,33 @@ module GraphitiGql
             Loaders::Many.factory(_sideload, params).load(id)
           end
         end
+
+        private
+
+        def customized_edge?
+          @sideload.type == :many_to_many && @sideload.class.edge_resource
+        end
+
+        def build_customized_edge_type(sideload_type)
+          # build the edge class
+          prior_edge_class = sideload_type.edge_type_class
+          edge_class = Class.new(prior_edge_class)
+          edge_resource = @sideload.class.edge_resource
+          edge_resource.attributes.each_pair do |name, config|
+            next if name == :id
+            Schema::Fields::Attribute.new(name, config, @sideload).apply(edge_class)
+          end
+          registered_parent = Schema.registry.get(@sideload.parent_resource.class)
+          parent_name = registered_parent[:type].graphql_name
+          edge_class.define_method :graphql_name do
+            "#{parent_name}To#{sideload_type.graphql_name}Edge"
+          end
+
+          # build the sideload type with new edge class applied
+          klass = Class.new(sideload_type)
+          klass.edge_type_class(edge_class)
+          klass
+        end
       end
     end
   end

data/lib/graphiti_gql/schema/list_arguments.rb

@@ -58,18 +58,21 @@ module GraphitiGql
         filter_graphql_name = "#{type_name}Filter#{filter_name.to_s.camelize(:lower)}"
         klass.graphql_name(filter_graphql_name)
         filter_config[:operators].keys.each do |operator|
-          canonical_graphiti_type = Graphiti::Types
-            .name_for(filter_config[:type])
-          type = GQL_TYPE_MAP[canonical_graphiti_type]
-          type = String if filter_name == :id
-          required = !!filter_config[:required] && operator == "eq"
-  
+          graphiti_type = Graphiti::Types[filter_config[:type]]
+          type = graphiti_type[:graphql_type]
+          if !type
+            canonical_graphiti_type = Graphiti::Types
+              .name_for(filter_config[:type])
+            type = GQL_TYPE_MAP[canonical_graphiti_type]
+            type = String if filter_name == :id
+          end
+
           if (allowlist = filter_config[:allow])
             type = define_allowlist_type(filter_graphql_name, allowlist)
           end
   
           type = [type] unless !!filter_config[:single]
-          klass.argument operator, type, required: required
+          klass.argument operator, type, required: false
         end
         klass
       end

data/lib/graphiti_gql/schema/query.rb

@@ -3,9 +3,8 @@ module GraphitiGql
     class Query
       def initialize(resources, existing_query: nil)
         @resources = resources
-        @query_class = Class.new(existing_query || ::GraphQL::Schema::Object)
+        @query_class = Class.new(existing_query || Schema.base_object)
         @query_class.graphql_name "Query"
-        @query_class.field_class ::GraphQL::Schema::Field
       end
 
       def build

data/lib/graphiti_gql/schema/resource_type.rb

@@ -68,7 +68,7 @@ module GraphitiGql
             Registry.instance[registry_name][:type]
           end
         else
-          klass = Class.new(GraphQL::Schema::Object)
+          klass = Class.new(Schema.base_object)
         end
 
         klass

data/lib/graphiti_gql/schema.rb

@@ -1,21 +1,28 @@
 module GraphitiGql
   class Schema
+    class PreciseDatetime < GraphQL::Types::ISO8601DateTime
+      self.time_precision = 6
+    end
+
     GQL_TYPE_MAP = {
       integer_id: String,
       string: String,
       uuid: String,
       integer: Integer,
+      big_integer: GraphQL::Types::BigInt,
       float: Float,
       boolean: GraphQL::Schema::Member::GraphQLTypeNames::Boolean,
       date: GraphQL::Types::ISO8601Date,
       datetime: GraphQL::Types::ISO8601DateTime,
+      precise_datetime: PreciseDatetime,
       hash: GraphQL::Types::JSON,
       array: [GraphQL::Types::JSON],
       array_of_strings: [String],
       array_of_integers: [Integer],
       array_of_floats: [Float],
       array_of_dates: [GraphQL::Types::ISO8601Date],
-      array_of_datetimes: [GraphQL::Types::ISO8601DateTime]
+      array_of_datetimes: [GraphQL::Types::ISO8601DateTime],
+      array_of_precise_datetimes: [PreciseDatetime]
     }
 
     class RelayConnectionExtension < GraphQL::Schema::Field::ConnectionExtension
@@ -25,6 +32,29 @@ module GraphitiGql
       end
     end
 
+    def self.base_object
+      klass = Class.new(GraphQL::Schema::Object)
+      # TODO make this config maybe
+      if defined?(ActionView)
+        klass.send(:include, ActionView::Helpers::TranslationHelper)
+        klass.class_eval do
+          def initialize(*)
+            super
+            @virtual_path = "."
+          end
+        end
+      end
+      klass
+    end
+
+    def self.registry
+      Registry.instance
+    end
+
+    def self.print
+      GraphQL::Schema::Printer.print_schema(GraphitiGql.schema)
+    end
+
     def initialize(resources)
       @resources = resources
     end
@@ -35,6 +65,7 @@ module GraphitiGql
       klass.use(GraphQL::Batch)
       klass.connections.add(ResponseShim, Connection)
       klass.connections.add(Array, ToManyConnection)
+      klass.orphan_types [GraphQL::Types::JSON]
       klass
     end
   end

data/lib/graphiti_gql/spec_helper.rb

@@ -0,0 +1,45 @@
+module GraphitiGql
+  module SpecHelper
+    extend ActiveSupport::Concern
+
+    included do
+      extend Forwardable
+      def_delegators :result,
+        :page_info,
+        :errors,
+        :error_messages,
+        :nodes,
+        :stats
+
+      if defined?(RSpec)
+        let(:params) { {} }
+        let(:resource) { described_class }
+        let(:ctx) { {} }
+      end
+    end
+
+    def gql_datetime(timestamp, precise = false)
+      if precise
+        timestamp.utc.round(10).iso8601(6)
+      else
+        DateTime.parse(timestamp.to_s).iso8601
+      end
+    end
+
+    def run
+      lambda do
+        proxy = resource.gql(params, ctx)
+        proxy.to_h
+        proxy
+      end
+    end
+
+    def run!
+      @result = run.call
+    end
+
+    def result
+      @result ||= run!
+    end
+  end
+end

data/lib/graphiti_gql/version.rb

@@ -1,3 +1,3 @@
 module GraphitiGql
-  VERSION = "0.1.0"
+  VERSION = "0.2.2"
 end

data/lib/graphiti_gql.rb

@@ -24,11 +24,16 @@ require "graphiti_gql/schema/fields/to_many"
 require "graphiti_gql/schema/fields/to_one"
 require "graphiti_gql/schema/fields/attribute"
 require "graphiti_gql/schema/fields/stats"
+require "graphiti_gql/active_resource"
 require "graphiti_gql/engine" if defined?(Rails)
 
 module GraphitiGql
   class Error < StandardError; end
 
+  class Configuration
+    attr_accessor :application_controller
+  end
+
   def self.schema!
     Schema::Registry.instance.clear
     resources ||= Graphiti.resources.reject(&:abstract_class?)
@@ -39,6 +44,14 @@ module GraphitiGql
     @schema
   end
 
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.configure
+    yield config
+  end
+
   def self.entrypoints=(val)
     @entrypoints = val
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti_gql
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Lee Richmond
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-03 00:00:00.000000000 Z
+date: 2022-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -137,6 +137,7 @@ files:
 - config/routes.rb
 - graphiti_gql.gemspec
 - lib/graphiti_gql.rb
+- lib/graphiti_gql/active_resource.rb
 - lib/graphiti_gql/engine.rb
 - lib/graphiti_gql/errors.rb
 - lib/graphiti_gql/graphiti_hax.rb
@@ -160,6 +161,7 @@ files:
 - lib/graphiti_gql/schema/registry.rb
 - lib/graphiti_gql/schema/resource_type.rb
 - lib/graphiti_gql/schema/util.rb
+- lib/graphiti_gql/spec_helper.rb
 - lib/graphiti_gql/version.rb
 homepage: https://www.graphiti.dev
 licenses: