RubyGems - graphiti - Versions diffs - 2.0.0.beta.2 → 2.0.0.beta.4 - Mend

graphiti 2.0.0.beta.2 → 2.0.0.beta.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (269) hide show

checksums.yaml +4 -4
data/.github/workflows/ci.yml +30 -86
data/.github/workflows/docs.yml +60 -0
data/.github/workflows/release.yml +8 -8
data/.gitignore +7 -0
data/.npmrc +9 -0
data/.standard.yml +4 -1
data/Appraisals +33 -32
data/CHANGELOG.md +41 -0
data/README.md +13 -2
data/UPGRADING.md +2 -68
data/docs/concepts/backends-and-models.md +122 -0
data/docs/concepts/endpoints.md +183 -0
data/docs/concepts/links.md +212 -0
data/docs/concepts/overview.md +80 -0
data/docs/concepts/persisting.md +376 -0
data/docs/concepts/relationships.md +527 -0
data/docs/concepts/resources.md +677 -0
data/docs/getting-started/first-api.md +289 -0
data/docs/getting-started/installation.md +185 -0
data/docs/intro.md +307 -0
data/docs/js/authentication.md +63 -0
data/docs/js/ddau.md +20 -0
data/docs/js/extra-params.md +41 -0
data/docs/js/index.md +112 -0
data/docs/js/installation.md +120 -0
data/docs/js/middleware.md +72 -0
data/docs/js/models.md +202 -0
data/docs/js/reads.md +494 -0
data/docs/js/state-syncing.md +100 -0
data/docs/js/writes.md +373 -0
data/docs/reference/vandal.md +63 -0
data/docs/reference/why.md +13 -0
data/docs/topics/authorization.md +155 -0
data/docs/topics/caching.md +55 -0
data/docs/topics/customizing-sideloads.md +156 -0
data/docs/topics/debugging.md +216 -0
data/docs/topics/error-handling.md +210 -0
data/docs/topics/etags.md +46 -0
data/docs/topics/hopping-relationships.md +149 -0
data/docs/topics/json-attributes.md +77 -0
data/docs/topics/openstruct-models.md +50 -0
data/docs/topics/remote-resources.md +291 -0
data/docs/topics/testing.md +894 -0
data/docs/topics/without-activerecord.md +324 -0
data/docs/tutorial/index.md +58 -0
data/docs/tutorial/step_0.md +107 -0
data/docs/tutorial/step_1.md +199 -0
data/docs/tutorial/step_2.md +312 -0
data/docs/tutorial/step_3.md +142 -0
data/docs/tutorial/step_4.md +135 -0
data/docs/tutorial/step_5.md +69 -0
data/docs/tutorial/step_6.md +82 -0
data/docs/tutorial/step_7.md +205 -0
data/docs/tutorial/step_8.md +128 -0
data/docs/tutorial/step_9.md +171 -0
data/docs/upgrading.md +265 -0
data/gemfiles/rails_7_1.gemfile +4 -3
data/gemfiles/{rails_7_2_graphiti_rails.gemfile → rails_7_2.gemfile} +3 -3
data/gemfiles/{rails_8_1_graphiti_rails.gemfile → rails_8_0.gemfile} +3 -3
data/gemfiles/{rails_8_0_graphiti_rails.gemfile → rails_8_1.gemfile} +3 -3
data/graphiti.gemspec +7 -5
data/{deprecated_generators → lib/generators}/graphiti/api_test_generator.rb +7 -1
data/{deprecated_generators → lib/generators}/graphiti/generator_mixin.rb +14 -1
data/{deprecated_generators → lib/generators}/graphiti/install_generator.rb +19 -13
data/{deprecated_generators → lib/generators}/graphiti/resource_generator.rb +43 -6
data/{deprecated_generators → lib/generators}/graphiti/templates/index_request_spec.rb.erb +1 -1
data/{deprecated_generators → lib/generators}/graphiti/templates/resource_reads_spec.rb.erb +6 -6
data/{deprecated_generators → lib/generators}/graphiti/templates/show_request_spec.rb.erb +1 -1
data/lib/graphiti/configuration.rb +2 -2
data/lib/graphiti/error_serializers/conflict_request.rb +19 -0
data/lib/graphiti/error_serializers/deprecated_constants.rb +48 -0
data/lib/graphiti/error_serializers/invalid_request.rb +56 -0
data/lib/graphiti/error_serializers/validation.rb +143 -0
data/lib/graphiti/errors.rb +4 -23
data/lib/graphiti/query.rb +1 -1
data/lib/graphiti/rails/context.rb +33 -0
data/lib/graphiti/rails/controller.rb +41 -0
data/lib/graphiti/rails/debugging.rb +18 -0
data/lib/graphiti/rails/exception_handlers.rb +77 -0
data/lib/graphiti/rails/railtie.rb +139 -0
data/lib/graphiti/rails/responders.rb +21 -0
data/lib/graphiti/rails/test_helpers.rb +22 -0
data/lib/graphiti/rails.rb +47 -29
data/lib/graphiti/resource/configuration.rb +1 -0
data/lib/graphiti/resource/interface.rb +2 -2
data/lib/graphiti/resource/persistence.rb +14 -2
data/lib/graphiti/resource/remote.rb +2 -2
data/lib/graphiti/resource/sideloading.rb +1 -1
data/lib/graphiti/resource.rb +13 -1
data/lib/graphiti/responders.rb +7 -20
data/lib/graphiti/schema.rb +5 -1
data/lib/graphiti/schema_diff.rb +4 -0
data/lib/graphiti/scope.rb +45 -37
data/lib/graphiti/serializer.rb +6 -0
data/lib/graphiti/sideload/belongs_to.rb +38 -5
data/lib/graphiti/sideload/polymorphic_belongs_to.rb +27 -23
data/lib/graphiti/sideload.rb +54 -35
data/lib/graphiti/spec_helpers/errors.rb +73 -0
data/lib/graphiti/spec_helpers/errors_proxy.rb +75 -0
data/lib/graphiti/spec_helpers/helpers.rb +107 -0
data/lib/graphiti/spec_helpers/node.rb +88 -0
data/lib/graphiti/spec_helpers/rspec.rb +147 -0
data/lib/graphiti/spec_helpers.rb +53 -0
data/lib/graphiti/util/include_params.rb +2 -2
data/lib/graphiti/util/persistence.rb +10 -11
data/lib/graphiti/util/serializer_relationships.rb +41 -5
data/lib/graphiti/version.rb +1 -1
data/lib/graphiti-rails.rb +11 -0
data/lib/graphiti.rb +34 -10
data/lib/graphiti_errors.rb +11 -0
data/lib/graphiti_spec_helpers/rspec.rb +3 -0
data/lib/graphiti_spec_helpers.rb +11 -0
data/lib/{graphiti/deprecated_tasks.rb → tasks/graphiti.rake} +6 -1
data/package-lock.json +6199 -0
data/package.json +5 -4
data/website/.gitignore +20 -0
data/website/README.md +43 -0
data/website/docusaurus.config.js +141 -0
data/website/package-lock.json +19474 -0
data/website/package.json +46 -0
data/website/sidebars.js +82 -0
data/website/src/css/custom.css +58 -0
data/website/src/pages/markdown-page.mdx +7 -0
data/website/static/.nojekyll +0 -0
data/website/static/1.13/2019/03/31/graphiti-1-0.html +205 -0
data/website/static/1.13/2019/05/08/graphiti-1-1.html +212 -0
data/website/static/1.13/2019/05/20/graphiti-1-2.html +214 -0
data/website/static/1.13/2019/10/14/tutorial.html +198 -0
data/website/static/1.13/CNAME +1 -0
data/website/static/1.13/README.md +16 -0
data/website/static/1.13/assets/css/syntax.css +60 -0
data/website/static/1.13/assets/favicons/android-chrome-192x192.png +0 -0
data/website/static/1.13/assets/favicons/android-chrome-256x256.png +0 -0
data/website/static/1.13/assets/favicons/apple-touch-icon.png +0 -0
data/website/static/1.13/assets/favicons/browserconfig.xml +9 -0
data/website/static/1.13/assets/favicons/favicon-16x16.png +0 -0
data/website/static/1.13/assets/favicons/favicon-32x32.png +0 -0
data/website/static/1.13/assets/favicons/favicon.ico +0 -0
data/website/static/1.13/assets/favicons/mstile-150x150.png +0 -0
data/website/static/1.13/assets/favicons/safari-pinned-tab.svg +1 -0
data/website/static/1.13/assets/favicons/site.webmanifest +19 -0
data/website/static/1.13/assets/img/backend.gif +0 -0
data/website/static/1.13/assets/img/conformity.png +0 -0
data/website/static/1.13/assets/img/error_payload.png +0 -0
data/website/static/1.13/assets/img/gh.png +0 -0
data/website/static/1.13/assets/img/lifecycle.gif +0 -0
data/website/static/1.13/assets/img/logo-500.png +0 -0
data/website/static/1.13/assets/img/logo.png +0 -0
data/website/static/1.13/assets/img/love-graffiti.jpg +0 -0
data/website/static/1.13/assets/img/meta_total_count.png +0 -0
data/website/static/1.13/assets/img/persist.jpg +0 -0
data/website/static/1.13/assets/img/resource.gif +0 -0
data/website/static/1.13/assets/img/rest-graffiti.jpg +0 -0
data/website/static/1.13/assets/img/rest1.gif +0 -0
data/website/static/1.13/assets/img/rest2.gif +0 -0
data/website/static/1.13/assets/img/rest3.gif +0 -0
data/website/static/1.13/assets/img/rethink-rest-graffiti.jpg +0 -0
data/website/static/1.13/assets/img/why.png +0 -0
data/website/static/1.13/assets/js/highlight.pack.js +2 -0
data/website/static/1.13/assets/main.css +15518 -0
data/website/static/1.13/assets/main.css.map +1 -0
data/website/static/1.13/bin/bundle +109 -0
data/website/static/1.13/bin/jekyll +27 -0
data/website/static/1.13/bin/kramdown +27 -0
data/website/static/1.13/bin/listen +27 -0
data/website/static/1.13/bin/rake +27 -0
data/website/static/1.13/bin/rougify +27 -0
data/website/static/1.13/bin/safe_yaml +27 -0
data/website/static/1.13/bin/sass +27 -0
data/website/static/1.13/bin/sass-convert +27 -0
data/website/static/1.13/bin/scss +27 -0
data/website/static/1.13/blog.html +259 -0
data/website/static/1.13/cheatsheet.html +316 -0
data/website/static/1.13/cookbooks/authorization.md +0 -0
data/website/static/1.13/cookbooks/caching.md +0 -0
data/website/static/1.13/cookbooks/customizing-sideloads.html +325 -0
data/website/static/1.13/cookbooks/etags.md +0 -0
data/website/static/1.13/cookbooks/hopping-relationships.html +324 -0
data/website/static/1.13/cookbooks/json_attributes.md +0 -0
data/website/static/1.13/cookbooks/openstruct-models.md +0 -0
data/website/static/1.13/cookbooks/remote-resources.md +0 -0
data/website/static/1.13/cookbooks/without-activerecord.html +510 -0
data/website/static/1.13/features.html +249 -0
data/website/static/1.13/feed.xml +106 -0
data/website/static/1.13/guides/concepts/backends-and-models.html +467 -0
data/website/static/1.13/guides/concepts/debugging.html +440 -0
data/website/static/1.13/guides/concepts/endpoints.html +432 -0
data/website/static/1.13/guides/concepts/error-handling.html +396 -0
data/website/static/1.13/guides/concepts/links.html +501 -0
data/website/static/1.13/guides/concepts/remote-resources.html +536 -0
data/website/static/1.13/guides/concepts/resources.html +2176 -0
data/website/static/1.13/guides/concepts/testing.html +1469 -0
data/website/static/1.13/guides/getting-started/installation.html +420 -0
data/website/static/1.13/guides/graphiti-rails-migration.html +242 -0
data/website/static/1.13/guides/index.html +269 -0
data/website/static/1.13/guides/overview.html +325 -0
data/website/static/1.13/guides/upgrading-2-0.html +193 -0
data/website/static/1.13/guides/upgrading.html +314 -0
data/website/static/1.13/guides/vandal.html +282 -0
data/website/static/1.13/guides/why.html +1121 -0
data/website/static/1.13/index.html +72 -0
data/website/static/1.13/js/authentication.html +295 -0
data/website/static/1.13/js/ddau.html +238 -0
data/website/static/1.13/js/extra-params.html +270 -0
data/website/static/1.13/js/index.html +321 -0
data/website/static/1.13/js/installation.html +637 -0
data/website/static/1.13/js/introduction.html +257 -0
data/website/static/1.13/js/middleware.html +318 -0
data/website/static/1.13/js/reads/fieldsets.html +271 -0
data/website/static/1.13/js/reads/filtering.html +289 -0
data/website/static/1.13/js/reads/includes.html +260 -0
data/website/static/1.13/js/reads/index.html +497 -0
data/website/static/1.13/js/reads/nested-queries.html +353 -0
data/website/static/1.13/js/reads/pagination.html +260 -0
data/website/static/1.13/js/reads/sorting.html +265 -0
data/website/static/1.13/js/reads/statistics.html +289 -0
data/website/static/1.13/js/state-syncing.html +340 -0
data/website/static/1.13/js/writes/deferred.html +296 -0
data/website/static/1.13/js/writes/dirty-tracking.html +399 -0
data/website/static/1.13/js/writes/index.html +391 -0
data/website/static/1.13/js/writes/nested.html +330 -0
data/website/static/1.13/js/writes/validations.html +272 -0
data/website/static/1.13/quickstart.html +660 -0
data/website/static/1.13/template +161 -0
data/website/static/1.13/tutorial/index.html +250 -0
data/website/static/1.13/tutorial/step_0.html +292 -0
data/website/static/1.13/tutorial/step_1.html +517 -0
data/website/static/1.13/tutorial/step_2.html +481 -0
data/website/static/1.13/tutorial/step_3.html +323 -0
data/website/static/1.13/tutorial/step_4.html +318 -0
data/website/static/1.13/tutorial/step_5.html +265 -0
data/website/static/1.13/tutorial/step_6.html +276 -0
data/website/static/1.13/tutorial/step_7.html +390 -0
data/website/static/1.13/tutorial/step_8.html +316 -0
data/website/static/1.13/tutorial/step_9.html +365 -0
data/website/static/assets/img/error_payload.png +0 -0
data/website/static/assets/img/legacy/legacy-0378a3bb39.png +0 -0
data/website/static/assets/img/legacy/legacy-05bbd3e5fd.png +0 -0
data/website/static/assets/img/legacy/legacy-07aa104495.png +0 -0
data/website/static/assets/img/legacy/legacy-0c75a16b3a.gif +0 -0
data/website/static/assets/img/legacy/legacy-3076df6209.png +0 -0
data/website/static/assets/img/legacy/legacy-7f6889bc89.png +0 -0
data/website/static/assets/img/legacy/legacy-a2cc4363c3.png +0 -0
data/website/static/assets/img/legacy/legacy-f67cfa89ab.png +0 -0
data/website/static/assets/img/meta_total_count.png +0 -0
data/website/static/img/docusaurus-social-card.jpg +0 -0
data/website/static/img/docusaurus.png +0 -0
data/website/static/img/favicon.ico +0 -0
data/website/static/img/logo.png +0 -0
data/website/static/img/logo.svg +1 -0
data/website/static/img/undraw_docusaurus_mountain.svg +171 -0
data/website/static/img/undraw_docusaurus_react.svg +170 -0
data/website/static/img/undraw_docusaurus_tree.svg +40 -0
metadata +245 -46
data/gemfiles/rails_6.gemfile +0 -18
data/gemfiles/rails_6_graphiti_rails.gemfile +0 -19
data/gemfiles/rails_7.gemfile +0 -18
data/gemfiles/rails_7_1_graphiti_rails.gemfile +0 -19
data/gemfiles/rails_7_graphiti_rails.gemfile +0 -19
data/lib/graphiti/railtie.rb +0 -121
/data/{deprecated_generators → lib/generators}/graphiti/resource_test_generator.rb +0 -0
/data/{deprecated_generators → lib/generators}/graphiti/templates/application_resource.rb.erb +0 -0
/data/{deprecated_generators → lib/generators}/graphiti/templates/controller.rb.erb +0 -0
/data/{deprecated_generators → lib/generators}/graphiti/templates/create_request_spec.rb.erb +0 -0
/data/{deprecated_generators → lib/generators}/graphiti/templates/destroy_request_spec.rb.erb +0 -0
/data/{deprecated_generators → lib/generators}/graphiti/templates/resource.rb.erb +0 -0
/data/{deprecated_generators → lib/generators}/graphiti/templates/resource_writes_spec.rb.erb +0 -0
/data/{deprecated_generators → lib/generators}/graphiti/templates/update_request_spec.rb.erb +0 -0

data/website/static/1.13/guides/concepts/resources.html ADDED Viewed

@@ -0,0 +1,2176 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+  <meta charset="utf-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <link href="https://fonts.googleapis.com/css?family=Roboto+Mono" rel="stylesheet">
+  <link href="https://fonts.googleapis.com/css?family=Boogaloo" rel="stylesheet">
+  <link rel="apple-touch-icon" sizes="180x180" href="/1.13/assets/favicons/apple-touch-icon.png">
+  <link rel="icon" type="image/png" sizes="32x32" href="/1.13/assets/favicons/favicon-32x32.png">
+  <link rel="icon" type="image/png" sizes="16x16" href="/1.13/assets/favicons/favicon-16x16.png">
+  <link rel="manifest" href="/1.13/assets/favicons/site.webmanifest">
+  <link rel="mask-icon" href="/1.13/assets/favicons/safari-pinned-tab.svg" color="#F86DA7">
+  <link rel="shortcut icon" href="/1.13/assets/favicons/favicon.ico">
+  <meta name="msapplication-TileColor" content="#F86DA7">
+  <meta name="msapplication-config" content="/1.13/assets/favicons/browserconfig.xml">
+  <meta name="theme-color" content="#F86DA7">
+  <title>Graphiti</title>
+  <meta name="description" content="Stylish Graph APIs">
+  <link rel="stylesheet" href="/1.13/assets/main.css?ref=wh4t3v45">
+  <link rel="alternate" type="application/rss+xml" title="Graphiti" href="/1.13/feed.xml">
+  <!-- Global site tag (gtag.js) - Google Analytics -->
+  <script async src="https://www.googletagmanager.com/gtag/js?id=UA-127904727-1"></script>
+  <script>
+    window.dataLayer = window.dataLayer || [];
+    function gtag(){dataLayer.push(arguments);}
+    gtag('js', new Date());
+    gtag('config', 'UA-127904727-1');
+  </script>
+  <!-- javascript -->
+  <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
+  <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js" integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa" crossorigin="anonymous"></script>
+</head>
+  <body>
+    <main class="page-content" aria-label="Content">
+      <div class="wrapper">
+        <header class="navbar navbar-inverse normal" role="banner">
+  <div class="container">
+    <div class="navbar-header">
+      <a href="/1.13/1.13" class="navbar-brand">
+        <img alt="logo" src="/1.13/assets/img/logo.png">
+      </a>
+    </div>
+    <nav class="" role="navigation">
+      <ul class="nav navbar-nav nav-links">
+        <li>
+          <a class="quickstart nav-link" href="/1.13/quickstart">Quickstart</a>
+        </li>
+        <li>
+          <a class="guides nav-link" href="/1.13/guides">Guides</a>
+        </li>
+        <li>
+          <a class="tutorial nav-link" href="/1.13/tutorial">Tutorial</a>
+        </li>
+        <li>
+          <a class="spraypaint nav-link" href="/1.13/js">Spraypaint</a>
+        </li>
+      </ul>
+      <ul class="nav gh navbar-nav navbar-right visible-lg visible-md">
+        <li>
+          <span class="star">⭐</span>
+          <a href="https://github.com/graphiti-api/graphiti">
+            <img alt="github-star" style="margin-right: 65px;margin-top: -20px" src="/1.13/assets/img/gh.png">
+          </a>
+        </li>
+      </ul>
+    </nav>
+  </div>
+</header>
+        <div class="container">
+          <div class="toc col-md-3">
+  <h1 id="resources">Resources</h1>
+  <ul>
+    <li>1 <a href="#overview">Overview</a></li>
+    <li>2 <a href="#attributes">Attributes</a>
+      <ul>
+        <li><a href="#limiting-behavior">Limiting Behavior</a></li>
+        <li><a href="#default-behavior">Default Behavior</a></li>
+        <li><a href="#customizing-display">Customizing Display</a></li>
+        <li><a href="#types">Types</a></li>
+        <li><a href="#enum-types">Enum Types</a></li>
+        <li><a href="#custom-types">Custom Types</a></li>
+      </ul>
+    </li>
+    <li>3 <a href="#querying">Querying</a>
+      <ul>
+        <li><a href="#query-interface">Query Interface</a></li>
+        <li><a href="#composing-with-scopes">Composing with Scopes</a></li>
+        <li><a href="#base-scope"><code class="language-plaintext highlighter-rouge">#base_scope</code></a></li>
+        <li><a href="#sort">Sort</a>
+          <ul>
+            <li><a href="#sort-options">Sort Options</a></li>
+          </ul>
+        </li>
+        <li><a href="#filter">Filter</a>
+          <ul>
+            <li><a href="#filter-options">Filter Options</a></li>
+            <li><a href="#boolean-filter">Boolean Filter</a></li>
+            <li><a href="#hash-filter">Hash Filter</a></li>
+            <li><a href="#escaping-values">Escaping Values</a></li>
+          </ul>
+        </li>
+        <li><a href="#statistics">Statistics</a></li>
+        <li><a href="#extra-fields">Extra Fields</a></li>
+        <li><a href="#resolve"><code class="language-plaintext highlighter-rouge">#resolve</code></a></li>
+      </ul>
+    </li>
+    <li>4 <a href="#configuration">Configuration</a>
+      <ul>
+        <li><a href="#polymorphic-resources">Polymorphic Resources</a></li>
+      </ul>
+    </li>
+    <li>5 <a href="#relationships">Relationships</a>
+      <ul>
+        <li><a href="#deep-queries">Deep Queries</a></li>
+        <li><a href="#customizing-relationships">Customizing Relationships</a>
+          <ul>
+            <li><a href="#conditional-relationships">Conditional Relationships</a></li>
+            <li><a href="#customizing-scope">Customizing Scope</a></li>
+            <li><a href="#customizing-assignment">Customizing Assignment</a></li>
+          </ul>
+        </li>
+        <li><a href="#has-many">has_many</a></li>
+        <li><a href="#belongs-to">belongs_to</a></li>
+        <li><a href="#has-one">has_one</a>
+          <ul>
+            <li><a href="#faux-has-one">Faux has_one</a></li>
+          </ul>
+        </li>
+        <li><a href="#many-to-many">many_to_many</a></li>
+        <li><a href="#polymorphic-belongs-to">polymorphic_belongs_to</a></li>
+        <li><a href="#polymorphic-has-many">polymorphic_has_many</a></li>
+      </ul>
+    </li>
+    <li>6 <a href="#generators">Generators</a></li>
+    <li>7 <a href="#persisting">Persisting</a>
+      <ul>
+        <li><a href="#persistence-lifecycle-hooks">Lifecycle Hooks</a></li>
+        <li><a href="#sideposting">Sideposting</a>
+          <ul>
+            <li><a href="#create">Create</a></li>
+            <li><a href="#expanded-example">Expanded Example</a></li>
+          </ul>
+        </li>
+        <li><a href="#validation-errors">Validation Errors</a></li>
+      </ul>
+    </li>
+    <li>8 <a href="#context">Context</a></li>
+    <li>9 <a href="#concurrency">Concurrency</a></li>
+    <li>10 <a href="#adapters">Adapters</a></li>
+  </ul>
+</div>
+<div class="col-md-8">
+<a class="anchor" id="overview" />
+  <a class="header" href="#overview">
+    <h2>
+      1 Overview
+    </h2>
+  </a>
+  <p align="center">
+  <img width="100%" src="/1.13/assets/img/rest3.gif" />
+</p>
+  <p>The same way a <code class="language-plaintext highlighter-rouge">Model</code> is an abstraction around a database table, a
+<code class="language-plaintext highlighter-rouge">Resource</code> is an abstraction around an API endpoint. It holds logic for
+<strong><em>querying</em></strong>, <strong><em>persisting</em></strong>, and <strong><em>serializing</em></strong> data.</p>
+  <blockquote>
+    <p>For a condensed view of the Resource interface, see the
+<a href="/1.13/cheatsheet">cheatsheet</a>.</p>
+  </blockquote>
+<a class="anchor" id="attributes" />
+  <a class="header" href="#attributes">
+    <h2>
+      2 Attributes
+    </h2>
+  </a>
+  <p>A <strong>Resource</strong> is composed of <strong>Attribute</strong>s. Each Attribute has a
+<strong>name</strong> (e.g. <code class="language-plaintext highlighter-rouge">first_name</code>) that corresponds to a JSON key, and a
+<strong>Type</strong> (e.g. <code class="language-plaintext highlighter-rouge">string</code>) that corresponds to a JSON value.</p>
+  <p>To define an attribute:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">attribute</span> <span class="ss">:first_name</span><span class="p">,</span> <span class="ss">:string</span></code></pre></figure>
+<a class="anchor" id="limiting-behavior" />
+  <a class="header" href="#limiting-behavior">
+    <h4>
+      2.1 Limiting Behavior
+    </h4>
+  </a>
+  <p>Each attribute consists of five flags: <code class="language-plaintext highlighter-rouge">readable</code>, <code class="language-plaintext highlighter-rouge">writable</code>,
+<code class="language-plaintext highlighter-rouge">sortable</code>, <code class="language-plaintext highlighter-rouge">filterable</code>, and <code class="language-plaintext highlighter-rouge">schema</code>. Any of these flags can be turned off:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">attribute</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">:string</span><span class="p">,</span> <span class="ss">sortable: </span><span class="kp">false</span></code></pre></figure>
+  <p>Or use <code class="language-plaintext highlighter-rouge">only/except</code> shorthand:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">attribute</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">:string</span><span class="p">,</span> <span class="ss">only: </span><span class="p">[</span><span class="ss">:sortable</span><span class="p">]</span>
+<span class="n">attribute</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">:string</span><span class="p">,</span> <span class="ss">except: </span><span class="p">[</span><span class="ss">:writable</span><span class="p">]</span></code></pre></figure>
+  <p>The <code class="language-plaintext highlighter-rouge">schema</code> flag is not affected by <code class="language-plaintext highlighter-rouge">only/except</code> options.
+This option determines if the attribute is exported to the schema.json.</p>
+  <p>You might want to allow behavior only if a certain condition is met.
+Pass a symbol to guard this behavior via corresponding method, only allowing the
+behavior if the method returns <code class="language-plaintext highlighter-rouge">true</code>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">attribute</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">:string</span><span class="p">,</span> <span class="ss">writable: :admin?</span>
+<span class="k">def</span> <span class="nf">admin?</span>
+  <span class="c1"># ... logic ...</span>
+<span class="k">end</span></code></pre></figure>
+  <p>When guarding the <code class="language-plaintext highlighter-rouge">:readable</code> flag, the method can optionally accept the
+model instance and the name of the attribute being serialized as arguments:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">attribute</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">:string</span><span class="p">,</span> <span class="ss">readable: :allowed?</span>
+<span class="n">attribute</span> <span class="ss">:age</span><span class="p">,</span> <span class="ss">:integer</span><span class="p">,</span> <span class="ss">readable: :attribute_allowed?</span>
+<span class="k">def</span> <span class="nf">allowed?</span><span class="p">(</span><span class="n">model_instance</span><span class="p">)</span>
+  <span class="n">model_instance</span><span class="p">.</span><span class="nf">internal</span> <span class="o">==</span> <span class="kp">false</span>
+<span class="k">end</span>
+<span class="k">def</span> <span class="nf">attribute_allowed?</span><span class="p">(</span><span class="n">model_instance</span><span class="p">,</span> <span class="n">attribute_name</span><span class="p">)</span>
+  <span class="no">PolicyChecker</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="n">model_instance</span><span class="p">).</span><span class="nf">attribute_readable?</span><span class="p">(</span><span class="n">attribute_name</span><span class="p">)</span>
+<span class="k">end</span></code></pre></figure>
+  <p><code class="language-plaintext highlighter-rouge">:writable</code> guards mirror this: the guard method (or proc) can optionally accept the model being written and the name of the attribute. On an update, the model is the persisted record being modified; on a create, it is a new unsaved instance. The model is only looked up when a guard actually declares a parameter for it, so zero-argument guards behave exactly as before.</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">attribute</span> <span class="ss">:salary</span><span class="p">,</span> <span class="ss">:integer</span><span class="p">,</span> <span class="ss">writable: :salary_writable?</span>
+<span class="k">def</span> <span class="nf">salary_writable?</span><span class="p">(</span><span class="n">model_instance</span><span class="p">,</span> <span class="n">attribute_name</span><span class="p">)</span>
+  <span class="no">PolicyChecker</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="n">model_instance</span><span class="p">).</span><span class="nf">attribute_writable?</span><span class="p">(</span><span class="n">attribute_name</span><span class="p">)</span>
+<span class="k">end</span></code></pre></figure>
+  <p>If the guard returns <code class="language-plaintext highlighter-rouge">false</code>, the request is rejected with an <code class="language-plaintext highlighter-rouge">unwritable_attribute</code> validation error before anything is persisted.</p>
+<a class="anchor" id="default-behavior" />
+  <a class="header" href="#default-behavior">
+    <h4>
+      2.2 Default Behavior
+    </h4>
+  </a>
+  <p>By default, attributes are enabled for all behavior. You may want to
+disable certain behavior globally, for example a read-only API. Use
+these properties to affect all subclasses:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="nb">self</span><span class="p">.</span><span class="nf">attributes_readable_by_default</span> <span class="o">=</span> <span class="kp">false</span> <span class="c1"># default true</span>
+<span class="nb">self</span><span class="p">.</span><span class="nf">attributes_writable_by_default</span> <span class="o">=</span> <span class="kp">false</span> <span class="c1"># default true</span>
+<span class="nb">self</span><span class="p">.</span><span class="nf">attributes_filterable_by_default</span> <span class="o">=</span> <span class="kp">false</span> <span class="c1"># default true</span>
+<span class="nb">self</span><span class="p">.</span><span class="nf">attributes_sortable_by_default</span> <span class="o">=</span> <span class="kp">false</span> <span class="c1"># default true</span>
+<span class="nb">self</span><span class="p">.</span><span class="nf">attributes_schema_by_default</span> <span class="o">=</span> <span class="kp">false</span> <span class="c1"># default true</span></code></pre></figure>
+  <p>As for resource defined guards, you can pass a symbol to guard the
+behavior globally. This can be used to globally delegate access control to a
+dedicated system.</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="nb">self</span><span class="p">.</span><span class="nf">attributes_readable_by_default</span> <span class="o">=</span> <span class="ss">:attribute_readable?</span> <span class="c1"># default true</span>
+<span class="k">def</span> <span class="nf">attribute_readable?</span><span class="p">(</span><span class="n">model_instance</span><span class="p">,</span> <span class="n">attribute_name</span><span class="p">)</span>
+  <span class="no">PolicyChecker</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="n">model_instance</span><span class="p">).</span><span class="nf">attribute_readable?</span><span class="p">(</span><span class="n">attribute_name</span><span class="p">)</span>
+<span class="k">end</span></code></pre></figure>
+<a class="anchor" id="customizing-display" />
+  <a class="header" href="#customizing-display">
+    <h4>
+      2.3 Customizing Display
+    </h4>
+  </a>
+  <p>Pass a block to <code class="language-plaintext highlighter-rouge">attribute</code> to customize display:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">attribute</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">:string</span> <span class="k">do</span>
+  <span class="vi">@object</span><span class="p">.</span><span class="nf">name</span><span class="p">.</span><span class="nf">upcase</span>
+<span class="k">end</span></code></pre></figure>
+  <p><code class="language-plaintext highlighter-rouge">@object</code> will be an instance of your model.</p>
+<a class="anchor" id="types" />
+  <a class="header" href="#types">
+    <h4>
+      2.4 Types
+    </h4>
+  </a>
+  <p>Each <strong>Attribute</strong> has a <strong>Type</strong>. Each <strong>Type</strong> defines behavior for</p>
+  <ul>
+    <li>Reading</li>
+    <li>Writing</li>
+    <li>Filtering</li>
+  </ul>
+  <p>For each of these, we’ll first attempt to <em>coerce</em> the given value to
+the correct type. If that fails, we will raise an error.</p>
+  <p>The implementation for each of these actions lives in a <a href="https://dry-rb.org/gems/dry-types">Dry Type</a>. Take the <code class="language-plaintext highlighter-rouge">:integer_id</code> type: here we want to <em>render</em> a string, but <em>query</em> with an integer (this is the default for all Resource <code class="language-plaintext highlighter-rouge">id</code> attributes):</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="no">Graphiti</span><span class="o">::</span><span class="no">Types</span><span class="p">[</span><span class="ss">:integer_id</span><span class="p">]</span>
+<span class="c1"># {</span>
+<span class="c1">#   params: Dry::Types['coercible.integer'],</span>
+<span class="c1">#   read: Dry::Types['coercible.string'],</span>
+<span class="c1">#   write: Dry::Types['coercible.integer'],</span>
+<span class="c1">#   ...</span>
+<span class="c1"># }</span></code></pre></figure>
+  <p>You can edit these implementations as you wish. Let’s make the <code class="language-plaintext highlighter-rouge">:string</code> type
+render an integer:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="no">Graphiti</span><span class="o">::</span><span class="no">Types</span><span class="p">[</span><span class="ss">:string</span><span class="p">][</span><span class="ss">:read</span><span class="p">]</span> <span class="o">=</span> <span class="no">Dry</span><span class="o">::</span><span class="no">Types</span><span class="p">[</span><span class="s1">'coercible.integer'</span><span class="p">]</span></code></pre></figure>
+  <p>The built-in Types are:</p>
+  <ul>
+    <li><code class="language-plaintext highlighter-rouge">integer_id</code></li>
+    <li><code class="language-plaintext highlighter-rouge">string</code></li>
+    <li><code class="language-plaintext highlighter-rouge">integer</code></li>
+    <li><code class="language-plaintext highlighter-rouge">big_decimal</code></li>
+    <li><code class="language-plaintext highlighter-rouge">float</code></li>
+    <li><code class="language-plaintext highlighter-rouge">date</code></li>
+    <li><code class="language-plaintext highlighter-rouge">datetime</code></li>
+    <li><code class="language-plaintext highlighter-rouge">uuid</code></li>
+    <li><code class="language-plaintext highlighter-rouge">string_enum</code></li>
+    <li><code class="language-plaintext highlighter-rouge">integer_enum</code></li>
+    <li><code class="language-plaintext highlighter-rouge">boolean</code></li>
+    <li><code class="language-plaintext highlighter-rouge">hash</code></li>
+    <li><code class="language-plaintext highlighter-rouge">array</code></li>
+  </ul>
+  <p>All but the last 3 have Array doppelgängers: <code class="language-plaintext highlighter-rouge">array_of_integers</code>,
+<code class="language-plaintext highlighter-rouge">array_of_dates</code>, etc.</p>
+  <p>The <code class="language-plaintext highlighter-rouge">integer_id</code> type says, “render as a string, but query as an
+integer” and is the default for the <code class="language-plaintext highlighter-rouge">id</code> attribute. The <code class="language-plaintext highlighter-rouge">uuid</code> type says
+“this is a string, but query me case-sensitive by default”.</p>
+<a class="anchor" id="enum-types" />
+  <a class="header" href="#enum-types">
+    <h5>
+      2.5 Enum Types
+    </h5>
+  </a>
+  <p>Graphiti provides two built enum types, <code class="language-plaintext highlighter-rouge">string_enum</code> and <code class="language-plaintext highlighter-rouge">integer_enum</code>.  These behave
+in exactly the same way as the <code class="language-plaintext highlighter-rouge">string</code> and <code class="language-plaintext highlighter-rouge">integer</code> types, respectively, except that
+when declaring them as either an attribute or a filter you are required to
+pass the <code class="language-plaintext highlighter-rouge">allow</code> option, which is the list of acceptable values for the field:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">attribute</span> <span class="ss">:status</span><span class="p">,</span> <span class="ss">:string_enum</span><span class="p">,</span> <span class="ss">allow: </span><span class="p">[</span><span class="s1">'draft'</span><span class="p">,</span> <span class="s1">'published'</span><span class="p">]</span></code></pre></figure>
+  <p>Or if your attribute is backed by an ActiveRecord, you could reference
+the values directly</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># app/models/post.rb</span>
+<span class="k">class</span> <span class="nc">Post</span> <span class="o">&lt;</span> <span class="no">ApplicationRecord</span>
+  <span class="n">enum</span> <span class="ss">status: </span><span class="p">{</span>
+    <span class="ss">draft: </span><span class="mi">0</span><span class="p">,</span>
+    <span class="ss">published: </span><span class="mi">1</span>
+  <span class="p">}</span>
+<span class="k">end</span>
+<span class="c1"># app/resources/post_resource.rb</span>
+<span class="k">class</span> <span class="nc">PostResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="n">attribute</span> <span class="ss">:status</span><span class="p">,</span> <span class="ss">:string_enum</span><span class="p">,</span> <span class="ss">allow: </span><span class="no">Post</span><span class="p">.</span><span class="nf">statuses</span><span class="p">.</span><span class="nf">keys</span>
+<span class="k">end</span></code></pre></figure>
+  <p>See the section on <a href="#filter-options">filter options</a> for more details on <code class="language-plaintext highlighter-rouge">allow</code> behavior</p>
+  <p><strong>Note</strong>: Graphiti does not currently do any value checking on enum fields when
+writing an attribute, and it still expects that your model layer will validate any
+data coming in.</p>
+<a class="anchor" id="custom-types" />
+  <a class="header" href="#custom-types">
+    <h5>
+      2.6 Custom Types
+    </h5>
+  </a>
+  <p><a href="https://dry-rb.org/gems/dry-types/main/custom-types/">Dry Types supports custom types</a>. Let’s register a “capital letters” type:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># Define the Type</span>
+<span class="n">definition</span> <span class="o">=</span> <span class="no">Dry</span><span class="o">::</span><span class="no">Types</span><span class="o">::</span><span class="no">Nominal</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="no">String</span><span class="p">)</span>
+<span class="n">type</span> <span class="o">=</span> <span class="n">definition</span><span class="p">.</span><span class="nf">constructor</span> <span class="k">do</span> <span class="o">|</span><span class="n">input</span><span class="o">|</span>
+  <span class="n">input</span><span class="p">.</span><span class="nf">upcase</span>
+<span class="k">end</span>
+<span class="c1"># Register it with Graphiti</span>
+<span class="no">Graphiti</span><span class="o">::</span><span class="no">Types</span><span class="p">[</span><span class="ss">:caps_lock</span><span class="p">]</span> <span class="o">=</span> <span class="p">{</span>
+  <span class="ss">params: </span><span class="n">type</span><span class="p">,</span>
+  <span class="ss">read: </span><span class="n">type</span><span class="p">,</span>
+  <span class="ss">write: </span><span class="n">type</span><span class="p">,</span>
+  <span class="ss">kind: </span><span class="s1">'scalar'</span><span class="p">,</span>
+  <span class="ss">canonical_name: :caps_lock</span><span class="p">,</span>
+  <span class="ss">description: </span><span class="s1">'All capital letters'</span>
+<span class="p">}</span>
+<span class="c1"># Use in a Resource</span>
+<span class="n">attribute</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">:caps_lock</span></code></pre></figure>
+<a class="anchor" id="querying" />
+  <a class="header" href="#querying">
+    <h2>
+      3 Querying
+    </h2>
+  </a>
+  <p>Resources must be able to dynamically compose a query that can be run
+against an arbitrary backend (SQL, NoSQL, service calls, etc). They do
+this through the concept of <strong>scoping</strong>.</p>
+  <p>The best way to understand scoping is to take a look at what happens “under the hood”. Here’s the simple Resource, where most of the logic is hiding in the Adapter:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">PostResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="n">attribute</span> <span class="ss">:title</span><span class="p">,</span> <span class="ss">:string</span>
+<span class="k">end</span></code></pre></figure>
+  <p>Now let’s show the long-hand version. This is completely runnable code (we’re just overriding the default behavior with an explicit version of the same):</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">PostResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="n">filter</span> <span class="ss">:title</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+    <span class="n">eq</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+      <span class="n">scope</span><span class="p">.</span><span class="nf">where</span><span class="p">(</span><span class="ss">title: </span><span class="n">value</span><span class="p">)</span>
+    <span class="k">end</span>
+  <span class="k">end</span>
+  <span class="n">sort</span> <span class="ss">:title</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">dir</span><span class="o">|</span>
+    <span class="n">scope</span><span class="p">.</span><span class="nf">order</span><span class="p">(</span><span class="ss">title: </span><span class="n">dir</span><span class="p">)</span>
+  <span class="k">end</span>
+  <span class="n">paginate</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">current_page</span><span class="p">,</span> <span class="n">per_page</span><span class="o">|</span>
+    <span class="n">scope</span><span class="p">.</span><span class="nf">page</span><span class="p">(</span><span class="n">current_page</span><span class="p">).</span><span class="nf">per</span><span class="p">(</span><span class="n">per_page</span><span class="p">)</span>
+  <span class="k">end</span>
+  <span class="k">def</span> <span class="nf">base_scope</span>
+    <span class="no">Post</span><span class="p">.</span><span class="nf">all</span>
+  <span class="k">end</span>
+  <span class="k">def</span> <span class="nf">resolve</span><span class="p">(</span><span class="n">scope</span><span class="p">)</span>
+    <span class="n">scope</span><span class="p">.</span><span class="nf">to_a</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+  <p>Let’s break this down the key elements:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">def</span> <span class="nf">base_scope</span>
+  <span class="no">Post</span><span class="p">.</span><span class="nf">all</span>
+<span class="k">end</span></code></pre></figure>
+  <p>Graphiti builds queries just like ActiveRecord: start with a base scope (<code class="language-plaintext highlighter-rouge">Post.all</code>), and alter that scope based on the incoming request. <code class="language-plaintext highlighter-rouge">#base_scope</code> defines our starting point.</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">filter</span> <span class="ss">:title</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+  <span class="n">eq</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+    <span class="n">scope</span><span class="p">.</span><span class="nf">where</span><span class="p">(</span><span class="ss">title: </span><span class="n">value</span><span class="p">)</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+  <p>When the <code class="language-plaintext highlighter-rouge">title</code> query parameter is present, we alter the scope.</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">def</span> <span class="nf">resolve</span><span class="p">(</span><span class="n">scope</span><span class="p">)</span>
+  <span class="n">scope</span><span class="p">.</span><span class="nf">to_a</span>
+<span class="k">end</span></code></pre></figure>
+  <p>The <code class="language-plaintext highlighter-rouge">#resolve</code> method is in charge of actually executing the query
+and returning model instances.</p>
+  <p>In other words, this code is roughly equivalent to:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">scope</span> <span class="o">=</span> <span class="no">Post</span><span class="p">.</span><span class="nf">all</span> <span class="c1"># #base_scope</span>
+<span class="k">if</span> <span class="n">value</span> <span class="o">=</span> <span class="n">params</span><span class="p">[</span><span class="ss">:filter</span><span class="p">].</span><span class="nf">try</span><span class="p">(</span><span class="ss">:[]</span><span class="p">,</span> <span class="ss">:title</span><span class="p">)</span>
+  <span class="n">scope</span> <span class="o">=</span> <span class="n">scope</span><span class="p">.</span><span class="nf">where</span><span class="p">(</span><span class="ss">title: </span><span class="n">value</span><span class="p">)</span> <span class="c1"># .filter</span>
+<span class="k">end</span>
+<span class="n">scope</span><span class="p">.</span><span class="nf">to_a</span> <span class="c1"># #resolve</span></code></pre></figure>
+<a class="anchor" id="query-interface" />
+  <a class="header" href="#query-interface">
+    <h3>
+      3.1 Query Interface
+    </h3>
+  </a>
+  <p>Resources can query and persist data without an API request or
+response. To query, pass a <a href="http://jsonapi.org">JSONAPI-compliant</a> query hash:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="no">EmployeeResource</span><span class="p">.</span><span class="nf">all</span><span class="p">({</span>
+  <span class="ss">filter: </span><span class="p">{</span> <span class="ss">first_name: </span><span class="s1">'Jane'</span> <span class="p">},</span>
+  <span class="ss">sort: </span><span class="s1">'-created_at'</span><span class="p">,</span>
+  <span class="ss">page: </span><span class="p">{</span> <span class="ss">size: </span><span class="mi">10</span><span class="p">,</span> <span class="ss">number: </span><span class="mi">2</span> <span class="p">}</span>
+<span class="p">})</span></code></pre></figure>
+  <p>The return value from <code class="language-plaintext highlighter-rouge">.all</code> is a <strong>proxy</strong> object, similar to
+<code class="language-plaintext highlighter-rouge">ActiveRecord::Relation</code>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># ActiveRecord:</span>
+<span class="n">employees</span> <span class="o">=</span> <span class="no">Employee</span><span class="p">.</span><span class="nf">all</span>
+<span class="n">employees</span><span class="p">.</span><span class="nf">class</span> <span class="c1"># ActiveRecord::Relation</span>
+<span class="c1"># No query fires until .map</span>
+<span class="n">employees</span><span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&amp;</span><span class="ss">:first_name</span><span class="p">)</span> <span class="c1"># =&gt; ["Jane", "Joe", ...]</span>
+<span class="c1"># Graphiti Resource:</span>
+<span class="n">employees</span> <span class="o">=</span> <span class="no">EmployeeResource</span><span class="p">.</span><span class="nf">all</span>
+<span class="n">employees</span><span class="p">.</span><span class="nf">class</span> <span class="c1"># Graphiti::ResourceProxy</span>
+<span class="c1"># No query fires until .map</span>
+<span class="n">employees</span><span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&amp;</span><span class="ss">:first_name</span><span class="p">)</span> <span class="c1"># =&gt; ["Jane", "Joe", ...]</span>
+<span class="c1"># Access model instances directly</span>
+<span class="n">employees</span><span class="p">.</span><span class="nf">data</span> <span class="c1"># =&gt; [#&lt;Employee&gt;, #&lt;Employee&gt;, ...]</span></code></pre></figure>
+  <p>This proxy object can render <a href="http://jsonapi.org">JSONAPI</a>, simple
+JSON, or XML:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">employees</span> <span class="o">=</span> <span class="no">EmployeeResource</span><span class="p">.</span><span class="nf">all</span>
+<span class="n">employees</span><span class="p">.</span><span class="nf">to_jsonapi</span>
+<span class="n">employees</span><span class="p">.</span><span class="nf">to_json</span>
+<span class="n">employees</span><span class="p">.</span><span class="nf">to_xml</span></code></pre></figure>
+  <p>Use <code class="language-plaintext highlighter-rouge">.find</code> to find a single record by id, raising
+<code class="language-plaintext highlighter-rouge">Graphiti::Errors::RecordNotFound</code> if no records are returned:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">employee</span> <span class="o">=</span> <span class="no">EmployeeResource</span><span class="p">.</span><span class="nf">find</span><span class="p">(</span><span class="ss">id: </span><span class="mi">123</span><span class="p">)</span>
+<span class="n">employee</span><span class="p">.</span><span class="nf">data</span><span class="p">.</span><span class="nf">first_name</span> <span class="c1"># =&gt; "Jane"</span></code></pre></figure>
+  <p><em>Note</em>: <code class="language-plaintext highlighter-rouge">SomeResource.find</code> returns a <code class="language-plaintext highlighter-rouge">ResourceProxy</code>. To access the model/record proper you will want to make sure you call <code class="language-plaintext highlighter-rouge">.data</code> on the result of find as shown above.</p>
+<a class="anchor" id="composing-with-scopes" />
+  <a class="header" href="#composing-with-scopes">
+    <h3>
+      3.2 Composing with Scopes
+    </h3>
+  </a>
+<a class="anchor" id="base-scope" />
+  <a class="header" href="#base-scope">
+    <h4>
+      3.2.1 #base_scope
+    </h4>
+  </a>
+  <p>Override the <code class="language-plaintext highlighter-rouge">#base_scope</code> method whenever you have logic that should
+apply to <em>every</em> query. For example, if we only ever wanted to return
+<code class="language-plaintext highlighter-rouge">active</code> Positions:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">def</span> <span class="nf">base_scope</span>
+  <span class="no">Position</span><span class="p">.</span><span class="nf">where</span><span class="p">(</span><span class="ss">active: </span><span class="kp">true</span><span class="p">)</span>
+<span class="k">end</span></code></pre></figure>
+  <p>This can be overridden by passing a second argument to <code class="language-plaintext highlighter-rouge">Resource.all</code>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">InactivePostsController</span> <span class="o">&lt;</span> <span class="no">PostsController</span>
+  <span class="k">def</span> <span class="nf">index</span>
+    <span class="n">posts</span> <span class="o">=</span> <span class="no">PostResource</span><span class="p">.</span><span class="nf">all</span><span class="p">(</span><span class="n">params</span><span class="p">,</span> <span class="no">Post</span><span class="p">.</span><span class="nf">where</span><span class="p">(</span><span class="ss">active: </span><span class="kp">false</span><span class="p">))</span>
+    <span class="n">respond_with</span><span class="p">(</span><span class="n">posts</span><span class="p">)</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+<a class="anchor" id="sort" />
+  <a class="header" href="#sort">
+    <h4>
+      3.4 Sort
+    </h4>
+  </a>
+  <p>Use the <code class="language-plaintext highlighter-rouge">sort</code> DSL to customize sorting behavior.</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">sort</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">:string</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">direction</span><span class="o">|</span>
+  <span class="n">scope</span><span class="p">.</span><span class="nf">order</span><span class="p">(</span><span class="ss">first_name: </span><span class="n">direction</span><span class="p">,</span> <span class="ss">last_name: </span><span class="n">direction</span><span class="p">)</span>
+<span class="k">end</span></code></pre></figure>
+  <p>If you’ve already defined a corresponding attribute, you’ll be
+overriding that default behavior (and there is no need to pass a type as
+the second argument):</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">attribute</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">:string</span>
+<span class="n">sort</span> <span class="ss">:name</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">direction</span><span class="o">|</span>
+  <span class="c1"># ... code ...</span>
+<span class="k">end</span></code></pre></figure>
+  <blockquote>
+    <p>Note: <code class="language-plaintext highlighter-rouge">sort</code> defines a sort-only attribute. If you want other
+behavior, like filtering, it’s best to define the attribute first.</p>
+  </blockquote>
+<a class="anchor" id="sort-options" />
+  <a class="header" href="#sort-options">
+    <h5>
+      3.4.1 Sort Options
+    </h5>
+  </a>
+  <p>Pass <code class="language-plaintext highlighter-rouge">:only</code> if you support just a single direction:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">sort</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">only: </span><span class="p">[</span><span class="ss">:desc</span><span class="p">]</span></code></pre></figure>
+<a class="anchor" id="filter" />
+  <a class="header" href="#filter">
+    <h4>
+      3.5 Filter
+    </h4>
+  </a>
+  <p>Use the <code class="language-plaintext highlighter-rouge">filter</code> DSL to customize each <em>operator</em>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">filter</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">:string</span> <span class="k">do</span>
+  <span class="n">eq</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+    <span class="n">scope</span><span class="p">.</span><span class="nf">where</span><span class="p">(</span><span class="ss">first_name: </span><span class="n">value</span><span class="p">)</span>
+  <span class="k">end</span>
+  <span class="c1"># prefix do ... end</span>
+  <span class="c1"># suffix do ... end</span>
+  <span class="c1"># etc</span>
+<span class="k">end</span></code></pre></figure>
+  <p>The built-in operators for ActiveRecord are:</p>
+  <ul>
+    <li>eq (case-insensitive)</li>
+    <li>eql (case-sensitive)</li>
+    <li>prefix</li>
+    <li>suffix</li>
+    <li>match</li>
+    <li>gt (greater-than)</li>
+    <li>gte (greater-than-or-equal-to)</li>
+    <li>lt (less-than)</li>
+    <li>lte (less-than-or-equal-to)</li>
+  </ul>
+  <blockquote>
+    <p>Note that Graphiti expects filters to support multiple values by
+default, so <code class="language-plaintext highlighter-rouge">value</code> will be an array. Pass <code class="language-plaintext highlighter-rouge">single: true</code> if you do
+not support multiple values.</p>
+  </blockquote>
+  <blockquote>
+    <p>To pass multiple values in a query string, comma-delimit:
+<code class="language-plaintext highlighter-rouge">/employees?filter[name]=Jane,John</code></p>
+  </blockquote>
+  <p>If you’ve already defined a corresponding attribute, you’ll be
+overriding that default behavior (and there is no need to pass a type as
+the second argument):</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">attribute</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">:string</span>
+<span class="n">filter</span> <span class="ss">:name</span> <span class="k">do</span>
+  <span class="n">eq</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+    <span class="c1"># ... code ...</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+  <p>You can define custom operators on-the-fly:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">filter</span> <span class="ss">:name</span> <span class="k">do</span>
+  <span class="n">fuzzy_match</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+    <span class="c1"># ... code ...</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+  <p>Will now support <code class="language-plaintext highlighter-rouge">filter[name][fuzzy_match]=foo</code></p>
+  <blockquote>
+    <p>Note: <code class="language-plaintext highlighter-rouge">filter</code> defines a filter-only attribute. If you want other
+behavior, like sorting, it’s best to define the attribute first.</p>
+  </blockquote>
+<a class="anchor" id="filter-options" />
+  <a class="header" href="#filter-options">
+    <h5>
+      3.5.1 Filter Options
+    </h5>
+  </a>
+  <p>Pass <code class="language-plaintext highlighter-rouge">:only</code> or <code class="language-plaintext highlighter-rouge">:except</code> to limit possible operators:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">filter</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">:string</span><span class="p">,</span> <span class="ss">only: </span><span class="p">[</span><span class="ss">:eq</span><span class="p">,</span> <span class="ss">:suffix</span><span class="p">]</span></code></pre></figure>
+  <p>Pass <code class="language-plaintext highlighter-rouge">:allow</code> or <code class="language-plaintext highlighter-rouge">:reject</code> to only allow filtering on certain values, or
+reject bad values:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">filter</span> <span class="ss">:size</span><span class="p">,</span> <span class="ss">:string</span><span class="p">,</span> <span class="ss">allow: </span><span class="p">[</span><span class="s1">'Big'</span><span class="p">,</span> <span class="s1">'Medium'</span><span class="p">,</span> <span class="s1">'Small'</span><span class="p">]</span>
+<span class="n">filter</span> <span class="ss">:size</span><span class="p">,</span> <span class="ss">:string</span><span class="p">,</span> <span class="ss">reject: </span><span class="p">[</span><span class="s1">'X-Large'</span><span class="p">]</span></code></pre></figure>
+  <p>By default, all filters accept multiple values, causing the yielded
+<code class="language-plaintext highlighter-rouge">value</code> to always be an array. Pass <code class="language-plaintext highlighter-rouge">single: true</code> to only allow a
+single value:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># Default behavior</span>
+<span class="n">filter</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">:string</span> <span class="k">do</span>
+  <span class="n">eq</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+    <span class="n">value</span> <span class="c1"># =&gt; ["Jane"]</span>
+  <span class="k">end</span>
+<span class="k">end</span>
+<span class="c1"># With single: true</span>
+<span class="n">filter</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">:string</span><span class="p">,</span> <span class="ss">single: </span><span class="kp">true</span> <span class="k">do</span>
+  <span class="n">eq</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+    <span class="n">value</span> <span class="c1"># =&gt; "Jane"</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+  <p>Filters can be required:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># Via attribute</span>
+<span class="n">attribute</span> <span class="ss">:customer_id</span><span class="p">,</span> <span class="ss">:integer</span><span class="p">,</span> <span class="ss">filterable: :required</span>
+<span class="c1"># Via filter</span>
+<span class="n">filter</span> <span class="ss">:customer_id</span><span class="p">,</span> <span class="ss">:string</span><span class="p">,</span> <span class="ss">required: </span><span class="kp">true</span></code></pre></figure>
+  <p>Filters can also depend on other filters, requiring all criteria to be
+present:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># We query customers by id AND type, not one or the other</span>
+<span class="n">filter</span> <span class="ss">:customer_id</span><span class="p">,</span> <span class="ss">:integer</span><span class="p">,</span> <span class="ss">dependent: </span><span class="p">[</span><span class="ss">:customer_type</span><span class="p">]</span>
+<span class="n">filter</span> <span class="ss">:customer_type</span><span class="p">,</span> <span class="ss">:string</span><span class="p">,</span> <span class="ss">dependent: </span><span class="p">[</span><span class="ss">:customer_id</span><span class="p">]</span></code></pre></figure>
+<a class="anchor" id="boolean-filter" />
+  <a class="header" href="#boolean-filter">
+    <h5>
+      3.5.2 Boolean Filter
+    </h5>
+  </a>
+  <p>It doesn’t make sense for a filter with type <code class="language-plaintext highlighter-rouge">boolean</code> to accept
+multiple values. These filters will be <code class="language-plaintext highlighter-rouge">single: true</code> by default.</p>
+<a class="anchor" id="hash-filter" />
+  <a class="header" href="#hash-filter">
+    <h5>
+      3.5.3 Hash Filter
+    </h5>
+  </a>
+  <p>Filters with type <code class="language-plaintext highlighter-rouge">hash</code> will automatically parse JSON when passed in a
+URL query string:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># GET /employees?filter[metadata]={ "foo": 100 }</span>
+<span class="n">filter</span> <span class="ss">:metadata</span><span class="p">,</span> <span class="ss">:hash</span> <span class="k">do</span>
+  <span class="n">eq</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+    <span class="n">value</span> <span class="c1"># =&gt; [{ "foo" =&gt; 100 }]</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+<a class="anchor" id="escaping-values" />
+  <a class="header" href="#escaping-values">
+    <h5>
+      3.5.4 Escaping Values
+    </h5>
+  </a>
+  <p>By default, Graphiti parses a comma-delimited string as an array. There
+are times you may not want this - for instance a “keyword search” field
+that could contain a comma.</p>
+  <p>Wrap values in <code class="language-plaintext highlighter-rouge">{{curlies}}</code> to avoid parsing:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># GET /employees?filter[keywords]={{some,value}}</span>
+<span class="n">filter</span> <span class="ss">:keywords</span><span class="p">,</span> <span class="ss">:string</span> <span class="k">do</span>
+  <span class="n">eq</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+    <span class="n">value</span> <span class="c1"># =&gt; "some,value"</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+  <p>You can also define arrays explicitly instead of delimiting on comma:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># GET /employees?filter[keywords]=[some,value]</span>
+<span class="n">filter</span> <span class="ss">:keywords</span><span class="p">,</span> <span class="ss">:string</span> <span class="k">do</span>
+  <span class="n">eq</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+    <span class="n">value</span> <span class="c1"># =&gt; ["some", "value"]</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+  <p>If a filter is marked <code class="language-plaintext highlighter-rouge">single: true</code>, we’ll avoid any array parsing and
+escape the value for you, filtering on the string as given.</p>
+  <p>By default a value that comes in as <code class="language-plaintext highlighter-rouge">null</code> is treated as a string <code class="language-plaintext highlighter-rouge">"null"</code>.
+To coerce <code class="language-plaintext highlighter-rouge">null</code> to a Ruby <code class="language-plaintext highlighter-rouge">nil</code> mark the filter with <code class="language-plaintext highlighter-rouge">allow_nil: true</code>.
+This can be changed for all attributes by setting <code class="language-plaintext highlighter-rouge">filters_accept_nil_by_default</code></p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">PostResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">filters_accept_nil_by_default</span> <span class="o">=</span> <span class="kp">true</span>
+<span class="k">end</span></code></pre></figure>
+<a class="anchor" id="statistics" />
+  <a class="header" href="#statistics">
+    <h4>
+      3.6 Statistics
+    </h4>
+  </a>
+  <p>Statistics are useful and common. Consider a datagrid listing posts - we might want a “Total Posts” count displayed above the grid without firing an additional request. Notably, that statistic <strong>should</strong> take into account filtering, but <strong>should not</strong> take into account pagination.</p>
+  <p>All resources have a total count statistic by default:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="no">PostResource</span><span class="p">.</span><span class="nf">all</span><span class="p">({</span>
+  <span class="ss">stats: </span><span class="p">{</span> <span class="ss">total: </span><span class="s1">'count'</span> <span class="p">}</span>
+<span class="p">})</span></code></pre></figure>
+  <p><code class="language-plaintext highlighter-rouge">/posts?stats[total]=count</code></p>
+  <p>Would cause the <code class="language-plaintext highlighter-rouge">meta</code> section of the response to be:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="p">{</span>
+  <span class="ss">meta: </span><span class="p">{</span>
+    <span class="ss">stats: </span><span class="p">{</span>
+      <span class="ss">total: </span><span class="p">{</span>
+        <span class="ss">count: </span><span class="mi">100</span>
+      <span class="p">}</span>
+    <span class="p">}</span>
+  <span class="p">}</span>
+<span class="p">}</span></code></pre></figure>
+  <p>Allow a given statistic to be requested using <code class="language-plaintext highlighter-rouge">.stat</code>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">stat</span> <span class="ss">total: </span><span class="p">[</span><span class="ss">:count</span><span class="p">]</span>
+<span class="n">stat</span> <span class="ss">rating: </span><span class="p">[</span><span class="ss">:average</span><span class="p">]</span>
+<span class="n">stat</span> <span class="ss">likes: </span><span class="p">[</span><span class="ss">:sum</span><span class="p">]</span>
+<span class="n">stat</span> <span class="ss">score: </span><span class="p">[</span><span class="ss">:maximum</span><span class="p">]</span>
+<span class="n">stat</span> <span class="ss">score: </span><span class="p">[</span><span class="ss">:maximum</span><span class="p">]</span>
+<span class="c1"># e.g.</span>
+<span class="c1"># {</span>
+<span class="c1">#   meta: {</span>
+<span class="c1">#     stats: {</span>
+<span class="c1">#       rating: {</span>
+<span class="c1">#         average: 74</span>
+<span class="c1">#       }</span>
+<span class="c1">#     }</span>
+<span class="c1">#   }</span>
+<span class="c1"># }</span></code></pre></figure>
+  <p>You can also define custom statistics:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">stat</span> <span class="ss">rating: </span><span class="p">[</span><span class="ss">:average</span><span class="p">]</span> <span class="k">do</span>
+  <span class="n">standard_deviation</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="kp">attr</span><span class="o">|</span>
+    <span class="c1"># your standard deviation code here</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+<a class="anchor" id="extra-fields" />
+  <a class="header" href="#extra-fields">
+    <h4>
+      3.7 Extra Fields
+    </h4>
+  </a>
+  <p>Sometimes you have a field that is not always needed, and perhaps
+computationally expensive. In this case, you only want the field
+returned when explicitly requested by the client. To do this:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">extra_attribute</span> <span class="ss">:net_worth</span></code></pre></figure>
+  <p>This works just like <code class="language-plaintext highlighter-rouge">attribute</code>, except the field is read-only and will
+only be returned when requested. The query parameter signature matches
+<code class="language-plaintext highlighter-rouge">fields</code>: <code class="language-plaintext highlighter-rouge">?extra_fields[employees]=net_worth</code>.</p>
+  <p>You may want to adjust your scope to eager load data when a given extra
+field is requested. To do this:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">resource</span><span class="p">.</span><span class="nf">on_extra_attribute</span> <span class="ss">:net_worth</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="o">|</span>
+  <span class="n">scope</span><span class="p">.</span><span class="nf">includes</span><span class="p">(</span><span class="ss">:assets</span><span class="p">)</span>
+<span class="k">end</span></code></pre></figure>
+<a class="anchor" id="resolve" />
+  <a class="header" href="#resolve">
+    <h4>
+      3.8 #resolve
+    </h4>
+  </a>
+  <p>After we build up a query, we pass it to <code class="language-plaintext highlighter-rouge">#resolve</code>. Resolve <strong>must</strong> do
+two things:</p>
+  <ul>
+    <li>Execute the query</li>
+    <li>Return an array of <code class="language-plaintext highlighter-rouge">Model</code> instances</li>
+  </ul>
+  <p>Override <code class="language-plaintext highlighter-rouge">#resolve</code> if you need more than the default behavior:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">def</span> <span class="nf">resolve</span><span class="p">(</span><span class="n">scope</span><span class="p">)</span>
+  <span class="no">Rails</span><span class="p">.</span><span class="nf">logger</span><span class="p">.</span><span class="nf">info</span> <span class="s2">"begin resolving scope..."</span>
+  <span class="n">result</span> <span class="o">=</span> <span class="k">super</span>
+  <span class="no">Rails</span><span class="p">.</span><span class="nf">logger</span><span class="p">.</span><span class="nf">info</span> <span class="s2">"resolved!"</span>
+  <span class="n">result</span>
+<span class="k">end</span></code></pre></figure>
+<a class="anchor" id="configuration" />
+  <a class="header" href="#configuration">
+    <h2>
+      4 Configuration
+    </h2>
+  </a>
+  <p>Here’s a Resource with explicit defaults:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">PostResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">model</span> <span class="o">=</span> <span class="no">Post</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">type</span> <span class="o">=</span> <span class="s1">'posts'</span>
+  <span class="c1"># Only used if you care about Links</span>
+  <span class="n">primary_endpoint</span> <span class="s1">'/posts'</span><span class="p">,</span> <span class="p">[</span><span class="ss">:index</span><span class="p">,</span> <span class="ss">:show</span><span class="p">,</span> <span class="ss">:create</span><span class="p">,</span> <span class="ss">:update</span><span class="p">,</span> <span class="ss">:destroy</span><span class="p">]</span>
+  <span class="c1"># default nil</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">default_sort</span> <span class="o">=</span> <span class="p">[{</span> <span class="ss">title: :asc</span> <span class="p">}]</span>
+  <span class="c1"># default 20</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">default_page_size</span> <span class="o">=</span> <span class="mi">10</span>
+<span class="k">end</span></code></pre></figure>
+  <p>Typically you’d inherit from <code class="language-plaintext highlighter-rouge">ApplicationResource</code>. Here are some common higher-level customization options that will affect subclasses:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">ApplicationResource</span> <span class="o">&lt;</span> <span class="no">Graphiti</span><span class="o">::</span><span class="no">Resource</span>
+  <span class="c1"># Must be set when no corresponding model/query</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">abstract_class</span> <span class="o">=</span> <span class="kp">true</span>
+  <span class="c1"># Subclasses can override if needed</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">adapter</span> <span class="o">=</span> <span class="no">Graphiti</span><span class="o">::</span><span class="no">Adapters</span><span class="o">::</span><span class="no">ActiveRecord</span>
+  <span class="c1"># Default attribute flags:</span>
+  <span class="c1"># attribute :title, :string,</span>
+  <span class="c1">#   readable: default,</span>
+  <span class="c1">#   writable: default,</span>
+  <span class="c1">#   sortable: default,</span>
+  <span class="c1">#   filterable: default</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">attributes_readable_by_default</span> <span class="o">=</span> <span class="kp">true</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">attributes_writable_by_default</span> <span class="o">=</span> <span class="kp">true</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">attributes_sortable_by_default</span> <span class="o">=</span> <span class="kp">true</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">attributes_filterable_by_default</span> <span class="o">=</span> <span class="kp">true</span>
+  <span class="c1"># Used for link generation</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">base_url</span> <span class="o">=</span> <span class="no">Rails</span><span class="p">.</span><span class="nf">application</span><span class="p">.</span><span class="nf">routes</span><span class="p">.</span><span class="nf">default_url_options</span><span class="p">[</span><span class="ss">:host</span><span class="p">]</span>
+  <span class="c1"># Used for link generation</span>
+  <span class="c1"># Suggest referencing this config/routes.rb:</span>
+  <span class="c1"># scope path: ApplicationResource.endpoint_namespace do</span>
+  <span class="c1">#   resources :posts</span>
+  <span class="c1"># end</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">endpoint_namespace</span> <span class="o">=</span> <span class="s1">'/api/v1'</span>
+  <span class="c1"># Will raise an error if a resource is being accessed from a URL it is not allowlisted for</span>
+  <span class="c1"># Helpful for link validation</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">validate_endpoints</span> <span class="o">=</span> <span class="kp">false</span>
+  <span class="c1"># Automatically generate JSONAPI links?</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">autolink</span> <span class="o">=</span> <span class="kp">true</span>
+<span class="k">end</span></code></pre></figure>
+<a class="anchor" id="polymorphic-resources" />
+  <a class="header" href="#polymorphic-resources">
+    <h3>
+      4.1 Polymorphic Resources
+    </h3>
+  </a>
+  <p>Polymorphic Resources are similar to <a href="https://api.rubyonrails.org/classes/ActiveRecord/Inheritance.html">ActiveRecord STI</a>: when a single query can return multiple Resource instances. We may query <code class="language-plaintext highlighter-rouge">/tasks</code>, but return <code class="language-plaintext highlighter-rouge">bugs</code>, <code class="language-plaintext highlighter-rouge">features</code>, <code class="language-plaintext highlighter-rouge">epics</code>, etc.</p>
+  <p>For example, given the <code class="language-plaintext highlighter-rouge">ActiveRecord</code> models:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">Employee</span> <span class="o">&lt;</span> <span class="no">ApplicationRecord</span>
+  <span class="n">has_many</span> <span class="ss">:tasks</span>
+<span class="k">end</span>
+<span class="c1"># tasks table has a 'type' column</span>
+<span class="k">class</span> <span class="nc">Task</span> <span class="o">&lt;</span> <span class="no">ApplicationRecord</span>
+  <span class="n">belongs_to</span> <span class="ss">:employee</span>
+<span class="k">end</span>
+<span class="k">class</span> <span class="nc">Bug</span> <span class="o">&lt;</span> <span class="no">Task</span>
+<span class="k">end</span>
+<span class="c1"># ONLY Feature has #points</span>
+<span class="k">class</span> <span class="nc">Feature</span> <span class="o">&lt;</span> <span class="no">Task</span>
+  <span class="k">def</span> <span class="nf">points</span>
+    <span class="mi">5</span>
+  <span class="k">end</span>
+<span class="k">end</span>
+<span class="c1"># ONLY Epic has the milestones relationship</span>
+<span class="k">class</span> <span class="nc">Epic</span> <span class="o">&lt;</span> <span class="no">Task</span>
+  <span class="n">has_many</span> <span class="ss">:milestones</span>
+<span class="k">end</span>
+<span class="k">class</span> <span class="nc">Milestone</span> <span class="o">&lt;</span> <span class="no">ApplicationRecord</span>
+  <span class="n">belongs_to</span> <span class="ss">:epic</span>
+<span class="k">end</span></code></pre></figure>
+  <p>We could define the following Polymorphic Resources:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">TaskResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="c1"># Reference child classes</span>
+  <span class="nb">self</span><span class="p">.</span><span class="nf">polymorphic</span> <span class="o">=</span> <span class="p">[</span>
+    <span class="s1">'BugResource'</span><span class="p">,</span>
+    <span class="s1">'FeatureResource'</span><span class="p">,</span>
+    <span class="s1">'EpicResource'</span>
+  <span class="p">]</span>
+  <span class="n">attribute</span> <span class="ss">:title</span><span class="p">,</span> <span class="ss">:string</span>
+<span class="k">end</span>
+<span class="k">class</span> <span class="nc">BugResource</span> <span class="o">&lt;</span> <span class="no">TaskResource</span>
+<span class="k">end</span>
+<span class="k">class</span> <span class="nc">FeatureResource</span> <span class="o">&lt;</span> <span class="no">TaskResource</span>
+  <span class="n">attribute</span> <span class="ss">:points</span><span class="p">,</span> <span class="ss">:integer</span>
+<span class="k">end</span>
+<span class="k">class</span> <span class="nc">EpicResource</span> <span class="o">&lt;</span> <span class="no">TaskResource</span>
+  <span class="n">has_many</span> <span class="ss">:milestones</span>
+<span class="k">end</span>
+<span class="k">class</span> <span class="nc">MilestoneResource</span> <span class="o">&lt;</span> <span class="no">TaskResource</span>
+  <span class="n">belongs_to</span> <span class="ss">:epic</span>
+<span class="k">end</span></code></pre></figure>
+  <p>If we hit a <code class="language-plaintext highlighter-rouge">/tasks</code> endpoint, we’d get back <a href="http://jsonapi.org/format/#document-resource-identifier-objects">JSONAPI types</a> of <code class="language-plaintext highlighter-rouge">bugs</code>, <code class="language-plaintext highlighter-rouge">features</code> and <code class="language-plaintext highlighter-rouge">epics</code>. Only <code class="language-plaintext highlighter-rouge">features</code> would render the <code class="language-plaintext highlighter-rouge">points</code> attribute, and only <code class="language-plaintext highlighter-rouge">epics</code> would render the <code class="language-plaintext highlighter-rouge">milestones relationship</code>.</p>
+  <p>A query to <code class="language-plaintext highlighter-rouge">/tasks?include=milestones</code> would correctly only query
+and render Milestones for Epics.</p>
+<a class="anchor" id="relationships" />
+  <a class="header" href="#relationships">
+    <h2>
+      5 Relationships
+    </h2>
+  </a>
+  <p>Resources can connect to other Resources via <strong>relationships</strong>.
+Each relationship determines behavior for:</p>
+  <ul>
+    <li>Sideloading (load both Resources in a single request)</li>
+    <li>Links (URL to lazy-load in separate request)</li>
+    <li>Sideposting (save both in single request)</li>
+  </ul>
+  <p>When connecting resources, you can imagine the logic similar to
+<code class="language-plaintext highlighter-rouge">ActiveRecord</code>’s <code class="language-plaintext highlighter-rouge">.includes</code>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">PostResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="n">has_many</span> <span class="ss">:comments</span>
+<span class="k">end</span>
+<span class="k">class</span> <span class="nc">CommentResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="n">attribute</span> <span class="ss">:post_id</span><span class="p">,</span> <span class="ss">:integer</span><span class="p">,</span> <span class="ss">only: </span><span class="p">[</span><span class="ss">:filterable</span><span class="p">]</span>
+  <span class="n">belongs_to</span> <span class="ss">:post</span>
+<span class="k">end</span>
+<span class="no">PostResource</span><span class="p">.</span><span class="nf">all</span><span class="p">(</span><span class="ss">include: </span><span class="s1">'comments'</span><span class="p">)</span>
+<span class="c1"># Under the hood:</span>
+<span class="c1"># CommentResource.all(filter: { post_id: array_of_post_ids })</span>
+<span class="no">CommentResource</span><span class="p">.</span><span class="nf">all</span><span class="p">(</span><span class="ss">include: </span><span class="s1">'post'</span><span class="p">)</span>
+<span class="c1"># Under the hood:</span>
+<span class="c1"># PostResource.all(filter: { id: array_of_comment_ids })</span></code></pre></figure>
+  <blockquote>
+    <p>Note the explicit <code class="language-plaintext highlighter-rouge">post_id</code> filter on <code class="language-plaintext highlighter-rouge">CommentResource</code></p>
+  </blockquote>
+<a class="anchor" id="deep-queries" />
+  <a class="header" href="#deep-queries">
+    <h3>
+      5.1 Deep Queries
+    </h3>
+  </a>
+  <p>A query that applies to a relationship is referred to as a <strong>deep
+query</strong>. Use the dot-syntax to deep query:</p>
+  <p><code class="language-plaintext highlighter-rouge">/employees?include=positions&amp;filter[positions.title]=Manager</code></p>
+  <p><code class="language-plaintext highlighter-rouge">/employees?include=positions.department&amp;filter[positions.department.name]=Engineering</code></p>
+  <p>The above references the <strong>relationship name</strong>. For simplicity, you can
+also pass the JSONAPI type in brackets:</p>
+  <p><code class="language-plaintext highlighter-rouge">/employees?include=positions.department&amp;filter[departments][name]=Engineering</code></p>
+  <p>Sorting and pagination currently only support the JSONAPI type:</p>
+  <p><code class="language-plaintext highlighter-rouge">/employees?include=positions.department&amp;sort=departments.name</code></p>
+  <p><code class="language-plaintext highlighter-rouge">/employees?include=positions.department&amp;page[departments][size]=10</code></p>
+<a class="anchor" id="customizing-relationships" />
+  <a class="header" href="#customizing-relationships">
+    <h4>
+      5.2 Customizing Relationships
+    </h4>
+  </a>
+  <p>The default options you can override are:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">has_many</span> <span class="ss">:positions</span><span class="p">,</span>
+  <span class="ss">foreign_key: :employee_id</span><span class="p">,</span>
+  <span class="ss">primary_key: :id</span><span class="p">,</span>
+  <span class="ss">resource: </span><span class="no">EmployeeResource</span><span class="p">,</span>
+  <span class="ss">readable: </span><span class="kp">true</span><span class="p">,</span>
+  <span class="ss">writable: </span><span class="kp">true</span><span class="p">,</span>
+  <span class="ss">link: </span><span class="nb">self</span><span class="p">.</span><span class="nf">autolink</span><span class="p">,</span> <span class="c1"># default true</span>
+  <span class="ss">single: </span><span class="kp">false</span><span class="p">,</span> <span class="c1"># only allow this sideload when one employee</span>
+  <span class="ss">always_include_resource_ids: </span><span class="kp">false</span></code></pre></figure>
+  <p><em>note</em>: Setting <code class="language-plaintext highlighter-rouge">always_include_resource_ids: true</code> could result in 1+N queries (see <a href="https://github.com/graphiti-api/graphiti/issues/167#issuecomment-686866646">#167</a>)</p>
+<a class="anchor" id="conditional-relationships" />
+  <a class="header" href="#conditional-relationships">
+    <h5>
+      5.2.1 Conditional Relationships
+    </h5>
+  </a>
+  <p>Like attributes, the <code class="language-plaintext highlighter-rouge">readable</code> and <code class="language-plaintext highlighter-rouge">writable</code> flags on a relationship accept more than a boolean: pass a symbol, string, or proc and the relationship becomes conditional, evaluated per-request.</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">EmployeeResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="n">has_many</span> <span class="ss">:salary_histories</span><span class="p">,</span> <span class="ss">readable: :admin?</span><span class="p">,</span> <span class="ss">writable: :admin?</span>
+  <span class="k">def</span> <span class="nf">admin?</span>
+    <span class="n">context</span><span class="p">.</span><span class="nf">current_user</span><span class="p">.</span><span class="nf">admin?</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+  <p>When a readable guard returns <code class="language-plaintext highlighter-rouge">false</code>, the relationship is omitted from the serialized output and any attempt to sideload it via <code class="language-plaintext highlighter-rouge">?include=</code> is silently scrubbed from the request. When a writable guard returns <code class="language-plaintext highlighter-rouge">false</code>, sideposting to that relationship is rejected with an <code class="language-plaintext highlighter-rouge">unwritable_relationship</code> validation error.</p>
+  <p>Unlike attribute guards, relationship guards take no arguments. Include scrubbing happens before any records have been fetched, so there is no model to hand them — base the decision on <code class="language-plaintext highlighter-rouge">context</code> alone.</p>
+  <p>The guard can live on either side of the relationship. Graphiti first looks for the method on the resource declaring the relationship; if it isn’t defined there but is defined on the related resource, the related resource’s method is used. Defining the guard on the related resource lets a single guard cover every relationship pointing at it:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">SalaryHistoryResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="c1"># Any resource declaring a relationship to SalaryHistoryResource with</span>
+  <span class="c1"># readable: :admin? will use this method, unless it defines its own.</span>
+  <span class="k">def</span> <span class="nf">admin?</span>
+    <span class="n">context</span><span class="p">.</span><span class="nf">current_user</span><span class="p">.</span><span class="nf">admin?</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+  <blockquote>
+    <p><strong>Upgrading to 1.12:</strong> relationship guards are new enforcement, not a new
+option. Before 1.12, a symbol, string, or proc passed to a relationship’s
+<code class="language-plaintext highlighter-rouge">readable</code>/<code class="language-plaintext highlighter-rouge">writable</code> was accepted and silently treated as <code class="language-plaintext highlighter-rouge">true</code> — the guard
+was never called. Those guards now run. If your app already passes one of
+these, a relationship that has been serialized all along may start
+disappearing from responses.</p>
+    <p>To list every guarded relationship in your app before deploying, run
+<code class="language-plaintext highlighter-rouge">bin/rails runner 'puts Graphiti.guarded_relationships'</code>.</p>
+    <p>Apps using <code class="language-plaintext highlighter-rouge">schema.json</code> also get this for free: guarded relationships are
+flagged in the schema, and the schema check reports them as
+<code class="language-plaintext highlighter-rouge">became guarded</code>.</p>
+  </blockquote>
+<a class="anchor" id="customizing-scope" />
+  <a class="header" href="#customizing-scope">
+    <h5>
+      5.2.2 Customizing Scope
+    </h5>
+  </a>
+  <p>Use <code class="language-plaintext highlighter-rouge">params</code> to change the query parameters that will be passed to the
+associated Resource:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">has_many</span> <span class="ss">:active_positions</span><span class="p">,</span> <span class="ss">resource: </span><span class="no">PositionResource</span> <span class="k">do</span>
+  <span class="n">params</span> <span class="k">do</span> <span class="o">|</span><span class="nb">hash</span><span class="p">,</span> <span class="n">employees</span><span class="o">|</span>
+    <span class="nb">hash</span><span class="p">[</span><span class="ss">:filter</span><span class="p">][</span><span class="ss">:active</span><span class="p">]</span> <span class="o">=</span> <span class="kp">true</span>
+  <span class="k">end</span>
+<span class="k">end</span>
+<span class="c1"># Would cause the underlying query:</span>
+<span class="c1">#</span>
+<span class="c1"># PositionResource.all({</span>
+<span class="c1">#   filter: {</span>
+<span class="c1">#     employee_id: array_of_employee_ids</span>
+<span class="c1">#     active: true</span>
+<span class="c1">#   }</span>
+<span class="c1"># })</span></code></pre></figure>
+  <p>If there is no existing AR association for this we would also need to make it a getter/setter on the model.</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># app/models/position.rb</span>
+<span class="nb">attr_accessor</span> <span class="ss">:active_positions</span></code></pre></figure>
+<a class="anchor" id="customizing-assignment" />
+  <a class="header" href="#customizing-assignment">
+    <h5>
+      5.2.3 Customizing Assignment
+    </h5>
+  </a>
+  <p>Once we’ve fetched primary data and its relationship (e.g. we have an
+<code class="language-plaintext highlighter-rouge">employees</code> array and <code class="language-plaintext highlighter-rouge">positions</code> array), we need to associate these
+objects:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">employees</span><span class="p">.</span><span class="nf">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">e</span><span class="o">|</span>
+  <span class="n">e</span><span class="p">.</span><span class="nf">positions</span> <span class="o">=</span> <span class="n">positions</span><span class="p">.</span><span class="nf">select</span> <span class="p">{</span> <span class="o">|</span><span class="nb">p</span><span class="o">|</span> <span class="nb">p</span><span class="p">.</span><span class="nf">employee_id</span> <span class="o">==</span> <span class="n">e</span><span class="p">.</span><span class="nf">id</span> <span class="p">}</span>
+<span class="k">end</span></code></pre></figure>
+  <p>Occasionally this logic will be non-standard or more complex. Use
+<code class="language-plaintext highlighter-rouge">assign_each</code> to customize, returning all relevant children for the
+given parent:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">has_many</span> <span class="ss">:positions</span> <span class="k">do</span>
+  <span class="n">assign_each</span> <span class="k">do</span> <span class="o">|</span><span class="n">employee</span><span class="p">,</span> <span class="n">positions</span><span class="o">|</span>
+    <span class="n">positions</span><span class="p">.</span><span class="nf">select</span> <span class="p">{</span> <span class="o">|</span><span class="nb">p</span><span class="o">|</span> <span class="nb">p</span><span class="p">.</span><span class="nf">belongs_to?</span><span class="p">(</span><span class="n">employee</span><span class="p">)</span> <span class="p">}</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+  <p>Or if all else fails, use <code class="language-plaintext highlighter-rouge">#assign</code> to control all the logic:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">has_many</span> <span class="ss">:positions</span> <span class="k">do</span>
+  <span class="n">assign</span> <span class="k">do</span> <span class="o">|</span><span class="n">employees</span><span class="p">,</span> <span class="n">positions</span><span class="o">|</span>
+    <span class="n">employees</span><span class="p">.</span><span class="nf">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">employee</span><span class="o">|</span>
+      <span class="n">positions</span><span class="p">.</span><span class="nf">select</span> <span class="p">{</span> <span class="o">|</span><span class="nb">p</span><span class="o">|</span> <span class="nb">p</span><span class="p">.</span><span class="nf">belongs_to?</span><span class="p">(</span><span class="n">employee</span><span class="p">)</span> <span class="p">}</span>
+    <span class="k">end</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+  <p><strong>Note</strong>: ActiveRecord will sometimes cause unexpected queries when
+assigning. If you’re overriding <code class="language-plaintext highlighter-rouge">#assign</code>, make sure to keep an eye on
+this. If using <code class="language-plaintext highlighter-rouge">#assign_each</code>, you’re fine because the adapter will take
+care of this for you.</p>
+<a class="anchor" id="has-many" />
+  <a class="header" href="#has-many">
+    <h4>
+      5.3 has_many
+    </h4>
+  </a>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">has_many</span> <span class="ss">:positions</span></code></pre></figure>
+  <p>Defaults to these common options:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">has_many</span> <span class="ss">:positions</span><span class="p">,</span>
+  <span class="ss">foreign_key: :employee_id</span><span class="p">,</span>
+  <span class="ss">primary_key: :id</span><span class="p">,</span>
+  <span class="ss">always_include_resource_ids: </span><span class="kp">false</span><span class="p">,</span>
+  <span class="ss">resource: </span><span class="no">PositionResource</span></code></pre></figure>
+  <p>Which would cause the following query when sideloading:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="no">PositionResource</span><span class="p">.</span><span class="nf">all</span><span class="p">({</span> <span class="ss">filter: </span><span class="p">{</span> <span class="n">employee_id</span> <span class="o">=&gt;</span> <span class="n">employee_ids</span> <span class="p">}</span> <span class="p">})</span></code></pre></figure>
+  <p>This means <strong>we need to make sure that filter is supported</strong>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">PositionResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="n">attribute</span> <span class="ss">:employee_id</span><span class="p">,</span> <span class="ss">:integer</span><span class="p">,</span> <span class="ss">only: </span><span class="p">[</span><span class="ss">:filterable</span><span class="p">]</span>
+  <span class="c1"># ... code ...</span>
+<span class="k">end</span></code></pre></figure>
+  <p>Once we’ve resolved <code class="language-plaintext highlighter-rouge">employees</code> and <code class="language-plaintext highlighter-rouge">positions</code> the resulting objects
+would be associated with logic similar to:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">employees</span><span class="p">.</span><span class="nf">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">e</span><span class="o">|</span>
+  <span class="n">e</span><span class="p">.</span><span class="nf">positions</span> <span class="o">=</span> <span class="n">positions</span><span class="p">.</span><span class="nf">select</span> <span class="p">{</span> <span class="o">|</span><span class="nb">p</span><span class="o">|</span> <span class="nb">p</span><span class="p">.</span><span class="nf">employee_id</span> <span class="o">==</span> <span class="n">e</span><span class="p">.</span><span class="nf">id</span> <span class="p">}</span>
+<span class="k">end</span></code></pre></figure>
+  <p>And generate a Link:</p>
+  <p><code class="language-plaintext highlighter-rouge">/positions?filter[employee_id]=1,2,3</code></p>
+<a class="anchor" id="belongs-to" />
+  <a class="header" href="#belongs-to">
+    <h4>
+      5.4 belongs_to
+    </h4>
+  </a>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">belongs_to</span> <span class="ss">:employee</span></code></pre></figure>
+  <p>Defaults to these common options:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">belongs_to</span> <span class="ss">:employee</span><span class="p">,</span>
+  <span class="ss">foreign_key: :employee_id</span><span class="p">,</span>
+  <span class="ss">primary_key: :id</span><span class="p">,</span>
+  <span class="ss">always_include_resource_ids: </span><span class="kp">false</span><span class="p">,</span>
+  <span class="ss">resource: </span><span class="no">EmployeeResource</span></code></pre></figure>
+  <p>Which would cause the following query when sideloading:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="no">EmployeeResource</span><span class="p">.</span><span class="nf">all</span><span class="p">({</span> <span class="ss">filter: </span><span class="p">{</span> <span class="nb">id</span> <span class="o">=&gt;</span> <span class="n">position_ids</span> <span class="p">}</span> <span class="p">})</span></code></pre></figure>
+  <p>And assign the resulting objects with logic similar to:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">positions</span><span class="p">.</span><span class="nf">each</span> <span class="k">do</span> <span class="o">|</span><span class="nb">p</span><span class="o">|</span>
+  <span class="nb">p</span><span class="p">.</span><span class="nf">employee</span> <span class="o">=</span> <span class="n">employees</span><span class="p">.</span><span class="nf">find</span> <span class="p">{</span> <span class="o">|</span><span class="n">e</span><span class="o">|</span> <span class="nb">p</span><span class="p">.</span><span class="nf">employee_id</span> <span class="o">==</span> <span class="n">e</span><span class="p">.</span><span class="nf">id</span> <span class="p">}</span>
+<span class="k">end</span></code></pre></figure>
+  <p>And generate a Link:</p>
+  <p><code class="language-plaintext highlighter-rouge">/employees?filter[id]=1,2,3</code></p>
+<a class="anchor" id="has-one" />
+  <a class="header" href="#has-one">
+    <h4>
+      5.5 has_one
+    </h4>
+  </a>
+  <p><code class="language-plaintext highlighter-rouge">has_one</code> works exactly like <code class="language-plaintext highlighter-rouge">has_many</code>, but only one record will be
+returned. When sideloading this will be a single element, much like
+<code class="language-plaintext highlighter-rouge">belongs_to</code>.</p>
+  <p>There is one small caveat: Links always point to an <code class="language-plaintext highlighter-rouge">index</code> action, so
+we can apply filters. That means following <em><code class="language-plaintext highlighter-rouge">has_one</code> Link will lead to
+an array</em>, and you should select the first record.</p>
+<a class="anchor" id="faux-has-one" />
+  <a class="header" href="#faux-has-one">
+    <h5>
+      5.5.1 Faux has_one
+    </h5>
+  </a>
+  <p>A “Faux Has One” occurs when there is more than one record of
+associated data, but we only want to return the <em>first</em> record in that
+array. Consider this <code class="language-plaintext highlighter-rouge">ActiveRecord</code> relationship:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># app/models/employee.rb</span>
+<span class="n">has_many</span> <span class="ss">:positions</span>
+<span class="n">has_one</span> <span class="ss">:current_position</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="p">{</span> <span class="n">where</span><span class="p">(</span><span class="ss">created_at: :desc</span><span class="p">)</span> <span class="p">},</span> <span class="ss">class_name: </span><span class="s1">'Position'</span>
+<span class="no">Employee</span><span class="p">.</span><span class="nf">includes</span><span class="p">(</span><span class="s1">'current_position'</span><span class="p">).</span><span class="nf">to_a</span>
+<span class="c1"># SELECT * FROM employees</span>
+<span class="c1"># SELECT * FROM positions WHERE employee_id IN (?) ORDER BY created_at DESC</span></code></pre></figure>
+  <p>When we eager load, <em>more than one Position is returned from the
+database query</em>. Assigning only the first record and dropping the rest
+occurs in ruby, not the database query.</p>
+  <p>The same thing happens in Graphiti:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># app/resources/employee_resource.rb</span>
+<span class="n">has_many</span> <span class="ss">:positions</span>
+<span class="n">has_one</span> <span class="ss">:current_position</span><span class="p">,</span> <span class="ss">resource: </span><span class="no">PositionResource</span> <span class="k">do</span>
+  <span class="n">params</span> <span class="k">do</span> <span class="o">|</span><span class="nb">hash</span><span class="o">|</span>
+    <span class="nb">hash</span><span class="p">[</span><span class="ss">:sort</span><span class="p">]</span> <span class="o">=</span> <span class="s1">'-created_at'</span>
+  <span class="k">end</span>
+<span class="k">end</span>
+<span class="no">EmployeeResource</span><span class="p">.</span><span class="nf">all</span><span class="p">(</span><span class="ss">include: </span><span class="s1">'current_position'</span><span class="p">)</span>
+<span class="c1"># PositionResource.all({</span>
+<span class="c1">#   filter: { employee_id: employee_ids },</span>
+<span class="c1">#   sort: '-created_at'</span>
+<span class="c1"># })</span></code></pre></figure>
+  <p>Though everything works as expected, a large number of Position records
+can incur a performance penalty (as we’d be instantiating a large number
+of ActiveRecord objects).</p>
+  <p>For this reason, you are encouraged to model Faux Has One’s in such a
+way that the underlying database query only returns the relevant single
+record. Imagine if we had a <code class="language-plaintext highlighter-rouge">historical_index</code> column on <code class="language-plaintext highlighter-rouge">positions</code>,
+where a value of <code class="language-plaintext highlighter-rouge">1</code> meant “most recent”:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># app/models/employee.rb</span>
+<span class="n">has_many</span> <span class="ss">:positions</span>
+<span class="n">has_one</span> <span class="ss">:current_position</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="p">{</span> <span class="n">where</span><span class="p">(</span><span class="ss">historical_index: </span><span class="mi">1</span><span class="p">)</span> <span class="p">},</span> <span class="ss">class_name: </span><span class="s1">'Position'</span>
+<span class="no">Employee</span><span class="p">.</span><span class="nf">includes</span><span class="p">(</span><span class="s1">'current_position'</span><span class="p">).</span><span class="nf">to_a</span>
+<span class="c1"># SELECT * FROM employees</span>
+<span class="c1"># SELECT * FROM positions WHERE employee_id IN (?) AND historical_index = 1</span></code></pre></figure>
+  <p>We’ve ensured the <em>query itself</em> only returns a single record.
+Optimizing a Graphiti API is the same as optimizing queries.</p>
+<a class="anchor" id="many-to-many" />
+  <a class="header" href="#many-to-many">
+    <h4>
+      5.6 many_to_many
+    </h4>
+  </a>
+  <blockquote>
+    <p>This relationship is specific to relational databases that use a “join
+table” between two tables.</p>
+  </blockquote>
+  <p>Though you can make this work for other ORMs/clients, it’s easiest to
+explain by focusing on <code class="language-plaintext highlighter-rouge">ActiveRecord</code>.</p>
+  <p>First, <strong>you must use <a href="https://guides.rubyonrails.org/association_basics.html#the-has-many-through-association">has_many :through</a> and not has_and_belongs_to_many</strong>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">Employee</span> <span class="o">&lt;</span> <span class="no">ApplicationRecord</span>
+  <span class="n">has_many</span> <span class="ss">:team_memberships</span>
+  <span class="n">has_many</span> <span class="ss">:teams</span><span class="p">,</span> <span class="ss">through: :team_memberships</span>
+<span class="k">end</span>
+<span class="k">class</span> <span class="nc">TeamMembership</span> <span class="o">&lt;</span> <span class="no">ApplicationRecord</span>
+  <span class="n">belongs_to</span> <span class="ss">:employee</span>
+  <span class="n">belongs_to</span> <span class="ss">:team</span>
+<span class="k">end</span>
+<span class="k">class</span> <span class="nc">Team</span> <span class="o">&lt;</span> <span class="no">ApplicationRecord</span>
+  <span class="n">has_many</span> <span class="ss">:team_memberships</span>
+  <span class="n">has_many</span> <span class="ss">:employees</span><span class="p">,</span> <span class="ss">through: :team_memberships</span>
+<span class="k">end</span></code></pre></figure>
+  <p>You can always expose <code class="language-plaintext highlighter-rouge">team_memberships</code> to your API - particularly
+useful if that table holds metadata about the relationship.</p>
+  <p>Other times, however, clients of the API should not have knowledge of
+this implementation detail. In these cases, use <code class="language-plaintext highlighter-rouge">many_to_many</code>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">EmployeeResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="n">many_to_many</span> <span class="ss">:teams</span>
+<span class="k">end</span>
+<span class="c1"># Generates the Link</span>
+<span class="c1"># /teams?filter[employee_id]=1,2,3</span>
+<span class="k">class</span> <span class="nc">TeamResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="n">many_to_many</span> <span class="ss">:employees</span>
+<span class="k">end</span>
+<span class="c1"># Generates the Link</span>
+<span class="c1"># /teams?filter[team_id]=1,2,3</span></code></pre></figure>
+  <p>The <code class="language-plaintext highlighter-rouge">many_to_many</code> call will automatically add a Filter to the
+associated resource. The logic for that filter, in the case of <code class="language-plaintext highlighter-rouge">ActiveRecord</code>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># app/resources/employee_resource.rb</span>
+<span class="n">filter</span> <span class="ss">:team_id</span><span class="p">,</span> <span class="ss">:integer</span> <span class="k">do</span>
+  <span class="n">eq</span> <span class="k">do</span> <span class="o">|</span><span class="n">scope</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+    <span class="n">scope</span>
+      <span class="p">.</span><span class="nf">includes</span><span class="p">(</span><span class="ss">:team_memberships</span><span class="p">)</span>
+      <span class="p">.</span><span class="nf">where</span><span class="p">(</span><span class="ss">team_memberships: </span><span class="p">{</span> <span class="ss">team_id: </span><span class="n">value</span> <span class="p">}</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+  <p>To customize the foreign key, you will need to specify a hash rather
+than a symbol. The hash key is the relationship name, so the above is
+equivalent to</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># app/resources/employee_resource.rb</span>
+<span class="n">many_to_many</span> <span class="ss">:teams</span><span class="p">,</span> <span class="ss">foreign_key: </span><span class="p">{</span> <span class="ss">team_memberships: :team_id</span> <span class="p">}</span></code></pre></figure>
+  <p>If using ActiveRecord, and the API relationship name does not match your
+Model relationship name, use <code class="language-plaintext highlighter-rouge">:as</code> to specify the model relationship
+that should be used to derive the query:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># The API relationship is "teams", ActiveRecord has "groups"</span>
+<span class="n">many_to_many</span> <span class="ss">:teams</span><span class="p">,</span> <span class="ss">as: :groups</span></code></pre></figure>
+<a class="anchor" id="polymorphic-belongs-to" />
+  <a class="header" href="#polymorphic-belongs-to">
+    <h4>
+      5.7 polymorphic_belongs_to
+    </h4>
+  </a>
+  <p>With polymorphic associations, a Resource can belong to more than one other Resource, on a single association. Though these relationships are not specific to <code class="language-plaintext highlighter-rouge">ActiveRecord</code>, we’ll use <code class="language-plaintext highlighter-rouge">ActiveRecord</code> conventions to describe the use case.</p>
+  <p>Given the following <a href="https://guides.rubyonrails.org/association_basics.html#polymorphic-associations">polymorphic ActiveRecords</a>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">Note</span> <span class="o">&lt;</span> <span class="no">ApplicationRecord</span>
+  <span class="n">belongs_to</span> <span class="ss">:notable</span><span class="p">,</span> <span class="ss">polymorphic: </span><span class="kp">true</span>
+<span class="k">end</span>
+<span class="k">class</span> <span class="nc">Employee</span> <span class="o">&lt;</span> <span class="no">ApplicationRecord</span>
+  <span class="n">has_many</span> <span class="ss">:notes</span><span class="p">,</span> <span class="ss">as: :notable</span>
+<span class="k">end</span>
+<span class="k">class</span> <span class="nc">Department</span> <span class="o">&lt;</span> <span class="no">ApplicationRecord</span>
+  <span class="n">has_many</span> <span class="ss">:notes</span><span class="p">,</span> <span class="ss">as: :notable</span>
+<span class="k">end</span>
+<span class="k">class</span> <span class="nc">Team</span> <span class="o">&lt;</span> <span class="no">ApplicationRecord</span>
+  <span class="n">has_many</span> <span class="ss">:notes</span><span class="p">,</span> <span class="ss">as: :notable</span>
+<span class="k">end</span></code></pre></figure>
+  <p>By <code class="language-plaintext highlighter-rouge">ActiveRecord</code> convention, the <code class="language-plaintext highlighter-rouge">notes</code> table would have columns
+<code class="language-plaintext highlighter-rouge">notable_id</code> and <code class="language-plaintext highlighter-rouge">notable_type</code>.</p>
+  <p>Graphiti has the same concept. In this case we would group all the notes
+by a given <code class="language-plaintext highlighter-rouge">notable_type</code>, and follow a different <code class="language-plaintext highlighter-rouge">belongs_to</code>
+association for each group:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># app/resources/note_resource.rb</span>
+<span class="n">polymorphic_belongs_to</span> <span class="ss">:notable</span> <span class="k">do</span>
+  <span class="n">group_by</span><span class="p">(</span><span class="ss">:notable_type</span><span class="p">)</span> <span class="k">do</span>
+    <span class="n">on</span><span class="p">(</span><span class="ss">:Employee</span><span class="p">)</span>
+    <span class="n">on</span><span class="p">(</span><span class="ss">:Department</span><span class="p">)</span>
+    <span class="n">on</span><span class="p">(</span><span class="ss">:Team</span><span class="p">)</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+  <p>The <code class="language-plaintext highlighter-rouge">on</code> DSL is shorthand for a <code class="language-plaintext highlighter-rouge">belongs_to</code> relationship that accepts
+all the usual options and customizations:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">on</span><span class="p">(</span><span class="ss">:Employee</span><span class="p">).</span><span class="nf">belongs_to</span> <span class="ss">:employee</span><span class="p">,</span>
+  <span class="ss">resource: </span><span class="no">EmployeeResource</span>
+  <span class="c1"># ... etc ...</span></code></pre></figure>
+  <p>In other words: group all Notes by <code class="language-plaintext highlighter-rouge">notable_type</code>, and for all that have
+the value of <code class="language-plaintext highlighter-rouge">"Employee"</code> use the <code class="language-plaintext highlighter-rouge">belongs_to :employee</code> relationship
+for further querying.</p>
+<a class="anchor" id="polymorphic-has-many" />
+  <a class="header" href="#polymorphic-has-many">
+    <h4>
+      5.8 polymorphic_has_many
+    </h4>
+  </a>
+  <p>Continuing from the prior section, the corresponding association of a
+<code class="language-plaintext highlighter-rouge">polymorphic_belongs_to</code> is a <code class="language-plaintext highlighter-rouge">polymorphic_has_many</code>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">EmployeeResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="n">polymorphic_has_many</span> <span class="ss">:notes</span><span class="p">,</span> <span class="ss">as: :notable</span>
+<span class="k">end</span></code></pre></figure>
+  <p>Predictably, this causes the query:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="no">NoteResource</span><span class="p">.</span><span class="nf">all</span><span class="p">({</span>
+  <span class="ss">filter: </span><span class="p">{</span>
+    <span class="ss">notable_type: </span><span class="s1">'Employee'</span><span class="p">,</span>
+    <span class="ss">notable_id: </span><span class="n">employee_ids</span>
+  <span class="p">}</span>
+<span class="p">})</span></code></pre></figure>
+  <p>And the Link</p>
+  <p><code class="language-plaintext highlighter-rouge">/notes?filter[notable_id]=1,2,3&amp;filter[notable_type]=Employee</code></p>
+  <p>Which means the following filters are required:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">NoteResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="n">attribute</span> <span class="ss">:notable_id</span><span class="p">,</span> <span class="ss">:integer</span><span class="p">,</span> <span class="ss">only: </span><span class="p">[</span><span class="ss">:filterable</span><span class="p">]</span>
+  <span class="n">attribute</span> <span class="ss">:notable_type</span><span class="p">,</span> <span class="ss">:string</span><span class="p">,</span> <span class="ss">only: </span><span class="p">[</span><span class="ss">:filterable</span><span class="p">]</span>
+  <span class="c1"># ... code ...</span>
+<span class="k">end</span></code></pre></figure>
+<a class="anchor" id="generators" />
+  <a class="header" href="#generators">
+    <h2>
+      6 Generators
+    </h2>
+  </a>
+  <p>To generate a Resource:</p>
+  <figure class="highlight"><pre><code class="language-bash" data-lang="bash"><span class="nv">$ </span>rails generate graphiti:resource NAME <span class="o">[</span>attribute:type] <span class="o">[</span>options]</code></pre></figure>
+  <p>For example:</p>
+  <figure class="highlight"><pre><code class="language-bash" data-lang="bash"><span class="nv">$ </span>rails generate graphiti:resource Employee first_name:string age:integer</code></pre></figure>
+  <p>Will add a route, controller, resource, and tests.</p>
+  <p>Limit the actions this resource supports with <code class="language-plaintext highlighter-rouge">-a</code>:</p>
+  <figure class="highlight"><pre><code class="language-bash" data-lang="bash"><span class="nv">$ </span>rails generate graphiti:resource Employee <span class="nt">-a</span> index show</code></pre></figure>
+<a class="anchor" id="persisting" />
+  <a class="header" href="#persisting">
+    <h2>
+      7 Persisting
+    </h2>
+  </a>
+  <p>Graphiti allows writing a graph of data in a single request. We’ll do
+the work of parsing the graph and ordering operations, so you can focus
+on the part you care about: the logic for actually persisting an object.</p>
+  <p>By default, persistence operations are handled by your adapter. The
+“expanded” view of the ActiveRecord implementation is below:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># app/resources/employee_resource.rb</span>
+<span class="k">def</span> <span class="nf">create</span><span class="p">(</span><span class="n">attributes</span><span class="p">)</span>
+  <span class="n">employee</span> <span class="o">=</span> <span class="no">Employee</span><span class="p">.</span><span class="nf">new</span>
+  <span class="n">attributes</span><span class="p">.</span><span class="nf">each_pair</span> <span class="k">do</span> <span class="o">|</span><span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+    <span class="n">employee</span><span class="p">.</span><span class="nf">send</span><span class="p">(</span><span class="ss">:"</span><span class="si">#{</span><span class="n">key</span><span class="si">}</span><span class="ss">="</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
+  <span class="k">end</span>
+  <span class="n">employee</span><span class="p">.</span><span class="nf">save</span>
+  <span class="n">employee</span>
+<span class="k">end</span>
+<span class="k">def</span> <span class="nf">update</span><span class="p">(</span><span class="n">attributes</span><span class="p">)</span>
+  <span class="n">employee</span> <span class="o">=</span> <span class="no">EmployeeResource</span><span class="p">.</span><span class="nf">find</span><span class="p">(</span><span class="n">attributes</span><span class="p">.</span><span class="nf">delete</span><span class="p">(</span><span class="ss">:id</span><span class="p">)).</span><span class="nf">data</span>
+  <span class="n">attributes</span><span class="p">.</span><span class="nf">each_pair</span> <span class="k">do</span> <span class="o">|</span><span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+    <span class="n">employee</span><span class="p">.</span><span class="nf">send</span><span class="p">(</span><span class="ss">:"</span><span class="si">#{</span><span class="n">key</span><span class="si">}</span><span class="ss">="</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
+  <span class="k">end</span>
+  <span class="n">employee</span><span class="p">.</span><span class="nf">save</span>
+  <span class="n">employee</span>
+<span class="k">end</span>
+<span class="k">def</span> <span class="nf">destroy</span><span class="p">(</span><span class="n">attributes</span><span class="p">)</span>
+  <span class="n">employee</span> <span class="o">=</span> <span class="no">EmployeeResource</span><span class="p">.</span><span class="nf">find</span><span class="p">(</span><span class="n">attributes</span><span class="p">.</span><span class="nf">delete</span><span class="p">(</span><span class="ss">:id</span><span class="p">)).</span><span class="nf">data</span>
+  <span class="n">employee</span><span class="p">.</span><span class="nf">destroy</span>
+  <span class="n">employee</span>
+<span class="k">end</span></code></pre></figure>
+  <ul>
+    <li>You are encouraged <strong>not</strong> to override these directly. Instead, use
+hooks (see next section).</li>
+    <li>We’ll process any <code class="language-plaintext highlighter-rouge">writable: false</code> or guarded attributes prior to
+these methods.</li>
+    <li>After these methods, we’ll check the Model instance for validation
+errors, rolling back the transaction if any Model in the graph is
+invalid.</li>
+    <li>These methods <strong>must return the Model instance</strong>.</li>
+  </ul>
+<a class="anchor" id="persistence-lifecycle-hooks" />
+  <a class="header" href="#persistence-lifecycle-hooks">
+    <h3>
+      7.1 Persistence Lifecycle Hooks
+    </h3>
+  </a>
+  <p>Let’s dive into a persistence request. If you look at the code snippets in
+the prior section, the flow breaks down into 3 steps:</p>
+  <ul>
+    <li>Build or find the model</li>
+    <li>Assign attributes to the model</li>
+    <li>Save</li>
+  </ul>
+  <p>You can hook into each step:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">PostResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="n">before_attributes</span> <span class="k">do</span> <span class="o">|</span><span class="n">attributes</span><span class="o">|</span>
+    <span class="c1"># Before attributes have been assigned to the model</span>
+  <span class="k">end</span>
+  <span class="n">after_attributes</span> <span class="k">do</span> <span class="o">|</span><span class="n">model</span><span class="o">|</span>
+    <span class="c1"># After attributes have been assigned to the model</span>
+  <span class="k">end</span>
+  <span class="n">around_attributes</span> <span class="ss">:do_around_attributes</span>
+  <span class="k">def</span> <span class="nf">do_around_attributes</span><span class="p">(</span><span class="n">attributes</span><span class="p">)</span>
+    <span class="c1"># before</span>
+    <span class="n">model_instance</span> <span class="o">=</span> <span class="k">yield</span> <span class="n">attributes</span>
+    <span class="c1"># after</span>
+  <span class="k">end</span>
+  <span class="n">before_save</span> <span class="k">do</span> <span class="o">|</span><span class="n">model</span><span class="o">|</span>
+    <span class="c1"># After attributes assigned, but before persisting</span>
+  <span class="k">end</span>
+  <span class="n">after_save</span> <span class="k">do</span> <span class="o">|</span><span class="n">model</span><span class="o">|</span>
+    <span class="c1"># After model has been saved</span>
+  <span class="k">end</span>
+  <span class="n">around_save</span> <span class="ss">:do_around_save</span>
+  <span class="k">def</span> <span class="nf">do_around_save</span><span class="p">(</span><span class="n">model</span><span class="p">)</span>
+    <span class="c1"># before</span>
+    <span class="k">yield</span> <span class="n">model</span>
+    <span class="c1"># after</span>
+  <span class="k">end</span>
+  <span class="c1"># This is an *override*</span>
+  <span class="c1"># During #create, build a blank model instance</span>
+  <span class="c1"># By default, we'd call adapter.build(model_class)</span>
+  <span class="k">def</span> <span class="nf">build</span><span class="p">(</span><span class="n">model_class</span><span class="p">)</span>
+    <span class="n">model_class</span><span class="p">.</span><span class="nf">new</span>
+  <span class="k">end</span>
+  <span class="c1"># This is an *override*</span>
+  <span class="c1"># During #create/#update, assign new attributes to the model instance</span>
+  <span class="c1"># By default, we'd call adapter.assign_attributes(model_instance, attributes)</span>
+  <span class="k">def</span> <span class="nf">assign_attributes</span><span class="p">(</span><span class="n">model_instance</span><span class="p">,</span> <span class="n">attributes</span><span class="p">)</span>
+    <span class="n">attributes</span><span class="p">.</span><span class="nf">each_pair</span> <span class="k">do</span> <span class="o">|</span><span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+      <span class="n">model_instance</span><span class="p">.</span><span class="nf">send</span><span class="p">(</span><span class="ss">:"</span><span class="si">#{</span><span class="n">key</span><span class="si">}</span><span class="ss">="</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
+    <span class="k">end</span>
+  <span class="k">end</span>
+  <span class="c1"># This is an *override*</span>
+  <span class="c1"># During #create/#update, actually save the model instance</span>
+  <span class="c1"># By default, we'd call adapter.save(model_instance)</span>
+  <span class="k">def</span> <span class="nf">save</span><span class="p">(</span><span class="n">model_instance</span><span class="p">)</span>
+    <span class="n">model_instance</span><span class="p">.</span><span class="nf">save</span>
+    <span class="n">model_instance</span>
+  <span class="k">end</span>
+  <span class="c1"># This is an *override*</span>
+  <span class="c1"># During #destroy, actually save the model instance</span>
+  <span class="c1"># By default, we'd call adapter.destroy(model_instance)</span>
+  <span class="k">def</span> <span class="nf">delete</span><span class="p">(</span><span class="n">model_instance</span><span class="p">)</span>
+    <span class="n">model_instance</span><span class="p">.</span><span class="nf">destroy</span>
+    <span class="n">model_instance</span>
+  <span class="k">end</span>
+  <span class="c1"># Finally, you may want to hook around *all* the above steps:</span>
+  <span class="c1"># Only applies to #create/#update</span>
+  <span class="n">around_persistence</span> <span class="ss">:do_around_persistence</span>
+  <span class="k">def</span> <span class="nf">do_around_persistence</span><span class="p">(</span><span class="n">attributes</span><span class="p">)</span>
+    <span class="n">attributes</span><span class="p">[</span><span class="ss">:foo</span><span class="p">]</span> <span class="o">=</span> <span class="s1">'bar'</span>
+    <span class="n">model</span> <span class="o">=</span> <span class="k">yield</span> <span class="c1"># build/find, assign attrs, save</span>
+    <span class="n">model</span><span class="p">.</span><span class="nf">update_counter_cache</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+  <ul>
+    <li>All hooks have <code class="language-plaintext highlighter-rouge">only/except</code> options, e.g. <code class="language-plaintext highlighter-rouge">before_attributes only:
+[:update]</code></li>
+    <li>Most hooks can be called with an in-line block, or by passing a method
+name (e.g. <code class="language-plaintext highlighter-rouge">before_attributes :do_something</code>). The exception is
+<code class="language-plaintext highlighter-rouge">around_*</code> hooks, which <em>must</em> be called with a method name.</li>
+  </ul>
+  <p>When persisting multiple objects at once, we’ll open a database
+transaction, process each model individually, ensure all models pass
+validation, then close the transaction. This means that if you raise an
+error at any point, or any model does not pass validations, the
+transaction will be rolled back.</p>
+  <p>You may want to perform an operation after all models have been
+processed and validated, but before the transaction is closed. One
+example is sending an email - you don’t want to send if the models were
+invalid, so <code class="language-plaintext highlighter-rouge">after_save</code> wouldn’t work. And you still want to do it
+<em>within</em> the transaction, so if your email server is down and an error
+is raised the transaction gets rolled back.</p>
+  <p>For this scenario, use <code class="language-plaintext highlighter-rouge">before_commit</code>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">before_commit</span> <span class="k">do</span> <span class="o">|</span><span class="n">model</span><span class="o">|</span>
+  <span class="no">PostMailer</span><span class="p">.</span><span class="nf">with</span><span class="p">(</span><span class="ss">post: </span><span class="n">model</span><span class="p">).</span><span class="nf">some_email</span><span class="p">.</span><span class="nf">deliver</span>
+<span class="k">end</span></code></pre></figure>
+<a class="anchor" id="sideposting" />
+  <a class="header" href="#sideposting">
+    <h3>
+      7.2 Sideposting
+    </h3>
+  </a>
+  <p>The act of persisting multiple Resources in a single request is called
+<strong>Sideposting</strong>. The payload mirrors the <strong>sideloading</strong> payload for
+read operations, with minor additions.</p>
+  <p>Let’s create a Post and associate it to an existing Blog in a single
+request:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># POST /api/v1/posts</span>
+<span class="p">{</span>
+  <span class="ss">type: </span><span class="s1">'posts'</span><span class="p">,</span>
+  <span class="ss">attributes: </span><span class="p">{</span> <span class="ss">title: </span><span class="s1">'My post'</span> <span class="p">},</span>
+  <span class="ss">relationships: </span><span class="p">{</span>
+    <span class="ss">blog: </span><span class="p">{</span>
+      <span class="ss">data: </span><span class="p">{</span>
+        <span class="ss">id: </span><span class="s1">'1'</span><span class="p">,</span>
+        <span class="ss">type: </span><span class="s1">'blogs'</span><span class="p">,</span>
+        <span class="ss">method: </span><span class="s1">'update'</span>
+      <span class="p">}</span>
+    <span class="p">}</span>
+  <span class="p">}</span>
+<span class="p">}</span></code></pre></figure>
+  <p>The critical addition here is the <code class="language-plaintext highlighter-rouge">method</code> key. When we persist RESTful
+Resources, we send a corresponding HTTP verb. This follows the same
+pattern, adding a verb for each Resource in the graph. <code class="language-plaintext highlighter-rouge">method</code> can be
+one of:</p>
+  <ul>
+    <li><code class="language-plaintext highlighter-rouge">create</code></li>
+    <li><code class="language-plaintext highlighter-rouge">update</code></li>
+    <li><code class="language-plaintext highlighter-rouge">destroy</code></li>
+    <li><code class="language-plaintext highlighter-rouge">disassociate</code> (e.g. <code class="language-plaintext highlighter-rouge">null</code> foreign key)</li>
+  </ul>
+  <p>When we sidepost, all objects will be persisted within the same database
+transaction, which rolls back if an error is raised or any objects are invalid.</p>
+<a class="anchor" id="create" />
+  <a class="header" href="#create">
+    <h4>
+      7.2.1 Create
+    </h4>
+  </a>
+  <p>Let’s say we want to create a Post and its Blog in a single request.
+You’ll note that we don’t have the <code class="language-plaintext highlighter-rouge">id</code> key to generate a <a href="http://jsonapi.org/format/#document-resource-identifier-objects">Resource
+Identifier</a> (combination of <code class="language-plaintext highlighter-rouge">id</code> and <code class="language-plaintext highlighter-rouge">type</code>
+that uniquely identifies a Resource).</p>
+  <p>To accomodate this, send an ephemeral <code class="language-plaintext highlighter-rouge">temp-id</code> (any UUID):</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="p">{</span>
+  <span class="c1"># POST /api/v1/posts</span>
+  <span class="p">{</span>
+    <span class="ss">type: </span><span class="s1">'posts'</span><span class="p">,</span>
+    <span class="ss">attributes: </span><span class="p">{</span> <span class="ss">title: </span><span class="s1">'My post'</span> <span class="p">},</span>
+    <span class="ss">relationships: </span><span class="p">{</span>
+      <span class="ss">blog: </span><span class="p">{</span>
+        <span class="ss">data: </span><span class="p">{</span>
+          <span class="ss">:'temp-id'</span> <span class="o">=&gt;</span> <span class="s1">'abc123'</span><span class="p">,</span>
+          <span class="ss">type: </span><span class="s1">'blogs'</span><span class="p">,</span>
+          <span class="ss">method: </span><span class="s1">'create'</span>
+        <span class="p">}</span>
+      <span class="p">}</span>
+    <span class="p">},</span>
+    <span class="ss">included: </span><span class="p">[</span>
+      <span class="p">{</span>
+        <span class="ss">:'temp-id'</span> <span class="o">=&gt;</span> <span class="s1">'abc123'</span>
+        <span class="ss">type: </span><span class="s1">'blogs'</span><span class="p">,</span>
+        <span class="ss">attributes: </span><span class="p">{</span> <span class="ss">name: </span><span class="s1">'New Blog'</span> <span class="p">}</span>
+      <span class="p">}</span>
+    <span class="p">]</span>
+  <span class="p">}</span>
+<span class="p">}</span></code></pre></figure>
+  <p>This random UUID:</p>
+  <ul>
+    <li>Connects relevant sections of the payload.</li>
+    <li>Tells clients how to associate their in-memory objects with the ids returned from the server.</li>
+  </ul>
+<a class="anchor" id="expanded-example" />
+  <a class="header" href="#expanded-example">
+    <h4>
+      7.2.2 Expanded Example
+    </h4>
+  </a>
+  <p>Here we’re updating a Post, changing the name of its associated Blog, creating a Tag, deleting one Comment, and disassociating (<code class="language-plaintext highlighter-rouge">null</code> foreign key) a different Comment, all in a single request:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="p">{</span>
+  <span class="ss">data: </span><span class="p">{</span>
+    <span class="ss">type: </span><span class="s1">'posts'</span><span class="p">,</span>
+    <span class="ss">id: </span><span class="mi">123</span><span class="p">,</span>
+    <span class="ss">attributes: </span><span class="p">{</span> <span class="ss">title: </span><span class="s1">'Updated!'</span> <span class="p">},</span>
+    <span class="ss">relationships: </span><span class="p">{</span>
+      <span class="ss">blog: </span><span class="p">{</span>
+        <span class="ss">data: </span><span class="p">{</span>
+          <span class="ss">type: </span><span class="s1">'blogs'</span><span class="p">,</span>
+          <span class="ss">id: </span><span class="mi">123</span><span class="p">,</span>
+          <span class="ss">method: </span><span class="s1">'update'</span>
+        <span class="p">}</span>
+      <span class="p">},</span>
+      <span class="ss">tags: </span><span class="p">{</span>
+        <span class="ss">data: </span><span class="p">[{</span>
+          <span class="ss">type: </span><span class="s1">'tags'</span><span class="p">,</span>
+          <span class="n">temp</span><span class="o">-</span><span class="ss">id: </span><span class="s1">'s0m3uu1d'</span><span class="p">,</span>
+          <span class="ss">method: </span><span class="s1">'create'</span>
+        <span class="p">}]</span>
+      <span class="p">},</span>
+      <span class="ss">comments: </span><span class="p">{</span>
+        <span class="ss">data: </span><span class="p">[</span>
+          <span class="p">{</span>
+            <span class="ss">type: </span><span class="s1">'comments'</span><span class="p">,</span>
+            <span class="ss">id: </span><span class="s1">'123'</span><span class="p">,</span>
+            <span class="ss">method: </span><span class="s1">'destroy'</span>
+          <span class="p">},</span>
+          <span class="p">{</span>
+            <span class="ss">type: </span><span class="s1">'comments'</span><span class="p">,</span>
+            <span class="ss">id: </span><span class="s1">'456'</span><span class="p">,</span>
+            <span class="ss">method: </span><span class="s1">'disassociate'</span>
+          <span class="p">}</span>
+        <span class="p">]</span>
+      <span class="p">}</span>
+    <span class="p">}</span>
+  <span class="p">},</span>
+  <span class="ss">included: </span><span class="p">[</span>
+    <span class="p">{</span>
+      <span class="ss">type: </span><span class="s1">'tags'</span><span class="p">,</span>
+      <span class="ss">:'temp-id'</span> <span class="o">=&gt;</span> <span class="s1">'s0m3uu1d'</span><span class="p">,</span>
+      <span class="ss">attributes: </span><span class="p">{</span> <span class="ss">name: </span><span class="s1">'Important'</span> <span class="p">}</span>
+    <span class="p">},</span>
+    <span class="p">{</span>
+      <span class="ss">type: </span><span class="s1">'blogs'</span><span class="p">,</span>
+      <span class="ss">id: </span><span class="o">=&gt;</span> <span class="s1">'123'</span><span class="p">,</span>
+      <span class="ss">attributes: </span><span class="p">{</span> <span class="ss">name: </span><span class="s1">'Updated!'</span> <span class="p">}</span>
+    <span class="p">}</span>
+  <span class="p">]</span>
+<span class="p">}</span></code></pre></figure>
+<a class="anchor" id="validation-errors" />
+  <a class="header" href="#validation-errors">
+    <h3>
+      7.3 Validation Errors
+    </h3>
+  </a>
+  <p>When a persistence operation is attempted but the corresponding Resource
+is invalid, the transaction will be rolled back and an <a href="http://jsonapi.org/format/#errors">errors payload</a> will be returned
+with a <code class="language-plaintext highlighter-rouge">422</code> response code:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="p">{</span>
+  <span class="ss">errors: </span><span class="p">[{</span>
+    <span class="ss">code:  </span><span class="s1">'unprocessable_entity'</span><span class="p">,</span>
+    <span class="ss">status: </span><span class="s1">'422'</span><span class="p">,</span>
+    <span class="ss">title: </span><span class="s2">"Validation Error"</span><span class="p">,</span>
+    <span class="ss">detail: </span><span class="s2">"Title can't be blank"</span><span class="p">,</span>
+    <span class="ss">source: </span><span class="p">{</span> <span class="ss">pointer: </span><span class="s1">'/data/attributes/title'</span> <span class="p">},</span>
+    <span class="ss">meta: </span><span class="p">{</span>
+      <span class="ss">attribute: :title</span><span class="p">,</span>
+      <span class="ss">message: </span><span class="s2">"can't be blank"</span><span class="p">,</span>
+      <span class="ss">code: :blank</span>
+    <span class="p">}</span>
+  <span class="p">}]</span>
+<span class="p">}</span></code></pre></figure>
+  <p>To get this functionality, your Model must adhere to the
+<a href="https://api.rubyonrails.org/classes/ActiveModel/Validations.html">ActiveModel::Validations API</a>.</p>
+  <p>You get this for free with ActiveRecord, or it can be mixed in to any
+PORO:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">Post</span>
+  <span class="kp">include</span> <span class="no">ActiveModel</span><span class="o">::</span><span class="no">Validations</span>
+  <span class="n">validates</span> <span class="ss">:title</span><span class="p">,</span> <span class="ss">presence: </span><span class="kp">true</span>
+<span class="k">end</span></code></pre></figure>
+  <p>Errors on associations will have a slightly expanded payload:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="p">{</span>
+  <span class="ss">errors: </span><span class="p">[{</span>
+    <span class="ss">code: </span><span class="s1">'unprocessable_entity'</span><span class="p">,</span>
+    <span class="ss">status: </span><span class="s1">'422'</span><span class="p">,</span>
+    <span class="ss">title: </span><span class="s1">'Validation Error'</span><span class="p">,</span>
+    <span class="ss">detail: </span><span class="s2">"Name can't be blank"</span><span class="p">,</span>
+    <span class="ss">source: </span><span class="p">{</span> <span class="ss">pointer: </span><span class="s1">'/data/attributes/name'</span> <span class="p">},</span>
+    <span class="ss">meta: </span><span class="p">{</span>
+      <span class="ss">relationship: </span><span class="p">{</span>
+        <span class="ss">attribute: :name</span><span class="p">,</span>
+        <span class="ss">message: </span><span class="s2">"can't be blank"</span><span class="p">,</span>
+        <span class="ss">code: :blank</span><span class="p">,</span>
+        <span class="ss">name: :pets</span><span class="p">,</span>
+        <span class="ss">id: </span><span class="s1">'444'</span><span class="p">,</span>
+        <span class="ss">type: </span><span class="s1">'pets'</span>
+      <span class="p">}</span>
+    <span class="p">}</span>
+  <span class="p">}]</span>
+<span class="p">}</span></code></pre></figure>
+  <p>When <a href="#sideposting">Sideposting</a>, the errors payload will contain all
+invalid Resources in the graph.</p>
+<a class="anchor" id="read-on-write" />
+  <a class="header" href="#read-on-write">
+    <h2>
+      7.4 Read on Write
+    </h2>
+  </a>
+  <p>By default, the response of a persistence operation will mirror your
+request. But sometimes you need control over the response. The most
+common scenario is sideloading an additional entity - imagine creating
+an order, and wanting the order’s shipping information to come back in
+the response.</p>
+  <p>You can do this by POSTing the payload as normal, but adding query
+parameters to the URL:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># POST /api/v1/orders?include=shipping_information</span>
+<span class="p">{</span>
+  <span class="ss">type: </span><span class="s1">'orders'</span><span class="p">,</span>
+  <span class="ss">attributes: </span><span class="p">{</span> <span class="o">...</span> <span class="p">}</span>
+<span class="p">}</span></code></pre></figure>
+  <p>This will sideload the shipping information in the response. When using
+<a href="/1.13/js/index">Spraypaint</a>, do this with:</p>
+  <figure class="highlight"><pre><code class="language-typescript" data-lang="typescript"><span class="nx">order</span><span class="p">.</span><span class="nf">save</span><span class="p">({</span> <span class="na">returnScope</span><span class="p">:</span> <span class="nx">Order</span><span class="p">.</span><span class="nf">includes</span><span class="p">(</span><span class="dl">'</span><span class="s1">shipping_information</span><span class="dl">'</span><span class="p">)</span> <span class="p">})</span></code></pre></figure>
+<a class="anchor" id="context" />
+  <a class="header" href="#context">
+    <h2>
+      8 Context
+    </h2>
+  </a>
+  <p>All resources have access to <code class="language-plaintext highlighter-rouge">#context</code>. If you’re using Rails,
+<code class="language-plaintext highlighter-rouge">context</code> is the controller instance processing the request.</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># app/resources/post_resource.rb</span>
+<span class="n">attribute</span> <span class="ss">:active</span><span class="p">,</span> <span class="ss">:boolean</span><span class="p">,</span> <span class="ss">writable: :admin?</span>
+<span class="k">def</span> <span class="nf">admin?</span>
+  <span class="n">context</span><span class="p">.</span><span class="nf">current_user</span><span class="p">.</span><span class="nf">admin?</span>
+<span class="k">end</span></code></pre></figure>
+  <p>Because <code class="language-plaintext highlighter-rouge">current_user</code> is so common, we recommend putting this in
+<code class="language-plaintext highlighter-rouge">ApplicationResource</code>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># app/resources/application_resource.rb</span>
+<span class="k">class</span> <span class="nc">ApplicationResource</span> <span class="o">&lt;</span> <span class="no">Graphiti</span><span class="o">::</span><span class="no">Resource</span>
+  <span class="c1"># ... code ...</span>
+  <span class="k">def</span> <span class="nf">current_user</span>
+    <span class="n">context</span><span class="p">.</span><span class="nf">current_user</span>
+  <span class="k">end</span>
+<span class="k">end</span>
+<span class="c1"># app/resources/post_resource.rb</span>
+<span class="k">class</span> <span class="nc">PostResource</span> <span class="o">&lt;</span> <span class="no">ApplicationResource</span>
+  <span class="c1"># ... code ...</span>
+  <span class="k">def</span> <span class="nf">admin?</span>
+    <span class="n">current_user</span><span class="p">.</span><span class="nf">admin?</span>
+  <span class="k">end</span>
+<span class="k">end</span></code></pre></figure>
+  <p>You can manually set context with <code class="language-plaintext highlighter-rouge">with_context</code>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">ctx</span> <span class="o">=</span> <span class="no">OpenStruct</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="ss">current_user: </span><span class="no">User</span><span class="p">.</span><span class="nf">first</span><span class="p">)</span>
+<span class="no">Graphiti</span><span class="p">.</span><span class="nf">with_context</span><span class="p">(</span><span class="n">ctx</span><span class="p">)</span> <span class="k">do</span>
+  <span class="c1"># current_user == ctx.current_user</span>
+  <span class="no">PostResource</span><span class="p">.</span><span class="nf">all</span>
+<span class="k">end</span></code></pre></figure>
+<a class="anchor" id="concurrency" />
+  <a class="header" href="#concurrency">
+    <h2>
+      9 Concurrency
+    </h2>
+  </a>
+  <p>By default when using Rails, Graphiti will turn on concurrency when <code class="language-plaintext highlighter-rouge">::Rails.application.config.cache_classes</code> is <code class="language-plaintext highlighter-rouge">true</code> (the default for staging and production environments). This will cause sibling sideloads to load concurrently. If a <code class="language-plaintext highlighter-rouge">Post</code> is sideloading <code class="language-plaintext highlighter-rouge">Comments</code> and <code class="language-plaintext highlighter-rouge">Author</code>, we’ll load both of those at the same time.</p>
+  <p>You can turn on/off this behavior explicitly:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="c1"># config/intializers/graphiti.rb</span>
+<span class="no">Graphiti</span><span class="p">.</span><span class="nf">configure</span> <span class="k">do</span> <span class="o">|</span><span class="n">c</span><span class="o">|</span>
+  <span class="n">c</span><span class="p">.</span><span class="nf">concurrency</span> <span class="o">=</span> <span class="kp">false</span>
+<span class="k">end</span></code></pre></figure>
+  <p><strong>NOTE</strong>: Since this kicks off a new Thread, thread locals will be dropped. So if your code refers to <code class="language-plaintext highlighter-rouge">Thread.current[:foo]</code> you should set and get that on <code class="language-plaintext highlighter-rouge">Graphiti.context</code>:</p>
+  <figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="c1"># BAD:</span>
+<span class="no">Thread</span><span class="p">.</span><span class="nf">current</span><span class="p">[</span><span class="ss">:foo</span><span class="p">]</span> <span class="o">=</span> <span class="s2">"bar"</span>
+<span class="no">Thread</span><span class="p">.</span><span class="nf">current</span><span class="p">[</span><span class="ss">:foo</span><span class="p">]</span> <span class="c1"># =&gt; will be nil when sideloading!</span>
+ <span class="c1"># GOOD:</span>
+<span class="no">Graphiti</span><span class="p">.</span><span class="nf">context</span><span class="p">[</span><span class="ss">:foo</span><span class="p">]</span> <span class="o">=</span> <span class="s2">"bar"</span>
+<span class="no">Graphiti</span><span class="p">.</span><span class="nf">context</span><span class="p">[</span><span class="ss">:foo</span><span class="p">]</span> <span class="c1"># =&gt; "bar", even when sideloading</span></code></pre></figure>
+<a class="anchor" id="adapters" />
+  <a class="header" href="#adapters">
+    <h2>
+      10 Adapters
+    </h2>
+  </a>
+  <p>Common resource overrides can be packaged into an Adapter for code
+re-use. The most common example is using a different client/datastore
+than ActiveRecord/RelationalDB.</p>
+  <p><a href="/1.13/cookbooks/without-activerecord">Adapters are best explained in our ‘Without ActiveRecord’
+Cookbook</a>.</p>
+  <p><br />
+<br /></p>
+</div>
+        </div>
+      </div>
+    </main>
+    <div class="main-footer main-footer--dark">
+  <div class="container">
+    <div class="row">
+      <div class="col-sm-4 menu">
+        <h3>Overview</h3>
+        <ul>
+          <li>
+            <a href="/1.13/quickstart">Quickstart</a>
+          </li>
+          <li>
+            <a href="/1.13/tutorial">Tutorial</a>
+          </li>
+          <li>
+            <a href="/1.13/guides">Guides</a>
+          </li>
+        </ul>
+      </div>
+      <div class="col-sm-4 menu">
+        <h3>Contact</h3>
+        <ul>
+          <li>
+            <a target="_blank" href="https://discord.gg/wgqkMBsSRV">Discord Chat</a>
+          </li>
+          <li>
+            <a href="mailto:richmolj@gmail.com">Email</a>
+          </li>
+        </ul>
+      </div>
+      <div class="col-sm-4 menu">
+        <h3>Related</h3>
+        <ul>
+          <li>
+            <a target="_blank" href="http://jsonapi.org">JSONAPI Spec</a>
+          </li>
+          <li>
+            <a target="_blank" href="http://jsonapi-rb.org">jsonapi-rb</a>
+          </li>
+          <li>
+            <a target="_blank" href="https://vuejs.org/">VueJS</a>
+          </li>
+        </ul>
+      </div>
+    </div>
+  </div>
+</div>
+    <script type="text/javascript">
+$(function () {
+  var flipTabs = function() {
+    var isTS = true;
+    if (localStorage.getItem('js-lang') === 'javascript') {
+      isTS = false;
+    }
+    $('.code-tabs').each(function(index, el) {
+      if (isTS) {
+        console.log('hiding js');
+        $($(el).children()[1]).hide();
+        $($(el).children()[0]).show();
+      } else {
+        console.log('hiding ts');
+        $($(el).children()[0]).hide();
+        $($(el).children()[1]).show();
+      }
+    });
+    if (isTS) {
+      $('.tab.typescript').addClass('active');
+      $('.tab.javascript').removeClass('active');
+    } else {
+      $('.tab.typescript').removeClass('active');
+      $('.tab.javascript').addClass('active');
+    }
+  }
+  $('.tab').click(function() {
+    if ($(this).hasClass('typescript')) {
+      localStorage.setItem('js-lang', 'typescript');
+    } else {
+      localStorage.setItem('js-lang', 'javascript');
+    }
+    flipTabs();
+  });
+  flipTabs();
+})
+</script>
+  </body>
+</html>