@effect/platform 0.45.2 → 0.45.4

package/src/internal/http/client.ts

@@ -555,7 +555,7 @@ export const schemaFunction = dual<
     request: ClientRequest.ClientRequest
   ) => (
     a: SA
-  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, Exclude<SR | R, Scope.Scope>>,
+  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>,
   <R, E, A, SA, SI, SR>(
     self: Client.Client<R, E, A>,
     schema: Schema.Schema<SA, SI, SR>
@@ -563,29 +563,27 @@ export const schemaFunction = dual<
     request: ClientRequest.ClientRequest
   ) => (
     a: SA
-  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, Exclude<SR | R, Scope.Scope>>
+  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>
 >(2, (self, schema) => {
   const encode = Schema.encode(schema)
   return (request) => (a) =>
-    Effect.scoped(
-      Effect.flatMap(
-        Effect.tryMap(encode(a), {
-          try: (body) => new TextEncoder().encode(JSON.stringify(body)),
-          catch: (error) =>
-            internalError.requestError({
-              request,
-              reason: "Encode",
-              error
-            })
-        }),
-        (body) =>
-          self(
-            internalRequest.setBody(
-              request,
-              internalBody.uint8Array(body, "application/json")
-            )
+    Effect.flatMap(
+      Effect.tryMap(encode(a), {
+        try: (body) => new TextEncoder().encode(JSON.stringify(body)),
+        catch: (error) =>
+          internalError.requestError({
+            request,
+            reason: "Encode",
+            error
+          })
+      }),
+      (body) =>
+        self(
+          internalRequest.setBody(
+            request,
+            internalBody.uint8Array(body, "application/json")
           )
-      )
+        )
     )
 })
 

package/src/internal/http/serverResponse.ts

@@ -10,6 +10,7 @@ import * as Headers from "../../Http/Headers.js"
 import * as Platform from "../../Http/Platform.js"
 import type * as ServerResponse from "../../Http/ServerResponse.js"
 import * as UrlParams from "../../Http/UrlParams.js"
+import * as Template from "../../Template.js"
 import * as internalBody from "./body.js"
 
 /** @internal */
@@ -91,6 +92,52 @@ export const text = (body: string, options?: ServerResponse.Options.WithContentT
     internalBody.text(body, getContentType(options))
   )
 
+/** @internal */
+export const html: {
+  <A extends ReadonlyArray<Template.Interpolated>>(
+    strings: TemplateStringsArray,
+    ...args: A
+  ): Effect.Effect<
+    ServerResponse.ServerResponse,
+    Template.Interpolated.Error<A[number]>,
+    Template.Interpolated.Context<A[number]>
+  >
+  (html: string): ServerResponse.ServerResponse
+} = (
+  strings: TemplateStringsArray | string,
+  ...args: ReadonlyArray<Template.Interpolated>
+) => {
+  if (typeof strings === "string") {
+    return text(strings, { contentType: "text/html" })
+  }
+
+  return Effect.map(
+    Template.make(strings, ...args),
+    (_) => text(_, { contentType: "text/html" })
+  ) as any
+}
+
+/** @internal */
+export const htmlStream = <A extends ReadonlyArray<Template.InterpolatedWithStream>>(
+  strings: TemplateStringsArray,
+  ...args: A
+): Effect.Effect<
+  ServerResponse.ServerResponse,
+  never,
+  Template.Interpolated.Context<A[number]>
+> =>
+  Effect.map(
+    Effect.context<any>(),
+    (context) =>
+      stream(
+        Stream.provideContext(
+          Stream.encodeText(Template.stream(strings, ...args)),
+          context
+        ),
+        { contentType: "text/html" }
+      )
+  )
+
 /** @internal */
 export const json = (
   body: unknown,