@effectify/react-router 0.4.9 → 0.5.0

package/README.md

@@ -26,7 +26,7 @@ Create a server runtime with your Effect layers:
 
 ```typescript
 // lib/server-runtime.ts
-import { make } from "@effectify/react-router";
+import { make } from "@effectify/react-router"
 import * as Layer from "effect/Layer"
 
 const layers = Layer.empty
@@ -40,22 +40,22 @@ Use the Effect-based loaders and actions in your React Router routes:
 
 ```typescript
 // routes/home.tsx
-import type * as Route from "./+types.home";
-import { httpSuccess, httpFailure, LoaderArgsContext } from "@effectify/react-router";
-import { withLoaderEffect } from "~/lib/server-runtime";
+import type * as Route from "./+types.home"
+import { httpFailure, httpSuccess, LoaderArgsContext } from "@effectify/react-router"
+import { withLoaderEffect } from "~/lib/server-runtime"
 import * as Effect from "effect/Effect"
 
 export const loader = withLoaderEffect(
-  Effect.gen(function* () {
+  Effect.gen(function*() {
     const { request } = yield* LoaderArgsContext
     yield* Effect.log("request", request)
-    
+
     // Improved DX: Simple syntax for success responses
-    return yield* httpSuccess({ hello: 'world' })
-    
+    return yield* httpSuccess({ hello: "world" })
+
     // For error responses, use:
     // return yield* httpFailure("Something went wrong")
-  })
+  }),
 )
 
 export default function Home({ loaderData }: Route.ComponentProps) {
@@ -75,31 +75,35 @@ The library provides helper functions for better DX when returning HTTP response
 ### Success Responses
 
 Instead of the verbose:
+
 ```typescript
-return yield* Effect.succeed(new HttpResponseSuccess({ data: { hello: 'world' }}))
+return yield * Effect.succeed(new HttpResponseSuccess({ data: { hello: "world" } }))
 ```
 
 Use the simplified syntax:
+
 ```typescript
-return yield* httpSuccess({ hello: 'world' })
+return yield * httpSuccess({ hello: "world" })
 ```
 
 ### Error Responses
 
 For error handling, use the `httpFailure` helper:
+
 ```typescript
-return yield* httpFailure("Something went wrong")
+return yield * httpFailure("Something went wrong")
 // or with more complex error objects
-return yield* httpFailure({ code: 'VALIDATION_ERROR', message: 'Invalid input' })
+return yield * httpFailure({ code: "VALIDATION_ERROR", message: "Invalid input" })
 ```
 
 ### Redirects
 
 For redirects, use the `httpRedirect` helper:
+
 ```typescript
-return yield* httpRedirect('/login')
+return yield * httpRedirect("/login")
 // or with custom status/headers
-return yield* httpRedirect('/dashboard', { status: 301 })
+return yield * httpRedirect("/dashboard", { status: 301 })
 ```
 
 ## API
@@ -115,12 +119,14 @@ Creates Effect-based runtime helpers for React Router.
 #### Returns
 
 An object containing:
+
 - `withLoaderEffect`: Wrapper for React Router loaders using Effect
 - `withActionEffect`: Wrapper for React Router actions using Effect
 
 ### `LoaderArgsContext`
 
 Effect context providing access to React Router loader arguments including:
+
 - `request`: The incoming Request object
 - `params`: Route parameters
 - `context`: Additional context data
@@ -150,7 +156,7 @@ The library provides comprehensive error handling with full ErrorBoundary suppor
 
 ```typescript
 // The library automatically logs errors like this:
-Effect.tapError((cause) => Effect.logError('Loader effect failed', cause))
+Effect.tapError((cause) => Effect.logError("Loader effect failed", cause))
 
 // Loader errors are automatically converted to Response objects for ErrorBoundary:
 // - Effect errors → Response with { ok: false, errors: [...] } and status 500
@@ -167,7 +173,7 @@ const runtime = make(pipe(
   // Your app layers
   MyAppLayer,
   // Custom logger layer
-  Logger.replace(Logger.defaultLogger, customLogger)
+  Logger.replace(Logger.defaultLogger, customLogger),
 ))
 ```
 
@@ -178,4 +184,4 @@ const runtime = make(pipe(
 
 ## License
 
-MIT
+MIT

package/dist/src/index.d.ts

@@ -1,4 +1,4 @@
-export * from './lib/context.js';
-export * as HttpApiHandler from './lib/http-api-handler.js';
-export * from './lib/http-response.js';
-export * as Runtime from './lib/runtime.js';
+export * from "./lib/context.js";
+export * as HttpApiHandler from "./lib/http-api-handler.js";
+export * from "./lib/http-response.js";
+export * as Runtime from "./lib/runtime.js";

package/dist/src/index.js

@@ -1,4 +1,4 @@
-export * from './lib/context.js';
-export * as HttpApiHandler from './lib/http-api-handler.js';
-export * from './lib/http-response.js';
-export * as Runtime from './lib/runtime.js';
+export * from "./lib/context.js";
+export * as HttpApiHandler from "./lib/http-api-handler.js";
+export * from "./lib/http-response.js";
+export * as Runtime from "./lib/runtime.js";

package/dist/src/lib/context.d.ts

@@ -1,5 +1,5 @@
-import * as Context from 'effect/Context';
-import type { ActionFunctionArgs, LoaderFunctionArgs } from 'react-router';
+import * as Context from "effect/Context";
+import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
 declare const ActionArgsContext_base: Context.TagClass<ActionArgsContext, "ActionArgsContext", ActionFunctionArgs<any>>;
 export declare class ActionArgsContext extends ActionArgsContext_base {
 }

package/dist/src/lib/context.js

@@ -1,5 +1,5 @@
-import * as Context from 'effect/Context';
-export class ActionArgsContext extends Context.Tag('ActionArgsContext')() {
+import * as Context from "effect/Context";
+export class ActionArgsContext extends Context.Tag("ActionArgsContext")() {
 }
-export class LoaderArgsContext extends Context.Tag('LoaderArgsContext')() {
+export class LoaderArgsContext extends Context.Tag("LoaderArgsContext")() {
 }

package/dist/src/lib/http-api-handler.d.ts

@@ -1,13 +1,12 @@
-/** biome-ignore-all lint/suspicious/noConsole: <debug> */
-import type * as HttpApi from '@effect/platform/HttpApi';
-import * as HttpApiScalar from '@effect/platform/HttpApiScalar';
-import * as Layer from 'effect/Layer';
-import type { ActionFunctionArgs, LoaderFunctionArgs } from 'react-router';
+import type * as HttpApi from "@effect/platform/HttpApi";
+import * as HttpApiScalar from "@effect/platform/HttpApiScalar";
+import * as Layer from "effect/Layer";
+import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
 export type HttpApiOptions = {
     apiLive: Layer.Layer<HttpApi.Api, never, never>;
     scalar?: HttpApiScalar.ScalarConfig;
 };
-export type RoutePath = '/' | `/${string}/`;
+export type RoutePath = "/" | `/${string}/`;
 export declare const make: (options: HttpApiOptions & {
     pathPrefix?: RoutePath;
 }) => ({ request }: ActionFunctionArgs | LoaderFunctionArgs) => Promise<Response>;

package/dist/src/lib/http-api-handler.js

@@ -1,11 +1,11 @@
-import * as HttpApiBuilder from '@effect/platform/HttpApiBuilder';
-import * as HttpApiScalar from '@effect/platform/HttpApiScalar';
-import * as HttpServer from '@effect/platform/HttpServer';
-import { Option } from 'effect';
-import { pipe } from 'effect/Function';
-import * as Layer from 'effect/Layer';
+import * as HttpApiBuilder from "@effect/platform/HttpApiBuilder";
+import * as HttpApiScalar from "@effect/platform/HttpApiScalar";
+import * as HttpServer from "@effect/platform/HttpServer";
+import { Option } from "effect";
+import { pipe } from "effect/Function";
+import * as Layer from "effect/Layer";
 export const make = (options) => ({ request }) => pipe(Option.fromNullable(options.scalar), Option.map((scalar) => HttpApiScalar.layer({
-    path: `${options.pathPrefix || '/api/'}docs`,
+    path: `${options.pathPrefix || "/api/"}docs`,
     scalar: {
         ...scalar,
         baseServerURL: new URL(request.url).origin,

package/dist/src/lib/http-response.d.ts

@@ -1,4 +1,4 @@
-import * as Effect from 'effect/Effect';
+import * as Effect from "effect/Effect";
 declare const HttpResponseSuccess_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
     readonly _tag: "HttpResponseSuccess";
 };

package/dist/src/lib/http-response.js

@@ -1,11 +1,11 @@
-import * as Data from 'effect/Data';
-import * as Effect from 'effect/Effect';
-import * as Match from 'effect/Match';
-export class HttpResponseSuccess extends Data.TaggedClass('HttpResponseSuccess') {
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+export class HttpResponseSuccess extends Data.TaggedClass("HttpResponseSuccess") {
 }
-export class HttpResponseFailure extends Data.TaggedClass('HttpResponseFailure') {
+export class HttpResponseFailure extends Data.TaggedClass("HttpResponseFailure") {
 }
-export class HttpResponseRedirect extends Data.TaggedClass('HttpResponseRedirect') {
+export class HttpResponseRedirect extends Data.TaggedClass("HttpResponseRedirect") {
 }
 export const matchHttpResponse = () => Match.typeTags();
 // Helper functions for better DX

package/dist/src/lib/runtime.d.ts

@@ -1,8 +1,8 @@
-import * as Effect from 'effect/Effect';
-import type * as Layer from 'effect/Layer';
-import { type ActionFunctionArgs, type LoaderFunctionArgs } from 'react-router';
-import { ActionArgsContext, LoaderArgsContext } from '../lib/context.js';
-import { type HttpResponse } from '../lib/http-response.js';
+import * as Effect from "effect/Effect";
+import type * as Layer from "effect/Layer";
+import { type ActionFunctionArgs, type LoaderFunctionArgs } from "react-router";
+import { ActionArgsContext, LoaderArgsContext } from "../lib/context.js";
+import { type HttpResponse } from "../lib/http-response.js";
 export declare const make: <R, E>(layer: Layer.Layer<R, E, never>) => {
     withLoaderEffect: <A, B, R0 extends R | LoaderArgsContext>(self: Effect.Effect<HttpResponse<A> | Response, B, R0>) => (args: LoaderFunctionArgs) => Promise<{
         ok: true;

package/dist/src/lib/runtime.js

@@ -1,18 +1,18 @@
-import * as Effect from 'effect/Effect';
-import * as Exit from 'effect/Exit';
-import { pipe } from 'effect/Function';
-import * as Logger from 'effect/Logger';
-import * as ManagedRuntime from 'effect/ManagedRuntime';
-import { data, redirect } from 'react-router';
-import { ActionArgsContext, LoaderArgsContext } from '../lib/context.js';
-import { matchHttpResponse } from '../lib/http-response.js';
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { pipe } from "effect/Function";
+import * as Logger from "effect/Logger";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import { data, redirect } from "react-router";
+import { ActionArgsContext, LoaderArgsContext } from "../lib/context.js";
+import { matchHttpResponse } from "../lib/http-response.js";
 export const make = (layer) => {
     const runtime = ManagedRuntime.make(layer);
     const withLoaderEffect = (self) => (args) => {
-        const runnable = pipe(self, Effect.provide(Logger.pretty), Effect.provideService(LoaderArgsContext, args), Effect.tapError((cause) => Effect.logError('Loader effect failed', cause)));
+        const runnable = pipe(self, Effect.provide(Logger.pretty), Effect.provideService(LoaderArgsContext, args), Effect.tapError((cause) => Effect.logError("Loader effect failed", cause)));
         return runtime.runPromiseExit(runnable).then(Exit.match({
             onFailure: (cause) => {
-                if (cause._tag === 'Fail') {
+                if (cause._tag === "Fail") {
                     // Preserve the original error for ErrorBoundary
                     const error = cause.error;
                     if (error instanceof Response) {
@@ -25,15 +25,15 @@ export const make = (layer) => {
                     const errorData = { ok: false, errors: [String(error)] };
                     throw new Response(JSON.stringify(errorData), {
                         status: 500,
-                        headers: { 'Content-Type': 'application/json' },
+                        headers: { "Content-Type": "application/json" },
                     });
                 }
                 // Handle other types of failures (interrupts, defects, etc.)
-                console.error('Runtime execution failed with defect:', JSON.stringify(cause, null, 2));
-                const errorData = { ok: false, errors: ['Internal server error'] };
+                console.error("Runtime execution failed with defect:", JSON.stringify(cause, null, 2));
+                const errorData = { ok: false, errors: ["Internal server error"] };
                 throw new Response(JSON.stringify(errorData), {
                     status: 500,
-                    headers: { 'Content-Type': 'application/json' },
+                    headers: { "Content-Type": "application/json" },
                 });
             },
             onSuccess: (result) => {
@@ -47,16 +47,16 @@ export const make = (layer) => {
                     HttpResponseSuccess: ({ data: response }) => ({ ok: true, data: response }),
                     HttpResponseFailure: ({ cause }) => {
                         // Convert HttpResponseFailure to Response for ErrorBoundary with ok: false
-                        const errorMessage = typeof cause === 'string' ? cause : String(cause);
+                        const errorMessage = typeof cause === "string" ? cause : String(cause);
                         const errorData = { ok: false, errors: [errorMessage] };
                         throw new Response(JSON.stringify(errorData), {
                             status: 500,
-                            headers: { 'Content-Type': 'application/json' },
+                            headers: { "Content-Type": "application/json" },
                         });
                     },
                     HttpResponseRedirect: ({ to, init = {} }) => {
                         redirect(to, init);
-                        return { ok: false, errors: ['Redirecting...'] };
+                        return { ok: false, errors: ["Redirecting..."] };
                     },
                 })(result);
             },
@@ -67,13 +67,13 @@ export const make = (layer) => {
         const runnable = pipe(self, Effect.provide(Logger.pretty), Effect.provideService(ActionArgsContext, args), Effect.tapError((cause) => {
             // Don't log if it's a Response - that's expected behavior
             if (!(cause instanceof Response)) {
-                return Effect.logError('Action effect failed', cause);
+                return Effect.logError("Action effect failed", cause);
             }
             return Effect.void;
         }));
         return runtime.runPromiseExit(runnable).then(Exit.match({
             onFailure: (cause) => {
-                if (cause._tag === 'Fail') {
+                if (cause._tag === "Fail") {
                     const error = cause.error;
                     // If the error is a Response, throw it directly to preserve headers
                     if (error instanceof Response) {
@@ -82,7 +82,7 @@ export const make = (layer) => {
                     return data({ ok: false, errors: [String(error)] }, { status: 400 });
                 }
                 // Handle other types of failures
-                return data({ ok: false, errors: ['Internal server error'] }, { status: 400 });
+                return data({ ok: false, errors: ["Internal server error"] }, { status: 400 });
             },
             onSuccess: (result) => {
                 // If the result is a Response, throw it directly to preserve headers (including Set-Cookie)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectify/react-router",
-  "version": "0.4.9",
+  "version": "0.5.0",
   "description": "Integration of React Router with Effect for React applications",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -24,7 +24,7 @@
   "peerDependencies": {
     "@effect/platform": "0.94.0",
     "@effect/platform-node": "0.104.0",
-    "effect": "3.19.13",
+    "effect": "3.19.15",
     "react-router": "7.9.6"
   },
   "devDependencies": {},