@effect/platform 0.11.4 → 0.12.0

package/src/Http/Middleware.ts

@@ -0,0 +1,69 @@
+/**
+ * @since 1.0.0
+ */
+import type * as App from "@effect/platform/Http/App"
+import * as internal from "@effect/platform/internal/http/middleware"
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Middleware {
+  <R, E>(self: App.Default<R, E>): App.Default<any, any>
+}
+
+/**
+ * @since 1.0.0
+ */
+export namespace Middleware {
+  /**
+   * @since 1.0.0
+   */
+  export interface Applied<R, E, A extends App.Default<any, any>> {
+    (self: App.Default<R, E>): A
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make: <M extends Middleware>(middleware: M) => M = internal.make
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const compose: {
+  <B extends App.Default<any, any>, C extends App.Default<any, any>>(
+    that: (b: B) => C
+  ): <A extends App.Default<any, any>>(self: (a: A) => B) => (a: A) => C
+  <A extends App.Default<any, any>, B extends App.Default<any, any>, C extends App.Default<any, any>>(
+    self: (a: A) => B,
+    that: (b: B) => C
+  ): (a: A) => C
+} = internal.compose
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const logger: <R, E>(httpApp: App.Default<R, E>) => App.Default<R, E> = internal.logger
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const tracer: <R, E>(httpApp: App.Default<R, E>) => App.Default<R, E> = internal.tracer
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const loggerTracer: <R, E>(httpApp: App.Default<R, E>) => App.Default<R, E> = internal.loggerTracer
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const xForwardedHeaders: <R, E>(httpApp: App.Default<R, E>) => App.Default<R, E> = internal.xForwardedHeaders

package/src/Http/Router.ts

@@ -0,0 +1,342 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Chunk from "@effect/data/Chunk"
+import type * as Context from "@effect/data/Context"
+import type * as Option from "@effect/data/Option"
+import type * as Effect from "@effect/io/Effect"
+import type * as App from "@effect/platform/Http/App"
+import type * as Method from "@effect/platform/Http/Method"
+import type * as Error from "@effect/platform/Http/ServerError"
+import type * as ServerResponse from "@effect/platform/Http/ServerResponse"
+import * as internal from "@effect/platform/internal/http/router"
+import type * as ParseResult from "@effect/schema/ParseResult"
+import type * as Schema from "@effect/schema/Schema"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const TypeId: unique symbol = internal.TypeId
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Router<R, E> extends App.Default<Exclude<R, RouteContext>, E | Error.RouteNotFound> {
+  readonly [TypeId]: TypeId
+  readonly routes: Chunk.Chunk<Route<R, E>>
+  readonly mounts: Chunk.Chunk<readonly [string, App.Default<R, E>]>
+}
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const RouteTypeId: unique symbol = internal.RouteTypeId
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type RouteTypeId = typeof RouteTypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Route<R, E> {
+  readonly [RouteTypeId]: RouteTypeId
+  readonly method: Method.Method | "*"
+  readonly path: string
+  readonly handler: Route.Handler<R, E>
+  readonly prefix: Option.Option<string>
+}
+
+/**
+ * @since 1.0.0
+ */
+export namespace Route {
+  /**
+   * @since 1.0.0
+   */
+  export type Handler<R, E> = Effect.Effect<
+    R,
+    E,
+    ServerResponse.ServerResponse
+  >
+}
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const RouteContextTypeId: unique symbol = internal.RouteContextTypeId
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type RouteContextTypeId = typeof RouteContextTypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface RouteContext {
+  readonly [RouteContextTypeId]: RouteContextTypeId
+  readonly params: Readonly<Record<string, string | undefined>>
+  readonly searchParams: Readonly<Record<string, string>>
+}
+
+/**
+ * @since 1.0.0
+ * @category route context
+ */
+export const RouteContext: Context.Tag<RouteContext, RouteContext> = internal.RouteContext
+
+/**
+ * @since 1.0.0
+ * @category route context
+ */
+export const params: Effect.Effect<
+  RouteContext,
+  never,
+  Readonly<Record<string, string | undefined>>
+> = internal.params
+
+/**
+ * @since 1.0.0
+ * @category route context
+ */
+export const searchParams: Effect.Effect<
+  RouteContext,
+  never,
+  Readonly<Record<string, string>>
+> = internal.searchParams
+
+/**
+ * @since 1.0.0
+ * @category route context
+ */
+export const schemaParams: <I extends Readonly<Record<string, string>>, A>(
+  schema: Schema.Schema<I, A>
+) => Effect.Effect<RouteContext, ParseResult.ParseError, A> = internal.schemaParams
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const empty: Router<never, never> = internal.empty
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const fromIterable: <R, E>(
+  routes: Iterable<Route<R, E>>
+) => Router<R, E> = internal.fromIterable
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeRoute: <R, E>(
+  method: Method.Method,
+  path: string,
+  handler: Route.Handler<R, E>
+) => Route<R, E> = internal.makeRoute
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const prefixAll: {
+  (prefix: string): <R, E>(self: Router<R, E>) => Router<R, E>
+  <R, E>(self: Router<R, E>, prefix: string): Router<R, E>
+} = internal.prefixAll
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const concat: {
+  <R1, E1>(that: Router<R1, E1>): <R, E>(
+    self: Router<R, E>
+  ) => Router<R1 | R, E1 | E>
+  <R, E, R1, E1>(self: Router<R, E>, that: Router<R1, E1>): Router<
+    R | R1,
+    E | E1
+  >
+} = internal.concat
+
+/**
+ * @since 1.0.0
+ * @category routing
+ */
+export const mount: {
+  <R1, E1>(path: string, that: Router<R1, E1>): <R, E>(
+    self: Router<R, E>
+  ) => Router<R1 | R, E1 | E>
+  <R, E, R1, E1>(
+    self: Router<R, E>,
+    path: string,
+    that: Router<R1, E1>
+  ): Router<R | R1, E | E1>
+} = internal.mount
+
+/**
+ * @since 1.0.0
+ * @category routing
+ */
+export const mountApp: {
+  <R1, E1>(path: string, that: App.Default<R1, E1>): <R, E>(
+    self: Router<R, E>
+  ) => Router<R1 | R, E1 | E>
+  <R, E, R1, E1>(
+    self: Router<R, E>,
+    path: string,
+    that: App.Default<R1, E1>
+  ): Router<R | R1, E | E1>
+} = internal.mountApp
+
+/**
+ * @since 1.0.0
+ * @category routing
+ */
+export const route: (method: Method.Method) => {
+  <R1, E1>(path: string, handler: Route.Handler<R1, E1>): <R, E>(
+    self: Router<R, E>
+  ) => Router<R | Exclude<R1, RouteContext>, E1 | E>
+  <R, E, R1, E1>(
+    self: Router<R, E>,
+    path: string,
+    handler: Route.Handler<R1, E1>
+  ): Router<R | Exclude<R1, RouteContext>, E | E1>
+} = internal.route
+
+/**
+ * @since 1.0.0
+ * @category routing
+ */
+export const all: {
+  <R1, E1>(path: string, handler: Route.Handler<R1, E1>): <R, E>(
+    self: Router<R, E>
+  ) => Router<R | Exclude<R1, RouteContext>, E1 | E>
+  <R, E, R1, E1>(
+    self: Router<R, E>,
+    path: string,
+    handler: Route.Handler<R1, E1>
+  ): Router<R | Exclude<R1, RouteContext>, E | E1>
+} = internal.all
+
+/**
+ * @since 1.0.0
+ * @category routing
+ */
+export const get: {
+  <R1, E1>(path: string, handler: Route.Handler<R1, E1>): <R, E>(
+    self: Router<R, E>
+  ) => Router<R | Exclude<R1, RouteContext>, E1 | E>
+  <R, E, R1, E1>(
+    self: Router<R, E>,
+    path: string,
+    handler: Route.Handler<R1, E1>
+  ): Router<R | Exclude<R1, RouteContext>, E | E1>
+} = internal.get
+
+/**
+ * @since 1.0.0
+ * @category routing
+ */
+export const post: {
+  <R1, E1>(path: string, handler: Route.Handler<R1, E1>): <R, E>(
+    self: Router<R, E>
+  ) => Router<R | Exclude<R1, RouteContext>, E1 | E>
+  <R, E, R1, E1>(
+    self: Router<R, E>,
+    path: string,
+    handler: Route.Handler<R1, E1>
+  ): Router<R | Exclude<R1, RouteContext>, E | E1>
+} = internal.post
+
+/**
+ * @since 1.0.0
+ * @category routing
+ */
+export const patch: {
+  <R1, E1>(path: string, handler: Route.Handler<R1, E1>): <R, E>(
+    self: Router<R, E>
+  ) => Router<R | Exclude<R1, RouteContext>, E1 | E>
+  <R, E, R1, E1>(
+    self: Router<R, E>,
+    path: string,
+    handler: Route.Handler<R1, E1>
+  ): Router<R | Exclude<R1, RouteContext>, E | E1>
+} = internal.patch
+
+/**
+ * @since 1.0.0
+ * @category routing
+ */
+export const put: {
+  <R1, E1>(path: string, handler: Route.Handler<R1, E1>): <R, E>(
+    self: Router<R, E>
+  ) => Router<R | Exclude<R1, RouteContext>, E1 | E>
+  <R, E, R1, E1>(
+    self: Router<R, E>,
+    path: string,
+    handler: Route.Handler<R1, E1>
+  ): Router<R | Exclude<R1, RouteContext>, E | E1>
+} = internal.put
+
+/**
+ * @since 1.0.0
+ * @category routing
+ */
+export const del: {
+  <R1, E1>(path: string, handler: Route.Handler<R1, E1>): <R, E>(
+    self: Router<R, E>
+  ) => Router<R | Exclude<R1, RouteContext>, E1 | E>
+  <R, E, R1, E1>(
+    self: Router<R, E>,
+    path: string,
+    handler: Route.Handler<R1, E1>
+  ): Router<R | Exclude<R1, RouteContext>, E | E1>
+} = internal.del
+
+/**
+ * @since 1.0.0
+ * @category routing
+ */
+export const head: {
+  <R1, E1>(path: string, handler: Route.Handler<R1, E1>): <R, E>(
+    self: Router<R, E>
+  ) => Router<R | Exclude<R1, RouteContext>, E1 | E>
+  <R, E, R1, E1>(
+    self: Router<R, E>,
+    path: string,
+    handler: Route.Handler<R1, E1>
+  ): Router<R | Exclude<R1, RouteContext>, E | E1>
+} = internal.head
+
+/**
+ * @since 1.0.0
+ * @category routing
+ */
+export const options: {
+  <R1, E1>(path: string, handler: Route.Handler<R1, E1>): <R, E>(
+    self: Router<R, E>
+  ) => Router<R | Exclude<R1, RouteContext>, E1 | E>
+  <R, E, R1, E1>(
+    self: Router<R, E>,
+    path: string,
+    handler: Route.Handler<R1, E1>
+  ): Router<R | Exclude<R1, RouteContext>, E | E1>
+} = internal.options

package/src/Http/Server.ts

@@ -0,0 +1,134 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Context from "@effect/data/Context"
+import type * as Effect from "@effect/io/Effect"
+import type * as Scope from "@effect/io/Scope"
+import type * as App from "@effect/platform/Http/App"
+import type * as Middleware from "@effect/platform/Http/Middleware"
+import type * as Error from "@effect/platform/Http/ServerError"
+import type * as ServerRequest from "@effect/platform/Http/ServerRequest"
+import * as internal from "@effect/platform/internal/http/server"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const TypeId: unique symbol = internal.TypeId
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Server {
+  readonly [TypeId]: TypeId
+  readonly serve: {
+    <R, E>(httpApp: App.Default<R, E>): Effect.Effect<
+      Exclude<R, ServerRequest.ServerRequest> | Scope.Scope,
+      Error.ServeError,
+      never
+    >
+    <R, E, App extends App.Default<any, any>>(
+      httpApp: App.Default<R, E>,
+      middleware: Middleware.Middleware.Applied<R, E, App>
+    ): Effect.Effect<
+      Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest> | Scope.Scope,
+      Error.ServeError,
+      never
+    >
+  }
+  readonly address: Address
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface ServeOptions {
+  readonly respond: boolean
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type Address = UnixAddress | TcpAddress
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface TcpAddress {
+  readonly _tag: "TcpAddress"
+  readonly hostname: string
+  readonly port: number
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface UnixAddress {
+  readonly _tag: "UnixAddress"
+  readonly path: string
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const Server: Context.Tag<Server, Server> = internal.serverTag
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make: (
+  options: {
+    readonly serve: (
+      httpApp: App.Default<never, unknown>,
+      middleware?: Middleware.Middleware
+    ) => Effect.Effect<Scope.Scope, Error.ServeError, never>
+    readonly address: Address
+  }
+) => Server = internal.make
+
+/**
+ * @since 1.0.0
+ * @category accessors
+ */
+export const serve: {
+  (): <R, E>(
+    httpApp: App.Default<R, E>
+  ) => Effect.Effect<
+    Server | Scope.Scope | Exclude<R, ServerRequest.ServerRequest>,
+    Error.ServeError,
+    never
+  >
+  <R, E, App extends App.Default<any, any>>(
+    middleware: Middleware.Middleware.Applied<R, E, App>
+  ): (
+    httpApp: App.Default<R, E>
+  ) => Effect.Effect<
+    Server | Scope.Scope | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
+    Error.ServeError,
+    never
+  >
+  <R, E>(
+    httpApp: App.Default<R, E>
+  ): Effect.Effect<Server | Scope.Scope | Exclude<R, ServerRequest.ServerRequest>, Error.ServeError, never>
+  <R, E, App extends App.Default<any, any>>(
+    httpApp: App.Default<R, E>,
+    middleware: Middleware.Middleware.Applied<R, E, App>
+  ): Effect.Effect<
+    Server | Scope.Scope | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
+    Error.ServeError,
+    never
+  >
+} = internal.serve

package/src/Http/ServerError.ts

@@ -0,0 +1,111 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Data from "@effect/data/Data"
+import type * as ServerRequest from "@effect/platform/Http/ServerRequest"
+import type * as ServerResponse from "@effect/platform/Http/ServerResponse"
+import * as internal from "@effect/platform/internal/http/serverError"
+
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+export const TypeId: unique symbol = internal.TypeId
+
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+export type HttpServerError = RequestError | ResponseError | RouteNotFound | ServeError
+
+/**
+ * @since 1.0.0
+ */
+export namespace HttpError {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface Proto extends Data.Case {
+    readonly [TypeId]: TypeId
+    readonly _tag: string
+  }
+
+  /**
+   * @since 1.0.0
+   */
+  export type ProvidedFields = TypeId | "_tag" | keyof Data.Case
+}
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+export interface RequestError extends HttpError.Proto {
+  readonly _tag: "RequestError"
+  readonly request: ServerRequest.ServerRequest
+  readonly reason: "Transport" | "Decode"
+  readonly error: unknown
+}
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+export const RequestError: (props: Omit<RequestError, HttpError.ProvidedFields>) => RequestError = internal.requestError
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+export interface RouteNotFound extends HttpError.Proto {
+  readonly _tag: "RouteNotFound"
+  readonly request: ServerRequest.ServerRequest
+}
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+export const RouteNotFound: (props: Omit<RouteNotFound, HttpError.ProvidedFields>) => RouteNotFound =
+  internal.routeNotFound
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+export interface ResponseError extends HttpError.Proto {
+  readonly _tag: "ResponseError"
+  readonly request: ServerRequest.ServerRequest
+  readonly response: ServerResponse.ServerResponse
+  readonly reason: "Decode"
+  readonly error: unknown
+}
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+export const ResponseError: (props: Omit<ResponseError, HttpError.ProvidedFields>) => ResponseError =
+  internal.responseError
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+export interface ServeError extends HttpError.Proto {
+  readonly _tag: "ServeError"
+  readonly error: unknown
+}
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+export const ServeError: (props: Omit<ServeError, HttpError.ProvidedFields>) => ServeError = internal.serveError