react-email-rails 0.1.0 → 0.1.2

package/bin/build.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import { createBuilder } from "vite"
+import { fail, isolatedViteConfig, loadReactEmailRailsConfig } from "./shared.mjs"
+import { RENDER_PROTOCOL_VERSION, VERSION } from "../dist/version.js"
+
+if (process.argv.includes("--health")) {
+  process.stdout.write(
+    JSON.stringify({ ok: true, protocolVersion: RENDER_PROTOCOL_VERSION, packageVersion: VERSION }),
+  )
+  process.exit(0)
+}
+
+const args = process.argv.slice(2)
+const readOption = (long, short) => {
+  const prefixed = args.find((arg) => arg.startsWith(`${long}=`))
+  if (prefixed) return prefixed.slice(long.length + 1)
+
+  const longIndex = args.indexOf(long)
+  if (longIndex !== -1) return args[longIndex + 1]
+
+  if (!short) return undefined
+  const shortIndex = args.indexOf(short)
+  return shortIndex === -1 ? undefined : args[shortIndex + 1]
+}
+
+const root = args.find((arg, index) => {
+  if (arg.startsWith("-")) return false
+  const previous = args[index - 1]
+  return (
+    previous !== "--mode" &&
+    previous !== "-m" &&
+    previous !== "--config" &&
+    previous !== "-c" &&
+    previous !== "--configLoader" &&
+    previous !== "--logLevel" &&
+    previous !== "-l"
+  )
+})
+const mode = readOption("--mode", "-m") ?? "production"
+const configFile = readOption("--config", "-c")
+const configLoader = readOption("--configLoader")
+const logLevel = readOption("--logLevel", "-l")
+
+process.env.NODE_ENV ??= "production"
+
+const { userConfig, plugin, vite } = await loadReactEmailRailsConfig({
+  command: "build",
+  mode,
+  root,
+  configFile,
+  logLevel,
+  configLoader,
+})
+
+// Build production emails with the same isolation principle as the dev renderer:
+// keep component resolution and transforms, but leave unrelated app plugins out
+// of the email environment so client/global plugin hooks cannot break SSR output.
+const builder = await createBuilder(
+  isolatedViteConfig(userConfig, vite, {
+    root: root ?? userConfig.root,
+    configFile: false,
+    mode,
+    builder: {},
+    plugins: [plugin],
+    appType: "custom",
+    clearScreen: false,
+    logLevel,
+  }),
+  null,
+)
+
+const environment = builder.environments.email
+if (!environment) fail("react-email-rails: email build environment not found")
+
+await builder.build(environment)

package/bin/config.mjs

@@ -1,19 +1,9 @@
 #!/usr/bin/env node
-import { loadConfigFromFile } from "vite"
+import { loadReactEmailRailsConfig } from "./shared.mjs"
 
-const loaded = await loadConfigFromFile({ command: "serve", mode: process.env.NODE_ENV ?? "development" })
-const plugins = (loaded?.config?.plugins ?? []).flat(Infinity).filter(Boolean)
-const plugin = plugins.find((plugin) => plugin.name === "react-email-rails")
-const metadata = plugin?.[Symbol.for("react-email-rails.config")]
-
-if (!plugin) {
-  process.stderr.write("react-email-rails: reactEmailRails() plugin not found in the Vite config\n")
-  process.exit(1)
-}
-
-if (!metadata) {
-  process.stderr.write("react-email-rails: reactEmailRails() plugin metadata not found\n")
-  process.exit(1)
-}
+const { metadata } = await loadReactEmailRailsConfig({
+  command: "serve",
+  mode: process.env.NODE_ENV ?? "development",
+})
 
 process.stdout.write(JSON.stringify(metadata))

package/bin/dev.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { createServer, isRunnableDevEnvironment, loadConfigFromFile } from "vite"
+import { createServer, isRunnableDevEnvironment } from "vite"
+import { fail, isolatedViteConfig, loadReactEmailRailsConfig } from "./shared.mjs"
 import { RENDER_PROTOCOL_VERSION, VERSION } from "../dist/version.js"
 
 if (process.argv.includes("--health")) {
@@ -18,45 +19,49 @@ const logger = {
   hasWarned: false,
 }
 
-// Load only this plugin and aliases; host dev-server plugins have global side effects.
-const loaded = await loadConfigFromFile({ command: "serve", mode: "development" })
-const userConfig = loaded?.config ?? {}
-const emailPlugin = (userConfig.plugins ?? [])
-  .flat(Infinity)
-  .find((plugin) => plugin?.name === "react-email-rails")
-
-if (!emailPlugin) {
-  process.stderr.write("react-email-rails: reactEmailRails() plugin not found in the Vite config\n")
-  process.exit(1)
+const divertStdout = () => {
+  const write = process.stdout.write.bind(process.stdout)
+  process.stdout.write = (chunk, encoding, callback) => {
+    if (typeof encoding === "function") return process.stderr.write(chunk, encoding)
+    return process.stderr.write(chunk, encoding, callback)
+  }
+  return () => {
+    process.stdout.write = write
+  }
 }
 
+// Load only this plugin and aliases; host dev-server plugins have global side effects.
+const restoreStdout = divertStdout()
+const { userConfig, plugin, vite } = await loadReactEmailRailsConfig({
+  command: "serve",
+  mode: "development",
+})
+
 // Forward config that affects how components resolve and compile (but not the
 // host's dev-server plugins, which have global side effects), so dev rendering
 // stays close to the production email bundle.
-const server = await createServer({
-  configFile: false,
-  resolve: userConfig.resolve,
-  define: userConfig.define,
-  css: userConfig.css,
-  esbuild: { jsx: "automatic" },
-  plugins: [emailPlugin],
-  server: { middlewareMode: true },
-  appType: "custom",
-  clearScreen: false,
-  customLogger: logger,
-})
+const server = await createServer(
+  isolatedViteConfig(userConfig, vite, {
+    configFile: false,
+    plugins: [plugin],
+    server: { middlewareMode: true },
+    appType: "custom",
+    clearScreen: false,
+    customLogger: logger,
+  }),
+)
 
 // Render through the same `email` environment the production build uses, so dev
 // and build resolve and compile components identically.
 const environment = server.environments.email
 if (!isRunnableDevEnvironment(environment)) {
   await server.close()
-  process.stderr.write("react-email-rails: the email environment is not runnable\n")
-  process.exit(1)
+  fail("react-email-rails: the email environment is not runnable")
 }
 
 try {
   const { run } = await environment.runner.import("virtual:react-email-rails/server")
+  restoreStdout()
   await run()
 } finally {
   await server.close()

package/bin/shared.mjs

@@ -0,0 +1,76 @@
+import { loadConfigFromFile, mergeConfig } from "vite"
+
+const CONFIG_SYMBOL = Symbol.for("react-email-rails.config")
+const VITE_CONFIG_SYMBOL = Symbol.for("react-email-rails.vite")
+const EMAIL_VITE_CONFIG_KEYS = [
+  "assetsInclude",
+  "css",
+  "define",
+  "esbuild",
+  "json",
+  "oxc",
+  "plugins",
+  "resolve",
+]
+
+export async function loadReactEmailRailsConfig({
+  command,
+  mode,
+  root,
+  configFile,
+  logLevel,
+  configLoader,
+}) {
+  const loaded = await loadConfigFromFile(
+    { command, mode },
+    configFile,
+    root,
+    logLevel,
+    undefined,
+    configLoader,
+  )
+  const userConfig = loaded?.config ?? {}
+  const plugin = (userConfig.plugins ?? [])
+    .flat(Infinity)
+    .find((plugin) => plugin?.name === "react-email-rails")
+  const metadata = plugin?.[CONFIG_SYMBOL]
+
+  if (!plugin) fail("react-email-rails: reactEmailRails() plugin not found in the Vite config")
+  if (!metadata) fail("react-email-rails: reactEmailRails() plugin metadata not found")
+
+  return {
+    userConfig,
+    plugin,
+    metadata,
+    vite: plugin[VITE_CONFIG_SYMBOL] ?? {},
+  }
+}
+
+export function isolatedViteConfig(userConfig, emailViteConfig, baseConfig) {
+  const userEsbuild =
+    userConfig.esbuild && typeof userConfig.esbuild === "object" ? userConfig.esbuild : {}
+  const forwarded = {
+    assetsInclude: userConfig.assetsInclude,
+    resolve: userConfig.resolve,
+    define: userConfig.define,
+    css: userConfig.css,
+    json: userConfig.json,
+    oxc: userConfig.oxc,
+    esbuild: { ...userEsbuild, jsx: userEsbuild.jsx ?? "automatic" },
+  }
+
+  return mergeConfig({ ...forwarded, ...baseConfig }, pickEmailViteConfig(emailViteConfig))
+}
+
+function pickEmailViteConfig(config) {
+  return Object.fromEntries(
+    EMAIL_VITE_CONFIG_KEYS.flatMap((key) =>
+      config && Object.hasOwn(config, key) ? [[key, config[key]]] : [],
+    ),
+  )
+}
+
+export function fail(message) {
+  process.stderr.write(`${message}\n`)
+  process.exit(1)
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "vite";
+import type { Plugin, UserConfig } from "vite";
 export type EmailsOption = string | {
     path?: string;
     extension?: string | string[];
@@ -7,6 +7,10 @@ export type EmailsOption = string | {
 export type ReactEmailRailsOptions = {
     emails?: EmailsOption;
     standalone?: boolean;
+    vite?: ReactEmailRailsViteOptions;
+};
+export type ReactEmailRailsViteOptions = Pick<UserConfig, "assetsInclude" | "css" | "define" | "esbuild" | "json" | "plugins" | "resolve"> & {
+    oxc?: unknown;
 };
 export declare const EMAIL_ENVIRONMENT = "email";
 export declare function reactEmailRails(options?: ReactEmailRailsOptions): Plugin;

package/dist/index.js

@@ -4,9 +4,11 @@ const VIRTUAL_SERVER = "virtual:react-email-rails/server";
 const VIRTUAL_MAIN = "virtual:react-email-rails/main";
 const RESOLVED_SERVER = `\0${VIRTUAL_SERVER}`;
 const RESOLVED_MAIN = `\0${VIRTUAL_MAIN}`;
+const VIRTUAL_MODULE_PATTERN = /virtual:react-email-rails\/(?:server|main)$/;
 // The dedicated build environment that emits the server-side email bundle.
 export const EMAIL_ENVIRONMENT = "email";
 const CONFIG_SYMBOL = Symbol.for("react-email-rails.config");
+const VITE_CONFIG_SYMBOL = Symbol.for("react-email-rails.vite");
 const OUT_DIR = "tmp/react-email-rails";
 const BUNDLE_FILE = "emails.js";
 export function reactEmailRails(options = {}) {
@@ -34,41 +36,48 @@ export function reactEmailRails(options = {}) {
     const globArg = JSON.stringify(globPatterns.length === 1 ? globPatterns[0] : globPatterns);
     const plugin = {
         name: "react-email-rails",
-        resolveId(id) {
-            if (id === VIRTUAL_SERVER)
-                return RESOLVED_SERVER;
-            if (id === VIRTUAL_MAIN)
-                return RESOLVED_MAIN;
+        resolveId: {
+            filter: { id: VIRTUAL_MODULE_PATTERN },
+            handler(id) {
+                if (id === VIRTUAL_SERVER)
+                    return RESOLVED_SERVER;
+                if (id === VIRTUAL_MAIN)
+                    return RESOLVED_MAIN;
+            },
         },
-        load(id) {
-            if (id === RESOLVED_SERVER) {
-                return [
-                    `import { serve, toComponentName } from "react-email-rails/runtime"`,
-                    `const modules = import.meta.glob(${globArg})`,
-                    `const extensions = ${JSON.stringify(extensions)}`,
-                    `const registry = Object.create(null)`,
-                    `for (const path in modules) {`,
-                    `  const extension = extensions.find((extension) => path.endsWith(extension)) ?? path.slice(path.lastIndexOf("."))`,
-                    `  registry[toComponentName(path, ${JSON.stringify(root)}, extension)] = modules[path]`,
-                    `}`,
-                    `export const run = () => serve(registry)`,
-                ].join("\n");
-            }
-            if (id === RESOLVED_MAIN) {
-                return `import { run } from ${JSON.stringify(VIRTUAL_SERVER)}\nrun()\n`;
-            }
+        load: {
+            filter: { id: VIRTUAL_MODULE_PATTERN },
+            handler(id) {
+                if (id === RESOLVED_SERVER) {
+                    return [
+                        `import { serve, toComponentName } from "react-email-rails/runtime"`,
+                        `const modules = import.meta.glob(${globArg})`,
+                        `const extensions = ${JSON.stringify(extensions)}`,
+                        `const registry = Object.create(null)`,
+                        `for (const path in modules) {`,
+                        `  const extension = extensions.find((extension) => path.endsWith(extension)) ?? path.slice(path.lastIndexOf("."))`,
+                        `  registry[toComponentName(path, ${JSON.stringify(root)}, extension)] = modules[path]`,
+                        `}`,
+                        `export const run = () => serve(registry)`,
+                    ].join("\n");
+                }
+                if (id === RESOLVED_MAIN) {
+                    return `import { run } from ${JSON.stringify(VIRTUAL_SERVER)}\nrun()\n`;
+                }
+            },
         },
-        config() {
-            // Register a dedicated `email` build environment and opt the app into
-            // building all environments, so a plain `vite build` emits the email
-            // bundle alongside the client assets — no separate build step required.
-            // The environment is a server consumer. Standalone builds inline Node
-            // dependencies by default so Rails runtime images do not need node_modules.
+        config(_config, env) {
+            // Register a dedicated `email` build environment. The official
+            // react-email-rails-build bin opts into building it with an isolated
+            // plugin stack so host app plugins cannot break email SSR builds.
+            // The environment is a server consumer. Production standalone builds inline
+            // Node dependencies by default so Rails runtime images do not need
+            // node_modules; dev rendering keeps dependencies external for Vite's module
+            // runner.
             return {
-                builder: {},
                 environments: {
                     [EMAIL_ENVIRONMENT]: {
-                        ...(standalone ? { resolve: { noExternal: true } } : {}),
+                        ...(standalone && env.command === "build" ? { resolve: { noExternal: true } } : {}),
                         build: {
                             ssr: true,
                             outDir: OUT_DIR,
@@ -98,6 +107,9 @@ export function reactEmailRails(options = {}) {
             ...metadata,
         },
     });
+    Object.defineProperty(plugin, VITE_CONFIG_SYMBOL, {
+        value: options.vite ?? {},
+    });
     return plugin;
 }
 export { RENDER_PROTOCOL_VERSION, VERSION } from "./version.js";

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.0";
+export declare const VERSION = "0.1.2";
 export declare const RENDER_PROTOCOL_VERSION = 1;

package/dist/version.js

@@ -1,2 +1,2 @@
-export const VERSION = "0.1.0";
+export const VERSION = "0.1.2";
 export const RENDER_PROTOCOL_VERSION = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-email-rails",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Build and send emails using React and Rails",
   "license": "MIT",
   "type": "module",
@@ -37,6 +37,7 @@
   },
   "types": "./dist/index.d.ts",
   "bin": {
+    "react-email-rails-build": "./bin/build.mjs",
     "react-email-rails-config": "./bin/config.mjs",
     "react-email-rails-dev": "./bin/dev.mjs"
   },

package/src/index.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "vite"
+import type { ConfigEnv, Plugin, UserConfig } from "vite"
 
 export type EmailsOption =
   | string
@@ -11,6 +11,14 @@ export type EmailsOption =
 export type ReactEmailRailsOptions = {
   emails?: EmailsOption
   standalone?: boolean
+  vite?: ReactEmailRailsViteOptions
+}
+
+export type ReactEmailRailsViteOptions = Pick<
+  UserConfig,
+  "assetsInclude" | "css" | "define" | "esbuild" | "json" | "plugins" | "resolve"
+> & {
+  oxc?: unknown
 }
 
 type PluginMetadata = {
@@ -31,10 +39,12 @@ const VIRTUAL_SERVER = "virtual:react-email-rails/server"
 const VIRTUAL_MAIN = "virtual:react-email-rails/main"
 const RESOLVED_SERVER = `\0${VIRTUAL_SERVER}`
 const RESOLVED_MAIN = `\0${VIRTUAL_MAIN}`
+const VIRTUAL_MODULE_PATTERN = /virtual:react-email-rails\/(?:server|main)$/
 
 // The dedicated build environment that emits the server-side email bundle.
 export const EMAIL_ENVIRONMENT = "email"
 const CONFIG_SYMBOL = Symbol.for("react-email-rails.config")
+const VITE_CONFIG_SYMBOL = Symbol.for("react-email-rails.vite")
 const OUT_DIR = "tmp/react-email-rails"
 const BUNDLE_FILE = "emails.js"
 
@@ -72,42 +82,49 @@ export function reactEmailRails(options: ReactEmailRailsOptions = {}): Plugin {
   const plugin: Plugin = {
     name: "react-email-rails",
 
-    resolveId(id) {
-      if (id === VIRTUAL_SERVER) return RESOLVED_SERVER
-      if (id === VIRTUAL_MAIN) return RESOLVED_MAIN
+    resolveId: {
+      filter: { id: VIRTUAL_MODULE_PATTERN },
+      handler(id) {
+        if (id === VIRTUAL_SERVER) return RESOLVED_SERVER
+        if (id === VIRTUAL_MAIN) return RESOLVED_MAIN
+      },
     },
 
-    load(id) {
-      if (id === RESOLVED_SERVER) {
-        return [
-          `import { serve, toComponentName } from "react-email-rails/runtime"`,
-          `const modules = import.meta.glob(${globArg})`,
-          `const extensions = ${JSON.stringify(extensions)}`,
-          `const registry = Object.create(null)`,
-          `for (const path in modules) {`,
-          `  const extension = extensions.find((extension) => path.endsWith(extension)) ?? path.slice(path.lastIndexOf("."))`,
-          `  registry[toComponentName(path, ${JSON.stringify(root)}, extension)] = modules[path]`,
-          `}`,
-          `export const run = () => serve(registry)`,
-        ].join("\n")
-      }
-
-      if (id === RESOLVED_MAIN) {
-        return `import { run } from ${JSON.stringify(VIRTUAL_SERVER)}\nrun()\n`
-      }
+    load: {
+      filter: { id: VIRTUAL_MODULE_PATTERN },
+      handler(id) {
+        if (id === RESOLVED_SERVER) {
+          return [
+            `import { serve, toComponentName } from "react-email-rails/runtime"`,
+            `const modules = import.meta.glob(${globArg})`,
+            `const extensions = ${JSON.stringify(extensions)}`,
+            `const registry = Object.create(null)`,
+            `for (const path in modules) {`,
+            `  const extension = extensions.find((extension) => path.endsWith(extension)) ?? path.slice(path.lastIndexOf("."))`,
+            `  registry[toComponentName(path, ${JSON.stringify(root)}, extension)] = modules[path]`,
+            `}`,
+            `export const run = () => serve(registry)`,
+          ].join("\n")
+        }
+
+        if (id === RESOLVED_MAIN) {
+          return `import { run } from ${JSON.stringify(VIRTUAL_SERVER)}\nrun()\n`
+        }
+      },
     },
 
-    config() {
-      // Register a dedicated `email` build environment and opt the app into
-      // building all environments, so a plain `vite build` emits the email
-      // bundle alongside the client assets — no separate build step required.
-      // The environment is a server consumer. Standalone builds inline Node
-      // dependencies by default so Rails runtime images do not need node_modules.
+    config(_config, env: ConfigEnv) {
+      // Register a dedicated `email` build environment. The official
+      // react-email-rails-build bin opts into building it with an isolated
+      // plugin stack so host app plugins cannot break email SSR builds.
+      // The environment is a server consumer. Production standalone builds inline
+      // Node dependencies by default so Rails runtime images do not need
+      // node_modules; dev rendering keeps dependencies external for Vite's module
+      // runner.
       return {
-        builder: {},
         environments: {
           [EMAIL_ENVIRONMENT]: {
-            ...(standalone ? { resolve: { noExternal: true } } : {}),
+            ...(standalone && env.command === "build" ? { resolve: { noExternal: true } } : {}),
             build: {
               ssr: true,
               outDir: OUT_DIR,
@@ -139,6 +156,9 @@ export function reactEmailRails(options: ReactEmailRailsOptions = {}): Plugin {
       ...metadata,
     },
   })
+  Object.defineProperty(plugin, VITE_CONFIG_SYMBOL, {
+    value: options.vite ?? {},
+  })
 
   return plugin
 }

package/src/version.ts

@@ -1,2 +1,2 @@
-export const VERSION = "0.1.0"
+export const VERSION = "0.1.2"
 export const RENDER_PROTOCOL_VERSION = 1