graphiti 2.0.0.beta.3 → 2.0.0.beta.5

data/docs/upgrading.md

@@ -0,0 +1,260 @@
+---
+title: 'Upgrading to Graphiti 2.0'
+slug: /upgrading
+---
+
+# Upgrading to Graphiti 2.0
+
+Graphiti 2.0 requires **Ruby 3.2+** and **ActiveSupport 7.1+**. Rails is not a dependency, but if you use it, 7.1+. Ruby 3.1 and earlier are past end of life, and Rails 6.1 and 7.0 do not support Ruby 3.2. Apps that cannot move yet should stay on the 1.x branch, which remains open for hotfixes.
+
+## What you have to change {#what-you-have-to-change}
+
+Four things, and three of them fail loudly if you skip them.
+
+**1. Drop three gems.** `graphiti-rails`, `graphiti_spec_helpers` and `graphiti_errors` are now part of `graphiti` itself.
+
+```diff title="Gemfile"
++ gem "graphiti", "~> 2.0.0.beta" # follows the betas and picks up 2.0 final when it ships
+- gem "graphiti-rails"
+- gem "graphiti_spec_helpers"
+- gem "graphiti_errors"
+```
+
+Graphiti raises at load if one is still installed, because they ship files that collide with Graphiti's own, so leaving them in place means load order decides which copy you get.
+
+**2. Include the Rails integration in your controllers.**
+
+```ruby
+class ApplicationController < ActionController::Base
+  include Graphiti::Rails::Controller
+end
+```
+
+If the controller already has `include Graphiti::Rails`, replace it with `include Graphiti::Rails::Controller`. 
+
+<details>
+<summary>What the include actually brings, and what a controller without it loses</summary>
+
+Until 2.0, Graphiti added itself to **every** controller in the application: an `around_action` wrapping each request in a Graphiti context, another wrapping it in the debugger, and a catch-all exception handler, on Devise controllers, admin controllers, HTML pages, everything.
+
+`Graphiti::Rails::Controller` now bundles all of it, and including it is required. Including it in `ApplicationController` matches 1.x behavior. Including it in an API base class scopes it and leaves the rest of the app alone. A controller without it gets no Graphiti context, no debugger, and none of Graphiti's exception handlers, so if a resource action sees an empty `Graphiti.context`, this include is what is missing.
+
+The class-level DSL travels with it, which is the one failure you see before a request is ever served:
+
+```ruby
+class PostsController < ApplicationController
+  self.sideload_allowlist = {index: [:comments]} # NoMethodError without the include
+end
+```
+
+`sideload_allowlist` comes from `Graphiti::Context`, so a controller that never includes `Graphiti::Rails::Controller` raises `NoMethodError` while the class body is being loaded. Watch for base classes that were given `Graphiti::Rails::Responders` alone. Responders declares formats and nothing else, and does not carry the context.
+
+`Graphiti::Rails::Responders` is separate and most apps do not need it. It exists for the [`responders`](https://github.com/heartcombo/responders) gem's `respond_with`, and depends on that gem, which is why it is not part of `Graphiti::Rails::Controller`.
+
+</details>
+
+**3. Update `around_persistence` hooks**, if you have any.
+
+They now receive the already-assigned model where they used to receive the attributes hash, so a hook doing `attributes[:tenant_id] = current_tenant.id` raises. Move that to `before_attributes`, or set it on the model.
+
+<details>
+<summary>Before and after, and what else moved with it</summary>
+
+Attributes are now assigned to the model once, up front, before the persistence hooks run, which is what lets `build` and `find` hand you the model before anything is written. See the [lifecycle hooks guide](/concepts/persisting#persistence-lifecycle-hooks) for what that enables.
+
+That changes one hook.
+
+#### around_persistence receives the model, not the attributes hash
+
+It now wraps the save of an already-assigned model, and gets that model:
+
+```ruby
+# 1.x
+def do_around_persistence(attributes)
+  attributes[:tenant_id] = current_tenant.id
+  model = yield
+  model.log_saved!
+end
+
+# 2.0
+def do_around_persistence(model)
+  model.tenant_id = current_tenant.id # last chance to touch the model before save, inside the transaction
+  saved = yield
+  saved.log_saved!
+end
+```
+
+To migrate, move attribute-hash modifications to `before_attributes` (which still receives the mutable hash, before assignment), or set the value on the model as above. Hooks that only wrap their yield, such as transactions, timing and post-save side effects, need no changes. Graphiti 1.x releases warn at runtime when a hook would be affected.
+
+`before/around/after_attributes` and `before/around/after_save` are unchanged. Custom `create`/`update` adapter overrides keep their 1.x signatures.
+
+#### Fine print
+
+- If you inspect the model before saving, the attributes callbacks run at inspection time (in your controller, outside the save transaction). On the plain `save` path they run inside the transaction, at the same point as 1.x.
+- Writable guards judge persisted state: a guard asking for the model gets a fresh build/find, never the current request's unsaved changes. A payload cannot influence its own authorization.
+- Sideposted child models are still built and assigned during save, and `data` exposes the pre-assigned root model only.
+
+</details>
+
+**4. Wrap specs that assert on error payloads.**
+
+```ruby
+RSpec.configure do |config|
+  config.include Graphiti::Rails::TestHelpers, type: :request
+end
+
+it "renders a 404" do
+  handle_request_exceptions { get "/posts/999" }
+
+  expect(response.status).to eq(404)
+end
+```
+
+Exceptions now propagate untouched in tests rather than rendering, so a spec expecting a 404 body sees the exception raised instead. This is the one that breaks the suite that would otherwise have told you the app was fine.
+
+<details>
+<summary>Why it has to be a request spec</summary>
+
+Exceptions propagate untouched in tests as of 2.0. A spec that asserts on a rendered error payload sees the exception raised instead, so wrap the request in `handle_request_exceptions`. The setup is [step 4 of the migration](/upgrading#what-you-have-to-change).
+
+It has to be a request spec. Exceptions are rendered in Rack middleware, which controller specs bypass, so the same assertion in a controller spec never sees a rendered payload no matter how it is wrapped.
+
+`handle_request_exceptions` replaces `GraphitiErrors.enable!` and `.disable!`, which toggled rendering globally. Wrapping the request scopes it to the example instead.
+
+</details>
+
+## Behavior changes to be aware of {#behavior-changes}
+
+Nothing to do here. These change what a client receives or when a callback runs, and none of them warns you, because none of them is a rename.
+
+<details>
+<summary>A `belongs_to` renders resource linkage in every payload, where 1.x sent only a link</summary>
+
+A `belongs_to` now includes resource linkage in the payload by default, where 1.x sent only a link:
+
+```json
+"employee": { "data": { "type": "employees", "id": "1" }, "links": { "related": "..." } }
+```
+
+The id comes from the foreign key already on the parent, so this costs no extra queries, and clients can resolve the relationship against data they already hold instead of following the link. `has_many` is unchanged, since answering there means a query per record.
+
+Not every `belongs_to` qualifies. A `scope` or `params` block, a `base_scope`, a polymorphic or remote target or a custom `primary_key` all mean the foreign key is not the related id, and those keep loading the association, so they stay opt-in as in 1.x.
+
+Relationships are marked `linkage: true` in `schema.json`, and the schema check reports a relationship that stops including it.
+
+To go back to the old payload for one relationship:
+
+```ruby
+belongs_to :employee, always_include_resource_ids: false
+```
+
+Or for the whole API, on the resource everything inherits from. The same setting with `true` is the 2.0 replacement for the `Sideload::BelongsTo` monkey patch that [#167](https://github.com/graphiti-api/graphiti/issues/167) has been recommending, and it now covers every relationship type rather than only `belongs_to`:
+
+```ruby
+class ApplicationResource < Graphiti::Resource
+  self.abstract_class = true
+
+  self.always_include_resource_ids_by_default = false
+end
+```
+
+How linkage is configured, and when a `belongs_to` cannot use its foreign key, is covered in [Customizing Relationships](/concepts/relationships#customizing-relationships).
+
+</details>
+
+<details>
+<summary>`ConflictRequest` renders `code: "conflict"` at 409, where `graphiti-rails` surfaced it as a 500</summary>
+
+Graphiti 1.x shipped two exception systems, `graphiti_errors` in core and `rescue_registry` in `graphiti-rails`, and both loaded in every Rails app. `rescue_registry` is now the only one, and installs automatically as a dependency.
+
+Graphiti registers handlers for `InvalidRequest` (400), `ConflictRequest` (409), `RecordNotFound` (404), `RemoteWrite` (400) and `SingularSideload` (400), plus a fallback that renders anything else as JSON:API. Register your own on any controller:
+
+```ruby
+register_exception MyApp::Forbidden, status: 403
+register_exception MyApp::Throttled, status: 429, handler: MyApp::ThrottleHandler
+```
+
+`register_exception` comes from `rescue_registry`, which adds it to every controller, so you do not need `Graphiti::Rails::Controller` to register your own exceptions or to have them rendered. What the include adds is Graphiti's own registrations above, plus the fallback that renders anything unregistered as JSON:API.
+
+Only formats in `config.graphiti.handled_exception_formats` (default `[:jsonapi]`) are rendered by Graphiti. Everything else falls through to Rails.
+
+If you subclassed `GraphitiErrors::ExceptionHandler`, note the interface changed with the gem: it is now `build_payload` / `formatted_response` / `status_code`, not `error_payload` / `status_code(error)`.
+
+Registering and customizing handlers is covered in [Error Handling](/topics/error-handling).
+
+**Conflicts now report as conflicts.** `Graphiti::Errors::ConflictRequest`, raised when a `PATCH` payload's id does not match the URL, used to render a 409 whose body said `code: "bad_request"`, `title: "Request Error"`. It now says `code: "conflict"`, `title: "Conflict Error"`. Under `graphiti-rails` this exception had no registered handler at all and surfaced as a 500, so for most apps this payload is new rather than changed.
+
+</details>
+
+<details>
+<summary>`Node#respond_to?` answers `true` for any attribute present in the payload</summary>
+
+`Node#respond_to?` is now a proper `respond_to_missing?`, so `node.respond_to?(:first_name)` returns `true` for attributes present in the payload where it used to return `false`. Nothing to do unless a spec asserted on the old `false`.
+
+The node helpers are covered in [#jsonapi_data](/topics/testing#jsonapi-data).
+
+</details>
+
+<details>
+<summary>Attributes are assigned before the persistence hooks run, so inspecting a model first moves the attributes callbacks outside the save transaction</summary>
+
+If you inspect the model before saving, the attributes callbacks run at inspection time, in your controller and outside the save transaction. On the plain `save` path they run inside the transaction, at the same point as 1.x.
+
+The hooks and their order are covered in [Persistence Lifecycle Hooks](/concepts/persisting#persistence-lifecycle-hooks).
+
+</details>
+
+## Deprecations you should fix {#deprecations-you-should-fix}
+
+Every name below still works, warns, and will be removed in the next major. They're easy fixes though, so why not now?
+
+| 1.x | 2.0 |
+| --- | --- |
+| `require "graphiti_spec_helpers/rspec"` | `require "graphiti/spec_helpers/rspec"` |
+| `GraphitiSpecHelpers::RSpec` / `::Sugar` / `::Errors::*` | `Graphiti::SpecHelpers::*` |
+| `require "graphiti-rails"` | remove / no longer needed |
+| `include Graphiti::Rails` | `include Graphiti::Rails::Controller`|
+| `include Graphiti::Responders` | `include Graphiti::Rails::Responders` |
+| `jsonapi_context` | `graphiti_context` |
+| `GraphitiErrors::Validation::Serializer` | `Graphiti::ErrorSerializers::Validation` |
+| `GraphitiErrors::InvalidRequest::Serializer` | `Graphiti::ErrorSerializers::InvalidRequest` |
+| `GraphitiErrors::ConflictRequest::Serializer` | `Graphiti::ErrorSerializers::ConflictRequest` |
+| rspec shared contexts `"resource testing"`, `"remote api"` | `"graphiti resource testing"`, `"graphiti remote api"` |
+| `GraphitiContextProxy` | `Graphiti::SpecHelpers::ContextProxy` |
+| `context_namespace` | `current_action` |
+| `Graphiti::Rails::DEPRECATOR` | `Graphiti::DEPRECATOR` (the old name still resolves) |
+| `require "graphiti_errors"`, `require "graphiti/responders"` | remove / no longer needed |
+
+`RSpec.describe PostResource, type: :resource` still picks up the resource-testing context automatically. That has not changed.
+
+## Removed outright {#removed-outright}
+
+| 1.x | 2.0 |
+| --- | --- |
+| `include GraphitiErrors` | `register_exception` is available on every controller |
+| `GraphitiErrors::ExceptionHandler` | subclass `Graphiti::Rails::ExceptionHandler` |
+| `GraphitiErrors.enable!` / `.disable!` | `handle_request_exceptions` |
+
+## Without Rails {#without-rails}
+
+<details>
+<summary>Using the error serializers and exception handling outside Rails</summary>
+
+The serializers move but keep working: `Graphiti::ErrorSerializers::Validation`, `::InvalidRequest` and `::ConflictRequest` load with core and need no Rails.
+
+`GraphitiErrors::ExceptionHandler`, which turned any exception into a JSON:API errors payload, is replaced by `RescueRegistry::ExceptionHandler`, a runtime dependency now, and usable outside Rails:
+
+```ruby
+require "rack" # or RescueRegistry::ExceptionHandler raises NameError on Rack
+require "rescue_registry"
+
+handler = RescueRegistry::ExceptionHandler.new(exception, status: 404)
+handler.build_payload            # => {errors: [{code: :not_found, status: "404", ...}]}
+handler.formatted_response(:json) # => [404, "{\"errors\":[...]}", :json]
+```
+
+`register_exception` and the rendering are Rails-only, but rescue_registry ships `RescueRegistry::ShowExceptions`, a Rack middleware for exactly this case. See its README.
+
+`GraphitiErrors.logger` has no replacement. `Graphiti.logger` is the nearest thing.
+
+</details>

data/gemfiles/rails_7_1.gemfile

@@ -2,12 +2,13 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 7.1"
+gem "rails", "~> 7.1.0"
 gem "rspec-rails"
-gem "sqlite3", "~> 2.1"
-gem "database_cleaner"
+gem "responders"
+gem "sqlite3", "~> 1.4"
 
 group :test do
+  gem "database_cleaner"
   gem "pry"
   gem "pry-byebug", platform: [:mri]
   gem "appraisal"

data/gemfiles/{rails_7_2_graphiti_rails.gemfile → rails_7_2.gemfile}

@@ -2,13 +2,13 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 7.2"
+gem "rails", "~> 7.2.0"
 gem "rspec-rails"
+gem "responders"
 gem "sqlite3", "~> 2.1"
-gem "database_cleaner"
-gem "graphiti-rails", "~> 0.4.0"
 
 group :test do
+  gem "database_cleaner"
   gem "pry"
   gem "pry-byebug", platform: [:mri]
   gem "appraisal"

data/gemfiles/{rails_8_1_graphiti_rails.gemfile → rails_8_0.gemfile}

@@ -2,13 +2,13 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 8.1"
+gem "rails", "~> 8.0.0"
 gem "rspec-rails"
+gem "responders"
 gem "sqlite3", "~> 2.1"
-gem "database_cleaner"
-gem "graphiti-rails", "~> 0.4.0"
 
 group :test do
+  gem "database_cleaner"
   gem "pry"
   gem "pry-byebug", platform: [:mri]
   gem "appraisal"

data/gemfiles/{rails_8_0_graphiti_rails.gemfile → rails_8_1.gemfile}

@@ -2,13 +2,13 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 8.0"
+gem "rails", "~> 8.1.0"
 gem "rspec-rails"
+gem "responders"
 gem "sqlite3", "~> 2.1"
-gem "database_cleaner"
-gem "graphiti-rails", "~> 0.4.0"
 
 group :test do
+  gem "database_cleaner"
   gem "pry"
   gem "pry-byebug", platform: [:mri]
   gem "appraisal"

data/graphiti.gemspec

@@ -16,32 +16,14 @@ Gem::Specification.new do |spec|
   spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 3.0"
-
-  # TODO: remove once the 1.12 upgrade window has passed
-  spec.post_install_message = <<~MSG
-    Graphiti: relationship readable:/writable: guards are now enforced.
-
-    Symbols, strings, and procs passed to a relationship's readable/writable
-    guards were always interpreted as true and never actually called before this
-    conditional relationship change. They are now evaluated per-request, where
-    unreadable relationships are omitted from responses and includes, and unwritable
-    relationships reject writes.
-
-    To list every affected relationship in your app:
-
-      bin/rails runner 'puts Graphiti.guarded_relationships'
-
-    Audit these before deploying. Apps using schema.json will also see affected 
-    relationships flagged as "became guarded" by the schema check.
-  MSG
+  spec.required_ruby_version = ">= 3.2"
 
   spec.add_dependency "jsonapi-serializable", "~> 0.3.0"
   spec.add_dependency "jsonapi-renderer", "~> 0.2", ">= 0.2.2"
   spec.add_dependency "dry-types", ">= 0.15.0", "< 2.0"
-  spec.add_dependency "graphiti_errors", "~> 1.1.0"
+  spec.add_dependency "rescue_registry", "~> 1.0"
   spec.add_dependency "concurrent-ruby", ">= 1.2", "< 2.0"
-  spec.add_dependency "activesupport", ">= 5.2"
+  spec.add_dependency "activesupport", ">= 7.1"
   # Bundled (no longer default) as of Ruby 3.5; graphiti uses OpenStruct in lib/
   spec.add_dependency "ostruct", ">= 0.5"
 
@@ -50,6 +32,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", ">= 10.0"
   spec.add_development_dependency "standard", "~> 1.4.0"
-  spec.add_development_dependency "activemodel", ">= 5.2"
-  spec.add_development_dependency "graphiti_spec_helpers", "1.0.beta.4"
+  spec.add_development_dependency "activemodel", ">= 7.1"
+  # Was reaching the suite transitively through graphiti_spec_helpers, which is
+  # now part of this gem.
+  spec.add_development_dependency "rspec", "~> 3.0"
 end

data/{deprecated_generators → lib/generators}/graphiti/api_test_generator.rb

@@ -4,7 +4,7 @@ module Graphiti
   class ApiTestGenerator < ::Rails::Generators::Base
     include GeneratorMixin
 
-    source_root File.expand_path("templates", __dir__)
+    source_root File.expand_path("../templates", __FILE__)
 
     argument :resource, type: :string
     class_option :actions,
@@ -13,6 +13,12 @@ module Graphiti
       aliases: ["--actions", "-a"],
       desc: 'Array of controller actions, e.g. "index show destroy"'
 
+    class_option :rawid,
+      type: :boolean,
+      default: false,
+      aliases: ["--rawid", "-r"],
+      desc: "Generate tests using rawid"
+
     desc "Generates rspec request specs at spec/api"
     def generate
       generate_api_specs

data/{deprecated_generators → lib/generators}/graphiti/generator_mixin.rb

@@ -12,7 +12,6 @@ module Graphiti
     def api_namespace
       @api_namespace ||= begin
         ns = graphiti_config["namespace"]
-        ns.delete_suffix("/")
 
         if ns.blank?
           ns = prompt \
@@ -42,5 +41,19 @@ module Graphiti
       config = graphiti_config.merge(attrs)
       File.open(".graphiticfg.yml", "w") { |f| f.write(config.to_yaml) }
     end
+
+    def id_or_rawid
+      @options["rawid"] ? "rawid" : "id"
+    end
+
+    def sort_raw_ids
+      return unless @options["rawid"]
+      ".sort"
+    end
+
+    def sort_raw_ids_descending
+      return unless @options["rawid"]
+      ".sort.reverse"
+    end
   end
 end

data/{deprecated_generators → lib/generators}/graphiti/install_generator.rb

@@ -4,7 +4,7 @@ module Graphiti
   class InstallGenerator < ::Rails::Generators::Base
     include GeneratorMixin
 
-    source_root File.expand_path("../templates", __FILE__)
+    source_root File.expand_path("templates", __dir__)
 
     class_option :'omit-comments',
       type: :boolean,
@@ -41,8 +41,20 @@ module Graphiti
         RUBY
       end
 
-      inject_into_file "spec/rails_helper.rb", after: /RSpec.configure.+^end$/m do
-        "\n\nGraphitiSpecHelpers::RSpec.schema!"
+      if defined?(RSpec)
+        inject_into_file "spec/rails_helper.rb", after: /RSpec.configure.+^end$/m do
+          <<~RUBY
+
+            require "graphiti/spec_helpers/rspec"
+
+            RSpec.configure do |config|
+              config.include Graphiti::SpecHelpers::RSpec
+              config.include Graphiti::SpecHelpers::Sugar
+            end
+
+            Graphiti::SpecHelpers::RSpec.schema!
+          RUBY
+        end
       end
 
       insert_into_file "config/routes.rb", after: "Rails.application.routes.draw do\n" do
@@ -70,16 +82,10 @@ module Graphiti
     end
 
     def app_controller_code
-      str = ""
-      str << "  include Graphiti::Rails\n"
-      str << "  include Graphiti::Responders\n"
-      str << "\n"
-      str << "  register_exception Graphiti::Errors::RecordNotFound,\n"
-      str << "    status: 404\n"
-      str << "\n"
-      str << "  rescue_from Exception do |e|\n"
-      str << "    handle_exception(e)\n"
-      str << "  end\n"
+      str = +"  include Graphiti::Rails::Controller\n"
+      if defined?(::Responders)
+        str << "  include Graphiti::Rails::Responders\n"
+      end
       str
     end
   end

data/{deprecated_generators → lib/generators}/graphiti/resource_generator.rb

@@ -14,6 +14,12 @@ module Graphiti
       aliases: ["--omit-comments", "-c"],
       desc: "Generate without documentation comments"
 
+    class_option :rawid,
+      type: :boolean,
+      default: false,
+      aliases: ["--rawid", "-r"],
+      desc: "Generate tests using rawid"
+
     class_option :actions,
       type: :array,
       default: nil,
@@ -26,6 +32,12 @@ module Graphiti
       aliases: ["--model", "-m"],
       desc: "Specify to use attributes from a particular model"
 
+    # No short alias: -c is already --omit-comments.
+    class_option :controller,
+      banner: "Name",
+      type: :string,
+      desc: "Generate the controller under this name instead of the resource's, e.g. Api::V1::Posts"
+
     desc "This generator creates a resource file at app/resources, as well as corresponding controller/specs/route/etc"
     def generate_all
       generate_model
@@ -94,7 +106,10 @@ module Graphiti
       end
       if attributes_class.table_exists?
         attributes_class.columns.map do |c|
-          OpenStruct.new({name: c.name.to_sym, type: c.type})
+          OpenStruct.new({
+            name: c.name.to_sym,
+            type: convert_column_type_to_graphiti_resource_type(c.type)
+          })
         end
       else
         raise "#{attributes_class} table must exist. Please run migrations."
@@ -113,11 +128,26 @@ module Graphiti
     end
 
     def responders?
-      defined?(Responders)
+      defined?(::Responders)
+    end
+
+    # Api::V1::Posts, Api::V1::PostsController and api/v1/posts all name the
+    # same controller. Normalizing here means the class name, the file path and
+    # the route all come from one place.
+    def controller_class_name
+      @controller_class_name ||= begin
+        given = options[:controller]
+        base = given ? given.sub(/Controller\z/, "").camelize : model_klass.name
+        "#{base.pluralize}Controller"
+      end
+    end
+
+    def controller_path
+      controller_class_name.sub(/Controller\z/, "").underscore
     end
 
     def generate_controller
-      to = File.join("app/controllers", class_path, "#{file_name.pluralize}_controller.rb")
+      to = File.join("app/controllers", "#{controller_path}_controller.rb")
       template("controller.rb.erb", to)
     end
 
@@ -132,10 +162,10 @@ module Graphiti
     end
 
     def generate_route
-      # Rails 5.2 adds `plural_route_name`, fallback to `plural_table_name`
-      plural_name = try(:plural_route_name) || plural_table_name
-
-      code = "resources :#{plural_name}"
+      code = "resources :#{file_name.pluralize}"
+      # Rails would otherwise infer the controller from the route name, which
+      # is only right when the controller was named after the resource.
+      code << %(, controller: "#{controller_path}") if options[:controller]
       code << %(, only: [#{actions.map { |a| ":#{a}" }.join(", ")}]) if actions.length < 5
       code << "\n"
       inject_into_file "config/routes.rb", after: /ApplicationResource.*$\n/ do
@@ -146,12 +176,14 @@ module Graphiti
     def generate_resource_specs
       opts = {}
       opts[:actions] = @options[:actions] if @options[:actions]
+      opts[:rawid] = @options[:rawid] if @options[:rawid]
       invoke "graphiti:resource_test", [resource_klass], opts
     end
 
     def generate_api_specs
       opts = {}
       opts[:actions] = @options[:actions] if @options[:actions]
+      opts[:rawid] = @options[:rawid] if @options[:rawid]
       invoke "graphiti:api_test", [resource_klass], opts
     end
 
@@ -176,5 +208,34 @@ module Graphiti
     def type
       model_klass.name.underscore.pluralize
     end
+
+    def convert_column_type_to_graphiti_resource_type(type)
+      # TODO: Support database specific types.
+      case type
+      when :string, :text
+        :string
+      when :float, :decimal
+        :integer
+      when :integer, :bigint
+        :integer
+      when :datetime, :time
+        :datetime
+      when :date
+        :date
+      when :boolean
+        :boolean
+      when :numeric
+        # TODO: Return type.
+        type
+      when :primary_key
+        # TODO: Return type.
+        type
+      when :binary
+        # TODO: Return type.
+        type
+      else
+        type
+      end
+    end
   end
 end

data/{deprecated_generators → lib/generators}/graphiti/templates/controller.rb.erb

@@ -1,5 +1,5 @@
 <% module_namespacing do -%>
-class <%= model_klass.name.pluralize %>Controller < ApplicationController
+class <%= controller_class_name %> < ApplicationController
   <%- if actions?('index') -%>
   def index
     <%= file_name.pluralize %> = <%= resource_klass %>.all(params)

data/{deprecated_generators → lib/generators}/graphiti/templates/index_request_spec.rb.erb

@@ -16,7 +16,7 @@ RSpec.describe "<%= type %>#index", type: :request do
       make_request
       expect(response.status).to eq(200), response.body
       expect(d.map(&:jsonapi_type).uniq).to match_array(['<%= type %>'])
-      expect(d.map(&:id)).to match_array([<%= var %>1.id, <%= var %>2.id])
+      expect(d.map(&:<%= id_or_rawid %>)).to match_array([<%= var %>1.id, <%= var %>2.id])
     end
   end
 end