dotenvx, almost perfect replacement for dotenv

Kenn Ejima — Sun, 30 Mar 2025 04:39:47 +0000

When I first discovered dotenvx, I thought, “This is exactly what I was looking for!”

Now I can safely share the .env file with the team via Git. I used to pass around the entire .env using 1Password — which worked — but now we only need to share one secret: .env.keys.

No more rotating every API key when someone leaves the team. Just rotate the secret key. Fantastic!

Except the last part is not true. Team members can decrypt env vars and save them elsewhere. So yes, you still need to rotate API keys periodically.

That’s when it hit me — dotenvx solves .env distribution, but it doesn’t inherently improve security.

So I started thinking: why not stick with our battle-tested workflow and just bolt on encrypted .env distribution?

Keep .env in .gitignore as always
Add .env.encrypted to the repo
Let contributors decrypt with a command and update the full .env as needed

This allows for a transparent migration.

No need to change your dev server launch commands or update package.json to use dotenvx run all over the place. Just run a simple decrypt command when someone commits a new .env.encrypted. Keep the same mental model around .env.

This will also prevent the false sense of security that I felt — makes it clear you still need to rotate your API keys, because nothing is inherently changed. You just improved the process of distribution of .env, not security.

I think this aspect is very important to maintain the efficacy of security in practice.

I hope dotenvx will embrace this thought process for the spirit of progressive enhancement.

Unpacking React Router v7.4: A Source Code Guided Tour

Kenn Ejima — Sat, 29 Mar 2025 06:44:35 +0000

React Router has been the de facto standard for routing in React applications for years. With the release of version 6, and subsequent refinements leading up to v7.4.1, the library underwent a significant evolution, embracing modern React features and introducing powerful data loading and mutation capabilities.

But how is such a foundational library structured? What can we learn about its design, features, and philosophy by looking at its source code organization? Let's take a guided tour through the React Router v7.4.1 repository structure to gain a deeper understanding of the framework.

(Note: We're looking at the organization of the code, not dissecting every line. The goal is to understand the framework's architecture and features through its structure.)

The Big Picture: A Monorepo Approach

The first thing you notice is the root directory structure. It clearly indicates a monorepo setup, likely managed by pnpm (evident from pnpm-lock.yaml and pnpm-workspace.yaml). This structure is common for large JavaScript projects with multiple related packages.

├── packages/
│ ├── create-react-router/
│ ├── react-router/
│ ├── react-router-dev/
│ ├── react-router-dom/
│ ├── react-router-fs-routes/
│ ├── react-router-node/
│ ├── react-router-cloudflare/
│ └── ... (other adapters/utils)
├── docs/
├── examples/
├── integration/
├── decisions/
├── .github/

This monorepo structure tells us several things:

Modularity: React Router isn't a single monolithic library. It's broken down into distinct, publishable packages.
Core vs. Environment: There's a separation between the core routing logic and environment-specific bindings (like DOM, Node.js, Cloudflare).
Tooling: Dedicated packages exist for developer experience (react-router-dev, create-react-router).
Ecosystem: The presence of adapters (react-router-node, react-router-cloudflare, react-router-express, etc.) highlights the goal of being platform-agnostic where possible.

Let's dive into the key areas revealed by the source structure.

`packages/`: The Heart of the Framework

This directory contains the actual code distributed on npm. Understanding these packages is key to understanding React Router's capabilities.

1. `react-router` (The Core)

Location: packages/react-router/
Purpose: This is the engine. It contains the fundamental routing logic, context providers, core hooks (useParams, useLocation, useNavigate), route matching algorithms (matchPath, matchRoutes), and the data router primitives (createRouter, router state management). It's platform-agnostic.
Key Files (Conceptual): You'll find the implementation for <Router>, <Routes>, <Route>, <Outlet>, core hooks, history management abstractions, and the core logic driving data loaders and actions here (lib/router/router.ts, lib/components.tsx, lib/hooks.tsx).

2. `react-router-dom` (Web Bindings)

Location: packages/react-router-dom/
Purpose: This package adapts the core react-router for the web browser environment. It provides browser-specific routers (<BrowserRouter>, <HashRouter>), components like <Link> and <NavLink>, handles browser history integration, form submissions (<Form>), and importantly, re-exports everything from react-router.
Why Re-export? Historically, react-router-dom was the primary entry point. Re-exporting maintains backward compatibility and provides a single convenient import point for web developers. The index.ts file clearly shows this re-export strategy.
DOM-Specific Logic: Includes handling DOM events for links, integrating with the browser's History API, and managing scroll restoration (<ScrollRestoration>).

3. `react-router-dev` (Developer Experience)

Location: packages/react-router-dev/
Purpose: This is a crucial package for modern React Router development, particularly when using framework-like features (data loading, SSR, code splitting). It provides build tool integrations (especially Vite), a development CLI, and type generation.
Vite Integration (vite/): Contains the Vite plugin (plugin.ts) responsible for server-side rendering setup, client/server entry coordination, HMR (Hot Module Replacement) for routes, route module splitting, and more. This tight integration enables seamless SSR and efficient development workflows.
Type Generation (typegen/): Analyzes your route structure and generates TypeScript types for useLoaderData, useActionData, and useParams, drastically improving type safety. This is a huge DX win.
CLI (cli/): Provides commands like react-router dev and react-router build.

4. `create-react-router` (Project Scaffolding)

Location: packages/create-react-router/
Purpose: A command-line tool (npm create react-router@latest) to quickly set up new React Router projects with recommended configurations (often including Vite and react-router-dev). It simplifies boilerplate setup.

5. Platform Adapters (`react-router-node`, `react-router-cloudflare`, `react-router-express`, `react-router-architect`)

Location: packages/react-router-*/
Purpose: These packages provide adapters to run React Router's server-side features (SSR, data loading/actions) on specific platforms like Node.js (generic or Express), Cloudflare Workers, or Architect. They handle request/response abstractions and platform-specific APIs (like session storage strategies). This demonstrates the library's ambition to work seamlessly across different deployment environments.

6. Utility Packages (`react-router-fs-routes`, `react-router-remix-routes-option-adapter`, `react-router-serve`)

fs-routes: Implements file-system based routing conventions (similar to Next.js or Remix).
remix-routes-option-adapter: Likely facilitates using Remix-style route configuration.
serve: A simple production server for running built React Router applications.

`docs/`: Learning and Understanding

The structure of the docs/ directory is incredibly revealing about how the React Router team wants users to learn the library. It follows a structured approach:

start/: Getting started guides for different "modes" (Framework, Data, Declarative). This acknowledges that users might adopt RR with varying levels of feature usage.
tutorials/: Step-by-step guides to build specific things (e.g., the Address Book). Practical, hands-on learning.
how-to/: Focused guides on achieving specific tasks (e.g., error boundaries, file uploads, view transitions). Problem-oriented.
explanation/: Deeper dives into concepts (e.g., route matching, hydration, state management). Understanding-oriented.
api/: The detailed reference for every component, hook, and utility function, organized logically (Components, Hooks, Data Routers, Utils, etc.). Essential for lookup.
upgrading/: Guides for migrating from previous versions.

This structure mirrors established documentation best practices (like the Diátaxis framework) and shows a strong commitment to user education.

`examples/`: Practical Application

The examples/ directory complements the docs/ by providing standalone, runnable applications showcasing various features and patterns:

Basic Usage: basic, basic-data-router
Data Loading/Mutations: data-router, notes
Authentication: auth, auth-router-provider
Advanced Features: lazy-loading, ssr-data-router, error-boundaries, view-transitions, navigation-blocking
Customization: custom-link, custom-filter-link

Each example typically includes its own package.json, build setup (often Vite), and source code (src/App.tsx or similar). This allows users to isolate, run, and modify specific patterns.

`decisions/`: The "Why" Behind the Code

This is a gem for deep understanding. The decisions/ directory contains Architecture Decision Records (ADRs). These markdown files document significant design choices and the reasoning behind them. Examples include:

0002-lazy-route-modules.md
0003-data-strategy.md
0005-remixing-react-router.md (Shows the influence of Remix)
0010-splitting-up-client-and-server-code-in-vite.md

Reviewing these provides invaluable context on why React Router works the way it does, especially regarding data loading, Vite integration, and its relationship with Remix.

Testing and Quality (`integration/`, `packages/react-router/tests/`)

The presence of extensive test suites (integration/ for end-to-end tests across different setups, and __tests__/ within packages for unit/integration tests) demonstrates a commitment to stability and correctness. The integration tests, often using Playwright (playwright.config.ts), cover complex scenarios like:

Data loading (loader-test.ts, defer-test.ts)
Mutations (action-test.ts, form-test.ts)
Vite integration (vite-dev-test.ts, vite-build-test.ts, vite-ssr-test.ts)
Specific features (redirects-test.ts, scroll-test.ts, blocking-test.ts)

This robust testing strategy is crucial for a library depended upon by so many applications.

Configuration, Build, and CI (`.eslintrc`, `tsconfig.json`, `tsup.config.ts`, `.github/workflows/`)

These files reveal the underlying tooling and processes:

TypeScript: The project is heavily based on TypeScript (tsconfig.json files everywhere, .ts/.tsx extensions).
Build System: tsup is used for bundling individual packages (tsup.config.ts), likely chosen for its simplicity and speed for library building. Vite is used for examples, development (react-router-dev), and integration tests.
Linting/Formatting: ESLint (.eslintrc) and Prettier (prettier.config.js) enforce code quality and consistency.
CI/CD: GitHub Actions (.github/workflows/) automate testing (test.yml, integration-*.yml), formatting (format.yml), releases (release.yml), and other maintenance tasks. This ensures code quality and reliable releases.

Conclusion: What the Structure Tells Us

Exploring the React Router v7.4.1 source code structure reveals a mature, modular, and feature-rich framework designed for modern React development. Key takeaways from this tour include:

Modularity: A clear separation of concerns between the core logic, DOM bindings, developer tooling, and platform adapters via a monorepo.
Data-Centric: Data loading and mutations are first-class citizens, deeply integrated into the routing lifecycle (evident in core logic, docs, and examples).
Developer Experience Focus: Significant investment in tooling (@react-router/dev), type safety (typegen), project scaffolding (create-react-router), and comprehensive documentation (docs/, examples/).
Vite Integration: Vite is the preferred bundler for leveraging advanced features like SSR, HMR, and route module splitting seamlessly.
Platform Adaptability: Designed to work beyond the browser, with dedicated adapters for server environments.
Transparency: Design decisions are documented (decisions/), fostering community understanding.
Robustness: Extensive testing and automated CI/CD processes ensure quality and stability.

By understanding how React Router is organized, developers can better appreciate its capabilities, navigate its documentation more effectively, and leverage its powerful features to build sophisticated React applications. It's not just about the APIs; it's about the thoughtful architecture that enables them.

DEV Community: Kenn Ejima

dotenvx, almost perfect replacement for dotenv

Unpacking React Router v7.4: A Source Code Guided Tour

The Big Picture: A Monorepo Approach

packages/: The Heart of the Framework

1. react-router (The Core)

2. react-router-dom (Web Bindings)

3. react-router-dev (Developer Experience)

4. create-react-router (Project Scaffolding)

5. Platform Adapters (react-router-node, react-router-cloudflare, react-router-express, react-router-architect)

6. Utility Packages (react-router-fs-routes, react-router-remix-routes-option-adapter, react-router-serve)

docs/: Learning and Understanding

examples/: Practical Application

decisions/: The "Why" Behind the Code

Testing and Quality (integration/, packages/react-router/__tests__/)

Configuration, Build, and CI (.eslintrc, tsconfig.json, tsup.config.ts, .github/workflows/)