graphiti_graphql 0.1.0 → 0.1.5

data/lib/graphiti_graphql/graphiti_schema/resource.rb

@@ -59,18 +59,14 @@ module GraphitiGraphQL
         !!config[:remote]
       end
 
-      def fetch_remote_schema!
-        parts = remote_url.split("/")
-        parts.pop
-        url = "#{parts.join("/")}/vandal/schema.json"
-        response = faraday.get(url)
-        JSON.parse(response.body).deep_symbolize_keys
-      end
-
       def name
         config[:name]
       end
 
+      def stats
+        config[:stats]
+      end
+
       def type
         config[:type]
       end
@@ -102,16 +98,6 @@ module GraphitiGraphQL
       def all_attributes
         attributes.merge(extra_attributes)
       end
-
-      private
-
-      def faraday
-        if defined?(Faraday)
-          Faraday
-        else
-          raise "Faraday not defined. Please require the 'faraday' gem to use remote resources"
-        end
-      end
     end
   end
 end

data/lib/graphiti_graphql/graphiti_schema/wrapper.rb

@@ -16,21 +16,6 @@ module GraphitiGraphQL
       def resources
         schema[:resources].map { |r| get_resource(r[:name]) }
       end
-
-      # TODO some work here, dupes, refer back, etc
-      def merge_remotes!
-        resources.select(&:remote?).each do |resource|
-          remote_schema = resource.fetch_remote_schema!
-          remote_schema[:resources].each do |remote_config|
-            unless resources.map(&:name).include?(remote_config[:name])
-              remote_config[:name] = resource.name
-              schema[:resources].reject! { |r| r[:name] == resource.name }
-              schema[:resources] << remote_config
-              schema
-            end
-          end
-        end
-      end
     end
   end
 end

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)}
@@ -32,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
@@ -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)
@@ -118,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
@@ -146,8 +140,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,
@@ -233,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}
@@ -309,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

@@ -3,6 +3,7 @@ module GraphitiGraphQL
     GQL_TYPE_MAP = {
       integer_id: String,
       string: String,
+      uuid: String,
       integer: Integer,
       float: Float,
       boolean: GraphQL::Schema::Member::GraphQLTypeNames::Boolean,
@@ -33,6 +34,7 @@ module GraphitiGraphQL
     end
 
     attr_accessor :type_registry, :schema, :graphiti_schema
+    attr_reader :query_fields
 
     def self.federation?
       !!@federation
@@ -53,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
 
@@ -82,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)
 
@@ -243,28 +115,65 @@ 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,
-        [type_registry[resource.graphql_class_name][:type]],
+    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,
+        generate_connection_type(resource, top_level: true),
+        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
+        null: false
+      @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|
@@ -308,13 +217,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
 
@@ -338,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)
@@ -375,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,
@@ -383,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
@@ -412,8 +349,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
@@ -425,10 +363,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]
@@ -482,8 +416,27 @@ 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)
+      name = resource.graphql_class_name(true)
       !!type_registry[name]
     end