graphiti 2.0.0.beta.7 → 2.0.0.beta.9

data/docs/upgrading.md

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

data/website/.gitignore

@@ -1,20 +0,0 @@
-# Dependencies
-/node_modules
-
-# Production
-/build
-
-# Generated files
-.docusaurus
-.cache-loader
-
-# Misc
-.DS_Store
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
-
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*

data/website/README.md

@@ -1,43 +0,0 @@
-# Website
-
-This website is built using [Docusaurus](https://docusaurus.io/), a modern static website generator.
-
-## Installation
-
-```bash
-npm install
-```
-
-**Note**: feel free to use the package manager of your choice.
-
-## Local Development
-
-```bash
-npm run start
-```
-
-This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server.
-
-## Build
-
-```bash
-npm run build
-```
-
-This command generates static content into the `build` directory and can be served using any static contents hosting service.
-
-## Deployment
-
-Using SSH:
-
-```bash
-USE_SSH=true npm run deploy
-```
-
-Not using SSH:
-
-```bash
-GIT_USER=<Your GitHub username> npm run deploy
-```
-
-If you are using GitHub Pages for hosting, this command is a convenient way to build the website and push to the `gh-pages` branch.

data/website/docusaurus.config.js

@@ -1,197 +0,0 @@
-// @ts-check
-const {themes} = require('prism-react-renderer');
-
-const codeBlockTheme = (theme, backgroundColor) => ({
-  ...theme,
-  plain: {...theme.plain, backgroundColor},
-});
-
-// Docusaurus prepends baseUrl to navbar and Link hrefs, but not to raw HTML
-// like announcementBar content, so that markup has to build its own absolute
-// paths. Always has a trailing slash.
-const baseUrl = process.env.DOCS_BASE_URL || '/';
-
-// The theme's strikethrough and underline on diff lines are inline styles, so
-// CSS cannot undo them. Colour and the +/- signs already carry it.
-const withoutDiffDecoration = (theme) => ({
-  ...theme,
-  styles: theme.styles.map(({types, style}) =>
-    types.some((type) => type === 'inserted' || type === 'deleted')
-      ? {types, style: {...style, textDecorationLine: undefined}}
-      : {types, style}
-  ),
-});
-
-/** @type {import('@docusaurus/types').Config} */
-const config = {
-  title: 'Graphiti',
-  tagline: 'Stylish Graph APIs',
-  favicon: 'img/favicon.ico',
-
-  // Apex, matching the CNAME. This feeds canonical tags and sitemap.xml, so it
-  // has to agree with the host actually serving the site or the two split
-  // search ranking between them.
-  url: 'https://graphiti.dev',
-  // graphiti.dev resolves to this repo, so the site serves from the root.
-  // DOCS_BASE_URL still overrides it for a build served from the project-pages
-  // path, which is what /graphiti/ was during the beta.
-  baseUrl,
-  organizationName: 'graphiti-api',
-  projectName: 'graphiti',
-
-  onBrokenLinks: 'warn',
-  markdown: {hooks: {onBrokenMarkdownLinks: 'warn'}},
-
-  presets: [
-    [
-      'classic',
-      /** @type {import('@docusaurus/preset-classic').Options} */
-      ({
-        docs: {
-          // markdown lives at the repo root, next to the code it documents
-          path: '../docs',
-          routeBasePath: '/',
-          sidebarPath: require.resolve('./sidebars.js'),
-          editUrl: 'https://github.com/graphiti-api/graphiti/tree/main/website/',
-          // Unversioned docs serve at the root, and would otherwise be
-          // labelled "Next" in the dropdown. Once `npm run docusaurus
-          // docs:version 2.0` cuts a version, that becomes the root and the
-          // working copy moves to /next.
-          versions: {current: {label: '2.0 beta'}},
-        },
-        blog: false,
-        theme: {customCss: require.resolve('./src/css/custom.css')},
-      }),
-    ],
-  ],
-
-  plugins: [
-    [
-      '@docusaurus/plugin-client-redirects',
-      {
-        // The 1.x Jekyll site served /guides/* and /cookbooks/*, and early 2.0
-        // drafts served /quickstart and /cheatsheet. Keep those URLs alive.
-        // Nothing under /1.13/ is touched: that is the frozen 1.x site.
-        redirects: [
-          {from: ['/quickstart'], to: '/getting-started/first-api'},
-          {from: ['/cheatsheet', '/guides', '/guides/index'], to: '/'},
-          {from: ['/guides/overview'], to: '/concepts/overview'},
-          {from: ['/guides/why'], to: '/reference/why'},
-          {from: ['/guides/vandal'], to: '/reference/vandal'},
-          {from: ['/guides/upgrading', '/guides/upgrading-2-0', '/reference/upgrading-2-0', '/upgrading/controllers', '/upgrading/testing', '/upgrading/persistence-hooks', '/upgrading/exception-handling', '/upgrading/belongs-to-linkage', '/upgrading/without-rails'], to: '/upgrading'},
-          {from: ['/guides/getting-started/installation'], to: '/getting-started/installation'},
-
-          {from: ['/guides/concepts/resources'], to: '/concepts/resources'},
-          {from: ['/guides/concepts/endpoints'], to: '/concepts/endpoints'},
-          {from: ['/guides/concepts/links'], to: '/concepts/links'},
-          {from: ['/guides/concepts/backends-and-models'], to: '/concepts/backends-and-models'},
-          {from: ['/guides/concepts/testing'], to: '/topics/testing'},
-          {from: ['/guides/concepts/debugging'], to: '/topics/debugging'},
-          {from: ['/guides/concepts/error-handling'], to: '/topics/error-handling'},
-          {from: ['/guides/concepts/remote-resources', '/cookbooks/remote-resources'], to: '/topics/remote-resources'},
-
-          // Cookbook stubs that never had content now point at the real pages
-          {from: ['/cookbooks/authorization'], to: '/topics/authorization'},
-          {from: ['/cookbooks/caching'], to: '/topics/caching'},
-          {from: ['/cookbooks/etags'], to: '/topics/etags'},
-          {from: ['/cookbooks/json_attributes'], to: '/topics/json-attributes'},
-          {from: ['/cookbooks/openstruct-models'], to: '/topics/openstruct-models'},
-          {from: ['/cookbooks/without-activerecord'], to: '/topics/without-activerecord'},
-          {from: ['/cookbooks/customizing-sideloads'], to: '/topics/customizing-sideloads'},
-          {from: ['/cookbooks/hopping-relationships'], to: '/topics/hopping-relationships'},
-
-          {from: ['/js/introduction'], to: '/js/'},
-          {
-            from: [
-              '/js/reads/index',
-              '/js/reads/filtering',
-              '/js/reads/sorting',
-              '/js/reads/pagination',
-              '/js/reads/fieldsets',
-              '/js/reads/includes',
-              '/js/reads/nested-queries',
-              '/js/reads/statistics',
-            ],
-            to: '/js/reads',
-          },
-          {
-            from: [
-              '/js/writes/index',
-              '/js/writes/validations',
-              '/js/writes/dirty-tracking',
-              '/js/writes/nested',
-              '/js/writes/deferred',
-            ],
-            to: '/js/writes',
-          },
-        ],
-
-        // The 2.0 docs were staged under /graphiti/ for the whole beta, so
-        // those URLs are in the wild. createRedirects sees every generated
-        // route, which the static /1.13/ tree is not: that one is by hand.
-        createRedirects(existingPath) {
-          return [`/graphiti${existingPath}`];
-        },
-      },
-    ],
-  ],
-
-  themeConfig: {
-    announcementBar: {
-      // Changing the id un-dismisses the bar for everyone who has closed it.
-      id: 'graphiti-2-0-beta',
-      content: `Graphiti 2.0 is in beta, and the docs have been reorganized to describe it. <a href="${baseUrl}1.13/">Docs for 1.x</a>.`,
-      isCloseable: true,
-    },
-    colorMode: {
-      // Dark for a first-time visitor. Flip respectPrefersColorScheme to true
-      // to follow the OS setting instead, in which case defaultMode only
-      // applies when the visitor has no preference either way. Once someone
-      // uses the navbar toggle their choice is remembered and wins over both.
-      defaultMode: 'dark',
-      respectPrefersColorScheme: false,
-    },
-    navbar: {
-      title: 'Graphiti',
-      logo: {alt: 'Graphiti', src: 'img/logo.png'},
-      items: [
-        {
-          type: 'docsVersionDropdown',
-          position: 'right',
-          // 1.x stays as the original Jekyll site, frozen under /1.13.
-          //
-          // The pathname:// prefix is required. It is Docusaurus' escape hatch
-          // for a path that is served statically but is not an app route:
-          // without it the link renders as a react-router push, which finds no
-          // match and shows the 404 page even though the file is served fine.
-          // The prefix is stripped before baseUrl is applied, and it also makes
-          // the link count as external, hence target '_self' to keep it from
-          // opening in a new tab.
-          dropdownItemsAfter: [
-            {href: 'pathname:///1.13/', label: '1.x', target: '_self'},
-          ],
-        },
-        {href: 'https://github.com/graphiti-api/graphiti', label: 'GitHub', position: 'right'},
-        {href: 'https://discord.gg/wgqkMBsSRV', label: 'Discord', position: 'right'},
-      ],
-    },
-    footer: {
-      style: 'dark',
-      copyright: [
-        'Originally created by <a href="https://github.com/richmolj">Lee Richmond</a>,',
-        '<a href="https://github.com/wadetandy">Wade Tandy</a>, and',
-        '<a href="https://github.com/wagenet">Peter Wagenet</a>.',
-        'Maintained by <a href="https://github.com/jkeen">Jeff Keen</a>',
-        'with <a href="https://github.com/graphiti-api/graphiti/graphs/contributors">many contributors</a>.',
-        '<br />Graphiti is released under the MIT license.',
-      ].join(' '),
-    },
-    prism: {
-      theme: withoutDiffDecoration(themes.oneLight),
-      darkTheme: withoutDiffDecoration(codeBlockTheme(themes.oneDark, '#21252b')),
-      additionalLanguages: ['ruby', 'bash', 'json', 'http', 'diff'],
-    },
-  },
-};
-
-module.exports = config;