@fncts/http 0.0.0

package/_src/HttpApp.ts

@@ -0,0 +1,129 @@
+import type { Middleware } from "./Middleware.js";
+import type { ServerResponse } from "./ServerResponse.js";
+import type { ResponseError } from "@fncts/http/ResponseError";
+
+import { globalValue } from "@fncts/base/data/Global";
+import { defaultRuntime, type Runtime } from "@fncts/io/IO";
+
+import { clientAbortFiberId } from "./ServerError.js";
+import { ServerRequest } from "./ServerRequest.js";
+import { isServerResponse } from "./ServerResponse.js";
+
+/**
+ * @tsplus type fncts.http.HttpApp
+ */
+export interface HttpApp<R, E, A> extends IO<R | ServerRequest, E, A> {}
+
+/**
+ * @tsplus type fncts.http.HttpAppOps
+ */
+export interface HttpAppOps {}
+
+export const HttpApp: HttpAppOps = {};
+
+export declare namespace HttpApp {
+  export type Default<R, E> = HttpApp<R, E, ServerResponse>;
+}
+
+/**
+ * @tsplus pipeable fncts.http.HttpApp toHandled
+ */
+export function toHandled<E, RH>(
+  handleResponse: (request: ServerRequest, exit: Exit<E | ResponseError, ServerResponse>) => IO<RH, never, any>,
+  middleware?: Middleware,
+) {
+  return <R>(self: HttpApp.Default<R, E>): HttpApp.Default<Exclude<R | RH, Scope>, E | ResponseError> => {
+    const responded = IO.withFiberRuntime<R | RH | ServerRequest, E | ResponseError, ServerResponse>((fiber) => {
+      const request    = fiber.getFiberRef(FiberRef.currentEnvironment).unsafeGet(ServerRequest.Tag);
+      const handler    = fiber.getFiberRef(HttpApp.currentPreResponseHandlers);
+      const preHandled = handler.match(
+        () => self,
+        (handler) => self.flatMap((response) => handler(request, response)),
+      );
+      return preHandled.result.flatMap((exit) => {
+        if (exit.isFailure()) {
+          const haltMaybe = exit.cause.haltMaybe;
+          if (haltMaybe.isJust() && isServerResponse(haltMaybe.value)) {
+            exit = Exit.succeed(haltMaybe.value);
+          }
+        }
+        return handleResponse(request, exit) > exit;
+      });
+    });
+
+    return (middleware ? middleware(responded) : responded).scoped.uninterruptible;
+  };
+}
+
+export type PreResponseHandler = (
+  request: ServerRequest,
+  response: ServerResponse,
+) => FIO<ResponseError, ServerResponse>;
+
+/**
+ * @tsplus static fncts.http.HttpAppOps currentPreResponseHandlers
+ */
+export const currentPreResponseHandlers = globalValue(Symbol.for("fncts.http.HttpApp.currentPreResponseHandlers"), () =>
+  FiberRef.unsafeMake<Maybe<PreResponseHandler>>(Nothing()),
+);
+
+/**
+ * @tsplus static fncts.http.HttpAppOps appendPreResponseHandler
+ */
+export function appendPreResponseHandler(handler: PreResponseHandler): UIO<void> {
+  return HttpApp.currentPreResponseHandlers.update((handlers) =>
+    handlers.match(
+      () => Just(handler),
+      (prev) => Just((request, response) => prev(request, response).flatMap((response) => handler(request, response))),
+    ),
+  );
+}
+
+/**
+ * @tsplus pipeable fncts.http.HttpApp withPreResponseHandler
+ */
+export function withPreResponseHandler(handler: PreResponseHandler) {
+  return <R, E, A>(self: HttpApp<R, E, A>): HttpApp<R, E, A> =>
+    HttpApp.currentPreResponseHandlers.locallyWith((handlers) =>
+      handlers.match(
+        () => Just(handler),
+        (prev) =>
+          Just((request, response) => prev(request, response).flatMap((response) => handler(request, response))),
+      ),
+    )(self);
+}
+
+export function toWebHandlerRuntime<R>(runtime: Runtime<R>) {
+  const run           = runtime.unsafeRunFiber;
+  const resolveSymbol = Symbol();
+  const rejectSymbol  = Symbol();
+  return <E>(self: HttpApp.Default<R | Scope, E>) => {
+    const handled = self.toHandled((request, exit) => {
+      const webRequest = request.source as Request;
+      if (exit.isSuccess()) {
+        (request as any)[resolveSymbol](exit.value.toWeb(request.method === "HEAD"));
+      } else if (exit.cause.isInterruptedOnly) {
+        (request as any)[resolveSymbol](new Response(null, { status: webRequest.signal.aborted ? 499 : 503 }));
+      } else {
+        (request as any)[rejectSymbol](exit.cause.prettyPrint);
+      }
+      return IO.unit;
+    });
+    return (request: Request): Promise<Response> =>
+      new Promise((resolve, reject) => {
+        const req                   = ServerRequest.fromWeb(request);
+        (req as any)[resolveSymbol] = resolve;
+        (req as any)[rejectSymbol]  = reject;
+        const fiber                 = run(
+          self.provideSomeService(req, ServerRequest.Tag).map((res) => res.toWeb(req.method === "HEAD")).scoped,
+        );
+        request.signal.addEventListener("abort", () => {
+          fiber.interruptAsFork(clientAbortFiberId);
+        });
+      });
+  };
+}
+
+export function toWebHandler<E>(self: HttpApp.Default<Scope, E>): (request: Request) => Promise<Response> {
+  return toWebHandlerRuntime(defaultRuntime)(self);
+}

package/_src/IncomingMessage/api.ts

@@ -0,0 +1,25 @@
+import type { IncomingMessage } from "./definition.js";
+
+/**
+ * @tsplus pipeable fncts.http.IncomingMessage schemaBodyJson
+ */
+export function schemaBodyJson<A>(schema: Schema<A>) {
+  const decode = schema.decode;
+  return <E>(self: IncomingMessage<E>): IO<never, E | ParseFailure, A> => self.json.flatMap(decode);
+}
+
+/**
+ * @tsplus pipeable fncts.http.IncomingMessage schemaBodyUrlParams
+ */
+export function schemaBodyUrlParams<A>(schema: Schema<A>) {
+  const decode = schema.decode;
+  return <E>(self: IncomingMessage<E>): IO<never, E | ParseFailure, A> => self.urlParamsBody.flatMap(decode);
+}
+
+/**
+ * @tsplus pipeable fncts.http.IncomingMessage schemaHeaders
+ */
+export function schemaHeaders<A>(schema: Schema<A>) {
+  const decode = schema.decode;
+  return <E>(self: IncomingMessage<E>): IO<never, E | ParseFailure, A> => decode(self.headers);
+}

package/_src/IncomingMessage/definition.ts

@@ -0,0 +1,20 @@
+import type { Headers } from "../Headers.js";
+import type { UrlParams } from "../UrlParams.js";
+
+export const IncomingMessageTypeId = Symbol.for("fncts.http.IncomingMessage");
+export type IncomingMessageTypeId = typeof IncomingMessageTypeId;
+
+/**
+ * @tsplus type fncts.http.IncomingMessage
+ * @tsplus companion fncts.http.IncomingMessageOps
+ */
+export abstract class IncomingMessage<E> {
+  readonly [IncomingMessageTypeId]: IncomingMessageTypeId = IncomingMessageTypeId;
+  abstract readonly headers: Headers;
+  abstract readonly remoteAddress: Maybe<string>;
+  abstract readonly json: IO<never, E, unknown>;
+  abstract readonly text: IO<never, E, string>;
+  abstract readonly urlParamsBody: IO<never, E, UrlParams>;
+  abstract readonly arrayBuffer: IO<never, E, ArrayBuffer>;
+  abstract readonly stream: Stream<never, E, Uint8Array>;
+}

package/_src/IncomingMessage.ts

@@ -0,0 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: barrel, include: ./IncomingMessage/*.ts }
+export * from "./IncomingMessage/definition.js";
+export * from "./IncomingMessage/api.js";
+// codegen:end

package/_src/Method.ts

@@ -0,0 +1,5 @@
+export type Method = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+
+export function hasBody(method: Method): boolean {
+  return method !== "GET" && method !== "HEAD";
+}

package/_src/Middleware.ts

@@ -0,0 +1,29 @@
+import type { HttpApp } from "@fncts/http/HttpApp";
+
+/**
+ * @tsplus type fncts.http.Middleware
+ */
+export interface Middleware {
+  <R, E>(self: HttpApp.Default<R, E>): HttpApp.Default<any, any>;
+}
+
+/**
+ * @tsplus type fncts.http.MiddlewareOps
+ */
+export interface MiddlewareOps {}
+
+export const Middleware: MiddlewareOps = {};
+
+export declare namespace Middleware {
+  export interface Applied<R, E, A extends HttpApp.Default<any, any>> {
+    (self: HttpApp.Default<R, E>): A;
+  }
+}
+
+/**
+ * @tsplus static fncts.http.MiddlewareOps __call
+ * @tsplus static fncts.http.MiddlewareOps make
+ */
+export function make<M extends Middleware>(middleware: M): M {
+  return middleware;
+}

package/_src/QueryParams.ts

@@ -0,0 +1,7 @@
+/**
+ * @tsplus type fncts.http.QueryParams
+ * @tsplus companion fncts.http.QueryParams
+ */
+export interface QueryParams {
+  [param: string]: string;
+}

package/_src/RequestError.ts

@@ -0,0 +1,13 @@
+import type { ServerRequest } from "./ServerRequest";
+
+export const RequestErrorTypeId = Symbol.for("fncts.http.RequestError");
+export type RequestErrorTypeId = typeof RequestErrorTypeId;
+
+export class RequestError {
+  readonly [RequestErrorTypeId]: RequestErrorTypeId = RequestErrorTypeId;
+  constructor(
+    readonly request: ServerRequest,
+    readonly reason: "Transport" | "Decode",
+    readonly error: unknown,
+  ) {}
+}

package/_src/ResponseError.ts

@@ -0,0 +1,25 @@
+import { ServerRequest } from "@fncts/http/ServerRequest";
+import { ServerResponse } from "@fncts/http/ServerResponse";
+
+export const ResponseErrorTypeId = Symbol.for("fncts.http.ResponseError");
+export type ResponseErrorTypeId = typeof ResponseErrorTypeId;
+
+export class ResponseError extends Error {
+  readonly [ResponseErrorTypeId]: ResponseErrorTypeId = ResponseErrorTypeId;
+  constructor(
+    readonly request: ServerRequest,
+    readonly response: ServerResponse,
+    readonly reason: "Decode",
+    readonly error: unknown,
+  ) {
+    super();
+  }
+
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`;
+  }
+
+  get message() {
+    return `${this.reason} error (${this.response.status} ${this.methodAndUrl}): ${super.message}`;
+  }
+}

package/_src/Route/api.ts

@@ -0,0 +1,53 @@
+import type { Method } from "../Method.js";
+import type { PathInput, Route } from "./definition.js";
+
+import { RouteContext } from "./definition.js";
+import { RouteImpl } from "./internal.js";
+
+/**
+ * @tsplus static fncts.http.RouteContextOps params
+ */
+export const params = IO.service(RouteContext.Tag).map((routeContext) => routeContext.params);
+
+/**
+ * @tsplus static fncts.http.RouteContextOps searchParams
+ */
+export const searchParams = IO.service(RouteContext.Tag).map((routeContext) => routeContext.searchParams);
+
+/**
+ * @tsplus static fncts.http.RouteContextOps schemaParams
+ */
+export function schemaParams<A>(schema: Schema<A>): IO<RouteContext, ParseFailure, A> {
+  const decode = schema.decode;
+  return IO.service(RouteContext.Tag).flatMap((routeContext) =>
+    decode({ ...routeContext.params, ...routeContext.searchParams }),
+  );
+}
+
+/**
+ * @tsplus static fncts.http.RouteContextOps schemaPathParams
+ */
+export function schemaPathParams<A>(schema: Schema<A>): IO<RouteContext, ParseFailure, A> {
+  const decode = schema.decode;
+  return params.flatMap(decode);
+}
+
+/**
+ * @tsplus static fncts.http.RouteContextOps schemaSearchParams
+ */
+export function schemaSearchParams<A>(schema: Schema<A>): IO<RouteContext, ParseFailure, A> {
+  const decode = schema.decode;
+  return searchParams.flatMap(decode);
+}
+
+/**
+ * @tsplus static fncts.http.RouteOps __call
+ */
+export function make<R, E>(
+  method: Method,
+  path: PathInput,
+  handler: Route.Handler<R, E>,
+  prefix: Maybe<string> = Nothing(),
+): Route<R, E> {
+  return new RouteImpl(method, path, handler, prefix);
+}

package/_src/Route/definition.ts

@@ -0,0 +1,40 @@
+import type { Method } from "../Method.js";
+import type { ServerRequest } from "../ServerRequest";
+import type { ServerResponse } from "../ServerResponse.js";
+
+export const RouteTypeId = Symbol.for("fncts.http.RouteTypeId");
+export type RouteTypeId = typeof RouteTypeId;
+
+export type PathInput = `/${string}` | "*";
+
+export abstract class Route<R, E> {
+  readonly [RouteTypeId]: RouteTypeId = RouteTypeId;
+
+  abstract readonly method: Method | "*";
+  abstract readonly path: PathInput;
+  abstract readonly handler: Route.Handler<R, E>;
+  abstract readonly prefix: Maybe<string>;
+}
+
+export declare namespace Route {
+  export type Handler<R, E> = IO<R | ServerRequest | RouteContext, E, ServerResponse>;
+}
+
+export const RouteContextTypeId = Symbol.for("fncts.http.RouteContextTypeId");
+export type RouteContextTypeId = typeof RouteContextTypeId;
+
+/**
+ * @tsplus type fncts.http.RouteContext
+ * @tsplus companion fncts.http.RouteContextOps
+ */
+export abstract class RouteContext {
+  readonly [RouteContextTypeId]: RouteContextTypeId = RouteContextTypeId;
+  abstract readonly route: Route<unknown, unknown>;
+  abstract readonly params: Readonly<Record<string, string | undefined>>;
+  abstract readonly searchParams: Readonly<Record<string, string>>;
+}
+
+/**
+ * @tsplus static fncts.http.RouteContextOps Tag
+ */
+export const RouteContextTag = Tag<RouteContext>();

package/_src/Route/internal.ts

@@ -0,0 +1,25 @@
+import type { Method } from "../Method.js";
+import type { PathInput } from "./definition";
+
+import { Route, RouteContext } from "./definition.js";
+
+export class RouteImpl<R, E> extends Route<R, E> {
+  constructor(
+    readonly method: Method | "*",
+    readonly path: PathInput,
+    readonly handler: Route.Handler<R, E>,
+    readonly prefix: Maybe<string> = Nothing(),
+  ) {
+    super();
+  }
+}
+
+export class RouteContextImpl extends RouteContext {
+  constructor(
+    readonly route: Route<unknown, unknown>,
+    readonly params: Readonly<Record<string, string | undefined>>,
+    readonly searchParams: Readonly<Record<string, string>>,
+  ) {
+    super();
+  }
+}

package/_src/Route.ts

@@ -0,0 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: barrel, include: ./Route/*.ts, exclude: Route/*(*internal).* }
+export * from "./Route/definition.js";
+export * from "./Route/api.js";
+// codegen:end

package/_src/RouteNotFound.ts

@@ -0,0 +1,14 @@
+import type { ServerRequest } from "./ServerRequest.js";
+
+export const RouteNotFoundTypeId = Symbol.for("fncts.http.RouteNotFound");
+export type RouteNotFoundTypeId = typeof RouteNotFoundTypeId;
+
+export class RouteNotFound extends Error {
+  constructor(readonly request: ServerRequest) {
+    super();
+  }
+
+  get message() {
+    return `${this.request.method} ${this.request.url} not found`;
+  }
+}

package/_src/Router/api.ts

@@ -0,0 +1,161 @@
+import type { HttpApp } from "../HttpApp.js";
+import type { Method } from "../Method.js";
+import type { PathInput, Route } from "../Route.js";
+import type { Router } from "./definition.js";
+
+import { RouteImpl } from "../Route/internal.js";
+import { RouterInternal } from "./internal.js";
+
+/**
+ * @tsplus static fncts.http.RouterOps empty
+ */
+export const empty: Router<never, never> = new RouterInternal(Conc.empty(), Conc.empty());
+
+export function route(method: Method | "*") {
+  return <R1, E1>(path: PathInput, handler: Route.Handler<R1, E1>) =>
+    <R, E>(self: Router<R, E>): Router<R | Router.ExcludeProvided<R1>, E | E1> =>
+      new RouterInternal<any, any>(self.routes.append(new RouteImpl(method, path, handler)), self.mounts);
+}
+
+/**
+ * @tsplus pipeable fncts.http.Router get
+ * @tsplus static fncts.http.RouterOps get
+ */
+export const get: <R1, E1>(
+  path: PathInput,
+  handler: Route.Handler<R1, E1>,
+) => <R, E>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E | E1> = route("GET");
+
+/**
+ * @tsplus pipeable fncts.http.Router post
+ * @tsplus static fncts.http.RouterOps post
+ */
+export const post: <R1, E1>(
+  path: PathInput,
+  handler: Route.Handler<R1, E1>,
+) => <R, E>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E | E1> = route("POST");
+/**
+ * @tsplus pipeable fncts.http.Router put
+ * @tsplus static fncts.http.RouterOps put
+ */
+export const put: <R1, E1>(
+  path: PathInput,
+  handler: Route.Handler<R1, E1>,
+) => <R, E>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E | E1> = route("PUT");
+/**
+ * @tsplus pipeable fncts.http.Router patch
+ * @tsplus static fncts.http.RouterOps patch
+ */
+export const patch: <R1, E1>(
+  path: PathInput,
+  handler: Route.Handler<R1, E1>,
+) => <R, E>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E | E1> = route("PATCH");
+/**
+ * @tsplus pipeable fncts.http.Router del
+ * @tsplus static fncts.http.RouterOps del
+ */
+export const del: <R1, E1>(
+  path: PathInput,
+  handler: Route.Handler<R1, E1>,
+) => <R, E>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E | E1> = route("DELETE");
+/**
+ * @tsplus pipeable fncts.http.Router head
+ * @tsplus static fncts.http.RouterOps head
+ */
+export const head: <R1, E1>(
+  path: PathInput,
+  handler: Route.Handler<R1, E1>,
+) => <R, E>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E | E1> = route("HEAD");
+/**
+ * @tsplus pipeable fncts.http.Router options
+ * @tsplus static fncts.http.RouterOps options
+ */
+export const options: <R1, E1>(
+  path: PathInput,
+  handler: Route.Handler<R1, E1>,
+) => <R, E>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E | E1> = route("OPTIONS");
+
+/**
+ * @tsplus pipeable fncts.http.Router use
+ * @tsplus static fncts.http.RouterOps use
+ */
+export function use<R, E, R1, E1>(f: (self: Route.Handler<R, E>) => HttpApp.Default<R1, E1>, __tsplusTrace?: string) {
+  return (self: Router<R, E>): Router<Router.ExcludeProvided<R1>, E1> =>
+    new RouterInternal<any, any>(
+      self.routes.map((route) => new RouteImpl(route.method, route.path, f(route.handler as any), route.prefix)),
+      self.mounts.map(({ prefix, httpApp }) => ({ prefix, httpApp: f(httpApp as any) })),
+    );
+}
+
+/**
+ * @tsplus static fncts.http.RouterOps from
+ */
+export function from<R extends Route<any, any>>(
+  routes: Iterable<R>,
+): Router<R extends Route<infer Env, infer _> ? Env : never, R extends Route<infer _, infer E> ? E : never> {
+  return new RouterInternal(Conc.from(routes), Conc.empty());
+}
+
+/**
+ * @tsplus pipeable fncts.http.Router concat
+ */
+export function concat<R1, E1>(that: Router<R1, E1>) {
+  return <R, E>(self: Router<R, E>): Router<R | R1, E | E1> =>
+    new RouterInternal(self.routes.concat(that.routes) as Conc<Route<R | R1, E | E1>>, self.mounts);
+}
+
+function removeTrailingSlash(path: PathInput): PathInput {
+  return (path.endsWith("/") ? path.slice(0, -1) : path) as PathInput;
+}
+
+/**
+ * @tsplus pipeable fncts.http.Router prefixAll
+ */
+export function prefixAll(prefix: PathInput) {
+  return <R, E>(self: Router<R, E>): Router<R, E> => {
+    prefix = removeTrailingSlash(prefix);
+    return new RouterInternal(
+      self.routes.map(
+        (route) =>
+          new RouteImpl(
+            route.method,
+            route.path === "/" ? prefix : ((prefix + route.path) as PathInput),
+            route.handler,
+            route.prefix.map((_) => prefix + _).orElse(Just(prefix)),
+          ),
+      ),
+      self.mounts.map(({ prefix: path, httpApp }) => ({ prefix: path === "/" ? prefix : prefix + path, httpApp })),
+    );
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.http.Router mount
+ */
+export function mount<R1, E1>(path: `/${string}`, that: Router<R1, E1>) {
+  return <R, E>(self: Router<R, E>): Router<R | R1, E | E1> => self.concat(that.prefixAll(path));
+}
+
+/**
+ * @tsplus pipeable fncts.http.Router catchAll
+ */
+export function catchAll<E, R1, E1>(f: (e: E) => Route.Handler<R1, E1>, __tsplusTrace?: string) {
+  return <R>(self: Router<R, E>): Router<R | Router.ExcludeProvided<R1>, E1> =>
+    self.use((handler) => handler.catchAll(f));
+}
+
+/**
+ * @tsplus pipeable fncts.http.Router catchAllCause
+ */
+export function catchAllCause<E, R1, E1>(f: (e: Cause<E>) => Route.Handler<R1, E1>, __tsplusTrace?: string) {
+  return <R>(self: Router<R, E>): Router<R | Router.ExcludeProvided<R1>, E1> =>
+    self.use((handler) => handler.catchAllCause(f));
+}
+
+/**
+ * @tsplus pipeable fncts.http.Router provideService
+ */
+export function provideService<T>(service: T, tag: Tag<T>, __tsplusTrace?: string) {
+  return <R, E>(self: Router<R, E>): Router<Exclude<R, T>, E> =>
+    self.use((handler) => handler.provideSomeService(service, tag));
+}

package/_src/Router/definition.ts

@@ -0,0 +1,29 @@
+import type { HttpApp } from "../HttpApp.js";
+import type { Route, RouteContext } from "../Route.js";
+import type { RouteNotFound } from "../RouteNotFound.js";
+import type { ServerRequest } from "../ServerRequest.js";
+import type { ServerResponse } from "@fncts/http/ServerResponse";
+
+import { External } from "@fncts/io/IO";
+
+export const RouterTypeId = Symbol.for("fncts.http.Router");
+export type RouterTypeId = typeof RouterTypeId;
+
+/**
+ * @tsplus type fncts.http.Router
+ * @tsplus companion fncts.http.RouterOps
+ */
+export abstract class Router<R, E>
+  extends External<Exclude<R, RouteContext>, E | RouteNotFound, ServerResponse>
+  implements HttpApp.Default<Exclude<R, RouteContext>, E | RouteNotFound>
+{
+  readonly [RouterTypeId]: RouterTypeId = RouterTypeId;
+  abstract readonly routes: Conc<Route<R, E>>;
+  abstract readonly mounts: Conc<
+    Readonly<{ prefix: string; httpApp: HttpApp.Default<R, E>; options?: { readonly inclduePrefix?: boolean } }>
+  >;
+}
+
+export declare namespace Router {
+  export type ExcludeProvided<A> = Exclude<A, RouteContext | ServerRequest | Scope>;
+}