@effect/platform 0.48.15 → 0.48.17

package/src/Http/Headers.ts

@@ -50,18 +50,21 @@ export const schemaFromSelf: Schema.Schema<Headers> = Schema.declare(isHeaders,
  * @since 1.0.0
  * @category schemas
  */
-export const schema: Schema.Schema<Headers, ReadonlyRecord.ReadonlyRecord<string, string>> = Schema.transform(
-  Schema.record(Schema.string, Schema.string),
-  schemaFromSelf,
-  (record) => fromInput(record),
-  identity
-)
+export const schema: Schema.Schema<Headers, ReadonlyRecord.ReadonlyRecord<string, string | ReadonlyArray<string>>> =
+  Schema.transform(
+    Schema.record(Schema.string, Schema.union(Schema.string, Schema.array(Schema.string))),
+    schemaFromSelf,
+    (record) => fromInput(record),
+    identity
+  )
 
 /**
  * @since 1.0.0
  * @category models
  */
-export type Input = ReadonlyRecord.ReadonlyRecord<string, string> | Iterable<readonly [string, string]>
+export type Input =
+  | ReadonlyRecord.ReadonlyRecord<string, string | ReadonlyArray<string>>
+  | Iterable<readonly [string, string]>
 
 /**
  * @since 1.0.0
@@ -83,7 +86,12 @@ export const fromInput: (input?: Input) => Headers = (input) => {
     )) as Headers
   }
   return ReadonlyRecord.fromEntries(
-    Object.entries(input).map(([k, v]) => [k.toLowerCase(), v])
+    Object.entries(input).map(([k, v]) =>
+      [
+        k.toLowerCase(),
+        Array.isArray(v) ? v.join(", ") : v
+      ] as const
+    )
   ) as Headers
 }
 

package/src/Http/IncomingMessage.ts

@@ -1,6 +1,7 @@
 /**
  * @since 1.0.0
  */
+import type { ParseOptions } from "@effect/schema/AST"
 import * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
 import * as Effect from "effect/Effect"
@@ -47,8 +48,8 @@ export interface IncomingMessage<E> extends Inspectable {
  * @since 1.0.0
  * @category schema
  */
-export const schemaBodyJson = <A, I, R>(schema: Schema.Schema<A, I, R>) => {
-  const parse = Schema.decodeUnknown(schema)
+export const schemaBodyJson = <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
+  const parse = Schema.decodeUnknown(schema, options)
   return <E>(self: IncomingMessage<E>): Effect.Effect<A, E | ParseResult.ParseError, R> =>
     Effect.flatMap(self.json, parse)
 }
@@ -57,8 +58,8 @@ export const schemaBodyJson = <A, I, R>(schema: Schema.Schema<A, I, R>) => {
  * @since 1.0.0
  * @category schema
  */
-export const schemaBodyJsonEffect = <A, I, R>(schema: Schema.Schema<A, I, R>) => {
-  const decode = schemaBodyJson(schema)
+export const schemaBodyJsonEffect = <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
+  const decode = schemaBodyJson(schema, options)
   return <E, E2, R2>(effect: Effect.Effect<IncomingMessage<E>, E2, R2>) => Effect.scoped(Effect.flatMap(effect, decode))
 }
 
@@ -67,9 +68,10 @@ export const schemaBodyJsonEffect = <A, I, R>(schema: Schema.Schema<A, I, R>) =>
  * @category schema
  */
 export const schemaBodyUrlParams = <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<A, I, R>
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
 ) => {
-  const parse = Schema.decodeUnknown(schema)
+  const parse = Schema.decodeUnknown(schema, options)
   return <E>(self: IncomingMessage<E>): Effect.Effect<A, E | ParseResult.ParseError, R> =>
     Effect.flatMap(self.urlParamsBody, (_) => parse(Object.fromEntries(_)))
 }
@@ -79,9 +81,10 @@ export const schemaBodyUrlParams = <R, I extends Readonly<Record<string, string>
  * @category schema
  */
 export const schemaBodyUrlParamsEffect = <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<A, I, R>
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
 ) => {
-  const decode = schemaBodyUrlParams(schema)
+  const decode = schemaBodyUrlParams(schema, options)
   return <E, E2, R2>(effect: Effect.Effect<IncomingMessage<E>, E2, R2>) => Effect.scoped(Effect.flatMap(effect, decode))
 }
 
@@ -90,9 +93,10 @@ export const schemaBodyUrlParamsEffect = <R, I extends Readonly<Record<string, s
  * @category schema
  */
 export const schemaHeaders = <R, I extends Readonly<Record<string, string | undefined>>, A>(
-  schema: Schema.Schema<A, I, R>
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
 ) => {
-  const parse = Schema.decodeUnknown(schema)
+  const parse = Schema.decodeUnknown(schema, options)
   return <E>(self: IncomingMessage<E>): Effect.Effect<A, ParseResult.ParseError, R> => parse(self.headers)
 }
 
@@ -101,9 +105,10 @@ export const schemaHeaders = <R, I extends Readonly<Record<string, string | unde
  * @category schema
  */
 export const schemaHeadersEffect = <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<A, I, R>
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
 ) => {
-  const decode = schemaHeaders(schema)
+  const decode = schemaHeaders(schema, options)
   return <E, E2, R2>(effect: Effect.Effect<IncomingMessage<E>, E2, R2>) => Effect.scoped(Effect.flatMap(effect, decode))
 }
 

package/src/Http/Multipart.ts

@@ -1,6 +1,7 @@
 /**
  * @since 1.0.0
  */
+import type { ParseOptions } from "@effect/schema/AST"
 import type * as ParseResult from "@effect/schema/ParseResult"
 import type * as Schema from "@effect/schema/Schema"
 import type { YieldableError } from "effect/Cause"
@@ -221,7 +222,8 @@ export const filesSchema: Schema.Schema<ReadonlyArray<PersistedFile>> = internal
  * @category schema
  */
 export const schemaJson: <A, I, R>(
-  schema: Schema.Schema<A, I, R>
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
 ) => {
   (field: string): (persisted: Persisted) => Effect.Effect<A, ParseResult.ParseError, R>
   (persisted: Persisted, field: string): Effect.Effect<A, ParseResult.ParseError, R>
@@ -232,7 +234,8 @@ export const schemaJson: <A, I, R>(
  * @category schema
  */
 export const schemaPersisted: <R, I extends Partial<Persisted>, A>(
-  schema: Schema.Schema<A, I, R>
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
 ) => (persisted: Persisted) => Effect.Effect<A, ParseResult.ParseError, R> = internal.schemaPersisted
 
 /**

package/src/Http/Router.ts

@@ -1,6 +1,7 @@
 /**
  * @since 1.0.0
  */
+import type { ParseOptions } from "@effect/schema/AST"
 import type * as ParseResult from "@effect/schema/ParseResult"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Cause from "effect/Cause"
@@ -148,12 +149,56 @@ export const searchParams: Effect.Effect<
   RouteContext
 > = internal.searchParams
 
+/**
+ * @since 1.0.0
+ * @category route context
+ */
+export const schemaJson: <
+  R,
+  I extends {
+    readonly method?: Method.Method | undefined
+    readonly url?: string | undefined
+    readonly cookies?: Readonly<Record<string, string>> | undefined
+    readonly headers?: Readonly<Record<string, string>> | undefined
+    readonly pathParams?: Readonly<Record<string, string>> | undefined
+    readonly searchParams?: Readonly<Record<string, string>> | undefined
+    readonly body?: any
+  },
+  A
+>(
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
+) => Effect.Effect<A, ParseResult.ParseError | Error.RequestError, RouteContext | R | ServerRequest.ServerRequest> =
+  internal.schemaJson
+
+/**
+ * @since 1.0.0
+ * @category route context
+ */
+export const schemaNoBody: <
+  R,
+  I extends {
+    readonly method?: Method.Method | undefined
+    readonly url?: string | undefined
+    readonly cookies?: Readonly<Record<string, string>> | undefined
+    readonly headers?: Readonly<Record<string, string>> | undefined
+    readonly pathParams?: Readonly<Record<string, string>> | undefined
+    readonly searchParams?: Readonly<Record<string, string>> | undefined
+  },
+  A
+>(
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
+) => Effect.Effect<A, ParseResult.ParseError | Error.RequestError, RouteContext | R | ServerRequest.ServerRequest> =
+  internal.schemaNoBody
+
 /**
  * @since 1.0.0
  * @category route context
  */
 export const schemaParams: <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<A, I, R>
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
 ) => Effect.Effect<A, ParseResult.ParseError, RouteContext | R> = internal.schemaParams
 
 /**
@@ -161,7 +206,8 @@ export const schemaParams: <R, I extends Readonly<Record<string, string>>, A>(
  * @category route context
  */
 export const schemaPathParams: <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<A, I, R>
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
 ) => Effect.Effect<A, ParseResult.ParseError, RouteContext | R> = internal.schemaPathParams
 
 /**
@@ -169,7 +215,8 @@ export const schemaPathParams: <R, I extends Readonly<Record<string, string>>, A
  * @category route context
  */
 export const schemaSearchParams: <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<A, I, R>
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
 ) => Effect.Effect<A, ParseResult.ParseError, RouteContext | R> = internal.schemaSearchParams
 
 /**

package/src/Http/ServerRequest.ts

@@ -1,12 +1,14 @@
 /**
  * @since 1.0.0
  */
+import type { ParseOptions } from "@effect/schema/AST"
 import type * as ParseResult from "@effect/schema/ParseResult"
 import type * as Schema from "@effect/schema/Schema"
 import type { Channel } from "effect/Channel"
 import type { Chunk } from "effect/Chunk"
 import type * as Context from "effect/Context"
 import type * as Effect from "effect/Effect"
+import type { ReadonlyRecord } from "effect/ReadonlyRecord"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import type * as FileSystem from "../FileSystem.js"
@@ -49,6 +51,7 @@ export interface ServerRequest extends IncomingMessage.IncomingMessage<Error.Req
   readonly url: string
   readonly originalUrl: string
   readonly method: Method
+  readonly cookies: ReadonlyRecord<string, string>
 
   readonly multipart: Effect.Effect<
     Multipart.Persisted,
@@ -104,12 +107,22 @@ export const upgradeChannel: <IE = never>() => Channel<
   ServerRequest
 > = internal.upgradeChannel
 
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaCookies: <R, I extends Readonly<Record<string, string>>, A>(
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
+) => Effect.Effect<A, ParseResult.ParseError, ServerRequest | R> = internal.schemaCookies
+
 /**
  * @since 1.0.0
  * @category schema
  */
 export const schemaHeaders: <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<A, I, R>
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
 ) => Effect.Effect<A, ParseResult.ParseError, ServerRequest | R> = internal.schemaHeaders
 
 /**
@@ -117,7 +130,8 @@ export const schemaHeaders: <R, I extends Readonly<Record<string, string>>, A>(
  * @category schema
  */
 export const schemaBodyJson: <A, I, R>(
-  schema: Schema.Schema<A, I, R>
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
 ) => Effect.Effect<A, Error.RequestError | ParseResult.ParseError, ServerRequest | R> = internal.schemaBodyJson
 
 /**
@@ -125,7 +139,8 @@ export const schemaBodyJson: <A, I, R>(
  * @category schema
  */
 export const schemaBodyForm: <R, I extends Partial<Multipart.Persisted>, A>(
-  schema: Schema.Schema<A, I, R>
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
 ) => Effect.Effect<
   A,
   Multipart.MultipartError | ParseResult.ParseError | Error.RequestError,
@@ -137,15 +152,17 @@ export const schemaBodyForm: <R, I extends Partial<Multipart.Persisted>, A>(
  * @category schema
  */
 export const schemaBodyUrlParams: <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<A, I, R>
-) => Effect.Effect<A, Error.RequestError | ParseResult.ParseError, ServerRequest | R> = internal.schemaBodyUrlParams
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
+) => Effect.Effect<A, ParseResult.ParseError | Error.RequestError, R | ServerRequest> = internal.schemaBodyUrlParams
 
 /**
  * @since 1.0.0
  * @category schema
  */
 export const schemaBodyMultipart: <R, I extends Partial<Multipart.Persisted>, A>(
-  schema: Schema.Schema<A, I, R>
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
 ) => Effect.Effect<
   A,
   Multipart.MultipartError | ParseResult.ParseError,
@@ -157,7 +174,8 @@ export const schemaBodyMultipart: <R, I extends Partial<Multipart.Persisted>, A>
  * @category schema
  */
 export const schemaBodyFormJson: <A, I, R>(
-  schema: Schema.Schema<A, I, R>
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
 ) => (
   field: string
 ) => Effect.Effect<

package/src/Http/ServerResponse.ts

@@ -1,6 +1,7 @@
 /**
  * @since 1.0.0
  */
+import type { ParseOptions } from "@effect/schema/AST"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
 import type { Inspectable } from "effect/Inspectable"
@@ -10,6 +11,7 @@ import type * as FileSystem from "../FileSystem.js"
 import * as internal from "../internal/http/serverResponse.js"
 import type * as Template from "../Template.js"
 import type * as Body from "./Body.js"
+import type { Cookie, Cookies, CookiesError } from "./Cookies.js"
 import type * as Headers from "./Headers.js"
 import type * as Platform from "./Platform.js"
 import type * as UrlParams from "./UrlParams.js"
@@ -35,6 +37,7 @@ export interface ServerResponse extends Effect.Effect<ServerResponse>, Inspectab
   readonly status: number
   readonly statusText?: string | undefined
   readonly headers: Headers.Headers
+  readonly cookies: Cookies
   readonly body: Body.Body
 }
 
@@ -46,6 +49,7 @@ export interface Options {
   readonly status?: number | undefined
   readonly statusText?: string | undefined
   readonly headers?: Headers.Headers | undefined
+  readonly cookies?: Cookies | undefined
   readonly contentType?: string | undefined
   readonly contentLength?: number | undefined
 }
@@ -76,19 +80,20 @@ export const isServerResponse: (u: unknown) => u is ServerResponse = internal.is
  * @since 1.0.0
  * @category constructors
  */
-export const empty: (options?: Options.WithContent) => ServerResponse = internal.empty
+export const empty: (options?: Options.WithContent | undefined) => ServerResponse = internal.empty
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const uint8Array: (body: Uint8Array, options?: Options.WithContentType) => ServerResponse = internal.uint8Array
+export const uint8Array: (body: Uint8Array, options?: Options.WithContentType | undefined) => ServerResponse =
+  internal.uint8Array
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const text: (body: string, options?: Options.WithContentType) => ServerResponse = internal.text
+export const text: (body: string, options?: Options.WithContentType | undefined) => ServerResponse = internal.text
 
 /**
  * @since 1.0.0
@@ -117,7 +122,7 @@ export const htmlStream: <A extends ReadonlyArray<Template.InterpolatedWithStrea
  */
 export const json: (
   body: unknown,
-  options?: Options.WithContent
+  options?: Options.WithContent | undefined
 ) => Effect.Effect<ServerResponse, Body.BodyError> = internal.json
 
 /**
@@ -125,7 +130,8 @@ export const json: (
  * @category constructors
  */
 export const schemaJson: <A, I, R>(
-  schema: Schema.Schema<A, I, R>
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
 ) => (body: A, options?: Options.WithContent | undefined) => Effect.Effect<ServerResponse, Body.BodyError, R> =
   internal.schemaJson
 
@@ -133,31 +139,34 @@ export const schemaJson: <A, I, R>(
  * @since 1.0.0
  * @category constructors
  */
-export const unsafeJson: (body: unknown, options?: Options.WithContent) => ServerResponse = internal.unsafeJson
+export const unsafeJson: (body: unknown, options?: Options.WithContent | undefined) => ServerResponse =
+  internal.unsafeJson
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const urlParams: (body: UrlParams.Input, options?: Options.WithContent) => ServerResponse = internal.urlParams
+export const urlParams: (body: UrlParams.Input, options?: Options.WithContent | undefined) => ServerResponse =
+  internal.urlParams
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const raw: (body: unknown, options?: Options) => ServerResponse = internal.raw
+export const raw: (body: unknown, options?: Options | undefined) => ServerResponse = internal.raw
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const formData: (body: FormData, options?: Options.WithContent) => ServerResponse = internal.formData
+export const formData: (body: FormData, options?: Options.WithContent | undefined) => ServerResponse = internal.formData
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const stream: (body: Stream.Stream<Uint8Array, unknown>, options?: Options) => ServerResponse = internal.stream
+export const stream: (body: Stream.Stream<Uint8Array, unknown>, options?: Options | undefined) => ServerResponse =
+  internal.stream
 
 /**
  * @since 1.0.0
@@ -165,7 +174,7 @@ export const stream: (body: Stream.Stream<Uint8Array, unknown>, options?: Option
  */
 export const file: (
   path: string,
-  options?: Options & FileSystem.StreamOptions
+  options?: (Options & FileSystem.StreamOptions) | undefined
 ) => Effect.Effect<ServerResponse, PlatformError.PlatformError, Platform.Platform> = internal.file
 
 /**
@@ -174,7 +183,7 @@ export const file: (
  */
 export const fileWeb: (
   file: Body.Body.FileLike,
-  options?: Options.WithContent & FileSystem.StreamOptions
+  options?: (Options.WithContent & FileSystem.StreamOptions) | undefined
 ) => Effect.Effect<ServerResponse, never, Platform.Platform> = internal.fileWeb
 
 /**
@@ -195,6 +204,129 @@ export const setHeaders: {
   (self: ServerResponse, input: Headers.Input): ServerResponse
 } = internal.setHeaders
 
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const removeCookie: {
+  (name: string): (self: ServerResponse) => ServerResponse
+  (self: ServerResponse, name: string): ServerResponse
+} = internal.removeCookie
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const replaceCookies: {
+  (cookies: Cookies): (self: ServerResponse) => ServerResponse
+  (self: ServerResponse, cookies: Cookies): ServerResponse
+} = internal.replaceCookies
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setCookie: {
+  (
+    name: string,
+    value: string,
+    options?: Cookie["options"]
+  ): (
+    self: ServerResponse
+  ) => Effect.Effect<
+    ServerResponse,
+    CookiesError
+  >
+  (
+    self: ServerResponse,
+    name: string,
+    value: string,
+    options?: Cookie["options"]
+  ): Effect.Effect<
+    ServerResponse,
+    CookiesError
+  >
+} = internal.setCookie
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const unsafeSetCookie: {
+  (
+    name: string,
+    value: string,
+    options?: Cookie["options"]
+  ): (self: ServerResponse) => ServerResponse
+  (
+    self: ServerResponse,
+    name: string,
+    value: string,
+    options?: Cookie["options"]
+  ): ServerResponse
+} = internal.unsafeSetCookie
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const updateCookies: {
+  (f: (cookies: Cookies) => Cookies): (self: ServerResponse) => ServerResponse
+  (self: ServerResponse, f: (cookies: Cookies) => Cookies): ServerResponse
+} = internal.updateCookies
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setCookies: {
+  (
+    cookies: Iterable<
+      readonly [
+        name: string,
+        value: string,
+        options?: Cookie["options"]
+      ]
+    >
+  ): (self: ServerResponse) => Effect.Effect<ServerResponse, CookiesError, never>
+  (
+    self: ServerResponse,
+    cookies: Iterable<
+      readonly [
+        name: string,
+        value: string,
+        options?: Cookie["options"]
+      ]
+    >
+  ): Effect.Effect<ServerResponse, CookiesError, never>
+} = internal.setCookies
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const unsafeSetCookies: {
+  (
+    cookies: Iterable<
+      readonly [
+        name: string,
+        value: string,
+        options?: Cookie["options"]
+      ]
+    >
+  ): (self: ServerResponse) => ServerResponse
+  (
+    self: ServerResponse,
+    cookies: Iterable<
+      readonly [
+        name: string,
+        value: string,
+        options?: Cookie["options"]
+      ]
+    >
+  ): ServerResponse
+} = internal.unsafeSetCookies
+
 /**
  * @since 1.0.0
  * @category combinators
@@ -217,4 +349,4 @@ export const setStatus: {
  * @since 1.0.0
  * @category conversions
  */
-export const toWeb: (response: ServerResponse, withoutBody?: boolean) => Response = internal.toWeb
+export const toWeb: (response: ServerResponse, withoutBody?: boolean | undefined) => Response = internal.toWeb

package/src/Http/UrlParams.ts

@@ -1,6 +1,7 @@
 /**
  * @since 1.0.0
  */
+import type { ParseOptions } from "@effect/schema/AST"
 import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
 import * as Effect from "effect/Effect"
@@ -217,7 +218,7 @@ const baseUrl = (): string | undefined => {
  * @since 1.0.0
  * @category schema
  */
-export const schemaJson = <A, I, R>(schema: Schema.Schema<A, I, R>): {
+export const schemaJson = <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined): {
   (
     field: string
   ): (self: UrlParams) => Effect.Effect<A, ParseResult.ParseError, R>
@@ -226,7 +227,7 @@ export const schemaJson = <A, I, R>(schema: Schema.Schema<A, I, R>): {
     field: string
   ): Effect.Effect<A, ParseResult.ParseError, R>
 } => {
-  const parse = Schema.decodeUnknown(Schema.parseJson(schema))
+  const parse = Schema.decodeUnknown(Schema.parseJson(schema), options)
   return dual<
     (field: string) => (self: UrlParams) => Effect.Effect<A, ParseResult.ParseError, R>,
     (self: UrlParams, field: string) => Effect.Effect<A, ParseResult.ParseError, R>

package/src/HttpClient.ts

@@ -6,6 +6,7 @@ import * as client from "./Http/Client.js"
 import * as error from "./Http/ClientError.js"
 import * as request from "./Http/ClientRequest.js"
 import * as response from "./Http/ClientResponse.js"
+import * as cookies from "./Http/Cookies.js"
 import * as headers from "./Http/Headers.js"
 import * as urlParams from "./Http/UrlParams.js"
 
@@ -24,6 +25,13 @@ export {
    * - Module: `@effect/platform/Http/Client`
    */
   client,
+  /**
+   * @since 1.0.0
+   *
+   * - Docs: [Http/Cookies](https://effect-ts.github.io/effect/platform/Http/Cookies.ts.html)
+   * - Module: `@effect/platform/Http/Cookies`
+   */
+  cookies,
   /**
    * @since 1.0.0
    *

package/src/HttpServer.ts

@@ -3,6 +3,7 @@
  */
 import * as app from "./Http/App.js"
 import * as body from "./Http/Body.js"
+import * as cookies from "./Http/Cookies.js"
 import * as etag from "./Http/Etag.js"
 import * as headers from "./Http/Headers.js"
 import * as middleware from "./Http/Middleware.js"
@@ -31,6 +32,13 @@ export {
    * - Module: `@effect/platform/Http/Body`
    */
   body,
+  /**
+   * @since 1.0.0
+   *
+   * - Docs: [Http/Cookies](https://effect-ts.github.io/effect/platform/Http/Cookies.ts.html)
+   * - Module: `@effect/platform/Http/Cookies`
+   */
+  cookies,
   /**
    * @since 1.0.0
    *

package/src/internal/http/body.ts

@@ -1,3 +1,4 @@
+import type { ParseOptions } from "@effect/schema/AST"
 import * as Schema from "@effect/schema/Schema"
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
@@ -127,8 +128,8 @@ export const urlParams = (urlParams: UrlParams.UrlParams): Body.Uint8Array =>
   text(UrlParams.toString(urlParams), "application/x-www-form-urlencoded")
 
 /** @internal */
-export const jsonSchema = <A, I, R>(schema: Schema.Schema<A, I, R>) => {
-  const encode = Schema.encode(schema)
+export const jsonSchema = <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions) => {
+  const encode = Schema.encode(schema, options)
   return (body: A): Effect.Effect<Body.Uint8Array, Body.BodyError, R> =>
     Effect.flatMap(
       Effect.mapError(encode(body), (error) => BodyError({ _tag: "SchemaError", error })),