@effect/platform 0.11.0 → 0.11.2

package/src/Http/ClientResponse.ts

@@ -0,0 +1,42 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Error from "@effect/platform/Http/ClientError"
+import type * as ClientRequest from "@effect/platform/Http/ClientRequest"
+import type * as IncomingMessage from "@effect/platform/Http/IncomingMessage"
+import * as internal from "@effect/platform/internal/http/clientResponse"
+
+export {
+  /**
+   * @since 1.0.0
+   * @category schema
+   */
+  parseSchema
+} from "@effect/platform/Http/IncomingMessage"
+
+/**
+ * @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 ClientResponse extends IncomingMessage.IncomingMessage<Error.ResponseError> {
+  readonly [TypeId]: TypeId
+  readonly status: number
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const fromWeb: (request: ClientRequest.ClientRequest, source: Response) => ClientResponse = internal.fromWeb

package/src/Http/FormData.ts

@@ -0,0 +1,61 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Error from "@effect/platform/Http/ClientError"
+import type * as Stream from "@effect/stream/Stream"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const TypeId = Symbol.for("@effect/platform/Http/FormData")
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type Part = Field | File
+
+/**
+ * @since 1.0.0
+ */
+export namespace Part {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface Proto {
+    readonly [TypeId]: TypeId
+    readonly _tag: string
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Field extends Part.Proto {
+  readonly _tag: "FormDataField"
+  readonly key: string
+  readonly contentType: string
+  readonly value: string
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface File extends Part.Proto {
+  readonly _tag: "File"
+  readonly key: string
+  readonly name: string
+  readonly contentType: string
+  readonly content: Stream.Stream<never, Error.RequestError, Uint8Array>
+  readonly source?: unknown
+}

package/src/Http/Headers.ts

@@ -0,0 +1,69 @@
+/**
+ * @since 1.0.0
+ */
+import { dual } from "@effect/data/Function"
+import * as HashMap from "@effect/data/HashMap"
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Headers extends HashMap.HashMap<string, string> {}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type Input = Headers | Readonly<Record<string, string>> | Iterable<readonly [string, string]>
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const empty: Headers = HashMap.empty()
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const fromInput: (input?: Input) => Headers = (input) => {
+  if (input === undefined) {
+    return empty
+  } else if (HashMap.isHashMap(input)) {
+    return input
+  } else if (Symbol.iterator in input) {
+    return HashMap.fromIterable([...input].map(([k, v]) => [k.toLowerCase(), v])) as Headers
+  }
+  return HashMap.fromIterable(Object.entries(input).map(([k, v]) => [k.toLowerCase(), v]))
+}
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const set = dual<
+  (key: string, value: string) => (self: Headers) => Headers,
+  (self: Headers, key: string, value: string) => Headers
+>(3, (self, key, value) => HashMap.set(self, key.toLowerCase(), value))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setAll = dual<
+  (headers: Input) => (self: Headers) => Headers,
+  (self: Headers, headers: Input) => Headers
+>(2, (self, headers) =>
+  HashMap.union(
+    self,
+    fromInput(headers)
+  ))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const remove = dual<
+  (key: string) => (self: Headers) => Headers,
+  (self: Headers, key: string) => Headers
+>(2, (self, key) => HashMap.remove(self, key.toLowerCase()))

package/src/Http/IncomingMessage.ts

@@ -0,0 +1,45 @@
+/**
+ * @since 1.0.0
+ */
+import * as Effect from "@effect/io/Effect"
+import type * as Headers from "@effect/platform/Http/Headers"
+import type * as ParseResult from "@effect/schema/ParseResult"
+import * 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/IncomingMessage")
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface IncomingMessage<E> {
+  readonly [TypeId]: TypeId
+  readonly headers: Headers.Headers
+  readonly json: Effect.Effect<never, E, unknown>
+  readonly text: Effect.Effect<never, E, string>
+  readonly blob: Effect.Effect<never, E, Blob>
+  readonly formData: Effect.Effect<never, E, FormData>
+  // readonly formDataStream: Stream.Stream<never, Error.TransportError, FormData.Part>
+  readonly stream: Stream.Stream<never, E, Uint8Array>
+}
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const parseSchema = <I, A>(schema: Schema.Schema<I, A>) => {
+  const parse = Schema.parse(schema)
+  return <E>(self: IncomingMessage<E>): Effect.Effect<never, E | ParseResult.ParseError, A> =>
+    Effect.flatMap(self.json, parse)
+}

package/src/Http/Method.ts

@@ -0,0 +1,17 @@
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type Method =
+  | "GET"
+  | "POST"
+  | "PUT"
+  | "DELETE"
+  | "PATCH"
+  | "HEAD"
+  | "OPTIONS"
+
+/**
+ * @since 1.0.0
+ */
+export const hasBody = (method: Method): boolean => method !== "GET" && method !== "HEAD"

package/src/Http/UrlParams.ts

@@ -0,0 +1,106 @@
+/**
+ * @since 1.0.0
+ */
+import * as Chunk from "@effect/data/Chunk"
+import { dual } from "@effect/data/Function"
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface UrlParams extends Chunk.Chunk<[string, string]> {}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type Input = UrlParams | Readonly<Record<string, string>> | Iterable<readonly [string, string]> | URLSearchParams
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const fromInput = (input: Input): UrlParams => {
+  if (Chunk.isChunk(input)) {
+    return input
+  } else if (Symbol.iterator in input) {
+    return Chunk.fromIterable(input) as UrlParams
+  }
+  return Chunk.fromIterable(Object.entries(input))
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const empty: UrlParams = Chunk.empty()
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const set = dual<
+  (key: string, value: string) => (self: UrlParams) => UrlParams,
+  (self: UrlParams, key: string, value: string) => UrlParams
+>(3, (self, key, value) =>
+  Chunk.append(
+    Chunk.filter(self, ([k]) => k !== key),
+    [key, value]
+  ))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setAll = dual<
+  (input: Input) => (self: UrlParams) => UrlParams,
+  (self: UrlParams, input: Input) => UrlParams
+>(2, (self, input) => {
+  const toSet = fromInput(input)
+  const keys = Chunk.toReadonlyArray(toSet).map(([k]) => k)
+  return Chunk.appendAll(
+    Chunk.filter(self, ([k]) => keys.includes(k)),
+    toSet
+  )
+})
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const append = dual<
+  (key: string, value: string) => (self: UrlParams) => UrlParams,
+  (self: UrlParams, key: string, value: string) => UrlParams
+>(3, (self, key, value) =>
+  Chunk.append(
+    self,
+    [key, value]
+  ))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const appendAll = dual<
+  (input: Input) => (self: UrlParams) => UrlParams,
+  (self: UrlParams, input: Input) => UrlParams
+>(2, (self, input) =>
+  Chunk.appendAll(
+    self,
+    fromInput(input)
+  ))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const remove = dual<
+  (key: string) => (self: UrlParams) => UrlParams,
+  (self: UrlParams, key: string) => UrlParams
+>(2, (self, key) => Chunk.filter(self, ([k]) => k !== key))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const toString = (self: UrlParams): string => new URLSearchParams(Chunk.toReadonlyArray(self) as any).toString()

package/src/HttpClient.ts

@@ -0,0 +1,32 @@
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ */
+export * as body from "@effect/platform/Http/Body"
+/**
+ * @since 1.0.0
+ */
+export * as client from "@effect/platform/Http/Client"
+/**
+ * @since 1.0.0
+ */
+export * as request from "@effect/platform/Http/ClientRequest"
+/**
+ * @since 1.0.0
+ */
+export * as response from "@effect/platform/Http/ClientResponse"
+/**
+ * @since 1.0.0
+ */
+export * as error from "@effect/platform/Http/ClientError"
+/**
+ * @since 1.0.0
+ */
+export * as headers from "@effect/platform/Http/Headers"
+/**
+ * @since 1.0.0
+ */
+export * as urlParams from "@effect/platform/Http/UrlParams"

package/src/internal/http/body.ts

@@ -0,0 +1,113 @@
+import * as Effect from "@effect/io/Effect"
+import type * as Body from "@effect/platform/Http/Body"
+import * as Schema from "@effect/schema/Schema"
+import type * as Stream_ from "@effect/stream/Stream"
+
+/** @internal */
+export const TypeId: Body.TypeId = Symbol.for(
+  "@effect/platform/Http/Body"
+) as Body.TypeId
+
+class EmptyImpl implements Body.Empty {
+  readonly [TypeId]: Body.TypeId = TypeId
+  readonly _tag = "Empty"
+}
+
+/** @internal */
+export const empty: Body.Empty = new EmptyImpl()
+
+class RawImpl implements Body.Raw {
+  readonly [TypeId]: Body.TypeId = TypeId
+  readonly _tag = "Raw"
+  constructor(
+    readonly body: unknown,
+    readonly contentType?: string,
+    readonly contentLength?: number
+  ) {}
+}
+
+/** @internal */
+export const raw = (body: unknown, contentType?: string, contentLength?: number): Body.Raw =>
+  new RawImpl(body, contentType, contentLength)
+
+class BytesImpl implements Body.Bytes {
+  readonly [TypeId]: Body.TypeId = TypeId
+  readonly _tag = "Bytes"
+  constructor(
+    readonly body: Uint8Array,
+    readonly contentType?: string
+  ) {}
+  get contentLength(): number {
+    return this.body.length
+  }
+}
+
+/** @internal */
+export const bytes = (body: Uint8Array, contentType?: string): Body.Bytes => new BytesImpl(body, contentType)
+
+/** @internal */
+export const text = (body: string, contentType?: string): Body.Bytes =>
+  bytes(new TextEncoder().encode(body), contentType)
+
+class BytesEffectImpl implements Body.BytesEffect {
+  readonly [TypeId]: Body.TypeId = TypeId
+  readonly _tag = "BytesEffect"
+  constructor(
+    readonly body: Effect.Effect<never, unknown, Uint8Array>,
+    readonly contentType?: string
+  ) {}
+}
+
+/** @internal */
+export const bytesEffect = (
+  body: Effect.Effect<never, unknown, Uint8Array>,
+  contentType?: string
+): Body.BytesEffect => new BytesEffectImpl(body, contentType)
+
+/** @internal */
+export const json = (body: unknown): Body.BytesEffect =>
+  bytesEffect(
+    Effect.try(() => new TextEncoder().encode(JSON.stringify(body))),
+    "application/json"
+  )
+
+/** @internal */
+export const jsonSchema = <I, A>(schema: Schema.Schema<I, A>) => {
+  const encode = Schema.encode(schema)
+  return (body: A): Body.BytesEffect =>
+    bytesEffect(
+      Effect.flatMap(
+        encode(body),
+        (json) => Effect.try(() => new TextEncoder().encode(JSON.stringify(json)))
+      ),
+      "application/json"
+    )
+}
+
+class FormDataImpl implements Body.FormData {
+  readonly [TypeId]: Body.TypeId = TypeId
+  readonly _tag = "FormData"
+  constructor(
+    readonly formData: FormData
+  ) {}
+}
+
+/** @internal */
+export const formData = (body: FormData): Body.FormData => new FormDataImpl(body)
+
+class StreamImpl implements Body.Stream {
+  readonly [TypeId]: Body.TypeId = TypeId
+  readonly _tag = "Stream"
+  constructor(
+    readonly stream: Stream_.Stream<never, unknown, Uint8Array>,
+    readonly contentType?: string,
+    readonly contentLength?: number
+  ) {}
+}
+
+/** @internal */
+export const stream = (
+  body: Stream_.Stream<never, unknown, Uint8Array>,
+  contentType?: string,
+  contentLength?: number
+): Body.Stream => new StreamImpl(body, contentType, contentLength)