@effect/platform 0.38.0 → 0.40.0

package/src/Http/{FormData.ts → Multipart.ts}

@@ -13,7 +13,7 @@ import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import type * as Multipasta from "multipasta"
 import type * as FileSystem from "../FileSystem.js"
-import * as internal from "../internal/http/formData.js"
+import * as internal from "../internal/http/multipart.js"
 import type * as Path from "../Path.js"
 
 /**
@@ -68,7 +68,7 @@ export interface File extends Part.Proto {
   readonly key: string
   readonly name: string
   readonly contentType: string
-  readonly content: Stream.Stream<never, FormDataError, Uint8Array>
+  readonly content: Stream.Stream<never, MultipartError, Uint8Array>
 }
 
 /**
@@ -87,7 +87,7 @@ export interface PersistedFile extends Part.Proto {
  * @since 1.0.0
  * @category models
  */
-export interface PersistedFormData {
+export interface Persisted {
   readonly [key: string]: ReadonlyArray<PersistedFile> | string
 }
 
@@ -107,9 +107,9 @@ export type ErrorTypeId = typeof ErrorTypeId
  * @since 1.0.0
  * @category errors
  */
-export interface FormDataError extends Data.Case {
+export interface MultipartError extends Data.Case {
   readonly [ErrorTypeId]: ErrorTypeId
-  readonly _tag: "FormDataError"
+  readonly _tag: "MultipartError"
   readonly reason: "FileTooLarge" | "FieldTooLarge" | "BodyTooLarge" | "TooManyParts" | "InternalError" | "Parse"
   readonly error: unknown
 }
@@ -118,10 +118,10 @@ export interface FormDataError extends Data.Case {
  * @since 1.0.0
  * @category errors
  */
-export const FormDataError: (
-  reason: FormDataError["reason"],
+export const MultipartError: (
+  reason: MultipartError["reason"],
   error: unknown
-) => FormDataError = internal.FormDataError
+) => MultipartError = internal.MultipartError
 
 /**
  * @since 1.0.0
@@ -203,17 +203,17 @@ export const filesSchema: Schema.Schema<ReadonlyArray<PersistedFile>, ReadonlyAr
 export const schemaJson: <I, A>(
   schema: Schema.Schema<I, A>
 ) => {
-  (field: string): (formData: PersistedFormData) => Effect.Effect<never, FormDataError | ParseResult.ParseError, A>
-  (formData: PersistedFormData, field: string): Effect.Effect<never, FormDataError | ParseResult.ParseError, A>
+  (field: string): (persisted: Persisted) => Effect.Effect<never, ParseResult.ParseError, A>
+  (persisted: Persisted, field: string): Effect.Effect<never, ParseResult.ParseError, A>
 } = internal.schemaJson
 
 /**
  * @since 1.0.0
  * @category schema
  */
-export const schemaPersisted: <I extends PersistedFormData, A>(
+export const schemaPersisted: <I extends Persisted, A>(
   schema: Schema.Schema<I, A>
-) => (formData: PersistedFormData) => Effect.Effect<never, ParseResult.ParseError, A> = internal.schemaPersisted
+) => (persisted: Persisted) => Effect.Effect<never, ParseResult.ParseError, A> = internal.schemaPersisted
 
 /**
  * @since 1.0.0
@@ -222,7 +222,7 @@ export const schemaPersisted: <I extends PersistedFormData, A>(
 export const makeChannel: <IE>(
   headers: Record<string, string>,
   bufferSize?: number
-) => Channel.Channel<never, IE, Chunk.Chunk<Uint8Array>, unknown, FormDataError | IE, Chunk.Chunk<Part>, unknown> =
+) => Channel.Channel<never, IE, Chunk.Chunk<Uint8Array>, unknown, MultipartError | IE, Chunk.Chunk<Part>, unknown> =
   internal.makeChannel
 
 /**
@@ -236,8 +236,7 @@ export const makeConfig: (headers: Record<string, string>) => Effect.Effect<neve
  * @since 1.0.0
  * @category constructors
  */
-export const formData: (
-  stream: Stream.Stream<never, FormDataError, Part>,
-  writeFile?: (path: string, file: File) => Effect.Effect<FileSystem.FileSystem, FormDataError, void>
-) => Effect.Effect<FileSystem.FileSystem | Path.Path | Scope.Scope, FormDataError, PersistedFormData> =
-  internal.formData
+export const toPersisted: (
+  stream: Stream.Stream<never, MultipartError, Part>,
+  writeFile?: (path: string, file: File) => Effect.Effect<FileSystem.FileSystem, MultipartError, void>
+) => Effect.Effect<FileSystem.FileSystem | Path.Path | Scope.Scope, MultipartError, Persisted> = internal.toPersisted

package/src/Http/Router.ts

@@ -111,6 +111,7 @@ export type RouteContextTypeId = typeof RouteContextTypeId
 export interface RouteContext {
   readonly [RouteContextTypeId]: RouteContextTypeId
   readonly params: Readonly<Record<string, string | undefined>>
+  readonly route: Route<unknown, unknown>
   readonly searchParams: Readonly<Record<string, string>>
 }
 

package/src/Http/ServerRequest.ts

@@ -10,10 +10,10 @@ import type * as Stream from "effect/Stream"
 import type * as FileSystem from "../FileSystem.js"
 import * as internal from "../internal/http/serverRequest.js"
 import type * as Path from "../Path.js"
-import type * as FormData from "./FormData.js"
 import type * as Headers from "./Headers.js"
 import type * as IncomingMessage from "./IncomingMessage.js"
 import type { Method } from "./Method.js"
+import type * as Multipart from "./Multipart.js"
 import type * as Error from "./ServerError.js"
 
 export {
@@ -47,12 +47,12 @@ export interface ServerRequest extends IncomingMessage.IncomingMessage<Error.Req
   readonly originalUrl: string
   readonly method: Method
 
-  readonly formData: Effect.Effect<
+  readonly multipart: Effect.Effect<
     Scope.Scope | FileSystem.FileSystem | Path.Path,
-    FormData.FormDataError,
-    FormData.PersistedFormData
+    Multipart.MultipartError,
+    Multipart.Persisted
   >
-  readonly formDataStream: Stream.Stream<never, FormData.FormDataError, FormData.Part>
+  readonly multipartStream: Stream.Stream<never, Multipart.MultipartError, Multipart.Part>
 
   readonly modify: (
     options: {
@@ -73,11 +73,11 @@ export const ServerRequest: Context.Tag<ServerRequest, ServerRequest> = internal
  * @since 1.0.0
  * @category accessors
  */
-export const persistedFormData: Effect.Effect<
+export const persistedMultipart: Effect.Effect<
   Scope.Scope | FileSystem.FileSystem | Path.Path | ServerRequest,
-  FormData.FormDataError,
+  Multipart.MultipartError,
   unknown
-> = internal.persistedFormData
+> = internal.multipartPersisted
 
 /**
  * @since 1.0.0
@@ -95,6 +95,18 @@ export const schemaBodyJson: <I, A>(
   schema: Schema.Schema<I, A>
 ) => Effect.Effect<ServerRequest, Error.RequestError | ParseResult.ParseError, A> = internal.schemaBodyJson
 
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaBodyForm: <I extends Multipart.Persisted, A>(
+  schema: Schema.Schema<I, A>
+) => Effect.Effect<
+  ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path,
+  Multipart.MultipartError | Error.RequestError | ParseResult.ParseError,
+  A
+> = internal.schemaBodyForm
+
 /**
  * @since 1.0.0
  * @category schema
@@ -107,27 +119,27 @@ export const schemaBodyUrlParams: <I extends Readonly<Record<string, string>>, A
  * @since 1.0.0
  * @category schema
  */
-export const schemaFormData: <I extends FormData.PersistedFormData, A>(
+export const schemaBodyMultipart: <I extends Multipart.Persisted, A>(
   schema: Schema.Schema<I, A>
 ) => Effect.Effect<
   ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path,
-  FormData.FormDataError | ParseResult.ParseError,
+  Multipart.MultipartError | ParseResult.ParseError,
   A
-> = internal.schemaFormData
+> = internal.schemaBodyMultipart
 
 /**
  * @since 1.0.0
  * @category schema
  */
-export const schemaFormDataJson: <I, A>(
+export const schemaBodyFormJson: <I, A>(
   schema: Schema.Schema<I, A>
 ) => (
   field: string
 ) => Effect.Effect<
   ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path,
-  Error.RequestError | FormData.FormDataError | ParseResult.ParseError,
+  Error.RequestError | ParseResult.ParseError,
   A
-> = internal.schemaFormDataJson
+> = internal.schemaBodyFormJson
 
 /**
  * @since 1.0.0

package/src/Http/ServerResponse.ts

@@ -41,11 +41,11 @@ export interface ServerResponse extends Effect.Effect<never, never, ServerRespon
  * @category models
  */
 export interface Options {
-  readonly status?: number
-  readonly statusText?: string
-  readonly headers?: Headers.Headers
-  readonly contentType?: string
-  readonly contentLength?: number
+  readonly status?: number | undefined
+  readonly statusText?: string | undefined
+  readonly headers?: Headers.Headers | undefined
+  readonly contentType?: string | undefined
+  readonly contentLength?: number | undefined
 }
 
 /**

package/src/Http/UrlParams.ts

@@ -1,8 +1,11 @@
 /**
  * @since 1.0.0
  */
+import type * as ParseResult from "@effect/schema/ParseResult"
+import * as Schema from "@effect/schema/Schema"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
+import * as Option from "effect/Option"
 import * as ReadonlyArray from "effect/ReadonlyArray"
 
 /**
@@ -34,6 +37,62 @@ export const fromInput = (input: Input): UrlParams => {
  */
 export const empty: UrlParams = []
 
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const getAll: {
+  (key: string): (self: UrlParams) => ReadonlyArray<string>
+  (self: UrlParams, key: string): ReadonlyArray<string>
+} = dual<
+  (key: string) => (self: UrlParams) => ReadonlyArray<string>,
+  (self: UrlParams, key: string) => ReadonlyArray<string>
+>(2, (self, key) =>
+  ReadonlyArray.reduce(self, [] as Array<string>, (acc, [k, value]) => {
+    if (k === key) {
+      acc.push(value)
+    }
+    return acc
+  }))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const getFirst: {
+  (key: string): (self: UrlParams) => Option.Option<string>
+  (self: UrlParams, key: string): Option.Option<string>
+} = dual<
+  (key: string) => (self: UrlParams) => Option.Option<string>,
+  (self: UrlParams, key: string) => Option.Option<string>
+>(2, (self, key) =>
+  Option.map(
+    ReadonlyArray.findFirst(
+      self,
+      ([k]) => k === key
+    ),
+    ([, value]) => value
+  ))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const getLast: {
+  (key: string): (self: UrlParams) => Option.Option<string>
+  (self: UrlParams, key: string): Option.Option<string>
+} = dual<
+  (key: string) => (self: UrlParams) => Option.Option<string>,
+  (self: UrlParams, key: string) => Option.Option<string>
+>(2, (self, key) =>
+  Option.map(
+    ReadonlyArray.findLast(
+      self,
+      ([k]) => k === key
+    ),
+    ([, value]) => value
+  ))
+
 /**
  * @since 1.0.0
  * @category combinators
@@ -143,3 +202,23 @@ const baseUrl = (): string | undefined => {
   }
   return undefined
 }
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaJson = <I, A>(schema: Schema.Schema<I, A>): {
+  (
+    field: string
+  ): (self: UrlParams) => Effect.Effect<never, ParseResult.ParseError, A>
+  (
+    self: UrlParams,
+    field: string
+  ): Effect.Effect<never, ParseResult.ParseError, A>
+} => {
+  const parse = Schema.parse(Schema.parseJson(schema))
+  return dual<
+    (field: string) => (self: UrlParams) => Effect.Effect<never, ParseResult.ParseError, A>,
+    (self: UrlParams, field: string) => Effect.Effect<never, ParseResult.ParseError, A>
+  >(2, (self, field) => parse(Option.getOrElse(getLast(self, field), () => "")))
+}

package/src/HttpServer.ts

@@ -3,9 +3,9 @@
  */
 import * as app from "./Http/App.js"
 import * as body from "./Http/Body.js"
-import * as formData from "./Http/FormData.js"
 import * as headers from "./Http/Headers.js"
 import * as middleware from "./Http/Middleware.js"
+import * as multipart from "./Http/Multipart.js"
 import * as router from "./Http/Router.js"
 import * as error from "./Http/ServerError.js"
 import * as request from "./Http/ServerRequest.js"
@@ -34,13 +34,6 @@ export {
    * - Module: `@effect/platform/Http/ServerError`
    */
   error,
-  /**
-   * @since 1.0.0
-   *
-   * - Docs: [Http/FormData](https://effect-ts.github.io/platform/platform/Http/FormData.html)
-   * - Module: `@effect/platform/Http/FormData`
-   */
-  formData,
   /**
    * @since 1.0.0
    *
@@ -55,6 +48,13 @@ export {
    * - Module: `@effect/platform/Http/Middleware`
    */
   middleware,
+  /**
+   * @since 1.0.0
+   *
+   * - Docs: [Http/Multipart](https://effect-ts.github.io/platform/platform/Http/Multipart.html)
+   * - Module: `@effect/platform/Http/Multipart`
+   */
+  multipart,
   /**
    * @since 1.0.0
    *

package/src/internal/http/body.ts

@@ -6,6 +6,7 @@ import * as Stream_ from "effect/Stream"
 import type * as PlatformError from "../../Error.js"
 import * as FileSystem from "../../FileSystem.js"
 import type * as Body from "../../Http/Body.js"
+import * as UrlParams from "../../Http/UrlParams.js"
 
 /** @internal */
 export const TypeId: Body.TypeId = Symbol.for(
@@ -68,13 +69,14 @@ class Uint8ArrayImpl implements Body.Uint8Array {
 export const uint8Array = (body: Uint8Array, contentType?: string): Body.Uint8Array =>
   new Uint8ArrayImpl(body, contentType ?? "application/octet-stream")
 
+const encoder = new TextEncoder()
+
 /** @internal */
 export const text = (body: string, contentType?: string): Body.Uint8Array =>
-  uint8Array(new TextEncoder().encode(body), contentType ?? "text/plain")
+  uint8Array(encoder.encode(body), contentType ?? "text/plain")
 
 /** @internal */
-export const unsafeJson = (body: unknown): Body.Uint8Array =>
-  uint8Array(new TextEncoder().encode(JSON.stringify(body)), "application/json")
+export const unsafeJson = (body: unknown): Body.Uint8Array => text(JSON.stringify(body), "application/json")
 
 /** @internal */
 export const json = (body: unknown): Effect.Effect<never, Body.BodyError, Body.Uint8Array> =>
@@ -83,6 +85,10 @@ export const json = (body: unknown): Effect.Effect<never, Body.BodyError, Body.U
     catch: (error) => BodyError({ _tag: "JsonError", error })
   })
 
+/** @internal */
+export const urlParams = (urlParams: UrlParams.UrlParams): Body.Uint8Array =>
+  text(UrlParams.toString(urlParams), "application/x-www-form-urlencoded")
+
 /** @internal */
 export const jsonSchema = <I, A>(schema: Schema.Schema<I, A>) => {
   const encode = Schema.encode(schema)

package/src/internal/http/client.ts

@@ -4,7 +4,6 @@ import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
 import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
 import { pipeArguments } from "effect/Pipeable"
 import type * as Predicate from "effect/Predicate"
 import type * as Schedule from "effect/Schedule"
@@ -53,20 +52,17 @@ export const make = <R, E, A, R2, E2>(
 }
 
 const addB3Headers = (req: ClientRequest.ClientRequest) =>
-  Effect.map(
-    Effect.currentSpan,
-    Option.match({
-      onNone: () => req,
-      onSome: (span) =>
-        internalRequest.setHeader(
-          req,
-          "b3",
-          `${span.traceId}-${span.spanId}-${span.sampled ? "1" : "0"}${
-            span.parent._tag === "Some" ? `-${span.parent.value.spanId}` : ""
-          }`
-        )
-    })
-  )
+  Effect.match(Effect.currentSpan, {
+    onFailure: () => req,
+    onSuccess: (span) =>
+      internalRequest.setHeader(
+        req,
+        "b3",
+        `${span.traceId}-${span.spanId}-${span.sampled ? "1" : "0"}${
+          span.parent._tag === "Some" ? `-${span.parent.value.spanId}` : ""
+        }`
+      )
+  })
 
 /** @internal */
 export const makeDefault = (
@@ -85,7 +81,7 @@ export const Fetch = Context.Tag<Client.Fetch, typeof globalThis.fetch>(
 )
 
 /** @internal */
-export const fetch = (options: RequestInit = {}): Client.Client.Default =>
+export const fetch = (options?: RequestInit): Client.Client.Default =>
   makeDefault((request) =>
     Effect.flatMap(
       UrlParams.makeUrl(request.url, request.urlParams, (_) =>
@@ -142,7 +138,7 @@ const convertBody = (body: Body.Body): BodyInit | undefined => {
 }
 
 /** @internal */
-export const fetchOk = (options: RequestInit = {}): Client.Client.Default => filterStatusOk(fetch(options))
+export const fetchOk = (options?: RequestInit): Client.Client.Default => filterStatusOk(fetch(options))
 
 /** @internal */
 export const layer = Layer.succeed(tag, fetch())

package/src/internal/http/clientRequest.ts

@@ -55,7 +55,7 @@ export const make: {
   modify(empty, {
     method,
     url,
-    ...(options ?? {})
+    ...(options ?? undefined)
   })
 
 /** @internal */