@fncts/http 0.0.0

package/_src/Router/internal.ts

@@ -0,0 +1,95 @@
+import type { HttpApp } from "../HttpApp.js";
+import type { ServerResponse } from "../ServerResponse.js";
+
+import { IO } from "@fncts/io/IO";
+import * as FindMyWay from "find-my-way-ts";
+
+import { type PathInput, type Route, RouteContext } from "../Route.js";
+import { RouteContextImpl, RouteImpl } from "../Route/internal.js";
+import { RouteNotFound } from "../RouteNotFound.js";
+import { ServerRequest } from "../ServerRequest.js";
+import { Router } from "./definition.js";
+
+export class RouterInternal<R, E> extends Router<R, E> {
+  readonly httpApp: IO<Exclude<R, RouteContext>, E | RouteNotFound, ServerResponse>;
+
+  constructor(
+    readonly routes: Conc<Route<R, E>>,
+    readonly mounts: Conc<
+      Readonly<{ prefix: string; httpApp: HttpApp.Default<R, E>; options?: { readonly inclduePrefix?: boolean } }>
+    >,
+  ) {
+    super();
+    this.httpApp = toHttpApp(this) as any;
+  }
+
+  get toIO(): IO<Exclude<R, RouteContext>, RouteNotFound | E, ServerResponse> {
+    return this.httpApp;
+  }
+}
+
+function toHttpApp<R, E>(self: Router<R, E>): HttpApp.Default<R, E | RouteNotFound> {
+  const router = FindMyWay.make<Route<R, E>>();
+
+  const mounts = self.mounts.map(
+    ({ prefix, httpApp, options }) =>
+      [
+        prefix,
+        new RouteContextImpl(
+          new RouteImpl(
+            "*",
+            options?.inclduePrefix ? (`${prefix}/*` as PathInput) : "/*",
+            httpApp,
+            options?.inclduePrefix ? Nothing() : Just(prefix),
+          ),
+          {},
+          {},
+        ) as RouteContext,
+        options,
+      ] as const,
+  );
+  const mountsLen = mounts.length;
+  self.routes.forEach((route) => {
+    if (route.method === "*") {
+      router.all(route.path, route);
+    } else {
+      router.on(route.method, route.path, route);
+    }
+  });
+  return IO.withFiberRuntime<R | ServerRequest, E | RouteNotFound, ServerResponse>((fiber) => {
+    let context   = fiber.getFiberRef(FiberRef.currentEnvironment);
+    const request = context.unsafeGet(ServerRequest.Tag);
+    if (mountsLen > 0) {
+      for (let i = 0; i < mountsLen; i++) {
+        const [path, routeContext, options] = mounts[i];
+        if (request.url.startsWith(path)) {
+          context = context.add(routeContext, RouteContext.Tag);
+          if (options?.inclduePrefix !== true) {
+            context = context.add(sliceRequestUrl(request, path), ServerRequest.Tag);
+          }
+          return FiberRef.currentEnvironment.locally(context)(routeContext.route.handler as HttpApp.Default<R, E>);
+        }
+      }
+    }
+
+    let result = router.find(request.method, request.url);
+    if (result === undefined && request.method === "HEAD") {
+      result = router.find("GET", request.url);
+    }
+    if (result === undefined) {
+      return IO.failNow(new RouteNotFound(request));
+    }
+    const route = result.handler;
+    if (route.prefix.isJust()) {
+      context = context.add(sliceRequestUrl(request, route.prefix.value), ServerRequest.Tag);
+    }
+    return FiberRef.currentEnvironment.locally(context)(
+      route.handler as IO<Router.ExcludeProvided<R>, E, ServerResponse>,
+    );
+  });
+}
+
+function sliceRequestUrl(request: ServerRequest, prefix: string) {
+  const prefixLen = prefix.length;
+  return request.modify({ url: request.url.length <= prefixLen ? "/" : request.url.slice(prefixLen) });
+}

package/_src/Router.ts

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

package/_src/Server.ts

@@ -0,0 +1,88 @@
+import type { HttpApp } from "@fncts/http/HttpApp";
+import type { Middleware } from "@fncts/http/Middleware";
+import type { ServerRequest } from "@fncts/http/ServerRequest";
+
+export const ServerTypeId = Symbol.for("fncts.http.Server");
+export type ServerTypeId = typeof ServerTypeId;
+
+/**
+ * @tsplus type fncts.http.Server
+ * @tsplus companion fncts.http.ServerOps
+ */
+export abstract class Server {
+  readonly [ServerTypeId]: ServerTypeId = ServerTypeId;
+  abstract serve<R, E>(httpApp: HttpApp.Default<R, E>): IO<Exclude<R, ServerRequest> | Scope, never, void>;
+  abstract serve<R, E, App extends HttpApp.Default<any, any>>(
+    httpApp: HttpApp.Default<R, E>,
+    middleware: Middleware.Applied<R, E, App>,
+  ): IO<Exclude<R, ServerRequest> | Scope, never, void>;
+  abstract readonly address: Address;
+}
+
+/**
+ * @tsplus static fncts.http.ServerOps Tag
+ */
+export const ServerTag = Tag<Server>();
+
+export type Address = TcpAddress | UnixAddress;
+
+export interface TcpAddress {
+  readonly _tag: "TcpAddress";
+  readonly hostname: string;
+  readonly port: number;
+}
+
+export interface UnixAddress {
+  readonly _tag: "UnixAddress";
+  readonly path: string;
+}
+
+/**
+ * @tsplus static fncts.http.ServerOps __call
+ */
+export function make(options: {
+  readonly serve: (httpApp: HttpApp.Default<never, unknown>, middleware?: Middleware) => IO<Scope, never, void>;
+  readonly address: Address;
+}): Server {
+  return new (class extends Server {
+    serve = options.serve;
+    address = options.address;
+  })();
+}
+
+/**
+ * @tsplus pipeable fncts.http.HttpApp serve
+ */
+export function serve(): <R, E>(
+  httpApp: HttpApp.Default<R, E>,
+) => Layer<Server | Exclude<R, ServerRequest | Scope>, never, never>;
+export function serve<R, E, App extends HttpApp.Default<any, any>>(
+  middleware: Middleware.Applied<R, E, App>,
+): (
+  httpApp: HttpApp.Default<R, E>,
+  middleware: Middleware.Applied<R, E, App>,
+) => Layer<Server | Exclude<R, ServerRequest | Scope>, never, never>;
+export function serve<R, E, App extends HttpApp.Default<any, any>>(
+  middleware?: Middleware.Applied<R, E, App>,
+): (httpApp: HttpApp.Default<R, E>) => Layer<Server | Exclude<R, ServerRequest | Scope>, never, never> {
+  return (httpApp) =>
+    Layer.scopedDiscard(IO.service(Server.Tag).flatMap((server) => server.serve(httpApp, middleware!))) as any;
+}
+
+/**
+ * @tsplus pipeable fncts.http.HttpApp serveIO
+ */
+export function serveIO(): <R, E>(
+  httpApp: HttpApp.Default<R, E>,
+) => IO<Server | Exclude<R, ServerRequest | Scope>, never, never>;
+export function serveIO<R, E, App extends HttpApp.Default<any, any>>(
+  middleware: Middleware.Applied<R, E, App>,
+): (
+  httpApp: HttpApp.Default<R, E>,
+  middleware: Middleware.Applied<R, E, App>,
+) => IO<Server | Exclude<R, ServerRequest | Scope>, never, never>;
+export function serveIO<R, E, App extends HttpApp.Default<any, any>>(
+  middleware?: Middleware.Applied<R, E, App>,
+): (httpApp: HttpApp.Default<R, E>) => IO<Server | Exclude<R, ServerRequest | Scope>, never, never> {
+  return (httpApp) => IO.service(Server.Tag).flatMap((server) => server.serve(httpApp, middleware!)) as any;
+}

package/_src/ServerError.ts

@@ -0,0 +1,14 @@
+import { Runtime } from "@fncts/base/data/FiberId";
+import { globalValue } from "@fncts/base/data/Global";
+
+export const clientAbortFiberId = globalValue("fncts.http.ServerError.clientAbortFiberId", () => new Runtime(-499, 0));
+
+export const ServeErrorTypeId = Symbol.for("fncts.http.ServeError");
+export type ServeErrorTypeId = typeof ServeErrorTypeId;
+
+export class ServeError extends Error {
+  readonly [ServeErrorTypeId]: ServeErrorTypeId = ServeErrorTypeId;
+  constructor(readonly error?: unknown) {
+    super();
+  }
+}

package/_src/ServerRequest/api.ts

@@ -0,0 +1,10 @@
+import type { ServerRequest } from "./definition.js";
+
+import { ServerRequestImpl } from "./internal.js";
+
+/**
+ * @tsplus static fncts.http.ServerRequestOps fromWeb
+ */
+export function fromWeb(request: globalThis.Request): ServerRequest {
+  return new ServerRequestImpl(request, request.url);
+}

package/_src/ServerRequest/definition.ts

@@ -0,0 +1,33 @@
+import type { Headers } from "../Headers.js";
+import type { Method } from "../Method.js";
+import type { RequestError } from "../RequestError.js";
+import type { Socket } from "@fncts/http/Socket";
+
+import { IncomingMessage } from "../IncomingMessage/definition.js";
+
+export const ServerRequestTypeId = Symbol.for("fncts.http.ServerRequest");
+export type ServerRequestTypeId = typeof ServerRequestTypeId;
+
+/**
+ * @tsplus type fncts.http.ServerRequest
+ * @tsplus companion fncts.http.ServerRequestOps
+ */
+export abstract class ServerRequest extends IncomingMessage<RequestError> {
+  readonly [ServerRequestTypeId]: ServerRequestTypeId = ServerRequestTypeId;
+
+  abstract readonly source: unknown;
+  abstract readonly url: string;
+  abstract readonly originalUrl: string;
+  abstract readonly method: Method;
+  abstract upgrade: IO<never, RequestError, Socket>;
+  abstract modify(options: {
+    readonly url?: string;
+    readonly headers?: Headers;
+    readonly remoteAddress?: string;
+  }): ServerRequest;
+}
+
+/**
+ * @tsplus static fncts.http.ServerRequestOps Tag
+ */
+export const ServerRequestTag = Tag<ServerRequest>();

package/_src/ServerRequest/internal.ts

@@ -0,0 +1,106 @@
+import type { Method } from "../Method.js";
+import type { Socket } from "@fncts/http/Socket";
+
+import { Headers } from "../Headers.js";
+import { RequestError } from "../RequestError.js";
+import { UrlParams } from "../UrlParams.js";
+import { ServerRequest } from "./definition.js";
+
+export class ServerRequestImpl extends ServerRequest {
+  constructor(
+    readonly source: Request,
+    readonly url: string,
+    public headersOverride?: Headers,
+    private remoteAddressOverride?: string,
+  ) {
+    super();
+  }
+
+  get method(): Method {
+    return this.source.method.toUpperCase() as Method;
+  }
+
+  get originalUrl() {
+    return this.source.url;
+  }
+
+  get remoteAddress() {
+    return Maybe.fromNullable(this.remoteAddressOverride);
+  }
+
+  get headers() {
+    this.headersOverride ??= Headers.fromHeaders(this.source.headers);
+    return this.headersOverride;
+  }
+
+  private textIO: IO<never, RequestError, string> | undefined;
+  get text(): IO<never, RequestError, string> {
+    if (this.textIO) {
+      return this.textIO;
+    }
+
+    this.textIO = IO.fromPromiseCatch(
+      this.source.text(),
+      (error) => new RequestError(this, "Decode", error),
+    ).memoize.unsafeRun.getOrThrow;
+
+    return this.textIO;
+  }
+
+  get json(): IO<never, RequestError, unknown> {
+    return this.text.flatMap((text) =>
+      IO.tryCatch(
+        () => JSON.parse(text),
+        (error) => new RequestError(this, "Decode", error),
+      ),
+    );
+  }
+
+  get urlParamsBody(): IO<never, RequestError, UrlParams> {
+    return this.text.flatMap((text) =>
+      IO.tryCatch(
+        () => UrlParams(new URLSearchParams(text)),
+        (error) => new RequestError(this, "Decode", error),
+      ),
+    );
+  }
+
+  private arrayBufferIO: IO<never, RequestError, ArrayBuffer> | undefined;
+  get arrayBuffer(): IO<never, RequestError, ArrayBuffer> {
+    if (this.arrayBufferIO) {
+      return this.arrayBufferIO;
+    }
+
+    this.arrayBufferIO = IO.fromPromiseCatch(
+      this.source.arrayBuffer(),
+      (error) => new RequestError(this, "Decode", error),
+    ).memoize.unsafeRun.getOrThrow;
+
+    return this.arrayBufferIO;
+  }
+
+  get stream(): Stream<never, RequestError, Uint8Array> {
+    if (this.source.body) {
+      return Stream.fromReadableStream(this.source.body, (error) => new RequestError(this, "Decode", error));
+    } else {
+      return Stream.failNow(new RequestError(this, "Decode", "cannot create stream from empty body"));
+    }
+  }
+
+  modify(options: {
+    readonly url?: string | undefined;
+    readonly headers?: Headers | undefined;
+    readonly remoteAddress?: string | undefined;
+  }): ServerRequest {
+    return new ServerRequestImpl(
+      this.source,
+      options.url ?? this.url,
+      options.headers ?? this.headers,
+      options.remoteAddress ?? this.remoteAddressOverride,
+    );
+  }
+
+  get upgrade(): IO<never, RequestError, Socket> {
+    return IO.failNow(new RequestError(this, "Decode", "Not an upgradeable ServerRequest"));
+  }
+}

package/_src/ServerRequest.ts

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

package/_src/ServerResponse/api.ts

@@ -0,0 +1,177 @@
+import type { BodyError } from "../BodyError.js";
+import type { Options } from "./definition";
+
+import { Body, BodyTag } from "../Body.js";
+import { Headers } from "../Headers.js";
+import { UrlParams } from "../UrlParams.js";
+import { ServerResponse } from "./definition.js";
+
+/**
+ * @tsplus static fncts.http.ServerResponseOps empty
+ */
+export function empty(options?: Options.WithContent): ServerResponse {
+  return new ServerResponse(options?.status ?? 204, options?.statusText, options?.headers ?? Headers.empty, Body.empty);
+}
+
+/**
+ * @tsplus static fncts.http.ServerResponseOps uint8Array
+ */
+export function uint8Array(body: Uint8Array, options?: Options.WithContentType): ServerResponse {
+  return new ServerResponse(
+    options?.status ?? 200,
+    options?.statusText,
+    options?.headers ?? Headers.empty,
+    Body.uint8Array(body, getContentType(options)),
+  );
+}
+
+/**
+ * @tsplus static fncts.http.ServerResponseOps text
+ */
+export function text(body: string, options?: Options.WithContentType): ServerResponse {
+  return new ServerResponse(
+    options?.status ?? 200,
+    options?.statusText,
+    options?.headers ?? Headers.empty,
+    Body.text(body, getContentType(options)),
+  );
+}
+
+/**
+ * @tsplus static fncts.http.ServerResponseOps json
+ */
+export function json(body: unknown, options?: Options.WithContent): IO<never, BodyError, ServerResponse> {
+  return Body.json(body).map(
+    (body) => new ServerResponse(options?.status ?? 200, options?.statusText, options?.headers ?? Headers.empty, body),
+  );
+}
+
+/**
+ * @tsplus static fncts.http.ServerResponseOps schemaJson
+ */
+export function schemaJson<A>(schema: Schema<A>) {
+  const encode = Body.jsonSchema(schema);
+  return (body: A, options?: Options.WithContent): IO<never, BodyError, ServerResponse> =>
+    encode(body).map(
+      (body) =>
+        new ServerResponse(options?.status ?? 200, options?.statusText, options?.headers ?? Headers.empty, body),
+    );
+}
+
+/**
+ * @tsplus static fncts.http.ServerResponseOps urlParams
+ */
+export function urlParams(body: UrlParams.Input, options?: Options.WithContent): ServerResponse {
+  return new ServerResponse(
+    options?.status ?? 200,
+    options?.statusText,
+    options?.headers ?? Headers.empty,
+    Body.text(UrlParams(body).toString(), "application/x-www-form-urlencoded"),
+  );
+}
+
+/**
+ * @tsplus static fncts.http.ServerResponseOps stream
+ */
+export function stream(body: Stream<never, unknown, Uint8Array>, options?: Options): ServerResponse {
+  return new ServerResponse(
+    options?.status ?? 200,
+    options?.statusText,
+    options?.headers ?? Headers.empty,
+    Body.stream(body, {
+      contentType: getContentType(options),
+      contentLength: options?.contentLength,
+    }),
+  );
+}
+
+/**
+ * @tsplus pipeable fncts.http.ServerResponse setHeader
+ */
+export function setHeader(key: string, value: string) {
+  return (self: ServerResponse): ServerResponse =>
+    new ServerResponse(self.status, self.statusText, self.headers.set(key, value), self.body);
+}
+
+/**
+ * @tsplus pipeable fncts.http.ServerResponse setHeaders
+ */
+export function setHeaders(headers: Headers.Input) {
+  return (self: ServerResponse): ServerResponse =>
+    new ServerResponse(self.status, self.statusText, self.headers.setAll(headers), self.body);
+}
+
+/**
+ * @tsplus pipeable fncts.http.ServerResponse setStatus
+ */
+export function setStatus(status: number, statusText?: string) {
+  return (self: ServerResponse): ServerResponse => new ServerResponse(status, statusText, self.headers, self.body);
+}
+
+/**
+ * @tsplus pipeable fncts.http.ServerResponse setBody
+ */
+export function setBody(body: Body) {
+  return (self: ServerResponse): ServerResponse => {
+    let headers = self.headers;
+    body.concrete();
+    if (body._tag === BodyTag.Empty) {
+      headers = self.headers.remove("content-type").remove("content-length");
+    }
+    return new ServerResponse(self.status, self.statusText, headers, body);
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.http.ServerResponse toWeb
+ */
+export function toWeb(withoutBody = false) {
+  return (self: ServerResponse): Response => {
+    if (withoutBody) {
+      return new Response(undefined, {
+        status: self.status,
+        statusText: self.statusText,
+        headers: self.headers.toHeadersInit(),
+      });
+    }
+
+    self.body.concrete();
+    switch (self.body._tag) {
+      case BodyTag.Empty:
+        return new Response(undefined, {
+          status: self.status,
+          statusText: self.statusText,
+          headers: self.headers.toHeadersInit(),
+        });
+      case BodyTag.Uint8Array:
+      case BodyTag.Raw:
+        return new Response(self.body.body as any, {
+          status: self.status,
+          statusText: self.statusText,
+          headers: self.headers.toHeadersInit(),
+        });
+      case BodyTag.FormData:
+        return new Response(self.body.formData, {
+          status: self.status,
+          statusText: self.statusText,
+          headers: self.headers.toHeadersInit(),
+        });
+      case BodyTag.Stream:
+        return new Response(self.body.stream.toReadableStream, {
+          status: self.status,
+          statusText: self.statusText,
+          headers: self.headers.toHeadersInit(),
+        });
+    }
+  };
+}
+
+function getContentType(options: Options | undefined): string | undefined {
+  if (options?.contentType) {
+    return options.contentType;
+  } else if (options?.headers) {
+    return options.headers.unsafeGet("content-type");
+  } else {
+    return;
+  }
+}

package/_src/ServerResponse/definition.ts

@@ -0,0 +1,51 @@
+import type { Body } from "../Body.js";
+
+import { Headers } from "../Headers.js";
+
+export const ServerResponseTypeId = Symbol.for("fncts.http.ServerResponse");
+export type ServerResponseTypeId = typeof ServerResponseTypeId;
+
+/**
+ * @tsplus type fncts.http.ServerResponse
+ * @tsplus companion fncts.http.ServerResponseOps
+ */
+export class ServerResponse {
+  readonly [ServerResponseTypeId]: ServerResponseTypeId = ServerResponseTypeId;
+  readonly headers: Headers;
+  constructor(
+    readonly status: number,
+    readonly statusText: string | undefined,
+    headers: Headers,
+    readonly body: Body,
+  ) {
+    if (body.contentType || body.contentLength) {
+      const newHeaders = headers.backing.beginMutation;
+      if (body.contentType) {
+        newHeaders.set("content-type", body.contentType);
+      }
+      if (body.contentLength) {
+        newHeaders.set("content-length", body.contentLength.toString());
+      }
+      this.headers = new Headers(newHeaders.endMutation);
+    } else {
+      this.headers = headers;
+    }
+  }
+}
+
+export interface Options {
+  status?: number;
+  statusText?: string;
+  headers?: Headers;
+  contentType?: string;
+  contentLength?: number;
+}
+
+export declare namespace Options {
+  export interface WithContent extends Omit<Options, "contentType" | "contentLength"> {}
+  export interface WithContentType extends Omit<Options, "contentLength"> {}
+}
+
+export function isServerResponse(u: unknown): u is ServerResponse {
+  return isObject(u) && ServerResponseTypeId in u;
+}

package/_src/ServerResponse.ts

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