ff-serv 0.1.2 → 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

@@ -0,0 +1,120 @@
+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: AnyResponse;
+	  }
+	| {
+			matched: false;
+			response: undefined;
+	  };
+
+export class Handler<NAME extends string, R> {
+	constructor(
+		readonly _tag: NAME,
+		readonly handle: (opt: {
+			url: URL;
+			request: Request;
+		}) => Effect.Effect<HandlerResult, unknown, R>,
+	) {}
+}
+
+// #endregion
+
+type ExtractRequirements<T> = T extends Handler<string, infer R> ? R : never;
+
+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<R>();
+		return async (request: Request) => {
+			const urlObj = new URL(request.url);
+			const requestId = nanoid(6);
+
+			const effect = Effect.gen(function* () {
+				yield* Logger.info(
+					{ request: { pathname: urlObj.pathname } },
+					'Request started',
+				);
+
+				for (const handler of handlers) {
+					if (!handler) continue;
+
+					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(
+							{ handler: handler._tag, request, result },
+							'Processed handler',
+						);
+
+					if (!result.matched) continue;
+					return result.response;
+				}
+
+				return new Response('Not Found', { status: 404 });
+			}).pipe(
+				Effect.tap((response) =>
+					response.ok
+						? Logger.info(`Request completed with status ${response.status}`)
+						: Logger.warn(`Request completed with status ${response.status}`),
+				),
+				Effect.withSpan('http'),
+				Effect.annotateLogs({ requestId }),
+				Effect.scoped,
+			) as Effect.Effect<Response, never, R>;
+
+			return runFork(effect);
+		};
+	});

package/src/http/index.ts

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,26 @@
+import type { Context } from '@orpc/server';
+import type { FetchHandler } from '@orpc/server/fetch';
+import type { FriendlyStandardHandleOptions } from '@orpc/server/standard';
+import { Effect } from 'effect';
+import { Handler } from './fetch-handler.js';
+
+type MaybeOptionalOptions<TOptions> =
+	Record<never, never> extends TOptions
+		? [options?: TOptions]
+		: [options: TOptions];
+
+export function oRPCHandler<T extends Context, E, R>(
+	handler: FetchHandler<T>,
+	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 +1,3 @@
+export * from './http/index.js';
 export { Logger } from './logger.js';
+export { getPort } from './port.js';

package/src/port.ts

@@ -0,0 +1,5 @@
+import { Effect } from 'effect';
+import * as GetPort from 'get-port';
+
+export const getPort = (options?: GetPort.Options) =>
+	Effect.tryPromise(() => GetPort.default(options));