activeadmin-graphql 0.1.0

data/lib/active_admin/graphql/schema_builder/build.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    class SchemaBuilder
+      module Build
+        def build
+          unless defined?(ActiveRecord::Base)
+            raise ActiveAdmin::DependencyError, "ActiveAdmin::GraphQL requires ActiveRecord."
+          end
+
+          @aa_by_model = {}
+          @object_types = {}
+          @enum_types = {}
+          @create_input_types = {}
+          @update_input_types = {}
+          @list_filter_input_types = {}
+          @find_input_types = {}
+          @aa_by_graphql_type_name = {}
+
+          active_resources.each do |aa_res|
+            model = aa_res.resource_class
+            @aa_by_model[model] = aa_res
+            @object_types[model] = build_object_type(aa_res)
+            @aa_by_graphql_type_name[graphql_type_name_for(aa_res)] = aa_res
+          end
+
+          wire_belongs_to_associations
+
+          active_resources.each do |aa_res|
+            model = aa_res.resource_class
+            @create_input_types[model] = build_create_input_type(aa_res)
+            @update_input_types[model] = build_update_input_type(aa_res)
+            @list_filter_input_types[model] = build_list_filter_input_type(aa_res)
+            @find_input_types[model] = build_find_input_type(aa_res)
+          end
+
+          union_members = @object_types.values.uniq
+          registered_resource_union =
+            if union_members.any?
+              u = Class.new(::GraphQL::Schema::Union) do
+                graphql_name "ActiveAdminRegisteredResource"
+                description "Any resource object type registered for GraphQL in this namespace."
+                possible_types(*union_members)
+              end
+              attach_registered_resource_union_visibility!(u)
+              u
+            end
+
+          query_type = build_query_type(registered_resource_union: registered_resource_union)
+          mutation_type = build_mutation_type
+
+          model_to_type = @object_types
+
+          schema = Class.new(::GraphQL::Schema)
+          schema.query(query_type)
+          schema.mutation(mutation_type) if mutation_type
+          dataloader_plugin = @namespace.graphql_dataloader || ::GraphQL::Dataloader
+          schema.use(dataloader_plugin)
+          apply_graphql_visibility!(schema)
+          if registered_resource_union
+            schema.define_singleton_method(:resolve_type) do |abstract_type, obj, ctx|
+              if abstract_type == registered_resource_union
+                typ = model_to_type[obj.class]
+                unless typ
+                  raise ::GraphQL::ExecutionError,
+                    "ActiveAdminRegisteredResource could not resolve type for #{obj.class.name}"
+                end
+
+                typ
+              else
+                super(abstract_type, obj, ctx)
+              end
+            end
+          end
+          configure_schema_plugins(schema)
+          hook = @namespace.graphql_configure_schema
+          hook.call(schema) if hook.respond_to?(:call)
+          schema
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/schema_builder/graph_params.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    class SchemaBuilder
+      module GraphParams
+        def graph_params_from_field_kwargs(aa_res, scope: nil, q: nil, order: nil, **kw)
+          h = {}
+          h[:scope] = scope if scope.present?
+          h[:q] = q if !q.nil?
+          h[:order] = order if order.present?
+          merge_belongs_to_kw!(aa_res, kw, h)
+        end
+
+        def graph_params_for_mutation(aa_res, kw)
+          merge_belongs_to_kw!(aa_res, kw, {})
+        end
+
+        def graph_params_from_input(aa_res, input)
+          h = {}
+          return h if input.nil?
+
+          blob = input.to_h.stringify_keys
+          if (btc = aa_res.belongs_to_config)
+            k = btc.to_param.to_s
+            h[k] = blob[k] if blob.key?(k) && blob[k].present?
+          end
+          h
+        end
+
+        def assignable_slice_from_input(aa_res, input)
+          blob = input.to_h.stringify_keys
+          names = aa_res.graphql_assignable_attribute_names.map(&:to_s)
+          if (btc = aa_res.belongs_to_config)
+            names -= [btc.to_param.to_s]
+          end
+          blob.slice(*names)
+        end
+
+        def list_graph_params(aa_res, filter:, scope:, q:, order:, **kw)
+          h = graph_params_from_field_kwargs(aa_res, scope: scope, q: q, order: order, **kw)
+          return h unless filter
+
+          fh = filter.to_h.stringify_keys
+          h["scope"] = fh["scope"] if fh.key?("scope")
+          h["order"] = fh["order"] if fh.key?("order")
+          h["q"] = fh["q"] if fh.key?("q")
+          if (btc = aa_res.belongs_to_config)
+            pk = btc.to_param.to_s
+            h[pk] = fh[pk] if fh.key?(pk)
+          end
+          h
+        end
+
+        def graph_params_from_find_blob(aa_res, blob)
+          h = {}
+          if (btc = aa_res.belongs_to_config)
+            k = btc.to_param.to_s
+            h[k] = blob[k] if blob.key?(k)
+          end
+          h
+        end
+
+        def merge_belongs_to_kw!(aa_res, kw, h)
+          if (btc = aa_res.belongs_to_config)
+            key = btc.to_param
+            val = kw[key] || kw[key.to_s] || kw[key.to_sym]
+            h[key] = val if val.present?
+          end
+          h
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/schema_builder/mutation_action_types.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    class SchemaBuilder
+      module MutationActionTypes
+        private
+
+        def defined_actions_for(aa_res)
+          aa_res.controller.instance_methods.map(&:to_sym) & ActiveAdmin::ResourceController::ACTIVE_ADMIN_ACTIONS
+        end
+
+        def run_action_return_type(aa_res, kind)
+          cfg = aa_res.graphql_config
+          specific = case kind
+          when :batch then cfg.batch_run_action.payload_type
+          when :member then cfg.member_run_action.payload_type
+          when :collection then cfg.collection_run_action.payload_type
+          else
+            raise ArgumentError, "unknown run-action kind #{kind.inspect}"
+          end
+          ty = specific || cfg.run_action_payload_type || RunActionPayload
+          ensure_run_action_graphql_object!(aa_res, ty)
+          ty
+        end
+
+        def member_action_return_type(aa_res, action_name)
+          per = aa_res.graphql_config.member_action_mutations[action_name.to_s]
+          ty = per&.payload_type || aa_res.graphql_config.member_run_action.payload_type ||
+            aa_res.graphql_config.run_action_payload_type || RunActionPayload
+          ensure_run_action_graphql_object!(aa_res, ty)
+          ty
+        end
+
+        def collection_action_return_type(aa_res, action_name)
+          per = aa_res.graphql_config.collection_action_mutations[action_name.to_s]
+          ty = per&.payload_type || aa_res.graphql_config.collection_run_action.payload_type ||
+            aa_res.graphql_config.run_action_payload_type || RunActionPayload
+          ensure_run_action_graphql_object!(aa_res, ty)
+          ty
+        end
+
+        def ensure_run_action_graphql_object!(aa_res, ty)
+          unless ty.is_a?(Class) && ty < ::GraphQL::Schema::Object
+            raise ActiveAdmin::DependencyError,
+              "#{aa_res.resource_name} graphql run_action payload type must be a GraphQL::Schema::Object subclass, got #{ty.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/schema_builder/mutation_batch.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    class SchemaBuilder
+      module MutationBatch
+        private
+
+        def mutation_batch_field(sb, ns, aa_res)
+          plural = aa_res.resource_name.route_key.tr("-", "_")
+          fname = "#{plural}_batch_action"
+          allowed = aa_res.batch_actions.map { |a| a.sym.to_s }.freeze
+          batch_payload_t = run_action_return_type(aa_res, :batch)
+
+          proc do
+            field fname.to_sym, batch_payload_t, null: false, camelize: false,
+              visibility: {kind: :mutation_batch_action, graphql_type_name: sb.send(:graphql_type_name_for, aa_res), resource: aa_res, field_name: fname},
+              description: "Run a batch action registered on #{aa_res.resource_name} (+batch_action+ DSL), " \
+                    "same as the index batch UI (+collection_selection+ / +batch_action_inputs+)." do
+              argument :batch_action, ::GraphQL::Types::String, required: true, camelize: false
+              argument :ids, [::GraphQL::Types::ID], required: true, camelize: false
+              argument :inputs, [KeyValuePairInput], required: false, camelize: false,
+                description: "Batch action form fields as key/value pairs (passed as +batch_action_inputs+)."
+              if (btc = aa_res.belongs_to_config)
+                argument btc.to_param.to_sym, ::GraphQL::Types::ID, required: btc.required?, camelize: false
+              end
+            end
+
+            define_method(fname.to_sym) do |batch_action:, ids:, inputs: nil, **kw|
+              auth = context[:auth]
+              mdl = aa_res.resource_class
+              unless auth.authorized?(aa_res, ActiveAdmin::Authorization::READ, mdl)
+                raise ::GraphQL::ExecutionError, "not authorized to read #{mdl.name}"
+              end
+
+              ba = batch_action.to_s
+              unless allowed.include?(ba)
+                raise ::GraphQL::ExecutionError, "Unknown batch_action #{ba.inspect} for #{plural}"
+              end
+
+              proxy = ResourceQueryProxy.new(
+                aa_resource: aa_res,
+                user: context[:auth].user,
+                namespace: ns,
+                graph_params: sb.graph_params_for_mutation(aa_res, kw)
+              )
+              sb.graphql_resolve_batch_action(
+                aa_res,
+                proxy: proxy,
+                context: context,
+                batch_action: ba,
+                ids: ids,
+                inputs: inputs
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/schema_builder/mutation_collection.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    class SchemaBuilder
+      module MutationCollection
+        private
+
+        def mutation_collection_fields(sb, ns, aa_res)
+          [mutation_collection_aggregate_field(sb, ns, aa_res)] + aa_res.collection_actions.map do |ca|
+            mutation_single_collection_action_field(sb, ns, aa_res, ca)
+          end
+        end
+
+        def mutation_collection_aggregate_field(sb, ns, aa_res)
+          plural = aa_res.resource_name.route_key.tr("-", "_")
+          fname = "#{plural}_collection_action"
+          allowed = aa_res.collection_actions.map { |a| a.name.to_s }.freeze
+          collection_payload_t = run_action_return_type(aa_res, :collection)
+
+          proc do
+            field fname.to_sym, collection_payload_t, null: false, camelize: false,
+              visibility: {kind: :mutation_collection_action, graphql_type_name: sb.send(:graphql_type_name_for, aa_res), resource: aa_res, field_name: fname, aggregate: true},
+              description: "Invoke a +collection_action+ on #{aa_res.resource_name} by name (same scoping as REST +index+). Prefer per-action fields +#{plural}_collection_<action>+ for distinct inputs or return types." do
+              argument :action, ::GraphQL::Types::String, required: true, camelize: false
+              argument :params, [KeyValuePairInput], required: false, camelize: false,
+                description: "Extra request params as flat key/value pairs."
+              if (btc = aa_res.belongs_to_config)
+                argument btc.to_param.to_sym, ::GraphQL::Types::ID, required: btc.required?, camelize: false
+              end
+            end
+
+            define_method(fname.to_sym) do |action:, params: nil, **kw|
+              auth = context[:auth]
+              mdl = aa_res.resource_class
+              unless auth.authorized?(aa_res, ActiveAdmin::Authorization::READ, mdl)
+                raise ::GraphQL::ExecutionError, "not authorized to read #{mdl.name}"
+              end
+
+              act = action.to_s
+              unless allowed.include?(act)
+                raise ::GraphQL::ExecutionError, "Unknown collection action #{act.inspect} for #{plural}"
+              end
+
+              proxy = ResourceQueryProxy.new(
+                aa_resource: aa_res,
+                user: context[:auth].user,
+                namespace: ns,
+                graph_params: sb.graph_params_for_mutation(aa_res, kw)
+              )
+              sb.graphql_resolve_collection_action(
+                aa_res,
+                proxy: proxy,
+                context: context,
+                action: act,
+                params: params,
+                **kw
+              )
+            end
+          end
+        end
+
+        def mutation_single_collection_action_field(sb, ns, aa_res, collection_action_def)
+          plural = aa_res.resource_name.route_key.tr("-", "_")
+          action_name = collection_action_def.name.to_s
+          field_name = "#{plural}_collection_#{action_name.tr("-", "_")}"
+          fname = field_name.to_sym
+          per_cfg = aa_res.graphql_config.collection_action_mutations[action_name]
+          collection_payload_t = collection_action_return_type(aa_res, action_name)
+
+          proc do
+            field fname, collection_payload_t, null: false, camelize: false,
+              visibility: {
+                kind: :mutation_collection_action,
+                graphql_type_name: sb.send(:graphql_type_name_for, aa_res),
+                resource: aa_res,
+                field_name: field_name,
+                collection_action: action_name
+              },
+              description: "Invoke +collection_action+ #{action_name} on #{aa_res.resource_name} (same scoping as REST +index+)." do
+              argument :params, [KeyValuePairInput], required: false, camelize: false,
+                description: "Extra request params as flat key/value pairs."
+              if (btc = aa_res.belongs_to_config)
+                argument btc.to_param.to_sym, ::GraphQL::Types::ID, required: btc.required?, camelize: false
+              end
+              if per_cfg&.arguments_proc
+                instance_exec(&per_cfg.arguments_proc)
+              end
+            end
+
+            define_method(fname) do |params: nil, **kw|
+              auth = context[:auth]
+              mdl = aa_res.resource_class
+              unless auth.authorized?(aa_res, ActiveAdmin::Authorization::READ, mdl)
+                raise ::GraphQL::ExecutionError, "not authorized to read #{mdl.name}"
+              end
+
+              proxy = ResourceQueryProxy.new(
+                aa_resource: aa_res,
+                user: context[:auth].user,
+                namespace: ns,
+                graph_params: sb.graph_params_for_mutation(aa_res, kw)
+              )
+              sb.graphql_resolve_collection_action(
+                aa_res,
+                proxy: proxy,
+                context: context,
+                action: action_name,
+                params: params,
+                **kw
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/schema_builder/mutation_create.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    class SchemaBuilder
+      module MutationCreate
+        private
+
+        def mutation_create_field(sb, ns, aa_res, model, type_c)
+          fname = "create_#{aa_res.resource_name.route_key.singularize.tr("-", "_")}"
+          create_input = @create_input_types[model]
+
+          proc do
+            field fname.to_sym, type_c, null: true, camelize: false,
+              visibility: {kind: :mutation_create, graphql_type_name: sb.send(:graphql_type_name_for, aa_res), resource: aa_res},
+              description: "Create #{model.name}" do
+              argument :input, create_input, required: true, camelize: false
+            end
+
+            define_method(fname.to_sym) do |input:, **|
+              auth = context[:auth]
+              unless auth.authorized?(aa_res, ActiveAdmin::Authorization::CREATE, model)
+                raise ::GraphQL::ExecutionError, "not authorized to create #{model.name}"
+              end
+
+              proxy = ResourceQueryProxy.new(
+                aa_resource: aa_res,
+                user: auth.user,
+                namespace: ns,
+                graph_params: sb.graph_params_from_input(aa_res, input)
+              )
+              attrs = sb.assignable_slice_from_input(aa_res, input)
+              record = if (hook = aa_res.graphql_config.resolve_create_proc)
+                hook.call(
+                  proxy: proxy,
+                  input: input,
+                  attributes: attrs,
+                  context: context,
+                  auth: auth,
+                  aa_resource: aa_res
+                )
+              else
+                r = proxy.build_new(attrs)
+                unless auth.authorized?(aa_res, ActiveAdmin::Authorization::CREATE, r)
+                  raise ::GraphQL::ExecutionError, "not authorized to create this record"
+                end
+
+                unless r.save
+                  raise ::GraphQL::ExecutionError, r.errors.full_messages.to_sentence
+                end
+                r
+              end
+
+              unless auth.authorized?(aa_res, ActiveAdmin::Authorization::CREATE, record)
+                raise ::GraphQL::ExecutionError, "not authorized to create this record"
+              end
+
+              record
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/schema_builder/mutation_member.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    class SchemaBuilder
+      module MutationMember
+        private
+
+        def mutation_member_fields(sb, ns, aa_res)
+          [mutation_member_aggregate_field(sb, ns, aa_res)] + aa_res.member_actions.map do |ma|
+            mutation_single_member_action_field(sb, ns, aa_res, ma)
+          end
+        end
+
+        def mutation_member_aggregate_field(sb, ns, aa_res)
+          plural = aa_res.resource_name.route_key.tr("-", "_")
+          fname = "#{plural}_member_action"
+          allowed = aa_res.member_actions.map { |a| a.name.to_s }.freeze
+          member_payload_t = run_action_return_type(aa_res, :member)
+
+          proc do
+            field fname.to_sym, member_payload_t, null: false, camelize: false,
+              visibility: {kind: :mutation_member_action, graphql_type_name: sb.send(:graphql_type_name_for, aa_res), resource: aa_res, field_name: fname, aggregate: true},
+              description: "Invoke a +member_action+ on #{aa_res.resource_name} by name (same scoping as REST +show+). Prefer per-action fields +#{plural}_member_<action>+ for distinct inputs or return types." do
+              argument :action, ::GraphQL::Types::String, required: true, camelize: false
+              argument :id, ::GraphQL::Types::ID, required: true, camelize: false
+              argument :params, [KeyValuePairInput], required: false, camelize: false,
+                description: "Extra request params as flat key/value pairs."
+              if (btc = aa_res.belongs_to_config)
+                argument btc.to_param.to_sym, ::GraphQL::Types::ID, required: btc.required?, camelize: false
+              end
+            end
+
+            define_method(fname.to_sym) do |action:, id:, params: nil, **kw|
+              auth = context[:auth]
+              mdl = aa_res.resource_class
+              unless auth.authorized?(aa_res, ActiveAdmin::Authorization::READ, mdl)
+                raise ::GraphQL::ExecutionError, "not authorized to read #{mdl.name}"
+              end
+
+              act = action.to_s
+              unless allowed.include?(act)
+                raise ::GraphQL::ExecutionError, "Unknown member action #{act.inspect} for #{plural}"
+              end
+
+              proxy = ResourceQueryProxy.new(
+                aa_resource: aa_res,
+                user: context[:auth].user,
+                namespace: ns,
+                graph_params: sb.graph_params_for_mutation(aa_res, kw)
+              )
+              sb.graphql_resolve_member_action(
+                aa_res,
+                proxy: proxy,
+                context: context,
+                action: act,
+                id: id,
+                params: params,
+                **kw
+              )
+            end
+          end
+        end
+
+        def mutation_single_member_action_field(sb, ns, aa_res, member_action_def)
+          plural = aa_res.resource_name.route_key.tr("-", "_")
+          action_name = member_action_def.name.to_s
+          field_name = "#{plural}_member_#{action_name.tr("-", "_")}"
+          fname = field_name.to_sym
+          per_cfg = aa_res.graphql_config.member_action_mutations[action_name]
+          member_payload_t = member_action_return_type(aa_res, action_name)
+
+          proc do
+            field fname, member_payload_t, null: false, camelize: false,
+              visibility: {
+                kind: :mutation_member_action,
+                graphql_type_name: sb.send(:graphql_type_name_for, aa_res),
+                resource: aa_res,
+                field_name: field_name,
+                member_action: action_name
+              },
+              description: "Invoke +member_action+ #{action_name} on #{aa_res.resource_name} (same scoping as REST +show+)." do
+              argument :id, ::GraphQL::Types::ID, required: true, camelize: false
+              argument :params, [KeyValuePairInput], required: false, camelize: false,
+                description: "Extra request params as flat key/value pairs."
+              if (btc = aa_res.belongs_to_config)
+                argument btc.to_param.to_sym, ::GraphQL::Types::ID, required: btc.required?, camelize: false
+              end
+              if per_cfg&.arguments_proc
+                instance_exec(&per_cfg.arguments_proc)
+              end
+            end
+
+            define_method(fname) do |id:, params: nil, **kw|
+              auth = context[:auth]
+              mdl = aa_res.resource_class
+              unless auth.authorized?(aa_res, ActiveAdmin::Authorization::READ, mdl)
+                raise ::GraphQL::ExecutionError, "not authorized to read #{mdl.name}"
+              end
+
+              proxy = ResourceQueryProxy.new(
+                aa_resource: aa_res,
+                user: context[:auth].user,
+                namespace: ns,
+                graph_params: sb.graph_params_for_mutation(aa_res, kw)
+              )
+              sb.graphql_resolve_member_action(
+                aa_res,
+                proxy: proxy,
+                context: context,
+                action: action_name,
+                id: id,
+                params: params,
+                **kw
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/schema_builder/mutation_type_builder.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    class SchemaBuilder
+      module MutationTypeBuilder
+        private
+
+        def build_mutation_type
+          mutations = []
+          ns = @namespace
+          sb = self
+
+          active_resources.each do |aa_res|
+            model = aa_res.resource_class
+            type_c = @object_types[model]
+            next unless type_c
+
+            actions = defined_actions_for(aa_res)
+
+            if actions.include?(:create)
+              mutations << mutation_create_field(sb, ns, aa_res, model, type_c)
+            end
+            if actions.include?(:update)
+              mutations << mutation_update_field(sb, ns, aa_res, model, type_c)
+            end
+            if actions.include?(:destroy)
+              mutations << mutation_destroy_field(sb, ns, aa_res, model)
+            end
+
+            if aa_res.batch_actions_enabled? && aa_res.batch_actions.any?
+              mutations << mutation_batch_field(sb, ns, aa_res)
+            end
+            mutations.concat(mutation_member_fields(sb, ns, aa_res)) if aa_res.member_actions.any?
+            mutations.concat(mutation_collection_fields(sb, ns, aa_res)) if aa_res.collection_actions.any?
+          end
+
+          return nil if mutations.empty?
+
+          Class.new(::GraphQL::Schema::Object) do
+            field_class ::ActiveAdmin::GraphQL::SchemaField
+
+            graphql_name "Mutation"
+            description "ActiveAdmin GraphQL mutations (#{ns.name})"
+
+            mutations.each { |m| class_eval(&m) }
+          end
+        end
+      end
+    end
+  end
+end