@effect/platform 0.87.1 → 0.87.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/platform",
-  "version": "0.87.1",
+  "version": "0.87.3",
   "description": "Unified interfaces for common platform-specific services",
   "license": "MIT",
   "repository": {
@@ -16,7 +16,7 @@
     "multipasta": "^0.2.5"
   },
   "peerDependencies": {
-    "effect": "^3.16.10"
+    "effect": "^3.16.11"
   },
   "publishConfig": {
     "provenance": true
@@ -171,6 +171,11 @@
       "import": "./dist/esm/HttpIncomingMessage.js",
       "default": "./dist/cjs/HttpIncomingMessage.js"
     },
+    "./HttpLayerRouter": {
+      "types": "./dist/dts/HttpLayerRouter.d.ts",
+      "import": "./dist/esm/HttpLayerRouter.js",
+      "default": "./dist/cjs/HttpLayerRouter.js"
+    },
     "./HttpMethod": {
       "types": "./dist/dts/HttpMethod.d.ts",
       "import": "./dist/esm/HttpMethod.js",
@@ -418,6 +423,9 @@
       "HttpIncomingMessage": [
         "./dist/dts/HttpIncomingMessage.d.ts"
       ],
+      "HttpLayerRouter": [
+        "./dist/dts/HttpLayerRouter.d.ts"
+      ],
       "HttpMethod": [
         "./dist/dts/HttpMethod.d.ts"
       ],

package/src/HttpApiBuilder.ts

@@ -123,6 +123,36 @@ export const httpApp: Effect.Effect<
   ) as any
 })
 
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const buildMiddleware: <Id extends string, Groups extends HttpApiGroup.HttpApiGroup.Any, E, R>(
+  api: HttpApi.HttpApi<Id, Groups, E, R>
+) => Effect.Effect<
+  (
+    effect: Effect.Effect<HttpServerResponse.HttpServerResponse, unknown>
+  ) => Effect.Effect<HttpServerResponse.HttpServerResponse, unknown, never>
+> = Effect.fnUntraced(
+  function*<Id extends string, Groups extends HttpApiGroup.HttpApiGroup.Any, E, R>(
+    api: HttpApi.HttpApi<Id, Groups, E, R>
+  ) {
+    const context = yield* Effect.context<never>()
+    const middlewareMap = makeMiddlewareMap(api.middlewares, context)
+    const errorSchema = makeErrorSchema(api as any)
+    const encodeError = Schema.encodeUnknown(errorSchema)
+    return (effect: Effect.Effect<HttpServerResponse.HttpServerResponse, unknown>) =>
+      Effect.catchAllCause(
+        applyMiddleware(middlewareMap, effect),
+        (cause) =>
+          Effect.matchEffect(Effect.provide(encodeError(Cause.squash(cause)), context), {
+            onFailure: () => Effect.failCause(cause),
+            onSuccess: Effect.succeed
+          })
+      )
+  }
+)
+
 /**
  * Construct an http web handler from an `HttpApi` instance.
  *

package/src/HttpApiScalar.ts

@@ -2,9 +2,11 @@
  * @since 1.0.0
  */
 import * as Effect from "effect/Effect"
-import type { Layer } from "effect/Layer"
+import * as Layer from "effect/Layer"
 import { Api } from "./HttpApi.js"
+import type * as HttpApi from "./HttpApi.js"
 import { Router } from "./HttpApiBuilder.js"
+import * as HttpLayerRouter from "./HttpLayerRouter.js"
 import * as HttpServerResponse from "./HttpServerResponse.js"
 import * as Html from "./internal/html.js"
 import * as internal from "./internal/httpApiScalar.js"
@@ -120,52 +122,45 @@ export type ScalarConfig = {
   defaultOpenAllTags?: boolean
 }
 
-/**
- * @since 1.0.0
- * @category layers
- */
-export const layer = (options?: {
-  readonly path?: `/${string}` | undefined
+const makeHandler = (options: {
+  readonly api: HttpApi.HttpApi.Any
   readonly source?: ScalarScriptSource
   readonly scalar?: ScalarConfig
-}): Layer<never, never, Api> =>
-  Router.use((router) =>
-    Effect.gen(function*() {
-      const { api } = yield* Api
-      const spec = OpenApi.fromApi(api)
+}) => {
+  const spec = OpenApi.fromApi(options.api as any)
 
-      const source = options?.source
-      const defaultScript = internal.javascript
-      const src: string | null = source
-        ? typeof source === "string"
-          ? source
-          : source.type === "cdn"
-          ? `https://cdn.jsdelivr.net/npm/@scalar/api-reference@${
-            source.version ?? "latest"
-          }/dist/browser/standalone.min.js`
-          : null
-        : null
+  const source = options?.source
+  const defaultScript = internal.javascript
+  const src: string | null = source
+    ? typeof source === "string"
+      ? source
+      : source.type === "cdn"
+      ? `https://cdn.jsdelivr.net/npm/@scalar/api-reference@${
+        source.version ?? "latest"
+      }/dist/browser/standalone.min.js`
+      : null
+    : null
 
-      const scalarConfig = {
-        _integration: "http",
-        ...options?.scalar
-      }
+  const scalarConfig = {
+    _integration: "http",
+    ...options?.scalar
+  }
 
-      const response = HttpServerResponse.html(`<!doctype html>
+  const response = HttpServerResponse.html(`<!doctype html>
 <html>
   <head>
     <meta charset="utf-8" />
     <title>${Html.escape(spec.info.title)}</title>
     ${
-        !spec.info.description
-          ? ""
-          : `<meta name="description" content="${Html.escape(spec.info.description)}"/>`
-      }
+    !spec.info.description
+      ? ""
+      : `<meta name="description" content="${Html.escape(spec.info.description)}"/>`
+  }
     ${
-        !spec.info.description
-          ? ""
-          : `<meta name="og:description" content="${Html.escape(spec.info.description)}"/>`
-      }
+    !spec.info.description
+      ? ""
+      : `<meta name="og:description" content="${Html.escape(spec.info.description)}"/>`
+  }
     <meta
       name="viewport"
       content="width=device-width, initial-scale=1" />
@@ -178,12 +173,55 @@ export const layer = (options?: {
       document.getElementById('api-reference').dataset.configuration = JSON.stringify(${Html.escapeJson(scalarConfig)})
     </script>
     ${
-        src
-          ? `<script src="${src}" crossorigin></script>`
-          : `<script>${defaultScript}</script>`
-      }
+    src
+      ? `<script src="${src}" crossorigin></script>`
+      : `<script>${defaultScript}</script>`
+  }
   </body>
 </html>`)
-      yield* router.get(options?.path ?? "/docs", Effect.succeed(response))
+
+  return Effect.succeed(response)
+}
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer = (options?: {
+  readonly path?: `/${string}` | undefined
+  readonly source?: ScalarScriptSource
+  readonly scalar?: ScalarConfig
+}): Layer.Layer<never, never, Api> =>
+  Router.use((router) =>
+    Effect.gen(function*() {
+      const { api } = yield* Api
+      const handler = makeHandler({ ...options, api })
+      yield* router.get(options?.path ?? "/docs", handler)
     })
   )
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerHttpLayerRouter: (
+  options: {
+    readonly api: HttpApi.HttpApi.Any
+    readonly path: `/${string}`
+    readonly source?: ScalarScriptSource
+    readonly scalar?: ScalarConfig
+  }
+) => Layer.Layer<
+  never,
+  never,
+  HttpLayerRouter.HttpRouter
+> = Effect.fnUntraced(function*(options: {
+  readonly api: HttpApi.HttpApi.Any
+  readonly path: `/${string}`
+  readonly source?: ScalarScriptSource
+  readonly scalar?: ScalarConfig
+}) {
+  const router = yield* HttpLayerRouter.HttpRouter
+  const handler = makeHandler(options)
+  yield* router.add("GET", options.path, handler)
+}, Layer.effectDiscard)

package/src/HttpApiSwagger.ts

@@ -2,30 +2,21 @@
  * @since 1.0.0
  */
 import * as Effect from "effect/Effect"
-import type { Layer } from "effect/Layer"
+import * as Layer from "effect/Layer"
 import { Api } from "./HttpApi.js"
+import type * as HttpApi from "./HttpApi.js"
 import { Router } from "./HttpApiBuilder.js"
+import * as HttpLayerRouter from "./HttpLayerRouter.js"
 import * as HttpServerResponse from "./HttpServerResponse.js"
 import * as Html from "./internal/html.js"
 import * as internal from "./internal/httpApiSwagger.js"
 import * as OpenApi from "./OpenApi.js"
 
-/**
- * Exported layer mounting Swagger/OpenAPI documentation UI.
- *
- * @param options.path  Optional mount path (default "/docs").
- *
- * @since 1.0.0
- * @category layers
- */
-export const layer = (options?: {
-  readonly path?: `/${string}` | undefined
-}): Layer<never, never, Api> =>
-  Router.use((router) =>
-    Effect.gen(function*() {
-      const { api } = yield* Api
-      const spec = OpenApi.fromApi(api)
-      const response = HttpServerResponse.html(`<!DOCTYPE html>
+const makeHandler = (options: {
+  readonly api: HttpApi.HttpApi.Any
+}) => {
+  const spec = OpenApi.fromApi(options.api as any)
+  const response = HttpServerResponse.html(`<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8" />
@@ -49,6 +40,46 @@ export const layer = (options?: {
   </script>
 </body>
 </html>`)
-      yield* router.get(options?.path ?? "/docs", Effect.succeed(response))
+  return Effect.succeed(response)
+}
+
+/**
+ * Exported layer mounting Swagger/OpenAPI documentation UI.
+ *
+ * @param options.path  Optional mount path (default "/docs").
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer = (options?: {
+  readonly path?: `/${string}` | undefined
+}): Layer.Layer<never, never, Api> =>
+  Router.use((router) =>
+    Effect.gen(function*() {
+      const { api } = yield* Api
+      const handler = makeHandler({ api })
+      yield* router.get(options?.path ?? "/docs", handler)
     })
   )
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerHttpLayerRouter: (
+  options: {
+    readonly api: HttpApi.HttpApi.Any
+    readonly path: `/${string}`
+  }
+) => Layer.Layer<
+  never,
+  never,
+  HttpLayerRouter.HttpRouter
+> = Effect.fnUntraced(function*(options: {
+  readonly api: HttpApi.HttpApi.Any
+  readonly path: `/${string}`
+}) {
+  const router = yield* HttpLayerRouter.HttpRouter
+  const handler = makeHandler(options)
+  yield* router.add("GET", options.path, handler)
+}, Layer.effectDiscard)

package/src/HttpApp.ts

@@ -4,12 +4,16 @@
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
+import * as Fiber from "effect/Fiber"
 import * as FiberRef from "effect/FiberRef"
+import * as GlobalValue from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
-import type * as Option from "effect/Option"
+import * as Option from "effect/Option"
 import * as Runtime from "effect/Runtime"
 import * as Scope from "effect/Scope"
+import * as Stream from "effect/Stream"
 import { unify } from "effect/Unify"
+import * as HttpBody from "./HttpBody.js"
 import type { HttpMiddleware } from "./HttpMiddleware.js"
 import * as ServerError from "./HttpServerError.js"
 import * as ServerRequest from "./HttpServerRequest.js"
@@ -115,9 +119,57 @@ export const toHandled = <E, R, _, EH, RH>(
       })
   )
 
-  return Effect.uninterruptible(Effect.scoped(withMiddleware)) as any
+  return Effect.uninterruptible(scoped(withMiddleware)) as any
 }
 
+/**
+ * If you want to finalize the http request scope elsewhere, you can use this
+ * function to eject from the default scope closure.
+ *
+ * @since 1.0.0
+ * @category Scope
+ */
+export const ejectDefaultScopeClose = (scope: Scope.Scope): void => {
+  ejectedScopes.add(scope)
+}
+
+/**
+ * @since 1.0.0
+ * @category Scope
+ */
+export const unsafeEjectStreamScope = (
+  response: ServerResponse.HttpServerResponse
+): ServerResponse.HttpServerResponse => {
+  if (response.body._tag !== "Stream") {
+    return response
+  }
+  const fiber = Option.getOrThrow(Fiber.getCurrentFiber())
+  const scope = Context.unsafeGet(fiber.currentContext, Scope.Scope) as Scope.CloseableScope
+  ejectDefaultScopeClose(scope)
+  return ServerResponse.setBody(
+    response,
+    HttpBody.stream(
+      Stream.ensuring(response.body.stream, Scope.close(scope, Exit.void)),
+      response.body.contentType,
+      response.body.contentLength
+    )
+  )
+}
+
+const ejectedScopes = GlobalValue.globalValue(
+  "@effect/platform/HttpApp/ejectedScopes",
+  () => new WeakSet<Scope.Scope>()
+)
+
+const scoped = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+  Effect.flatMap(Scope.make(), (scope) =>
+    Effect.onExit(Scope.extend(effect, scope), (exit) => {
+      if (ejectedScopes.has(scope)) {
+        return Effect.void
+      }
+      return Scope.close(scope, exit)
+    }))
+
 /**
  * @since 1.0.0
  * @category models
@@ -156,6 +208,7 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
   return <E>(self: Default<E, R | Scope.Scope>, middleware?: HttpMiddleware | undefined) => {
     const resolveSymbol = Symbol.for("@effect/platform/HttpApp/resolve")
     const httpApp = toHandled(self, (request, response) => {
+      response = unsafeEjectStreamScope(response)
       ;(request as any)[resolveSymbol](
         ServerResponse.toWeb(response, { withoutBody: request.method === "HEAD", runtime })
       )

package/src/HttpBody.ts

@@ -238,8 +238,7 @@ export interface Stream extends HttpBody.Proto {
 export const stream: (
   body: Stream_.Stream<globalThis.Uint8Array, unknown>,
   contentType?: string,
-  contentLength?: number,
-  etag?: string
+  contentLength?: number
 ) => Stream = internal.stream
 
 /**