react-email-rails 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5aaa4184f5aef5765da5cefbb47b85c6b1619f61d8cf3d7f722c6268fe8bfdf
-  data.tar.gz: 25d7d5100887b3976a0c258aa83df20c74080e042bea88f16767c4d7dc227055
+  metadata.gz: 8f53daab3807503144d3acc647a0d82c164e7c580a01a6c515131eee0f1dbfd9
+  data.tar.gz: 4e6529c8d47c16201f929c4c3a4486ec2d8bcf5965ac459b0c99b47bd8d88760
 SHA512:
-  metadata.gz: 78c3a0fb601dd5d81d2705872d3d2b7de0ed7876dd02013fc9b9108f0adbabd36e39b1f9dd92128d2a9005ee514679e7fcc3b8b5983ef21374c7d5a57c913349
-  data.tar.gz: 7a3a777b82c24144e8447c086004f61cb3c1f9d6dff596c6a309c1d103a6751eef8b78f45445794a028c9e15aea56a2930df11d933cc551d6d95f4cfda4f566e
+  metadata.gz: 395b4fb684b90dc42d154d2a85138ac4aad707e0789f3e5d980a5fd809049643e9255db6bdb6b255650e71288d6c4a8c2d9e81e3b01841e9649991844fe0a2f1
+  data.tar.gz: 0360e86df8ed619d6f6ab4294bbbd2c0659bb942d0cb906c68389b17e1541515e1ba1ae5c0f8cb6a8b2ae439d4c87d4d1b649c8e609f8f62893834351c867735

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.2
+
+- Support Vite 8 hook filters while keeping production email bundles standalone by default.
+- Keep development email rendering compatible with Vite's module runner.
+
+## 0.1.1
+
+- Build production React Email bundles from Rails asset tasks with an isolated email-only Vite build.
+- Add `react-email-rails-build` for direct production email bundle builds.
+
 ## 0.1.0
 
 - Initial public release.

data/CONTRIBUTING.md

@@ -22,47 +22,18 @@ cd vite && pnpm run build
 
 The Ruby gem version in `lib/react_email_rails/version.rb` is the package version source of truth. The renderer protocol version in `lib/react_email_rails/render_protocol.rb` is also synced into the Vite package. Run `cd vite && pnpm run sync:version` after changing either one.
 
-## Release Checks
-
-Before publishing, verify both packages can be built:
-
-```sh
-bundle exec rake build
-cd vite && pnpm pack --dry-run
-```
-
 ## Publishing
 
 Releases are tag-driven. Pushing `vX.Y.Z` to GitHub runs `.github/workflows/release.yml`, publishes the Ruby gem to RubyGems, publishes the Vite package to npm, and creates the GitHub Release with the built `.gem` and `.tgz` artifacts.
 
 ### Patch, Minor, and Major Releases
 
-Prepare the version bump:
+Update the source-of-truth gem version in `lib/react_email_rails/version.rb`, update `CHANGELOG.md`, and commit the release prep on `main` or open and merge a release pull request. Then tag the release commit:
 
 ```sh
-ruby scripts/prepare_release.rb patch
-# or: ruby scripts/prepare_release.rb minor
-# or: ruby scripts/prepare_release.rb major
+bin/release
 ```
 
-Replace the generated `CHANGELOG.md` TODO entry with the actual release notes, then run the checks:
-
-```sh
-ruby scripts/check_version_sync.rb
-bin/test
-bin/lint
-cd vite && pnpm run ci && pnpm pack --dry-run
-```
-
-Commit the release prep on `main` or open and merge a release pull request. Then tag the release commit:
-
-```sh
-git switch main
-git pull --ff-only origin main
-VERSION=$(ruby -r ./lib/react_email_rails/version -e 'print ReactEmailRails::VERSION')
-ruby scripts/check_release_tag.rb "v$VERSION"
-git tag -a "v$VERSION" -m "v$VERSION"
-git push origin "v$VERSION"
-```
+`bin/release` fetches `origin/main`, validates the version and changelog, infers whether the release is patch, minor, major, or initial from the existing SemVer tags, creates the annotated `vX.Y.Z` tag on `origin/main`, and pushes it after confirmation.
 
 The GitHub release workflow handles the rest. If publishing fails before both registries are updated, do not reuse the same version unless neither registry accepted it; bump to the next patch version and release again.

data/README.md

@@ -25,7 +25,7 @@ Building HTML emails is painfully archaic. [React Email](https://react.email) is
 
 **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,** Vite builds a server-side email bundle ahead of time. The plugin adds a dedicated `email` build environment, so your normal `vite build` emits the bundle alongside your client assets.
+**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.
 
 Delivery, headers, multipart parts, previews, queues, and callbacks all stay normal Action Mailer. If rendering fails, no email is sent and `ReactEmailRails::RenderError` is raised.
 
@@ -64,6 +64,13 @@ 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:
+
+- `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/rails react_email_rails:build` builds the bundle directly when CI or tests need it.
+
 ### Manual Install
 
 Install the npm package and peer dependencies manually:
@@ -384,18 +391,17 @@ Every render emits an [ActiveSupport::Notifications](https://guides.rubyonrails.
 
 ```ruby
 ActiveSupport::Notifications.subscribe("render.react-email-rails") do |event|
-  Rails.logger.info(
-    "[react-email-rails] rendered #{event.payload[:component]} " \
-    "(#{event.payload[:html_bytes]} bytes) in #{event.duration.round(1)}ms"
-  )
+  next if event.payload[:exception]
+
+  Rails.logger.info("[react-email-rails] Rendered #{event.payload[:component]} (Duration: #{event.duration.round}ms | Size: #{event.payload[:html_bytes]} bytes)")
 end
 ```
 
 ### Vite Configuration
 
-Most apps only need the `reactEmailRails()` plugin from [Quick Start](#quick-start). The options below change where components are discovered and how the bundle handles dependencies.
+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.
 
-In development, the renderer loads the `reactEmailRails()` plugin, JSX support, and your `resolve`, `define`, and `css` config — but none of your other dev-server plugins.
+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.
 
 #### Plugin Options
 
@@ -404,7 +410,8 @@ In development, the renderer loads the `reactEmailRails()` plugin, JSX support,
 | `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` |
-| `standalone` | `true` | Inline SSR dependencies with `ssr.noExternal: true` |
+| `standalone` | `true` | Inline production email bundle dependencies |
+| `vite` | `{}` | Extra email-only Vite config for compilation and resolution |
 
 Use a custom directory:
 
@@ -426,9 +433,31 @@ reactEmailRails({
 
 Component names come from the Vite directory layout (see [Component Names](#component-names)). To map mailer actions to a different layout, override `component_path_resolver` on the Ruby side rather than renaming in the plugin, so both halves stay in sync.
 
+#### 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:
+
+```ts
+import mdx from "@mdx-js/rollup"
+import { defineConfig } from "vite"
+import { reactEmailRails } from "react-email-rails"
+
+export default defineConfig({
+  plugins: [
+    reactEmailRails({
+      vite: {
+        plugins: [mdx()],
+      },
+    }),
+  ],
+})
+```
+
+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.
+
 #### Standalone Builds
 
-By default the 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.
+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.
 
 Set `standalone: false` when your runtime already ships `node_modules` and you prefer a smaller SSR-style bundle:
 
@@ -442,23 +471,29 @@ Externalized bundles are smaller and may build faster, but the renderer needs th
 
 ## Deployment
 
-For a standard Rails + Vite deploy, there is nothing extra to configure. Keep running your normal asset build and the email bundle is emitted alongside your client assets.
+For production deploys, run the normal Rails asset task:
 
-### Standard Vite Builds
+```sh
+bin/rails assets:precompile
+```
 
-The plugin registers a dedicated `email` [build environment](https://vite.dev/guide/api-environment), so a normal `vite build` writes `tmp/react-email-rails/emails.js`, which the bundled production renderer runs with Node. With [rails_vite](https://github.com/skryukov/rails_vite/), this already happens during `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 bundle is required, not an optimization. If it's missing, renders raise `ReactEmailRails::RenderError` and no mail is sent. Make sure `vite build` runs anywhere that renders mail, the same as for the rest of your assets.
+You can run it directly when needed:
 
-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.
+```sh
+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.
 
-### Custom Vite Builds
+The bundle is required, not an optimization. If it's missing, renders raise `ReactEmailRails::RenderError` and no mail is sent.
 
-To emit the bundle without a dedicated command, the plugin opts your project into Vite's [whole-app build](https://vite.dev/guide/api-environment):
+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.
 
-- A plain `vite build` builds every configured environment in one pass. For a standard client-only app, that's just your client assets plus the `email` bundle.
-- If you've defined other Vite environments, such as a custom `ssr` build, they build in the same pass too.
-- If your Vite config defines a custom `builder.buildApp`, make sure it builds `builder.environments.email` alongside your other environments. Custom builders replace Vite's default whole-app build orchestration.
+The build command preserves `emails.path`, `emails.extension`, `emails.ignore`, `standalone`, and email-only `vite` options.
 
 ### Runtime Dependencies
 
@@ -470,8 +505,8 @@ Boot verification is disabled by default. If you want the app to check the rende
 
 ```ruby
 ReactEmailRails.configure do |config|
-  config.verify_render_on_boot = -> { Rails.env.production? && Sidekiq.server? }
   config.render_mode = :persistent if Rails.env.production? && Sidekiq.server?
+  config.verify_render_on_boot = -> { Rails.env.production? && Sidekiq.server? }
 end
 ```
 

data/lib/react_email_rails/configuration.rb

@@ -1,5 +1,6 @@
 class ReactEmailRails::Configuration
   BUNDLE_PATH = "tmp/react-email-rails/emails.js"
+  BUILD_BIN = "node_modules/.bin/react-email-rails-build"
   DEV_RENDER_BIN = "node_modules/.bin/react-email-rails-dev"
 
   DEFAULT_RENDER_TIMEOUT = 10

data/lib/react_email_rails/railtie.rb

@@ -5,6 +5,8 @@ class ReactEmailRails::Railtie < Rails::Railtie
     end
   end
 
+  rake_tasks { load(File.expand_path("../tasks/react_email_rails/build.rake", __dir__)) }
+
   config.after_initialize do
     if ReactEmailRails.configuration.verify_render_on_boot? && !ReactEmailRails.healthy?
       Rails.logger.error(

data/lib/react_email_rails/render_modes/subprocess.rb

@@ -82,7 +82,7 @@ class ReactEmailRails::RenderModes::Subprocess
     return unless command_path == "node" && bundle_path.end_with?(ReactEmailRails::Configuration::BUNDLE_PATH)
     return if File.file?(bundle_path)
 
-    raise(render_error("email bundle not found at #{bundle_path.inspect}; run vite build before rendering React emails"))
+    raise(render_error("email bundle not found at #{bundle_path.inspect}; run react-email-rails-build before rendering React emails"))
   end
 
   def validate_response!(body)

data/lib/react_email_rails/tasks.rb

@@ -0,0 +1,32 @@
+require("fileutils")
+
+module ReactEmailRails::Tasks
+  class << self
+    def build
+      command = build_command
+      raise("react-email-rails build command not found at #{command.inspect}; run JavaScript package install first") unless File.exist?(command)
+
+      system(command, exception: true, chdir: Rails.root.to_s)
+      raise("react-email-rails build completed, but the email bundle was not found at #{bundle_path.inspect}") unless File.file?(bundle_path)
+    end
+
+    def clobber
+      FileUtils.rm_rf(Rails.root.join(File.dirname(ReactEmailRails::Configuration::BUNDLE_PATH)))
+    end
+
+    private
+
+    def build_command
+      candidates = [
+        ReactEmailRails::Configuration::BUILD_BIN,
+        "#{ReactEmailRails::Configuration::BUILD_BIN}.cmd",
+      ]
+      candidates.map { |path| Rails.root.join(path).to_s }.find { |path| File.exist?(path) } ||
+        Rails.root.join(ReactEmailRails::Configuration::BUILD_BIN).to_s
+    end
+
+    def bundle_path
+      Rails.root.join(ReactEmailRails::Configuration::BUNDLE_PATH).to_s
+    end
+  end
+end

data/lib/react_email_rails/version.rb

@@ -1,3 +1,3 @@
 module ReactEmailRails
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/lib/react_email_rails.rb

@@ -22,6 +22,7 @@ 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/configuration")
+require_relative("react_email_rails/tasks")
 require_relative("react_email_rails/props_resolver")
 require_relative("react_email_rails/railtie")
 

data/lib/tasks/react_email_rails/build.rake

@@ -0,0 +1,23 @@
+namespace(:react_email_rails) do
+  desc("Build the React Email Rails production bundle")
+  task(build: :environment) { ReactEmailRails::Tasks.build }
+
+  desc("Remove the React Email Rails production bundle")
+  task(clobber: :environment) { ReactEmailRails::Tasks.clobber }
+end
+
+unless ENV["SKIP_REACT_EMAIL_RAILS_BUILD"]
+  if Rake::Task.task_defined?("assets:precompile")
+    Rake::Task["assets:precompile"].enhance(["react_email_rails:build"])
+  else
+    desc("Compile assets")
+    Rake::Task.define_task("assets:precompile" => "react_email_rails:build")
+  end
+
+  if Rake::Task.task_defined?("assets:clobber")
+    Rake::Task["assets:clobber"].enhance(["react_email_rails:clobber"])
+  else
+    desc("Remove compiled assets")
+    Rake::Task.define_task("assets:clobber" => "react_email_rails:clobber")
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: react-email-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Supertape
@@ -163,7 +163,9 @@ files:
 - 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/tasks.rb
 - lib/react_email_rails/version.rb
+- lib/tasks/react_email_rails/build.rake
 homepage: https://github.com/heysupertape/react-email-rails
 licenses:
 - MIT