@effect/platform 0.48.29 → 0.49.1

package/src/internal/http/clientResponse.ts

@@ -217,7 +217,7 @@ export const stream = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse
   Stream.unwrapScoped(Effect.map(effect, (_) => _.stream))
 
 /** @internal */
-export const schemaJsonEffect = <
+export const schemaJsonScoped = <
   R,
   I extends {
     readonly status?: number | undefined
@@ -232,7 +232,7 @@ export const schemaJsonEffect = <
 }
 
 /** @internal */
-export const schemaNoBodyEffect = <
+export const schemaNoBodyScoped = <
   R,
   I extends {
     readonly status?: number | undefined

package/src/internal/http/middleware.ts

@@ -4,6 +4,7 @@ import * as Effect from "effect/Effect"
 import * as FiberRef from "effect/FiberRef"
 import { constFalse, dual } from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
+import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import type * as Predicate from "effect/Predicate"
 import * as Headers from "../../Http/Headers.js"
@@ -36,6 +37,17 @@ export const currentTracerDisabledWhen = globalValue(
 
 /** @internal */
 export const withTracerDisabledWhen = dual<
+  (
+    predicate: Predicate.Predicate<ServerRequest.ServerRequest>
+  ) => <R, E, A>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
+  <R, E, A>(
+    layer: Layer.Layer<A, E, R>,
+    predicate: Predicate.Predicate<ServerRequest.ServerRequest>
+  ) => Layer.Layer<A, E, R>
+>(2, (self, pred) => Layer.locally(self, currentTracerDisabledWhen, pred))
+
+/** @internal */
+export const withTracerDisabledWhenEffect = dual<
   (
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
   ) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
@@ -45,6 +57,17 @@ export const withTracerDisabledWhen = dual<
   ) => Effect.Effect<A, E, R>
 >(2, (self, pred) => Effect.locally(self, currentTracerDisabledWhen, pred))
 
+/** @internal */
+export const withTracerDisabledForUrls = dual<
+  (
+    urls: ReadonlyArray<string>
+  ) => <R, E, A>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
+  <R, E, A>(
+    layer: Layer.Layer<A, E, R>,
+    urls: ReadonlyArray<string>
+  ) => Layer.Layer<A, E, R>
+>(2, (self, urls) => Layer.locally(self, currentTracerDisabledWhen, (req) => urls.includes(req.url)))
+
 /** @internal */
 export const logger = make((httpApp) => {
   let counter = 0
@@ -54,7 +77,7 @@ export const logger = make((httpApp) => {
     return Effect.withLogSpan(
       Effect.onExit(httpApp, (exit) => {
         if (fiber.getFiberRef(loggerDisabled)) {
-          return Effect.unit
+          return Effect.void
         }
         return exit._tag === "Failure" ?
           Effect.annotateLogs(Effect.log(exit.cause), {

package/src/internal/http/multipart.ts

@@ -214,7 +214,7 @@ const makeFromQueue = <IE>(
     let partsFinished = false
 
     const input: AsyncInput.AsyncInputProducer<IE, Chunk.Chunk<Uint8Array>, unknown> = {
-      awaitRead: () => Effect.unit,
+      awaitRead: () => Effect.void,
       emit(element) {
         return Queue.offer(queue, element)
       },
@@ -238,7 +238,7 @@ const makeFromQueue = <IE>(
         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)
+              return finished ? Channel.void : Channel.zipRight(pump, take)
             }
             const chunk = Chunk.unsafeFromArray(chunks)
             chunks = []
@@ -282,7 +282,7 @@ const makeFromQueue = <IE>(
       pump,
       Channel.suspend(() => {
         if (partsBuffer.length === 0) {
-          return Channel.unit
+          return Channel.void
         }
         const parts = Chunk.unsafeFromArray(partsBuffer)
         partsBuffer = []
@@ -301,7 +301,7 @@ const makeFromQueue = <IE>(
       if (error._tag === "Some") {
         return Channel.failCause(error.value)
       } else if (partsFinished) {
-        return Channel.unit
+        return Channel.void
       }
       return Channel.zipRight(takeParts, partsChannel)
     })

package/src/internal/http/multiplex.ts

@@ -1,8 +1,8 @@
+import * as Arr from "effect/Array"
 import * as Effect from "effect/Effect"
 import * as Effectable from "effect/Effectable"
 import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
-import * as ReadonlyArray from "effect/ReadonlyArray"
 import type * as App from "../../Http/App.js"
 import type * as Multiplex from "../../Http/Multiplex.js"
 import * as Error from "../../Http/ServerError.js"
@@ -12,9 +12,9 @@ import type * as ServerResponse from "../../Http/ServerResponse.js"
 /** @internal */
 export const TypeId: Multiplex.TypeId = Symbol.for("@effect/platform/Http/Multiplex") as Multiplex.TypeId
 
-class MultiplexImpl<R, E>
+class MultiplexImpl<E = never, R = never>
   extends Effectable.Class<ServerResponse.ServerResponse, E | Error.RouteNotFound, R | ServerRequest.ServerRequest>
-  implements Multiplex.Multiplex<R, E>
+  implements Multiplex.Multiplex<E, R>
 {
   readonly [TypeId]: Multiplex.TypeId
 
@@ -22,14 +22,14 @@ class MultiplexImpl<R, E>
     readonly apps: ReadonlyArray<
       readonly [
         predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>,
-        app: App.Default<R, E>
+        app: App.Default<E, R>
       ]
     >
   ) {
     super()
     this[TypeId] = TypeId
 
-    let execute: (request: ServerRequest.ServerRequest) => App.Default<R, E | Error.RouteNotFound> = (request) =>
+    let execute: (request: ServerRequest.ServerRequest) => App.Default<E | Error.RouteNotFound, R> = (request) =>
       Effect.fail(new Error.RouteNotFound({ request }))
 
     for (let i = apps.length - 1; i >= 0; i--) {
@@ -45,7 +45,7 @@ class MultiplexImpl<R, E>
     this.execute = Effect.flatMap(ServerRequest.ServerRequest, execute)
   }
 
-  execute: App.Default<R, E | Error.RouteNotFound>
+  execute: App.Default<E | Error.RouteNotFound, R>
 
   commit() {
     return this.execute
@@ -65,26 +65,26 @@ class MultiplexImpl<R, E>
 }
 
 /** @internal */
-export const empty: Multiplex.Multiplex<never, never> = new MultiplexImpl([])
+export const empty: Multiplex.Multiplex<never> = new MultiplexImpl([])
 
 /** @internal */
 export const make = <R, E>(
   apps: Iterable<
-    readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>, app: App.Default<R, E>]
+    readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>, app: App.Default<E, R>]
   >
-): Multiplex.Multiplex<R, E> => new MultiplexImpl(ReadonlyArray.fromIterable(apps))
+): Multiplex.Multiplex<E, R> => new MultiplexImpl(Arr.fromIterable(apps))
 
 /** @internal */
 export const add = dual<
   <R2, E2, R3, E3>(
     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>,
+    app: App.Default<E3, R3>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2 | E3, R | R2 | R3>,
   <R, E, R2, E2, R3, E3>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
-    app: App.Default<R3, E3>
-  ) => Multiplex.Multiplex<R | R2 | R3, E | E2 | E3>
+    app: App.Default<E3, R3>
+  ) => Multiplex.Multiplex<E | E2 | E3, R | R2 | R3>
 >(
   3,
   (self, predicate, app) =>
@@ -99,14 +99,14 @@ export const headerExact = dual<
   <R2, E2>(
     header: string,
     value: string,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     header: string,
     value: string,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(
   4,
   (self, header, value, app) =>
@@ -121,14 +121,14 @@ export const headerRegex = dual<
   <R2, E2>(
     header: string,
     regex: RegExp,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     header: string,
     regex: RegExp,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(
   4,
   (self, header, regex, app) =>
@@ -143,14 +143,14 @@ export const headerStartsWith = dual<
   <R2, E2>(
     header: string,
     prefix: string,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     header: string,
     prefix: string,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(
   4,
   (self, header, prefix, app) =>
@@ -165,14 +165,14 @@ export const headerEndsWith = dual<
   <R2, E2>(
     header: string,
     suffix: string,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     header: string,
     suffix: string,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(
   4,
   (self, header, suffix, app) =>
@@ -186,50 +186,50 @@ export const headerEndsWith = dual<
 export const hostRegex = dual<
   <R2, E2>(
     regex: RegExp,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     regex: RegExp,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(3, (self, regex, app) => headerRegex(self, "host", regex, app))
 
 /** @internal */
 export const hostStartsWith = dual<
   <R2, E2>(
     prefix: string,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     prefix: string,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(3, (self, prefix, app) => headerStartsWith(self, "host", prefix, app))
 
 /** @internal */
 export const hostEndsWith = dual<
   <R2, E2>(
     suffix: string,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     suffix: string,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(3, (self, suffix, app) => headerEndsWith(self, "host", suffix, app))
 
 /** @internal */
 export const hostExact = dual<
   <R2, E2>(
     host: string,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     host: string,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(3, (self, host, app) => headerExact(self, "host", host, app))