@effectify/react-remix 0.1.0

package/README.md

@@ -0,0 +1,102 @@
+# @effectify/react-remix
+
+Integration of [Remix](https://remix.com/) with [Effect](https://effect.website/) for React applications.
+
+## Installation
+
+```bash
+# npm
+npm install @effectify/react-remix
+
+# yarn
+yarn add @effectify/react-remix
+
+# pnpm
+pnpm add @effectify/react-remix
+
+# bun
+bun add @effectify/react-remix
+```
+
+## Basic Usage
+
+### 1. Setup Server Runtime
+
+Create a server runtime with your Effect layers:
+
+```typescript
+// lib/server-runtime.ts
+import { Runtime } from "@effectify/react-remix";
+import * as Layer from "effect/Layer"
+
+const layers = Layer.empty
+
+export const { withLoaderEffect, withActionEffect } = Runtime.make(layers)
+```
+
+### 2. Use in Route Components
+
+Use the Effect-based loaders and actions in your Remix routes:
+
+```typescript
+// routes/home.tsx
+import type * as Route from "./+types.home";
+import { Ok, LoaderArgsContext } from "@effectify/react-remix";
+import { withLoaderEffect } from "~/lib/server-runtime";
+import * as Effect from "effect/Effect"
+
+export const loader = withLoaderEffect(
+  Effect.gen(function* () {
+    const { request } = yield* LoaderArgsContext
+    yield* Effect.log("request", request)
+    return yield* Effect.succeed(new Ok({ data: { hello: 'world' }}))
+  })
+)
+
+export default function Home({ loaderData }: Route.ComponentProps) {
+  return (
+    <div>
+      <h1>Home</h1>
+      <pre>{JSON.stringify(loaderData.data, null, 2)}</pre>
+    </div>
+  )
+}
+```
+
+## API
+
+### `make(layers)`
+
+Creates Effect-based runtime helpers for Remix.
+
+#### Parameters
+
+- `layers`: Effect Layer containing your application services and dependencies.
+
+#### Returns
+
+An object containing:
+- `withLoaderEffect`: Wrapper for Remix loaders using Effect
+- `withActionEffect`: Wrapper for Remix actions using Effect
+
+### `LoaderArgsContext`
+
+Effect context providing access to Remix loader arguments including:
+- `request`: The incoming Request object
+- `params`: Route parameters
+- `context`: Additional context data
+
+### Response Types
+
+- `Ok(data)`: Successful response with data
+- `Redirect(url)`: Redirect response
+- `Error(message)`: Error response
+
+## Requirements
+
+- Remix 2+
+- Effect ecosystem (`effect`)
+
+## License
+
+MIT

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/context.js';
+export * from './lib/http-response.js';
+export * as Runtime from './lib/runtime.js';

package/dist/src/index.js

@@ -0,0 +1,3 @@
+export * from './lib/context.js';
+export * from './lib/http-response.js';
+export * as Runtime from './lib/runtime.js';

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

@@ -0,0 +1,9 @@
+import type { ActionFunctionArgs, LoaderFunctionArgs } from '@remix-run/node';
+import * as Context from 'effect/Context';
+declare const ActionArgsContext_base: Context.TagClass<ActionArgsContext, "ActionArgsContext", ActionFunctionArgs>;
+export declare class ActionArgsContext extends ActionArgsContext_base {
+}
+declare const LoaderArgsContext_base: Context.TagClass<LoaderArgsContext, "LoaderArgsContext", LoaderFunctionArgs>;
+export declare class LoaderArgsContext extends LoaderArgsContext_base {
+}
+export {};

package/dist/src/lib/context.js

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

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

@@ -0,0 +1,21 @@
+declare const Ok_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: "Ok";
+};
+export declare class Ok<T> extends Ok_base<{
+    readonly data: T;
+}> {
+}
+declare const Redirect_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: "Redirect";
+};
+export declare class Redirect extends Redirect_base<{
+    readonly to: string;
+    readonly init?: number | ResponseInit | undefined;
+}> {
+}
+export type HttpResponse<T> = Redirect | Ok<T>;
+export declare const matchHttpResponse: <T>() => <P extends {
+    readonly Ok: (_: Ok<T>) => any;
+    readonly Redirect: (_: Redirect) => any;
+} & { readonly [Tag in Exclude<keyof P, "Ok" | "Redirect">]: never; }>(fields: P) => (input: HttpResponse<T>) => import("effect/Unify").Unify<ReturnType<P[keyof P]>>;
+export {};

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

@@ -0,0 +1,7 @@
+import * as Data from 'effect/Data';
+import * as Match from 'effect/Match';
+export class Ok extends Data.TaggedClass('Ok') {
+}
+export class Redirect extends Data.TaggedClass('Redirect') {
+}
+export const matchHttpResponse = () => Match.typeTags();

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

@@ -0,0 +1,21 @@
+import { type ActionFunctionArgs, type LoaderFunctionArgs } from '@remix-run/node';
+import * as Effect from 'effect/Effect';
+import type * as Layer from 'effect/Layer';
+import { ActionArgsContext, LoaderArgsContext } from './context.js';
+import { type HttpResponse } from './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<{
+        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("@remix-run/node").TypedResponse<{
+        ok: false;
+        errors: B_1;
+    }> | {
+        ok: true;
+        response: A;
+    } | import("@remix-run/node").TypedResponse<never>>;
+};

package/dist/src/lib/runtime.js

@@ -0,0 +1,49 @@
+import { json, redirect } from '@remix-run/node';
+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 { ActionArgsContext, LoaderArgsContext } from './context.js';
+import { matchHttpResponse } from './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));
+        return runtime.runPromiseExit(runnable).then(Exit.match({
+            onFailure: (cause) => {
+                console.error(cause);
+                if (cause._tag === 'Fail') {
+                    throw pipe(cause.error);
+                }
+                // biome-ignore lint/style/useThrowOnlyError: <library uses non-Error throws>
+                throw { ok: false, errors: ['Something went wrong'] };
+            },
+            onSuccess: matchHttpResponse()({
+                Ok: ({ data: response }) => {
+                    return { ok: true, data: response };
+                },
+                Redirect: ({ to, init = {} }) => {
+                    redirect(to, init);
+                    return { ok: false, errors: ['Redirecting...'] };
+                },
+            }),
+        }));
+    };
+    // 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.match({
+            onFailure: (errors) => json({ ok: false, errors }, { status: 400 }),
+            onSuccess: matchHttpResponse()({
+                Ok: ({ data: response }) => {
+                    return { ok: true, response };
+                },
+                Redirect: ({ to, init = {} }) => {
+                    return redirect(to, init);
+                },
+            }),
+        }));
+        return runtime.runPromise(runnable);
+    };
+    return { withLoaderEffect, withActionEffect };
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@effectify/react-remix",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "@effectify/source": "./src/index.ts",
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "@effect/platform": "0.91.1",
+    "@effect/platform-node": "0.97.1",
+    "effect": "3.17.14",
+    "@remix-run/react": "2.17.1",
+    "@remix-run/node": "2.17.1"
+  },
+  "devDependencies": {},
+  "peerDependencies": {},
+  "optionalDependencies": {}
+}