graphiti_graphql 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94c56621cb36c796bbefd0e8f626d90e359e2e8740b2cb443a8293e2f98b57df
-  data.tar.gz: dd1d065a140a292adab0f5d3c54e426dfcfa55b3691523f50ceb947fa752fdbd
+  metadata.gz: 75a9873f8fda91fa24f41d06e146826f3de27165452b61202dc45d597e869ef5
+  data.tar.gz: 69b67b64c1af770a2df57a74e6a30175e7c80f4d26d4a73a2db958f153b1c5b3
 SHA512:
-  metadata.gz: 94886a1ebbed6fee376239b1a10c197c3891cd280aad29973a7a1ce4d6f769e9c1fc3949bb4613dbe98c44d1f584a1b2863955c605798525e24ee1766b136891
-  data.tar.gz: d0ca0298e0e77da84361a1748a2b36457569910d43aed602a94cfd6eb8869c32c8a0db611bca68dbf64382fe0c5cd8dddb8956c105af9ae7819c4e92cce03adc
+  metadata.gz: fe62cbb5d5dd96ae3008add2bd13c465e0f2fd944869a478f544690bf6c459db2daf1504957adb243412a88cd318759fc6cd46f03a436b7b428d912d2530d2be
+  data.tar.gz: 2bd729f975995cf7433a3fc7c6864586dd5515955c68941c91e6036d2ef54cd024a3508a0869ed67eda7d6e61f612c37ae1b9b9b13ef19bb636948629edb4222

data/Gemfile

@@ -1,6 +1,4 @@
 source "https://rubygems.org"
 
 # Specify your gem's dependencies in graphiti_graphql.gemspec
-gemspec
-
-gem "graphiti"
+gemspec

data/Gemfile.lock

@@ -1,19 +1,9 @@
-PATH
-  remote: ../graphiti
-  specs:
-    graphiti (1.2.32)
-      activesupport (>= 4.1)
-      concurrent-ruby (~> 1.0)
-      dry-types (>= 0.15.0, < 2.0)
-      graphiti_errors (~> 1.1.0)
-      jsonapi-renderer (~> 0.2, >= 0.2.2)
-      jsonapi-serializable (~> 0.3.0)
-
 PATH
   remote: .
   specs:
-    graphiti_graphql (0.1.1)
+    graphiti_graphql (0.1.2)
       activesupport (>= 4.1)
+      graphiti (>= 1.2.36)
       graphql (~> 1.12)
 
 GEM
@@ -54,6 +44,13 @@ GEM
       dry-inflector (~> 0.1, >= 0.1.2)
       dry-logic (~> 1.0, >= 1.0.2)
     google-protobuf (3.15.2)
+    graphiti (1.2.36)
+      activesupport (>= 4.1)
+      concurrent-ruby (~> 1.0)
+      dry-types (>= 0.15.0, < 2.0)
+      graphiti_errors (~> 1.1.0)
+      jsonapi-renderer (~> 0.2, >= 0.2.2)
+      jsonapi-serializable (~> 0.3.0)
     graphiti_errors (1.1.2)
       jsonapi-serializable (~> 0.1)
     graphiti_spec_helpers (1.0.5)
@@ -63,13 +60,13 @@ GEM
     graphql-batch (0.4.3)
       graphql (>= 1.3, < 2)
       promise.rb (~> 0.7.2)
-    i18n (1.8.7)
+    i18n (1.8.9)
       concurrent-ruby (~> 1.0)
     jsonapi-renderer (0.2.2)
     jsonapi-serializable (0.3.1)
       jsonapi-renderer (~> 0.2.0)
     method_source (1.0.0)
-    minitest (5.14.3)
+    minitest (5.14.4)
     parallel (1.20.1)
     parser (3.0.0.0)
       ast (~> 2.4.1)
@@ -129,7 +126,6 @@ DEPENDENCIES
   activemodel (>= 4.1)
   apollo-federation (~> 1.1)
   bundler (~> 2.0)
-  graphiti!
   graphiti_graphql!
   graphiti_spec_helpers
   graphql (~> 1.12)

data/README.md

@@ -4,12 +4,14 @@ GraphQL (and Apollo Federation) support for Graphiti. Serve traditional Rails JS
 
 Currently read-only, but you can add your own Mutations [manually](#blending-with-graphql-ruby).
 
+Pre-alpha. Stay tuned.
+
 ## Setup
 
 Add to your `Gemfile`:
 
 ```rb
-gem 'graphiti', ">= 1.2.32"
+gem 'graphiti', ">= 1.2.33"
 gem "graphiti_graphql"
 ```
 
@@ -59,7 +61,7 @@ Define your Schema and Type classes as normal. Then in an initializer:
 GraphitiGraphQL.schema_class = MySchema
 ```
 
-Any pre-existing GraphQL endpoint will continue working as normal. But the GQL endpoint you mounted in `config/routes.rb` will now serve BOTH your low-level `graphql-ruby` schema AND your Graphiti-specific schema. Note these cannot (currently) be served side-by-side on under `query` within the *same request*.
+Any pre-existing GraphQL endpoint will continue working as normal. But the GQL endpoint you mounted in `config/routes.rb` will now serve BOTH your low-level `graphql-ruby` schema AND your Graphiti-specific schema. Note these cannot (currently) be served side-by-side under `query` within the *same request*.
 
 By default the GraphQL context will be `Graphiti.context[:object]`, which is the controller being called. You might want to customize this so your existing graphql-ruby code continues to expect the same context:
 

data/graphiti_graphql.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "graphiti", ">= 1.2.33"
+  spec.add_dependency "graphiti", ">= 1.2.36"
   spec.add_dependency "activesupport", ">= 4.1"
   spec.add_dependency "graphql", "~> 1.12"
 

data/lib/graphiti_graphql/federation/schema_decorator.rb

@@ -90,6 +90,22 @@ module GraphitiGraphQL
         federated_type
       end
 
+      def define_connection_type(name, type_class)
+        name = "#{name}FederatedConnection"
+        if (registered = type_registry[name])
+          return registered[:type]
+        end
+
+        klass = Class.new(@schema.class.base_object)
+        klass.graphql_name(name)
+        klass.field :nodes,
+          [type_class],
+          null: false,
+          extras: [:lookahead]
+        @schema.send :register, name, klass
+        klass
+      end
+
       def define_federated_has_many(type_class, relationship)
         local_name = GraphitiGraphQL::GraphitiSchema::Resource
           .gql_name(relationship.local_resource_class.name)
@@ -100,16 +116,20 @@ module GraphitiGraphQL
         local_interface = type_registry["I#{local_name}"]
         best_type = local_interface ? local_interface[:type] : local_type
 
+        connection_type = define_connection_type(local_name, best_type)
+
         field = type_class.field relationship.name,
-          [best_type],
+          connection_type,
           null: false,
-          extras: [:lookahead]
-
+          connection: false
         @schema.send :define_arguments_for_sideload_field,
           field, @schema.graphiti_schema.get_resource(local_resource_name)
-        type_class.define_method relationship.name do |lookahead:, **arguments|
-          # TODO test params...do version of sort with array/symbol keys and plain string
-          params = arguments.as_json
+
+        type_class.define_method relationship.name do |**arguments|
+          {data: object, arguments: arguments}
+        end
+        connection_type.define_method :nodes do |lookahead:, **arguments|
+          params = object[:arguments].as_json
             .deep_transform_keys { |key| key.to_s.underscore.to_sym }
           selections = lookahead.selections.map(&:name)
           selections << relationship.foreign_key
@@ -122,7 +142,7 @@ module GraphitiGraphQL
 
           Federation::Loaders::HasMany
             .for(relationship, params)
-            .load(object[:id])
+            .load(object[:data][:id])
         end
       end
 

data/lib/graphiti_graphql/graphiti_schema/resource.rb

@@ -63,6 +63,10 @@ module GraphitiGraphQL
         config[:name]
       end
 
+      def stats
+        config[:stats]
+      end
+
       def type
         config[:type]
       end

data/lib/graphiti_graphql/runner.rb

@@ -38,7 +38,7 @@ module GraphitiGraphQL
 
     def render(json, selection_name)
       payload = if find_one?(selection_name)
-        {selection_name.to_sym => json.values[0][0]}
+        {selection_name.to_sym => json.values[0][:nodes][0]}
       else
         json
       end
@@ -108,15 +108,19 @@ module GraphitiGraphQL
         gather_filters(params, selection, variables_hash, chained_name)
         gather_sorts(params, selection, variables_hash, chained_name)
         gather_pages(params, selection, variables_hash, chained_name)
+        gather_stats(params, selection, variables_hash, chained_name)
       end
 
       params[:include] ||= []
       params[:include] << chained_name if chained_name
 
-      fragments = selection.selections.select { |s|
+      nodes = selection.selections.find { |s| s.respond_to?(:name) && s.name == "nodes" }
+      children = nodes ? nodes.children : selection.selections
+
+      fragments = children.select { |s|
         s.is_a?(GraphQL::Language::Nodes::InlineFragment)
       }
-      non_fragments = selection.selections - fragments
+      non_fragments = children - fragments
 
       if pbt
         # Only id/_type possible here
@@ -223,7 +227,9 @@ module GraphitiGraphQL
 
               attr_arg.value.arguments.each do |operator_arg|
                 value = operator_arg.value
-                if value.respond_to?(:name) # is a variable
+                if value.is_a?(GraphQL::Language::Nodes::Enum)
+                  value = value.name
+                elsif value.respond_to?(:name) # is a variable
                   value = variable_hash[operator_arg.value.name]
                 end
                 f[filter_param_name] = {operator_arg.name.underscore => value}
@@ -299,5 +305,22 @@ module GraphitiGraphQL
         params[:page].merge!(pages)
       end
     end
+
+    def gather_stats(params, selection, variable_hash, chained_name = nil)
+      stats = selection.children.find { |c| c.name == "stats" }
+      nodes = selection.children.find { |c| c.name == "nodes" }
+
+      if stats
+        stat_param = {}
+        stats.children.each do |stat_node|
+          stat_name = stat_node.name
+          calculations = stat_node.children.map(&:name)
+          stat_param[stat_name.to_sym] = calculations.join(",")
+        end
+        stat_param = {chained_name => stat_param} if chained_name
+        params[:stats] = stat_param
+        params[:page] = {size: 0} unless nodes
+      end
+    end
   end
 end

data/lib/graphiti_graphql/schema.rb

@@ -132,11 +132,30 @@ module GraphitiGraphQL
 
     private
 
+    def generate_connection_type(resource, top_level: true)
+      name = "#{resource.graphql_class_name}#{top_level ? "TopLevel" : ""}Connection"
+      if registered = type_registry[name]
+        return registered[:type]
+      end
+
+      type = type_registry[resource.graphql_class_name][:type]
+      klass = Class.new(self.class.base_object)
+      klass.graphql_name(name)
+      klass.field :nodes,
+        [type],
+        "List #{resource.graphql_class_name(false).pluralize}",
+        null: false
+      if top_level
+        klass.field :stats, generate_stat_class(resource), null: false
+      end
+      register(name, klass)
+      klass
+    end
+
     def add_index(query_class, resource)
       field_name = resource.graphql_entrypoint.to_s.underscore.to_sym
       field = query_class.field field_name,
-        [type_registry[resource.graphql_class_name][:type]],
-        "List #{resource.graphql_class_name(false).pluralize}",
+        generate_connection_type(resource, top_level: true),
         null: false
       @query_fields[field_name] = resource
       define_arguments_for_sideload_field(field, resource)
@@ -147,7 +166,7 @@ module GraphitiGraphQL
       field = query_class.field field_name,
         type_registry[resource.graphql_class_name][:type],
         "Single #{resource.graphql_class_name(false).singularize}",
-        null: true
+        null: false
       @query_fields[field_name] = resource
       define_arguments_for_sideload_field field,
         resource,
@@ -232,17 +251,38 @@ module GraphitiGraphQL
     # TODO guarded operators or otherwise whatever eq => nil is
     def generate_filter_attribute_type(type_name, filter_name, filter_config)
       klass = Class.new(GraphQL::Schema::InputObject)
-      klass.graphql_name "#{type_name}Filter#{filter_name.to_s.camelize(:lower)}"
+      filter_graphql_name = "#{type_name}Filter#{filter_name.to_s.camelize(:lower)}"
+      klass.graphql_name(filter_graphql_name)
       filter_config[:operators].each do |operator|
         canonical_graphiti_type = Graphiti::Types
           .name_for(filter_config[:type])
         type = GQL_TYPE_MAP[canonical_graphiti_type]
         required = !!filter_config[:required] && operator == "eq"
+
+        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
       end
       klass
     end
 
+    def define_allowlist_type(filter_graphql_name, allowlist)
+      name = "#{filter_graphql_name}Allow"
+      if (registered = type_registry[name])
+        return registered[:type]
+      end
+      klass = Class.new(GraphQL::Schema::Enum)
+      klass.graphql_name(name)
+      allowlist.each do |allowed|
+        klass.value(allowed)
+      end
+      register(name, klass)
+      klass
+    end
+
     def generate_resource_for_sideload(sideload)
       if sideload.type == :polymorphic_belongs_to
         unless registered?(sideload.parent_resource)
@@ -269,7 +309,11 @@ module GraphitiGraphQL
           type_registry[sideload.graphql_class_name][:type]
         end
 
-        gql_field_type = sideload.to_many? ? [gql_type] : gql_type
+        gql_field_type = if sideload.to_many?
+          generate_connection_type(sideload.resource, top_level: false)
+        else
+          gql_type
+        end
         field_name = name.to_s.camelize(:lower)
         unless type_class.fields[field_name]
           field = type_class.field field_name.to_sym,
@@ -277,7 +321,6 @@ module GraphitiGraphQL
             null: !sideload.to_many?
 
           # No sort/filter/paginate on belongs_to
-          # unless sideload.type.to_s.include?('belongs_to')
           unless sideload.type == :polymorphic_belongs_to
             define_arguments_for_sideload_field(field, sideload.resource)
           end
@@ -373,6 +416,25 @@ module GraphitiGraphQL
       klass
     end
 
+    def generate_stat_class(resource)
+      klass = Class.new(self.class.base_object)
+      klass.graphql_name "#{resource.graphql_class_name(false)}Stats"
+      resource.stats.each_pair do |name, calculations|
+        calc_class = generate_calc_class(resource, name, calculations)
+        klass.field name, calc_class, null: false
+      end
+      klass
+    end
+
+    def generate_calc_class(resource, stat_name, calculations)
+      klass = Class.new(self.class.base_object)
+      klass.graphql_name "#{resource.graphql_class_name(false)}#{stat_name}Calculations"
+      calculations.each do |calc|
+        klass.field calc, Float, null: false
+      end
+      klass
+    end
+
     def registered?(resource)
       name = resource.graphql_class_name(false)
       !!type_registry[name]

data/lib/graphiti_graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphitiGraphQL
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti_graphql
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Lee Richmond
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-03-07 00:00:00.000000000 Z
+date: 2021-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphiti
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.33
+        version: 1.2.36
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.33
+        version: 1.2.36
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement