@effect/platform 0.37.4 → 0.37.6

package/src/Http/UrlParams.ts

@@ -1,40 +1,38 @@
 /**
  * @since 1.0.0
  */
-import * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
+import * as ReadonlyArray from "effect/ReadonlyArray"
 
 /**
  * @since 1.0.0
  * @category models
  */
-export interface UrlParams extends Chunk.Chunk<[string, string]> {}
+export interface UrlParams extends ReadonlyArray<readonly [string, string]> {}
 
 /**
  * @since 1.0.0
  * @category models
  */
-export type Input = UrlParams | Readonly<Record<string, string>> | Iterable<readonly [string, string]> | URLSearchParams
+export type Input = Readonly<Record<string, string>> | Iterable<readonly [string, string]> | URLSearchParams
 
 /**
  * @since 1.0.0
  * @category constructors
  */
 export const fromInput = (input: Input): UrlParams => {
-  if (Chunk.isChunk(input)) {
-    return input
-  } else if (Symbol.iterator in input) {
-    return Chunk.fromIterable(input) as UrlParams
+  if (Symbol.iterator in input) {
+    return ReadonlyArray.fromIterable(input)
   }
-  return Chunk.fromIterable(Object.entries(input))
+  return ReadonlyArray.fromIterable(Object.entries(input))
 }
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const empty: UrlParams = Chunk.empty()
+export const empty: UrlParams = []
 
 /**
  * @since 1.0.0
@@ -47,8 +45,8 @@ export const set: {
   (key: string, value: string) => (self: UrlParams) => UrlParams,
   (self: UrlParams, key: string, value: string) => UrlParams
 >(3, (self, key, value) =>
-  Chunk.append(
-    Chunk.filter(self, ([k]) => k !== key),
+  ReadonlyArray.append(
+    ReadonlyArray.filter(self, ([k]) => k !== key),
     [key, value]
   ))
 
@@ -64,9 +62,9 @@ export const setAll: {
   (self: UrlParams, input: Input) => UrlParams
 >(2, (self, input) => {
   const toSet = fromInput(input)
-  const keys = Chunk.toReadonlyArray(toSet).map(([k]) => k)
-  return Chunk.appendAll(
-    Chunk.filter(self, ([k]) => keys.includes(k)),
+  const keys = toSet.map(([k]) => k)
+  return ReadonlyArray.appendAll(
+    ReadonlyArray.filter(self, ([k]) => keys.includes(k)),
     toSet
   )
 })
@@ -82,7 +80,7 @@ export const append: {
   (key: string, value: string) => (self: UrlParams) => UrlParams,
   (self: UrlParams, key: string, value: string) => UrlParams
 >(3, (self, key, value) =>
-  Chunk.append(
+  ReadonlyArray.append(
     self,
     [key, value]
   ))
@@ -98,7 +96,7 @@ export const appendAll: {
   (input: Input) => (self: UrlParams) => UrlParams,
   (self: UrlParams, input: Input) => UrlParams
 >(2, (self, input) =>
-  Chunk.appendAll(
+  ReadonlyArray.appendAll(
     self,
     fromInput(input)
   ))
@@ -113,13 +111,13 @@ export const remove: {
 } = dual<
   (key: string) => (self: UrlParams) => UrlParams,
   (self: UrlParams, key: string) => UrlParams
->(2, (self, key) => Chunk.filter(self, ([k]) => k !== key))
+>(2, (self, key) => ReadonlyArray.filter(self, ([k]) => k !== key))
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const toString = (self: UrlParams): string => new URLSearchParams(Chunk.toReadonlyArray(self) as any).toString()
+export const toString = (self: UrlParams): string => new URLSearchParams(self as any).toString()
 
 /**
  * @since 1.0.0
@@ -129,7 +127,7 @@ export const makeUrl = <E>(url: string, params: UrlParams, onError: (e: unknown)
   Effect.try({
     try: () => {
       const urlInstance = new URL(url, baseUrl())
-      Chunk.forEach(params, ([key, value]) => {
+      ReadonlyArray.forEach(params, ([key, value]) => {
         if (value !== undefined) {
           urlInstance.searchParams.append(key, value)
         }

package/src/WorkerRunner.ts

@@ -95,6 +95,43 @@ export const layer: <I, R, E, O>(
   options?: Runner.Options<I, E, O> | undefined
 ) => Layer.Layer<R | PlatformRunner, WorkerError, never> = internal.layer
 
+/**
+ * @since 1.0.0
+ * @category models
+ */
+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> ? (
+        _: S
+      ) =>
+        | Stream.Stream<any, E, O>
+        | Effect.Effect<any, E, O>
+        | Layer.Layer<any, E, any>
+        | Layer.Layer<any, E, never>
+      : never
+  }
+
+  /**
+   * @since 1.0.0
+   */
+  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
+      }[keyof Handlers],
+      {
+        [K in keyof Handlers]: ReturnType<Handlers[K]> extends Layer.Layer<infer _R, infer _E, infer A> ? A : never
+      }[keyof Handlers]
+    >
+    | {
+      [K in keyof Handlers]: ReturnType<Handlers[K]> extends Layer.Layer<infer R, infer _E, infer _A> ? R : never
+    }[keyof Handlers]
+}
+
 /**
  * @since 1.0.0
  * @category constructors
@@ -102,22 +139,12 @@ export const layer: <I, R, E, O>(
 export const makeSerialized: <
   I,
   A extends Schema.TaggedRequest.Any,
-  const Handlers extends {
-    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>
-      ? (_: S) => Stream.Stream<any, E, O> | Effect.Effect<any, E, O> :
-      never
-  }
+  const Handlers extends SerializedRunner.Handlers<A>
 >(
   schema: Schema.Schema<I, A>,
   handlers: Handlers
-) => Effect.Effect<
-  | PlatformRunner
-  | Scope.Scope
-  | (ReturnType<Handlers[keyof Handlers]> extends Stream.Stream<infer R, infer _E, infer _A> ? R : never),
-  WorkerError,
-  void
-> = internal.makeSerialized
+) => Effect.Effect<PlatformRunner | Scope.Scope | SerializedRunner.HandlersContext<Handlers>, WorkerError, void> =
+  internal.makeSerialized
 
 /**
  * @since 1.0.0
@@ -126,18 +153,9 @@ export const makeSerialized: <
 export const layerSerialized: <
   I,
   A extends Schema.TaggedRequest.Any,
-  const Handlers extends {
-    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>
-      ? (_: S) => Stream.Stream<any, E, O> | Effect.Effect<any, E, O> :
-      never
-  }
+  const Handlers extends SerializedRunner.Handlers<A>
 >(
   schema: Schema.Schema<I, A>,
   handlers: Handlers
-) => Layer.Layer<
-  | PlatformRunner
-  | (ReturnType<Handlers[keyof Handlers]> extends Stream.Stream<infer R, infer _E, infer _A> ? R : never),
-  WorkerError,
-  never
-> = internal.layerSerialized
+) => Layer.Layer<PlatformRunner | SerializedRunner.HandlersContext<Handlers>, WorkerError, never> =
+  internal.layerSerialized

package/src/internal/http/middleware.ts

@@ -1,3 +1,4 @@
+import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as FiberRef from "effect/FiberRef"
 import * as Function from "effect/Function"
@@ -59,7 +60,7 @@ export const logger = make((httpApp) => {
                 Effect.annotateLogs(Effect.log(exit.cause), {
                   "http.method": request.method,
                   "http.url": request.url,
-                  "http.status": 500
+                  "http.status": Cause.isInterruptedOnly(exit.cause) ? 499 : 500
                 }) :
                 Effect.annotateLogs(Effect.log(""), {
                   "http.method": request.method,

package/src/internal/http/platform.ts

@@ -4,6 +4,7 @@ import { pipe } from "effect/Function"
 import * as FileSystem from "../../FileSystem.js"
 import type * as Body from "../../Http/Body.js"
 import * as Etag from "../../Http/Etag.js"
+import * as Headers from "../../Http/Headers.js"
 import type * as Platform from "../../Http/Platform.js"
 import type * as ServerResponse from "../../Http/ServerResponse.js"
 
@@ -19,7 +20,7 @@ export const make = (impl: {
     path: string,
     status: number,
     statusText: string | undefined,
-    headers: Record<string, string>,
+    headers: Headers.Headers,
     start: number,
     end: number | undefined,
     contentLength: number
@@ -28,7 +29,7 @@ export const make = (impl: {
     file: Body.Body.FileLike,
     status: number,
     statusText: string | undefined,
-    headers: Record<string, string>,
+    headers: Headers.Headers,
     options?: FileSystem.StreamOptions
   ) => ServerResponse.ServerResponse
 }): Effect.Effect<FileSystem.FileSystem | Etag.Generator, never, Platform.Platform> =>
@@ -45,12 +46,9 @@ export const make = (impl: {
           Effect.map(({ etag, info }) => {
             const start = Number(options?.offset ?? 0)
             const end = options?.bytesToRead !== undefined ? start + Number(options.bytesToRead) : undefined
-            const headers: Record<string, string> = {
-              ...(options?.headers ?? {}),
-              etag: Etag.toString(etag)
-            }
+            const headers = Headers.set(options?.headers ?? Headers.empty, "etag", Etag.toString(etag))
             if (info.mtime._tag === "Some") {
-              headers["last-modified"] = info.mtime.value.toUTCString()
+              ;(headers as any)["last-modified"] = info.mtime.value.toUTCString()
             }
             const contentLength = end !== undefined ? end - start : Number(info.size) - start
             return impl.fileResponse(
@@ -67,11 +65,13 @@ export const make = (impl: {
       },
       fileWebResponse(file, options) {
         return Effect.map(etagGen.fromFileWeb(file), (etag) => {
-          const headers: Record<string, string> = {
-            ...(options?.headers ?? {}),
-            etag: Etag.toString(etag),
-            "last-modified": new Date(file.lastModified).toUTCString()
-          }
+          const headers = Headers.merge(
+            options?.headers ?? Headers.empty,
+            Headers.unsafeFromRecord({
+              etag: Etag.toString(etag),
+              "last-modified": new Date(file.lastModified).toUTCString()
+            })
+          )
           return impl.fileWebResponse(
             file,
             options?.status ?? 200,

package/src/internal/workerRunner.ts

@@ -142,64 +142,69 @@ export const layer = <I, R, E, O>(
 export const makeSerialized = <
   I,
   A extends Schema.TaggedRequest.Any,
-  const Handlers extends {
-    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>
-      ? (_: S) => Stream.Stream<any, E, O> | Effect.Effect<any, E, O> :
-      never
-  }
+  const Handlers extends WorkerRunner.SerializedRunner.Handlers<A>
 >(
   schema: Schema.Schema<I, A>,
   handlers: Handlers
 ): Effect.Effect<
   | WorkerRunner.PlatformRunner
   | Scope.Scope
-  | (ReturnType<Handlers[keyof Handlers]> extends Stream.Stream<infer R, infer _E, infer _A> ? R : never),
+  | WorkerRunner.SerializedRunner.HandlersContext<Handlers>,
   WorkerError.WorkerError,
   void
-> => {
-  const parseRequest = Schema.parse(schema)
-  return make((request: A) => (handlers as any)[request._tag](request), {
-    transfers(message) {
-      return Transferable.get(message)
-    },
-    decode(message) {
-      return Effect.mapError(
-        parseRequest(message),
-        (error) => WorkerError.WorkerError("decode", error)
-      )
-    },
-    encodeError(request, message) {
-      return Effect.mapError(
-        Serializable.serializeFailure(request as any, message),
-        (error) => WorkerError.WorkerError("encode", error)
-      )
-    },
-    encodeOutput(request, message) {
-      return Effect.mapError(
-        Serializable.serializeSuccess(request as any, message),
-        (error) => WorkerError.WorkerError("encode", error)
-      )
-    }
-  })
-}
+> =>
+  Effect.gen(function*(_) {
+    const scope = yield* _(Effect.scope)
+    let context = Context.empty() as Context.Context<any>
+    const parseRequest = Schema.parse(schema)
+
+    return yield* _(make((request: A) => {
+      const result = (handlers as any)[request._tag](request)
+      if (Layer.isLayer(result)) {
+        return Effect.flatMap(Layer.buildWithScope(result, scope), (_) =>
+          Effect.sync(() => {
+            context = Context.merge(context, _)
+          }))
+      } else if (Effect.isEffect(result)) {
+        return Effect.provide(result, context)
+      }
+      return Stream.provideContext(result as any, context)
+    }, {
+      transfers(message) {
+        return Transferable.get(message)
+      },
+      decode(message) {
+        return Effect.mapError(
+          parseRequest(message),
+          (error) => WorkerError.WorkerError("decode", error)
+        )
+      },
+      encodeError(request, message) {
+        return Effect.mapError(
+          Serializable.serializeFailure(request as any, message),
+          (error) => WorkerError.WorkerError("encode", error)
+        )
+      },
+      encodeOutput(request, message) {
+        return Effect.mapError(
+          Serializable.serializeSuccess(request as any, message),
+          (error) => WorkerError.WorkerError("encode", error)
+        )
+      }
+    }))
+  }) as any
 
 /** @internal */
 export const layerSerialized = <
   I,
   A extends Schema.TaggedRequest.Any,
-  const Handlers extends {
-    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>
-      ? (_: S) => Stream.Stream<any, E, O> | Effect.Effect<any, E, O> :
-      never
-  }
+  const Handlers extends WorkerRunner.SerializedRunner.Handlers<A>
 >(
   schema: Schema.Schema<I, A>,
   handlers: Handlers
 ): Layer.Layer<
   | WorkerRunner.PlatformRunner
-  | (ReturnType<Handlers[keyof Handlers]> extends Stream.Stream<infer R, infer _E, infer _A> ? R : never),
+  | WorkerRunner.SerializedRunner.HandlersContext<Handlers>,
   WorkerError.WorkerError,
   never
 > => Layer.scopedDiscard(makeSerialized(schema, handlers))