graphiti_gql 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85aecb8badace989fe7f60f3187c189a2d73ce0e99fd4725a8388ed01f2a9cd0
-  data.tar.gz: 488756eb837219bde85b23a015bd6b6081fa2857c753c3e1837ab0fb7c758dc8
+  metadata.gz: 2a19fd68dc698b8a7284fe80686da9f50ee137365508241cd374e32aa6c505aa
+  data.tar.gz: d509f137452b90e94986c46267f8728160021de305e599ba47512af9366fe109
 SHA512:
-  metadata.gz: ef8b222b5b932bbcb6f21cb8a9480341499086b3daffbb85657af89e208c7b639c4b75fc1ec7f432edb818673ae1e971689fc3f940d11176721a651220f60325
-  data.tar.gz: 867db73b474375ab9189aa421c953f1ebb008f94ea906d163a4e70f6059ec7df3a699199322cd276f0227d6eebb80d15958587530a8e9e2282ad010139e8e926
+  metadata.gz: 22f8643e779d272d806d53179e5f83e6ca6157fc8c261e03ea3232fdf685faa35ad50c70bd3f5f0f445b8bd4578e616b9a538c9205e330a301a30f370b2c612a
+  data.tar.gz: ec6e08b56162dc2bb077bfd3cfc5fb5dcf8edcdc3680d940347eb33949f8530967e6d828e0b914f0920a406bad4807d83c643981f9ab0136dd7a3e9e422e068a

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/engine.rb

@@ -2,6 +2,7 @@ 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) }
@@ -10,11 +11,10 @@ module GraphitiGql
 
     initializer "graphiti_gql.define_controller" do
       require "#{Rails.root}/app/controllers/application_controller"
-      app_controller = ::ApplicationController # todo
+      app_controller = GraphitiGql.config.application_controller || ::ApplicationController
 
       # 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] || {}

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,218 @@
 # 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
 
-  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
+      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
-end
+  Graphiti::Scoping::Paginate.send(:prepend, PaginateExtras)
 
-Graphiti::Resource.send(:include, ResourceExtras)
+  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
 
-module FilterExtras
-  def filter_param
-    default_filter = resource.default_filter if resource.respond_to?(:default_filter)
-    default_filter ||= {}
-    default_filter.merge(super)
+  _in = definition.constructor do |input|
+    Time.zone.parse(input)
   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
+
+  # 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
+  Graphiti::Adapters::ActiveRecord.send(:include, ActiveRecordAdapterExtras)
+
+  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 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
+  Graphiti::Scoping::Sort.send(:prepend, SortExtras)
+  module QueryExtras
+    def hash
+      hash = super
+      hash[:reverse] = true if @params[:reverse]
+      hash
+    end
   end
-end
-Graphiti::Query.send(:prepend, QueryExtras)
-module ScopeExtras
-  def resolve(*args)
-    results = super
-    results.reverse! if @query.hash[:reverse]
-    results
+  
+  Graphiti::Query.send(:prepend, QueryExtras)
+  module ScopeExtras
+    def resolve(*args)
+      results = super
+      results.reverse! if @query.hash[:reverse]
+      results
+    end
   end
-end
-Graphiti::Scope.send(:prepend, ScopeExtras)
+  Graphiti::Scope.send(:prepend, ScopeExtras)
+end

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

@@ -3,17 +3,19 @@ module GraphitiGql
     module Fields
       class Attribute
         def initialize(name, config)
-          @name = name
           @config = config
+          @name = name
+          @alias = config[:alias]
         end
 
         def apply(type)
           is_nullable = !!@config[:null]
           _config = @config
           _name = @name
+          _alias = @alias 
           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)
               unless resource.send(readable)
@@ -24,7 +26,7 @@ module GraphitiGql
             value = if _config[:proc]
               instance_eval(&_config[:proc])
             else
-              object.send(_name)
+              object.send(_alias || _name)
             end
             return if value.nil?
             Graphiti::Types[_config[:type]][:read].call(value)

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.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,14 @@ module GraphitiGql
       end
     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 +50,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,150 @@
+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
+
+    class Util
+      def self.underscore(hash)
+        hash.deep_transform_keys { |k| k.to_s.underscore.to_sym }
+      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 << %|
+            }|
+      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
+      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] }
+    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
+    end
+  end
+end

data/lib/graphiti_gql/version.rb

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

data/lib/graphiti_gql.rb

@@ -29,6 +29,10 @@ 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 +43,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.0
 platform: ruby
 authors:
 - Lee Richmond
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-06-03 00:00:00.000000000 Z
+date: 2022-06-16 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: []
@@ -160,13 +160,14 @@ 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:
 - MIT
 metadata:
   homepage_uri: https://www.graphiti.dev
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -181,8 +182,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: GraphQL support for Graphiti
 test_files: []