activeadmin-graphql 0.1.0

data/lib/active_admin/graphql/key_value_pair_input.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    # Shared input for flat string key/value pairs (Rails param-style). Used instead of a JSON map
+    # for nested route segments and custom action arguments so the schema stays explicit.
+    class KeyValuePairInput < ::GraphQL::Schema::InputObject
+      graphql_name "ActiveAdminKeyValuePair"
+      description "Param entry: string key and value (same shape as flat Rails query/form fields)."
+
+      argument :key, ::GraphQL::Types::String, required: true, camelize: false
+      argument :value, ::GraphQL::Types::String, required: true, camelize: false
+    end
+
+    module KeyValuePairs
+      module_function
+
+      # @param entries [nil, Array<#key, #value>, Array<Hash>]
+      # @return [Hash<String, String>]
+      def to_hash(entries)
+        return {} if entries.nil?
+
+        unless entries.is_a?(Array)
+          raise ArgumentError, "expected an array of key/value pairs, got #{entries.class}"
+        end
+
+        entries.each_with_object({}) do |e, h|
+          key, val = extract_pair(e)
+          h[key.to_s] = val.to_s
+        end
+      end
+
+      def extract_pair(e)
+        if e.respond_to?(:key) && e.respond_to?(:value) && !e.is_a?(Hash)
+          [e.key, e.value]
+        elsif e.is_a?(Hash)
+          k = e["key"] || e[:key]
+          v = e["value"] || e[:value]
+          raise ::GraphQL::ExecutionError, "key/value pair missing key" if k.nil?
+
+          [k, v]
+        else
+          raise ::GraphQL::ExecutionError, "invalid key/value pair entry: #{e.class}"
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/railtie.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "engine"
+
+module ActiveAdmin
+  module GraphQL
+    class Railtie < ::Rails::Railtie
+    end
+  end
+end

data/lib/active_admin/graphql/record_source.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    # Batches +find+ by primary key for belongs_to-style fields (graphql-ruby dataloader).
+    class RecordSource < ::GraphQL::Dataloader::Source
+      def initialize(model_class)
+        @model_class = model_class
+        @pk = model_class.primary_key
+      end
+
+      def fetch(ids)
+        keys = ids.map { |raw| raw.nil? ? nil : ActiveAdmin::PrimaryKey.dataloader_tuple(@model_class, raw) }
+        uniq = keys.compact.uniq
+        return ids.map { nil } if uniq.empty?
+
+        if ActiveAdmin::PrimaryKey.composite?(@model_class)
+          records = @model_class.where(@pk => uniq).to_a
+          by_tuple = records.index_by { |r| ActiveAdmin::PrimaryKey.dataloader_tuple_from_record(r) }
+          keys.map { |t| t.nil? ? nil : by_tuple[t] }
+        else
+          pk_sym = @pk.to_sym
+          records = @model_class.where(pk_sym => uniq).to_a
+          by_id = records.index_by { |r| r.public_send(pk_sym) }
+          keys.map { |k| k.nil? ? nil : by_id[k] }
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/resource_config.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "run_action_mutation_config"
+
+module ActiveAdmin
+  module GraphQL
+    # Per-resource GraphQL options set via +graphql+ in +ActiveAdmin.register+.
+    class ResourceConfig
+      attr_accessor :enabled
+      attr_accessor :graphql_type_name
+      attr_accessor :only_attributes
+      attr_accessor :exclude_attributes
+      attr_accessor :extension_block
+
+      # Optional resolver overrides (set from +graphql do+). SchemaBuilder still owns field names,
+      # arguments, and types; procs replace only the Ruby resolution body.
+      attr_accessor :resolve_index_proc
+      attr_accessor :resolve_show_proc
+      attr_accessor :resolve_create_proc
+      attr_accessor :resolve_update_proc
+      attr_accessor :resolve_destroy_proc
+
+      # Default return type for run-action mutations (+batch+, +member+, +collection+) when a kind-specific
+      # {RunActionMutationConfig#payload_type} is not set. Falls back to {RunActionPayload}.
+      attr_accessor :run_action_payload_type
+
+      def initialize
+        @enabled = true
+        @exclude_attributes = []
+      end
+
+      def disabled?
+        !enabled
+      end
+
+      def batch_run_action
+        @batch_run_action ||= RunActionMutationConfig.new
+      end
+
+      def member_run_action
+        @member_run_action ||= RunActionMutationConfig.new
+      end
+
+      def collection_run_action
+        @collection_run_action ||= RunActionMutationConfig.new
+      end
+
+      # Per +member_action+ name (string) -> {RunActionMutationConfig} for typed fields like +posts_member_publish+.
+      def member_action_mutations
+        @member_action_mutations ||= {}
+      end
+
+      def member_action_mutation_for(name)
+        key = name.to_s
+        member_action_mutations[key] ||= RunActionMutationConfig.new
+      end
+
+      def collection_action_mutations
+        @collection_action_mutations ||= {}
+      end
+
+      def collection_action_mutation_for(name)
+        key = name.to_s
+        collection_action_mutations[key] ||= RunActionMutationConfig.new
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/resource_definition_dsl.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative "run_action_mutation_config"
+require_relative "run_action_mutation_dsl"
+
+module ActiveAdmin
+  module GraphQL
+    # DSL for +graphql do ... end+ inside +ActiveAdmin.register+.
+    class ResourceDefinitionDSL
+      def initialize(config)
+        @config = config
+      end
+
+      def disable!
+        @config.enabled = false
+      end
+
+      def type_name(name)
+        @config.graphql_type_name = name.to_s
+      end
+
+      def only(*attrs)
+        @config.only_attributes = attrs.flatten.map(&:to_sym)
+      end
+
+      def except(*attrs)
+        @config.exclude_attributes.concat(attrs.flatten.map(&:to_sym))
+      end
+      alias_method :exclude, :except
+
+      def configure(&block)
+        @config.extension_block = block
+      end
+
+      # Override the list field resolver (+posts+, etc.). Must return an +ActiveRecord::Relation+
+      # (or compatible with the connection type). Same auth and +ResourceQueryProxy+ as the default.
+      def resolve_index(&block)
+        @config.resolve_index_proc = block
+      end
+      alias_method :resolve_collection, :resolve_index
+
+      # Override the singular field resolver (+post+, +registered_resource+ for this type).
+      # Must return a record instance or +nil+.
+      def resolve_show(&block)
+        @config.resolve_show_proc = block
+      end
+      alias_method :resolve_member, :resolve_show
+
+      def resolve_create(&block)
+        @config.resolve_create_proc = block
+      end
+
+      def resolve_update(&block)
+        @config.resolve_update_proc = block
+      end
+
+      def resolve_destroy(&block)
+        @config.resolve_destroy_proc = block
+      end
+
+      # @see #batch_action_mutation
+      def resolve_batch_action(&block)
+        @config.batch_run_action.resolve_proc = block
+      end
+
+      # @see #member_action_mutation
+      def resolve_member_action(&block)
+        @config.member_run_action.resolve_proc = block
+      end
+
+      # @see #collection_action_mutation
+      def resolve_collection_action(&block)
+        @config.collection_run_action.resolve_proc = block
+      end
+
+      # Pair +type+ and +resolve+ for +posts_batch_action+ (graphql-ruby-style block).
+      def batch_action_mutation(&block)
+        RunActionMutationDSL.new(@config.batch_run_action).instance_exec(&block)
+      end
+
+      # With no name: configures the aggregate +posts_member_action(action: …)+ field.
+      # With a symbol/string: configures +posts_member_<action>+ (one field per +member_action+), so each
+      # action can use its own +type+, +resolve+, +arguments+, and GraphQL inputs.
+      def member_action_mutation(name = nil, &block)
+        cfg = name.nil? ? @config.member_run_action : @config.member_action_mutation_for(name)
+        RunActionMutationDSL.new(cfg).instance_exec(&block)
+      end
+
+      def collection_action_mutation(name = nil, &block)
+        cfg = name.nil? ? @config.collection_run_action : @config.collection_action_mutation_for(name)
+        RunActionMutationDSL.new(cfg).instance_exec(&block)
+      end
+
+      # Default return type for all run-action fields unless a kind-specific +type+ is set inside
+      # +batch_action_mutation+ / +member_action_mutation+ / +collection_action_mutation+.
+      def run_action_payload_type(type)
+        RunActionMutationConfig.ensure_graphql_object_subclass!(type)
+        @config.run_action_payload_type = type
+      end
+
+      def batch_action_run_action_payload_type(type)
+        RunActionMutationConfig.ensure_graphql_object_subclass!(type)
+        @config.batch_run_action.payload_type = type
+      end
+
+      def member_action_run_action_payload_type(type)
+        RunActionMutationConfig.ensure_graphql_object_subclass!(type)
+        @config.member_run_action.payload_type = type
+      end
+
+      def collection_action_run_action_payload_type(type)
+        RunActionMutationConfig.ensure_graphql_object_subclass!(type)
+        @config.collection_run_action.payload_type = type
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/resource_interface.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    # Implemented by every namespace resource +GraphQL::Schema::Object+ type so clients can
+    # fragment on a shared +id+ field or use abstract selections consistently.
+    module ResourceInterface
+      include ::GraphQL::Schema::Interface
+
+      graphql_name "ActiveAdminResource"
+      description "Shared shape for Active Admin resource records exposed in this namespace."
+
+      field :id, ::GraphQL::Types::ID, null: false
+
+      definition_methods do
+        def visible?(context)
+          hook = context[:namespace]&.graphql_schema_visible
+          return super if hook.nil?
+
+          super && !!hook.call(context, {kind: :resource_interface})
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/resource_query_proxy/controller.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    class ResourceQueryProxy
+      module Controller
+        private
+
+        def normalize_graph_params(graph_params)
+          h = graph_params.respond_to?(:to_unsafe_h) ? graph_params.to_unsafe_h : graph_params.to_h
+          h.stringify_keys
+        end
+
+        def param_hash_for(action, extra)
+          {
+            "action" => action,
+            "controller" => "active_admin/graphql"
+          }.merge(extra.stringify_keys).tap do |h|
+            merge_ransack!(h)
+            h["scope"] = @graph_params["scope"].to_s if @graph_params["scope"].present?
+            h["order"] = @graph_params["order"].to_s if @graph_params["order"].present?
+            merge_belongs_to!(h)
+          end
+        end
+
+        def merge_ransack!(h)
+          q = @graph_params["q"]
+          return if q.blank? && !@graph_params.key?("q")
+
+          h["q"] = normalize_q(q)
+        end
+
+        def normalize_q(q)
+          case q
+          when Hash
+            q.deep_stringify_keys
+          when ActionController::Parameters
+            q.to_unsafe_h.deep_stringify_keys
+          else
+            {}
+          end
+        end
+
+        def merge_belongs_to!(h)
+          btc = @aa_resource.belongs_to_config
+          return unless btc
+
+          key = btc.to_param.to_s
+          val = @graph_params[key]
+          h[key] = val.to_s if val.present?
+        end
+
+        def stub_controller!(controller, hash)
+          user = @user
+          params_obj = ActionController::Parameters.new(hash)
+          params_obj.permit!
+
+          controller.define_singleton_method(:params) { params_obj }
+          controller.define_singleton_method(:current_active_admin_user) { user }
+          controller.define_singleton_method(:current_user) { user }
+        end
+
+        def normalize_batch_inputs(inputs)
+          return {} if inputs.nil?
+
+          case inputs
+          when Array
+            KeyValuePairs.to_hash(inputs)
+          when String
+            JSON.parse(inputs)
+          when Hash
+            inputs
+          when ActionController::Parameters
+            inputs.to_unsafe_h
+          else
+            raise ::GraphQL::ExecutionError, "batch inputs must be a list of key/value pairs or a JSON object"
+          end.then do |h|
+            raise ::GraphQL::ExecutionError, "batch inputs must resolve to a hash" unless h.is_a?(Hash)
+
+            h.deep_stringify_keys
+          end
+        rescue JSON::ParserError => e
+          raise ::GraphQL::ExecutionError, "invalid batch inputs JSON (#{e.message})"
+        end
+
+        def normalize_extra_params(extra_params)
+          return {} if extra_params.nil?
+
+          if extra_params.is_a?(Array)
+            return KeyValuePairs.to_hash(extra_params)
+          end
+
+          h = extra_params.respond_to?(:to_unsafe_h) ? extra_params.to_unsafe_h : extra_params.to_h
+          h.stringify_keys
+        end
+
+        def attach_graphql_request!(controller)
+          return if controller.instance_variable_defined?(:@_request) && controller.request
+
+          env = Rack::MockRequest.env_for("http://test.host/", method: "POST", params: {_graphql: "1"})
+          req = ActionDispatch::Request.new(env)
+          res = ActionDispatch::Response.new
+          controller.send(:set_request!, req)
+          controller.send(:set_response!, res)
+          controller.define_singleton_method(:default_url_options) { {host: "test.host"} }
+        end
+
+        def perform_controller_command!(controller)
+          attach_graphql_request!(controller)
+          yield
+          build_run_payload(controller)
+        rescue ActiveAdmin::AccessDenied => e
+          raise ::GraphQL::ExecutionError, e.message
+        end
+
+        def build_run_payload(controller)
+          res = controller.response
+          RunActionPayload::Result.new(
+            ok: true,
+            status: res&.status,
+            location: extract_location(res),
+            body: extract_response_body(res)
+          )
+        end
+
+        def extract_location(res)
+          return nil unless res
+
+          loc = res.location if res.respond_to?(:location)
+          loc.presence || res.headers&.[]("Location")
+        end
+
+        def extract_response_body(res)
+          return nil unless res
+
+          b = res.body
+          return nil if b.nil? || (b.respond_to?(:empty?) && b.empty?)
+
+          s = b.is_a?(String) ? b : b.to_s
+          s = +s
+          s.force_encoding("UTF-8")
+          s.valid_encoding? ? s : nil
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/resource_query_proxy.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "rack/mock"
+
+require_relative "resource_query_proxy/controller"
+
+module ActiveAdmin
+  module GraphQL
+    # Reuses {ResourceController} data-access behaviour (+scoped_collection+, +find_collection+,
+    # +find_resource+, authorization scoping, Ransack, menu scopes, +sorting+, +includes+)
+    # so GraphQL list/detail mutations align with the HTML/JSON list and member REST endpoints.
+    class ResourceQueryProxy
+      include Controller
+
+      def initialize(aa_resource:, user:, namespace:, graph_params: {})
+        @aa_resource = aa_resource
+        @user = user
+        @namespace = namespace
+        @graph_params = normalize_graph_params(graph_params)
+      end
+
+      def relation_for_index
+        controller_for("index").send(:find_collection, except: %i[pagination collection_decorator])
+      end
+
+      def find_member(id)
+        extra = member_route_params_for_find(id)
+        controller_for("show", extra).send(:find_resource)
+      end
+
+      def build_new(attributes)
+        if missing_required_belongs_to?
+          raise ::GraphQL::ExecutionError,
+            "#{@aa_resource.belongs_to_config.to_param} is required for nested resource #{@aa_resource.resource_name}"
+        end
+
+        c = controller_for("new")
+        chain = c.send(:apply_authorization_scope, c.send(:scoped_collection))
+        permitted = attributes.stringify_keys.slice(*@aa_resource.graphql_assignable_attribute_names)
+        chain.build(permitted)
+      end
+
+      def run_batch_action(batch_sym, ids, inputs: {})
+        unless @aa_resource.batch_actions_enabled?
+          raise ::GraphQL::ExecutionError, "batch actions are disabled for #{@aa_resource.resource_name}"
+        end
+
+        inputs = normalize_batch_inputs(inputs)
+        extra = {
+          "batch_action" => batch_sym.to_s,
+          "collection_selection" => Array(ids).map(&:to_s),
+          "batch_action_inputs" => inputs.to_json
+        }
+        c = controller_for("batch_action", extra)
+        perform_controller_command!(c) { c.send(:batch_action) }
+      end
+
+      def run_member_action(action_name, id, extra_params: {})
+        action_name = action_name.to_s
+        unless @aa_resource.member_actions.any? { |a| a.name.to_s == action_name }
+          raise ::GraphQL::ExecutionError, "unknown member action #{action_name.inspect}"
+        end
+
+        extras = normalize_extra_params(extra_params)
+        c = controller_for(action_name, {"id" => id.to_s}.merge(extras))
+        perform_controller_command!(c) { c.send(action_name) }
+      end
+
+      def run_collection_action(action_name, extra_params: {})
+        action_name = action_name.to_s
+        unless @aa_resource.collection_actions.any? { |a| a.name.to_s == action_name }
+          raise ::GraphQL::ExecutionError, "unknown collection action #{action_name.inspect}"
+        end
+
+        extras = normalize_extra_params(extra_params)
+        c = controller_for(action_name, extras)
+        perform_controller_command!(c) { c.send(action_name) }
+      end
+
+      private
+
+      def member_route_params_for_find(id)
+        model = @aa_resource.resource_class
+        if ActiveAdmin::PrimaryKey.composite?(model)
+          attrs = ActiveAdmin::PrimaryKey.find_attributes(model, id)
+          tuple = ActiveAdmin::PrimaryKey.ordered_columns(model).map { |c| attrs[c] }
+          {"id" => tuple}
+        elsif id.is_a?(Hash)
+          id.stringify_keys
+        else
+          {"id" => id.to_s}
+        end
+      end
+
+      def missing_required_belongs_to?
+        btc = @aa_resource.belongs_to_config
+        return false unless btc&.required?
+
+        key = btc.to_param.to_s
+        val = @graph_params[key] || @graph_params[key.to_sym]
+        val.blank?
+      end
+
+      def controller_for(action, extra = {})
+        c = @aa_resource.controller.new
+        h = param_hash_for(action, extra)
+        stub_controller!(c, h)
+        c
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/run_action_mutation_config.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    # Pairs return type and optional resolver for one run-action mutation kind (+batch+, +member+,
+    # or +collection+). Default return type resolution falls back to {ResourceConfig#run_action_payload_type},
+    # then {RunActionPayload}.
+    class RunActionMutationConfig
+      # @return [Class, nil] +GraphQL::Schema::Object+ subclass
+      attr_accessor :payload_type
+      # @return [Proc, nil]
+      attr_accessor :resolve_proc
+      # Optional block evaluated in the graphql-ruby +field+ DSL context (+argument+, …) for per-action fields.
+      attr_accessor :arguments_proc
+
+      def self.ensure_graphql_object_subclass!(type)
+        unless type.is_a?(Class) && type < ::GraphQL::Schema::Object
+          raise ArgumentError, "Expected a GraphQL::Schema::Object subclass, got #{type.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/run_action_mutation_dsl.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "run_action_mutation_config"
+
+module ActiveAdmin
+  module GraphQL
+    # Nested DSL for a single run-action mutation kind (+batch_action_mutation+, etc.): +type+ and +resolve+,
+    # similar to graphql-ruby pairing field type with resolution.
+    class RunActionMutationDSL
+      def initialize(mutation_config)
+        @mutation_config = mutation_config
+      end
+
+      # GraphQL object type for this mutation field (alias: +payload_type+).
+      def type(gql_object_class)
+        RunActionMutationConfig.ensure_graphql_object_subclass!(gql_object_class)
+        @mutation_config.payload_type = gql_object_class
+      end
+      alias_method :payload_type, :type
+
+      def resolve(&block)
+        @mutation_config.resolve_proc = block
+      end
+
+      # Per-action fields only: extra GraphQL arguments (+argument :reason, String, …+).
+      # Not used on the aggregate +posts_member_action(action: …)+ field.
+      def arguments(&block)
+        @mutation_config.arguments_proc = block
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/run_action_payload.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    # Return type for mutations that run batch, member, or collection controller actions.
+    class RunActionPayload < ::GraphQL::Schema::Object
+      graphql_name "ActiveAdminRunActionPayload"
+
+      def self.visible?(context)
+        hook = context[:namespace]&.graphql_schema_visible
+        return super if hook.nil?
+
+        super && !!hook.call(context, {kind: :run_action_payload})
+      end
+
+      field :ok, ::GraphQL::Types::Boolean, null: false
+      field :status, ::GraphQL::Types::Int, null: true,
+        description: "HTTP-style status from the controller response, when set."
+      field :location, ::GraphQL::Types::String, null: true,
+        description: "Redirect target, if the action called +redirect_to+."
+      field :body, ::GraphQL::Types::String, null: true,
+        description: "Response body text when the action rendered (e.g. JSON)."
+
+      Result = Struct.new(:ok, :status, :location, :body, keyword_init: true)
+    end
+  end
+end