@effect/platform 0.48.15 → 0.48.17

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,8 @@ 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"
 import * as Stream from "effect/Stream"
@@ -14,6 +16,7 @@ import type * as Client from "../../Http/Client.js"
 import * as Error from "../../Http/ClientError.js"
 import type * as ClientRequest from "../../Http/ClientRequest.js"
 import type * as ClientResponse from "../../Http/ClientResponse.js"
+import * as Cookies from "../../Http/Cookies.js"
 import * as Method from "../../Http/Method.js"
 import * as UrlParams from "../../Http/UrlParams.js"
 import * as internalBody from "./body.js"
@@ -35,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: (
@@ -547,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>
   ) => (
@@ -557,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), {
@@ -609,3 +616,36 @@ export const tapRequest = dual<
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
   ) => Client.Client<R | R2, E | E2, A>
 >(2, (self, f) => make(self.execute as any, (request) => Effect.tap(self.preprocess(request), f)))
+
+/** @internal */
+export const withCookiesRef = dual<
+  (
+    ref: Ref.Ref<Cookies.Cookies>
+  ) => <R, E>(self: Client.Client.WithResponse<R, E>) => Client.Client.WithResponse<R, E>,
+  <R, E>(
+    self: Client.Client.WithResponse<R, E>,
+    ref: Ref.Ref<Cookies.Cookies>
+  ) => Client.Client.WithResponse<R, E>
+>(
+  2,
+  <R, E>(
+    self: Client.Client.WithResponse<R, E>,
+    ref: Ref.Ref<Cookies.Cookies>
+  ): Client.Client.WithResponse<R, E> =>
+    make(
+      (request: Effect.Effect<ClientRequest.ClientRequest, E, R>) =>
+        Effect.tap(
+          self.execute(request),
+          (response) => Ref.update(ref, (cookies) => Cookies.merge(cookies, response.cookies))
+        ),
+      (request) =>
+        Effect.flatMap(self.preprocess(request), (request) =>
+          Effect.map(
+            Ref.get(ref),
+            (cookies) =>
+              Cookies.isEmpty(cookies)
+                ? request
+                : internalRequest.setHeader(request, "cookie", Cookies.toCookieHeader(cookies))
+          ))
+    )
+)

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"
@@ -7,6 +8,7 @@ import * as Stream from "effect/Stream"
 import * as Error from "../../Http/ClientError.js"
 import type * as ClientRequest from "../../Http/ClientRequest.js"
 import type * as ClientResponse from "../../Http/ClientResponse.js"
+import * as Cookies from "../../Http/Cookies.js"
 import * as Headers from "../../Http/Headers.js"
 import * as IncomingMessage from "../../Http/IncomingMessage.js"
 import * as UrlParams from "../../Http/UrlParams.js"
@@ -49,6 +51,14 @@ class ClientResponseImpl extends Inspectable.Class implements ClientResponse.Cli
     return Headers.fromInput(this.source.headers)
   }
 
+  cachedCookies?: Cookies.Cookies
+  get cookies(): Cookies.Cookies {
+    if (this.cachedCookies) {
+      return this.cachedCookies
+    }
+    return this.cachedCookies = Cookies.fromSetCookie(this.source.headers.getSetCookie())
+  }
+
   get remoteAddress(): Option.Option<string> {
     return Option.none()
   }
@@ -151,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,
@@ -173,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,
@@ -215,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))
 }
@@ -229,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,13 +1,16 @@
+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"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
+import type { ReadonlyRecord } from "effect/ReadonlyRecord"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import type * as FileSystem from "../../FileSystem.js"
+import * as Cookies from "../../Http/Cookies.js"
 import * as Headers from "../../Http/Headers.js"
 import * as IncomingMessage from "../../Http/IncomingMessage.js"
 import type { Method } from "../../Http/Method.js"
@@ -34,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)
 }
 
@@ -50,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,
@@ -68,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,
@@ -164,6 +182,14 @@ class ServerRequestImpl extends Inspectable.Class implements ServerRequest.Serve
     return this.headersOverride
   }
 
+  private cachedCookies: ReadonlyRecord<string, string> | undefined
+  get cookies() {
+    if (this.cachedCookies) {
+      return this.cachedCookies
+    }
+    return this.cachedCookies = Cookies.parseHeader(this.headers.cookie ?? "")
+  }
+
   get stream(): Stream.Stream<Uint8Array, Error.RequestError> {
     return this.source.body
       ? Stream.fromReadableStream(() => this.source.body as any, (_) =>