dagger_ruby 0.7.0 → 0.10.0

data/dagger_ruby.gemspec

@@ -5,24 +5,25 @@ require_relative "lib/dagger_ruby/version"
 Gem::Specification.new do |spec|
   spec.name = "dagger_ruby"
   spec.version = DaggerRuby::VERSION
-  spec.authors = ["Gaurav Tiwari", "Claude Sonnet 4 + GPT-4"]
-  spec.email = ["gaurav@gauravtiwari.co.uk"]
-
-  spec.summary = "A Ruby SDK for Dagger - build powerful CI/CD pipelines using Ruby"
-  # rubocop:disable Layout/LineLength
-  spec.description = "DaggerRuby provides a fluent, idiomatic Ruby interface to Dagger's container-based CI/CD engine. " \
-                     "Define build pipelines programmatically with Ruby instead of YAML. " \
-                     "Features lazy execution, caching, secrets, and service orchestration."
-  # rubocop:enable Layout/LineLength
+  spec.authors = ["BoringCache"]
+  spec.email = ["oss@boringcache.com"]
+
+  spec.summary = "A Ruby client for Dagger's GraphQL API"
+  spec.description = "DaggerRuby provides a small, chainable Ruby interface for running container builds, " \
+                     "services, caches, secrets, and filesystem operations with the Dagger engine."
   spec.homepage = "https://github.com/boringcache/dagger_ruby"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.1.0"
+  spec.required_ruby_version = ">= 3.2.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
   spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/boringcache/dagger_ruby"
-  spec.metadata["changelog_uri"] = "https://github.com/boringcache/dagger_ruby/blob/main/CHANGELOG.md"
+  spec.metadata["source_code_uri"] = "#{spec.homepage}/tree/v#{spec.version}"
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
+  spec.metadata["documentation_uri"] = "#{spec.homepage}#readme"
+  spec.metadata["security_policy_uri"] = "#{spec.homepage}/security/policy"
+  spec.metadata["rubygems_mfa_required"] = "true"
 
   # Specify which files should be added to the gem when it is released.
   spec.files = Dir.glob(%w[
@@ -31,18 +32,14 @@ Gem::Specification.new do |spec|
                           LICENSE*
                           CHANGELOG*
                           README*
-                          .yardopts
+                          SECURITY*
                         ]).reject { |f| File.directory?(f) }
 
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  # Core dependencies - using only Ruby stdlib
-  spec.add_dependency "base64", "~> 0.1"
-  spec.add_dependency "json", "~> 2.6"
-  spec.add_dependency "logger", "~> 1.4"
+  spec.add_dependency "base64", "~> 0.3"
+  spec.add_dependency "json", "~> 2.21"
+  spec.add_dependency "logger", "~> 1.7"
 
   # Development dependencies are managed in Gemfile
-  spec.metadata["rubygems_mfa_required"] = "true"
 end

data/lib/dagger_ruby/cache_volume.rb

@@ -4,20 +4,10 @@ require_relative "dagger_object"
 
 module DaggerRuby
   class CacheVolume < DaggerObject
-    def self.from_id(id, client)
-      query = QueryBuilder.new("cacheVolume")
-      query.load_from_id(id)
-      new(query, client)
-    end
-
     def self.root_field_name
       "cacheVolume"
     end
 
-    def key
-      get_scalar("key")
-    end
-
     def sync
       get_scalar("id") # Force execution by getting ID
       self

data/lib/dagger_ruby/client.rb

@@ -61,17 +61,24 @@ module DaggerRuby
       Directory.new(QueryBuilder.new("directory"), self)
     end
 
-    def file
-      File.new(QueryBuilder.new("file"), self)
+    def file(name, contents, permissions: nil)
+      args = { "name" => name, "contents" => contents }
+      args["permissions"] = permissions if permissions
+      File.new(QueryBuilder.new.chain_operation("file", args), self)
     end
 
-    def secret
-      Secret.new(QueryBuilder.new("secret"), self)
+    def secret(uri, cache_key: nil)
+      args = { "uri" => uri }
+      args["cacheKey"] = cache_key if cache_key
+      Secret.new(QueryBuilder.new.chain_operation("secret", args), self)
     end
 
-    def cache_volume(name)
-      query = QueryBuilder.new
-      query = query.chain_operation("cacheVolume", { "key" => name })
+    def cache_volume(name, opts = {})
+      args = { "key" => name }
+      args["source"] = graphql_id(opts[:source]) if opts[:source]
+      args["sharing"] = QueryBuilder.enum_value(opts[:sharing]) if opts[:sharing]
+      args["owner"] = opts[:owner] if opts[:owner]
+      query = QueryBuilder.new.chain_operation("cacheVolume", args)
       CacheVolume.new(query, self)
     end
 
@@ -81,21 +88,12 @@ module DaggerRuby
 
     def git(url, opts = {})
       args = { "url" => url }
-      args["keepGitDir"] = opts[:keep_git_dir] if opts.key?(:keep_git_dir)
       args["sshKnownHosts"] = opts[:ssh_known_hosts] if opts[:ssh_known_hosts]
-      if opts[:ssh_auth_socket]
-        args["sshAuthSocket"] =
-          opts[:ssh_auth_socket].is_a?(DaggerObject) ? opts[:ssh_auth_socket].id : opts[:ssh_auth_socket]
-      end
+      args["sshAuthSocket"] = graphql_id(opts[:ssh_auth_socket]) if opts[:ssh_auth_socket]
       args["httpAuthUsername"] = opts[:http_auth_username] if opts[:http_auth_username]
-      if opts[:http_auth_token]
-        args["httpAuthToken"] =
-          opts[:http_auth_token].is_a?(DaggerObject) ? opts[:http_auth_token].id : opts[:http_auth_token]
-      end
-      if opts[:http_auth_header]
-        args["httpAuthHeader"] =
-          opts[:http_auth_header].is_a?(DaggerObject) ? opts[:http_auth_header].id : opts[:http_auth_header]
-      end
+      args["httpAuthToken"] = graphql_id(opts[:http_auth_token]) if opts[:http_auth_token]
+      args["httpAuthHeader"] = graphql_id(opts[:http_auth_header]) if opts[:http_auth_header]
+      args["experimentalServiceHost"] = graphql_id(opts[:service_host]) if opts[:service_host]
 
       query = QueryBuilder.new
       query = query.chain_operation("git", args)
@@ -106,10 +104,9 @@ module DaggerRuby
       args = { "url" => url }
       args["name"] = opts[:name] if opts[:name]
       args["permissions"] = opts[:permissions] if opts[:permissions]
-      if opts[:auth_header]
-        args["authHeader"] =
-          opts[:auth_header].is_a?(DaggerObject) ? opts[:auth_header].id : opts[:auth_header]
-      end
+      args["checksum"] = opts[:checksum] if opts[:checksum]
+      args["authHeader"] = graphql_id(opts[:auth_header]) if opts[:auth_header]
+      args["experimentalServiceHost"] = graphql_id(opts[:service_host]) if opts[:service_host]
 
       query = QueryBuilder.new
       query = query.chain_operation("http", args)
@@ -143,6 +140,10 @@ module DaggerRuby
 
     private
 
+    def graphql_id(value)
+      value.is_a?(DaggerObject) ? value.id : value
+    end
+
     def handle_response(response)
       case response.code.to_i
       when 200

data/lib/dagger_ruby/config.rb

@@ -1,8 +1,13 @@
 require "logger"
+require_relative "version"
 
 module DaggerRuby
   class Config
-    attr_reader :log_output, :workdir, :timeout, :quiet, :silent, :progress
+    ENGINE_IMAGE = "registry.dagger.io/engine".freeze
+    RUNTIMES = %i[auto apple docker].freeze
+
+    attr_reader :log_output, :workdir, :timeout, :quiet, :silent, :progress,
+                :runtime, :runner_host, :dagger_version, :verify_version
 
     def initialize(options = {})
       @log_output = options[:log_output]
@@ -11,6 +16,38 @@ module DaggerRuby
       @quiet = options[:quiet] || ENV["DAGGER_QUIET"]&.to_i
       @silent = options[:silent] || ENV["DAGGER_SILENT"] == "true"
       @progress = options[:progress] || ENV.fetch("DAGGER_PROGRESS", nil)
+      @runtime = normalize_runtime(options.fetch(:runtime, ENV.fetch("DAGGER_RUBY_RUNTIME", "auto")))
+      @runner_host = options[:runner_host]
+      @dagger_version = options.fetch(:dagger_version, DAGGER_VERSION).to_s.delete_prefix("v")
+      @verify_version = options.fetch(:verify_version, true)
+
+      raise ArgumentError, "runner_host and runtime cannot both be configured" if @runner_host && @runtime != :auto
+    end
+
+    def environment
+      environment = {}
+      environment["_EXPERIMENTAL_DAGGER_RUNNER_HOST"] = resolved_runner_host if resolved_runner_host
+      environment
+    end
+
+    def expected_engine_version
+      "v#{dagger_version}"
+    end
+
+    private
+
+    def normalize_runtime(value)
+      runtime = value.to_s.downcase.to_sym
+      return runtime if RUNTIMES.include?(runtime)
+
+      raise ArgumentError, "Unknown Dagger runtime '#{value}'. Use auto, apple, or docker."
+    end
+
+    def resolved_runner_host
+      return runner_host if runner_host
+      return if runtime == :auto
+
+      "image+#{runtime}://#{ENGINE_IMAGE}:#{expected_engine_version}"
     end
   end
 end

data/lib/dagger_ruby/container.rb

@@ -4,12 +4,6 @@ require_relative "dagger_object"
 
 module DaggerRuby
   class Container < DaggerObject
-    def self.from_id(id, client)
-      query = QueryBuilder.new("container")
-      query.load_from_id(id)
-      new(query, client)
-    end
-
     def self.root_field_name
       "container"
     end
@@ -22,23 +16,28 @@ module DaggerRuby
       args = { "path" => path, "source" => directory.is_a?(DaggerObject) ? directory.id : directory }
       args["exclude"] = opts[:exclude] if opts[:exclude]
       args["include"] = opts[:include] if opts[:include]
+      args["gitignore"] = opts[:gitignore] if opts[:gitignore]
       args["owner"] = opts[:owner] if opts[:owner]
       args["expand"] = opts[:expand] if opts.key?(:expand)
+      args["permissions"] = opts[:permissions] if opts[:permissions]
 
       chain_operation("withDirectory", args)
     end
 
-    def with_workdir(path)
-      chain_operation("withWorkdir", { "path" => path })
+    def with_workdir(path, expand: nil)
+      args = { "path" => path }
+      args["expand"] = expand unless expand.nil?
+      chain_operation("withWorkdir", args)
     end
 
     def with_exec(args, opts = {})
       exec_args = { "args" => args }
       exec_args["useEntrypoint"] = opts[:use_entrypoint] if opts.key?(:use_entrypoint)
       exec_args["stdin"] = opts[:stdin] if opts[:stdin]
+      exec_args["redirectStdin"] = opts[:redirect_stdin] if opts[:redirect_stdin]
       exec_args["redirectStdout"] = opts[:redirect_stdout] if opts[:redirect_stdout]
       exec_args["redirectStderr"] = opts[:redirect_stderr] if opts[:redirect_stderr]
-      exec_args["expect"] = opts[:expect] if opts[:expect]
+      exec_args["expect"] = QueryBuilder.enum_value(opts[:expect]) if opts[:expect]
       if opts.key?(:experimental_privileged_nesting)
         exec_args["experimentalPrivilegedNesting"] = opts[:experimental_privileged_nesting]
       end
@@ -54,7 +53,7 @@ module DaggerRuby
     def with_mounted_cache(path, cache, opts = {})
       args = { "path" => path, "cache" => cache.is_a?(DaggerObject) ? cache.id : cache }
       args["source"] = opts[:source] if opts[:source]
-      args["sharing"] = opts[:sharing] if opts[:sharing]
+      args["sharing"] = QueryBuilder.enum_value(opts[:sharing]) if opts[:sharing]
       args["owner"] = opts[:owner] if opts[:owner]
       args["expand"] = opts[:expand] if opts.key?(:expand)
 
@@ -91,10 +90,7 @@ module DaggerRuby
       chain_operation("withSecretVariable", args)
     end
 
-    def with_secret_env(name, secret)
-      args = { "name" => name, "secret" => secret.is_a?(DaggerObject) ? secret.id : secret }
-      chain_operation("withSecretEnv", args)
-    end
+    alias with_secret_env with_secret_variable
 
     def with_entrypoint(args, opts = {})
       entrypoint_args = { "args" => args }
@@ -102,13 +98,37 @@ module DaggerRuby
       chain_operation("withEntrypoint", entrypoint_args)
     end
 
+    def with_default_args(args)
+      chain_operation("withDefaultArgs", { "args" => args })
+    end
+
+    def with_docker_healthcheck(args, opts = {})
+      healthcheck_args = { "args" => args }
+      healthcheck_args["shell"] = opts[:shell] if opts.key?(:shell)
+      healthcheck_args["interval"] = opts[:interval] if opts[:interval]
+      healthcheck_args["timeout"] = opts[:timeout] if opts[:timeout]
+      healthcheck_args["startPeriod"] = opts[:start_period] if opts[:start_period]
+      healthcheck_args["startInterval"] = opts[:start_interval] if opts[:start_interval]
+      healthcheck_args["retries"] = opts[:retries] if opts[:retries]
+
+      chain_operation("withDockerHealthcheck", healthcheck_args)
+    end
+
+    def without_docker_healthcheck
+      chain_operation("withoutDockerHealthcheck")
+    end
+
     def with_user(name)
       chain_operation("withUser", { "name" => name })
     end
 
-    def with_registry_auth(_address, _username, _secret)
-      puts "⚠️  Registry auth temporarily disabled due to GraphQL formatting issues"
-      self
+    def with_registry_auth(address, username, secret)
+      args = {
+        "address" => address,
+        "username" => username,
+        "secret" => secret.is_a?(DaggerObject) ? secret.id : secret,
+      }
+      chain_operation("withRegistryAuth", args)
     end
 
     def without_registry_auth(address)
@@ -139,21 +159,6 @@ module DaggerRuby
       get_object("asService", Service, args)
     end
 
-    def build(context, opts = {})
-      args = { "context" => context.is_a?(DaggerObject) ? context.id : context }
-      args["dockerfile"] = opts[:dockerfile] if opts[:dockerfile]
-      args["target"] = opts[:target] if opts[:target]
-      args["buildArgs"] = opts[:build_args] if opts[:build_args]
-
-      if opts[:secrets]
-        raise NotImplementedError, "Build secrets are not yet supported. Use with_mounted_secret instead."
-      end
-
-      args["noInit"] = opts[:no_init] if opts.key?(:no_init)
-
-      chain_operation("build", args)
-    end
-
     def import(source, opts = {})
       args = { "source" => source.is_a?(DaggerObject) ? source.id : source }
       args["tag"] = opts[:tag] if opts[:tag]
@@ -179,7 +184,7 @@ module DaggerRuby
 
     def with_exposed_port(port, opts = {})
       args = { "port" => port }
-      args["protocol"] = opts[:protocol] if opts[:protocol]
+      args["protocol"] = QueryBuilder.enum_value(opts[:protocol]) if opts[:protocol]
       args["description"] = opts[:description] if opts[:description]
       if opts.key?(:experimental_skip_healthcheck)
         args["experimentalSkipHealthcheck"] = opts[:experimental_skip_healthcheck]
@@ -196,6 +201,7 @@ module DaggerRuby
     def with_mounted_directory(path, source, opts = {})
       args = { "path" => path, "source" => source.is_a?(DaggerObject) ? source.id : source }
       args["owner"] = opts[:owner] if opts[:owner]
+      args["readOnly"] = opts[:read_only] if opts.key?(:read_only)
       args["expand"] = opts[:expand] if opts.key?(:expand)
 
       chain_operation("withMountedDirectory", args)
@@ -232,7 +238,7 @@ module DaggerRuby
 
     def without_exposed_port(port, opts = {})
       args = { "port" => port }
-      args["protocol"] = opts[:protocol] if opts[:protocol]
+      args["protocol"] = QueryBuilder.enum_value(opts[:protocol]) if opts[:protocol]
 
       chain_operation("withoutExposedPort", args)
     end
@@ -273,24 +279,31 @@ module DaggerRuby
       get_scalar("entrypoint")
     end
 
+    def default_args
+      get_scalar("defaultArgs")
+    end
+
+    def docker_healthcheck
+      get_selection(
+        "dockerHealthcheck",
+        "args shell interval timeout startPeriod startInterval retries",
+      )
+    end
+
     def env_variables
-      get_scalar("envVariables")
+      get_selection("envVariables", "name value")
     end
 
     def env_variable(name)
-      query = @query_builder.build_query_with_selection("envVariable(name: \"#{name}\")")
-      result = @client.execute(query)
-      extract_value_from_result(result, "envVariable")
+      get_scalar("envVariable", { "name" => name })
     end
 
     def labels
-      get_scalar("labels")
+      get_selection("labels", "name value")
     end
 
     def label(name)
-      query = @query_builder.build_query_with_selection("label(name: \"#{name}\")")
-      result = @client.execute(query)
-      extract_value_from_result(result, "label")
+      get_scalar("label", { "name" => name })
     end
 
     def mounts
@@ -298,7 +311,7 @@ module DaggerRuby
     end
 
     def exposed_ports
-      get_scalar("exposedPorts")
+      get_selection("exposedPorts", "port protocol description experimentalSkipHealthcheck")
     end
 
     def platform
@@ -311,48 +324,51 @@ module DaggerRuby
 
     def export(path, opts = {})
       args = { "path" => path }
-      args["platformVariants"] = opts[:platform_variants] if opts[:platform_variants]
-      args["forcedCompression"] = opts[:forced_compression] if opts[:forced_compression]
-      args["mediaTypes"] = opts[:media_types] if opts[:media_types]
+      args["platformVariants"] = graphql_ids(opts[:platform_variants]) if opts[:platform_variants]
+      args["forcedCompression"] = QueryBuilder.enum_value(opts[:forced_compression]) if opts[:forced_compression]
+      args["mediaTypes"] = QueryBuilder.enum_value(opts[:media_types]) if opts[:media_types]
       args["expand"] = opts[:expand] if opts.key?(:expand)
 
-      query = @query_builder.build_query_with_selection("export(#{format_arguments(args)})")
-      result = @client.execute(query)
-      extract_value_from_result(result, "export")
+      get_scalar("export", args)
     end
 
     def export_to_file(path, opts = {})
-      args = { "path" => path }
-      args["platformVariants"] = opts[:platform_variants] if opts[:platform_variants]
-      args["forcedCompression"] = opts[:forced_compression] if opts[:forced_compression]
-      args["mediaTypes"] = opts[:media_types] if opts[:media_types]
-      args["expand"] = opts[:expand] if opts.key?(:expand)
+      export(path, opts)
+    end
+
+    def export_image(name, opts = {})
+      args = { "name" => name }
+      args["platformVariants"] = graphql_ids(opts[:platform_variants]) if opts[:platform_variants]
+      args["forcedCompression"] = QueryBuilder.enum_value(opts[:forced_compression]) if opts[:forced_compression]
+      args["mediaTypes"] = QueryBuilder.enum_value(opts[:media_types]) if opts[:media_types]
 
-      query = @query_builder.build_query_with_selection("exportToFile(#{format_arguments(args)})")
-      result = @client.execute(query)
-      extract_value_from_result(result, "exportToFile")
+      get_scalar("exportImage", args)
+      name
     end
 
     def publish(address, opts = {})
       args = { "address" => address }
-      args["platformVariants"] = opts[:platform_variants] if opts[:platform_variants]
-      args["forcedCompression"] = opts[:forced_compression] if opts[:forced_compression]
-      args["mediaTypes"] = opts[:media_types] if opts[:media_types]
-
-      query = @query_builder.build_query_with_selection("publish(#{format_arguments(args)})")
-      result = @client.execute(query)
-      extract_value_from_result(result, "publish")
+      args["platformVariants"] = graphql_ids(opts[:platform_variants]) if opts[:platform_variants]
+      args["forcedCompression"] = QueryBuilder.enum_value(opts[:forced_compression]) if opts[:forced_compression]
+      args["mediaTypes"] = QueryBuilder.enum_value(opts[:media_types]) if opts[:media_types]
+
+      if opts[:registry_service]
+        args["registryService"] = if opts[:registry_service].is_a?(DaggerObject)
+                                    opts[:registry_service].id
+                                  else
+                                    opts[:registry_service]
+                                  end
+      end
+      get_scalar("publish", args)
     end
 
     def as_tarball(opts = {})
       args = {}
-      args["platformVariants"] = opts[:platform_variants] if opts[:platform_variants]
-      args["forcedCompression"] = opts[:forced_compression] if opts[:forced_compression]
-      args["mediaTypes"] = opts[:media_types] if opts[:media_types]
+      args["platformVariants"] = graphql_ids(opts[:platform_variants]) if opts[:platform_variants]
+      args["forcedCompression"] = QueryBuilder.enum_value(opts[:forced_compression]) if opts[:forced_compression]
+      args["mediaTypes"] = QueryBuilder.enum_value(opts[:media_types]) if opts[:media_types]
 
-      query = @query_builder.build_query_with_selection("asTarball(#{format_arguments(args)})")
-      result = @client.execute(query)
-      extract_value_from_result(result, "asTarball")
+      get_object("asTarball", File, args)
     end
 
     def sync
@@ -362,32 +378,8 @@ module DaggerRuby
 
     private
 
-    def format_arguments(args)
-      return "" if args.empty?
-
-      args.map { |key, value| "#{key}: #{format_value(value)}" }.join(", ")
-    end
-
-    def format_value(value)
-      case value
-      when String
-        "\"#{value}\""
-      when Integer, Float
-        value.to_s
-      when TrueClass, FalseClass
-        value.to_s
-      when NilClass
-        "null"
-      when Array
-        "[#{value.map { |v| format_value(v) }.join(", ")}]"
-      when Hash
-        formatted_pairs = value.map { |k, v| "#{k}: #{format_value(v)}" }
-        "{ #{formatted_pairs.join(", ")} }"
-      when DaggerObject
-        value.id
-      else
-        "\"#{value}\""
-      end
+    def graphql_ids(values)
+      values.map { |value| value.is_a?(DaggerObject) ? value.id : value }
     end
   end
 end

data/lib/dagger_ruby/dagger_object.rb

@@ -23,8 +23,15 @@ module DaggerRuby
 
     protected
 
-    def get_scalar(field)
-      query = @query_builder.build_query_with_selection(field)
+    def get_scalar(field, args = {})
+      query = @query_builder.build_query_with_selection(field, args)
+      result = @client.execute_query(query)
+      extract_value_from_result(result, field)
+    end
+
+    def get_selection(field, selection, args = {})
+      selected_field = "#{QueryBuilder.new.field_selection(field, args)} { #{selection} }"
+      query = @query_builder.build_query_with_selection(selected_field)
       result = @client.execute_query(query)
       extract_value_from_result(result, field)
     end
@@ -52,42 +59,25 @@ module DaggerRuby
       klass.new(new_query, @client)
     end
 
-    def get_object_array(field, klass, _args = {})
-      query = @query_builder.build_query_with_selection(field)
-
-      array_field = query.selections.find { |s| s.field == field }
-      array_field&.select("id")
-
-      result = @client.execute(query)
-      ids = extract_array_from_result(result, field)
-
-      ids.map { |id_data| klass.from_id(id_data["id"], @client) }
-    end
-
-    private
-
-    def extract_array_from_result(result, field)
-      current = result["data"]
-
-      if @query_builder.root_field
-        current = current[@query_builder.root_field]
-        @query_builder.operation_chain.each do |operation|
-          current = current[operation[:field]] if current
-        end
-      end
-      current&.[](field) || []
+    def get_object_array(field, klass, args = {})
+      get_selection(field, "id", args).to_a.map { |data| klass.from_id(data.fetch("id"), @client) }
     end
 
     class << self
       def from_id(id, client)
-        query = QueryBuilder.new(root_field_name)
-        query.load_from_id(id)
+        query = QueryBuilder.new.chain_operation("load#{graphql_type_name}FromID", { "id" => id })
         new(query, client)
       end
 
       def root_field_name
         name.split("::").last.downcase
       end
+
+      private
+
+      def graphql_type_name
+        name.split("::").last
+      end
     end
   end
 end