graphiti_graphql 0.1.1 → 0.1.2

data/lib/graphiti_graphql/runner.rb

@@ -4,22 +4,28 @@ module GraphitiGraphQL
       query = GraphQL::Query.new(schema, query_string, variables: variables)
       definition = query.document.definitions.first
       selection = definition.selections.first
-      resource_class = find_entrypoint_resource_class(selection.name)
+      is_graphiti = schemas.generated.query_field?(selection.name)
 
-      # TODO: instead, keep track of fields we add
+      # Wrap *everything* in context, in case of federated request
       Util.with_gql_context do
-        if resource_class
+        if is_graphiti
+          resource_class = schemas.generated
+            .resource_for_query_field(selection.name)
           run_query(schema, resource_class, selection, query)
         else
-          Graphiti.graphql_schema.schema.execute query_string,
+          schemas.graphql.execute query_string,
             variables: variables,
-            context: GraphitiGraphQL.get_context
+            context: GraphitiGraphQL.config.get_context
         end
       end
     end
 
     private
 
+    def schemas
+      GraphitiGraphQL.schemas
+    end
+
     def run_query(schema, resource_class, selection, query)
       if (errors = collect_errors(schema, query)).any?
         {"errors" => errors.map(&:to_h)}
@@ -49,20 +55,8 @@ module GraphitiGraphQL
       query.validation_errors + query.analysis_errors + query.context.errors
     end
 
-    # We can't just constantize the name from the schema
-    # Because classes can be reopened and modified in tests (or elsewhere, in theory)
-    def find_entrypoint_resource_class(entrypoint)
-      Graphiti.resources.find(&matches_entrypoint?(entrypoint))
-    end
-
     def find_entrypoint_schema_resource(entrypoint)
-      graphiti_schema.resources.find(&matches_entrypoint?(entrypoint))
-    end
-
-    def matches_entrypoint?(entrypoint)
-      lambda do |resource|
-        resource.graphql_entrypoint.to_s.underscore == entrypoint.pluralize.underscore
-      end
+      schemas.generated.schema_resource_for_query_field(entrypoint)
     end
 
     def introspection_query?(query)
@@ -70,14 +64,10 @@ module GraphitiGraphQL
     end
 
     def find_resource_by_selection_name(name)
-      graphiti_schema.resources
+      schemas.graphiti.resources
         .find { |r| r.type == name.pluralize.underscore }
     end
 
-    def graphiti_schema
-      Graphiti.graphql_schema.graphiti_schema
-    end
-
     def schema_resource_for_selection(selection, parent_resource)
       if parent_resource
         parent_resource.related_resource(selection.name.underscore.to_sym)
@@ -146,8 +136,8 @@ module GraphitiGraphQL
       end
 
       fragments.each do |fragment|
-        resource_name = Graphiti.graphql_schema.type_registry[fragment.type.name][:resource]
-        klass = graphiti_schema.resources.find { |r| r.name == resource_name }
+        resource_name = schemas.generated.type_registry[fragment.type.name][:resource]
+        klass = schemas.graphiti.resources.find { |r| r.name == resource_name }
         _, _, fragment_sideload_selections = gather_fields fragment.selections,
           klass,
           params,

data/lib/graphiti_graphql/schema.rb

@@ -34,6 +34,7 @@ module GraphitiGraphQL
     end
 
     attr_accessor :type_registry, :schema, :graphiti_schema
+    attr_reader :query_fields
 
     def self.federation?
       !!@federation
@@ -54,26 +55,11 @@ module GraphitiGraphQL
     def self.generate(entrypoint_resources = nil)
       instance = new
       schema = Class.new(::GraphitiGraphQL.schema_class || GraphQL::Schema)
-
-      if federation?
-        schema.send(:include, ApolloFederation::Schema)
-      end
-
       graphiti_schema = GraphitiGraphQL::GraphitiSchema::Wrapper
         .new(Graphiti::Schema.generate)
-      # TODO: if we avoid this on federation, or remove altogether
-      # Make sure we don't blow up
-      # graphiti_schema.merge_remotes!
-
-      entries = entrypoint_resources || entrypoints
-      instance.apply_query(graphiti_schema, schema, entries)
-
-      # NB if we add mutation support, make sure this is applied after
-      if federation?
-        schema.use GraphQL::Batch
-      end
-      instance.schema = schema
       instance.graphiti_schema = graphiti_schema
+      instance.schema = schema
+      instance.apply_query(entrypoint_resources || entrypoints)
       instance
     end
 
@@ -83,147 +69,32 @@ module GraphitiGraphQL
 
     def initialize
       @type_registry = {}
+      @query_fields = {}
     end
 
-    # TODO put this in a Federation::Schema module
-    # Maybe even the External classes themselves?
-    # TODO assign/assign_each
-    def apply_federation(graphiti_schema, graphql_schema)
-      type_registry.each_pair do |name, config|
-        if config[:resource]
-          local_type = config[:type]
-          local_resource = Graphiti.resources
-            .find { |r| r.name == config[:resource] }
-          # TODO: maybe turn off the graphiti debug for these?
-          local_type.define_singleton_method :resolve_reference do |reference, context, lookahead|
-            Federation::BelongsToLoader
-              .for(local_resource, lookahead.selections.map(&:name))
-              .load(reference[:id])
-          end
-        end
-      end
-
-      # NB: test already registered bc 2 things have same relationship
-      GraphitiGraphQL::Federation.external_resources.each_pair do |klass_name, config|
-        pre_registered = !!type_registry[klass_name]
-        external_klass = if pre_registered
-          type_registry[klass_name][:type]
-        else
-          external_klass = Class.new(self.class.base_object)
-          external_klass.graphql_name klass_name
-          external_klass
-        end
-
-        unless pre_registered
-          external_klass.key(fields: "id")
-          external_klass.extend_type
-          external_klass.field :id, String, null: false, external: true
-          external_klass.class_eval do
-            def self.resolve_reference(reference, _context, _lookup)
-              reference
-            end
-          end
-        end
-
-        unless pre_registered
-          # NB must be registered before processing rels
-          type_registry[klass_name] = { type: external_klass }
-        end
-
-        # TODO: only do it if field not already defined
-        config.relationships.each_pair do |name, relationship|
-          if relationship.has_many?
-            define_federated_has_many(graphiti_schema, external_klass, relationship)
-          elsif relationship.belongs_to?
-            define_federated_belongs_to(config, relationship)
-          end
-        end
-      end
-    end
-
-    # TODO: refactor to not constantly pass schemas around
-    def define_federated_has_many(graphiti_schema, external_klass, relationship)
-      local_name = GraphitiGraphQL::GraphitiSchema::Resource
-        .gql_name(relationship.local_resource_class.name)
-      local_type = type_registry[local_name][:type]
-      local_resource_name = type_registry[local_name][:resource]
-      local_resource = Graphiti.resources.find { |r| r.name == local_resource_name }
-
-      local_interface = type_registry["I#{local_name}"]
-      best_type = local_interface ? local_interface[:type] : local_type
-
-      field = external_klass.field relationship.name,
-        [best_type],
-        null: false,
-        extras: [:lookahead]
-
-      define_arguments_for_sideload_field(field, graphiti_schema.get_resource(local_resource_name))
-      external_klass.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
-          .deep_transform_keys { |key| key.to_s.underscore.to_sym }
-        selections = lookahead.selections.map(&:name)
-        selections << relationship.foreign_key
-        selections << :_type # polymorphism
-        params[:fields] = { local_resource.type => selections.join(",") }
-
-        if (sort = Util.parse_sort(params[:sort]))
-          params[:sort] = sort
-        end
-
-        Federation::HasManyLoader
-          .for(local_resource, params, relationship.foreign_key)
-          .load(object[:id])
-      end
-    end
-
-    def define_federated_belongs_to(external_resource_config, relationship)
-      type_name = GraphitiSchema::Resource.gql_name(relationship.local_resource_class.name)
-      local_type = type_registry[type_name][:type]
-
-      # Todo maybe better way here
-      interface = type_registry["I#{type_name}"]
-
-      local_type = interface[:type] if interface
-      local_resource_name = type_registry[type_name][:resource]
-      local_resource_class = Graphiti.resources.find { |r| r.name == local_resource_name }
-
-      local_types = [local_type]
-      if interface
-        local_types |= interface[:implementers]
-      end
-
-      local_types.each do |local|
-        local.field relationship.name,
-          type_registry[external_resource_config.type_name][:type], # todo need to define the type?
-          null: true
-      end
-    end
-
-    def apply_query(graphiti_schema, graphql_schema, entries)
-      query_type = generate_schema_query(graphql_schema, graphiti_schema, entries)
-      if self.class.federation?
-        apply_federation(graphiti_schema, schema)
-      end
+    def apply_query(entries)
+      query_type = generate_schema_query(entries)
+      Federation::SchemaDecorator.decorate(self) if self.class.federation?
 
       # NB - don't call .query here of federation will break things
-      if graphql_schema.instance_variable_get(:@query_object)
-        graphql_schema.instance_variable_set(:@query_object, nil)
-        graphql_schema.instance_variable_set(:@federation_query_object, nil)
+      if schema.instance_variable_get(:@query_object)
+        schema.instance_variable_set(:@query_object, nil)
+        schema.instance_variable_set(:@federation_query_object, nil)
       end
-      graphql_schema.orphan_types(orphans(graphql_schema))
-      graphql_schema.query(query_type)
-      graphql_schema.query # Actually fires the federation code
+      schema.orphan_types(orphans(schema))
+      schema.query(query_type)
+      schema.query # Actually fires the federation code
     end
 
-    def generate_schema_query(graphql_schema, graphiti_schema, entrypoint_resources = nil)
-      existing_query = graphql_schema.instance_variable_get(:@query) || graphql_schema.send(:find_inherited_value, :query)
+    def generate_schema_query(entrypoint_resources = nil)
+      existing_query = schema.instance_variable_get(:@query)
+      existing_query ||= schema.send(:find_inherited_value, :query)
       # NB - don't call graphql_schema.query here of federation will break things
       query_class = Class.new(existing_query || self.class.base_object)
       # NB MUST be Query or federation-ruby will break things
       query_class.graphql_name "Query"
 
-      entrypoints(graphiti_schema, entrypoint_resources).each do |resource|
+      get_entrypoints(entrypoint_resources).each do |resource|
         next if resource.remote?
         generate_type(resource)
 
@@ -244,28 +115,46 @@ module GraphitiGraphQL
       end
     end
 
+    def schema_resource_for_query_field(name)
+      @query_fields[name.underscore.to_sym]
+    end
+
+    def query_field?(name)
+      @query_fields.include?(name.underscore.to_sym)
+    end
+
+    # We can't just constantize the name from the schema
+    # Because classes can be reopened and modified in tests (or elsewhere, in theory)
+    def resource_for_query_field(name)
+      schema_resource = @query_fields[name.underscore.to_sym]
+      Graphiti.resources.find { |r| r.name == schema_resource.name }
+    end
+
     private
 
     def add_index(query_class, resource)
-      field = query_class.field resource.graphql_entrypoint,
+      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}",
         null: false
+      @query_fields[field_name] = resource
       define_arguments_for_sideload_field(field, resource)
     end
 
     def add_show(query_class, resource)
-      entrypoint = resource.graphql_entrypoint.to_s.singularize.to_sym
-      field = query_class.field entrypoint,
+      field_name = resource.graphql_entrypoint.to_s.underscore.singularize.to_sym
+      field = query_class.field field_name,
         type_registry[resource.graphql_class_name][:type],
         "Single #{resource.graphql_class_name(false).singularize}",
         null: true
+      @query_fields[field_name] = resource
       define_arguments_for_sideload_field field,
         resource,
         top_level_single: true
     end
 
-    def entrypoints(graphiti_schema, manually_specified)
+    def get_entrypoints(manually_specified)
       resources = graphiti_schema.resources
       if manually_specified
         resources = resources.select { |r|
@@ -309,13 +198,17 @@ module GraphitiGraphQL
       if top_level_single
         field.argument(:id, String, required: true)
       else
-        sort_type = generate_sort_type(resource)
-        field.argument :sort, [sort_type], required: false
+        unless resource.sorts.empty?
+          sort_type = generate_sort_type(resource)
+          field.argument :sort, [sort_type], required: false
+        end
         field.argument :page, PageType, required: false
 
-        filter_type = generate_filter_type(field, resource)
-        required = resource.filters.any? { |name, config| !!config[:required] }
-        field.argument :filter, filter_type, required: required
+        unless resource.filters.empty?
+          filter_type = generate_filter_type(field, resource)
+          required = resource.filters.any? { |name, config| !!config[:required] }
+          field.argument :filter, filter_type, required: required
+        end
       end
     end
 
@@ -413,8 +306,9 @@ module GraphitiGraphQL
         klass = Module.new
         klass.send(:include, self.class.base_interface)
         klass.definition_methods do
+          # rubocop:disable Lint/NestedMethodDefinition(Standard)
           def resolve_type(object, context)
-            Graphiti.graphql_schema.schema.types[object[:__typename]]
+            GraphitiGraphQL.schemas.graphql.types[object[:__typename]]
           end
         end
       else
@@ -426,10 +320,6 @@ module GraphitiGraphQL
         implement(klass, type_registry[implements])
       end
 
-      if self.class.federation?
-        klass.key fields: "id"
-      end
-
       klass.field(:_type, String, null: false)
       resource.all_attributes.each do |name, config|
         if config[:readable]

data/lib/graphiti_graphql/util.rb

@@ -24,4 +24,4 @@ module GraphitiGraphQL
       end
     end
   end
-end
+end

data/lib/graphiti_graphql/version.rb

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

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: graphiti_graphql
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Lee Richmond
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-03-01 00:00:00.000000000 Z
+date: 2021-03-07 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphiti
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.33
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.33
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -227,6 +241,13 @@ files:
 - lib/graphiti_graphql/engine.rb
 - lib/graphiti_graphql/errors.rb
 - lib/graphiti_graphql/federation.rb
+- lib/graphiti_graphql/federation/apollo_federation_override.rb
+- lib/graphiti_graphql/federation/federated_relationship.rb
+- lib/graphiti_graphql/federation/federated_resource.rb
+- lib/graphiti_graphql/federation/loaders/belongs_to.rb
+- lib/graphiti_graphql/federation/loaders/has_many.rb
+- lib/graphiti_graphql/federation/resource_dsl.rb
+- lib/graphiti_graphql/federation/schema_decorator.rb
 - lib/graphiti_graphql/graphiti_schema/resource.rb
 - lib/graphiti_graphql/graphiti_schema/sideload.rb
 - lib/graphiti_graphql/graphiti_schema/wrapper.rb