@effect/platform 0.42.7 → 0.43.0

package/src/WorkerRunner.ts

@@ -18,7 +18,10 @@ import type { WorkerError } from "./WorkerError.js"
  */
 export interface BackingRunner<I, O> {
   readonly queue: Queue.Dequeue<I>
-  readonly send: (message: O, transfers?: ReadonlyArray<unknown>) => Effect.Effect<never, never, void>
+  readonly send: (
+    message: O,
+    transfers?: ReadonlyArray<unknown>
+  ) => Effect.Effect<never, never, void>
 }
 
 /**
@@ -72,9 +75,17 @@ export declare namespace Runner {
    * @category models
    */
   export interface Options<I, E, O> {
-    readonly decode?: (message: unknown) => Effect.Effect<never, WorkerError, I>
-    readonly encodeOutput?: (request: I, message: O) => Effect.Effect<never, WorkerError, unknown>
-    readonly encodeError?: (request: I, error: E) => Effect.Effect<never, WorkerError, unknown>
+    readonly decode?: (
+      message: unknown
+    ) => Effect.Effect<never, WorkerError, I>
+    readonly encodeOutput?: (
+      request: I,
+      message: O
+    ) => Effect.Effect<never, WorkerError, unknown>
+    readonly encodeError?: (
+      request: I,
+      error: E
+    ) => Effect.Effect<never, WorkerError, unknown>
     readonly transfers?: (message: O | E) => ReadonlyArray<unknown>
   }
 }
@@ -106,8 +117,19 @@ export declare namespace SerializedRunner {
    * @since 1.0.0
    */
   export type Handlers<A extends Schema.TaggedRequest.Any> = {
-    readonly [K in A["_tag"]]: Extract<A, { readonly _tag: K }> extends
-      Serializable.SerializableWithResult<infer _IS, infer S, infer _IE, infer E, infer _IO, infer O> ? (
+    readonly [K in A["_tag"]]: Extract<
+      A,
+      { readonly _tag: K }
+    > extends Serializable.SerializableWithResult<
+      infer _RS,
+      infer _IS,
+      infer S,
+      infer _RR,
+      infer _IE,
+      infer E,
+      infer _IO,
+      infer O
+    > ? (
         _: S
       ) =>
         | Stream.Stream<any, E, O>
@@ -120,10 +142,17 @@ export declare namespace SerializedRunner {
   /**
    * @since 1.0.0
    */
-  export type HandlersContext<Handlers extends Record<string, (...args: ReadonlyArray<any>) => any>> =
+  export type HandlersContext<
+    Handlers extends Record<string, (...args: ReadonlyArray<any>) => any>
+  > =
     | Exclude<
       {
-        [K in keyof Handlers]: ReturnType<Handlers[K]> extends Stream.Stream<infer R, infer _E, infer _A> ? R : never
+        [K in keyof Handlers]: ReturnType<Handlers[K]> extends Stream.Stream<
+          infer R,
+          infer _E,
+          infer _A
+        > ? R
+          : never
       }[keyof Handlers],
       InitialContext<Handlers>
     >
@@ -132,16 +161,22 @@ export declare namespace SerializedRunner {
   /**
    * @since 1.0.0
    */
-  type InitialContext<Handlers extends Record<string, (...args: ReadonlyArray<any>) => any>> =
-    Handlers["InitialMessage"] extends (...args: ReadonlyArray<any>) => Layer.Layer<infer _R, infer _E, infer A> ? A
-      : never
+  type InitialContext<
+    Handlers extends Record<string, (...args: ReadonlyArray<any>) => any>
+  > = Handlers["InitialMessage"] extends (
+    ...args: ReadonlyArray<any>
+  ) => Layer.Layer<infer _R, infer _E, infer A> ? A
+    : never
 
   /**
    * @since 1.0.0
    */
-  type InitialEnv<Handlers extends Record<string, (...args: ReadonlyArray<any>) => any>> =
-    Handlers["InitialMessage"] extends (...args: ReadonlyArray<any>) => Layer.Layer<infer R, infer _E, infer _A> ? R
-      : never
+  type InitialEnv<
+    Handlers extends Record<string, (...args: ReadonlyArray<any>) => any>
+  > = Handlers["InitialMessage"] extends (
+    ...args: ReadonlyArray<any>
+  ) => Layer.Layer<infer R, infer _E, infer _A> ? R
+    : never
 }
 
 /**
@@ -149,13 +184,14 @@ export declare namespace SerializedRunner {
  * @category constructors
  */
 export const makeSerialized: <
+  R,
   I,
   A extends Schema.TaggedRequest.Any,
   const Handlers extends SerializedRunner.Handlers<A>
 >(
-  schema: Schema.Schema<I, A>,
+  schema: Schema.Schema<R, I, A>,
   handlers: Handlers
-) => Effect.Effect<PlatformRunner | Scope.Scope | SerializedRunner.HandlersContext<Handlers>, WorkerError, void> =
+) => Effect.Effect<PlatformRunner | Scope.Scope | R | SerializedRunner.HandlersContext<Handlers>, WorkerError, void> =
   internal.makeSerialized
 
 /**
@@ -163,11 +199,12 @@ export const makeSerialized: <
  * @category layers
  */
 export const layerSerialized: <
+  R,
   I,
   A extends Schema.TaggedRequest.Any,
   const Handlers extends SerializedRunner.Handlers<A>
 >(
-  schema: Schema.Schema<I, A>,
+  schema: Schema.Schema<R, I, A>,
   handlers: Handlers
-) => Layer.Layer<PlatformRunner | SerializedRunner.HandlersContext<Handlers>, WorkerError, never> =
+) => Layer.Layer<PlatformRunner | R | SerializedRunner.HandlersContext<Handlers>, WorkerError, never> =
   internal.layerSerialized

package/src/internal/http/body.ts

@@ -90,9 +90,9 @@ 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>) => {
+export const jsonSchema = <R, I, A>(schema: Schema.Schema<R, I, A>) => {
   const encode = Schema.encode(schema)
-  return (body: A): Effect.Effect<never, Body.BodyError, Body.Uint8Array> =>
+  return (body: A): Effect.Effect<R, Body.BodyError, Body.Uint8Array> =>
     Effect.flatMap(
       Effect.mapError(encode(body), (error) => BodyError({ _tag: "SchemaError", error })),
       json

package/src/internal/http/client.ts

@@ -528,23 +528,23 @@ export const retry: {
 
 /** @internal */
 export const schemaFunction = dual<
-  <SI, SA>(
-    schema: Schema.Schema<SI, SA>
+  <SR, SI, SA>(
+    schema: Schema.Schema<SR, SI, SA>
   ) => <R, E, A>(
     self: Client.Client<R, E, A>
   ) => (
     request: ClientRequest.ClientRequest
   ) => (
     a: SA
-  ) => Effect.Effect<R, E | ParseResult.ParseError | Error.RequestError, A>,
-  <R, E, A, SI, SA>(
+  ) => Effect.Effect<R | SR, E | ParseResult.ParseError | Error.RequestError, A>,
+  <R, E, A, SR, SI, SA>(
     self: Client.Client<R, E, A>,
-    schema: Schema.Schema<SI, SA>
+    schema: Schema.Schema<SR, SI, SA>
   ) => (
     request: ClientRequest.ClientRequest
   ) => (
     a: SA
-  ) => Effect.Effect<R, E | ParseResult.ParseError | Error.RequestError, A>
+  ) => Effect.Effect<R | SR, E | ParseResult.ParseError | Error.RequestError, A>
 >(2, (self, schema) => {
   const encode = Schema.encode(schema)
   return (request) => (a) =>

package/src/internal/http/clientRequest.ts

@@ -362,16 +362,16 @@ export const fileWebBody = dual<
 >(2, (self, file) => setBody(self, internalBody.fileWeb(file)))
 
 /** @internal */
-export const schemaBody = <I, A>(schema: Schema.Schema<I, A>): {
-  (body: A): (self: ClientRequest.ClientRequest) => Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>
-  (self: ClientRequest.ClientRequest, body: A): Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>
+export const schemaBody = <R, I, A>(schema: Schema.Schema<R, I, A>): {
+  (body: A): (self: ClientRequest.ClientRequest) => Effect.Effect<R, Body.BodyError, ClientRequest.ClientRequest>
+  (self: ClientRequest.ClientRequest, body: A): Effect.Effect<R, Body.BodyError, ClientRequest.ClientRequest>
 } => {
   const encode = internalBody.jsonSchema(schema)
   return dual<
     (
       body: A
-    ) => (self: ClientRequest.ClientRequest) => Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>,
-    (self: ClientRequest.ClientRequest, body: A) => Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>
+    ) => (self: ClientRequest.ClientRequest) => Effect.Effect<R, Body.BodyError, ClientRequest.ClientRequest>,
+    (self: ClientRequest.ClientRequest, body: A) => Effect.Effect<R, Body.BodyError, ClientRequest.ClientRequest>
   >(2, (self, body) => Effect.map(encode(body), (body) => setBody(self, body)))
 }
 

package/src/internal/http/clientResponse.ts

@@ -133,15 +133,16 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
 
 /** @internal */
 export const schemaJson = <
+  R,
   I extends {
     readonly status?: number
     readonly headers?: Readonly<Record<string, string>>
     readonly body?: unknown
   },
   A
->(schema: Schema.Schema<I, A>) => {
-  const parse = Schema.parse(schema)
-  return (self: ClientResponse.ClientResponse): Effect.Effect<never, Error.ResponseError | ParseResult.ParseError, A> =>
+>(schema: Schema.Schema<R, I, A>) => {
+  const parse = Schema.decodeUnknown(schema)
+  return (self: ClientResponse.ClientResponse): Effect.Effect<R, Error.ResponseError | ParseResult.ParseError, A> =>
     Effect.flatMap(
       self.json,
       (body) =>
@@ -155,14 +156,15 @@ export const schemaJson = <
 
 /** @internal */
 export const schemaNoBody = <
+  R,
   I extends {
     readonly status?: number
     readonly headers?: Readonly<Record<string, string>>
   },
   A
->(schema: Schema.Schema<I, A>) => {
-  const parse = Schema.parse(schema)
-  return (self: ClientResponse.ClientResponse): Effect.Effect<never, ParseResult.ParseError, A> =>
+>(schema: Schema.Schema<R, I, A>) => {
+  const parse = Schema.decodeUnknown(schema)
+  return (self: ClientResponse.ClientResponse): Effect.Effect<R, ParseResult.ParseError, A> =>
     parse({
       status: self.status,
       headers: self.headers

package/src/internal/http/multipart.ts

@@ -89,7 +89,7 @@ export const withFieldMimeTypes = dual<
   <R, E, A>(effect: Effect.Effect<R, E, A>, mimeTypes: ReadonlyArray<string>) => Effect.Effect<R, E, A>
 >(2, (effect, mimeTypes) => Effect.locally(effect, fieldMimeTypes, Chunk.fromIterable(mimeTypes)))
 
-const fileSchema: Schema.Schema<Multipart.PersistedFile, Multipart.PersistedFile> = Schema.struct({
+const fileSchema: Schema.Schema<never, Multipart.PersistedFile, Multipart.PersistedFile> = Schema.struct({
   [TypeId]: Schema.uniqueSymbol(TypeId),
   _tag: Schema.literal("PersistedFile"),
   key: Schema.string,
@@ -100,27 +100,28 @@ const fileSchema: Schema.Schema<Multipart.PersistedFile, Multipart.PersistedFile
 
 /** @internal */
 export const filesSchema: Schema.Schema<
+  never,
   ReadonlyArray<Multipart.PersistedFile>,
   ReadonlyArray<Multipart.PersistedFile>
 > = Schema.array(fileSchema)
 
 /** @internal */
-export const schemaPersisted = <I extends Multipart.Persisted, A>(
-  schema: Schema.Schema<I, A>
+export const schemaPersisted = <R, I extends Multipart.Persisted, A>(
+  schema: Schema.Schema<R, I, A>
 ) => {
-  const parse = Schema.parse(schema)
+  const parse = Schema.decodeUnknown(schema)
   return (persisted: Multipart.Persisted) => parse(persisted)
 }
 
 /** @internal */
-export const schemaJson = <I, A>(schema: Schema.Schema<I, A>): {
+export const schemaJson = <R, I, A>(schema: Schema.Schema<R, I, A>): {
   (
     field: string
-  ): (persisted: Multipart.Persisted) => Effect.Effect<never, ParseResult.ParseError, A>
+  ): (persisted: Multipart.Persisted) => Effect.Effect<R, ParseResult.ParseError, A>
   (
     persisted: Multipart.Persisted,
     field: string
-  ): Effect.Effect<never, ParseResult.ParseError, A>
+  ): Effect.Effect<R, ParseResult.ParseError, A>
 } => {
   const fromJson = Schema.parseJson(schema)
   return dual<
@@ -128,14 +129,14 @@ export const schemaJson = <I, A>(schema: Schema.Schema<I, A>): {
       field: string
     ) => (
       persisted: Multipart.Persisted
-    ) => Effect.Effect<never, ParseResult.ParseError, A>,
+    ) => Effect.Effect<R, ParseResult.ParseError, A>,
     (
       persisted: Multipart.Persisted,
       field: string
-    ) => Effect.Effect<never, ParseResult.ParseError, A>
+    ) => Effect.Effect<R, ParseResult.ParseError, A>
   >(2, (persisted, field) =>
     Effect.map(
-      Schema.parse(
+      Schema.decodeUnknown(
         Schema.struct({
           [field]: fromJson
         })

package/src/internal/http/router.ts

@@ -36,20 +36,22 @@ export const params = Effect.map(RouteContext, (_) => _.params)
 export const searchParams = Effect.map(RouteContext, (_) => _.searchParams)
 
 /** @internal */
-export const schemaParams = <I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<I, A>) => {
-  const parse = Schema.parse(schema)
+export const schemaParams = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<R, I, A>) => {
+  const parse = Schema.decodeUnknown(schema)
   return Effect.flatMap(RouteContext, (_) => parse({ ..._.searchParams, ..._.params }))
 }
 
 /** @internal */
-export const schemaPathParams = <I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<I, A>) => {
-  const parse = Schema.parse(schema)
+export const schemaPathParams = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<R, I, A>) => {
+  const parse = Schema.decodeUnknown(schema)
   return Effect.flatMap(RouteContext, (_) => parse(_.params))
 }
 
 /** @internal */
-export const schemaSearchParams = <I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<I, A>) => {
-  const parse = Schema.parse(schema)
+export const schemaSearchParams = <R, I extends Readonly<Record<string, string>>, A>(
+  schema: Schema.Schema<R, I, A>
+) => {
+  const parse = Schema.decodeUnknown(schema)
   return Effect.flatMap(RouteContext, (_) => parse(_.searchParams))
 }
 

package/src/internal/http/serverRequest.ts

@@ -25,13 +25,13 @@ export const serverRequestTag = Context.Tag<ServerRequest.ServerRequest>(TypeId)
 export const multipartPersisted = Effect.flatMap(serverRequestTag, (request) => request.multipart)
 
 /** @internal */
-export const schemaHeaders = <I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<I, A>) => {
+export const schemaHeaders = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<R, I, A>) => {
   const parse = IncomingMessage.schemaHeaders(schema)
   return Effect.flatMap(serverRequestTag, parse)
 }
 
 /** @internal */
-export const schemaBodyJson = <I, A>(schema: Schema.Schema<I, A>) => {
+export const schemaBodyJson = <R, I, A>(schema: Schema.Schema<R, I, A>) => {
   const parse = IncomingMessage.schemaBodyJson(schema)
   return Effect.flatMap(serverRequestTag, parse)
 }
@@ -40,13 +40,13 @@ const isMultipart = (request: ServerRequest.ServerRequest) =>
   request.headers["content-type"]?.toLowerCase().includes("multipart/form-data")
 
 /** @internal */
-export const schemaBodyForm = <I extends Multipart.Persisted, A>(
-  schema: Schema.Schema<I, A>
+export const schemaBodyForm = <R, I extends Multipart.Persisted, A>(
+  schema: Schema.Schema<R, I, A>
 ) => {
   const parseMultipart = Multipart.schemaPersisted(schema)
-  const parseUrlParams = IncomingMessage.schemaBodyUrlParams(schema as Schema.Schema<any, A>)
+  const parseUrlParams = IncomingMessage.schemaBodyUrlParams(schema as Schema.Schema<R, any, A>)
   return Effect.flatMap(serverRequestTag, (request): Effect.Effect<
-    ServerRequest.ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path,
+    R | ServerRequest.ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path,
     Multipart.MultipartError | ParseResult.ParseError | Error.RequestError,
     A
   > => {
@@ -58,21 +58,23 @@ export const schemaBodyForm = <I extends Multipart.Persisted, A>(
 }
 
 /** @internal */
-export const schemaBodyUrlParams = <I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<I, A>) => {
+export const schemaBodyUrlParams = <R, I extends Readonly<Record<string, string>>, A>(
+  schema: Schema.Schema<R, I, A>
+) => {
   const parse = IncomingMessage.schemaBodyUrlParams(schema)
   return Effect.flatMap(serverRequestTag, parse)
 }
 
 /** @internal */
-export const schemaBodyMultipart = <I extends Multipart.Persisted, A>(
-  schema: Schema.Schema<I, A>
+export const schemaBodyMultipart = <R, I extends Multipart.Persisted, A>(
+  schema: Schema.Schema<R, I, A>
 ) => {
   const parse = Multipart.schemaPersisted(schema)
   return Effect.flatMap(multipartPersisted, parse)
 }
 
 /** @internal */
-export const schemaBodyFormJson = <I, A>(schema: Schema.Schema<I, A>) => {
+export const schemaBodyFormJson = <R, I, A>(schema: Schema.Schema<R, I, A>) => {
   const parseMultipart = Multipart.schemaJson(schema)
   const parseUrlParams = UrlParams.schemaJson(schema)
   return (field: string) =>
@@ -81,7 +83,7 @@ export const schemaBodyFormJson = <I, A>(schema: Schema.Schema<I, A>) => {
       (
         request
       ): Effect.Effect<
-        FileSystem.FileSystem | Path.Path | Scope.Scope | ServerRequest.ServerRequest,
+        R | FileSystem.FileSystem | Path.Path | Scope.Scope | ServerRequest.ServerRequest,
         ParseResult.ParseError | Error.RequestError,
         A
       > => {

package/src/internal/http/serverResponse.ts

@@ -117,14 +117,14 @@ export const unsafeJson = (
   )
 
 /** @internal */
-export const schemaJson = <I, A>(
-  schema: Schema.Schema<I, A>
+export const schemaJson = <R, I, A>(
+  schema: Schema.Schema<R, I, A>
 ) => {
   const encode = internalBody.jsonSchema(schema)
   return (
     body: A,
     options?: ServerResponse.Options.WithContent
-  ): Effect.Effect<never, Body.BodyError, ServerResponse.ServerResponse> =>
+  ): Effect.Effect<R, Body.BodyError, ServerResponse.ServerResponse> =>
     Effect.map(encode(body), (body) =>
       new ServerResponseImpl(
         options?.status ?? 200,

package/src/internal/keyValueStore.ts

@@ -68,12 +68,12 @@ export const SchemaStoreTypeId: KeyValueStore.SchemaStoreTypeId = Symbol.for(
 ) as KeyValueStore.SchemaStoreTypeId
 
 /** @internal */
-const makeSchemaStore = <I, A>(
+const makeSchemaStore = <R, I, A>(
   store: KeyValueStore.KeyValueStore,
-  schema: Schema.Schema<I, A>
-): KeyValueStore.SchemaStore<A> => {
+  schema: Schema.Schema<R, I, A>
+): KeyValueStore.SchemaStore<R, A> => {
   const jsonSchema = Schema.parseJson(schema)
-  const parse = Schema.parse(jsonSchema)
+  const parse = Schema.decodeUnknown(jsonSchema)
   const encode = Schema.encode(jsonSchema)
 
   const get = (key: string) =>
@@ -166,11 +166,11 @@ export const layerFileSystem = (directory: string) =>
   )
 
 /** @internal */
-export const layerSchema = <I, A>(
-  schema: Schema.Schema<I, A>,
+export const layerSchema = <R, I, A>(
+  schema: Schema.Schema<R, I, A>,
   tagIdentifier?: unknown
 ) => {
-  const tag = Context.Tag<KeyValueStore.SchemaStore<A>>(tagIdentifier)
+  const tag = Context.Tag<KeyValueStore.SchemaStore<R, A>>(tagIdentifier)
   const layer = Layer.effect(tag, Effect.map(keyValueStoreTag, (store) => store.forSchema(schema)))
   return { tag, layer } as const
 }

package/src/internal/workerRunner.ts

@@ -163,13 +163,15 @@ export const layer = <I, R, E, O>(
 
 /** @internal */
 export const makeSerialized = <
+  R,
   I,
   A extends Schema.TaggedRequest.Any,
   const Handlers extends WorkerRunner.SerializedRunner.Handlers<A>
 >(
-  schema: Schema.Schema<I, A>,
+  schema: Schema.Schema<R, I, A>,
   handlers: Handlers
 ): Effect.Effect<
+  | R
   | WorkerRunner.PlatformRunner
   | Scope.Scope
   | WorkerRunner.SerializedRunner.HandlersContext<Handlers>,
@@ -179,7 +181,7 @@ export const makeSerialized = <
   Effect.gen(function*(_) {
     const scope = yield* _(Effect.scope)
     let context = Context.empty() as Context.Context<any>
-    const parseRequest = Schema.parse(schema)
+    const parseRequest = Schema.decodeUnknown(schema) as (_: unknown) => Effect.Effect<never, never, A>
 
     return yield* _(make((request: A) => {
       const result = (handlers as any)[request._tag](request)
@@ -219,13 +221,15 @@ export const makeSerialized = <
 
 /** @internal */
 export const layerSerialized = <
+  R,
   I,
   A extends Schema.TaggedRequest.Any,
   const Handlers extends WorkerRunner.SerializedRunner.Handlers<A>
 >(
-  schema: Schema.Schema<I, A>,
+  schema: Schema.Schema<R, I, A>,
   handlers: Handlers
 ): Layer.Layer<
+  | R
   | WorkerRunner.PlatformRunner
   | WorkerRunner.SerializedRunner.HandlersContext<Handlers>,
   WorkerError.WorkerError,