ff-serv 0.1.3 → 0.1.4

package/src/http/basic.test.ts

@@ -0,0 +1,110 @@
+import { FetchHttpClient, FileSystem, HttpClient } from '@effect/platform';
+import { describe, expect, expectTypeOf, it, layer } from '@effect/vitest';
+import { Effect, Layer, type Scope } from 'effect';
+import { serverTester } from './__test__/utils.ts';
+import { basicHandler } from './basic.ts';
+import { createFetchHandler, type Handler } from './fetch-handler.ts';
+
+describe('type inferences', () => {
+	type DefaultRequirements = Scope.Scope;
+
+	it('no requirement', () => {
+		const handler = basicHandler('/dummy', () => new Response('ok'));
+		expectTypeOf(handler).toEqualTypeOf<Handler<'basicHandler', never>>();
+
+		expectTypeOf(createFetchHandler([handler])).toEqualTypeOf<
+			Effect.Effect<
+				(request: Request) => Promise<Response>,
+				never,
+				DefaultRequirements
+			>
+		>();
+	});
+
+	it('with requirement', () => {
+		const handler = basicHandler('/dummy', () =>
+			Effect.gen(function* () {
+				yield* HttpClient.HttpClient;
+				return new Response('ok');
+			}),
+		);
+		expectTypeOf(handler).toEqualTypeOf<
+			Handler<'basicHandler', HttpClient.HttpClient>
+		>();
+
+		expectTypeOf(createFetchHandler([handler])).toEqualTypeOf<
+			Effect.Effect<
+				(request: Request) => Promise<Response>,
+				never,
+				HttpClient.HttpClient | DefaultRequirements
+			>
+		>();
+	});
+
+	it('with requirements', () => {
+		expectTypeOf(
+			createFetchHandler([
+				basicHandler('/dummy', () =>
+					Effect.gen(function* () {
+						yield* HttpClient.HttpClient;
+						return new Response('ok');
+					}),
+				),
+				basicHandler('/dummy', () =>
+					Effect.gen(function* () {
+						yield* FileSystem.FileSystem;
+						return new Response('ok');
+					}),
+				),
+			]),
+		).toEqualTypeOf<
+			Effect.Effect<
+				(request: Request) => Promise<Response>,
+				never,
+				HttpClient.HttpClient | FileSystem.FileSystem | DefaultRequirements
+			>
+		>();
+	});
+});
+
+class Dummy extends Effect.Service<Dummy>()('dummy', {
+	sync: () => ({ message: 'ok-service' }),
+}) {}
+
+layer(Layer.mergeAll(FetchHttpClient.layer, Dummy.Default))((it) => {
+	it.effect('e2e', () =>
+		serverTester({
+			server: ({ port }) =>
+				Effect.gen(function* () {
+					return {
+						server: Bun.serve({
+							port: port,
+							fetch: yield* createFetchHandler([
+								basicHandler('/one', () => new Response('ok')),
+								basicHandler('/two', () =>
+									Effect.succeed(new Response('ok-effect')),
+								),
+								basicHandler('/three', () =>
+									Effect.gen(function* () {
+										const svc = yield* Dummy;
+										return new Response(svc.message);
+									}),
+								),
+							]),
+						}),
+					};
+				}),
+			test: ({ server }) =>
+				Effect.gen(function* () {
+					const call = (path: string) =>
+						HttpClient.get(`http://localhost:${server.port}${path}`).pipe(
+							Effect.flatMap((e) => e.text),
+						);
+
+					expect(yield* call('/one')).toEqual('ok');
+					expect(yield* call('/two')).toEqual('ok-effect');
+					expect(yield* call('/three')).toEqual('ok-service');
+				}),
+		}),
+	);
+});

package/src/http/basic.ts

@@ -0,0 +1,48 @@
+import { Effect } from 'effect';
+import { type AnyResponse, Handler } from './fetch-handler.js';
+
+export namespace Path {
+	export type Type = `/${string}` | ((url: URL) => boolean);
+	export function matched(path: Type, url: URL) {
+		return typeof path === 'function' ? path(url) : path === url.pathname;
+	}
+}
+
+export namespace Fn {
+	type Input = [request: Request];
+
+	type OutputSync = AnyResponse;
+	type OutputEffect<R> = Effect.Effect<AnyResponse, unknown, R>;
+
+	export type FnSync = (...input: Input) => OutputSync;
+	export type FnEffect<R> = (...input: Input) => OutputEffect<R>;
+	export type FnAny<R> = (...input: Input) => OutputSync | OutputEffect<R>;
+
+	export function exec<R>(fn: FnAny<R>, ...[request]: Input) {
+		const response = fn(request);
+		if (!Effect.isEffect(response)) return Effect.succeed(response);
+		return response;
+	}
+}
+
+export function basicHandler(
+	path: Path.Type,
+	fn: Fn.FnSync,
+): Handler<'basicHandler', never>;
+export function basicHandler<R>(
+	path: Path.Type,
+	fn: Fn.FnEffect<R>,
+): Handler<'basicHandler', R>;
+export function basicHandler<R>(path: Path.Type, fn: Fn.FnAny<R>) {
+	return new Handler('basicHandler', ({ url, request }) => {
+		if (!Path.matched(path, url))
+			return Effect.succeed({ matched: false, response: undefined });
+
+		return Effect.gen(function* () {
+			return {
+				matched: true,
+				response: yield* Fn.exec(fn, request),
+			};
+		});
+	});
+}

package/src/http/fetch-handler.test.ts

@@ -0,0 +1,78 @@
+import { FetchHttpClient, HttpClient } from '@effect/platform';
+import { expect, layer } from '@effect/vitest';
+import { Cause, Data, Effect, Layer, Ref } from 'effect';
+import { serverTester } from './__test__/utils.ts';
+import { basicHandler } from './basic.ts';
+import { createFetchHandler } from './fetch-handler.ts';
+
+class AlsoError extends Error {}
+class CustomError extends Data.TaggedError('CustomError') {}
+
+layer(
+	Layer.mergeAll(
+		FetchHttpClient.layer,
+		// Logger.pretty
+	),
+)((it) => {
+	it.effect('e2e', () =>
+		serverTester({
+			server: ({ port }) =>
+				Effect.gen(function* () {
+					const errorsRef = yield* Ref.make<Array<Cause.Cause<unknown>>>([]);
+					return {
+						errors: errorsRef,
+						server: Bun.serve({
+							port: port,
+							fetch: yield* createFetchHandler(
+								[
+									basicHandler('/one', () => {
+										throw new AlsoError();
+									}),
+									basicHandler('/two', () =>
+										Effect.gen(function* () {
+											return yield* new CustomError();
+										}),
+									),
+								],
+								{
+									onError: ({ error }) =>
+										Effect.gen(function* () {
+											const errors = yield* Ref.get(errorsRef) ?? [];
+											errors.push(error);
+											yield* Ref.set(errorsRef, errors);
+										}),
+								},
+							),
+						}),
+					};
+				}),
+			test: ({ errors, server }) =>
+				Effect.gen(function* () {
+					const call = (path: string) =>
+						HttpClient.get(`http://localhost:${server.port}${path}`).pipe(
+							Effect.flatMap((e) => e.text),
+						);
+
+					expect(yield* call('/one')).toEqual('Internal Server Error');
+					yield* Effect.gen(function* () {
+						const cause = (yield* Ref.get(errors))[0];
+						const isDie = cause._tag === 'Die';
+						expect(isDie, `Cause is ${cause._tag}`).toEqual(true);
+						if (isDie) {
+							expect(cause.defect).toBeInstanceOf(AlsoError);
+						}
+					});
+
+					expect(yield* call('/two')).toEqual('Internal Server Error');
+					yield* Effect.gen(function* () {
+						const cause = (yield* Ref.get(errors))[1];
+						const isFailType = Cause.isFailType(cause);
+						expect(isFailType, `Cause is ${cause._tag}`).toEqual(true);
+						if (isFailType) {
+							expect(cause.error).toBeInstanceOf(CustomError);
+						}
+					});
+				}),
+		}),
+	);
+});

package/src/http/fetch-handler.ts

@@ -1,49 +1,53 @@
 import { Effect, FiberSet } from 'effect';
+import type { Cause } from 'effect/Cause';
 import { nanoid } from 'nanoid';
 import { Logger } from '../logger.js';
 
+// #region Handler
+
+export type AnyResponse = Response | Promise<Response>;
+
 export type HandlerResult =
 	| {
 			matched: true;
-			response: Response | Promise<Response>;
+			response: AnyResponse;
 	  }
 	| {
 			matched: false;
 			response: undefined;
 	  };
 
-export type Handler<T extends string = string> = {
-	_tag: T;
-	handle: (opt: {
-		url: URL;
-		request: Request;
-	}) => HandlerResult | Promise<HandlerResult>;
-};
+export class Handler<NAME extends string, R> {
+	constructor(
+		readonly _tag: NAME,
+		readonly handle: (opt: {
+			url: URL;
+			request: Request;
+		}) => Effect.Effect<HandlerResult, unknown, R>,
+	) {}
+}
 
-export function basicHandler(
-	path: string | ((url: URL) => boolean),
-	handler: (request: Request) => Response | Promise<Response>,
-): Handler<'basicHandler'> {
-	return {
-		_tag: 'basicHandler',
-		handle: ({ url, request }) => {
-			const matched =
-				typeof path === 'function' ? path(url) : path === url.pathname;
-			if (!matched) return { matched: false, response: undefined };
+// #endregion
 
-			return { matched: true, response: handler(request) };
-		},
-	};
-}
+type ExtractRequirements<T> = T extends Handler<string, infer R> ? R : never;
 
-export const createFetchHandler = (
-	handlers?: Handler | [Handler, ...Array<Handler>],
+export const createFetchHandler = <
+	const HANDLERS extends [
+		Handler<string, unknown>,
+		...Array<Handler<string, unknown>>,
+	],
+	R = ExtractRequirements<HANDLERS[number]>,
+>(
+	handlers: HANDLERS,
 	opts?: {
 		debug?: boolean;
+		onError?: (ctx: {
+			error: Cause<unknown>;
+		}) => Effect.Effect<unknown, unknown>;
 	},
 ) =>
 	Effect.gen(function* () {
-		const runFork = yield* FiberSet.makeRuntimePromise();
+		const runFork = yield* FiberSet.makeRuntimePromise<R>();
 		return async (request: Request) => {
 			const urlObj = new URL(request.url);
 			const requestId = nanoid(6);
@@ -54,14 +58,40 @@ export const createFetchHandler = (
 					'Request started',
 				);
 
-				for (const handler of Array.isArray(handlers) ? handlers : [handlers]) {
+				for (const handler of handlers) {
 					if (!handler) continue;
 
-					const maybeResult = handler.handle({ url: urlObj, request });
-					const result =
-						maybeResult instanceof Promise
-							? yield* Effect.tryPromise(() => maybeResult)
-							: maybeResult;
+					const result = yield* handler.handle({ url: urlObj, request }).pipe(
+						Effect.flatMap(({ matched, response }) =>
+							Effect.gen(function* () {
+								if (matched) {
+									return {
+										matched: true,
+										response:
+											response instanceof Promise
+												? yield* Effect.tryPromise(() => response)
+												: response,
+									} as const;
+								}
+								return { matched: false, response: undefined } as const;
+							}),
+						),
+						Effect.catchAllCause((error) =>
+							Effect.gen(function* () {
+								yield* Logger.error(
+									{ error },
+									`Unhandled exception in HTTP handler '${handler._tag}'`,
+								);
+								if (opts?.onError) yield* opts.onError({ error });
+								return {
+									matched: true,
+									response: new Response('Internal Server Error', {
+										status: 500,
+									}),
+								} as const;
+							}),
+						),
+					);
 
 					if (opts?.debug)
 						yield* Logger.debug(
@@ -75,32 +105,16 @@ export const createFetchHandler = (
 
 				return new Response('Not Found', { status: 404 });
 			}).pipe(
-				Effect.flatMap((response) =>
-					response instanceof Promise
-						? Effect.tryPromise(() => response)
-						: Effect.succeed(response),
-				),
 				Effect.tap((response) =>
 					response.ok
 						? Logger.info(`Request completed with status ${response.status}`)
 						: Logger.warn(`Request completed with status ${response.status}`),
 				),
-				Effect.catchAll((error) =>
-					Effect.gen(function* () {
-						yield* Logger.error(
-							{ error },
-							'Unhandled exception in HTTP handler',
-						);
-						return new Response('Internal Server Error', {
-							status: 500,
-						});
-					}),
-				),
 				Effect.withSpan('http'),
 				Effect.annotateLogs({ requestId }),
 				Effect.scoped,
-			);
+			) as Effect.Effect<Response, never, R>;
 
 			return runFork(effect);
 		};
-	});
+	});

package/src/http/index.ts

@@ -1 +1,2 @@
-export * from './fetch-handler.js';
+export { basicHandler } from './basic.js';
+export { createFetchHandler } from './fetch-handler.js';

package/src/http/orpc.test.ts

@@ -0,0 +1,43 @@
+import { expect, it } from '@effect/vitest';
+import { createORPCClient } from '@orpc/client';
+import { RPCLink } from '@orpc/client/fetch';
+import { os, type RouterClient } from '@orpc/server';
+import { RPCHandler } from '@orpc/server/fetch';
+import { Effect } from 'effect';
+import { UnknownException } from 'effect/Cause';
+import { wrapClient } from 'ff-effect';
+import { serverTester } from './__test__/utils.ts';
+import { createFetchHandler } from './fetch-handler.ts';
+import { oRPCHandler } from './orpc.ts';
+
+it.effect('e2e', () =>
+	serverTester({
+		server: ({ port }) =>
+			Effect.gen(function* () {
+				const router = {
+					health: os.handler(() => 'ok'),
+				};
+				const handler = new RPCHandler(router);
+
+				return {
+					router,
+					server: Bun.serve({
+						port: port,
+						fetch: yield* createFetchHandler([oRPCHandler(handler)]),
+					}),
+				};
+			}),
+		test: ({ server, router }) =>
+			Effect.gen(function* () {
+				const orpcClient: RouterClient<typeof router> = createORPCClient(
+					new RPCLink({ url: `http://localhost:${server.port}` }),
+				);
+				const call = wrapClient({
+					client: orpcClient,
+					error: ({ cause }) => new UnknownException(cause),
+				});
+
+				expect(yield* call((client) => client.health())).toEqual('ok');
+			}),
+	}),
+);

package/src/http/orpc.ts

@@ -1,18 +1,26 @@
 import type { Context } from '@orpc/server';
 import type { FetchHandler } from '@orpc/server/fetch';
 import type { FriendlyStandardHandleOptions } from '@orpc/server/standard';
-import type { Handler } from './fetch-handler.js';
+import { Effect } from 'effect';
+import { Handler } from './fetch-handler.js';
 
-type MaybeOptionalOptions<TOptions> = Record<never, never> extends TOptions
-	? [options?: TOptions]
-	: [options: TOptions];
+type MaybeOptionalOptions<TOptions> =
+	Record<never, never> extends TOptions
+		? [options?: TOptions]
+		: [options: TOptions];
 
-export function oRPCHandler<T extends Context>(
+export function oRPCHandler<T extends Context, E, R>(
 	handler: FetchHandler<T>,
-	...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>
-): Handler<'oRPCHandler'> {
-	return {
-		_tag: 'oRPCHandler',
-		handle: async ({ request }) => handler.handle(request, ...rest),
-	};
+	opt?:
+		| FriendlyStandardHandleOptions<T>
+		| Effect.Effect<FriendlyStandardHandleOptions<T>, E, R>,
+) {
+	return new Handler('oRPCHandler', ({ request }) =>
+		Effect.gen(function* () {
+			const _opt = (
+				opt ? [Effect.isEffect(opt) ? yield* opt : opt] : []
+			) as MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>;
+			return yield* Effect.tryPromise(() => handler.handle(request, ..._opt));
+		}),
+	);
 }

package/src/index.ts

@@ -1,3 +1,3 @@
-export { basicHandler, createFetchHandler } from './http/index.js';
+export * from './http/index.js';
 export { Logger } from './logger.js';
-export { getPort } from './port.js';
+export { getPort } from './port.js';

package/dist/fetch-handler-BgTGMsrV.d.cts

@@ -1,23 +0,0 @@
-import * as effect_Scope from 'effect/Scope';
-import { Effect } from 'effect';
-
-type HandlerResult = {
-    matched: true;
-    response: Response | Promise<Response>;
-} | {
-    matched: false;
-    response: undefined;
-};
-type Handler<T extends string = string> = {
-    _tag: T;
-    handle: (opt: {
-        url: URL;
-        request: Request;
-    }) => HandlerResult | Promise<HandlerResult>;
-};
-declare function basicHandler(path: string | ((url: URL) => boolean), handler: (request: Request) => Response | Promise<Response>): Handler<'basicHandler'>;
-declare const createFetchHandler: (handlers?: Handler | [Handler, ...Array<Handler>], opts?: {
-    debug?: boolean;
-}) => Effect.Effect<(request: Request) => Promise<Response>, never, effect_Scope.Scope>;
-
-export { type Handler as H, basicHandler as b, createFetchHandler as c };

package/dist/fetch-handler-BgTGMsrV.d.ts

@@ -1,23 +0,0 @@
-import * as effect_Scope from 'effect/Scope';
-import { Effect } from 'effect';
-
-type HandlerResult = {
-    matched: true;
-    response: Response | Promise<Response>;
-} | {
-    matched: false;
-    response: undefined;
-};
-type Handler<T extends string = string> = {
-    _tag: T;
-    handle: (opt: {
-        url: URL;
-        request: Request;
-    }) => HandlerResult | Promise<HandlerResult>;
-};
-declare function basicHandler(path: string | ((url: URL) => boolean), handler: (request: Request) => Response | Promise<Response>): Handler<'basicHandler'>;
-declare const createFetchHandler: (handlers?: Handler | [Handler, ...Array<Handler>], opts?: {
-    debug?: boolean;
-}) => Effect.Effect<(request: Request) => Promise<Response>, never, effect_Scope.Scope>;
-
-export { type Handler as H, basicHandler as b, createFetchHandler as c };