@effect/platform 0.10.4 → 0.11.1

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/console.ts

@@ -172,12 +172,12 @@ export const warn = (...args: ReadonlyArray<any>) => Effect.flatMap(Console, (_)
 
 /** @internal */
 export const withGroup = (options?: { label?: string; collapsed?: boolean }) =>
-  <R, E, A>(
-    self: Effect.Effect<R, E, A>
-  ) => Effect.flatMap(Console, (_) => _.withGroup(options)(self))
+<R, E, A>(
+  self: Effect.Effect<R, E, A>
+) => Effect.flatMap(Console, (_) => _.withGroup(options)(self))
 
 /** @internal */
 export const withTime = (label?: string) =>
-  <R, E, A>(
-    self: Effect.Effect<R, E, A>
-  ) => Effect.flatMap(Console, (_) => _.withTime(label)(self))
+<R, E, A>(
+  self: Effect.Effect<R, E, A>
+) => Effect.flatMap(Console, (_) => _.withTime(label)(self))

package/src/internal/effectify.ts

@@ -15,17 +15,17 @@ export const effectify: {
   ): Effectify<F, E | E2>
 } =
   (<A>(fn: Function, onError?: (e: any, args: any) => any, onSyncError?: (e: any, args: any) => any) =>
-    (...args: Array<any>) =>
-      Effect.async<never, Error, A>((resume) => {
-        try {
-          fn(...args, (err: Error | null, result: A) => {
-            if (err) {
-              resume(Effect.fail(onError ? onError(err, args) : err))
-            } else {
-              resume(Effect.succeed(result))
-            }
-          })
-        } catch (err) {
-          resume(onSyncError ? Effect.fail(onSyncError(err, args)) : Effect.die(err))
-        }
-      })) as any
+  (...args: Array<any>) =>
+    Effect.async<never, Error, A>((resume) => {
+      try {
+        fn(...args, (err: Error | null, result: A) => {
+          if (err) {
+            resume(Effect.fail(onError ? onError(err, args) : err))
+          } else {
+            resume(Effect.succeed(result))
+          }
+        })
+      } catch (err) {
+        resume(onSyncError ? Effect.fail(onSyncError(err, args)) : Effect.die(err))
+      }
+    })) as any

package/src/internal/error.ts

@@ -6,8 +6,8 @@ export const PlatformErrorTypeId: Error.PlatformErrorTypeId = Symbol.for(
   "@effect/platform/Error/PlatformErrorTypeId"
 ) as Error.PlatformErrorTypeId
 
-const make = <A extends Error.PlatformError>(tag: A["_tag"]) =>
-  (props: Omit<A, Error.PlatformError.ProvidedFields>): A =>
+const make =
+  <A extends Error.PlatformError>(tag: A["_tag"]) => (props: Omit<A, Error.PlatformError.ProvidedFields>): A =>
     Data.struct({
       [PlatformErrorTypeId]: PlatformErrorTypeId,
       _tag: tag,

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)