@effect/platform 0.48.16 → 0.48.17

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,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 { Channel } from "effect/Channel"
@@ -106,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
 
 /**
@@ -119,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
 
 /**
@@ -127,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,
@@ -139,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,
@@ -159,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"
@@ -79,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
@@ -120,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
 
 /**
@@ -128,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
 
@@ -136,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
@@ -168,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
 
 /**
@@ -177,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
 
 /**
@@ -343,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/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 })),

package/src/internal/http/client.ts

@@ -1,3 +1,4 @@
+import type { ParseOptions } from "@effect/schema/AST"
 import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
 import * as Context from "effect/Context"
@@ -5,7 +6,7 @@ import * as Effect from "effect/Effect"
 import { dual, pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
 import { pipeArguments } from "effect/Pipeable"
-import type * as Predicate from "effect/Predicate"
+import * as Predicate from "effect/Predicate"
 import * as Ref from "effect/Ref"
 import type * as Schedule from "effect/Schedule"
 import type * as Scope from "effect/Scope"
@@ -37,6 +38,8 @@ const clientProto = {
   }
 }
 
+const isClient = (u: unknown): u is Client.Client<unknown, unknown, unknown> => Predicate.hasProperty(u, TypeId)
+
 /** @internal */
 export const make = <R, E, A, R2, E2>(
   execute: (
@@ -549,7 +552,8 @@ export const retry: {
 /** @internal */
 export const schemaFunction = dual<
   <SA, SI, SR>(
-    schema: Schema.Schema<SA, SI, SR>
+    schema: Schema.Schema<SA, SI, SR>,
+    options?: ParseOptions | undefined
   ) => <R, E, A>(
     self: Client.Client<R, E, A>
   ) => (
@@ -559,14 +563,15 @@ export const schemaFunction = dual<
   ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>,
   <R, E, A, SA, SI, SR>(
     self: Client.Client<R, E, A>,
-    schema: Schema.Schema<SA, SI, SR>
+    schema: Schema.Schema<SA, SI, SR>,
+    options?: ParseOptions | undefined
   ) => (
     request: ClientRequest.ClientRequest
   ) => (
     a: SA
   ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>
->(2, (self, schema) => {
-  const encode = Schema.encode(schema)
+>((args) => isClient(args[0]), (self, schema, options) => {
+  const encode = Schema.encode(schema, options)
   return (request) => (a) =>
     Effect.flatMap(
       Effect.tryMap(encode(a), {

package/src/internal/http/clientRequest.ts

@@ -1,3 +1,4 @@
+import type { ParseOptions } from "@effect/schema/AST"
 import type * as Schema from "@effect/schema/Schema"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
@@ -373,11 +374,11 @@ export const fileWebBody = dual<
 >(2, (self, file) => setBody(self, internalBody.fileWeb(file)))
 
 /** @internal */
-export const schemaBody = <A, I, R>(schema: Schema.Schema<A, I, R>): {
+export const schemaBody = <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined): {
   (body: A): (self: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, Body.BodyError, R>
   (self: ClientRequest.ClientRequest, body: A): Effect.Effect<ClientRequest.ClientRequest, Body.BodyError, R>
 } => {
-  const encode = internalBody.jsonSchema(schema)
+  const encode = internalBody.jsonSchema(schema, options)
   return dual<
     (
       body: A

package/src/internal/http/clientResponse.ts

@@ -1,3 +1,4 @@
+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"
@@ -160,8 +161,8 @@ export const schemaJson = <
     readonly body?: unknown | undefined
   },
   A
->(schema: Schema.Schema<A, I, R>) => {
-  const parse = Schema.decodeUnknown(schema)
+>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
+  const parse = Schema.decodeUnknown(schema, options)
   return (self: ClientResponse.ClientResponse): Effect.Effect<A, Error.ResponseError | ParseResult.ParseError, R> =>
     Effect.flatMap(
       self.json,
@@ -182,8 +183,8 @@ export const schemaNoBody = <
     readonly headers?: Readonly<Record<string, string>> | undefined
   },
   A
->(schema: Schema.Schema<A, I, R>) => {
-  const parse = Schema.decodeUnknown(schema)
+>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
+  const parse = Schema.decodeUnknown(schema, options)
   return (self: ClientResponse.ClientResponse): Effect.Effect<A, ParseResult.ParseError, R> =>
     parse({
       status: self.status,
@@ -224,8 +225,8 @@ export const schemaJsonEffect = <
     readonly body?: unknown | undefined
   },
   A
->(schema: Schema.Schema<A, I, R>) => {
-  const decode = schemaJson(schema)
+>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
+  const decode = schemaJson(schema, options)
   return <E, R2>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R2>) =>
     Effect.scoped(Effect.flatMap(effect, decode))
 }
@@ -238,8 +239,8 @@ export const schemaNoBodyEffect = <
     readonly headers?: Readonly<Record<string, string>> | undefined
   },
   A
->(schema: Schema.Schema<A, I, R>) => {
-  const decode = schemaNoBody(schema)
+>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
+  const decode = schemaNoBody(schema, options)
   return <E, R2>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R2>) =>
     Effect.scoped(Effect.flatMap(effect, decode))
 }

package/src/internal/http/multipart.ts

@@ -1,3 +1,4 @@
+import type { ParseOptions } from "@effect/schema/AST"
 import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
 import * as Cause from "effect/Cause"
@@ -108,14 +109,15 @@ export const filesSchema: Schema.Schema<ReadonlyArray<Multipart.PersistedFile>>
 
 /** @internal */
 export const schemaPersisted = <R, I extends Partial<Multipart.Persisted>, 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 (persisted: Multipart.Persisted) => parse(persisted)
 }
 
 /** @internal */
-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
   ): (persisted: Multipart.Persisted) => Effect.Effect<A, ParseResult.ParseError, R>
@@ -140,7 +142,8 @@ export const schemaJson = <A, I, R>(schema: Schema.Schema<A, I, R>): {
       Schema.decodeUnknown(
         Schema.struct({
           [field]: fromJson
-        })
+        }),
+        options
       )(persisted),
       (_) => _[field]
     ))

package/src/internal/http/router.ts

@@ -1,3 +1,4 @@
+import type { ParseOptions } from "@effect/schema/AST"
 import * as Schema from "@effect/schema/Schema"
 import type * as Cause from "effect/Cause"
 import * as Chunk from "effect/Chunk"
@@ -37,22 +38,95 @@ export const params = Effect.map(RouteContext, (_) => _.params)
 export const searchParams = Effect.map(RouteContext, (_) => _.searchParams)
 
 /** @internal */
-export const schemaParams = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<A, I, R>) => {
-  const parse = Schema.decodeUnknown(schema)
+export const schemaJson = <
+  R,
+  I extends {
+    readonly method?: Method.Method
+    readonly url?: string
+    readonly cookies?: Readonly<Record<string, string>>
+    readonly headers?: Readonly<Record<string, string>>
+    readonly pathParams?: Readonly<Record<string, string>>
+    readonly searchParams?: Readonly<Record<string, string>>
+    readonly body?: any
+  },
+  A
+>(
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
+) => {
+  const parse = Schema.decodeUnknown(schema, options)
+  return Effect.flatMap(
+    ServerRequest.ServerRequest,
+    (request) =>
+      Effect.flatMap(Effect.zip(request.json, RouteContext), ([body, context]) =>
+        parse({
+          method: request.method,
+          url: request.url,
+          headers: request.headers,
+          cookies: request.cookies,
+          pathParams: context.params,
+          searchParams: context.searchParams,
+          body
+        }))
+  )
+}
+
+/** @internal */
+export const schemaNoBody = <
+  R,
+  I extends {
+    readonly method?: Method.Method
+    readonly url?: string
+    readonly cookies?: Readonly<Record<string, string>>
+    readonly headers?: Readonly<Record<string, string>>
+    readonly pathParams?: Readonly<Record<string, string>>
+    readonly searchParams?: Readonly<Record<string, string>>
+  },
+  A
+>(
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
+) => {
+  const parse = Schema.decodeUnknown(schema, options)
+  return Effect.flatMap(
+    ServerRequest.ServerRequest,
+    (request) =>
+      Effect.flatMap(RouteContext, (context) =>
+        parse({
+          method: request.method,
+          url: request.url,
+          headers: request.headers,
+          cookies: request.cookies,
+          pathParams: context.params,
+          searchParams: context.searchParams
+        }))
+  )
+}
+
+/** @internal */
+export const schemaParams = <R, I extends Readonly<Record<string, string>>, A>(
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
+) => {
+  const parse = Schema.decodeUnknown(schema, options)
   return Effect.flatMap(RouteContext, (_) => parse({ ..._.searchParams, ..._.params }))
 }
 
 /** @internal */
-export const schemaPathParams = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<A, I, R>) => {
-  const parse = Schema.decodeUnknown(schema)
+export const schemaPathParams = <R, I extends Readonly<Record<string, string>>, A>(
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
+) => {
+  const parse = Schema.decodeUnknown(schema, options)
   return Effect.flatMap(RouteContext, (_) => parse(_.params))
 }
 
 /** @internal */
 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
 ) => {
-  const parse = Schema.decodeUnknown(schema)
+  const parse = Schema.decodeUnknown(schema, options)
   return Effect.flatMap(RouteContext, (_) => parse(_.searchParams))
 }
 

package/src/internal/http/serverRequest.ts

@@ -1,5 +1,6 @@
+import type { ParseOptions } from "@effect/schema/AST"
 import type * as ParseResult from "@effect/schema/ParseResult"
-import type * as Schema from "@effect/schema/Schema"
+import * as Schema from "@effect/schema/Schema"
 import * as Channel from "effect/Channel"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
@@ -36,14 +37,26 @@ export const upgradeChannel = <IE = never>() => Channel.unwrap(Effect.map(upgrad
 export const multipartPersisted = Effect.flatMap(serverRequestTag, (request) => request.multipart)
 
 /** @internal */
-export const schemaHeaders = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<A, I, R>) => {
-  const parse = IncomingMessage.schemaHeaders(schema)
+export const schemaCookies = <R, I extends Readonly<Record<string, string>>, A>(
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
+) => {
+  const parse = Schema.decodeUnknown(schema, options)
+  return Effect.flatMap(serverRequestTag, (req) => parse(req.cookies))
+}
+
+/** @internal */
+export const schemaHeaders = <R, I extends Readonly<Record<string, string>>, A>(
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
+) => {
+  const parse = IncomingMessage.schemaHeaders(schema, options)
   return Effect.flatMap(serverRequestTag, parse)
 }
 
 /** @internal */
-export const schemaBodyJson = <A, I, R>(schema: Schema.Schema<A, I, R>) => {
-  const parse = IncomingMessage.schemaBodyJson(schema)
+export const schemaBodyJson = <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
+  const parse = IncomingMessage.schemaBodyJson(schema, options)
   return Effect.flatMap(serverRequestTag, parse)
 }
 
@@ -52,10 +65,11 @@ const isMultipart = (request: ServerRequest.ServerRequest) =>
 
 /** @internal */
 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
 ) => {
-  const parseMultipart = Multipart.schemaPersisted(schema)
-  const parseUrlParams = IncomingMessage.schemaBodyUrlParams(schema as Schema.Schema<A, any, R>)
+  const parseMultipart = Multipart.schemaPersisted(schema, options)
+  const parseUrlParams = IncomingMessage.schemaBodyUrlParams(schema as Schema.Schema<A, any, R>, options)
   return Effect.flatMap(serverRequestTag, (request): Effect.Effect<
     A,
     Multipart.MultipartError | ParseResult.ParseError | Error.RequestError,
@@ -70,24 +84,26 @@ export const schemaBodyForm = <R, I extends Partial<Multipart.Persisted>, A>(
 
 /** @internal */
 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 = IncomingMessage.schemaBodyUrlParams(schema)
+  const parse = IncomingMessage.schemaBodyUrlParams(schema, options)
   return Effect.flatMap(serverRequestTag, parse)
 }
 
 /** @internal */
 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
 ) => {
-  const parse = Multipart.schemaPersisted(schema)
+  const parse = Multipart.schemaPersisted(schema, options)
   return Effect.flatMap(multipartPersisted, parse)
 }
 
 /** @internal */
-export const schemaBodyFormJson = <A, I, R>(schema: Schema.Schema<A, I, R>) => {
-  const parseMultipart = Multipart.schemaJson(schema)
-  const parseUrlParams = UrlParams.schemaJson(schema)
+export const schemaBodyFormJson = <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
+  const parseMultipart = Multipart.schemaJson(schema, options)
+  const parseUrlParams = UrlParams.schemaJson(schema, options)
   return (field: string) =>
     Effect.flatMap(
       serverRequestTag,