activeadmin-graphql 0.1.0

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    class SchemaBuilder
+      module TypesInputs
+        private
+
+        def define_input_assignable_arguments!(input_class, aa_res, required:)
+          model = aa_res.resource_class
+          cols_by_name = model.columns.index_by(&:name)
+          gassign = aa_res.graphql_assignable_attribute_names.map(&:to_s)
+          if (btc = aa_res.belongs_to_config)
+            gassign -= [btc.to_param.to_s]
+          end
+
+          gassign.each do |name|
+            col = cols_by_name[name]
+            next unless col
+
+            gql_t = graphql_scalar_for_column(aa_res, model, col)
+            input_class.argument(name.to_sym, gql_t, required: required, camelize: false)
+          end
+        end
+
+        def build_create_input_type(aa_res)
+          model = aa_res.resource_class
+          gname = graphql_type_name_for(aa_res)
+          btc = aa_res.belongs_to_config
+          builder = self
+
+          klass = Class.new(::GraphQL::Schema::InputObject) do
+            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)
+
+            if btc
+              argument btc.to_param.to_sym, ::GraphQL::Types::ID, required: btc.required?, camelize: false
+            end
+          end
+          attach_input_object_visibility!(klass, "#{gname}CreateInput", aa_res, :create_input)
+          klass
+        end
+
+        def build_update_input_type(aa_res)
+          model = aa_res.resource_class
+          gname = graphql_type_name_for(aa_res)
+          btc = aa_res.belongs_to_config
+          builder = self
+
+          klass = Class.new(::GraphQL::Schema::InputObject) do
+            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)
+
+            if btc
+              argument btc.to_param.to_sym, ::GraphQL::Types::ID, required: false, camelize: false
+            end
+          end
+          attach_input_object_visibility!(klass, "#{gname}UpdateInput", aa_res, :update_input)
+          klass
+        end
+
+        def build_list_filter_input_type(aa_res)
+          gname = graphql_type_name_for(aa_res)
+          btc = aa_res.belongs_to_config
+
+          klass = Class.new(::GraphQL::Schema::InputObject) do
+            graphql_name "#{gname}ListFilterInput"
+            description "Index-style filters for #{aa_res.resource_name} (+scope+, +order+, Ransack +q+, parent ids)."
+
+            argument :scope, ::GraphQL::Types::String, required: false, camelize: false
+            argument :order, ::GraphQL::Types::String, required: false, camelize: false
+            argument :q, ::GraphQL::Types::JSON, required: false, camelize: false
+            if btc
+              argument btc.to_param.to_sym, ::GraphQL::Types::ID, required: false, camelize: false
+            end
+          end
+          attach_input_object_visibility!(klass, "#{gname}ListFilterInput", aa_res, :list_filter_input)
+          klass
+        end
+
+        def build_find_input_type(aa_res)
+          gname = graphql_type_name_for(aa_res)
+          btc = aa_res.belongs_to_config
+          model = aa_res.resource_class
+          builder = self
+
+          klass = Class.new(::GraphQL::Schema::InputObject) do
+            graphql_name "#{gname}WhereInput"
+            description "Primary key (and nested parents) for loading one #{aa_res.resource_name} record."
+
+            if ActiveAdmin::PrimaryKey.composite?(model)
+              argument :id, ::GraphQL::Types::ID, required: false, camelize: false,
+                description: "JSON object string with all primary keys, e.g. " \
+                       "{\"book_code\":\"x\",\"seq\":1}"
+              ActiveAdmin::PrimaryKey.ordered_columns(model).each do |col|
+                coldef = model.columns_hash[col]
+                next unless coldef
+
+                gql_t = builder.send(:graphql_scalar_for_column, aa_res, model, coldef)
+                argument col.to_sym, gql_t, required: false, camelize: false
+              end
+            else
+              argument :id, ::GraphQL::Types::ID, required: true, camelize: false
+            end
+            if btc
+              argument btc.to_param.to_sym, ::GraphQL::Types::ID, required: btc.required?, camelize: false
+            end
+          end
+          attach_input_object_visibility!(klass, "#{gname}WhereInput", aa_res, :where_input)
+          klass
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    class SchemaBuilder
+      module TypesObject
+        private
+
+        def build_enum_type(aa_res, column_name, mapping)
+          key = [aa_res.resource_class.name, column_name.to_s]
+          return @enum_types[key] if @enum_types[key]
+
+          gql_enum_name = self.class.graphql_enum_type_name(graphql_type_name_for(aa_res), column_name)
+          enum_class = Class.new(::GraphQL::Schema::Enum) do
+            graphql_name gql_enum_name
+            description "Rails enum `#{aa_res.resource_class.name}##{column_name}`"
+
+            mapping.each_key do |k|
+              value(k.to_s.upcase.gsub(/[^A-Z0-9_]/, "_").squeeze("_"), value: k)
+            end
+          end
+          gql_en = gql_enum_name
+          coln = column_name.to_s
+          ar = aa_res
+          enum_class.define_singleton_method(:visible?) do |ctx|
+            hook = ctx[:namespace]&.graphql_schema_visible
+            return super(ctx) if hook.nil?
+
+            super(ctx) && !!hook.call(ctx, {kind: :resource_enum, graphql_type_name: gql_en, resource: ar, column: coln})
+          end
+          @enum_types[key] = enum_class
+        end
+
+        def graphql_scalar_for_column(aa_res, model, col)
+          if model.defined_enums.key?(col.name)
+            return build_enum_type(aa_res, col.name, model.defined_enums[col.name])
+          end
+
+          case col.type
+          when :integer, :bigint
+            ::GraphQL::Types::Int
+          when :float, :decimal
+            ::GraphQL::Types::Float
+          when :boolean
+            ::GraphQL::Types::Boolean
+          when :datetime, :timestamp
+            ::GraphQL::Types::ISO8601DateTime
+          when :date
+            ::GraphQL::Types::ISO8601Date
+          when :json, :jsonb
+            ::GraphQL::Types::JSON
+          else
+            ::GraphQL::Types::String
+          end
+        end
+
+        def build_object_type(aa_res)
+          model = aa_res.resource_class
+          gname = graphql_type_name_for(aa_res)
+          cols_by_name = model.columns.index_by(&:name)
+          attr_names = attributes_for(aa_res).map(&:to_s)
+
+          type_class = Class.new(::GraphQL::Schema::Object) do
+            graphql_name gname
+            description "ActiveAdmin resource `#{aa_res.resource_name}`"
+            implements ::ActiveAdmin::GraphQL::ResourceInterface
+          end
+
+          pk_cols = ActiveAdmin::PrimaryKey.columns(model)
+
+          type_class.field :id, ::GraphQL::Types::ID, null: 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
+
+            col = cols_by_name[name]
+            next unless col
+
+            gql_t = graphql_scalar_for_column(aa_res, model, col)
+            type_class.field(name.to_sym, gql_t, null: true, camelize: false)
+
+            type_class.define_method(name.to_sym) { object.public_send(name) }
+          end
+
+          if (ext = aa_res.graphql_config.extension_block)
+            type_class.class_eval(&ext)
+          end
+
+          attach_resource_object_visibility!(type_class, gname, aa_res)
+          type_class
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    class SchemaBuilder
+      module Visibility
+        private
+
+        def apply_graphql_visibility!(schema)
+          vis = @namespace.graphql_visibility
+          return if vis.nil?
+
+          if vis == true
+            schema.use(::GraphQL::Schema::Visibility)
+          elsif vis.is_a?(Hash)
+            schema.use(::GraphQL::Schema::Visibility, **vis.symbolize_keys)
+          else
+            raise ActiveAdmin::DependencyError,
+              "namespace graphql_visibility must be nil, true, or a Hash of GraphQL::Schema::Visibility options"
+          end
+        end
+
+        def attach_registered_resource_union_visibility!(union_class)
+          union_class.define_singleton_method(:visible?) do |ctx|
+            hook = ctx[:namespace]&.graphql_schema_visible
+            return super(ctx) if hook.nil?
+
+            super(ctx) && !!hook.call(ctx, {kind: :registered_resource_union})
+          end
+        end
+
+        def attach_resource_object_visibility!(type_class, graphql_name, aa_res)
+          type_class.field_class(::ActiveAdmin::GraphQL::SchemaField)
+          gn = graphql_name
+          ar = aa_res
+          type_class.define_singleton_method(:visible?) do |ctx|
+            hook = ctx[:namespace]&.graphql_schema_visible
+            return super(ctx) if hook.nil?
+
+            super(ctx) && !!hook.call(ctx, {kind: :resource_object, graphql_type_name: gn, resource: ar})
+          end
+        end
+
+        def attach_input_object_visibility!(input_class, graphql_type_name, aa_res, role)
+          gtn = graphql_type_name
+          ar = aa_res
+          r = role
+          input_class.define_singleton_method(:visible?) do |ctx|
+            hook = ctx[:namespace]&.graphql_schema_visible
+            return super(ctx) if hook.nil?
+
+            super(ctx) && !!hook.call(ctx, {kind: :input_object, graphql_type_name: gtn, resource: ar, role: r})
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    class SchemaBuilder
+      module Wire
+        private
+
+        def wire_belongs_to_associations
+          @object_types.each do |model, type_class|
+            aa_res = @aa_by_model[model]
+            next unless aa_res
+
+            model.reflect_on_all_associations(:belongs_to).each do |ref|
+              next if ref.polymorphic?
+              target = ref.klass
+              next unless @object_types[target]
+
+              field_name = ref.name.to_sym
+              fk = ref.foreign_key.to_s
+
+              type_class.field field_name, @object_types[target], null: true, camelize: false
+
+              type_class.define_method(field_name) do
+                fk_val = object.public_send(fk)
+                next nil if fk_val.nil?
+
+                dataloader.with(ActiveAdmin::GraphQL::RecordSource, target).load(fk_val)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/schema_builder.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    class SchemaBuilder
+    end
+  end
+end
+
+require_relative "schema_builder/graph_params"
+require_relative "schema_builder/visibility"
+require_relative "schema_builder/resources"
+require_relative "schema_builder/types_object"
+require_relative "schema_builder/types_inputs"
+require_relative "schema_builder/wire"
+require_relative "schema_builder/query_type_registered"
+require_relative "schema_builder/query_type_collection"
+require_relative "schema_builder/query_type_member"
+require_relative "schema_builder/query_type_pages"
+require_relative "schema_builder/query_type"
+require_relative "schema_builder/resolvers"
+require_relative "schema_builder/mutation_action_types"
+require_relative "schema_builder/mutation_type_builder"
+require_relative "schema_builder/mutation_create"
+require_relative "schema_builder/mutation_update_destroy"
+require_relative "schema_builder/mutation_batch"
+require_relative "schema_builder/mutation_member"
+require_relative "schema_builder/mutation_collection"
+require_relative "schema_builder/build"
+
+module ActiveAdmin
+  module GraphQL
+    class SchemaBuilder
+      def self.graphql_enum_type_name(type_basename, column_name)
+        base = type_basename.to_s.gsub(/[^a-zA-Z0-9_]/, "_").squeeze("_")
+        col = column_name.to_s.gsub(/[^a-zA-Z0-9_]/, "_").squeeze("_")
+        "#{base.camelize}Enum#{col.camelize(:upper)}"
+      end
+
+      def initialize(namespace)
+        @namespace = namespace
+      end
+
+      include GraphParams
+      include Visibility
+      include Resources
+      include TypesObject
+      include TypesInputs
+      include Wire
+      include QueryType
+      include Resolvers
+      include MutationActionTypes
+      include MutationTypeBuilder
+      include MutationCreate
+      include MutationUpdateDestroy
+      include MutationBatch
+      include MutationMember
+      include MutationCollection
+      include Build
+    end
+  end
+end

data/lib/active_admin/graphql/schema_field.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    # Subclass of {::GraphQL::Schema::Field} for namespace +Query+ / +Mutation+ fields.
+    #
+    # The +visibility:+ keyword accepts an optional Hash of metadata forwarded to
+    # +graphql_schema_visible+ (second argument) when {GraphQL::Schema::Visibility} is enabled.
+    # That hook runs from {#visible?}; it does not replace graphql-ruby's visibility system—it
+    # composes with +super+ like any custom +Field+ class.
+    class SchemaField < ::GraphQL::Schema::Field
+      def initialize(visibility: nil, **kwargs, &block)
+        @visibility = visibility
+        super(**kwargs, &block)
+      end
+
+      def visible?(ctx)
+        return false unless super
+
+        return true unless @visibility
+
+        hook = ctx[:namespace]&.graphql_schema_visible
+        return true if hook.nil?
+
+        !!hook.call(ctx, @visibility)
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    VERSION = "0.1.0"
+  end
+end

data/lib/active_admin/graphql.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  # GraphQL HTTP API for ActiveAdmin (graphql-ruby), shipped in the +activeadmin-graphql+ gem.
+  #
+  # Bundling +activeadmin-graphql+ loads +graphql-ruby+ and registers this integration. Enable the
+  # HTTP endpoint per namespace in +config/initializers/active_admin.rb+:
+  #
+  #   ActiveAdmin.setup do |config|
+  #     config.namespace :admin do |api|
+  #       api.graphql = true
+  #     end
+  #   end
+  #
+  module GraphQL
+    SCHEMA_CACHE = {}
+  end
+end
+
+require_relative "graphql/resource_config"
+
+module ActiveAdmin
+  module GraphQL
+    class << self
+      # Requires graphql-ruby and schema builders. Safe to call repeatedly; loads once.
+      def load!
+        return if @graphql_features_loaded
+
+        @graphql_features_loaded = true
+        ActiveAdmin::Dependency["graphql"].spec!
+        require "graphql"
+        require "graphql/types/json"
+        require "graphql/types/iso_8601_date_time"
+        require "graphql/types/iso_8601_date"
+        require_relative "graphql/resource_interface"
+        require_relative "graphql/schema_field"
+        require_relative "graphql/auth_context"
+        require_relative "graphql/record_source"
+        require_relative "graphql/resource_query_proxy"
+        require_relative "graphql/run_action_payload"
+        require_relative "graphql/run_action_mutation_config"
+        require_relative "graphql/run_action_mutation_dsl"
+        require_relative "graphql/key_value_pair_input"
+        require_relative "graphql/schema_builder"
+      end
+
+      # @param namespace [ActiveAdmin::Namespace]
+      # @return [Class] schema class (subclass of GraphQL::Schema)
+      def schema_for(namespace)
+        cache_key = namespace.name
+        SCHEMA_CACHE.delete(cache_key) if defined?(Rails) && Rails.env.development?
+        SCHEMA_CACHE[cache_key] ||= SchemaBuilder.new(namespace).build
+      end
+
+      def clear_schema_cache!
+        SCHEMA_CACHE.clear
+      end
+
+      def clear_schema_for!(namespace)
+        SCHEMA_CACHE.delete(namespace.name)
+      end
+    end
+  end
+end
+
+require_relative "graphql/integration"
+ActiveAdmin::GraphQL::Integration.install!
+ActiveAdmin::GraphQL.load!

data/lib/active_admin/primary_key.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+# Shim: GraphQL uses composite-PK helpers; upstream ActiveAdmin may not ship this module yet.
+unless defined?(ActiveAdmin::PrimaryKey)
+  require "json"
+
+  module ActiveAdmin
+    module PrimaryKey
+      module_function
+
+      def composite?(model)
+        pk = model.primary_key
+        pk.is_a?(Array) && pk.size > 1
+      end
+
+      def ordered_columns(model)
+        Array(model.primary_key).map(&:to_s)
+      end
+
+      def columns(model)
+        ordered_columns(model)
+      end
+
+      def composite_attribute_hash(model, id_param)
+        cols = ordered_columns(model)
+        h =
+          case id_param
+          when Hash
+            id_param.stringify_keys.slice(*cols)
+          when String
+            parsed = JSON.parse(id_param)
+            raise ArgumentError, "composite id must be a JSON object" unless parsed.is_a?(Hash)
+
+            parsed.stringify_keys.slice(*cols)
+          when Array
+            cols.zip(id_param).to_h
+          else
+            raise ArgumentError, "unsupported composite id type"
+          end
+
+        missing = cols - h.keys
+        raise ArgumentError, "composite id missing keys: #{missing.join(", ")}" if missing.any?
+
+        absent = cols.select { |c| h[c].nil? }
+        raise ArgumentError, "composite id missing values for: #{absent.join(", ")}" if absent.any?
+
+        h
+      end
+
+      def find_attributes(model, id_param)
+        cols = ordered_columns(model)
+        if cols.size == 1
+          {cols.first => id_param}
+        else
+          composite_attribute_hash(model, id_param)
+        end
+      end
+
+      def graphql_id_value(record)
+        cols = ordered_columns(record.class)
+        if cols.size == 1
+          record.public_send(cols.first).to_s
+        else
+          payload = cols.each_with_object({}) { |c, m| m[c] = record.read_attribute(c) }
+          JSON.generate(payload)
+        end
+      end
+
+      def dataloader_tuple(model, raw)
+        cols = ordered_columns(model)
+        return raw if cols.size == 1
+
+        h = composite_attribute_hash(model, raw)
+        cols.map { |c| h[c] }
+      end
+
+      def dataloader_tuple_from_record(record)
+        ordered_columns(record.class).map { |c| record.read_attribute(c) }
+      end
+
+      def member_param_hash(model, blob)
+        blob = blob.stringify_keys
+        cols = ordered_columns(model)
+        if cols.size == 1
+          id = blob["id"]
+          raise ArgumentError, "id is required" if id.blank?
+
+          {"id" => id.to_s}
+        elsif blob["id"].present?
+          find_attributes(model, blob["id"]).stringify_keys
+        elsif cols.all? { |c| blob.key?(c) && blob[c].present? }
+          cols.to_h { |c| [c, blob[c]] }
+        else
+          raise ArgumentError, "composite id requires id (JSON) or all primary key columns"
+        end
+      end
+
+      def field_kw_to_param_hash(model, id:, **kw)
+        cols = ordered_columns(model)
+        if cols.size == 1
+          raise ArgumentError, "id is required" if id.blank?
+
+          {"id" => id.to_s}
+        elsif id.present?
+          find_attributes(model, id).stringify_keys
+        else
+          out = cols.to_h { |c| [c, kw[c.to_sym] || kw[c]] }
+          if cols.all? { |c| !out[c].nil? }
+            out.transform_values(&:to_s)
+          else
+            raise ArgumentError, "composite id requires id (JSON) or all primary key fields as arguments"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activeadmin/graphql.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "active_admin"
+require_relative "../active_admin/primary_key"
+require_relative "../active_admin/graphql"