@effect/platform 0.43.11 → 0.44.0

package/src/internal/http/multipart.ts

@@ -49,8 +49,8 @@ export const maxParts: FiberRef.FiberRef<Option.Option<number>> = globalValue(
 
 /** @internal */
 export const withMaxParts = dual<
-  (count: Option.Option<number>) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(effect: Effect.Effect<R, E, A>, count: Option.Option<number>) => Effect.Effect<R, E, A>
+  (count: Option.Option<number>) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <R, E, A>(effect: Effect.Effect<A, E, R>, count: Option.Option<number>) => Effect.Effect<A, E, R>
 >(2, (effect, count) => Effect.locally(effect, maxParts, count))
 
 /** @internal */
@@ -61,8 +61,8 @@ export const maxFieldSize: FiberRef.FiberRef<FileSystem.Size> = globalValue(
 
 /** @internal */
 export const withMaxFieldSize = dual<
-  (size: FileSystem.SizeInput) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(effect: Effect.Effect<R, E, A>, size: FileSystem.SizeInput) => Effect.Effect<R, E, A>
+  (size: FileSystem.SizeInput) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <R, E, A>(effect: Effect.Effect<A, E, R>, size: FileSystem.SizeInput) => Effect.Effect<A, E, R>
 >(2, (effect, size) => Effect.locally(effect, maxFieldSize, FileSystem.Size(size)))
 
 /** @internal */
@@ -73,8 +73,8 @@ export const maxFileSize: FiberRef.FiberRef<Option.Option<FileSystem.Size>> = gl
 
 /** @internal */
 export const withMaxFileSize = dual<
-  (size: Option.Option<FileSystem.SizeInput>) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(effect: Effect.Effect<R, E, A>, size: Option.Option<FileSystem.SizeInput>) => Effect.Effect<R, E, A>
+  (size: Option.Option<FileSystem.SizeInput>) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <R, E, A>(effect: Effect.Effect<A, E, R>, size: Option.Option<FileSystem.SizeInput>) => Effect.Effect<A, E, R>
 >(2, (effect, size) => Effect.locally(effect, maxFileSize, Option.map(size, FileSystem.Size)))
 
 /** @internal */
@@ -85,11 +85,11 @@ export const fieldMimeTypes: FiberRef.FiberRef<Chunk.Chunk<string>> = globalValu
 
 /** @internal */
 export const withFieldMimeTypes = dual<
-  (mimeTypes: ReadonlyArray<string>) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(effect: Effect.Effect<R, E, A>, mimeTypes: ReadonlyArray<string>) => Effect.Effect<R, E, A>
+  (mimeTypes: ReadonlyArray<string>) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <R, E, A>(effect: Effect.Effect<A, E, R>, mimeTypes: ReadonlyArray<string>) => Effect.Effect<A, E, R>
 >(2, (effect, mimeTypes) => Effect.locally(effect, fieldMimeTypes, Chunk.fromIterable(mimeTypes)))
 
-const fileSchema: Schema.Schema<never, Multipart.PersistedFile, Multipart.PersistedFile> = Schema.struct({
+const fileSchema: Schema.Schema<Multipart.PersistedFile> = Schema.struct({
   [TypeId]: Schema.uniqueSymbol(TypeId),
   _tag: Schema.literal("PersistedFile"),
   key: Schema.string,
@@ -99,29 +99,25 @@ const fileSchema: Schema.Schema<never, Multipart.PersistedFile, Multipart.Persis
 })
 
 /** @internal */
-export const filesSchema: Schema.Schema<
-  never,
-  ReadonlyArray<Multipart.PersistedFile>,
-  ReadonlyArray<Multipart.PersistedFile>
-> = Schema.array(fileSchema)
+export const filesSchema: Schema.Schema<ReadonlyArray<Multipart.PersistedFile>> = Schema.array(fileSchema)
 
 /** @internal */
 export const schemaPersisted = <R, I extends Multipart.Persisted, A>(
-  schema: Schema.Schema<R, I, A>
+  schema: Schema.Schema<A, I, R>
 ) => {
   const parse = Schema.decodeUnknown(schema)
   return (persisted: Multipart.Persisted) => parse(persisted)
 }
 
 /** @internal */
-export const schemaJson = <R, I, A>(schema: Schema.Schema<R, I, A>): {
+export const schemaJson = <A, I, R>(schema: Schema.Schema<A, I, R>): {
   (
     field: string
-  ): (persisted: Multipart.Persisted) => Effect.Effect<R, ParseResult.ParseError, A>
+  ): (persisted: Multipart.Persisted) => Effect.Effect<A, ParseResult.ParseError, R>
   (
     persisted: Multipart.Persisted,
     field: string
-  ): Effect.Effect<R, ParseResult.ParseError, A>
+  ): Effect.Effect<A, ParseResult.ParseError, R>
 } => {
   const fromJson = Schema.parseJson(schema)
   return dual<
@@ -129,11 +125,11 @@ export const schemaJson = <R, I, A>(schema: Schema.Schema<R, I, A>): {
       field: string
     ) => (
       persisted: Multipart.Persisted
-    ) => Effect.Effect<R, ParseResult.ParseError, A>,
+    ) => Effect.Effect<A, ParseResult.ParseError, R>,
     (
       persisted: Multipart.Persisted,
       field: string
-    ) => Effect.Effect<R, ParseResult.ParseError, A>
+    ) => Effect.Effect<A, ParseResult.ParseError, R>
   >(2, (persisted, field) =>
     Effect.map(
       Schema.decodeUnknown(
@@ -148,7 +144,7 @@ export const schemaJson = <R, I, A>(schema: Schema.Schema<R, I, A>): {
 /** @internal */
 export const makeConfig = (
   headers: Record<string, string>
-): Effect.Effect<never, never, MP.BaseConfig> =>
+): Effect.Effect<MP.BaseConfig> =>
   Effect.map(
     Effect.all({
       maxParts: Effect.map(FiberRef.get(maxParts), Option.getOrUndefined),
@@ -177,12 +173,11 @@ export const makeChannel = <IE>(
   headers: Record<string, string>,
   bufferSize = 16
 ): Channel.Channel<
-  never,
-  IE,
+  Chunk.Chunk<Multipart.Part>,
   Chunk.Chunk<Uint8Array>,
-  unknown,
   Multipart.MultipartError | IE,
-  Chunk.Chunk<Multipart.Part>,
+  IE,
+  unknown,
   unknown
 > =>
   Channel.acquireUseRelease(
@@ -198,12 +193,11 @@ const makeFromQueue = <IE>(
   config: MP.BaseConfig,
   queue: Queue.Queue<Chunk.Chunk<Uint8Array> | null>
 ): Channel.Channel<
-  never,
-  IE,
+  Chunk.Chunk<Multipart.Part>,
   Chunk.Chunk<Uint8Array>,
-  unknown,
   IE | Multipart.MultipartError,
-  Chunk.Chunk<Multipart.Part>,
+  IE,
+  unknown,
   unknown
 > =>
   Channel.suspend(() => {
@@ -233,7 +227,7 @@ const makeFromQueue = <IE>(
       onFile(info) {
         let chunks: Array<Uint8Array> = []
         let finished = false
-        const take: Channel.Channel<never, unknown, unknown, unknown, never, Chunk.Chunk<Uint8Array>, void> = Channel
+        const take: Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, never, unknown, void, unknown> = Channel
           .suspend(() => {
             if (chunks.length === 0) {
               return finished ? Channel.unit : Channel.zipRight(pump, take)
@@ -289,13 +283,12 @@ const makeFromQueue = <IE>(
     )
 
     const partsChannel: Channel.Channel<
-      never,
-      unknown,
-      unknown,
+      Chunk.Chunk<Multipart.Part>,
       unknown,
       IE | Multipart.MultipartError,
-      Chunk.Chunk<Multipart.Part>,
-      void
+      unknown,
+      void,
+      unknown
     > = Channel.suspend(() => {
       if (error._tag === "Some") {
         return Channel.failCause(error.value)
@@ -351,11 +344,11 @@ class FileImpl implements Multipart.File {
   readonly key: string
   readonly name: string
   readonly contentType: string
-  readonly content: Stream.Stream<never, Multipart.MultipartError, Uint8Array>
+  readonly content: Stream.Stream<Uint8Array, Multipart.MultipartError>
 
   constructor(
     info: MP.PartInfo,
-    channel: Channel.Channel<never, unknown, unknown, unknown, never, Chunk.Chunk<Uint8Array>, void>
+    channel: Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, never, unknown, void, unknown>
   ) {
     this[TypeId] = TypeId
     this.key = info.name
@@ -377,9 +370,9 @@ const defaultWriteFile = (path: string, file: Multipart.File) =>
 
 /** @internal */
 export const toPersisted = (
-  stream: Stream.Stream<never, Multipart.MultipartError, Multipart.Part>,
+  stream: Stream.Stream<Multipart.Part, Multipart.MultipartError>,
   writeFile = defaultWriteFile
-): Effect.Effect<FileSystem.FileSystem | Path.Path | Scope.Scope, Multipart.MultipartError, Multipart.Persisted> =>
+): Effect.Effect<Multipart.Persisted, Multipart.MultipartError, FileSystem.FileSystem | Path.Path | Scope.Scope> =>
   pipe(
     Effect.Do,
     Effect.bind("fs", () => FileSystem.FileSystem),

package/src/internal/http/multiplex.ts

@@ -12,7 +12,7 @@ import type * as ServerResponse from "../../Http/ServerResponse.js"
 export const TypeId: Multiplex.TypeId = Symbol.for("@effect/platform/Http/Multiplex") as Multiplex.TypeId
 
 class MultiplexImpl<R, E>
-  extends Effectable.Class<R | ServerRequest.ServerRequest, E | Error.RouteNotFound, ServerResponse.ServerResponse>
+  extends Effectable.Class<ServerResponse.ServerResponse, E | Error.RouteNotFound, R | ServerRequest.ServerRequest>
   implements Multiplex.Multiplex<R, E>
 {
   readonly [TypeId]: Multiplex.TypeId
@@ -20,7 +20,7 @@ class MultiplexImpl<R, E>
   constructor(
     readonly apps: ReadonlyArray<
       readonly [
-        predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R, E, boolean>,
+        predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>,
         app: App.Default<R, E>
       ]
     >
@@ -57,19 +57,19 @@ export const empty: Multiplex.Multiplex<never, never> = new MultiplexImpl([])
 /** @internal */
 export const make = <R, E>(
   apps: Iterable<
-    readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R, E, boolean>, app: App.Default<R, E>]
+    readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>, app: App.Default<R, E>]
   >
 ): Multiplex.Multiplex<R, E> => new MultiplexImpl(ReadonlyArray.fromIterable(apps))
 
 /** @internal */
 export const add = dual<
   <R2, E2, R3, E3>(
-    predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R2, E2, boolean>,
+    predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
     app: App.Default<R3, E3>
   ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2 | R3, E | E2 | E3>,
   <R, E, R2, E2, R3, E3>(
     self: Multiplex.Multiplex<R, E>,
-    predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R2, E2, boolean>,
+    predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
     app: App.Default<R3, E3>
   ) => Multiplex.Multiplex<R | R2 | R3, E | E2 | E3>
 >(

package/src/internal/http/platform.ts

@@ -12,7 +12,7 @@ import type * as ServerResponse from "../../Http/ServerResponse.js"
 export const TypeId: Platform.TypeId = Symbol.for("@effect/platform/Http/Platform") as Platform.TypeId
 
 /** @internal */
-export const tag = Context.Tag<Platform.Platform>(TypeId)
+export const tag = Context.GenericTag<Platform.Platform>("@effect/platform/Http/Platform")
 
 /** @internal */
 export const make = (impl: {
@@ -32,7 +32,7 @@ export const make = (impl: {
     headers: Headers.Headers,
     options?: FileSystem.StreamOptions
   ) => ServerResponse.ServerResponse
-}): Effect.Effect<FileSystem.FileSystem | Etag.Generator, never, Platform.Platform> =>
+}): Effect.Effect<Platform.Platform, never, FileSystem.FileSystem | Etag.Generator> =>
   Effect.gen(function*(_) {
     const fs = yield* _(FileSystem.FileSystem)
     const etagGen = yield* _(Etag.Generator)

package/src/internal/http/router.ts

@@ -27,7 +27,7 @@ export const RouteContextTypeId: Router.RouteContextTypeId = Symbol.for(
 ) as Router.RouteContextTypeId
 
 /** @internal */
-export const RouteContext = Context.Tag<Router.RouteContext>("@effect/platform/Http/Router/RouteContext")
+export const RouteContext = Context.GenericTag<Router.RouteContext>("@effect/platform/Http/Router/RouteContext")
 
 /** @internal */
 export const params = Effect.map(RouteContext, (_) => _.params)
@@ -36,29 +36,29 @@ 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<R, I, A>) => {
+export const schemaParams = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<A, I, R>) => {
   const parse = Schema.decodeUnknown(schema)
   return Effect.flatMap(RouteContext, (_) => parse({ ..._.searchParams, ..._.params }))
 }
 
 /** @internal */
-export const schemaPathParams = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<R, I, A>) => {
+export const schemaPathParams = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<A, I, R>) => {
   const parse = Schema.decodeUnknown(schema)
   return Effect.flatMap(RouteContext, (_) => parse(_.params))
 }
 
 /** @internal */
 export const schemaSearchParams = <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<R, I, A>
+  schema: Schema.Schema<A, I, R>
 ) => {
   const parse = Schema.decodeUnknown(schema)
   return Effect.flatMap(RouteContext, (_) => parse(_.searchParams))
 }
 
 class RouterImpl<R, E> extends Effectable.StructuralClass<
-  Exclude<R, Router.RouteContext>,
+  ServerResponse.ServerResponse,
   E | Error.RouteNotFound,
-  ServerResponse.ServerResponse
+  Exclude<R, Router.RouteContext>
 > implements Router.Router<R, E> {
   readonly [TypeId]: Router.TypeId
   constructor(
@@ -70,9 +70,9 @@ class RouterImpl<R, E> extends Effectable.StructuralClass<
     this.httpApp = toHttpApp(this) as any
   }
   private httpApp: Effect.Effect<
-    Exclude<R, Router.RouteContext>,
+    ServerResponse.ServerResponse,
     E | Error.RouteNotFound,
-    ServerResponse.ServerResponse
+    Exclude<R, Router.RouteContext>
   >
   commit() {
     return this.httpApp
@@ -134,7 +134,7 @@ const toHttpApp = <R, E>(
         request = sliceRequestUrl(request, route.prefix.value)
       }
       return Effect.mapInputContext(
-        route.handler as Effect.Effect<Router.Router.ExcludeProvided<R>, E, ServerResponse.ServerResponse>,
+        route.handler as Effect.Effect<ServerResponse.ServerResponse, E, Router.Router.ExcludeProvided<R>>,
         (context) =>
           Context.add(
             Context.add(context, ServerRequest.ServerRequest, request),
@@ -387,7 +387,7 @@ export const catchTags: {
     Router.Router.ExcludeProvided<
       | R
       | {
-        [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<infer R, any, any>) ? R : never
+        [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, any, infer R>) ? R : never
       }[keyof Cases]
     >,
     | Exclude<E, { _tag: keyof Cases }>
@@ -409,7 +409,7 @@ export const catchTags: {
     Router.Router.ExcludeProvided<
       | R
       | {
-        [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<infer R, any, any>) ? R : never
+        [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, any, infer R>) ? R : never
       }[keyof Cases]
     >,
     | Exclude<E, { _tag: keyof Cases }>
@@ -442,7 +442,7 @@ export const provideService = dual<
 export const provideServiceEffect = dual<
   <T extends Context.Tag<any, any>, R1, E1>(
     tag: T,
-    effect: Effect.Effect<R1, E1, Context.Tag.Service<T>>
+    effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
   ) => <R, E>(
     self: Router.Router<R, E>
   ) => Router.Router<
@@ -452,7 +452,7 @@ export const provideServiceEffect = dual<
   <R, E, T extends Context.Tag<any, any>, R1, E1>(
     self: Router.Router<R, E>,
     tag: T,
-    effect: Effect.Effect<R1, E1, Context.Tag.Service<T>>
+    effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
   ) => Router.Router<
     Router.Router.ExcludeProvided<R1 | Exclude<R, Context.Tag.Identifier<T>>>,
     E | E1
@@ -460,5 +460,5 @@ export const provideServiceEffect = dual<
 >(3, <R, E, T extends Context.Tag<any, any>, R1, E1>(
   self: Router.Router<R, E>,
   tag: T,
-  effect: Effect.Effect<R1, E1, Context.Tag.Service<T>>
+  effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
 ) => use(self, Effect.provideServiceEffect(tag, effect)))

package/src/internal/http/server.ts

@@ -12,7 +12,7 @@ import type * as ServerRequest from "../../Http/ServerRequest.js"
 export const TypeId: Server.TypeId = Symbol.for("@effect/platform/Http/Server") as Server.TypeId
 
 /** @internal */
-export const serverTag = Context.Tag<Server.Server>(TypeId)
+export const serverTag = Context.GenericTag<Server.Server>("@effect/platform/Http/Server")
 
 const serverProto = {
   [TypeId]: TypeId
@@ -27,7 +27,7 @@ export const make = (
     readonly serve: (
       httpApp: App.Default<never, unknown>,
       middleware?: Middleware.Middleware
-    ) => Effect.Effect<Scope.Scope, never, void>
+    ) => Effect.Effect<void, never, Scope.Scope>
     readonly address: Server.Address
   }
 ): Server.Server => Object.assign(Object.create(serverProto), options)
@@ -37,30 +37,26 @@ export const serve = dual<
   {
     (): <R, E>(
       httpApp: App.Default<R, E>
-    ) => Layer.Layer<
-      Server.Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>,
-      never,
-      never
-    >
+    ) => Layer.Layer<never, never, Server.Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>>
     <R, E, App extends App.Default<any, any>>(middleware: Middleware.Middleware.Applied<R, E, App>): (
       httpApp: App.Default<R, E>
     ) => Layer.Layer<
-      Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>,
       never,
-      never
+      never,
+      Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>
     >
   },
   {
     <R, E>(
       httpApp: App.Default<R, E>
-    ): Layer.Layer<Server.Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>, never, never>
+    ): Layer.Layer<never, never, Server.Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>>
     <R, E, App extends App.Default<any, any>>(
       httpApp: App.Default<R, E>,
       middleware: Middleware.Middleware.Applied<R, E, App>
     ): Layer.Layer<
-      Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>,
       never,
-      never
+      never,
+      Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>
     >
   }
 >(
@@ -69,9 +65,9 @@ export const serve = dual<
     httpApp: App.Default<R, E>,
     middleware?: Middleware.Middleware.Applied<R, E, App>
   ): Layer.Layer<
-    Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>,
     never,
-    never
+    never,
+    Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>
   > =>
     Layer.scopedDiscard(
       Effect.flatMap(
@@ -87,29 +83,29 @@ export const serveEffect = dual<
     (): <R, E>(
       httpApp: App.Default<R, E>
     ) => Effect.Effect<
-      Server.Server | Scope.Scope | Exclude<R, ServerRequest.ServerRequest>,
+      void,
       never,
-      void
+      Server.Server | Scope.Scope | Exclude<R, ServerRequest.ServerRequest>
     >
     <R, E, App extends App.Default<any, any>>(middleware: Middleware.Middleware.Applied<R, E, App>): (
       httpApp: App.Default<R, E>
     ) => Effect.Effect<
-      Server.Server | Scope.Scope | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
+      void,
       never,
-      void
+      Server.Server | Scope.Scope | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>
     >
   },
   {
     <R, E>(
       httpApp: App.Default<R, E>
-    ): Effect.Effect<Server.Server | Scope.Scope | Exclude<R, ServerRequest.ServerRequest>, never, void>
+    ): Effect.Effect<void, never, Server.Server | Scope.Scope | Exclude<R, ServerRequest.ServerRequest>>
     <R, E, App extends App.Default<any, any>>(
       httpApp: App.Default<R, E>,
       middleware: Middleware.Middleware.Applied<R, E, App>
     ): Effect.Effect<
-      Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest> | Scope.Scope,
+      void,
       never,
-      void
+      Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest> | Scope.Scope
     >
   }
 >(
@@ -118,12 +114,53 @@ export const serveEffect = dual<
     httpApp: App.Default<R, E>,
     middleware: Middleware.Middleware.Applied<R, E, App>
   ): Effect.Effect<
-    Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest> | Scope.Scope,
+    void,
     never,
-    void
+    Server.Server | Exclude<R, ServerRequest.ServerRequest> | Scope.Scope
   > =>
     Effect.flatMap(
       serverTag,
       (server) => server.serve(httpApp, middleware)
     )) as any
 )
+
+/** @internal */
+export const formatAddress = (address: Server.Address): string => {
+  switch (address._tag) {
+    case "UnixAddress":
+      return `unix://${address.path}`
+    case "TcpAddress":
+      return `http://${address.hostname}:${address.port}`
+  }
+}
+
+/** @internal */
+export const addressWith = <R, E, A>(
+  effect: (address: Server.Address) => Effect.Effect<A, E, R>
+): Effect.Effect<A, E, Server.Server | R> =>
+  Effect.flatMap(
+    serverTag,
+    (server) => effect(server.address)
+  )
+
+/** @internal */
+export const addressFormattedWith = <R, E, A>(
+  effect: (address: string) => Effect.Effect<A, E, R>
+): Effect.Effect<A, E, Server.Server | R> =>
+  Effect.flatMap(
+    serverTag,
+    (server) => effect(formatAddress(server.address))
+  )
+
+/** @internal */
+export const logAddress: Effect.Effect<void, never, Server.Server> = addressFormattedWith((_) =>
+  Effect.log(`Listening on ${_}`)
+)
+
+/** @internal */
+export const withLogAddress = <R, E, A>(
+  layer: Layer.Layer<A, E, R>
+): Layer.Layer<A, E, R | Exclude<Server.Server, A>> =>
+  Layer.effectDiscard(logAddress).pipe(
+    Layer.provideMerge(layer)
+  )

package/src/internal/http/serverRequest.ts

@@ -19,19 +19,19 @@ import type * as Path from "../../Path.js"
 export const TypeId: ServerRequest.TypeId = Symbol.for("@effect/platform/Http/ServerRequest") as ServerRequest.TypeId
 
 /** @internal */
-export const serverRequestTag = Context.Tag<ServerRequest.ServerRequest>(TypeId)
+export const serverRequestTag = Context.GenericTag<ServerRequest.ServerRequest>("@effect/platform/Http/ServerRequest")
 
 /** @internal */
 export const multipartPersisted = Effect.flatMap(serverRequestTag, (request) => request.multipart)
 
 /** @internal */
-export const schemaHeaders = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<R, I, A>) => {
+export const schemaHeaders = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<A, I, R>) => {
   const parse = IncomingMessage.schemaHeaders(schema)
   return Effect.flatMap(serverRequestTag, parse)
 }
 
 /** @internal */
-export const schemaBodyJson = <R, I, A>(schema: Schema.Schema<R, I, A>) => {
+export const schemaBodyJson = <A, I, R>(schema: Schema.Schema<A, I, R>) => {
   const parse = IncomingMessage.schemaBodyJson(schema)
   return Effect.flatMap(serverRequestTag, parse)
 }
@@ -41,14 +41,14 @@ const isMultipart = (request: ServerRequest.ServerRequest) =>
 
 /** @internal */
 export const schemaBodyForm = <R, I extends Multipart.Persisted, A>(
-  schema: Schema.Schema<R, I, A>
+  schema: Schema.Schema<A, I, R>
 ) => {
   const parseMultipart = Multipart.schemaPersisted(schema)
-  const parseUrlParams = IncomingMessage.schemaBodyUrlParams(schema as Schema.Schema<R, any, A>)
+  const parseUrlParams = IncomingMessage.schemaBodyUrlParams(schema as Schema.Schema<A, any, R>)
   return Effect.flatMap(serverRequestTag, (request): Effect.Effect<
-    R | ServerRequest.ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path,
+    A,
     Multipart.MultipartError | ParseResult.ParseError | Error.RequestError,
-    A
+    R | ServerRequest.ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path
   > => {
     if (isMultipart(request)) {
       return Effect.flatMap(request.multipart, parseMultipart)
@@ -59,7 +59,7 @@ export const schemaBodyForm = <R, I extends Multipart.Persisted, A>(
 
 /** @internal */
 export const schemaBodyUrlParams = <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<R, I, A>
+  schema: Schema.Schema<A, I, R>
 ) => {
   const parse = IncomingMessage.schemaBodyUrlParams(schema)
   return Effect.flatMap(serverRequestTag, parse)
@@ -67,14 +67,14 @@ export const schemaBodyUrlParams = <R, I extends Readonly<Record<string, string>
 
 /** @internal */
 export const schemaBodyMultipart = <R, I extends Multipart.Persisted, A>(
-  schema: Schema.Schema<R, I, A>
+  schema: Schema.Schema<A, I, R>
 ) => {
   const parse = Multipart.schemaPersisted(schema)
   return Effect.flatMap(multipartPersisted, parse)
 }
 
 /** @internal */
-export const schemaBodyFormJson = <R, I, A>(schema: Schema.Schema<R, I, A>) => {
+export const schemaBodyFormJson = <A, I, R>(schema: Schema.Schema<A, I, R>) => {
   const parseMultipart = Multipart.schemaJson(schema)
   const parseUrlParams = UrlParams.schemaJson(schema)
   return (field: string) =>
@@ -83,9 +83,9 @@ export const schemaBodyFormJson = <R, I, A>(schema: Schema.Schema<R, I, A>) => {
       (
         request
       ): Effect.Effect<
-        R | FileSystem.FileSystem | Path.Path | Scope.Scope | ServerRequest.ServerRequest,
+        A,
         ParseResult.ParseError | Error.RequestError,
-        A
+        R | FileSystem.FileSystem | Path.Path | Scope.Scope | ServerRequest.ServerRequest
       > => {
         if (isMultipart(request)) {
           return Effect.flatMap(
@@ -147,7 +147,7 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
     return this.headersOverride
   }
 
-  get stream(): Stream.Stream<never, Error.RequestError, Uint8Array> {
+  get stream(): Stream.Stream<Uint8Array, Error.RequestError> {
     return this.source.body
       ? Stream.fromReadableStream(() => this.source.body as any, (_) =>
         Error.RequestError({
@@ -162,8 +162,8 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
       }))
   }
 
-  private textEffect: Effect.Effect<never, Error.RequestError, string> | undefined
-  get text(): Effect.Effect<never, Error.RequestError, string> {
+  private textEffect: Effect.Effect<string, Error.RequestError> | undefined
+  get text(): Effect.Effect<string, Error.RequestError> {
     if (this.textEffect) {
       return this.textEffect
     }
@@ -181,7 +181,7 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
     return this.textEffect
   }
 
-  get json(): Effect.Effect<never, Error.RequestError, unknown> {
+  get json(): Effect.Effect<unknown, Error.RequestError> {
     return Effect.tryMap(this.text, {
       try: (_) => JSON.parse(_) as unknown,
       catch: (error) =>
@@ -193,7 +193,7 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
     })
   }
 
-  get urlParamsBody(): Effect.Effect<never, Error.RequestError, UrlParams.UrlParams> {
+  get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, Error.RequestError> {
     return Effect.flatMap(this.text, (_) =>
       Effect.try({
         try: () => UrlParams.fromInput(new URLSearchParams(_)),
@@ -208,15 +208,15 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
 
   private multipartEffect:
     | Effect.Effect<
-      Scope.Scope | FileSystem.FileSystem | Path.Path,
+      Multipart.Persisted,
       Multipart.MultipartError,
-      Multipart.Persisted
+      Scope.Scope | FileSystem.FileSystem | Path.Path
     >
     | undefined
   get multipart(): Effect.Effect<
-    Scope.Scope | FileSystem.FileSystem | Path.Path,
+    Multipart.Persisted,
     Multipart.MultipartError,
-    Multipart.Persisted
+    Scope.Scope | FileSystem.FileSystem | Path.Path
   > {
     if (this.multipartEffect) {
       return this.multipartEffect
@@ -227,15 +227,15 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
     return this.multipartEffect
   }
 
-  get multipartStream(): Stream.Stream<never, Multipart.MultipartError, Multipart.Part> {
+  get multipartStream(): Stream.Stream<Multipart.Part, Multipart.MultipartError> {
     return Stream.pipeThroughChannel(
       Stream.mapError(this.stream, (error) => Multipart.MultipartError("InternalError", error)),
       Multipart.makeChannel(this.headers)
     )
   }
 
-  private arrayBufferEffect: Effect.Effect<never, Error.RequestError, ArrayBuffer> | undefined
-  get arrayBuffer(): Effect.Effect<never, Error.RequestError, ArrayBuffer> {
+  private arrayBufferEffect: Effect.Effect<ArrayBuffer, Error.RequestError> | undefined
+  get arrayBuffer(): Effect.Effect<ArrayBuffer, Error.RequestError> {
     if (this.arrayBuffer) {
       return this.arrayBuffer
     }