activeadmin-graphql 0.2.1 → 0.3.1

data/lib/active_admin/graphql/integration.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "resource_definition_dsl"
+require_relative "resource_methods"
 
 module ActiveAdmin
   module GraphQL
@@ -60,36 +61,34 @@ module ActiveAdmin
         end
       end
 
-      module ResourceMethods
-        def graphql_config
-          @graphql_config ||= ActiveAdmin::GraphQL::ResourceConfig.new
+      module ResourceDSLMethods
+        def graphql(&block)
+          if block
+            ActiveAdmin::GraphQL::ResourceDefinitionDSL.new(config.graphql_config).instance_exec(&block)
+          end
+          config.graphql_config
         end
 
-        def attributes_for_graphql
-          keys = resource_attributes.keys
-          cfg = graphql_config
-          if cfg.only_attributes
-            keys &= cfg.only_attributes
+        def permit_params(*args, &block)
+          unless block
+            config.graphql_config.html_permit_params_attributes = flatten_html_permit_params(args)
           end
-          keys -= cfg.exclude_attributes
-          keys
+          super
         end
 
-        def graphql_assignable_attribute_names
-          names = attributes_for_graphql.map(&:to_s)
-          pk_cols = ActiveAdmin::PrimaryKey.columns(resource_class)
-          return names if pk_cols.size > 1
-
-          names - pk_cols
-        end
-      end
+        private
 
-      module ResourceDSLMethods
-        def graphql(&block)
-          if block
-            ActiveAdmin::GraphQL::ResourceDefinitionDSL.new(config.graphql_config).instance_exec(&block)
+        def flatten_html_permit_params(args)
+          args.flat_map do |arg|
+            case arg
+            when Symbol, String
+              [arg.to_sym]
+            when Hash
+              arg.keys.map(&:to_sym)
+            else
+              []
+            end
           end
-          config.graphql_config
         end
       end
 

data/lib/active_admin/graphql/mutation_execution_error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    module MutationExecutionError
+      module_function
+
+      def validation(record)
+        ::GraphQL::ExecutionError.new(
+          record.errors.full_messages.to_sentence,
+          extensions: {"errors" => record.errors.full_messages}
+        )
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/mutation_input_config.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    # Create or update input options set from +graphql { create do … }+ / +update do … }+.
+    class MutationInputConfig
+      attr_accessor :permit_params_attributes
+      attr_accessor :resolve_proc
+    end
+  end
+end

data/lib/active_admin/graphql/mutation_input_definition_dsl.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    # Nested DSL for +graphql { create do … }+ and +update do … }+, pairing
+    # ActiveAdmin +permit_params+ with graphql-ruby-style +resolve+.
+    class MutationInputDefinitionDSL
+      def initialize(config)
+        @config = config
+      end
+
+      def permit_params(*attrs)
+        @config.permit_params_attributes = attrs.flatten.map(&:to_sym)
+      end
+      alias_method :permit, :permit_params
+
+      def resolve(&block)
+        @config.resolve_proc = block
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/policy_set_cache.rb

@@ -53,7 +53,9 @@ module ActiveAdmin
           elsif subject.is_a?(ActiveAdmin::Page)
             "page:#{subject.name}"
           elsif subject.is_a?(ActiveRecord::Base)
-            "record:#{subject.class.name}:#{PrimaryKey.graphql_id_value(subject)}"
+            identity = PrimaryKey.graphql_id_value(subject)
+            identity = "#{identity}:object:#{subject.object_id}" if subject.class.primary_key.blank?
+            "record:#{subject.class.name}:#{identity}"
           else
             "object:#{subject.object_id}"
           end

data/lib/active_admin/graphql/record_source.rb

@@ -6,13 +6,14 @@ module ActiveAdmin
     class RecordSource < ::GraphQL::Dataloader::Source
       def initialize(model_class)
         @model_class = model_class
-        @pk = model_class.primary_key
+        @pk_columns = ActiveAdmin::PrimaryKey.columns(model_class)
+        @pk = ActiveAdmin::PrimaryKey.composite?(model_class) ? model_class.primary_key : @pk_columns.first
       end
 
       def fetch(ids)
         keys = normalized_keys(ids)
         uniq = keys.compact.uniq
-        return Array.new(ids.size) { nil } if uniq.empty?
+        return Array.new(ids.size) { nil } if uniq.empty? || @pk.nil?
 
         indexed = load_records(uniq)
         keys.map { |key| key.nil? ? nil : indexed[key] }

data/lib/active_admin/graphql/resource_config.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "run_action_mutation_config"
+require_relative "mutation_input_config"
 
 module ActiveAdmin
   module GraphQL
@@ -10,14 +11,16 @@ module ActiveAdmin
       attr_accessor :graphql_type_name
       attr_accessor :only_attributes
       attr_accessor :exclude_attributes
+      attr_accessor :permit_params_attributes
+      attr_accessor :html_permit_params_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_writer :resolve_create_proc
+      attr_writer :resolve_update_proc
       attr_accessor :resolve_destroy_proc
 
       # Default return type for run-action mutations (+batch+, +member+, +collection+) when a kind-specific
@@ -33,6 +36,22 @@ module ActiveAdmin
         !enabled
       end
 
+      def create_input
+        @create_input ||= MutationInputConfig.new
+      end
+
+      def update_input
+        @update_input ||= MutationInputConfig.new
+      end
+
+      def resolve_create_proc
+        @resolve_create_proc || create_input.resolve_proc
+      end
+
+      def resolve_update_proc
+        @resolve_update_proc || update_input.resolve_proc
+      end
+
       def batch_run_action
         @batch_run_action ||= RunActionMutationConfig.new
       end

data/lib/active_admin/graphql/resource_definition_dsl.rb

@@ -2,6 +2,7 @@
 
 require_relative "run_action_mutation_config"
 require_relative "run_action_mutation_dsl"
+require_relative "mutation_input_definition_dsl"
 
 module ActiveAdmin
   module GraphQL
@@ -18,6 +19,7 @@ module ActiveAdmin
       def type_name(name)
         @config.graphql_type_name = name.to_s
       end
+      alias_method :graphql_name, :type_name
 
       def only(*attrs)
         @config.only_attributes = attrs.flatten.map(&:to_sym)
@@ -28,6 +30,23 @@ module ActiveAdmin
       end
       alias_method :exclude, :except
 
+      def permit_params(*attrs)
+        @config.permit_params_attributes = attrs.flatten.map(&:to_sym)
+      end
+      alias_method :permit, :permit_params
+
+      def create(&block)
+        return unless block
+
+        MutationInputDefinitionDSL.new(@config.create_input).instance_exec(&block)
+      end
+
+      def update(&block)
+        return unless block
+
+        MutationInputDefinitionDSL.new(@config.update_input).instance_exec(&block)
+      end
+
       def configure(&block)
         @config.extension_block = block
       end

data/lib/active_admin/graphql/resource_methods.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    module Integration
+      module ResourceMethods
+        SERVER_OWNED_TIMESTAMP_COLUMNS = %w[created_at updated_at].freeze
+
+        def graphql_config
+          @graphql_config ||= ActiveAdmin::GraphQL::ResourceConfig.new
+        end
+
+        def attributes_for_graphql
+          keys = resource_attributes.keys
+          cfg = graphql_config
+          if cfg.only_attributes
+            keys &= cfg.only_attributes
+          end
+          keys -= cfg.exclude_attributes
+          keys
+        end
+
+        def graphql_assignable_attribute_names
+          names = attributes_for_graphql.map(&:to_s)
+          pk_cols = ActiveAdmin::PrimaryKey.columns(resource_class)
+          return names if pk_cols.size > 1
+
+          names - pk_cols
+        end
+
+        def graphql_create_attribute_names
+          mutation_permit_params_names(
+            graphql_config.create_input.permit_params_attributes || graphql_config.permit_params_attributes
+          )
+        end
+
+        def graphql_update_attribute_names
+          mutation_permit_params_names(
+            graphql_config.update_input.permit_params_attributes || graphql_config.permit_params_attributes
+          )
+        end
+
+        private
+
+        def mutation_permit_params_names(permit_list)
+          names = graphql_assignable_attribute_names.map(&:to_s)
+          permit_list = graphql_config.html_permit_params_attributes if permit_list.nil?
+          return names - SERVER_OWNED_TIMESTAMP_COLUMNS if permit_list.nil?
+
+          names & permit_list.map(&:to_s)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    class ResourceQueryProxy
+      module Identity
+        private
+
+        def find_inferred_member(controller, model, id)
+          primary_key = ActiveAdmin::PrimaryKey.columns(model).first
+          raise ActiveRecord::RecordNotFound unless primary_key
+
+          records = controller.send(:scoped_collection).where(primary_key => id).limit(2).to_a
+          raise_ambiguous_id!(model) if records.size > 1
+
+          records.first || raise(ActiveRecord::RecordNotFound)
+        end
+
+        def index_records_by_id(relation, model, primary_key)
+          if model.primary_key.present?
+            return relation.index_by { |record| record.public_send(primary_key).to_s }
+          end
+
+          grouped = relation.to_a.group_by { |record| record.public_send(primary_key).to_s }
+          if grouped.any? { |_id, matches| matches.size > 1 }
+            raise_ambiguous_id!(model)
+          end
+
+          grouped.transform_values(&:first)
+        end
+
+        def raise_ambiguous_id!(model)
+          raise ::GraphQL::ExecutionError, "ambiguous GraphQL id for #{model.name}"
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/resource_query_proxy.rb

@@ -4,14 +4,14 @@ require "rack/mock"
 require "stringio"
 
 require_relative "resource_query_proxy/controller"
+require_relative "resource_query_proxy/identity"
 
 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.
+    # Reuses ResourceController data access so GraphQL operations align with the REST endpoints.
     class ResourceQueryProxy
       include Controller
+      include Identity
 
       def initialize(aa_resource:, user:, namespace:, graph_params: {})
         @aa_resource = aa_resource
@@ -26,7 +26,12 @@ module ActiveAdmin
 
       def find_member(id)
         extra = member_route_params_for_find(id)
-        controller_for("show", extra).send(:find_resource)
+        controller = controller_for("show", extra)
+        model = @aa_resource.resource_class
+        finder = controller.send(:method_for_find)
+        return controller.send(:find_resource) if model.primary_key.present? || finder != :find
+
+        find_inferred_member(controller, model, extra.fetch("id"))
       rescue ActiveRecord::RecordNotFound
         nil
       end
@@ -42,10 +47,10 @@ module ActiveAdmin
 
         controller = controller_for("index")
         relation = controller.send(:apply_authorization_scope, controller.send(:scoped_collection))
-        primary_key = model.primary_key.to_sym
-        indexed = relation.where(primary_key => string_ids).index_by do |record|
-          record.public_send(primary_key).to_s
-        end
+        primary_key = ActiveAdmin::PrimaryKey.columns(model).first&.to_sym
+        return string_ids.index_with { nil } if primary_key.nil?
+
+        indexed = index_records_by_id(relation.where(primary_key => string_ids), model, primary_key)
         string_ids.index_with { |identifier| indexed[identifier] }
       end
 

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

@@ -28,9 +28,9 @@ module ActiveAdmin
           h
         end
 
-        def assignable_slice_from_input(aa_res, input)
+        def assignable_slice_from_input(aa_res, input, attribute_names: nil)
           blob = input.to_h.stringify_keys
-          names = aa_res.graphql_assignable_attribute_names.map(&:to_s)
+          names = (attribute_names || aa_res.graphql_assignable_attribute_names).map(&:to_s)
           if (btc = aa_res.belongs_to_config)
             names -= [btc.to_param.to_s]
           end

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

@@ -29,7 +29,11 @@ module ActiveAdmin
                 namespace: ns,
                 graph_params: sb.graph_params_from_input(aa_res, input)
               )
-              attrs = sb.assignable_slice_from_input(aa_res, input)
+              attrs = sb.assignable_slice_from_input(
+                aa_res,
+                input,
+                attribute_names: aa_res.graphql_create_attribute_names
+              )
               record = if (hook = aa_res.graphql_config.resolve_create_proc)
                 hook.call(
                   proxy: proxy,
@@ -46,7 +50,7 @@ module ActiveAdmin
                 end
 
                 unless r.save
-                  raise ::GraphQL::ExecutionError, r.errors.full_messages.to_sentence
+                  raise MutationExecutionError.validation(r)
                 end
                 r
               end

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

@@ -42,7 +42,11 @@ module ActiveAdmin
                 raise ::GraphQL::ExecutionError, "not authorized to update this record"
               end
 
-              attrs = sb.assignable_slice_from_input(aa_res, input)
+              attrs = sb.assignable_slice_from_input(
+                aa_res,
+                input,
+                attribute_names: aa_res.graphql_update_attribute_names
+              )
               record = if (hook = aa_res.graphql_config.resolve_update_proc)
                 hook.call(
                   proxy: proxy,
@@ -54,9 +58,9 @@ module ActiveAdmin
                   aa_resource: aa_res
                 )
               else
-                attrs = attrs.stringify_keys.slice(*aa_res.graphql_assignable_attribute_names)
+                attrs = attrs.stringify_keys.slice(*aa_res.graphql_update_attribute_names)
                 unless record.update(attrs)
-                  raise ::GraphQL::ExecutionError, record.errors.full_messages.to_sentence
+                  raise MutationExecutionError.validation(record)
                 end
                 record
               end
@@ -66,17 +70,22 @@ module ActiveAdmin
         end
 
         def mutation_destroy_field(sb, ns, aa_res, model)
-          fname = "delete_#{aa_res.resource_name.route_key.singularize.tr("-", "_")}"
+          stem = aa_res.resource_name.route_key.singularize.tr("-", "_")
+          delete_name = "delete_#{stem}"
+          destroy_name = "destroy_#{stem}"
           find_type = @find_input_types[model]
+          type_basename = sb.send(:graphql_type_name_for, aa_res)
 
           proc do
-            field fname.to_sym, ::GraphQL::Types::Boolean, null: false, camelize: false,
-              visibility: {kind: :mutation_delete, graphql_type_name: sb.send(:graphql_type_name_for, aa_res), resource: aa_res},
-              description: "Delete #{model.name}" do
-              argument :where, find_type, required: true, camelize: false
+            [delete_name, destroy_name].each do |fname|
+              field fname.to_sym, ::GraphQL::Types::Boolean, null: false, camelize: false,
+                visibility: {kind: :mutation_delete, graphql_type_name: type_basename, resource: aa_res},
+                description: "Destroy #{model.name}" do
+                argument :where, find_type, required: true, camelize: false
+              end
             end
 
-            define_method(fname.to_sym) do |where:, **|
+            define_method(delete_name.to_sym) do |where:, **|
               auth = context[:auth]
               blob = where.to_h.stringify_keys
               graph = sb.graph_params_from_find_blob(aa_res, blob)
@@ -112,6 +121,7 @@ module ActiveAdmin
               end
               true
             end
+            alias_method destroy_name.to_sym, delete_name.to_sym
           end
         end
       end

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

@@ -6,10 +6,16 @@ module ActiveAdmin
       module TypesInputs
         private
 
-        def define_input_assignable_arguments!(input_class, aa_res, required:)
+        def mark_empty_input_object!(input_class)
+          return if input_class.any_arguments?
+
+          input_class.has_no_arguments(true)
+        end
+
+        def define_input_assignable_arguments!(input_class, aa_res, required:, attribute_names:)
           model = aa_res.resource_class
           cols_by_name = model.columns.index_by(&:name)
-          gassign = aa_res.graphql_assignable_attribute_names.map(&:to_s)
+          gassign = attribute_names.map(&:to_s)
           if (btc = aa_res.belongs_to_config)
             gassign -= [btc.to_param.to_s]
           end
@@ -33,12 +39,19 @@ module ActiveAdmin
             graphql_name "#{gname}CreateInput"
             description "Attributes (and nested route params) for creating #{model.name}"
 
-            builder.send(:define_input_assignable_arguments!, self, aa_res, required: false)
+            builder.send(
+              :define_input_assignable_arguments!,
+              self,
+              aa_res,
+              required: false,
+              attribute_names: aa_res.graphql_create_attribute_names
+            )
 
             if btc
               argument btc.to_param.to_sym, ::GraphQL::Types::ID, required: btc.required?, camelize: false
             end
           end
+          mark_empty_input_object!(klass)
           attach_input_object_visibility!(klass, "#{gname}CreateInput", aa_res, :create_input)
           klass
         end
@@ -53,12 +66,19 @@ module ActiveAdmin
             graphql_name "#{gname}UpdateInput"
             description "Partial attributes (and nested route params) for updating #{model.name}"
 
-            builder.send(:define_input_assignable_arguments!, self, aa_res, required: false)
+            builder.send(
+              :define_input_assignable_arguments!,
+              self,
+              aa_res,
+              required: false,
+              attribute_names: aa_res.graphql_update_attribute_names
+            )
 
             if btc
               argument btc.to_param.to_sym, ::GraphQL::Types::ID, required: false, camelize: false
             end
           end
+          mark_empty_input_object!(klass)
           attach_input_object_visibility!(klass, "#{gname}UpdateInput", aa_res, :update_input)
           klass
         end

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

@@ -83,12 +83,25 @@ module ActiveAdmin
           end
 
           pk_cols = ActiveAdmin::PrimaryKey.columns(model)
+          if pk_cols.empty?
+            raise ArgumentError,
+              "#{model.name} has no primary key for GraphQL `id`; set self.primary_key on the model"
+          end
 
           type_class.field :id, ::GraphQL::Types::ID, null: false, authorize: false
           type_class.define_method(:id) { ActiveAdmin::PrimaryKey.graphql_id_value(object) }
 
-          attr_names.each do |name|
-            next if pk_cols.include?(name) && pk_cols.size == 1
+          # ActiveAdmin omits a single-column primary key from resource_attributes; still expose
+          # non-id key columns as scalars (composite keys already remain in attributes).
+          # ActiveAdminResource owns GraphQL `id`; never emit a second field from an `id` column.
+          configured_pk_cols = pk_cols
+          if (only = aa_res.graphql_config.only_attributes)
+            configured_pk_cols &= only.map(&:to_s)
+          end
+          configured_pk_cols -= aa_res.graphql_config.exclude_attributes.map(&:to_s)
+          readable_names = (attr_names + configured_pk_cols).uniq
+          readable_names.each do |name|
+            next if name == "id"
 
             col = cols_by_name[name]
             next unless col

data/lib/active_admin/graphql/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveAdmin
   module GraphQL
-    VERSION = "0.2.1"
+    VERSION = "0.3.1"
   end
 end

data/lib/active_admin/graphql.rb

@@ -77,6 +77,7 @@ module ActiveAdmin
           graphql/run_action_mutation_dsl
           graphql/key_value_pair_input
           graphql/policy_set_cache
+          graphql/mutation_execution_error
           graphql/schema_builder
         ].each { |path| require_relative path }
       end

data/lib/active_admin/primary_key.rb

@@ -14,13 +14,22 @@ unless defined?(ActiveAdmin::PrimaryKey)
       end
 
       def ordered_columns(model)
-        Array(model.primary_key).map(&:to_s)
-      end
+        cols = case (pk = model.primary_key)
+        when nil, false then []
+        when Array then pk.map(&:to_s).reject(&:empty?)
+        else
+          (name = pk.to_s).empty? ? [] : [name]
+        end
+        return cols if cols.any?
+        return %w[id] if model.respond_to?(:columns_hash) && model.columns_hash.key?("id")
 
-      def columns(model)
-        ordered_columns(model)
+        []
+      rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotEstablished
+        []
       end
 
+      def columns(model) = ordered_columns(model)
+
       def composite_attribute_hash(model, id_param)
         cols = ordered_columns(model)
         hash = normalize_composite_input(cols, id_param)