@effectify/react-router 0.3.0 → 0.4.0

package/dist/src/index.d.ts

@@ -1,3 +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';

package/dist/src/index.js

@@ -1,3 +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';

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

@@ -0,0 +1,13 @@
+/** 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';
+export type HttpApiOptions = {
+    apiLive: Layer.Layer<HttpApi.Api, never, never>;
+    scalar?: HttpApiScalar.ScalarConfig;
+};
+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

@@ -0,0 +1,17 @@
+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`,
+    scalar: {
+        ...scalar,
+        baseServerURL: new URL(request.url).origin,
+    },
+}).pipe(Layer.provide(options.apiLive))), Option.getOrElse(() => Layer.empty), (ApiDocsLive) => {
+    const EnvLive = Layer.mergeAll(options.apiLive, ApiDocsLive, HttpServer.layerContext);
+    const { handler } = HttpApiBuilder.toWebHandler(EnvLive);
+    return handler(request);
+});

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

@@ -4,21 +4,21 @@ 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>(self: Effect.Effect<HttpResponse<A>, B, R | LoaderArgsContext>) => (args: LoaderFunctionArgs) => Promise<{
+    withLoaderEffect: <A, B>(self: Effect.Effect<HttpResponse<A> | Response, B, R | LoaderArgsContext>) => (args: LoaderFunctionArgs) => Promise<{
         ok: true;
         data: A;
     } | {
         ok: false;
         errors: string[];
     }>;
-    withActionEffect: <A, B_1>(self: Effect.Effect<HttpResponse<A>, B_1, R | ActionArgsContext>) => (args: ActionFunctionArgs) => Promise<import("react-router").UNSAFE_DataWithResponseInit<{
+    withActionEffect: <A, B_1>(self: Effect.Effect<HttpResponse<A> | Response, B_1, R | ActionArgsContext>) => (args: ActionFunctionArgs) => Promise<Response | import("react-router").UNSAFE_DataWithResponseInit<{
         ok: false;
-        errors: B_1;
+        errors: string[];
     }> | {
         ok: true;
         response: A;
     } | import("react-router").UNSAFE_DataWithResponseInit<{
         ok: false;
         errors: string[];
-    }> | Response>;
+    }>>;
 };

package/dist/src/lib/runtime.js

@@ -29,49 +29,75 @@ export const make = (layer) => {
                     });
                 }
                 // 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'] };
                 throw new Response(JSON.stringify(errorData), {
                     status: 500,
                     headers: { 'Content-Type': 'application/json' },
                 });
             },
-            onSuccess: matchHttpResponse()({
-                HttpResponseSuccess: ({ data: response }) => {
-                    return { ok: true, data: response };
-                },
-                HttpResponseFailure: ({ cause }) => {
-                    // Convert HttpResponseFailure to Response for ErrorBoundary with ok: false
-                    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' },
-                    });
-                },
-                HttpResponseRedirect: ({ to, init = {} }) => {
-                    redirect(to, init);
-                    return { ok: false, errors: ['Redirecting...'] };
-                },
-            }),
+            onSuccess: (result) => {
+                // If the result is a Response, throw it directly to preserve headers (including Set-Cookie)
+                // This is how React Router expects to handle Responses from loaders/actions
+                if (result instanceof Response) {
+                    throw result;
+                }
+                // Otherwise, match the HttpResponse types
+                return matchHttpResponse()({
+                    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 errorData = { ok: false, errors: [errorMessage] };
+                        throw new Response(JSON.stringify(errorData), {
+                            status: 500,
+                            headers: { 'Content-Type': 'application/json' },
+                        });
+                    },
+                    HttpResponseRedirect: ({ to, init = {} }) => {
+                        redirect(to, init);
+                        return { ok: false, errors: ['Redirecting...'] };
+                    },
+                })(result);
+            },
         }));
     };
     // Don't throw the Error requests, handle them in the normal UI. No ErrorBoundary
     const withActionEffect = (self) => (args) => {
-        const runnable = pipe(self, Effect.provide(Logger.pretty), Effect.provideService(ActionArgsContext, args), Effect.tapError((cause) => Effect.logError('Action effect failed', cause)), Effect.match({
-            onFailure: (errors) => data({ ok: false, errors }, { status: 400 }),
-            onSuccess: matchHttpResponse()({
-                HttpResponseSuccess: ({ data: response }) => {
-                    return { ok: true, response };
-                },
-                HttpResponseFailure: ({ cause }) => {
-                    return data({ ok: false, errors: [String(cause)] }, { status: 400 });
-                },
-                HttpResponseRedirect: ({ to, init = {} }) => {
-                    return redirect(to, init);
-                },
-            }),
+        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.void;
+        }));
+        return runtime.runPromiseExit(runnable).then(Exit.match({
+            onFailure: (cause) => {
+                if (cause._tag === 'Fail') {
+                    const error = cause.error;
+                    // If the error is a Response, throw it directly to preserve headers
+                    if (error instanceof Response) {
+                        throw error;
+                    }
+                    return data({ ok: false, errors: [String(error)] }, { status: 400 });
+                }
+                // Handle other types of failures
+                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)
+                // This is how React Router expects to handle Responses from actions
+                if (result instanceof Response) {
+                    throw result;
+                }
+                // Otherwise, match the HttpResponse types
+                return matchHttpResponse()({
+                    HttpResponseSuccess: ({ data: response }) => ({ ok: true, response }),
+                    HttpResponseFailure: ({ cause }) => data({ ok: false, errors: [String(cause)] }, { status: 400 }),
+                    HttpResponseRedirect: ({ to, init = {} }) => redirect(to, init),
+                })(result);
+            },
         }));
-        return runtime.runPromise(runnable);
     };
     return { withLoaderEffect, withActionEffect };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectify/react-router",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Integration of React Router with Effect for React applications",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,10 +22,10 @@
     "!**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "@effect/platform": "0.91.1",
-    "@effect/platform-node": "0.97.1",
-    "effect": "3.17.14",
-    "react-router": "7.9.2"
+    "@effect/platform": "0.93.3",
+    "@effect/platform-node": "0.101.1",
+    "effect": "3.19.6",
+    "react-router": "7.9.6"
   },
   "devDependencies": {},
   "peerDependencies": {},