@effect/platform 0.11.0 → 0.11.2

package/src/Http/Client.ts

@@ -0,0 +1,280 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Context from "@effect/data/Context"
+import type * as Predicate from "@effect/data/Predicate"
+import type * as Effect from "@effect/io/Effect"
+import type * as Layer from "@effect/io/Layer"
+import type * as Schedule from "@effect/io/Schedule"
+import type * as Error from "@effect/platform/Http/ClientError"
+import type * as ClientRequest from "@effect/platform/Http/ClientRequest"
+import type * as ClientResponse from "@effect/platform/Http/ClientResponse"
+import * as internal from "@effect/platform/internal/http/client"
+import type * as ParseResult from "@effect/schema/ParseResult"
+import type * as Schema from "@effect/schema/Schema"
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Client<R, E, A> {
+  (request: ClientRequest.ClientRequest): Effect.Effect<R, E, A>
+}
+
+/**
+ * @since 1.0.0
+ */
+export namespace Client {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type WithResponse<R, E> = Client<R, E, ClientResponse.ClientResponse>
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Default = WithResponse<never, Error.HttpClientError>
+}
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export const Client: Context.Tag<Client.Default, Client.Default> = internal.tag
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const fetchLayer: Layer.Layer<never, never, Client.Default> = internal.fetchLayer
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const fetch: (options?: RequestInit) => Client.Default = internal.fetch
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const fetchOk: (options?: RequestInit) => Client.Default = internal.fetchOk
+
+/**
+ * @since 1.0.0
+ * @category error handling
+ */
+export const catchAll: {
+  <E, R2, E2, A2>(f: (e: E) => Effect.Effect<R2, E2, A2>): <R, A>(self: Client<R, E, A>) => Client<R2 | R, E2, A2 | A>
+  <R, E, A, R2, E2, A2>(self: Client<R, E, A>, f: (e: E) => Effect.Effect<R2, E2, A2>): Client<R | R2, E2, A | A2>
+} = internal.catchAll
+
+/**
+ * @since 1.0.0
+ * @category error handling
+ */
+export const catchTag: {
+  <E extends { _tag: string }, K extends E["_tag"] & string, R1, E1, A1>(
+    tag: K,
+    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<R1, E1, A1>
+  ): <R, A>(self: Client<R, E, A>) => Client<R1 | R, E1 | Exclude<E, { _tag: K }>, A1 | A>
+  <R, E extends { _tag: string }, A, K extends E["_tag"] & string, E1, R1, A1>(
+    self: Client<R, E, A>,
+    tag: K,
+    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<R1, E1, A1>
+  ): Client<R | R1, E1 | Exclude<E, { _tag: K }>, A | A1>
+} = internal.catchTag
+
+/**
+ * @since 1.0.0
+ * @category error handling
+ */
+export const catchTags: {
+  <
+    E extends { _tag: string },
+    Cases extends { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect.Effect<any, any, any>) | undefined }
+  >(
+    cases: Cases
+  ): <R, A>(
+    self: Client<R, E, A>
+  ) => Client<
+    | R
+    | {
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<infer R, any, any> ? R : never
+    }[keyof Cases],
+    | Exclude<E, { _tag: keyof Cases }>
+    | {
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, infer E, any> ? E : never
+    }[keyof Cases],
+    | A
+    | {
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer A> ? A : never
+    }[keyof Cases]
+  >
+  <
+    R,
+    E extends { _tag: string },
+    A,
+    Cases extends { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect.Effect<any, any, any>) | undefined }
+  >(
+    self: Client<R, E, A>,
+    cases: Cases
+  ): Client<
+    | R
+    | {
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<infer R, any, any> ? R : never
+    }[keyof Cases],
+    | Exclude<E, { _tag: keyof Cases }>
+    | {
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, infer E, any> ? E : never
+    }[keyof Cases],
+    | A
+    | {
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer A> ? A : never
+    }[keyof Cases]
+  >
+} = internal.catchTags
+
+/**
+ * @since 1.0.0
+ * @category filters
+ */
+export const filterOrElse: {
+  <A, R2, E2, B>(
+    f: Predicate.Predicate<A>,
+    orElse: (a: A) => Effect.Effect<R2, E2, B>
+  ): <R, E>(self: Client<R, E, A>) => Client<R2 | R, E2 | E, A | B>
+  <R, E, A, R2, E2, B>(
+    self: Client<R, E, A>,
+    f: Predicate.Predicate<A>,
+    orElse: (a: A) => Effect.Effect<R2, E2, B>
+  ): Client<R | R2, E | E2, A | B>
+} = internal.filterOrElse
+
+/**
+ * @since 1.0.0
+ * @category filters
+ */
+export const filterOrFail: {
+  <A, E2>(f: Predicate.Predicate<A>, orFailWith: (a: A) => E2): <R, E>(self: Client<R, E, A>) => Client<R, E2 | E, A>
+  <R, E, A, E2>(self: Client<R, E, A>, f: Predicate.Predicate<A>, orFailWith: (a: A) => E2): Client<R, E | E2, A>
+} = internal.filterOrFail
+
+/**
+ * @since 1.0.0
+ * @category filters
+ */
+export const filterStatus: {
+  (
+    f: (status: number) => boolean
+  ): <R, E>(self: Client.WithResponse<R, E>) => Client.WithResponse<R, E | Error.ResponseError>
+  <R, E>(
+    self: Client.WithResponse<R, E>,
+    f: (status: number) => boolean
+  ): Client.WithResponse<R, Error.ResponseError | E>
+} = internal.filterStatus
+
+/**
+ * @since 1.0.0
+ * @category filters
+ */
+export const filterStatusOk: <R, E>(
+  self: Client.WithResponse<R, E>
+) => Client.WithResponse<R, Error.ResponseError | E> = internal.filterStatusOk
+
+/**
+ * @since 1.0.0
+ * @category mapping & sequencing
+ */
+export const map: {
+  <A, B>(f: (a: A) => B): <R, E>(self: Client<R, E, A>) => Client<R, E, B>
+  <R, E, A, B>(self: Client<R, E, A>, f: (a: A) => B): Client<R, E, B>
+} = internal.map
+
+/**
+ * @since 1.0.0
+ * @category mapping & sequencing
+ */
+export const mapEffect: {
+  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E>(self: Client<R, E, A>) => Client<R2 | R, E2 | E, B>
+  <R, E, A, R2, E2, B>(self: Client<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Client<R | R2, E | E2, B>
+} = internal.mapEffect
+
+/**
+ * @since 1.0.0
+ * @category mapping & sequencing
+ */
+export const mapRequest: {
+  (
+    f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
+  ): <R, E, A>(self: Client<R, E, A>) => Client<R, E, A>
+  <R, E, A>(self: Client<R, E, A>, f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest): Client<R, E, A>
+} = internal.mapRequest
+
+/**
+ * @since 1.0.0
+ * @category mapping & sequencing
+ */
+export const mapRequestEffect: {
+  <R2, E2>(
+    f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
+  ): <R, E, A>(self: Client<R, E, A>) => Client<R2 | R, E2 | E, A>
+  <R, E, A, R2, E2>(
+    self: Client<R, E, A>,
+    f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
+  ): Client<R | R2, E | E2, A>
+} = internal.mapRequestEffect
+
+/**
+ * @since 1.0.0
+ * @category error handling
+ */
+export const retry: {
+  <R1, E extends E0, E0, B>(policy: Schedule.Schedule<R1, E0, B>): <R, A>(self: Client<R, E, A>) => Client<R1 | R, E, A>
+  <R, E extends E0, E0, A, R1, B>(self: Client<R, E, A>, policy: Schedule.Schedule<R1, E0, B>): Client<R | R1, E, A>
+} = internal.retry
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaFunction: {
+  <SI, SA>(
+    schema: Schema.Schema<SI, SA>
+  ): <R, E, A>(
+    self: Client<R, E, A>
+  ) => (
+    request: ClientRequest.ClientRequest
+  ) => (a: SA) => Effect.Effect<R, Error.RequestError | E | ParseResult.ParseError, A>
+  <R, E, A, SI, SA>(
+    self: Client<R, E, A>,
+    schema: Schema.Schema<SI, SA>
+  ): (
+    request: ClientRequest.ClientRequest
+  ) => (a: SA) => Effect.Effect<R, Error.RequestError | ParseResult.ParseError | E, A>
+} = internal.schemaFunction
+
+/**
+ * @since 1.0.0
+ * @category mapping & sequencing
+ */
+export const tap: {
+  <A, R2, E2, _>(f: (a: A) => Effect.Effect<R2, E2, _>): <R, E>(self: Client<R, E, A>) => Client<R2 | R, E2 | E, A>
+  <R, E, A, R2, E2, _>(self: Client<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, _>): Client<R | R2, E | E2, A>
+} = internal.tap
+
+/**
+ * @since 1.0.0
+ * @category mapping & sequencing
+ */
+export const tapRequest: {
+  <R2, E2, _>(
+    f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, _>
+  ): <R, E, A>(self: Client<R, E, A>) => Client<R2 | R, E2 | E, A>
+  <R, E, A, R2, E2, _>(
+    self: Client<R, E, A>,
+    f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, _>
+  ): Client<R | R2, E | E2, A>
+} = internal.tapRequest

package/src/Http/ClientError.ts

@@ -0,0 +1,80 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Data from "@effect/data/Data"
+import type * as ClientRequest from "@effect/platform/Http/ClientRequest"
+import type * as ClientResponse from "@effect/platform/Http/ClientResponse"
+import * as internal from "@effect/platform/internal/http/clientError"
+
+/**
+ * @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 HttpClientError = RequestError | ResponseError
+
+/**
+ * @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: ClientRequest.ClientRequest
+  readonly reason: "Transport" | "Encode"
+  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 ResponseError extends HttpError.Proto {
+  readonly _tag: "ResponseError"
+  readonly request: ClientRequest.ClientRequest
+  readonly response: ClientResponse.ClientResponse
+  readonly reason: "StatusCode" | "Decode" | "EmptyBody"
+  readonly error: unknown
+}
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+export const ResponseError: (props: Omit<ResponseError, HttpError.ProvidedFields>) => ResponseError =
+  internal.responseError

package/src/Http/ClientRequest.ts

@@ -0,0 +1,320 @@
+/**
+ * @since 1.0.0
+ */
+import type { Pipeable } from "@effect/data/Pipeable"
+import type * as Body from "@effect/platform/Http/Body"
+import type * as Error from "@effect/platform/Http/ClientError"
+import type * as Headers from "@effect/platform/Http/Headers"
+import type { Method } from "@effect/platform/Http/Method"
+import type * as UrlParams from "@effect/platform/Http/UrlParams"
+import * as internal from "@effect/platform/internal/http/clientRequest"
+import type * as Schema from "@effect/schema/Schema"
+import type * as Stream from "@effect/stream/Stream"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const TypeId = Symbol.for("@effect/platform/Http/ClientRequest")
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface ClientRequest extends Pipeable {
+  readonly [TypeId]: TypeId
+  readonly method: Method
+  readonly url: string
+  readonly urlParams: UrlParams.UrlParams
+  readonly headers: Headers.Headers
+  readonly body: Body.Body
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Options {
+  readonly method?: Method
+  readonly url?: string
+  readonly urlParams?: UrlParams.Input
+  readonly headers?: Headers.Input
+  readonly body?: Body.Body
+  readonly accept?: string
+  readonly acceptJson?: boolean
+}
+
+/**
+ * @since 1.0.0
+ */
+export namespace Options {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface NoBody extends Omit<Options, "method" | "url" | "body"> {}
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface NoUrl extends Omit<Options, "method" | "url"> {}
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make: {
+  (method: "GET" | "HEAD"): (url: string, options?: Options.NoBody) => ClientRequest
+  (
+    method: Exclude<Method, "GET" | "HEAD">
+  ): (url: string, options?: Options.NoUrl) => ClientRequest
+} = internal.make
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const get: (url: string, options?: Options.NoBody) => ClientRequest = internal.get
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const post: (url: string, options?: Options.NoUrl) => ClientRequest = internal.post
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const patch: (url: string, options?: Options.NoUrl) => ClientRequest = internal.patch
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const put: (url: string, options?: Options.NoUrl) => ClientRequest = internal.put
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const del: (url: string, options?: Options.NoUrl) => ClientRequest = internal.del
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const head: (url: string, options?: Options.NoBody) => ClientRequest = internal.head
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const options: (url: string, options?: Options.NoUrl) => ClientRequest = internal.options
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const modify: {
+  (options: Options): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, options: Options): ClientRequest
+} = internal.modify
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setMethod: {
+  (method: Method): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, method: Method): ClientRequest
+} = internal.setMethod
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setHeader: {
+  (key: string, value: string): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, key: string, value: string): ClientRequest
+} = internal.setHeader
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setHeaders: {
+  (input: Headers.Input): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, input: Headers.Input): ClientRequest
+} = internal.setHeaders
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const basicAuth: {
+  (username: string, password: string): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, username: string, password: string): ClientRequest
+} = internal.basicAuth
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const accept: {
+  (mediaType: string): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, mediaType: string): ClientRequest
+} = internal.accept
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const acceptJson: (self: ClientRequest) => ClientRequest = internal.acceptJson
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setUrl: {
+  (url: string): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, url: string): ClientRequest
+} = internal.setUrl
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const prependUrl: {
+  (path: string): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, path: string): ClientRequest
+} = internal.prependUrl
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const appendUrl: {
+  (path: string): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, path: string): ClientRequest
+} = internal.appendUrl
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const updateUrl: {
+  (f: (url: string) => string): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, f: (url: string) => string): ClientRequest
+} = internal.updateUrl
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setUrlParam = internal.setUrlParam
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setUrlParams = internal.setUrlParams
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const appendUrlParam = internal.appendUrlParam
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const appendUrlParams = internal.appendUrlParams
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setBody: {
+  (body: Body.Body): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, body: Body.Body): ClientRequest
+} = internal.setBody
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const binaryBody: {
+  (body: Uint8Array, contentType?: string): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, body: Uint8Array, contentType?: string): ClientRequest
+} = internal.binaryBody
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const textBody: {
+  (body: string, contentType?: string): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, body: string, contentType?: string): ClientRequest
+} = internal.textBody
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const jsonBody: {
+  (body: unknown): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, body: string): ClientRequest
+} = internal.jsonBody
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const schemaBody: <I, A>(schema: Schema.Schema<I, A>) => {
+  (body: A): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, body: A): ClientRequest
+} = internal.schemaBody
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const urlParamsBody: {
+  (input: UrlParams.Input): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, input: UrlParams.Input): ClientRequest
+} = internal.urlParamsBody
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const formDataBody: {
+  (body: FormData): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, body: FormData): ClientRequest
+} = internal.formDataBody
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const streamBody: {
+  (
+    body: Stream.Stream<never, Error.RequestError, Uint8Array>,
+    options?: { readonly contentType?: string; readonly contentLength?: number }
+  ): (self: ClientRequest) => ClientRequest
+  (
+    self: ClientRequest,
+    body: Stream.Stream<never, Error.RequestError, Uint8Array>,
+    options?: { readonly contentType?: string; readonly contentLength?: number }
+  ): ClientRequest
+} = internal.streamBody