react-router-effect 1.0.2 → 2.0.0

package/README.md

@@ -27,7 +27,7 @@ const loader = makeLoader((args: Route.LoaderArgs) =>
 vp add react-router-effect effect react-router
 ```
 
-`effect` and `react-router` are peer dependencies.
+`effect` and `react-router` are peer dependencies. The library requires Effect 4 (`effect@^4.0.0`).
 
 ## Concepts
 
@@ -166,7 +166,7 @@ If a domain error implements `HttpServerRespondable`, you don't need to register
 it renders its own response:
 
 ```ts
-import { HttpServerRespondable, HttpServerResponse } from "effect/unstable/http";
+import { HttpServerRespondable, HttpServerResponse } from "effect/http";
 
 class NotAuthorizedError extends Data.TaggedError("NotAuthorizedError")<{}> {
   [HttpServerRespondable.symbol]() {

package/dist/index.d.mts

@@ -1,12 +1,12 @@
 import { Context, Effect, ManagedRuntime } from "effect";
-import { HttpServerRespondable } from "effect/unstable/http";
+import { HttpServerRespondable } from "effect/http";
 import { ActionFunctionArgs, LoaderFunctionArgs, MiddlewareFunction, RouterContext, UNSAFE_DataWithResponseInit } from "react-router";
 //#region src/errors.d.ts
 declare const ReturnableDataError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "ReturnableRouteError";
 } & Readonly<A>;
 /** Recoverable: short-circuits the loader but returns `data(...)` the component reads. */
-declare class ReturnableDataError<D> extends ReturnableDataError_base<{
+export declare class ReturnableDataError<D> extends ReturnableDataError_base<{
   data: D;
   init?: number | ResponseInit;
 }> {}
@@ -14,7 +14,7 @@ declare const ThrowableDataError_base: new <A extends Record<string, any> = {}>(
   readonly _tag: "ThrowableRouteError";
 } & Readonly<A>;
 /** Throwable: rejects with `data(...)` → boundary as an `ErrorResponse`. */
-declare class ThrowableDataError<D> extends ThrowableDataError_base<{
+export declare class ThrowableDataError<D> extends ThrowableDataError_base<{
   data: D;
   init?: number | ResponseInit;
 }> {}
@@ -22,7 +22,7 @@ declare const ThrowableRedirectError_base: new <A extends Record<string, any> =
   readonly _tag: "ThrowableRedirectError";
 } & Readonly<A>;
 /** Throwable: rejects with a redirect `Response`. */
-declare class ThrowableRedirectError extends ThrowableRedirectError_base<{
+export declare class ThrowableRedirectError extends ThrowableRedirectError_base<{
   url: string;
   init?: number | ResponseInit;
 }> {}
@@ -52,7 +52,7 @@ declare const Respond: {
   redirect: (url: string, init?: number | ResponseInit) => ThrowableRedirectError;
 };
 /** Narrows an unknown value to one of the library's route errors. */
-declare const isRouteError: (value: unknown) => value is AnyRouteError;
+export declare const isRouteError: (value: unknown) => value is AnyRouteError;
 //#endregion
 //#region src/factory.d.ts
 /** The library's base `Respond` helpers (`early` / `throw` / `redirect`). */
@@ -296,7 +296,7 @@ type RequestContextKey<ReqServices> = RouterContext<Context.Context<ReqServices>
  * );
  * ```
  */
-declare function makeEffectRouteFactory<DomainError extends Tagged = never>(): <const Returns extends HandlerReturns<DomainError> = {}, RServices = never, ReqServices = never, const ExtraRespond extends Record<string, (...args: never[]) => unknown> = {}>(builder: (respond: BaseRespond) => {
+export declare function makeEffectRouteFactory<DomainError extends Tagged = never>(): <const Returns extends HandlerReturns<DomainError> = {}, RServices = never, ReqServices = never, const ExtraRespond extends Record<string, (...args: never[]) => unknown> = {}>(builder: (respond: BaseRespond) => {
   /**
    * An optional handler per declared domain error, keyed by its tag. The keys
    * autocomplete to your domain-error tags and each handler's `error` parameter
@@ -339,4 +339,4 @@ declare function makeEffectRouteFactory<DomainError extends Tagged = never>(): <
   } & ExtraRespond;
 };
 //#endregion
-export { type AnyRouteError, type ErrorHandler, type RequestContextKey, ReturnableDataError, ThrowableDataError, ThrowableRedirectError, isRouteError, makeEffectRouteFactory };
+export type { AnyRouteError, ErrorHandler, RequestContextKey };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { Data, Effect } from "effect";
-import { HttpServerRespondable, HttpServerResponse } from "effect/unstable/http";
+import { HttpServerRespondable, HttpServerResponse } from "effect/http";
 import { data, redirect } from "react-router";
 //#region src/errors.ts
 /** Recoverable: short-circuits the loader but returns `data(...)` the component reads. */
@@ -152,7 +152,7 @@ function makeEffectRouteFactory() {
 		* configured runtime. Shared by `makeLoader`/`makeAction` and `makeMiddleware`
 		* — they differ only in how they build the effect and what `context` they read.
 		*/
-		function runProgram(effect, context) {
+		function runProgram(effect, context, signal) {
 			const program = effect.pipe(Effect.catchIf((_e) => true, (e) => {
 				if (isUserError(e)) {
 					const out = userHandlers[e._tag](e);
@@ -164,11 +164,11 @@ function makeEffectRouteFactory() {
 				return internalServerError();
 			}));
 			const provided = requestContextKey ? Effect.provideContext(program, context.get(requestContextKey)) : program;
-			return runtime ? runtime.runPromise(provided) : Effect.runPromise(provided);
+			return runtime ? runtime.runPromise(provided, { signal }) : Effect.runPromise(provided, { signal });
 		}
 		function makeLoaderOrAction(fn) {
 			const run = fn;
-			return (args) => runProgram(run(args), args.context);
+			return (args) => runProgram(run(args), args.context, args.request.signal);
 		}
 		/**
 		* Wraps a middleware function written as an effect. Pin it to the route's generated
@@ -194,8 +194,8 @@ function makeEffectRouteFactory() {
 					try: next,
 					catch: (e) => e
 				});
-				const { context } = args;
-				return runProgram(run(args, effectNext), context);
+				const { context, request } = args;
+				return runProgram(run(args, effectNext), context, request.signal);
 			};
 		}
 		return {

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schemastore.org/package.json",
   "name": "react-router-effect",
-  "version": "1.0.2",
+  "version": "2.0.0",
   "description": "Wrap React Router framework-mode route modules with Effect, with typed recover/throw/redirect error handling.",
   "keywords": [
     "action",
@@ -36,26 +36,27 @@
     "access": "public"
   },
   "devDependencies": {
-    "@changesets/changelog-github": "^0.7.0",
-    "@changesets/cli": "^2.31.1",
+    "@changesets/changelog-github": "^1.0.1",
+    "@changesets/cli": "^3.0.3",
     "@types/node": "^25.6.2",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^6.0.4",
-    "@vitest/browser": "4.1.10",
-    "@vitest/browser-playwright": "4.1.10",
-    "effect": "4.0.0-beta.107",
+    "@vitest/browser": "5.0.4",
+    "@vitest/browser-playwright": "5.0.4",
+    "effect": "4.0.5",
     "playwright": "1.60.0",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "react-router": "^8.3.0",
     "typescript": "^7.0.2",
-    "vite-plus": "latest",
-    "vitest": "4.1.10",
+    "vite": "npm:@voidzero-dev/vite-plus-core@latest",
+    "vite-plus": "^1.3.0",
+    "vitest": "5.0.4",
     "vitest-browser-react": "^2.2.0"
   },
   "peerDependencies": {
-    "effect": "^4.0.0-beta.107",
+    "effect": "^4.0.0",
     "react-router": "^7.16.0 || ^8.3.0"
   },
   "devEngines": {

package/src/factory.ts

@@ -1,5 +1,5 @@
 import { type Context, Effect, type ManagedRuntime } from "effect";
-import { HttpServerRespondable, HttpServerResponse } from "effect/unstable/http";
+import { HttpServerRespondable, HttpServerResponse } from "effect/http";
 import {
   data,
   redirect,
@@ -420,6 +420,7 @@ export function makeEffectRouteFactory<DomainError extends Tagged = never>() {
     function runProgram<E>(
       effect: Effect.Effect<unknown, E, RServices | ReqServices>,
       context: Readonly<RouterContextProvider>,
+      signal: AbortSignal,
     ): Promise<unknown> {
       // The internal channel is deliberately loose (`unknown` success); the caller
       // restores the precise resolved type (computed from `E` and the handler map).
@@ -464,9 +465,12 @@ export function makeEffectRouteFactory<DomainError extends Tagged = never>() {
       ) as Effect.Effect<unknown, FailureResponse, RServices>;
       // Run against the configured runtime so its services satisfy the effect's
       // `R`; with no runtime, the effect requires nothing and runs standalone.
+      // The request's abort signal interrupts the fiber, so finalizers run and
+      // in-flight work is cancelled. React Router races the handler against the same
+      // signal and discards its result, so the interrupt rejection is never rendered.
       return runtime
-        ? runtime.runPromise(provided)
-        : Effect.runPromise(provided as Effect.Effect<unknown, FailureResponse>);
+        ? runtime.runPromise(provided, { signal })
+        : Effect.runPromise(provided as Effect.Effect<unknown, FailureResponse>, { signal });
     }
 
     function makeLoaderOrAction<Args extends LoaderFunctionArgs | ActionFunctionArgs, A, E, R>(
@@ -486,7 +490,7 @@ export function makeEffectRouteFactory<DomainError extends Tagged = never>() {
         args: Args,
       ) => Effect.Effect<unknown, E, RServices | ReqServices>;
       return (args: Args) =>
-        runProgram(run(args), args.context) as Promise<
+        runProgram(run(args), args.context, args.request.signal) as Promise<
           A | DirectRecover<E> | RecoverOf<DomainError, Returns, E>
         >;
     }
@@ -546,8 +550,11 @@ export function makeEffectRouteFactory<DomainError extends Tagged = never>() {
             try: next as unknown as () => Promise<unknown>,
             catch: (e) => e as FailureResponse,
           });
-        const { context } = args as unknown as { context: Readonly<RouterContextProvider> };
-        return runProgram(run(args, effectNext), context) as Promise<
+        const { context, request } = args as unknown as {
+          context: Readonly<RouterContextProvider>;
+          request: Request;
+        };
+        return runProgram(run(args, effectNext), context, request.signal) as Promise<
           MiddlewareResultOf<Middleware> | undefined
         >;
       };