graphiti_gql 0.2.0 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a19fd68dc698b8a7284fe80686da9f50ee137365508241cd374e32aa6c505aa
-  data.tar.gz: d509f137452b90e94986c46267f8728160021de305e599ba47512af9366fe109
+  metadata.gz: 5d9dda0537212e47943587af28d28226e8ee6a4ad0d91b65f5074003ab370f17
+  data.tar.gz: 222fb453e4f73c6e4d0de606bae88aea041b23c48ba28355f575025dff7e3c92
 SHA512:
-  metadata.gz: 22f8643e779d272d806d53179e5f83e6ca6157fc8c261e03ea3232fdf685faa35ad50c70bd3f5f0f445b8bd4578e616b9a538c9205e330a301a30f370b2c612a
-  data.tar.gz: ec6e08b56162dc2bb077bfd3cfc5fb5dcf8edcdc3680d940347eb33949f8530967e6d828e0b914f0920a406bad4807d83c643981f9ab0136dd7a3e9e422e068a
+  metadata.gz: 8e5a6a8d98b058fb8237750190e6f051712d2f90f5bf49be615f68a594598589afb1811aec0f0fbe79bbcefd457d27a6cf78e84e8e90d539168da9ffd13b9a64
+  data.tar.gz: 6515ba7accff3edb9490028bc3545f649d2a33877f5d6eb77a32a9183e365241be56b3ba6b99b1c27095390c110ee3c3f7d6743844049dab6576461b22a64c7c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphiti_gql (0.1.0)
+    graphiti_gql (0.2.2)
       graphiti (~> 1.3.9)
       graphql (~> 2.0)
       graphql-batch (~> 0.5)
@@ -47,7 +47,7 @@ GEM
       jsonapi-serializable (~> 0.3.0)
     graphiti_errors (1.1.2)
       jsonapi-serializable (~> 0.1)
-    graphql (2.0.7)
+    graphql (2.0.11)
     graphql-batch (0.5.1)
       graphql (>= 1.10, < 3)
       promise.rb (~> 0.7.2)

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

@@ -9,9 +9,18 @@ module GraphitiGql
       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 = GraphitiGql.config.application_controller || ::ApplicationController
+      app_controller.send(:include, ControllerContext)
 
       # rubocop:disable Lint/ConstantDefinitionInBlock(Standard)
       class GraphitiGql::ExecutionController < app_controller
@@ -20,9 +29,15 @@ module GraphitiGql
           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/graphiti_hax.rb

@@ -11,6 +11,27 @@ module GraphitiGql
       end
     end
 
+    def selections
+      return @selections if @selections
+      lookahead = context[:current_arguments]
+        .keyword_arguments[:lookahead]
+      nodes = lookahead.selection(:nodes)
+      if !nodes.selected?
+        nodes = lookahead
+          .selection(:edges)
+          .selection(:node)
+      end
+
+      if !nodes.selected?
+        nodes = lookahead
+      end
+
+      @selections = nodes
+        .selections
+        .map(&:name).map { |name| name.to_s.underscore.to_sym }
+      @selections
+    end
+
     class_methods do
       def attribute(*args)
         super(*args).tap do
@@ -121,6 +142,24 @@ module GraphitiGql
   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] || {}
@@ -141,7 +180,11 @@ module GraphitiGql
   end
 
   _in = definition.constructor do |input|
-    Time.zone.parse(input)
+    if input.is_a?(ActiveSupport::TimeWithZone)
+      input = input.utc.round(10).iso8601(6)
+    else
+      Time.zone.parse(input)
+    end
   end
 
   # Register it with Graphiti
@@ -166,7 +209,9 @@ module GraphitiGql
       alias_method :filter_precise_datetime_not_eq, :filter_not_eq
     end
   end
-  Graphiti::Adapters::ActiveRecord.send(:include, ActiveRecordAdapterExtras)
+  if defined?(Graphiti::Adapters::ActiveRecord)
+    Graphiti::Adapters::ActiveRecord.send(:include, ActiveRecordAdapterExtras)
+  end
 
   Graphiti::Adapters::Abstract.class_eval do
     class << self
@@ -215,4 +260,17 @@ module GraphitiGql
     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/belongs_to.rb

@@ -53,7 +53,8 @@ module GraphitiGql
           end
         else
           params = {filter: {id: {eq: ids.join(",")}}}
-          records = @sideload.resource.class.all(params).data
+          resource = Schema.registry.get(@sideload.resource.class)[:resource]
+          records = resource.all(params).data
           map = records.index_by { |record| record.id }
           ids.each { |id| fulfill(id, map[id]) }
         end

data/lib/graphiti_gql/loaders/has_many.rb

@@ -1,12 +1,12 @@
 module GraphitiGql
   module Loaders
     class HasMany < Many
-      def assign(ids, proxy)
+      def assign(parent_records, proxy)
         records = proxy.data
         map = records.group_by { |record| record.send(@sideload.foreign_key) }
-        ids.each do |id|
-          data = [map[id] || [], proxy]
-          fulfill(id, data)
+        parent_records.each do |pr|
+          data = [map[pr.send(@sideload.primary_key)] || [], proxy]
+          fulfill(pr, data)
         end
       end
     end

data/lib/graphiti_gql/loaders/has_one.rb

@@ -0,0 +1,15 @@
+module GraphitiGql
+  module Loaders
+    class HasOne < Many
+      def assign(parent_records, proxy)
+        records = proxy.data
+        parent_records.each do |pr|
+          corresponding = records.find do |r|
+            r.send(@sideload.foreign_key) == pr.send(@sideload.primary_key)
+          end
+          fulfill(pr, corresponding)
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_gql/loaders/many.rb

@@ -6,6 +6,8 @@ module GraphitiGql
           PolymorphicHasMany.for(sideload, params)
         elsif sideload.type == :many_to_many
           ManyToMany.for(sideload, params)
+        elsif sideload.type == :has_one
+          HasOne.for(sideload, params)
         else
           HasMany.for(sideload, params)
         end
@@ -16,13 +18,26 @@ module GraphitiGql
         @params = params
       end
 
-      def perform(ids)
-        raise ::Graphiti::Errors::UnsupportedPagination if paginating? && ids.length > 1
-        raise Errors::UnsupportedStats if requesting_stats? && ids.length > 1 && !can_group?
+      def perform(parent_records)
+        raise ::Graphiti::Errors::UnsupportedPagination if paginating? && parent_records.length > 1
+        raise Errors::UnsupportedStats if requesting_stats? && parent_records.length > 1 && !can_group?
 
-        build_params(ids)
-        proxy = @sideload.resource.class.all(@params)
-        assign(ids, proxy)
+        ids = parent_records.map do |pr|
+          pk = pr.send(@sideload.primary_key)
+          if @sideload.polymorphic_as
+            hash = {}
+            hash[@sideload.foreign_key] = pk
+            hash[:"#{@sideload.polymorphic_as}_type"] = pr.class.name
+            hash
+          else
+            pk
+          end
+        end
+
+        build_params(ids, parent_records)
+        resource = Schema.registry.get(@sideload.resource.class)[:resource]
+        proxy = resource.all(@params)
+        assign(parent_records, proxy)
       end
 
       def assign(ids, proxy)
@@ -31,7 +46,7 @@ module GraphitiGql
 
       private
 
-      def build_params(ids)
+      def build_params(ids, parent_records)
         @params[:filter] ||= {}
 
         if @sideload.polymorphic_as
@@ -59,6 +74,10 @@ module GraphitiGql
           @params[:page] ||= {}
           @params[:page][:size] = 999
         end
+
+        if @sideload.params_proc
+          @sideload.params_proc.call(@params, parent_records)
+        end
       end
 
       def paginating?

data/lib/graphiti_gql/loaders/many_to_many.rb

@@ -1,14 +1,31 @@
 module GraphitiGql
   module Loaders
     class ManyToMany < Many
-      def assign(ids, proxy)
-        records = proxy.data
+      def assign(parent_records, proxy)
         thru = @sideload.foreign_key.keys.first
         fk = @sideload.foreign_key[thru]
-        ids.each do |id|
-          match = ->(thru) { thru.send(fk) == id }
-          corresponding = records.select { |record| record.send(thru).any?(&match) }
-          fulfill(id, [corresponding, proxy])
+        add_join_table_magic(proxy)
+        records = proxy.data
+        parent_records.each do |pr|
+          corresponding = records.select do |record|
+            record.send(:"_edge_#{fk}") == pr.send(@sideload.primary_key)
+          end
+          fulfill(pr, [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

data/lib/graphiti_gql/loaders/polymorphic_has_many.rb

@@ -1,15 +1,18 @@
 module GraphitiGql
   module Loaders
     class PolymorphicHasMany < Many
-      def assign(ids, proxy)
+      def assign(parent_records, proxy)
         records = proxy.data
-        ids.each do |id|
+        parent_records.each do |pr|
           corresponding = records.select do |record|
-            record.send("#{@sideload.polymorphic_as}_type") == id[:"#{@sideload.polymorphic_as}_type"] &&
-              record.send(@sideload.foreign_key) == id[@sideload.foreign_key]
+            child_ft = record.send("#{@sideload.polymorphic_as}_type")
+            child_fk = record.send(@sideload.foreign_key)
+            parent_ft = pr.class.name
+            parent_fk = pr.send(@sideload.primary_key)
+            child_ft == parent_ft && child_fk == parent_fk
           end
           data = [corresponding || [], proxy]
-          fulfill(id, data)
+          fulfill(pr, data)
         end
       end
     end

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

@@ -2,10 +2,12 @@ module GraphitiGql
   class Schema
     module Fields
       class Attribute
-        def initialize(name, config)
+        # 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)
@@ -13,20 +15,39 @@ module GraphitiGql
           _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
             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(_alias || _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)
@@ -36,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,32 +4,62 @@ 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)
-          field = type.field @sideload.name,
-            @sideload_type.connection_type,
-            null: false,
+          opts = {
+            null: has_one?,
             connection: false,
-            extensions: [RelayConnectionExtension],
             extras: [:lookahead]
+          }
+          opts[:extensions] = [RelayConnectionExtension] unless has_one?
+          field_type = has_one? ? @sideload_type : @sideload_type.connection_type
+          field = type.field @sideload.name,
+            field_type,
+            **opts
           ListArguments.new(@sideload.resource.class, @sideload).apply(field)
           _sideload = @sideload
           type.define_method(@sideload.name) do |**arguments|
             Util.is_readable_sideload!(_sideload)
             params = Util.params_from_args(arguments)
-            pk = object.send(_sideload.primary_key)
-            id = if _sideload.polymorphic_as
-              hash = {}
-              hash[_sideload.foreign_key] = pk
-              hash[:"#{_sideload.polymorphic_as}_type"] = object.class.name
-              id = hash
-            else
-              id = pk
-            end
-            Loaders::Many.factory(_sideload, params).load(id)
+            Loaders::Many.factory(_sideload, params).load(object)
+          end
+        end
+
+        private
+
+        def has_one?
+          @sideload.type == :has_one
+        end
+
+        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

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

@@ -19,7 +19,9 @@ module GraphitiGql
             if _sideload.type == :has_one
               id = object.send(_sideload.primary_key)
               params = { filter: { _sideload.foreign_key => { eq: id } } }
-              return _sideload.resource.class.all(params).data[0]
+
+              resource = Schema.registry.get(@sideload.resource.class)[:resource]
+              return resource.all(params).data[0]
             end
 
             lookahead = arguments[:lookahead]

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
@@ -32,7 +31,7 @@ module GraphitiGql
 
       def add_relationships
         each_relationship do |type, sideload_type, sideload|
-          if [:has_many, :many_to_many].include?(sideload.type)
+          if [:has_many, :many_to_many, :has_one].include?(sideload.type)
             Fields::ToMany.new(sideload, sideload_type).apply(type)
           else
             Fields::ToOne.new(sideload, sideload_type).apply(type)

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

@@ -32,6 +32,21 @@ 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

data/lib/graphiti_gql/spec_helper.rb

@@ -2,149 +2,44 @@ module GraphitiGql
   module SpecHelper
     extend ActiveSupport::Concern
 
-    class Node < OpenStruct
-      def decoded_id
-        Base64.decode64(self.id)
-      end
-
-      def int_id
-        decoded_id.to_i
-      end
-    end
+    included do
+      extend Forwardable
+      def_delegators :result,
+        :page_info,
+        :errors,
+        :error_messages,
+        :nodes,
+        :stats
 
-    class Util
-      def self.underscore(hash)
-        hash.deep_transform_keys { |k| k.to_s.underscore.to_sym }
+      if defined?(RSpec)
+        let(:params) { {} }
+        let(:resource) { described_class }
+        let(:ctx) { {} }
       end
     end
 
-    def query
-      name = Schema.registry.key_for(resource)
-      q = %|
-        query #{name} (
-          $filter: #{name}Filter,
-          $sort: [#{name}Sort!],
-          $first: Int,
-          $last: Int,
-          $before: String,
-          $after: String,
-        ) {
-          #{resource.graphql_entrypoint} (
-            filter: $filter,
-            sort: $sort,
-            first: $first,
-            last: $last,
-            before: $before,
-            after: $after,
-          ) {
-            edges {
-              node {|
-
-      fields.each do |name|
-        q << %|
-                #{name.to_s.camelize(:lower)}|
-      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 << %|
-            }|
+    def gql_datetime(timestamp, precise = false)
+      if precise
+        timestamp.utc.round(10).iso8601(6)
+      else
+        DateTime.parse(timestamp.to_s).iso8601
       end
-  
-      q << %|
-          }
-        }
-      |
-  
-      q
     end
 
     def run
       lambda do
-        gql_params = params.deep_transform_keys { |key| key.to_s.camelize(:lower).to_sym }
-        (gql_params[:sort] || []).each do |sort|
-          sort[:att] = sort[:att].to_s.camelize(:lower)
-          sort[:dir] = sort[:dir].to_s
-        end
-        GraphitiGql.run(query, gql_params, ctx).deep_symbolize_keys
+        proxy = resource.gql(params, ctx)
+        proxy.to_h
+        proxy
       end
     end
 
     def run!
-      @response = run.call
-    end
-
-    def response
-      @response ||= run!
-    end
-
-    def errors
-      response[:errors]
-    end
-
-    def error_messages
-      response[:errors].map { |e| e[:message] }
+      @result = run.call
     end
 
-    def nodes
-      return [] unless data
-      nodes = edges.map { |e| Util.underscore(e[:node]) }
-      nodes.map { |n| ::GraphitiGql::SpecHelper::Node.new(n) }
-    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 edges
-      data[data.keys.first][:edges]
-    end
-
-    def stats
-      Util.underscore(data[data.keys.first][:stats])
-    end
-
-    def page_info
-      Util.underscore(data[data.keys.first][:pageInfo])
-    end
-
-    included do
-      let(:params) { {} }
-      let(:resource) { described_class }
-      let(:ctx) { {} }
-      let(:fields) do
-        fields = []
-        resource.attributes.each_pair do |name, config|
-          (fields << name) if config[:readable]
-        end
-        fields
-      end
+    def result
+      @result ||= run!
     end
   end
 end

data/lib/graphiti_gql/version.rb

@@ -1,3 +1,3 @@
 module GraphitiGql
-  VERSION = "0.2.0"
+  VERSION = "0.2.3"
 end

data/lib/graphiti_gql.rb

@@ -9,6 +9,7 @@ require "graphiti_gql/loaders/has_many"
 require "graphiti_gql/loaders/many_to_many"
 require "graphiti_gql/loaders/polymorphic_has_many"
 require "graphiti_gql/loaders/belongs_to"
+require "graphiti_gql/loaders/has_one"
 require "graphiti_gql/response_shim"
 require "graphiti_gql/schema"
 require "graphiti_gql/schema/connection"
@@ -24,6 +25,7 @@ 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
@@ -64,6 +66,9 @@ module GraphitiGql
   end
 
   def self.run(query_string, variables = {}, context = {})
+    if context.empty? && Graphiti.context[:object]
+      context = Graphiti.context[:object]
+    end
     Graphiti.with_context(context) do
       result = schema.execute query_string,
         variables: variables,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti_gql
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.3
 platform: ruby
 authors:
 - Lee Richmond
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-16 00:00:00.000000000 Z
+date: 2022-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -108,7 +108,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '7.0'
-description: 
+description:
 email:
 - richmolj@gmail.com
 executables: []
@@ -137,11 +137,13 @@ 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
 - lib/graphiti_gql/loaders/belongs_to.rb
 - lib/graphiti_gql/loaders/has_many.rb
+- lib/graphiti_gql/loaders/has_one.rb
 - lib/graphiti_gql/loaders/many.rb
 - lib/graphiti_gql/loaders/many_to_many.rb
 - lib/graphiti_gql/loaders/polymorphic_has_many.rb
@@ -167,7 +169,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://www.graphiti.dev
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -182,8 +184,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: GraphQL support for Graphiti
 test_files: []