react-email-rails 0.11.1 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 727de1abdcab5dab75ca38cf157b919b01a74fc6e8c1aef873a658ebed812a68
-  data.tar.gz: 023f5e0bd2ac88a010e8db0a3f1bcdaac28b2cf9424106ad45d2a6ab68a8411a
+  metadata.gz: 281158df961cccec48c34e03628715fda9a9c9cf16bbda4cae3097f380498a48
+  data.tar.gz: 68d882e14c9a5ed7281b5e1bb39a046e7ecb77314b25667cb27a289509aac319
 SHA512:
-  metadata.gz: ad68609561536c4eb37215e578d1b94ec37fb77ef80c9334b68e2277a29c10d5d13040fe5817810e430ff067fe7d2ac03960815649897ab424b0fade017981bb
-  data.tar.gz: 77e460b82033c452fd7a4baaa2b711dba701dce6f7c2e572b10f2ddd4b7ad5b87b0b8572b3cd47382adc72a247227a57a8a9e2109ed717e7b23f7d44619ba08a
+  metadata.gz: 7a679b532deae816d2337e38810077045b85a38d0e0e86089d516ba70d8e9060a06b4c9e9af5a8fa4a7aaa310f101c2817c0f246e559f97c1baaf829f19db91c
+  data.tar.gz: 7117f2c68aacaa3a4683d2272384a8ee5171d3684c3ad2a7b809bb833e7b85b4a19df738de66de3c45ce234d7e87a78537db3d1c8b24c733fcb25b26b8fa3d60

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.12.1
+
+- Export `CamelMailer` and `CamelMessage` TypeScript types, plus a `Register` module augmentation (`propKeys: "camel"`) so apps that camelize props can type the injected `mailer` / `message` shapes without a local mapped type. Default `Mailer` / `Message` stay snake_case.
+- Timeouts that already received a partial response line no longer suggest a gem/npm version mismatch. The renderer drains stdout before deciding the process was silent.
+
+## 0.12.0
+
+- **Breaking:** Remove `config.render_mode`. There is one renderer: a long-lived Node child per Ruby process, speaking newline-delimited JSON. Delete `config.render_mode = :persistent` from initializers. Set `config.render_process_max_requests = 1` to recycle the child after every email.
+- **Breaking:** Replace `config.transform_props` (`:camel`, `:lower_camel`, `:dash`, `:snake`, `:none`) with `config.prop_transformer`, matching [inertia-rails](https://inertia-rails.dev/guide/configuration#prop_transformer). The default is a no-op (`->(props:) { props }`), so keys stay as `as_json` produced them. Camelize in an initializer if you want the previous 0.11 behavior. The exported `Mailer` and `Message` TypeScript types now describe that default snake_case shape.
+- Render HTML once and derive plain text with `toPlainText`, so `htmlToTextOptions` and `data-skip-in-text` apply to the same markup.
+- Raise clearer errors when a component is missing (including a capped list of known names) or has no default export.
+- Default `render_timeout` to 30 seconds in development so the first Vite-backed render can finish booting.
+- Timeouts with no stdout mention matching gem and npm versions, so a gem 0.12 talking to an older package that waits for EOF is easier to diagnose.
+- Recycle the Node child after invalid JSON so the next render can succeed.
+- Include Node stderr when the child exits without a protocol line, instead of reporting only that it exited.
+- Treat only `{ "health": true }` as a health check so a render payload that also sets `health` still renders.
+- Apply `html.pretty` only to the HTML body so pretty-printing does not change plain text.
+
 ## 0.11.1
 
 - Republish of 0.11.0 with no code changes. The 0.11.0 npm package was never published: npm provenance publishing requires GitHub-hosted runners, so the release workflow's publish job now runs on one. Do not use gem 0.11.0; it has no matching npm package.

data/README.md

@@ -8,7 +8,7 @@ react-email-rails lets Rails render React Email components into HTML and plain t
 
 ## Why
 
-HTML email is still awkward. React Email gives you a nicer component model, email-safe primitives, Tailwind support, and TypeScript. This gem connects that workflow to Rails without replacing Action Mailer: components render through Vite in development and a prebuilt renderer bundle in production, with optional persistent rendering for high-volume workers.
+HTML email is still awkward. React Email gives you a nicer component model, email-safe primitives, Tailwind support, and TypeScript. This gem connects that workflow to Rails without replacing Action Mailer: components render through Vite in development and a prebuilt renderer bundle in production, using a long-lived Node process per Ruby process.
 
 ## Status
 
@@ -159,11 +159,11 @@ React Email also provides primitives like [`<Button>`, `<Heading>`, `<Tailwind>`
 
 ## Rendering
 
-In development, react-email-rails renders components through Vite's dev pipeline. Your email components get the same module resolution and transforms as the rest of your frontend.
+In development, react-email-rails renders components through Vite's dev pipeline. Your email components get the same module resolution and transforms as the rest of your frontend. A long-lived Node child stays warm across previews and `deliver_now` calls so Vite is not cold-started for every email.
 
-In production, `assets:precompile` builds a server-side renderer bundle from your Vite config. Rails runs that bundle with Node whenever an email needs to render.
+In production, `assets:precompile` builds a server-side renderer bundle from your Vite config. Rails keeps one Node child per Ruby process and renders through that bundle.
 
-Every `react:` email renders HTML and plain text from the same component. If rendering fails, the email is not sent and `ReactEmailRails::RenderError` is raised.
+Every `react:` email renders HTML once and derives plain text from that markup. If rendering fails, the email is not sent and `ReactEmailRails::RenderError` is raised.
 
 ### Live-Reloading Previews
 
@@ -322,7 +322,7 @@ Set `config.deep_merge_shared_props = true` to make deep merging the default for
 
 Every `react:` email receives `mailer` and `message` props, mirroring the [`mailer` and `message` view helpers](https://guides.rubyonrails.org/action_mailer_basics.html#action-mailer-view-helpers) available to Action Mailer ERB views.
 
-`mailer` identifies the mailer action. `message` reflects the email after Action Mailer has assigned headers and defaults, including default `from` and `reply_to` values. With the default prop transform, import the `Mailer` and `Message` types to annotate them:
+`mailer` identifies the mailer action. `message` reflects the email after Action Mailer has assigned headers and defaults, including default `from` and `reply_to` values. Import the `Mailer` and `Message` types to annotate them:
 
 ```tsx
 import type { Mailer, Message } from "react-email-rails"
@@ -334,24 +334,24 @@ type WelcomeProps = {
 }
 ```
 
+The table shows the default snake_case keys. Keys follow `config.prop_transformer` just like your own props, so a camelize transformer yields `mailerName` / `replyTo` at runtime. Augment `Register` once so `Mailer` / `Message` match, or alias `CamelMailer` / `CamelMessage` — see [Prop Transformation](#prop-transformation).
+
 | Prop | Example |
 |------|---------|
-| `mailer.mailerName` | `"account_mailer"` |
-| `mailer.actionName` | `"welcome"` |
+| `mailer.mailer_name` | `"account_mailer"` |
+| `mailer.action_name` | `"welcome"` |
 | `message.subject` | `"Welcome"` |
 | `message.to` | `["account@example.com"]` |
 | `message.cc`, `message.bcc` | `["…"]` or `null` |
-| `message.from`, `message.replyTo` | `["app@example.com"]` |
-
-Context is merged before prop serialization, so keys follow `config.transform_props` just like your own props. The exported TypeScript types describe the default `:lower_camel` shape.
+| `message.from`, `message.reply_to` | `["app@example.com"]` |
 
-Per-mail and shared props win on conflict, so a prop named `mailer` or `message` overrides the injected context. When props come from a serializer, the context is merged in as long as `as_json` returns a hash; collections, arrays, and other non-object values pass through unchanged so their top-level shape is preserved.
+Context is merged before prop serialization. Per-mail and shared props win on conflict, so a prop named `mailer` or `message` overrides the injected context. When props come from a serializer, the context is merged in as long as `as_json` returns a hash; collections, arrays, and other non-object values pass through unchanged so their top-level shape is preserved.
 
 ### Prop Serialization
 
 Props are serialized with `as_json`, just like `render json:`. You can pass hashes, arrays, Active Model objects, and serializer output from libraries such as [Alba](https://github.com/okuramasafumi/alba) or [ActiveModel::Serializer](https://github.com/rails-api/active_model_serializers).
 
-Prop keys are camelized by default, so `plan_name` arrives in React as `planName`. See [Prop Transformation](#prop-transformation) to change that behavior.
+Keys are left as serialized by default, so `plan_name` arrives in React as `plan_name`. See [Prop Transformation](#prop-transformation) to camelize them.
 
 ### Component Files
 
@@ -409,7 +409,7 @@ export default function Welcome() {
 
 Configuration lives in two places:
 
-- Rails configuration controls mailer behavior, prop handling, rendering mode, timeouts, and error hooks.
+- Rails configuration controls mailer behavior, prop handling, timeouts, and error hooks.
 - Vite configuration controls email component discovery and the renderer bundle.
 
 ### Rails Configuration
@@ -418,17 +418,16 @@ Override Rails-side defaults in `config/initializers/react_email_rails.rb`:
 
 ```ruby
 ReactEmailRails.configure do |config|
-  # config.render_mode = :persistent
+  # config.render_timeout = 10
 end
 ```
 
 | Option | Default |
 |--------|---------|
 | `component_path_resolver` | `->(mailer:, action:) { "#{mailer}/#{action}" }` |
-| `transform_props` | `:lower_camel` |
-| `render_mode` | `:subprocess` |
+| `prop_transformer` | `->(props:) { props }` |
 | `render_options` | `{}` |
-| `render_timeout` | `10` seconds |
+| `render_timeout` | `30` seconds in development, `10` seconds otherwise |
 | `render_process_max_requests` | `1_000` |
 | `on_render_error` | `nil` |
 | `deep_merge_shared_props` | `false` |
@@ -436,48 +435,56 @@ end
 
 ### Prop Transformation
 
-Set `transform_props` to choose how Ruby prop keys are exposed to React:
-
-| Value | Example |
-|-------|---------|
-| `:camel` | `AccountName` |
-| `:lower_camel` | `accountName` |
-| `:dash` | `account-name` |
-| `:snake` | `account_name` |
-| `:none` | preserves serialized keys |
+Use `prop_transformer` to change props after `as_json` and before they reach React. To work with `snake_case` in Ruby and `camelCase` in components:
 
 ```ruby
 ReactEmailRails.configure do |config|
-  config.transform_props = :none
+  config.prop_transformer = lambda do |props:|
+    props.deep_transform_keys { |key| key.to_s.camelize(:lower) }
+  end
 end
 ```
 
-Only prop keys are transformed. Values are always serialized with `as_json`.
+The transformer is arbitrary, so TypeScript cannot infer it. The default `Mailer` and `Message` types stay snake_case (`mailer_name`, `reply_to`). App-authored props (`expiresMinutes`, and so on) stay hand-typed in the app.
+
+If you camelize in Ruby, augment `Register` once so `import type { Mailer, Message }` matches runtime — the same "configure once" idea as the initializer:
+
+```ts
+// e.g. react-email-rails.d.ts
+import "react-email-rails"
+
+declare module "react-email-rails" {
+  interface Register {
+    propKeys: "camel"
+  }
+}
+```
+
+The `import "react-email-rails"` (or an `export {}`) makes the file a module so TypeScript *augments* the package. Without it, a script-style `.d.ts` replaces the module and you lose the rest of the package's types.
 
-### Render Modes
+If you do not want a `.d.ts`, alias the camel types at the import. `CamelMailer` and `CamelMessage` are always camel, regardless of `Register`:
 
-The default `:subprocess` mode starts a fresh Node process for each render. It is simple, isolated, and always uses the latest bundle, but it pays Node startup and bundle load time for each email.
+```ts
+import type { CamelMailer as Mailer, CamelMessage as Message } from "react-email-rails"
+```
 
-`:persistent` mode keeps one long-lived Node child process per Ruby process. It is faster for render-heavy workers, but uses more memory and can serve a stale component until the child is recycled.
+The transformer receives one hash at a time: the root props object, or each object in a top-level collection. Nested hashes inside a single object are left to the transformer — `deep_transform_keys` walks those.
 
-Switch to persistent mode when Node startup shows up in traces or when a worker renders many emails from the same bundle:
+### Render Process
+
+Each Ruby process keeps one long-lived Node child. Renders are newline-delimited JSON and processed one at a time. Throughput scales with more worker processes. The child is fork-safe: clustered Puma and forking job runners spawn one Node child per worker.
+
+The child recycles after `render_process_max_requests` renders so a leaked or stale renderer cannot live forever. Set that option to `nil` to disable recycling, or to `1` to start a fresh Node process for every email:
 
 ```ruby
 ReactEmailRails.configure do |config|
-  config.render_mode = :persistent
+  config.render_process_max_requests = 1
 end
 ```
 
-Persistent mode details:
-
-- Renders are newline-delimited JSON and processed one at a time.
-- Throughput scales with more worker processes.
-- It is fork-safe; clustered Puma and forking job runners spawn one Node child per worker.
-- The child recycles after `render_process_max_requests` renders. Set that option to `nil` to disable recycling.
-
 ### Render Options
 
-`render_options` is passed to [@react-email/render](https://react.email/docs/utilities/render). Use `html` and `text` keys to configure each output. Option keys are camelized before they cross into JavaScript, so `html_to_text_options` becomes `htmlToTextOptions`.
+`render_options` is passed to [@react-email/render](https://react.email/docs/utilities/render). HTML is rendered once; plain text is derived from that markup with `toPlainText` (or `unstableToPlainText` when `unstable_text_conversion` is set). `html.pretty` is applied only to the HTML part, so it does not change the text body. `text.html_to_text_options` is forwarded to `toPlainText`. Option keys are camelized before they cross into JavaScript, so `html_to_text_options` becomes `htmlToTextOptions`.
 
 ```ruby
 ReactEmailRails.configure do |config|

data/lib/react_email_rails/configuration.rb

@@ -5,21 +5,11 @@ class ReactEmailRails::Configuration
   DEV_RENDER_BIN = "node_modules/.bin/react-email-rails-dev"
 
   DEFAULT_RENDER_TIMEOUT = 10
+  DEVELOPMENT_RENDER_TIMEOUT = 30
   DEFAULT_RENDER_PROCESS_MAX_REQUESTS = 1_000
   DEFAULT_LIVE_RELOAD_URL = "http://localhost:5173"
 
-  RENDER_MODES = {
-    subprocess: ReactEmailRails::RenderModes::Subprocess,
-    persistent: ReactEmailRails::RenderModes::Persistent,
-  }.freeze
-
-  KEY_TRANSFORMS = {
-    camel: ->(key) { key.to_s.camelize },
-    lower_camel: ->(key) { key.to_s.camelize(:lower) },
-    dash: ->(key) { key.to_s.underscore.dasherize },
-    snake: ->(key) { key.to_s.underscore },
-    none: ->(key) { key },
-  }.freeze
+  DEFAULT_PROP_TRANSFORMER = ->(props:) { props }
 
   DEFAULT_RENDER_COMMAND = lambda do
     if Rails.env.development?
@@ -32,14 +22,13 @@ class ReactEmailRails::Configuration
   attr_accessor(
     :component_path_resolver,
     :render_options,
-    :transform_props,
     :on_render_error,
     :deep_merge_shared_props,
     :live_reload_url,
   )
 
   attr_reader(
-    :render_mode,
+    :prop_transformer,
     :render_timeout,
     :render_process_max_requests,
   )
@@ -48,11 +37,10 @@ class ReactEmailRails::Configuration
     def default
       new.tap do |config|
         config.component_path_resolver = ->(mailer:, action:) { "#{mailer}/#{action}" }
-        config.render_mode = :subprocess
         config.render_options = {}
-        config.render_timeout = DEFAULT_RENDER_TIMEOUT
+        config.render_timeout = Rails.env.development? ? DEVELOPMENT_RENDER_TIMEOUT : DEFAULT_RENDER_TIMEOUT
         config.render_process_max_requests = DEFAULT_RENDER_PROCESS_MAX_REQUESTS
-        config.transform_props = :lower_camel
+        config.prop_transformer = DEFAULT_PROP_TRANSFORMER
         config.on_render_error = nil
         config.deep_merge_shared_props = false
         config.live_reload_url = DEFAULT_LIVE_RELOAD_URL
@@ -66,12 +54,12 @@ class ReactEmailRails::Configuration
     live_reload_url.to_s.chomp("/")
   end
 
-  def render_mode=(value)
-    if (value.is_a?(Symbol) || value.is_a?(String)) && !RENDER_MODES.key?(value.to_sym)
-      raise(ArgumentError, "Unknown react-email-rails render mode: #{value.inspect}")
+  def prop_transformer=(value)
+    unless value.respond_to?(:call)
+      raise(ArgumentError, "react-email-rails prop_transformer must be callable")
     end
 
-    @render_mode = value
+    @prop_transformer = value
   end
 
   def render_timeout=(value)
@@ -88,14 +76,6 @@ class ReactEmailRails::Configuration
     @render_process_max_requests = value
   end
 
-  def resolved_render_mode
-    return render_mode unless render_mode.is_a?(Symbol) || render_mode.is_a?(String)
-
-    RENDER_MODES.fetch(render_mode.to_sym) do
-      raise(ArgumentError, "Unknown react-email-rails render mode: #{render_mode.inspect}")
-    end
-  end
-
   def resolve_render_options(context = nil)
     value =
       if render_options.respond_to?(:call) && context
@@ -106,7 +86,7 @@ class ReactEmailRails::Configuration
         render_options
       end
 
-    deep_transform_keys(value.as_json, KEY_TRANSFORMS.fetch(:lower_camel))
+    camelize_render_option_keys(value.as_json)
   end
 
   private
@@ -116,23 +96,26 @@ class ReactEmailRails::Configuration
   end
 
   def serialize_props(props)
-    deep_transform_keys(props.as_json, key_transform)
+    transform_serialized_props(props.as_json)
   end
 
-  def key_transform
-    transform = transform_props.respond_to?(:to_sym) ? transform_props.to_sym : transform_props
-
-    KEY_TRANSFORMS.fetch(transform) do
-      raise(ArgumentError, "Unknown react-email-rails prop transform: #{transform_props.inspect}")
+  def transform_serialized_props(value)
+    case value
+    when Hash
+      prop_transformer.call(props: value)
+    when Array
+      value.map { |item| transform_serialized_props(item) }
+    else
+      value
     end
   end
 
-  def deep_transform_keys(value, transform)
+  def camelize_render_option_keys(value)
     case value
-    when Array
-      value.map { |item| deep_transform_keys(item, transform) }
     when Hash
-      value.transform_keys { |key| transform.call(key) }.transform_values { |item| deep_transform_keys(item, transform) }
+      value.deep_transform_keys { |key| key.to_s.camelize(:lower) }
+    when Array
+      value.map { |item| camelize_render_option_keys(item) }
     else
       value
     end

data/lib/react_email_rails/render_protocol.rb

@@ -6,10 +6,6 @@ module ReactEmailRails
   module RenderProtocol
     extend(self)
 
-    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/{render_modes/persistent/server.rb → renderer/child.rb}

@@ -1,10 +1,6 @@
-class ReactEmailRails::RenderModes::Persistent::Server
+class ReactEmailRails::Renderer::Child
   STDERR_LIMIT = 8 * 1024
 
-  Status = Data.define(:success) do
-    def success? = success
-  end
-
   def initialize(command)
     @command = command
     @mutex = Mutex.new
@@ -14,17 +10,35 @@ class ReactEmailRails::RenderModes::Persistent::Server
     @requests = 0
   end
 
-  def capture(input:, timeout:, max_requests:)
+  def exchange(input, timeout:, max_requests:)
     with_retry_on_broken_pipe do
-      capture_once(input:, timeout:).tap { recycle_if_needed(max_requests) }
+      request(input, timeout:).tap { recycle_if_needed(max_requests) }
     end
   end
 
   def health_check(timeout:)
-    with_retry_on_broken_pipe { health_check_once(timeout:) }
+    with_retry_on_broken_pipe { request(JSON.generate(health: true), timeout:) }
   end
 
   def stop
+    if @mutex.owned?
+      stop_unlocked
+    else
+      @mutex.synchronize { stop_unlocked }
+    end
+  end
+
+  def abandon
+    release_io
+  rescue IOError
+    nil
+  end
+
+  private
+
+  attr_reader(:command)
+
+  def stop_unlocked
     if @wait_thread&.alive?
       terminate_process("TERM", @wait_thread.pid)
       @wait_thread.join(1)
@@ -37,14 +51,6 @@ class ReactEmailRails::RenderModes::Persistent::Server
     release_io
   end
 
-  def abandon
-    release_io
-  rescue IOError
-    nil
-  end
-
-  private
-
   def release_io
     [@stdin, @stdout, @stderr].compact.each { |io| io.close unless io.closed? }
     @stdin = @stdout = @stderr = @wait_thread = @stderr_reader = nil
@@ -58,38 +64,13 @@ class ReactEmailRails::RenderModes::Persistent::Server
     begin
       @mutex.synchronize(&block)
     rescue Errno::EPIPE, IOError
-      failure("render process exited before responding")
+      failed("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"]
-
-    success(JSON.generate(
-      {
-        protocolVersion: response["protocolVersion"],
-        packageVersion: response["packageVersion"],
-      }.tap do |body|
-        body[:html] = response["html"] if response.key?("html")
-        body[:text] = response["text"] if response.key?("text")
-      end,
-    ))
-  rescue JSON::ParserError => e
-    failure("render process returned invalid JSON: #{e.message}")
-  end
-
-  def health_check_once(timeout:)
-    response = request(JSON.generate(health: true), timeout:)
-    response["ok"] ? success(JSON.generate(response)) : failure(response["error"].to_s.presence || "render process failed")
-  rescue JSON::ParserError => e
-    failure("render process returned invalid JSON: #{e.message}")
-  end
-
   def start
-    @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(*command, "--persistent", pgroup: true)
+    release_io
+    @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(*command, pgroup: true)
     @stderr_buffer = +""
     @stdout_buffer = +""
     @requests = 0
@@ -108,9 +89,12 @@ class ReactEmailRails::RenderModes::Persistent::Server
     @stdin.flush
 
     line = read_response_line(timeout)
-    return { "ok" => false, "error" => "render process exited before responding" } unless line
+    return failed("render process exited before responding") unless line
 
     JSON.parse(line)
+  rescue JSON::ParserError => e
+    stop
+    failed("render process returned invalid JSON: #{e.message}")
   end
 
   def read_response_line(timeout)
@@ -128,7 +112,17 @@ class ReactEmailRails::RenderModes::Persistent::Server
 
       remaining = deadline - monotonic_time
       if remaining <= 0 || IO.select([@stdout], nil, nil, remaining).nil?
+        drain_stdout_nonblock
+        if (buffered_line = consume_buffered_response_line)
+          line << buffered_line
+          return line
+        end
+
+        line << @stdout_buffer
+        @stdout_buffer.clear
         stop
+        raise(Timeout::Error, unmatched_package_message) if line.empty?
+
         raise(Timeout::Error)
       end
 
@@ -139,9 +133,20 @@ class ReactEmailRails::RenderModes::Persistent::Server
       end
     end
   rescue EOFError
+    wait_for_stderr
     line.presence
   end
 
+  def unmatched_package_message
+    "no response received; gem and npm package react-email-rails must both be #{ReactEmailRails::VERSION}"
+  end
+
+  def drain_stdout_nonblock
+    loop { @stdout_buffer << @stdout.read_nonblock(16 * 1024) }
+  rescue IO::WaitReadable, IOError, Errno::EAGAIN, Errno::EINTR
+    nil
+  end
+
   def consume_buffered_response_line
     separator = @stdout_buffer.index("\n")
     return unless separator
@@ -160,7 +165,8 @@ class ReactEmailRails::RenderModes::Persistent::Server
   end
 
   def drain_stderr
-    @stderr.each do |chunk|
+    loop do
+      chunk = @stderr.readpartial(4096)
       @stderr_mutex.synchronize do
         @stderr_buffer << chunk
         @stderr_buffer = @stderr_buffer.byteslice(-STDERR_LIMIT, STDERR_LIMIT) if @stderr_buffer.bytesize > STDERR_LIMIT
@@ -170,20 +176,17 @@ class ReactEmailRails::RenderModes::Persistent::Server
     nil
   end
 
-  def success(stdout)
-    ReactEmailRails::RenderModes::Subprocess::CommandRunner::Result.new(
-      stdout:,
-      stderr: "",
-      status: Status.new(true),
-    )
+  def wait_for_stderr
+    @stderr_reader&.join(1)
   end
 
-  def failure(message)
-    ReactEmailRails::RenderModes::Subprocess::CommandRunner::Result.new(
-      stdout: "",
-      stderr: [message, stderr_buffer].reject(&:blank?).join("\n"),
-      status: Status.new(false),
-    )
+  def failed(message)
+    wait_for_stderr unless @wait_thread&.alive?
+
+    {
+      "ok" => false,
+      "error" => [message, stderr_buffer].reject(&:blank?).join("\n"),
+    }
   end
 
   def stderr_buffer

data/lib/react_email_rails/{render_modes/subprocess.rb → renderer.rb}

@@ -1,50 +1,86 @@
-class ReactEmailRails::RenderModes::Subprocess
+class ReactEmailRails::Renderer
   class << self
     def healthy?(command:, timeout:)
-      result = CommandRunner.capture([*command, "--health"], timeout:)
-      ReactEmailRails::RenderProtocol.healthy_result?(result)
+      body = child_for(command).health_check(timeout:)
+      ReactEmailRails::RenderProtocol.compatible_response?(body)
     rescue StandardError
       false
     end
+
+    def stop_all
+      @mutex.synchronize do
+        @children&.each_value(&:stop)
+        @children&.clear
+      end
+    end
+
+    private
+
+    def exchange(command, input, timeout:, max_requests:)
+      child_for(command).exchange(input, timeout:, max_requests:)
+    end
+
+    def child_for(command)
+      @mutex.synchronize do
+        reset_after_fork
+        @children[command.map(&:to_s)] ||= Child.new(command)
+      end
+    end
+
+    def reset_after_fork
+      return if @owner_pid == Process.pid && @children
+
+      @children&.each_value(&:abandon)
+      @children = {}
+      @owner_pid = Process.pid
+    end
   end
 
+  @mutex = Mutex.new
+
   def initialize(payload:, label:)
     @payload = payload
     @label = label
   end
 
   def render
-    run
-  end
+    body = exchange
+    raise(render_error(error_message(body["error"]))) unless body["ok"]
 
-  private
-
-  attr_reader(:payload, :label)
-
-  def run
-    result = capture(payload_json)
-    raise(render_error(error_message(result.stderr, result.status))) unless result.status.success?
-
-    body = JSON.parse(result.stdout)
     validate_metadata!(body)
     build_rendered_email(body)
-  rescue JSON::ParserError => e
-    raise(render_error("render process returned invalid JSON: #{e.message}"))
   rescue KeyError => e
     raise(render_error("render process returned an invalid response: missing #{e.key.inspect}"))
   end
 
-  def capture(input)
+  private
+
+  attr_reader(:payload, :label)
+
+  def exchange
     with_capture_rescues do
       validate_command!
-      CommandRunner.capture(command, input:, timeout: render_timeout)
+      self.class.send(
+        :exchange,
+        command,
+        payload_json,
+        timeout: render_timeout,
+        max_requests: render_process_max_requests,
+      )
     end
   end
 
   def with_capture_rescues
     yield
-  rescue Timeout::Error
-    raise(render_error("render process timed out after #{render_timeout}s"))
+  rescue Timeout::Error => e
+    detail = e.message
+    suffix =
+      if detail.present? && detail != "Timeout::Error" && detail != "execution expired"
+        " (#{detail})"
+      else
+        ""
+      end
+    raise(render_error("render process timed out after #{render_timeout}s#{suffix}"))
   rescue Errno::ENOENT
     raise(render_error("render command not found: #{command.inspect}"))
   end
@@ -57,12 +93,16 @@ class ReactEmailRails::RenderModes::Subprocess
     ReactEmailRails.configuration.render_timeout
   end
 
+  def render_process_max_requests
+    ReactEmailRails.configuration.render_process_max_requests
+  end
+
   def payload_json
     @payload_json ||= JSON.generate(payload)
   end
 
-  def error_message(stderr, status)
-    stderr.to_s.strip.presence || "render process exited with #{status}"
+  def error_message(message)
+    message.to_s.strip.presence || "render process failed"
   end
 
   def validate_command!
@@ -97,3 +137,5 @@ class ReactEmailRails::RenderModes::Subprocess
     ReactEmailRails::RenderError.new("React Email render failed for #{label}: #{message}")
   end
 end
+
+at_exit { ReactEmailRails::Renderer.stop_all }

data/lib/react_email_rails/version.rb

@@ -1,3 +1,3 @@
 module ReactEmailRails
-  VERSION = "0.11.1"
+  VERSION = "0.12.1"
 end

data/lib/react_email_rails.rb

@@ -6,6 +6,7 @@ require("active_support/notifications")
 require("active_support/core_ext/object/blank")
 require("active_support/core_ext/object/json")
 require("active_support/core_ext/hash/deep_merge")
+require("active_support/core_ext/hash/keys")
 require("active_support/inflector")
 require("rails/railtie")
 
@@ -16,12 +17,8 @@ require_relative("react_email_rails/render_protocol")
 require_relative("react_email_rails/action_mailer")
 require_relative("react_email_rails/render_error")
 require_relative("react_email_rails/rendered_email")
-require_relative("react_email_rails/render_modes")
-require_relative("react_email_rails/render_modes/subprocess")
-require_relative("react_email_rails/render_modes/subprocess/command_runner")
-require_relative("react_email_rails/render_modes/persistent")
-require_relative("react_email_rails/render_modes/persistent/server")
-require_relative("react_email_rails/render_modes/persistent/command_runner")
+require_relative("react_email_rails/renderer")
+require_relative("react_email_rails/renderer/child")
 require_relative("react_email_rails/configuration")
 require_relative("react_email_rails/tasks")
 require_relative("react_email_rails/props_resolver")
@@ -45,7 +42,7 @@ module ReactEmailRails
       payload[:renderOptions] = render_options if render_options.present?
 
       instrument(component:) do
-        configuration.resolved_render_mode.new(payload:, label: component).render
+        renderer_class.new(payload:, label: component).render
       end
     rescue ReactEmailRails::RenderError => e
       configuration.on_render_error&.call(e, component:)
@@ -53,7 +50,7 @@ module ReactEmailRails
     end
 
     def healthy?
-      configuration.resolved_render_mode.healthy?(
+      Renderer.healthy?(
         command: configuration.send(:resolved_render_command),
         timeout: configuration.render_timeout,
       )
@@ -63,6 +60,10 @@ module ReactEmailRails
 
     private
 
+    def renderer_class
+      Renderer
+    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.11.1
+  version: 0.12.1
 platform: ruby
 authors:
 - Supertape
@@ -158,14 +158,10 @@ files:
 - lib/react_email_rails/props_resolver.rb
 - lib/react_email_rails/railtie.rb
 - lib/react_email_rails/render_error.rb
-- lib/react_email_rails/render_modes.rb
-- lib/react_email_rails/render_modes/persistent.rb
-- lib/react_email_rails/render_modes/persistent/command_runner.rb
-- lib/react_email_rails/render_modes/persistent/server.rb
-- lib/react_email_rails/render_modes/subprocess.rb
-- lib/react_email_rails/render_modes/subprocess/command_runner.rb
 - lib/react_email_rails/render_protocol.rb
 - lib/react_email_rails/rendered_email.rb
+- lib/react_email_rails/renderer.rb
+- lib/react_email_rails/renderer/child.rb
 - lib/react_email_rails/shared_props.rb
 - lib/react_email_rails/tasks.rb
 - lib/react_email_rails/version.rb

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

@@ -1,40 +0,0 @@
-class ReactEmailRails::RenderModes::Persistent::CommandRunner
-  @mutex = Mutex.new
-
-  class << self
-    def capture(command, input:, timeout:, max_requests: nil)
-      server_for(command).capture(input:, timeout:, max_requests:)
-    end
-
-    def healthy?(command, timeout:)
-      result = server_for(command).health_check(timeout:)
-      ReactEmailRails::RenderProtocol.healthy_result?(result)
-    rescue StandardError
-      false
-    end
-
-    def stop_all
-      @mutex.synchronize do
-        @servers&.each_value(&:stop)
-        @servers&.clear
-      end
-    end
-
-    private
-
-    def server_for(command)
-      @mutex.synchronize do
-        reset_after_fork
-        @servers[command.map(&:to_s)] ||= ReactEmailRails::RenderModes::Persistent::Server.new(command)
-      end
-    end
-
-    def reset_after_fork
-      return if @owner_pid == Process.pid && @servers
-
-      @servers&.each_value(&:abandon)
-      @servers = {}
-      @owner_pid = Process.pid
-    end
-  end
-end

data/lib/react_email_rails/render_modes/persistent.rb

@@ -1,26 +0,0 @@
-class ReactEmailRails::RenderModes::Persistent < ReactEmailRails::RenderModes::Subprocess
-  class << self
-    def healthy?(command:, timeout:)
-      CommandRunner.healthy?(command, timeout:)
-    end
-  end
-
-  private
-
-  def capture(input)
-    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.render_process_max_requests
-  end
-end
-
-at_exit { ReactEmailRails::RenderModes::Persistent::CommandRunner.stop_all }

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

@@ -1,56 +0,0 @@
-class ReactEmailRails::RenderModes::Subprocess::CommandRunner
-  Result = Data.define(:stdout, :stderr, :status)
-
-  class << self
-    def capture(command, input: nil, timeout:)
-      new(command:, input:, timeout:).capture
-    end
-  end
-
-  def initialize(command:, input:, timeout:)
-    @command = command
-    @input = input
-    @timeout = timeout
-  end
-
-  def capture
-    Open3.popen3(*command, pgroup: true) do |stdin, stdout, stderr, wait_thread|
-      out_reader = read_async(stdout)
-      err_reader = read_async(stderr)
-
-      write_input(stdin)
-
-      if wait_thread.join(timeout).nil?
-        terminate_process("KILL", wait_thread.pid)
-        wait_thread.join
-        out_reader.kill
-        err_reader.kill
-        raise(Timeout::Error)
-      end
-
-      Result.new(stdout: out_reader.value, stderr: err_reader.value, status: wait_thread.value)
-    end
-  end
-
-  private
-
-  attr_reader(:command, :input, :timeout)
-
-  def read_async(io)
-    Thread.new { io.read }.tap { |thread| thread.report_on_exception = false }
-  end
-
-  def write_input(stdin)
-    stdin.write(input) if input
-  rescue Errno::EPIPE
-    nil
-  ensure
-    stdin.close
-  end
-
-  def terminate_process(signal, pid)
-    Process.kill(signal, -pid)
-  rescue Errno::ESRCH, Errno::EPERM
-    nil
-  end
-end

data/lib/react_email_rails/render_modes.rb

@@ -1 +0,0 @@
-module ReactEmailRails::RenderModes; end