activeadmin-graphql 0.3.1 → 0.3.3

data/docs/issues/20261010111159_rails-composite-primary-keys-alignment.md

@@ -0,0 +1,81 @@
+# Rails composite primary keys alignment
+
+## Participants
+
+Andrei Makarov
+
+## Decisions
+
+Treat ActiveRecord composite primary keys and GraphQL `identity` as related but
+not identical contracts. Keep GraphQL `id` as a single `ID!` string. Do not
+adopt Rails form URL underscore packing as the default GraphQL id encoding.
+
+Record alignment against the Rails guide Composite Primary Keys
+(https://guides.rubyonrails.org/active_record_composite_primary_keys.html)
+after shipping inferred id columns and RFC 0007 identity DSL.
+
+## Effects
+
+Compared gem behavior to the guide’s model, query, form, and parameter rules.
+
+ActiveRecord composite primary key (self.primary_key = array):
+
+- Aligns: model declares composite key the same way as the guide’s
+  `self.primary_key = [:store_id, :sku]` style. Dummy `LibraryEdition` uses
+  `[:book_code, :seq]`.
+- Aligns: internal batch and find paths convert that string id into an ordered
+  value list and use Rails tuple/`Relation#find` style lookups
+  (`ActiveAdmin::PrimaryKey.dataloader_tuple`, `ResourceQueryProxy` composite
+  branch). That matches the guide’s `Product.find([3, "XYZ12345"])` and
+  `where(primary_key => [[...], [...]])` idea at the Ruby API layer.
+- Diverges: GraphQL and the published docs encode composite `id` as a JSON
+  object string (`{"book_code":"CPK","seq":7}`), not as the guide’s form/URL
+  underscore packing (`/books/2_25` with `params.extract_value(:id)`). JSON
+  keeps column names explicit and avoids ambiguity when a key value contains
+  `_`. Underscore packing is not accepted as GraphQL `id` today.
+- Diverges: GraphQL also accepts per-key arguments and `WhereInput` fields for
+  composite models. The guide’s controller example extracts one `:id` param
+  into an array; we keep named keys as a GraphQL-friendly alternate.
+- Aligns with guide caution: `where(id: ...)` / `find_by(id:)` on composite
+  models can mean an `:id` attribute, not the full primary key. The gem’s
+  GraphQL `id` field is the ActiveAdminResource identity string, not
+  necessarily an ActiveRecord `:id` column. Member lookup uses primary-key
+  columns (or configured identity), not a bare `where(id: graphql_id)` on
+  composite models.
+
+Keyless views and RFC 0007 `graphql { identity ... }`:
+
+- Outside the guide’s scope. The guide assumes a declared composite primary
+  key on the table/model. AlertEvent-style views with `primary_key = nil` and
+  a virtual Ruby `id` are not Rails composite primary keys.
+- `identity :a, :b, :c, separator: ":"` is an application-level encoding so
+  GraphQL can share the same string as a hand-rolled `def id; [...].join(":")`.
+  That separator form is closer in spirit to Rails’ delimited URL id than our
+  JSON composite encoding, but the delimiter and segment rules are app-chosen,
+  not `extract_value`’s underscore default.
+- Without `separator`, configured multi-column identity reuses the gem’s JSON
+  object string so keyless and AR-composite GraphQL ids stay one family.
+
+Stock ActiveAdmin HTML member routes still need a composite-aware
+`find_resource` (or custom finder) for AR composite keys; GraphQL does not
+make Rails form URLs use JSON.
+
+## Next
+
+Leave GraphQL composite `id` as JSON for AR composite primary keys unless a
+later RFC deliberately adds underscore (or `extract_value`-compatible) accept
+and emit. Document that choice next to the Rails guide, not as “the same
+format Rails uses for casting composite ids” without qualification.
+
+No change required for RFC 0007 separator identity; it is the escape hatch
+when the model is not a Rails composite primary key.
+
+## Source
+
+https://guides.rubyonrails.org/active_record_composite_primary_keys.html
+docs/graphql-api.md (Nonconventional primary keys, Composite primary keys)
+rfcs/0007-graphql-identity.md
+lib/active_admin/primary_key.rb
+lib/active_admin/graphql/resource_identity.rb
+spec/dummy/app/models/library_edition.rb
+spec/dummy/app/models/alert_event.rb

data/docs/issues/20261010111300_partitions-and-shards-support.md

@@ -0,0 +1,55 @@
+# Table partitions and database shards support
+
+## Participants
+
+Andrei Makarov
+
+## Decisions
+
+activeadmin-graphql does not treat database table partitions or Rails
+database shards as a GraphQL configuration surface. Identity DSL (RFC 0007)
+and ActiveRecord composite primary keys only encode lookup columns into
+GraphQL `id`. They do not select a shard, connection role, or physical
+partition.
+
+App-level Rails multi-database setup (`connects_to`, `connected_to`,
+horizontal shards, tenant middleware) may still apply implicitly: GraphQL
+resolvers reuse ActiveAdmin `scoped_collection` / `find_resource` on whatever
+connection the request process already has. That inheritance is undocumented
+as a product feature and untested in this gem.
+
+## Effects
+
+Searched lib, docs, rfcs, and spec for partition, shard, connects_to,
+multiple database, tenant routing, writing_role, and reading_role.
+
+Product code has no shard or partition API. Hits for “shard” and “partition”
+are Polyrun/CI test parallelism and agent IO-fault vocabulary, not databases.
+
+Dummy app uses one SQLite database (`spec/dummy/config/database.yml`). No
+multi-DB, no partitioned table fixtures, no `connected_to` specs.
+
+`RecordSource`, `PrimaryKey`, and `ResourceIdentity` run `where` / encode on
+the current model class only. A partition-key column can appear in
+`graphql { identity ... }` as part of the id string; that still queries the
+already-selected connection and does not prune or route partitions.
+
+## Next
+
+If a host needs GraphQL across shards or partitioned tables, keep routing in
+the Rails/ActiveAdmin request boundary (middleware, `connected_to`, custom
+finder). Do not invent gem DSL until a concrete host failure and RFC name the
+contract (shard key in GraphQL args, role switching, cross-shard batch limits).
+
+Optional later: document “unsupported / inherited only” next to identity in
+`docs/graphql-api.md` when a reader asks again.
+
+## Source
+
+lib/active_admin/graphql/resource_identity.rb
+lib/active_admin/graphql/record_source.rb
+lib/active_admin/graphql/resource_query_proxy.rb
+spec/dummy/config/database.yml
+rfcs/0007-graphql-identity.md
+docs/issues/20261010111159_rails-composite-primary-keys-alignment.md
+polyrun.yml (test shards only)

data/docs/issues/20261010111500_graphql-federation-support.md

@@ -0,0 +1,46 @@
+# GraphQL Federation support
+
+## Participants
+
+Andrei Makarov
+
+## Decisions
+
+activeadmin-graphql does not implement GraphQL Federation (Apollo Federation
+v1/v2, subgraph/supergraph, `@key` entities, `_entities` / `_service`). The
+product is one graphql-ruby schema per ActiveAdmin namespace for that admin
+HTTP endpoint.
+
+RFC 0007 `graphql { identity ... }` and `ActiveAdminResource.id` are record
+lookup identity inside that schema. They are not federation entity keys and
+do not emit federation SDL directives.
+
+## Effects
+
+Searched lib, docs, rfcs, spec, and the gemspec for federation, subgraph,
+supergraph, Apollo, `@key`, shareable, apollo-federation, `_entities`, and
+`_service`. No product hits.
+
+Runtime dependencies are `activeadmin` and `graphql` only. Schema build is
+`Class.new(::GraphQL::Schema)` with query, mutation, dataloader, and optional
+visibility (`lib/active_admin/graphql/schema_builder/build.rb`).
+`ResourceInterface` is a local interface for fragment reuse, not a federation
+entity type.
+
+An app could in principle call `graphql_configure_schema` on the built schema
+and layer a federation library itself. That path is neither documented nor
+tested here.
+
+## Next
+
+Keep federation out of scope until a host names a concrete subgraph contract
+and an RFC. Prefer documenting “single-schema admin API; federation
+unsupported” if readers keep asking.
+
+## Source
+
+activeadmin-graphql.gemspec
+lib/active_admin/graphql/schema_builder/build.rb
+lib/active_admin/graphql/resource_interface.rb
+rfcs/0007-graphql-identity.md
+docs/issues/20261010111300_partitions-and-shards-support.md

data/lib/active_admin/graphql/capability.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    # Named grants carried in GraphQL +context[:capabilities]+ (RFC 0008).
+    module Capability
+      module_function
+
+      def normalize_set(raw)
+        return nil if raw.nil?
+
+        Set.new(
+          Array(raw).filter_map do |item|
+            next if item.nil?
+
+            name = item.to_s.strip
+            next if name.empty?
+
+            name.to_sym
+          end
+        )
+      end
+
+      def granted?(context, capability_name)
+        return true if capability_name.nil?
+
+        caps = context[:capabilities]
+        return false if caps.nil?
+
+        caps = normalize_set(caps) unless caps.is_a?(Set)
+        caps.include?(capability_name.to_sym)
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/capability_definition_dsl.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    # Block body for +capability :name do ... end+ (RFC 0008).
+    class CapabilityDefinitionDSL
+      QUERY_ALIASES = {
+        index: :collection,
+        list: :collection,
+        show: :member
+      }.freeze
+
+      MUTATION_ALIASES = {
+        delete: :destroy
+      }.freeze
+
+      def initialize(config, capability_name)
+        @config = config
+        @capability_name = capability_name.to_sym
+      end
+
+      def fields(*names)
+        @config.assign_field_capabilities!(@capability_name, names)
+      end
+
+      def queries(*names)
+        keys = names.flatten.map { |name| normalize_query_key(name) }
+        @config.assign_query_capabilities!(@capability_name, keys)
+      end
+
+      def mutations(*names)
+        keys = names.flatten.map { |name| normalize_mutation_key(name) }
+        @config.assign_mutation_capabilities!(@capability_name, keys)
+      end
+
+      def member_actions(*names)
+        keys = names.flatten.map { |name| :"member_#{name.to_s.tr("-", "_")}" }
+        @config.assign_mutation_capabilities!(@capability_name, keys)
+      end
+
+      def batch_actions(*names)
+        keys = names.flatten.map { |name| :"batch_#{name.to_s.tr("-", "_")}" }
+        @config.assign_mutation_capabilities!(@capability_name, keys)
+      end
+
+      def collection_actions(*names)
+        keys = names.flatten.map { |name| :"collection_#{name.to_s.tr("-", "_")}" }
+        @config.assign_mutation_capabilities!(@capability_name, keys)
+      end
+
+      private
+
+      def normalize_query_key(name)
+        key = name.to_sym
+        QUERY_ALIASES.fetch(key, key)
+      end
+
+      def normalize_mutation_key(name)
+        key = name.to_sym
+        MUTATION_ALIASES.fetch(key, key)
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/integration.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "policy_adapter"
 require_relative "resource_definition_dsl"
 require_relative "resource_methods"
 
@@ -26,12 +27,26 @@ module ActiveAdmin
       def register_namespace_settings!
         ns = ActiveAdmin::NamespaceSettings
         ns.register :graphql, false
+        # true preserves 0.3.x: every ActiveRecord resource is in the schema once the namespace endpoint is on.
+        # Set false for opt-in per resource (empty graphql block or enable!).
+        ns.register :graphql_resource_enabled_default, true
+        ns.register :graphql_queries_enabled_default, true
+        ns.register :graphql_mutations_enabled_default, true
+        ns.register :graphql_run_actions_enabled_default, true
+        ns.register :graphql_policies_enabled, true
+        ns.register :graphql_policies_enabled_default, true
+        # Payload builder for policy fields when graphql_policies_enabled is true.
+        ns.register :graphql_policy_adapter, ActiveAdmin::GraphQL::PolicyAdapter
+        ns.register :graphql_registered_resource_enabled, true
+        ns.register :graphql_belongs_to_associations_enabled, true
         ns.register :graphql_path, "graphql"
         ns.register :graphql_multiplex_max, 20
         ns.register :graphql_dataloader, nil
         ns.register :graphql_visibility, nil
         ns.register :graphql_visibility_profile, nil
         ns.register :graphql_schema_visible, nil
+        # Optional Proc +(context_hash) -> Enumerable+ of capability names (RFC 0008).
+        ns.register :graphql_capabilities, nil
         ns.register :graphql_max_complexity, 300
         ns.register :graphql_max_depth, 18
         ns.register :graphql_batch_action_max_ids, 5000
@@ -64,7 +79,10 @@ module ActiveAdmin
       module ResourceDSLMethods
         def graphql(&block)
           if block
-            ActiveAdmin::GraphQL::ResourceDefinitionDSL.new(config.graphql_config).instance_exec(&block)
+            cfg = config.graphql_config
+            # Presence of a graphql block is an intentional opt-in when the namespace default is false.
+            cfg.enabled = true
+            ActiveAdmin::GraphQL::ResourceDefinitionDSL.new(cfg).instance_exec(&block)
           end
           config.graphql_config
         end

data/lib/active_admin/graphql/policy_adapter.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    # Builds +activeadmin_policies+ payloads for a namespace.
+    #
+    # Set +graphql_policy_adapter+ to this class (default), another subclass, or a
+    # constant name +String+. Omit policy fields with +graphql_policies_enabled = false+.
+    class PolicyAdapter
+      POLICY_ACTIONS = {
+        read: ActiveAdmin::Authorization::READ,
+        create: ActiveAdmin::Authorization::CREATE,
+        update: ActiveAdmin::Authorization::UPDATE,
+        destroy: ActiveAdmin::Authorization::DESTROY
+      }.freeze
+
+      attr_reader :namespace
+
+      def initialize(namespace:)
+        @namespace = namespace
+      end
+
+      # Whether this resource gets an object +activeadmin_policies+ field and a
+      # row in the +activeadmin_policies+ resources matrix.
+      def include_resource?(aa_resource)
+        aa_resource.graphql_config.policies_enabled
+      end
+
+      def policy_set(auth:, subject_owner:, subject:, context:)
+        base = {
+          allowed_actions: allowed_base_actions(
+            auth: auth,
+            subject_owner: subject_owner,
+            subject: subject,
+            context: context
+          ),
+          allowed_member_actions: [],
+          allowed_collection_actions: [],
+          allowed_batch_actions: []
+        }
+
+        append_resource_action_names!(base, auth: auth, subject_owner: subject_owner, subject: subject)
+
+        if (extra = namespace.graphql_policy_extra).respond_to?(:call)
+          out = extra.call(context, subject_owner, subject, base)
+          base = out if out.is_a?(Hash)
+        end
+        if (transform = namespace.graphql_policy_transform).respond_to?(:call)
+          out = transform.call(context, subject_owner, subject, base)
+          base = out if out.is_a?(Hash)
+        end
+        base
+      end
+
+      private
+
+      def policy_action_pairs
+        hook = namespace.graphql_policy_actions
+        if hook.respond_to?(:call)
+          raw = hook.call(namespace)
+          return raw.to_h.transform_keys(&:to_sym) if raw.respond_to?(:to_h)
+        end
+        POLICY_ACTIONS
+      end
+
+      def allowed_base_actions(auth:, subject_owner:, subject:, context:)
+        action_mapper = namespace.graphql_policy_action_mapper
+        policy_action_pairs.each_with_object([]) do |(name, default_action), out|
+          allowed = if action_mapper.respond_to?(:call)
+            action_mapper.call(context, subject_owner, subject, name, default_action)
+          else
+            auth.authorized?(subject_owner, default_action, subject)
+          end
+          out << name.to_s if allowed
+        end
+      end
+
+      def append_resource_action_names!(base, auth:, subject_owner:, subject:)
+        return unless subject_owner.is_a?(ActiveAdmin::Resource)
+
+        class_subject = subject_owner.resource_class
+        if subject.is_a?(Class)
+          return unless auth.authorized?(subject_owner, ActiveAdmin::Authorization::READ, class_subject)
+
+          base[:allowed_member_actions] = subject_owner.member_actions.map { |a| a.name.to_s }
+          base[:allowed_collection_actions] = subject_owner.collection_actions.map { |a| a.name.to_s }
+          base[:allowed_batch_actions] = subject_owner.batch_actions.map { |a| a.sym.to_s }
+        elsif auth.authorized?(subject_owner, ActiveAdmin::Authorization::READ, subject)
+          base[:allowed_member_actions] = subject_owner.member_actions.map { |a| a.name.to_s }
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/policy_set_cache.rb

@@ -6,10 +6,11 @@ module ActiveAdmin
     class PolicySetCache
       class << self
         def fetch(context, subject_owner:, subject:)
-          namespace = context[:namespace]
-          unless namespace
-            return policy_builder(context).send(
-              :build_policy_set,
+          adapter = policy_adapter(context)
+          raise ActiveAdmin::DependencyError, "graphql_policy_adapter is disabled" unless adapter
+
+          unless context[:namespace]
+            return adapter.policy_set(
               auth: context[:auth],
               subject_owner: subject_owner,
               subject: subject,
@@ -19,8 +20,7 @@ module ActiveAdmin
 
           cache = context[:policy_set_cache] ||= {}
           key = cache_key(subject_owner, subject)
-          cache[key] ||= policy_builder(context).send(
-            :build_policy_set,
+          cache[key] ||= adapter.policy_set(
             auth: context[:auth],
             subject_owner: subject_owner,
             subject: subject,
@@ -28,13 +28,17 @@ module ActiveAdmin
           )
         end
 
+        def policy_adapter(context)
+          policy_builder(context).send(:policy_adapter)
+        end
+
         def policy_builder(context)
           context[:policy_schema_builder] ||= SchemaBuilder.new(context[:namespace])
         end
 
         def cache_key(subject_owner, subject)
           owner_key = subject_owner_key(subject_owner)
-          "#{owner_key}:#{subject_key(subject)}"
+          "#{owner_key}:#{subject_key(subject_owner, subject)}"
         end
 
         private
@@ -47,13 +51,18 @@ module ActiveAdmin
           end
         end
 
-        def subject_key(subject)
+        def subject_key(subject_owner, subject)
           if subject.is_a?(Class)
             "class:#{subject.name}"
           elsif subject.is_a?(ActiveAdmin::Page)
             "page:#{subject.name}"
           elsif subject.is_a?(ActiveRecord::Base)
-            identity = PrimaryKey.graphql_id_value(subject)
+            identity =
+              if subject_owner.respond_to?(:graphql_config)
+                ResourceIdentity.graphql_id_value(subject_owner, subject)
+              else
+                PrimaryKey.graphql_id_value(subject)
+              end
             identity = "#{identity}:object:#{subject.object_id}" if subject.class.primary_key.blank?
             "record:#{subject.class.name}:#{identity}"
           else

data/lib/active_admin/graphql/resource_capability_dsl.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "capability_definition_dsl"
+
+module ActiveAdmin
+  module GraphQL
+    # +capability+ entry on {ResourceDefinitionDSL} (RFC 0008).
+    module ResourceCapabilityDSL
+      def capability(
+        name,
+        fields: nil,
+        queries: nil,
+        mutations: nil,
+        member_actions: nil,
+        batch_actions: nil,
+        collection_actions: nil,
+        &block
+      )
+        body = CapabilityDefinitionDSL.new(@config, name)
+        body.fields(*fields) if fields
+        body.queries(*queries) if queries
+        body.mutations(*mutations) if mutations
+        body.member_actions(*member_actions) if member_actions
+        body.batch_actions(*batch_actions) if batch_actions
+        body.collection_actions(*collection_actions) if collection_actions
+        body.instance_exec(&block) if block
+        name.to_sym
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/resource_capability_maps.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module GraphQL
+    # Capability → member maps on {ResourceConfig} (RFC 0008).
+    module ResourceCapabilityMaps
+      def field_capabilities
+        @field_capabilities ||= {}
+      end
+
+      def query_capabilities
+        @query_capabilities ||= {}
+      end
+
+      def mutation_capabilities
+        @mutation_capabilities ||= {}
+      end
+
+      def capability_for_field(name)
+        field_capabilities[name.to_sym]
+      end
+
+      def capability_for_query(kind)
+        query_capabilities[kind.to_sym]
+      end
+
+      def capability_for_mutation(kind)
+        mutation_capabilities[kind.to_sym]
+      end
+
+      def assign_field_capabilities!(capability_name, names)
+        assign_capabilities!(field_capabilities, capability_name, names, label: "field")
+      end
+
+      def assign_query_capabilities!(capability_name, names)
+        assign_capabilities!(query_capabilities, capability_name, names, label: "query")
+      end
+
+      def assign_mutation_capabilities!(capability_name, names)
+        assign_capabilities!(mutation_capabilities, capability_name, names, label: "mutation")
+      end
+
+      private
+
+      def assign_capabilities!(map, capability_name, names, label:)
+        capability = capability_name.to_sym
+        names.flatten.each do |name|
+          key = name.to_sym
+          existing = map[key]
+          if existing && existing != capability
+            raise ArgumentError,
+              "GraphQL #{label} #{key.inspect} already requires capability #{existing.inspect}"
+          end
+          map[key] = capability
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/graphql/resource_config.rb

@@ -2,18 +2,29 @@
 
 require_relative "run_action_mutation_config"
 require_relative "mutation_input_config"
+require_relative "resource_capability_maps"
 
 module ActiveAdmin
   module GraphQL
     # Per-resource GraphQL options set via +graphql+ in +ActiveAdmin.register+.
     class ResourceConfig
+      include ResourceCapabilityMaps
+
       attr_accessor :enabled
+      attr_accessor :queries_enabled
+      attr_accessor :mutations_enabled
+      attr_accessor :run_actions_enabled
+      attr_accessor :policies_enabled
       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
+      attr_accessor :identity_columns
+      attr_accessor :identity_separator
+      attr_accessor :identity_encode_proc
+      attr_accessor :identity_decode_proc
 
       # Optional resolver overrides (set from +graphql do+). SchemaBuilder still owns field names,
       # arguments, and types; procs replace only the Ruby resolution body.
@@ -27,8 +38,18 @@ module ActiveAdmin
       # {RunActionMutationConfig#payload_type} is not set. Falls back to {RunActionPayload}.
       attr_accessor :run_action_payload_type
 
-      def initialize
-        @enabled = true
+      def initialize(
+        enabled: true,
+        queries_enabled: true,
+        mutations_enabled: true,
+        run_actions_enabled: true,
+        policies_enabled: true
+      )
+        @enabled = enabled
+        @queries_enabled = queries_enabled
+        @mutations_enabled = mutations_enabled
+        @run_actions_enabled = run_actions_enabled
+        @policies_enabled = policies_enabled
         @exclude_attributes = []
       end
 

data/lib/active_admin/graphql/resource_definition_dsl.rb

@@ -3,17 +3,27 @@
 require_relative "run_action_mutation_config"
 require_relative "run_action_mutation_dsl"
 require_relative "mutation_input_definition_dsl"
+require_relative "resource_surface_dsl"
+require_relative "resource_capability_dsl"
 
 module ActiveAdmin
   module GraphQL
     # DSL for +graphql do ... end+ inside +ActiveAdmin.register+.
     class ResourceDefinitionDSL
+      include ResourceSurfaceDSL
+      include ResourceCapabilityDSL
+
       def initialize(config)
         @config = config
       end
 
-      def disable!
-        @config.enabled = false
+      # Declare GraphQL identity columns when ActiveRecord has no primary key / id column.
+      # See RFC 0007.
+      def identity(*columns, separator: nil, encode: nil, decode: nil)
+        @config.identity_columns = columns.flatten.map(&:to_s)
+        @config.identity_separator = separator
+        @config.identity_encode_proc = encode
+        @config.identity_decode_proc = decode
       end
 
       def type_name(name)