effect 4.0.0-beta.102 → 4.0.0-beta.103

package/src/unstable/http/internal/compression.ts

@@ -0,0 +1,196 @@
+import * as Effect from "../../../Effect.ts"
+import { identity } from "../../../Function.ts"
+import * as Stream from "../../../Stream.ts"
+import type * as Headers from "../Headers.ts"
+import * as HttpBody from "../HttpBody.ts"
+import type { Compression, CompressionAlgorithm, CompressionOptions } from "../HttpPlatform.ts"
+import * as Response from "../HttpServerResponse.ts"
+
+/** @internal */
+export const varyAcceptEncoding = (headers: Headers.Headers): string | undefined => {
+  const vary = headers["vary"]
+  if (vary === undefined) {
+    return "Accept-Encoding"
+  }
+  const members = vary.split(",").map((member) => member.trim().toLowerCase())
+  return members.includes("*") || members.includes("accept-encoding")
+    ? undefined
+    : `${vary}, Accept-Encoding`
+}
+
+/** @internal */
+export const wrapCompression = (impl: Compression): Compression => ({
+  algorithms: impl.algorithms,
+  compressResponse(response, algorithm, options) {
+    return Effect.map(impl.compressResponse(response, algorithm, options), (compressed) => {
+      if (compressed === response) {
+        return response
+      }
+      const headers: Record<string, string> = { "content-encoding": algorithm }
+      const vary = varyAcceptEncoding(compressed.headers)
+      if (vary !== undefined) {
+        headers["vary"] = vary
+      }
+      const etag = compressed.headers["etag"]
+      if (etag !== undefined && !etag.startsWith("W/")) {
+        headers["etag"] = `W/${etag}`
+      }
+      return Response.setHeaders(compressed, headers)
+    })
+  }
+})
+
+/** @internal */
+export const compressionTransformWeb =
+  (format: string) => (stream: ReadableStream<Uint8Array>): ReadableStream<Uint8Array> =>
+    stream.pipeThrough(
+      new CompressionStream(format as CompressionFormat) as unknown as ReadableWritablePair<Uint8Array, Uint8Array>
+    )
+
+/** @internal */
+export const setBodyWithoutLength = (
+  response: Response.HttpServerResponse,
+  body: HttpBody.HttpBody
+): Response.HttpServerResponse => Response.removeHeader(Response.setBody(response, body), "content-length")
+
+/** @internal */
+export const makeCompressionWeb = (options: {
+  readonly algorithms: Iterable<CompressionAlgorithm>
+  readonly transform: (
+    algorithm: CompressionAlgorithm,
+    options?: CompressionOptions | undefined
+  ) => (stream: ReadableStream<Uint8Array>) => ReadableStream<Uint8Array>
+}): Compression => ({
+  algorithms: new Set(options.algorithms),
+  compressResponse(response, algorithm, opts) {
+    const body = response.body
+    switch (body._tag) {
+      case "Uint8Array": {
+        const data = body.body
+        return Effect.succeed(streamBody(
+          response,
+          () => options.transform(algorithm, opts)(singleChunkStream(data)),
+          body.contentType
+        ))
+      }
+      case "Stream": {
+        const stream = body.stream
+        return Effect.succeed(streamBody(
+          response,
+          () => options.transform(algorithm, opts)(Stream.toReadableStream(stream)),
+          body.contentType
+        ))
+      }
+      case "Raw": {
+        const readable = rawReadableStream(body.body)
+        if (readable === undefined) {
+          return Effect.succeed(response)
+        }
+        return Effect.succeed(setBodyWithoutLength(
+          response,
+          HttpBody.raw(options.transform(algorithm, opts)(readable), { contentType: body.contentType })
+        ))
+      }
+      default: {
+        return Effect.succeed(response)
+      }
+    }
+  }
+})
+
+const streamBody = (
+  response: Response.HttpServerResponse,
+  evaluate: () => ReadableStream<Uint8Array>,
+  contentType: string | undefined
+): Response.HttpServerResponse =>
+  setBodyWithoutLength(
+    response,
+    HttpBody.stream(Stream.fromReadableStream({ evaluate, onError: identity }), contentType)
+  )
+
+const singleChunkStream = (data: Uint8Array): ReadableStream<Uint8Array> =>
+  new ReadableStream({
+    start(controller) {
+      controller.enqueue(data)
+      controller.close()
+    }
+  })
+
+const rawReadableStream = (raw: unknown): ReadableStream<Uint8Array> | undefined => {
+  if (typeof ReadableStream !== "undefined" && raw instanceof ReadableStream) {
+    return raw
+  } else if (raw instanceof globalThis.Response) {
+    return raw.body ?? undefined
+  }
+  return new globalThis.Response(raw as BodyInit).body ?? undefined
+}
+
+/** @internal */
+export const compressionWeb: Compression = makeCompressionWeb({
+  algorithms: ["gzip", "deflate"],
+  transform: (algorithm) => compressionTransformWeb(algorithm)
+})
+
+/** @internal */
+export const defaultCompressible = (contentType: string): boolean => {
+  const semi = contentType.indexOf(";")
+  const type = (semi === -1 ? contentType : contentType.slice(0, semi)).trim().toLowerCase()
+  if (type.startsWith("text/")) {
+    return true
+  }
+  switch (type) {
+    case "application/json":
+    case "application/javascript":
+    case "application/xml":
+    case "image/svg+xml":
+    case "application/wasm": {
+      return true
+    }
+  }
+  return type.endsWith("+json") || type.endsWith("+xml")
+}
+
+const acceptMember = /^([a-z0-9!#$%&'*+.^_`|~-]+)(?:;q=(0(?:\.[0-9]{0,3})?|1(?:\.0{0,3})?))?$/
+
+/** @internal */
+export const parseAcceptEncoding = (header: string): ReadonlyMap<string, number> | undefined => {
+  const trimmed = header.trim()
+  if (trimmed === "") {
+    return undefined
+  }
+  const accepted = new Map<string, number>()
+  for (const part of trimmed.split(",")) {
+    const member = part.trim().toLowerCase().replace(/[ \t]*;[ \t]*/g, ";")
+    const match = acceptMember.exec(member)
+    if (match === null) {
+      return undefined
+    }
+    accepted.set(match[1], match[2] === undefined ? 1 : Number(match[2]))
+  }
+  return accepted
+}
+
+/** @internal */
+export const negotiate = (
+  header: string | undefined,
+  preferred: ReadonlyArray<CompressionAlgorithm>,
+  supported: ReadonlySet<CompressionAlgorithm>
+): CompressionAlgorithm | undefined => {
+  if (header === undefined) {
+    return undefined
+  }
+  const accepted = parseAcceptEncoding(header)
+  if (accepted === undefined) {
+    return undefined
+  }
+  for (const algorithm of preferred) {
+    if (!supported.has(algorithm)) {
+      continue
+    }
+    const quality = accepted.get(algorithm) ?? accepted.get("*")
+    if (quality !== undefined && quality > 0) {
+      return algorithm
+    }
+  }
+  return undefined
+}

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -18,7 +18,6 @@ import type { FileSystem } from "../../FileSystem.ts"
 import { identity } from "../../Function.ts"
 import { stringOrRedacted } from "../../internal/redacted.ts"
 import * as Layer from "../../Layer.ts"
-import * as Option from "../../Option.ts"
 import type { Path } from "../../Path.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import { hasProperty } from "../../Predicate.ts"
@@ -58,7 +57,7 @@ import * as OpenApi from "./OpenApi.ts"
 /**
  * Registers an `HttpApi` with a `HttpRouter`.
  *
- * @category constructors
+ * @category layers
  * @since 4.0.0
  */
 export const layer = <Id extends string, Groups extends HttpApiGroup.Constraint>(
@@ -724,10 +723,10 @@ function decodePayload(
         }
         try {
           return decode(JSON.parse(text))
-        } catch (cause) {
+        } catch {
           return Effect.fail(
             new Schema.SchemaError(
-              new SchemaIssue.InvalidValue(Option.some(text), { message: `Invalid JSON: ${cause}` })
+              new SchemaIssue.InvalidValue({ message: "Expected a valid JSON body" })
             )
           )
         }
@@ -933,7 +932,7 @@ function makeStreamEncoder(endpoint: HttpApiEndpoint.Top): StreamEncoder | undef
     return (response, context) => {
       if (!Stream.isStream(response)) {
         return hasBuffered ? undefined : new Schema.SchemaError(
-          new SchemaIssue.InvalidValue(Option.some(response), { message: "Expected a streaming response" })
+          new SchemaIssue.InvalidValue({ message: "Expected a streaming response" })
         )
       }
 
@@ -952,7 +951,7 @@ function makeStreamEncoder(endpoint: HttpApiEndpoint.Top): StreamEncoder | undef
   return (response, context) => {
     if (!Stream.isStream(response)) {
       return hasBuffered ? undefined : new Schema.SchemaError(
-        new SchemaIssue.InvalidValue(Option.some(response), { message: "Expected a streaming response" })
+        new SchemaIssue.InvalidValue({ message: "Expected a streaming response" })
       )
     }
 
@@ -1087,7 +1086,7 @@ function getResponseTransformation(
   )
 
   return SchemaTransformation.transformOrFail({
-    decode: (res) => Effect.fail(new SchemaIssue.Forbidden(Option.some(res), { message: "Encode only schema" })),
+    decode: () => Effect.fail(new SchemaIssue.Forbidden({ message: "Encode only schema" })),
     encode
   })
 }
@@ -1106,8 +1105,10 @@ function getResponseEncode<E>(
         try {
           const s = JSON.stringify(e)
           return Effect.succeed(Response.text(s, { status, contentType: encoding.contentType }))
-        } catch (error) {
-          return Effect.fail(new SchemaIssue.InvalidValue(Option.some(e), { message: globalThis.String(error) }))
+        } catch {
+          return Effect.fail(
+            new SchemaIssue.InvalidValue({ message: "Expected a JSON-serializable response body" })
+          )
         }
       })
     }

package/src/unstable/httpapi/HttpApiClient.ts

@@ -16,7 +16,6 @@ import type * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import { identity } from "../../Function.ts"
 import * as InternalRecord from "../../internal/record.ts"
-import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import * as SchemaAST from "../../SchemaAST.ts"
@@ -62,7 +61,7 @@ export type Client<Groups extends HttpApiGroup.Constraint, E = never, R = never>
  * Derives the typed client interface for an `HttpApi`, preserving any additional
  * client error and service requirements supplied by the caller.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type ForApi<Api extends HttpApi.Constraint, E = never, R = never> = Api extends
@@ -75,7 +74,7 @@ type SuccessType<S> = S extends HttpApiSchema.StreamSse<
   infer _Value
 > ? Stream.Stream<
     _Value,
-    _Error["Type"] | HttpClientError.HttpClientError | Schema.SchemaError | Sse.Retry,
+    _Error["Type"] | HttpClientError.HttpClientError | Schema.SchemaError | Sse.Retry | Sse.SseError,
     never
   >
   : S extends HttpApiSchema.StreamUint8Array ? Stream.Stream<Uint8Array, HttpClientError.HttpClientError, never>
@@ -629,7 +628,7 @@ export const endpoint = <
  *
  * **Example** (Building typed URLs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi"
  *
@@ -647,8 +646,7 @@ export const endpoint = <
  *
  * buildUrl.users.getUser({
  *   params: { id: "123" }
- * })
- * //=> "https://api.example.com/users/123"
+ * }) // => "https://api.example.com/users/123"
  * ```
  *
  * @category constructors
@@ -1004,39 +1002,41 @@ function getEncodePayloadSchemaFromBody(
   const out = $HttpBody.pipe(Schema.decodeTo(
     schema,
     SchemaTransformation.transformOrFail<unknown, HttpBody.HttpBody>({
-      decode(httpBody) {
-        return Effect.fail(new SchemaIssue.Forbidden(Option.some(httpBody), { message: "Encode only schema" }))
+      decode() {
+        return Effect.fail(new SchemaIssue.Forbidden({ message: "Encode only schema" }))
       },
       encode(t) {
         switch (encoding._tag) {
           case "Multipart":
-            return Effect.fail(new SchemaIssue.Forbidden(Option.some(t), { message: "Payload must be a FormData" }))
+            return Effect.fail(new SchemaIssue.Forbidden({ message: "Payload must be a FormData" }))
           case "Json": {
             try {
               const body = JSON.stringify(t)
               return Effect.succeed(HttpBody.text(body, encoding.contentType))
-            } catch (error) {
-              return Effect.fail(new SchemaIssue.InvalidValue(Option.some(t), { message: globalThis.String(error) }))
+            } catch {
+              return Effect.fail(
+                new SchemaIssue.InvalidValue({ message: "Expected a JSON-serializable request body" })
+              )
             }
           }
           case "Text": {
             if (typeof t !== "string") {
               return Effect.fail(
-                new SchemaIssue.InvalidValue(Option.some(t), { message: "Expected a string" })
+                new SchemaIssue.InvalidValue({ message: "Expected a string" })
               )
             }
             return Effect.succeed(HttpBody.text(t, encoding.contentType))
           }
           case "FormUrlEncoded": {
             if (!Predicate.isObject(t)) {
-              return Effect.fail(new SchemaIssue.InvalidValue(Option.some(t), { message: "Expected a record" }))
+              return Effect.fail(new SchemaIssue.InvalidValue({ message: "Expected a record" }))
             }
             return Effect.succeed(HttpBody.urlParams(UrlParams.fromInput(t as any), encoding.contentType))
           }
           case "Uint8Array": {
             if (!(t instanceof Uint8Array)) {
               return Effect.fail(
-                new SchemaIssue.InvalidValue(Option.some(t), { message: "Expected a Uint8Array" })
+                new SchemaIssue.InvalidValue({ message: "Expected a Uint8Array" })
               )
             }
             return Effect.succeed(HttpBody.uint8Array(t, encoding.contentType))