react-email-rails 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52da00b9618d5b217b66af2598edf2a25fa9d0850447bfc95d8637c778837583
-  data.tar.gz: 84bcdbd09672b293b85d65bbde9779c0d0d2c2c282dd83e72cc2412d38150c6b
+  metadata.gz: 05b64507c82feabb25781eaec8487c5e7282f65060abbac88719bfb2bc79d499
+  data.tar.gz: fc1f7fe4d40195537b5218818aa0fb8b72be78834238223dc377c52f7843af15
 SHA512:
-  metadata.gz: b9ce2a8643e90776bee1f37c9758fd9d853465d37b73184e0ebdeb20a87e33d9d686354b1a8256cb3bb4887221d25b7c14c9b6733d905c04e86f3fa2d1e06cc7
-  data.tar.gz: 1257c29d6639ed5a1559d23d64316bea2c6ccf075b365e816dc0bfd41cb996003e466dbabe97bc50aa9b736e2a45e81e083cd908791f91d8d94f13b239e65f67
+  metadata.gz: 61afe5bf3fc51e550ca9608bd91deeeb9794cd4a90bac53a7bf0fb48f2f12f5984f50dadbbd245c05e34d8dc4ab7c478f2ff8420aa94e9f57c98e39fb04bab01
+  data.tar.gz: 992fd9253d2a2cf31f9ecd37f7bd960c52efddaf74541aefa5ed124ebef4941d9404c00d7f417a6cc2d36f998d3391d8f1bf3ec3d865ec232c43c5a2df2ed4c1

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.4.1
+
+- `ReactEmailRails.parse` now neutralizes unsafe link/button URI schemes: hrefs whose scheme is not `http`, `https`, `mailto`, or `tel` (e.g. `javascript:`/`data:`) are blanked before they reach the document `Hash`. Scheme detection ignores the whitespace and control characters browsers strip when resolving a scheme, so case- and whitespace-obfuscated payloads are caught too.
+
+## 0.4.0
+
+- `ReactEmailRails.parse` now accepts `markdown:` as an alternative to `html:`. Markdown is converted to HTML and runs through the same extension-driven parse path, producing the same document `Hash` — handy for agent- or tool-generated content. Pass exactly one of `html:`/`markdown:`.
+- Add `marked` as an optional peer dependency, required only when calling `parse` with `markdown:`. HTML parsing and compose-only rendering do not require it.
+
 ## 0.3.0
 
 - Add `ReactEmailRails.parse` to convert semantic HTML into a canonical `@react-email/editor` document using a renderer's extensions.

data/README.md

@@ -1,8 +1,8 @@
-![React Email + Rails](react-email-rails.png)
+![react-email-rails](react-email-rails.png)
 
-# React Email + Rails
+# react-email-rails
 
-Build and send emails using React and Rails — a seamless integration between [React Email](https://react.email) and [Action Mailer](https://guides.rubyonrails.org/action_mailer_basics.html).
+Build and send emails using React and Rails with [React Email](https://react.email) and [Action Mailer](https://guides.rubyonrails.org/action_mailer_basics.html).
 
 ## Contents
 
@@ -12,7 +12,6 @@ Build and send emails using React and Rails — a seamless integration between [
 - [Requirements](#requirements)
 - [Quick Start](#quick-start)
 - [Usage](#usage)
-- [Editor](#editor)
 - [Configuration](#configuration)
 - [Deployment](#deployment)
 - [Development](#development)
@@ -22,15 +21,15 @@ Build and send emails using React and Rails — a seamless integration between [
 
 ## Why
 
-Building HTML emails is painfully archaic. [React Email](https://react.email) is a collection of unstyled components for building emails with React, Tailwind, and TypeScript. This gem brings that power directly into your Rails app. Write emails as React components, send them through Action Mailer, and recipients get automatically generated HTML and text emails.
+Building HTML emails is painfully archaic. [React Email](https://react.email) brings React, Tailwind, and TypeScript to email templates. This gem wires it into Action Mailer so React components deliver as generated HTML and text emails.
 
 ## How
 
 **In development,** the gem renders components live through Vite's dev pipeline, so your emails get the same module resolution and transforms as the rest of your frontend.
 
-**In production,** Rails builds a server-side email bundle during `assets:precompile`. The bundled rake task runs an isolated email-only Vite build, using `reactEmailRails()` in your app's Vite config for discovery and options.
+**In production,** Rails builds a server-side renderer bundle during `assets:precompile` using `reactEmailRails()` in your Vite config for discovery and options.
 
-React Email Rails automatically renders both HTML and plain-text versions from the same component. Delivery, headers, previews, queues, and callbacks all stay normal Action Mailer. If rendering fails, no email is sent and `ReactEmailRails::RenderError` is raised.
+react-email-rails automatically renders both HTML and plain-text versions from the same component. Delivery, headers, previews, queues, and callbacks all stay normal Action Mailer. If rendering fails, no email is sent and `ReactEmailRails::RenderError` is raised.
 
 ## Status
 
@@ -44,7 +43,6 @@ React Email Rails automatically renders both HTML and plain-text versions from t
 - Vite 7 or 8
 - React 18 or 19
 - `@react-email/render` 2.x
-- For [rendering editor documents](#editor) (optional): `@react-email/editor` 1.5+ and `@tiptap/core` 3.x
 
 > We recommend [rails_vite](https://github.com/skryukov/rails_vite/) for Vite with Rails.
 
@@ -68,11 +66,11 @@ bin/rails generate react_email_rails:install
 
 This creates `config/initializers/react_email_rails.rb`, installs missing JavaScript dependencies when it can detect your package manager, adds `reactEmailRails()` to `vite.config.*`, and creates `app/javascript/emails`.
 
-The installed setup follows the normal Rails lifecycle:
+The installed setup then follows the normal Rails lifecycle:
 
 - `bin/rails generate react_email_rails:email ...` creates matching mailers and React components.
-- Development renders through Vite on demand.
-- `bin/rails assets:precompile` builds the production email bundle automatically.
+- `bin/dev` renders through Vite on demand.
+- `bin/rails assets:precompile` builds the production renderer bundle automatically.
 - `bin/rails react_email_rails:build` builds the bundle directly when CI or tests need it.
 
 ### Manual Install
@@ -104,9 +102,7 @@ Generate a mailer and React Email component:
 bin/rails generate react_email_rails:email Account welcome
 ```
 
-The generator follows Rails' mailer generator shape: `NAME [method method]`. It creates `app/mailers/account_mailer.rb`, matching components under your configured React Email directory, plus a mailer preview and test.
-
-The generator reads `emails.path` and `emails.extension` from `reactEmailRails()` when available. Pass flags to override them:
+The generator follows Rails' mailer generator shape: `NAME [method method]`. It creates the mailer, matching React components, a mailer preview, and a test. It reads `emails.path` and `emails.extension` from `reactEmailRails()` when available. Pass flags to override them:
 
 ```sh
 bin/rails generate react_email_rails:email Account welcome --emails-path=app/emails --extension=jsx
@@ -160,11 +156,11 @@ export default function Welcome({ account }: WelcomeProps) {
 
 > [@react-email/components](https://react.email/docs/components/html) provides primitives like `<Button>`, `<Heading>`, `<Tailwind>`, and more.
 
-That's it — it now renders and delivers like any other Action Mailer email.
+That's it. It now renders and delivers like any other Action Mailer email.
 
 ## Usage
 
-Pass data from your mailers and each top-level key becomes a prop on the React component's default export.
+Pass data from your mailer. Each top-level key becomes a prop on the component's default export.
 
 ```ruby
 mail react: { foo: "bar" }, ...
@@ -233,9 +229,9 @@ Component names are inferred from the mailer and action:
 | `AccountMailer#welcome` | `account_mailer/welcome` |
 | `Users::InviteMailer#new_invite` | `users/invite_mailer/new_invite` |
 
-Rails derives `account_mailer` from `AccountMailer` via its `mailer_name`. The default Vite plugin resolves those names under `app/javascript/emails`, so `account_mailer/welcome` maps to `app/javascript/emails/account_mailer/welcome.tsx` or `.jsx`.
+Rails derives `account_mailer` from `AccountMailer` via `mailer_name`. By default, `account_mailer/welcome` resolves to `app/javascript/emails/account_mailer/welcome.tsx` or `.jsx`.
 
-Files and directories starting with `_` are ignored as renderable email entries by default. Use them for shared components such as `_components/email_layout.tsx`; they can still be imported by email components.
+Files and directories starting with `_` are ignored as renderable email entries by default. Use them for shared components such as `_components/email_layout.tsx`. They can still be imported by email components.
 
 Override the inferred name per mail:
 
@@ -247,15 +243,15 @@ Or override `component_path_resolver` globally in your [configuration](#configur
 
 ### Prop Serialization
 
-Just like `render json:` in controllers, you can pass any object that responds to `as_json` to `mail react:`. Plain hashes, Active Model objects, and serialization libraries like [Alba](https://github.com/okuramasafumi/alba) or [ActiveModel::Serializer](https://github.com/rails-api/active_model_serializers) are supported.
+Like `render json:`, `mail react:` accepts any object that responds to `as_json`, including hashes, Active Model objects, and serializers such as [Alba](https://github.com/okuramasafumi/alba) or [ActiveModel::Serializer](https://github.com/rails-api/active_model_serializers).
 
 ### Prop Transformation
 
-By default, prop keys are camelized on the way to React, so `account.plan_name` arrives as `account.planName` in your component. This makes them more idiomatic for the frontend, but you can override the `transform_props` behavior in your [configuration](#configuration).
+Prop keys are camelized by default, so `account.plan_name` arrives as `account.planName`. Override `transform_props` in your [configuration](#configuration).
 
 ### Layouts
 
-Action Mailer layouts are not applied to `react:` emails. React Email treats layouts like any other component, so share structure with normal React composition instead:
+Action Mailer layouts aren't applied to `react:` emails. React Email treats layouts like any other component, so share structure with normal React composition instead:
 
 ```tsx
 // app/javascript/emails/_components/email_layout.tsx
@@ -295,173 +291,11 @@ export default function Welcome() {
 
 See [Component Names](#component-names) for how shared `_` files are handled.
 
-## Editor
-
-Alongside named components, the gem can render a [@react-email/editor](https://react.email/docs/editor) document — the Tiptap/ProseMirror JSON a visual editor produces — to HTML and text on the server.
-
-React Email exposes [composeReactEmail](https://react.email/docs/editor/api-reference/compose-react-email) for this, but only from the browser, with a live editor instance from the export panel. `ReactEmailRails.compose` is the server analog: it rebuilds what `composeReactEmail` needs headlessly (no DOM, no live editor) from the stored document and the extensions you declare, then calls the same function. So `compose` is to the editor what `render` is to a component.
-
-This is opt-in. The editor packages are optional peer dependencies and stay out of the email render path until you enable it.
-
-### Setup
-
-Install the editor packages:
-
-```sh
-npm i @react-email/editor @tiptap/core
-```
-
-To also parse HTML into documents with [`parse`](#parsing-html-into-a-document), add `@tiptap/html` and its server DOM, `happy-dom`:
-
-```sh
-npm i @tiptap/html happy-dom
-```
-
-Enable the `documents` option in your Vite config:
+### Editor
 
-```ts
-// vite.config.ts
+If you're also using [@react-email/editor](https://react.email/docs/editor) to let users compose emails inside your app, `ReactEmailRails.compose` can render those stored documents on the server.
 
-import { defineConfig } from "vite"
-import { reactEmailRails } from "react-email-rails"
-
-export default defineConfig({
-  plugins: [reactEmailRails({ documents: true })],
-})
-```
-
-`documents: true` enables it with defaults (`app/javascript/documents`, `.ts`/`.tsx` extensions). Like `emails`, it also accepts a directory string or `{ path, extension, ignore }`. See [Plugin Options](#plugin-options).
-
-### Document Renderers
-
-A document doesn't carry the editor configuration it was authored with, so a headless renderer has to be told which extensions a given document needs. Each file under the documents directory is a **document renderer** — the editor-side analog of an email component — and its name is resolved from the directory layout just like [component names](#component-names) (so `broadcast` maps to `app/javascript/documents/broadcast.ts`).
-
-```ts
-// app/javascript/documents/broadcast.ts
-
-import { StarterKit } from "@react-email/editor/extensions"
-import { EmailTheming } from "@react-email/editor/plugins"
-
-// Required: the Tiptap extensions the document was authored with.
-export function buildExtensions() {
-  return [StarterKit, EmailTheming]
-}
-```
-
-A renderer can export two optional hooks:
-
-| Export | Required | Description |
-|--------|----------|-------------|
-| `buildExtensions(context)` | Yes | Returns the Tiptap extension list for the document. |
-| `transformDocument(document, context)` | No | Returns a rewritten document before rendering — for example, to inject header/footer nodes that aren't persisted in the stored document. |
-| `getPreview(context)` | No | Returns inbox preview text when the `compose` call doesn't pass one. |
-
-`context` is the optional data you pass to `compose` (see below). Use it to vary extensions, transforms, or preview text per render.
-
-```ts
-// app/javascript/documents/broadcast.ts
-
-import { StarterKit } from "@react-email/editor/extensions"
-import { EmailTheming } from "@react-email/editor/plugins"
-
-export function buildExtensions(context) {
-  return [StarterKit, EmailTheming]
-}
-
-// Inject a branded header after the persisted theme node, wherever it sits.
-export function transformDocument(document, context) {
-  const header = {
-    type: "heading",
-    attrs: { level: 1 },
-    content: [{ type: "text", text: context.brandName }],
-  }
-  // Find globalContent and insert after it, rather than assuming a position, so
-  // the theme node is preserved.
-  const themeIndex = document.content.findIndex((node) => node.type === "globalContent")
-  const at = themeIndex + 1
-  return {
-    ...document,
-    content: [...document.content.slice(0, at), header, ...document.content.slice(at)],
-  }
-}
-
-export function getPreview(context) {
-  return context.previewText
-}
-```
-
-> **Match the extensions to the document.** `composeReactEmail` renders any node whose extension isn't registered as `null`, so a document that uses a node your `buildExtensions` omits will silently drop that content. Return the same extension list the document was authored with.
-
-> **Keep the theme node.** The editor persists its theme in a `globalContent` node and `EmailTheming` reads it back when rendering. If you reshape the document in `transformDocument`, preserve that node.
-
-### Composing a Document
-
-Call `ReactEmailRails.compose` with the renderer `type`, the stored document, and optional `context`/`preview`:
-
-```ruby
-broadcast = Broadcast.find(params[:id])
-
-rendered = ReactEmailRails.compose(
-  type: "broadcast",
-  document: broadcast.body,          # a Hash in Tiptap's shape, e.g. from a jsonb column
-  context: { brand_name: "Acme", preview_text: broadcast.subject },
-  preview: broadcast.subject,        # optional; falls back to getPreview(context)
-)
-
-rendered.html # => "<!DOCTYPE html>..."
-rendered.text # => "ACME\n\n..."
-```
-
-It returns the same `RenderedEmail` (`html`/`text`) as `render`, runs through the same [render modes](#render-modes), and raises `ReactEmailRails::RenderError` on failure. Documents don't go through Action Mailer — broadcasts and the like usually have their own delivery path — so deliver `rendered.html`/`rendered.text` however your app sends mail.
-
-**The document is a `Hash`.** You pass and store it as a plain Ruby `Hash` with string keys — what a jsonb column hands back, and what [`parse`](#parsing-html-into-a-document) returns. "Tiptap JSON" names the document's *shape* (and the format it's serialized to over the wire to the renderer), not the Ruby type; `compose` accepts any object that responds to `as_json`, but a `Hash` is the norm.
-
-**Keys:** the document's keys (`type`, `attrs`, `content`, `marks`, node names, `globalContent`) are structural and **passed through verbatim** — never transformed. Only `context` is key-transformed, camelized exactly like component props (so `brand_name` arrives as `brandName`, per [`transform_props`](#prop-transformation)).
-
-`render_options` does not apply to documents; `composeReactEmail` controls its own rendering.
-
-### Parsing HTML into a Document
-
-`ReactEmailRails.parse` converts semantic HTML into the same document `Hash` shape the editor stores, using the selected renderer's extensions. This needs the `@tiptap/html` and `happy-dom` packages (see [Setup](#setup)).
-
-```ruby
-document = ReactEmailRails.parse(
-  type: "broadcast",                 # the same renderer type compose uses
-  html: params[:body_html],          # the HTML the caller sent
-  context: { brand_name: "Acme" },   # optional; reaches buildExtensions, like compose
-)
-
-broadcast.update!(body: document)    # persist the Hash (e.g. to a jsonb column)
-```
-
-Later, render the stored document like any other:
-
-```ruby
-rendered = ReactEmailRails.compose(type: "broadcast", document: broadcast.body)
-```
-
-`parse` returns a plain Ruby `Hash` with string keys, normalized through the renderer's schema. It uses the same [render modes](#render-modes) as `compose` and raises `ReactEmailRails::RenderError` on failure. `context` is key-transformed like component props; the HTML is sent verbatim.
-
-What this means in practice:
-
-- HTML maps to a node only when an extension defines how to parse it. Unknown elements, inline styles, and classes may be dropped or flattened.
-- Editor-only constructs such as custom email nodes and the persisted `globalContent` theme node do not round-trip from plain HTML.
-- If you already have the document `Hash`, pass it to `compose` directly.
-
-### Debugging Dropped Content
-
-The most common integration bug is an extension/document mismatch. A node whose type is **missing from `buildExtensions` entirely** raises `ReactEmailRails::RenderError` (it can't be parsed) — loud and safe. The quiet case is a node that *is* in the schema but whose extension does not render to email (a plain Tiptap node rather than an email one): `composeReactEmail` renders it as nothing, with no error.
-
-`compose` reports those dropped node types so the silent case isn't silent. They appear both on the result as `rendered.warnings` and on the [`render.react-email-rails`](#instrumentation) instrumentation event as `payload[:warnings]` — an array of `{ type:, count: }`. The editor's own non-rendering nodes (the `globalContent` theme node and similar) are excluded, so a non-empty `warnings` means real content was lost. Subscribe to the event to alert on it — or refuse to send:
-
-```ruby
-ActiveSupport::Notifications.subscribe("render.react-email-rails") do |event|
-  warnings = event.payload[:warnings]
-  raise "dropped #{warnings.sum { _1[:count] }} node(s): #{warnings.map { _1[:type] }.join(", ")}" if warnings
-end
-```
-
-If content is missing, confirm `buildExtensions` returns the **same** extensions the document was authored with — the editor's `StarterKit` plus every custom node and plugin in use — and, if you reshape the document in `transformDocument`, that you preserved the `globalContent` theme node. Treat a mismatch as data or version skew: pinning a document's renderer `type` to the extension set it was created with, and versioning that set, avoids drift.
+See [Editor rendering](docs/editor.md) for setup and usage.
 
 ## Configuration
 
@@ -499,17 +333,13 @@ ReactEmailRails.configure do |config|
 end
 ```
 
-`transform_props` only controls prop key names; props are always serialized with `as_json`.
+`transform_props` only controls prop key names. Props are always serialized with `as_json`.
 
 #### Render Modes
 
-`:subprocess` starts a fresh Node process for each render. It's simple, always uses the latest bundle, and keeps failures isolated, but pays Node startup and bundle load on every render.
-
-`:persistent` reuses one long-lived Node process per worker. It's faster because it avoids per-render startup, but uses more memory and can serve a stale component until recycled.
-
-For background email delivery, the default `:subprocess` mode is usually enough. Switch to `:persistent` when Node startup appears in traces or batch jobs render many emails from the same bundle (see [Instrumentation](#instrumentation)).
+`:subprocess` starts a fresh Node process for each render. It's simple, isolated, and always uses the latest bundle, but pays Node startup and bundle load each time.
 
-The render mode also shapes the development experience: `:subprocess` boots a fresh Vite dev server per render and always reflects your latest edits, while `:persistent` reuses the server and may serve a stale component until the process is recycled.
+`:persistent` reuses one long-lived Node process per worker. It's faster for render-heavy workers, but uses more memory and can serve a stale component until recycled. The default `:subprocess` mode is usually enough. Switch when Node startup shows up in traces or batch jobs render many emails from the same bundle.
 
 Enable persistent mode for render-heavy worker processes:
 
@@ -521,13 +351,13 @@ end
 
 Persistent mode keeps one Node child per process:
 
-- Renders are sent as newline-delimited JSON and processed one at a time, so a single child never renders concurrently. Scale throughput by adding worker processes.
-- It is fork-safe: under clustered Puma or forking job runners, each worker spawns its own child.
+- Renders are newline-delimited JSON and processed one at a time. Scale throughput with more worker processes.
+- It's fork-safe: under clustered Puma or forking job runners, each worker spawns its own child.
 - The child is recycled after `render_process_max_requests` renders to bound memory growth. Set it to `nil` to disable recycling.
 
 #### Render Options
 
-`render_options` is passed to [@react-email/render](https://react.email/docs/utilities/render). `html` options apply to HTML rendering and `text` options apply to plain-text rendering. Keys are camelized before they cross into JavaScript.
+`render_options` is passed to [@react-email/render](https://react.email/docs/utilities/render). Use `html` and `text` keys for each output. Option keys are camelized before they cross into JavaScript.
 
 ```ruby
 ReactEmailRails.configure do |config|
@@ -546,7 +376,7 @@ end
 
 #### Error Reporting
 
-Use `on_render_error` to report failures before the exception is re-raised. The callback receives the error and a `context` of `kind:` (`"email"`, `"document"`, or `"parse"`) plus the identifier — `component:` for emails, `type:` for documents and parse requests. Accept `**context` so one handler covers every render kind:
+Use `on_render_error` to report failures before the exception is re-raised. The callback receives the error plus `kind:` and `component:`:
 
 ```ruby
 ReactEmailRails.configure do |config|
@@ -558,7 +388,7 @@ end
 
 #### Instrumentation
 
-Every render emits an [ActiveSupport::Notifications](https://guides.rubyonrails.org/active_support_instrumentation.html) event named `render.react-email-rails`, so you can log render timing or forward it to your APM. The payload carries a `kind` (`"email"`, `"document"`, or `"parse"`), the `component` name (email) or `type` (document and parse), and, on a successful render, the rendered HTML size in `html_bytes` (omitted for `parse`, which returns a document rather than HTML). Document renders that drop content also include `warnings` (see [Debugging Dropped Content](#debugging-dropped-content)):
+Every render emits `render.react-email-rails` through [ActiveSupport::Notifications](https://guides.rubyonrails.org/active_support_instrumentation.html). The payload includes `kind`, `component`, and successful HTML size in `html_bytes`:
 
 ```ruby
 ActiveSupport::Notifications.subscribe("render.react-email-rails") do |event|
@@ -568,9 +398,9 @@ end
 
 ### Vite Configuration
 
-Most apps only need the `reactEmailRails()` plugin from [Quick Start](#quick-start). The options below change where components are discovered, how the bundle handles dependencies, and which email-only Vite transforms run in the isolated renderer.
+Most apps only need the `reactEmailRails()` plugin from [Quick Start](#quick-start). The options below change component discovery, bundle dependency handling, and isolated renderer transforms.
 
-In development and production, the isolated renderer loads the `reactEmailRails()` plugin, JSX support, and component-facing Vite config such as `resolve`, `define`, `css`, `json`, `assetsInclude`, `esbuild`, and `oxc` — but none of your other app plugins. Forwarded config is only for compiling and resolving email components; server, preview, dependency optimization, and build output settings stay owned by React Email Rails.
+In development and production, the isolated renderer loads `reactEmailRails()`, JSX support, and component-facing Vite config such as `resolve`, `define`, `css`, `json`, `assetsInclude`, `esbuild`, and `oxc`. It doesn't load your other app plugins. Server, preview, dependency optimization, and build output settings stay owned by react-email-rails.
 
 #### Plugin Options
 
@@ -579,11 +409,7 @@ In development and production, the isolated renderer loads the `reactEmailRails(
 | `emails.path` | `"app/javascript/emails"` | Directory containing email components |
 | `emails.extension` | `[".tsx", ".jsx"]` | Component extension, or an array of extensions |
 | `emails.ignore` | `["**/_*", "**/_*/**"]` | Glob patterns ignored under `emails.path` |
-| `documents` | `false` (off) | Enable [editor document rendering](#editor). `true`, a path string, or `{ path, extension, ignore }` |
-| `documents.path` | `"app/javascript/documents"` | Directory containing document renderers |
-| `documents.extension` | `[".ts", ".tsx"]` | Renderer extension, or an array of extensions |
-| `documents.ignore` | `["**/_*", "**/_*/**"]` | Glob patterns ignored under `documents.path` |
-| `standalone` | `true` | Inline production email bundle dependencies |
+| `standalone` | `true` | Inline production renderer bundle dependencies |
 | `vite` | `{}` | Extra email-only Vite config for compilation and resolution |
 
 Use a custom directory:
@@ -608,7 +434,7 @@ Component names come from the Vite directory layout (see [Component Names](#comp
 
 #### Advanced: Email-Only Vite Plugins
 
-Most apps do not need extra email plugins. If email components need a transform that is not part of Vite's default pipeline, add that transform to the email renderer:
+Most apps don't need extra email plugins. If email components need a transform that isn't part of Vite's default pipeline, add that transform to the isolated renderer:
 
 ```ts
 import mdx from "@mdx-js/rollup"
@@ -626,11 +452,11 @@ export default defineConfig({
 })
 ```
 
-These `vite` options are used by `react-email-rails-dev` and `react-email-rails-build`. They are intentionally scoped to React Email. Only `assetsInclude`, `css`, `define`, `esbuild`, `json`, `oxc`, `plugins`, and `resolve` are accepted here; output settings such as `build.outDir` and `build.rollupOptions` are ignored so the Ruby renderer can always find the generated bundle.
+These `vite` options are used by `react-email-rails-dev` and `react-email-rails-build`. Only `assetsInclude`, `css`, `define`, `esbuild`, `json`, `oxc`, `plugins`, and `resolve` are accepted. Output settings such as `build.outDir` and `build.rollupOptions` are ignored so Ruby can always find the bundle.
 
 #### Standalone Builds
 
-By default the production email bundle inlines React, `@react-email/render`, and other Node dependencies. That makes the bundle larger, but it works well for Rails deploys that build assets in one stage and run without `node_modules` in the final runtime image. Development previews keep dependencies external for Vite's module runner, even when `standalone` is enabled.
+By default the production renderer bundle inlines React, `@react-email/render`, and other Node dependencies. This works well for Rails deploys that build assets in one stage and run without `node_modules` in the final image. Development previews keep dependencies external, even when `standalone` is enabled.
 
 Set `standalone: false` when your runtime already ships `node_modules` and you prefer a smaller SSR-style bundle:
 
@@ -650,7 +476,7 @@ For production deploys, run the normal Rails asset task:
 bin/rails assets:precompile
 ```
 
-The `react_email_rails:build` task is hooked into `assets:precompile` automatically. It loads your Vite config to find `reactEmailRails()` and its options, then writes `tmp/react-email-rails/emails.js` with the isolated React Email pipeline.
+The `react_email_rails:build` task is hooked into `assets:precompile` automatically. It loads `reactEmailRails()` options from your Vite config, then writes `tmp/react-email-rails/emails.js` with the email component registry. If [Editor document rendering](docs/editor.md) is enabled, the bundle also includes document renderers.
 
 You can run it directly when needed:
 
@@ -660,9 +486,9 @@ bin/rails react_email_rails:build
 
 Production rendering runs that bundle with Node. Set `SKIP_REACT_EMAIL_RAILS_BUILD=1` to skip the automatic asset hook. Directly running `bin/rails react_email_rails:build` always attempts the build.
 
-The npm package, Vite, React, and `@react-email/render` must be available when Rails runs `assets:precompile`. This is the same stage where Rails apps normally install JavaScript dependencies and build frontend assets.
+The npm package, Vite, React, and `@react-email/render` must be available when Rails runs `assets:precompile`. If you enable [Editor document rendering](docs/editor.md), its peer dependencies must be available too.
 
-The bundle is required, not an optimization. If it's missing, renders raise `ReactEmailRails::RenderError` and no mail is sent.
+The bundle is required, not an optimization. If it's missing, renders raise `ReactEmailRails::RenderError`. Action Mailer deliveries aren't sent.
 
 The Ruby gem and npm package must stay on the same version. The renderer includes a small protocol/version handshake, so mismatched installs fail with an actionable `ReactEmailRails::RenderError` instead of silently returning malformed output.
 
@@ -676,7 +502,7 @@ To confirm the renderer is ready before relying on it, run:
 bin/rails react_email_rails:verify
 ```
 
-It checks that the render command runs and that the npm package version matches the gem, then exits non-zero with an actionable message on failure. Wire it into your CI or release step to catch a missing bundle or version drift before a deploy ships — a renderer failure won't otherwise surface until the first email is sent.
+It checks that the render command runs and that the npm package version matches the gem, then exits non-zero with an actionable message on failure. Wire it into CI or release steps to catch missing bundles or version drift before the first render.
 
 For programmatic checks (for example, a health endpoint), `ReactEmailRails.healthy?` returns a boolean. If you specifically want a check at boot, call it from your own initializer and scope it to the processes that send mail so others don't pay the cost:
 

data/lib/generators/react_email_rails/email_generator.rb

@@ -2,11 +2,14 @@ require("rails/generators/named_base")
 require("json")
 require("open3")
 require("timeout")
+require_relative("vite_config_files")
 
 module ReactEmailRails; end
 module ReactEmailRails::Generators; end
 
 class ReactEmailRails::Generators::EmailGenerator < Rails::Generators::NamedBase
+  CONFIG_BIN = "node_modules/.bin/react-email-rails-config"
+
   source_root(File.expand_path("templates/email", __dir__))
 
   argument(:actions, type: :array, default: [], banner: "method method")
@@ -80,7 +83,7 @@ class ReactEmailRails::Generators::EmailGenerator < Rails::Generators::NamedBase
   end
 
   def component_base_path
-    File.join(emails_path, "#{file_path}_mailer")
+    File.join(emails_path, mailer_file_path)
   end
 
   def emails_path
@@ -131,47 +134,50 @@ class ReactEmailRails::Generators::EmailGenerator < Rails::Generators::NamedBase
 
   def vite_config_command
     [
-      "node_modules/.bin/react-email-rails-config",
-      "node_modules/.bin/react-email-rails-config.cmd",
+      CONFIG_BIN,
+      "#{CONFIG_BIN}.cmd",
     ].find { |path| File.exist?(File.join(destination_root, path)) }
   end
 
+  # The reactEmailRails({ ... }) plugin call, up to the option key being scanned for.
+  PLUGIN_OPENING = /reactEmailRails\s*\(\s*\{.*?/m
+
   def emails_path_from_vite_config
     source = vite_config_source
     return unless source
 
-    source[
-      /reactEmailRails\s*\(\s*\{.*?emails:\s*["']([^"']+)["']/m,
-      1,
-    ] || source[
-      /reactEmailRails\s*\(\s*\{.*?emails:\s*\{.*?path:\s*["']([^"']+)["']/m,
-      1,
-    ]
+    first_capture(
+      source,
+      /#{PLUGIN_OPENING}emails:\s*["']([^"']+)["']/m,
+      /#{PLUGIN_OPENING}emails:\s*\{.*?path:\s*["']([^"']+)["']/m,
+    )
   end
 
   def extension_from_vite_config
     source = vite_config_source
     return unless source
 
-    source[
-      /reactEmailRails\s*\(\s*\{.*?emails:\s*\{.*?extension:\s*["']([^"']+)["']/m,
-      1,
-    ] || source[
-      /reactEmailRails\s*\(\s*\{.*?emails:\s*\{.*?extension:\s*\[\s*["']([^"']+)["']/m,
-      1,
-    ]
+    first_capture(
+      source,
+      /#{PLUGIN_OPENING}emails:\s*\{.*?extension:\s*["']([^"']+)["']/m,
+      /#{PLUGIN_OPENING}emails:\s*\{.*?extension:\s*\[\s*["']([^"']+)["']/m,
+    )
+  end
+
+  # First capture-group match across an ordered list of patterns, or nil.
+  def first_capture(source, *patterns)
+    patterns.each do |pattern|
+      match = source[pattern, 1]
+      return match if match
+    end
+    nil
   end
 
   def vite_config_source
     @vite_config_source ||= begin
-      path = [
-        "vite.config.ts",
-        "vite.config.mts",
-        "vite.config.js",
-        "vite.config.mjs",
-        "vite.config.cts",
-        "vite.config.cjs",
-      ].find { |candidate| File.exist?(File.join(destination_root, candidate)) }
+      path = ReactEmailRails::Generators::VITE_CONFIG_FILES.find do |candidate|
+        File.exist?(File.join(destination_root, candidate))
+      end
 
       File.read(File.join(destination_root, path)) if path
     end

data/lib/generators/react_email_rails/install_generator.rb

@@ -1,4 +1,5 @@
 require("json")
+require_relative("vite_config_files")
 
 module ReactEmailRails; end
 module ReactEmailRails::Generators; end
@@ -21,14 +22,7 @@ class ReactEmailRails::Generators::InstallGenerator < Rails::Generators::Base
   }.freeze
 
   SUPPORTED_PACKAGE_MANAGERS = ["bun", "npm", "pnpm", "yarn"].freeze
-  VITE_CONFIG_FILES = [
-    "vite.config.ts",
-    "vite.config.mts",
-    "vite.config.js",
-    "vite.config.mjs",
-    "vite.config.cts",
-    "vite.config.cjs",
-  ].freeze
+  VITE_CONFIG_FILES = ReactEmailRails::Generators::VITE_CONFIG_FILES
 
   VITE_IMPORT = 'import { reactEmailRails } from "react-email-rails"'
 

data/lib/generators/react_email_rails/vite_config_files.rb

@@ -0,0 +1,14 @@
+module ReactEmailRails; end
+module ReactEmailRails::Generators; end
+
+module ReactEmailRails::Generators
+  # Candidate Vite config filenames in precedence order; shared by both generators.
+  VITE_CONFIG_FILES = [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vite.config.js",
+    "vite.config.mjs",
+    "vite.config.cts",
+    "vite.config.cjs",
+  ].freeze
+end

data/lib/react_email_rails/configuration.rb

@@ -1,6 +1,8 @@
 class ReactEmailRails::Configuration
+  # Must match OUT_DIR/BUNDLE_FILE in vite/src/index.ts (check_version_sync.rb asserts it).
   BUNDLE_PATH = "tmp/react-email-rails/emails.js"
   BUILD_BIN = "node_modules/.bin/react-email-rails-build"
+  CONFIG_BIN = "node_modules/.bin/react-email-rails-config"
   DEV_RENDER_BIN = "node_modules/.bin/react-email-rails-dev"
 
   DEFAULT_RENDER_TIMEOUT = 10
@@ -33,6 +35,7 @@ class ReactEmailRails::Configuration
     :transform_props,
     :on_render_error,
   )
+
   attr_reader(
     :render_mode,
     :render_timeout,
@@ -83,6 +86,8 @@ class ReactEmailRails::Configuration
     end
   end
 
+  # A callable render_options is instance_exec'd against `context` (the mailer) when given,
+  # so it can use per-mail helpers; otherwise it's called or returned as-is.
   def resolve_render_options(context = nil)
     value =
       if render_options.respond_to?(:call) && context
@@ -93,7 +98,7 @@ class ReactEmailRails::Configuration
         render_options
       end
 
-    deep_camelize_keys(value.as_json)
+    deep_transform_keys(value.as_json, KEY_TRANSFORMS.fetch(:lower_camel))
   end
 
   private
@@ -124,15 +129,4 @@ class ReactEmailRails::Configuration
       value
     end
   end
-
-  def deep_camelize_keys(value)
-    case value
-    when Array
-      value.map { |item| deep_camelize_keys(item) }
-    when Hash
-      value.transform_keys { |key| key.to_s.camelize(:lower) }.transform_values { |item| deep_camelize_keys(item) }
-    else
-      value
-    end
-  end
 end

data/lib/react_email_rails/props_resolver.rb

@@ -34,8 +34,7 @@ class ReactEmailRails::PropsResolver
   end
 
   def assign_props
-    # `react: true` infers the component name; instance vars become props only when the
-    # mailer opts in. Without it, the component renders with no props.
+    # `react: true` infers the component; instance vars become props only when the mailer opts in.
     return {} unless mailer.class.react_email_use_instance_props
 
     mailer.instance_variables.each_with_object({}) do |ivar, props|

data/lib/react_email_rails/render_modes/persistent/command_runner.rb

@@ -1,4 +1,7 @@
 class ReactEmailRails::RenderModes::Persistent::CommandRunner
+  # Eager (not lazy) so concurrent first renders can't each create separate Mutexes.
+  @mutex = Mutex.new
+
   class << self
     def capture(command, input:, timeout:, max_requests: nil)
       server_for(command).capture(input:, timeout:, max_requests:)
@@ -6,13 +9,13 @@ class ReactEmailRails::RenderModes::Persistent::CommandRunner
 
     def healthy?(command, timeout:)
       result = server_for(command).health_check(timeout:)
-      result.status.success? && ReactEmailRails::RenderProtocol.compatible_response?(JSON.parse(result.stdout))
+      ReactEmailRails::RenderProtocol.healthy_result?(result)
     rescue StandardError
       false
     end
 
     def stop_all
-      @mutex&.synchronize do
+      @mutex.synchronize do
         @servers&.each_value(&:stop)
         @servers&.clear
       end
@@ -21,18 +24,14 @@ class ReactEmailRails::RenderModes::Persistent::CommandRunner
     private
 
     def server_for(command)
-      @mutex ||= Mutex.new
-
       @mutex.synchronize do
         reset_after_fork
         @servers[command.map(&:to_s)] ||= ReactEmailRails::RenderModes::Persistent::Server.new(command)
       end
     end
 
-    # A forked child inherits the parent's Server objects and the open pipes to
-    # the parent's render processes. Sharing those pipes interleaves requests
-    # and responses across processes, so drop them (without killing the
-    # parent-owned process) and let this process spawn its own on demand.
+    # A forked child inherits the parent's Servers and their open pipes; sharing those pipes
+    # interleaves requests across processes, so drop them without killing the parent's process.
     def reset_after_fork
       return if @owner_pid == Process.pid && @servers
 

data/lib/react_email_rails/render_modes/persistent/server.rb

@@ -1,6 +1,7 @@
 class ReactEmailRails::RenderModes::Persistent::Server
   STDERR_LIMIT = 8 * 1024
 
+  # Minimal Process::Status stand-in; only #success? is ever read.
   Status = Data.define(:success) do
     def success? = success
   end
@@ -15,29 +16,13 @@ class ReactEmailRails::RenderModes::Persistent::Server
   end
 
   def capture(input:, timeout:, max_requests:)
-    @mutex.synchronize do
+    with_retry_on_broken_pipe do
       capture_once(input:, timeout:).tap { recycle_if_needed(max_requests) }
     end
-  rescue Errno::EPIPE, IOError
-    stop
-    begin
-      @mutex.synchronize do
-        capture_once(input:, timeout:).tap { recycle_if_needed(max_requests) }
-      end
-    rescue Errno::EPIPE, IOError
-      failure("render process exited before responding")
-    end
   end
 
   def health_check(timeout:)
-    @mutex.synchronize { health_check_once(timeout:) }
-  rescue Errno::EPIPE, IOError
-    stop
-    begin
-      @mutex.synchronize { health_check_once(timeout:) }
-    rescue Errno::EPIPE, IOError
-      failure("render process exited before responding")
-    end
+    with_retry_on_broken_pipe { health_check_once(timeout:) }
   end
 
   def stop
@@ -49,30 +34,46 @@ class ReactEmailRails::RenderModes::Persistent::Server
   rescue Errno::ESRCH, Errno::EPERM
     nil
   ensure
-    [@stdin, @stdout, @stderr].compact.each { |io| io.close unless io.closed? }
     @stderr_reader&.kill
-    @stdin = @stdout = @stderr = @wait_thread = @stderr_reader = nil
-    @stdout_buffer.clear
+    release_io
   end
 
-  # Release this process's copy of an inherited child's pipes without signalling
-  # the process itself, which is still owned by the parent that started it.
+  # Release this process's copy of an inherited child's pipes without signalling the parent-owned process.
   def abandon
-    [@stdin, @stdout, @stderr].compact.each { |io| io.close unless io.closed? }
-    @stdin = @stdout = @stderr = @wait_thread = @stderr_reader = nil
-    @stdout_buffer.clear
+    release_io
   rescue IOError
     nil
   end
 
   private
 
+  # Shared by stop (which also kills the process) and abandon (which must not).
+  def release_io
+    [@stdin, @stdout, @stderr].compact.each { |io| io.close unless io.closed? }
+    @stdin = @stdout = @stderr = @wait_thread = @stderr_reader = nil
+    @stdout_buffer.clear
+  end
+
+  # Run under the mutex; on a broken pipe, stop and retry once (the child respawns).
+  def with_retry_on_broken_pipe(&block)
+    @mutex.synchronize(&block)
+  rescue Errno::EPIPE, IOError
+    stop
+    begin
+      @mutex.synchronize(&block)
+    rescue Errno::EPIPE, IOError
+      failure("render process exited before responding")
+    end
+  end
+
   attr_reader(:command)
 
   def capture_once(input:, timeout:)
     response = request(input, timeout:)
     return failure(response["error"].to_s.presence || "render process failed") unless response["ok"]
 
+    # Re-serialize into the same Result.stdout contract the subprocess produces, so
+    # Subprocess#run parses and validates every render uniformly.
     success(JSON.generate(
       {
         protocolVersion: response["protocolVersion"],

data/lib/react_email_rails/render_modes/persistent.rb

@@ -8,20 +8,18 @@ class ReactEmailRails::RenderModes::Persistent < ReactEmailRails::RenderModes::S
   private
 
   def capture(input)
-    CommandRunner.capture(
-      command,
-      input:,
-      timeout: render_timeout,
-      max_requests: render_process_max_requests,
-    )
-  rescue Timeout::Error
-    raise(render_error("render process timed out after #{render_timeout}s"))
-  rescue Errno::ENOENT
-    raise(render_error("render command not found: #{command.inspect}"))
+    with_capture_rescues do
+      CommandRunner.capture(
+        command,
+        input:,
+        timeout: render_timeout,
+        max_requests: render_process_max_requests,
+      )
+    end
   end
 
   def render_process_max_requests
-    ReactEmailRails.configuration.send(:render_process_max_requests)
+    ReactEmailRails.configuration.render_process_max_requests
   end
 end
 

data/lib/react_email_rails/render_modes/subprocess/command_runner.rb

@@ -50,7 +50,7 @@ class ReactEmailRails::RenderModes::Subprocess::CommandRunner
 
   def terminate_process(signal, pid)
     Process.kill(signal, -pid)
-  rescue Errno::ESRCH
+  rescue Errno::ESRCH, Errno::EPERM
     nil
   end
 end

data/lib/react_email_rails/render_modes/subprocess.rb

@@ -2,16 +2,14 @@ class ReactEmailRails::RenderModes::Subprocess
   class << self
     def healthy?(command:, timeout:)
       result = CommandRunner.capture([*command, "--health"], timeout:)
-      result.status.success? && ReactEmailRails::RenderProtocol.compatible_response?(JSON.parse(result.stdout))
+      ReactEmailRails::RenderProtocol.healthy_result?(result)
     rescue StandardError
       false
     end
   end
 
-  # Payload-agnostic transport: the caller builds and serializes the payload.
-  # `label` identifies the render in error messages (component name or document type).
-  # `response` selects how the renderer's reply is interpreted: `:email` builds a
-  # RenderedEmail (render/compose), `:document` returns the parsed document (parse).
+  # `label` names the render in error messages. `response` reads the reply as `:email`
+  # (RenderedEmail, for render/compose) or `:document` (parsed document, for parse).
   def initialize(payload:, label:, response: :email)
     @payload = payload
     @label = label
@@ -40,8 +38,15 @@ class ReactEmailRails::RenderModes::Subprocess
   end
 
   def capture(input)
-    validate_command!
-    CommandRunner.capture(command, input:, timeout: render_timeout)
+    with_capture_rescues do
+      validate_command!
+      CommandRunner.capture(command, input:, timeout: render_timeout)
+    end
+  end
+
+  # Shared by Persistent#capture so the transport-error messages live in one place.
+  def with_capture_rescues
+    yield
   rescue Timeout::Error
     raise(render_error("render process timed out after #{render_timeout}s"))
   rescue Errno::ENOENT

data/lib/react_email_rails/render_protocol.rb

@@ -1,9 +1,16 @@
+require("json")
+
 module ReactEmailRails
   RENDER_PROTOCOL_VERSION = 3
 
   module RenderProtocol
     extend(self)
 
+    # Callers keep their own rescue to also cover failures obtaining the result.
+    def healthy_result?(result)
+      result.status.success? && compatible_response?(JSON.parse(result.stdout))
+    end
+
     def compatible_response?(body)
       body["ok"] == true && compatible_metadata?(body)
     end

data/lib/react_email_rails/rendered_email.rb

@@ -1,6 +1,5 @@
 module ReactEmailRails
-  # `warnings` carries non-fatal renderer warnings (e.g. document nodes dropped
-  # because no extension rendered them); empty for component renders.
+  # `warnings` are non-fatal (document nodes nothing rendered); empty for component renders.
   RenderedEmail = Data.define(:html, :text, :warnings) do
     def initialize(html:, text:, warnings: [])
       super

data/lib/react_email_rails/version.rb

@@ -1,3 +1,3 @@
 module ReactEmailRails
-  VERSION = "0.3.0"
+  VERSION = "0.4.1"
 end

data/lib/react_email_rails.rb

@@ -40,16 +40,10 @@ module ReactEmailRails
       payload = { component:, props: serialized_props(props) }
       payload[:renderOptions] = render_options if render_options.present?
 
-      instrument(kind: "email", component:) do
-        configuration.resolved_render_mode.new(payload:, label: component).render
-      end
-    rescue ReactEmailRails::RenderError => e
-      configuration.on_render_error&.call(e, kind: "email", component:)
-      raise
+      perform(payload:, label: component, kind: "email", component:)
     end
 
-    # Render an @react-email/editor document (Tiptap JSON) to HTML+text. The document
-    # is sent verbatim (its keys are structural); only context is key-transformed, like props.
+    # The document is sent verbatim (keys are structural); only context is key-transformed, like props.
     def compose(type:, document:, context: {}, preview: nil)
       payload = {
         kind: "document",
@@ -59,29 +53,19 @@ module ReactEmailRails
         preview:,
       }
 
-      instrument(kind: "document", type:) do
-        configuration.resolved_render_mode.new(payload:, label: type).render
-      end
-    rescue ReactEmailRails::RenderError => e
-      configuration.on_render_error&.call(e, kind: "document", type:)
-      raise
+      perform(payload:, label: type, kind: "document", type:)
     end
 
-    # Parse HTML into an editor document Hash using the renderer's extensions.
-    def parse(type:, html:, context: {})
+    # Parse semantic HTML or Markdown into an editor document Hash using the renderer's
+    # extensions. Pass exactly one of `html:` or `markdown:`.
+    def parse(type:, html: nil, markdown: nil, context: {})
       payload = {
         kind: "parse",
         type:,
-        html: html.to_s,
         context: serialized_props(context),
-      }
+      }.merge(parse_source(html:, markdown:))
 
-      instrument(kind: "parse", type:) do
-        configuration.resolved_render_mode.new(payload:, label: type, response: :document).render
-      end
-    rescue ReactEmailRails::RenderError => e
-      configuration.on_render_error&.call(e, kind: "parse", type:)
-      raise
+      perform(payload:, label: type, response: :document, kind: "parse", type:)
     end
 
     def healthy?
@@ -95,6 +79,27 @@ module ReactEmailRails
 
     private
 
+    def perform(payload:, label:, response: :email, **metadata)
+      instrument(**metadata) do
+        configuration.resolved_render_mode.new(payload:, label:, response:).render
+      end
+    rescue ReactEmailRails::RenderError => e
+      configuration.on_render_error&.call(e, **metadata)
+      raise
+    end
+
+    # Markdown is converted renderer-side, not here; both inputs are sent as-is.
+    def parse_source(html:, markdown:)
+      if !html.nil? && !markdown.nil?
+        raise(ArgumentError, "ReactEmailRails.parse accepts only one of html: or markdown:")
+      end
+
+      return { html: html.to_s } unless html.nil?
+      return { markdown: markdown.to_s } unless markdown.nil?
+
+      raise(ArgumentError, "ReactEmailRails.parse requires html: or markdown:")
+    end
+
     def serialized_props(value)
       configuration.send(:serialize_props, value)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: react-email-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Supertape
@@ -148,6 +148,7 @@ files:
 - lib/generators/react_email_rails/templates/email/mailer_test.rb.tt
 - lib/generators/react_email_rails/templates/initializer.rb
 - lib/generators/react_email_rails/templates/vite.config.ts
+- lib/generators/react_email_rails/vite_config_files.rb
 - lib/react-email-rails.rb
 - lib/react_email_rails.rb
 - lib/react_email_rails/action_mailer.rb