@effect/platform 0.11.5 → 0.12.0

package/src/Http/ClientRequest.ts

@@ -2,6 +2,9 @@
  * @since 1.0.0
  */
 import type { Pipeable } from "@effect/data/Pipeable"
+import type * as Effect from "@effect/io/Effect"
+import type * as PlatformError from "@effect/platform/Error"
+import type * as FileSystem from "@effect/platform/FileSystem"
 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"
@@ -36,6 +39,19 @@ export interface ClientRequest extends Pipeable {
   readonly body: Body.Body
 }
 
+/**
+ * @since 1.0.0
+ */
+export namespace ClientRequest {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface NonEffectBody extends ClientRequest {
+    readonly body: Body.NonEffect
+  }
+}
+
 /**
  * @since 1.0.0
  * @category models
@@ -253,10 +269,19 @@ export const setBody: {
  * @since 1.0.0
  * @category combinators
  */
-export const binaryBody: {
+export const uint8ArrayBody: {
   (body: Uint8Array, contentType?: string): (self: ClientRequest) => ClientRequest
   (self: ClientRequest, body: Uint8Array, contentType?: string): ClientRequest
-} = internal.binaryBody
+} = internal.uint8ArrayBody
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const effectBody: {
+  (body: Effect.Effect<never, unknown, Body.NonEffect>): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, body: Effect.Effect<never, unknown, Body.NonEffect>): ClientRequest
+} = internal.effectBody
 
 /**
  * @since 1.0.0
@@ -276,6 +301,15 @@ export const jsonBody: {
   (self: ClientRequest, body: unknown): ClientRequest
 } = internal.jsonBody
 
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const unsafeJsonBody: {
+  (body: unknown): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, body: unknown): ClientRequest
+} = internal.unsafeJsonBody
+
 /**
  * @since 1.0.0
  * @category combinators
@@ -318,3 +352,19 @@ export const streamBody: {
     options?: { readonly contentType?: string; readonly contentLength?: number }
   ): ClientRequest
 } = internal.streamBody
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const fileBody: {
+  (
+    path: string,
+    options?: FileSystem.StreamOptions & { readonly contentType?: string }
+  ): (self: ClientRequest) => Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, ClientRequest>
+  (
+    self: ClientRequest,
+    path: string,
+    options?: FileSystem.StreamOptions & { readonly contentType?: string }
+  ): Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, ClientRequest>
+} = internal.fileBody

package/src/Http/ClientResponse.ts

@@ -1,6 +1,7 @@
 /**
  * @since 1.0.0
  */
+import type * as Effect from "@effect/io/Effect"
 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"
@@ -11,7 +12,17 @@ export {
    * @since 1.0.0
    * @category schema
    */
-  parseSchema
+  schemaBodyJson,
+  /**
+   * @since 1.0.0
+   * @category schema
+   */
+  schemaBodyUrlParams,
+  /**
+   * @since 1.0.0
+   * @category schema
+   */
+  schemaHeaders
 } from "@effect/platform/Http/IncomingMessage"
 
 /**
@@ -33,6 +44,7 @@ export type TypeId = typeof TypeId
 export interface ClientResponse extends IncomingMessage.IncomingMessage<Error.ResponseError> {
   readonly [TypeId]: TypeId
   readonly status: number
+  readonly formData: Effect.Effect<never, Error.ResponseError, FormData>
 }
 
 /**

package/src/Http/FormData.ts

@@ -1,14 +1,22 @@
 /**
  * @since 1.0.0
  */
-import type * as Error from "@effect/platform/Http/ClientError"
+import type * as Chunk from "@effect/data/Chunk"
+import type * as Data from "@effect/data/Data"
+import type * as Option from "@effect/data/Option"
+import type * as Effect from "@effect/io/Effect"
+import type * as FiberRef from "@effect/io/FiberRef"
+import type * as FileSystem from "@effect/platform/FileSystem"
+import * as internal from "@effect/platform/internal/http/formData"
+import type * as ParseResult from "@effect/schema/ParseResult"
+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/FormData")
+export const TypeId: unique symbol = internal.TypeId
 
 /**
  * @since 1.0.0
@@ -41,7 +49,7 @@ export namespace Part {
  * @category models
  */
 export interface Field extends Part.Proto {
-  readonly _tag: "FormDataField"
+  readonly _tag: "Field"
   readonly key: string
   readonly contentType: string
   readonly value: string
@@ -56,6 +64,114 @@ export interface File extends Part.Proto {
   readonly key: string
   readonly name: string
   readonly contentType: string
-  readonly content: Stream.Stream<never, Error.RequestError, Uint8Array>
-  readonly source?: unknown
+  readonly content: Stream.Stream<never, FormDataError, Uint8Array>
 }
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const ErrorTypeId: unique symbol = internal.ErrorTypeId
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type ErrorTypeId = typeof ErrorTypeId
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export interface FormDataError extends Data.Case {
+  readonly [ErrorTypeId]: ErrorTypeId
+  readonly _tag: "FormDataError"
+  readonly reason: "FileTooLarge" | "FieldTooLarge" | "InternalError" | "Parse"
+  readonly error: unknown
+}
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export const FormDataError: (
+  reason: FormDataError["reason"],
+  error: unknown
+) => FormDataError = internal.FormDataError
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const maxFieldSize: FiberRef.FiberRef<FileSystem.Size> = internal.maxFieldSize
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const withMaxFieldSize: {
+  (size: FileSystem.SizeInput): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  <R, E, A>(effect: Effect.Effect<R, E, A>, size: FileSystem.SizeInput): Effect.Effect<R, E, A>
+} = internal.withMaxFieldSize
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const maxFileSize: FiberRef.FiberRef<Option.Option<FileSystem.Size>> = internal.maxFileSize
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const withMaxFileSize: {
+  (size: Option.Option<FileSystem.SizeInput>): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  <R, E, A>(effect: Effect.Effect<R, E, A>, size: Option.Option<FileSystem.SizeInput>): Effect.Effect<R, E, A>
+} = internal.withMaxFileSize
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const fieldMimeTypes: FiberRef.FiberRef<Chunk.Chunk<string>> = internal.fieldMimeTypes
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const withFieldMimeTypes: {
+  (mimeTypes: ReadonlyArray<string>): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  <R, E, A>(effect: Effect.Effect<R, E, A>, mimeTypes: ReadonlyArray<string>): Effect.Effect<R, E, A>
+} = internal.withFieldMimeTypes
+
+/**
+ * @since 1.0.0
+ * @category conversions
+ */
+export const toRecord: (formData: FormData) => Record<string, string | Array<globalThis.File>> = internal.toRecord
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const filesSchema: Schema.Schema<ReadonlyArray<globalThis.File>, ReadonlyArray<globalThis.File>> =
+  internal.filesSchema
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaJson: <I, A>(
+  schema: Schema.Schema<I, A>
+) => {
+  (field: string): (formData: FormData) => Effect.Effect<never, FormDataError | ParseResult.ParseError, A>
+  (formData: FormData, field: string): Effect.Effect<never, FormDataError | ParseResult.ParseError, A>
+} = internal.schemaJson
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaRecord: <I extends Readonly<Record<string, string | ReadonlyArray<globalThis.File>>>, A>(
+  schema: Schema.Schema<I, A>
+) => (formData: FormData) => Effect.Effect<never, ParseResult.ParseError, A> = internal.schemaRecord

package/src/Http/Headers.ts

@@ -3,6 +3,7 @@
  */
 import { dual } from "@effect/data/Function"
 import * as HashMap from "@effect/data/HashMap"
+import type * as Option from "@effect/data/Option"
 
 /**
  * @since 1.0.0
@@ -41,7 +42,34 @@ export const fromInput: (input?: Input) => Headers = (input) => {
  * @since 1.0.0
  * @category combinators
  */
-export const set = dual<
+export const has: {
+  (key: string): (self: Headers) => boolean
+  (self: Headers, key: string): boolean
+} = dual<
+  (key: string) => (self: Headers) => boolean,
+  (self: Headers, key: string) => boolean
+>(2, (self, key) => HashMap.has(self, key.toLowerCase()))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const get: {
+  (key: string): (self: Headers) => Option.Option<string>
+  (self: Headers, key: string): Option.Option<string>
+} = dual<
+  (key: string) => (self: Headers) => Option.Option<string>,
+  (self: Headers, key: string) => Option.Option<string>
+>(2, (self, key) => HashMap.get(self, key.toLowerCase()))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const set: {
+  (key: string, value: string): (self: Headers) => Headers
+  (self: Headers, key: string, value: string): Headers
+} = 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))
@@ -50,7 +78,10 @@ export const set = dual<
  * @since 1.0.0
  * @category combinators
  */
-export const setAll = dual<
+export const setAll: {
+  (headers: Input): (self: Headers) => Headers
+  (self: Headers, headers: Input): Headers
+} = dual<
   (headers: Input) => (self: Headers) => Headers,
   (self: Headers, headers: Input) => Headers
 >(2, (self, headers) =>
@@ -63,7 +94,10 @@ export const setAll = dual<
  * @since 1.0.0
  * @category combinators
  */
-export const remove = dual<
+export const remove: {
+  (key: string): (self: Headers) => Headers
+  (self: Headers, key: string): Headers
+} = dual<
   (key: string) => (self: Headers) => Headers,
   (self: Headers, key: string) => Headers
 >(2, (self, key) => HashMap.remove(self, key.toLowerCase()))

package/src/Http/IncomingMessage.ts

@@ -1,8 +1,14 @@
 /**
  * @since 1.0.0
  */
+import { dual } from "@effect/data/Function"
+import * as Global from "@effect/data/Global"
+import * as Option from "@effect/data/Option"
 import * as Effect from "@effect/io/Effect"
+import * as FiberRef from "@effect/io/FiberRef"
+import * as FileSystem from "@effect/platform/FileSystem"
 import type * as Headers from "@effect/platform/Http/Headers"
+import type * as UrlParams from "@effect/platform/Http/UrlParams"
 import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
 import type * as Stream from "@effect/stream/Stream"
@@ -28,9 +34,8 @@ export interface IncomingMessage<E> {
   readonly headers: Headers.Headers
   readonly json: Effect.Effect<never, E, unknown>
   readonly text: Effect.Effect<never, E, string>
+  readonly urlParams: Effect.Effect<never, E, UrlParams.UrlParams>
   readonly arrayBuffer: Effect.Effect<never, E, ArrayBuffer>
-  readonly formData: Effect.Effect<never, E, FormData>
-  // readonly formDataStream: Stream.Stream<never, Error.TransportError, FormData.Part>
   readonly stream: Stream.Stream<never, E, Uint8Array>
 }
 
@@ -38,8 +43,46 @@ export interface IncomingMessage<E> {
  * @since 1.0.0
  * @category schema
  */
-export const parseSchema = <I, A>(schema: Schema.Schema<I, A>) => {
+export const schemaBodyJson = <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)
 }
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaBodyUrlParams = <I extends Readonly<Record<string, string>>, 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.urlParams, (_) => parse(Object.fromEntries(_)))
+}
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaHeaders = <I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<I, A>) => {
+  const parse = Schema.parse(schema)
+  return <E>(self: IncomingMessage<E>): Effect.Effect<never, ParseResult.ParseError, A> =>
+    parse(Object.fromEntries(self.headers))
+}
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const maxBodySize: FiberRef.FiberRef<Option.Option<FileSystem.Size>> = Global.globalValue(
+  "@effect/platform/Http/ImcomingMessage/maxBodySize",
+  () => FiberRef.unsafeMake(Option.none<FileSystem.Size>())
+)
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const withMaxBodySize = dual<
+  (size: Option.Option<FileSystem.SizeInput>) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  <R, E, A>(effect: Effect.Effect<R, E, A>, size: Option.Option<FileSystem.SizeInput>) => Effect.Effect<R, E, A>
+>(2, (effect, size) => Effect.locally(effect, maxBodySize, Option.map(size, FileSystem.Size)))

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