effect 4.0.0-beta.103 → 4.0.0-beta.104

package/src/unstable/http/FindMyWay.ts

@@ -1,15 +1,74 @@
 /**
- * Re-exports the `find-my-way-ts` router package used by the unstable HTTP
- * routing modules.
+ * A radix-tree HTTP router used by the unstable HTTP routing modules.
  *
- * This module keeps the router types and helpers available from the Effect HTTP
- * namespace without wrapping or changing them.
+ * @since 4.0.0
+ */
+import * as internal from "./FindMyWay/internal/router.ts"
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2017-2019 Tomas Della Vedova
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
  *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface RouterConfig {
+  readonly ignoreTrailingSlash: boolean
+  readonly ignoreDuplicateSlashes: boolean
+  readonly caseSensitive: boolean
+  readonly maxParamLength: number
+}
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export type PathInput = `/${string}` | "*"
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface Router<A> {
+  readonly on: (method: string | Iterable<string>, path: PathInput, handler: A) => void
+  readonly all: (path: PathInput, handler: A) => void
+  readonly find: (method: string, url: string) => FindResult<A> | undefined
+  readonly has: (method: string, url: string) => boolean
+}
+
+/**
  * @since 4.0.0
+ * @category models
  */
+export interface FindResult<A> {
+  readonly handler: A
+  readonly params: Record<string, string | undefined>
+  readonly searchParams: Record<string, string | Array<string>>
+}
 
 /**
- * @category re-exports
  * @since 4.0.0
+ * @category constructors
  */
-export * from "find-my-way-ts"
+export const make: <A>(options?: Partial<RouterConfig>) => Router<A> = internal.make

package/src/unstable/http/HttpClientError.ts

@@ -299,7 +299,7 @@ export type HttpClientErrorReason = RequestError | ResponseError
  * @category schemas
  * @since 4.0.0
  */
-export class HttpClientErrorSchema extends Schema.ErrorClass<HttpClientErrorSchema>(TypeId)({
+export class HttpClientErrorSchema extends Schema.Error<HttpClientErrorSchema>(TypeId)({
   _tag: Schema.tag("HttpError"),
   kind: Schema.Literals(
     [

package/src/unstable/http/HttpClientRequest.ts

@@ -28,6 +28,7 @@ import * as Stream from "../../Stream.ts"
 import * as Headers from "./Headers.ts"
 import * as HttpBody from "./HttpBody.ts"
 import { hasBody, type HttpMethod } from "./HttpMethod.ts"
+import * as bodyInternal from "./internal/httpBody.ts"
 import * as Url from "./Url.ts"
 import * as UrlParams from "./UrlParams.ts"
 
@@ -874,25 +875,12 @@ export const setBody: {
    */
   (self: HttpClientRequest, body: HttpBody.HttpBody): HttpClientRequest
 } = dual(2, (self: HttpClientRequest, body: HttpBody.HttpBody): HttpClientRequest => {
-  let headers = self.headers
-  if (body._tag === "Empty" || body._tag === "FormData") {
-    headers = Headers.remove(Headers.remove(headers, "Content-Type"), "Content-length")
-  } else {
-    if (body.contentType) {
-      headers = Headers.set(headers, "content-type", body.contentType)
-    }
-    if (body.contentLength !== undefined) {
-      headers = Headers.set(headers, "content-length", body.contentLength.toString())
-    } else {
-      headers = Headers.remove(headers, "content-length")
-    }
-  }
   return makeWith(
     self.method,
     self.url,
     self.urlParams,
     self.hash,
-    headers,
+    bodyInternal.updateHeaders(self.headers, body),
     body
   )
 })

package/src/unstable/http/HttpClientResponse.ts

@@ -355,22 +355,7 @@ class WebHttpClientResponse extends Inspectable.Class implements HttpClientRespo
 
   private textBody?: Effect.Effect<string, Error.HttpClientError>
   get text(): Effect.Effect<string, Error.HttpClientError> {
-    if (this.textBody) {
-      return this.textBody
-    }
-    this.textBody = Effect.tryPromise({
-      try: () => this.source.text(),
-      catch: (cause) =>
-        new Error.HttpClientError({
-          reason: new Error.DecodeError({
-            request: this.request,
-            response: this,
-            cause
-          })
-        })
-    }).pipe(Effect.cached, Effect.runSync)
-    this.arrayBufferBody = Effect.map(this.textBody, (_) => new TextEncoder().encode(_).buffer)
-    return this.textBody
+    return this.textBody ??= Effect.map(this.arrayBuffer, (_) => new TextDecoder().decode(_))
   }
 
   get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, Error.HttpClientError> {
@@ -419,7 +404,6 @@ class WebHttpClientResponse extends Inspectable.Class implements HttpClientRespo
           })
         })
     }).pipe(Effect.cached, Effect.runSync)
-    this.textBody = Effect.map(this.arrayBufferBody, (_) => new TextDecoder().decode(_))
     return this.arrayBufferBody
   }
 

package/src/unstable/http/HttpPlatform.ts

@@ -161,14 +161,42 @@ export const layer = Layer.effect(HttpPlatform)(
           { contentLength, headers, status, statusText }
         )
       },
-      fileWebResponse(file, status, statusText, headers, _options) {
-        return Response.stream(
-          Stream.fromReadableStream({
+      fileWebResponse(file, status, statusText, headers, options) {
+        const offset = Number(options?.offset ?? 0)
+        const bytesToRead = options?.bytesToRead !== undefined ? Number(options.bytesToRead) : undefined
+        const chunkSize = options?.chunkSize !== undefined ? Math.max(1, Number(options.chunkSize)) : Infinity
+        const end = offset + (bytesToRead ?? Infinity)
+        const stream = end <= offset
+          ? Stream.empty
+          : Stream.fromReadableStream({
             evaluate: () => file.stream() as ReadableStream<Uint8Array>,
             onError: identity
-          }),
-          { headers, status, statusText }
-        )
+          }).pipe(
+            Stream.mapAccum(
+              () => 0,
+              (position, bytes) => {
+                const next = position + bytes.length
+                const start = Math.min(Math.max(offset - position, 0), bytes.length)
+                const stop = Math.min(Math.max(end - position, 0), bytes.length)
+                const chunks: Array<{ readonly bytes: Uint8Array; readonly done: boolean }> = []
+                for (let index = start; index < stop; index += chunkSize) {
+                  chunks.push({
+                    bytes: bytes.subarray(index, Math.min(index + chunkSize, stop)),
+                    done: next >= end && index + chunkSize >= stop
+                  })
+                }
+                return [next, chunks]
+              }
+            ),
+            Stream.takeUntil((chunk) => chunk.done),
+            Stream.map((chunk) => chunk.bytes)
+          )
+        return Response.stream(stream, {
+          contentLength: bytesToRead ?? file.size - offset,
+          headers,
+          status,
+          statusText
+        })
       }
     }))
 ).pipe(Layer.provide(Etag.layerWeak))

package/src/unstable/http/HttpServerRequest.ts

@@ -863,25 +863,25 @@ const rawBodyStream = (request: HttpServerRequest, body: unknown): Stream.Stream
   if (body instanceof Request) {
     return streamFromReadable(request, body.body)
   }
-  if (isFormData(body)) {
-    return streamFromReadable(request, new Response(body).body)
-  }
   if (isReadableStream(body)) {
     return streamFromReadable(request, body)
   }
+  if (isBodyInit(body)) {
+    return streamFromReadable(request, new Response(body).body)
+  }
   return Stream.fail(requestParseError(request, "Unsupported body type"))
 }
 
 const rawBodyBytes = (request: HttpServerRequest, body: unknown): Effect.Effect<Uint8Array, HttpServerError> => {
-  if (body instanceof Blob) {
-    return bytesFromBodyInit(request, body)
-  }
   if (body instanceof Request) {
     return Effect.tryPromise({
       try: () => body.arrayBuffer().then((buffer) => new Uint8Array(buffer)),
       catch: (cause) => requestParseError(request, undefined, cause)
     })
   }
+  if (isBodyInit(body)) {
+    return bytesFromBodyInit(request, body)
+  }
   return Effect.fail(requestParseError(request, "Unsupported body type"))
 }
 
@@ -995,6 +995,14 @@ const isReadableStream = (u: unknown): u is ReadableStream<Uint8Array> =>
 
 const isFormData = (u: unknown): u is FormData => typeof FormData !== "undefined" && u instanceof FormData
 
+const isBodyInit = (u: unknown): u is BodyInit =>
+  typeof u === "string" ||
+  (typeof ArrayBuffer !== "undefined" && (u instanceof ArrayBuffer || ArrayBuffer.isView(u))) ||
+  (typeof Blob !== "undefined" && u instanceof Blob) ||
+  isFormData(u) ||
+  (typeof URLSearchParams !== "undefined" && u instanceof URLSearchParams) ||
+  isReadableStream(u)
+
 const textDecoder = new TextDecoder()
 
 /**

package/src/unstable/http/HttpServerResponse.ts

@@ -34,6 +34,7 @@ import * as HttpClientRequest from "./HttpClientRequest.ts"
 import * as HttpClientResponse from "./HttpClientResponse.ts"
 import * as HttpIncomingMessage from "./HttpIncomingMessage.ts"
 import type { HttpPlatform } from "./HttpPlatform.ts"
+import * as bodyInternal from "./internal/httpBody.ts"
 import * as Template from "./Template.ts"
 import * as UrlParams from "./UrlParams.ts"
 
@@ -563,7 +564,7 @@ export const setHeader: {
     makeResponse({
       ...self,
       headers: Headers.set(self.headers, key, value)
-    })
+    }, true)
 )
 
 /**
@@ -623,7 +624,7 @@ export const setHeaders: {
     makeResponse({
       ...self,
       headers: Headers.setAll(self.headers, input)
-    })
+    }, true)
 )
 
 /**
@@ -1204,7 +1205,8 @@ export const setBody: {
   (self: HttpServerResponse, body: Body.HttpBody): HttpServerResponse
 } = dual(
   2,
-  (self: HttpServerResponse, body: Body.HttpBody): HttpServerResponse => makeResponse({ ...self, body })
+  (self: HttpServerResponse, body: Body.HttpBody): HttpServerResponse =>
+    makeResponse({ ...self, headers: bodyInternal.updateHeaders(self.headers, body), body })
 )
 
 /**
@@ -1623,7 +1625,7 @@ const makeResponse = (options: {
   readonly headers?: Headers.Headers | undefined
   readonly cookies?: Cookies.Cookies | undefined
   readonly body?: Body.HttpBody | undefined
-}) => {
+}, preferHeaders = false) => {
   const self = Object.create(Proto) as Mutable<HttpServerResponse>
   self.status = options.status
   self.statusText = options.statusText
@@ -1631,13 +1633,13 @@ const makeResponse = (options: {
   self.body = options.body ?? Body.empty
   if (
     self.body._tag !== "Empty" &&
-    (self.body.contentType || self.body.contentLength)
+    (self.body.contentType || self.body.contentLength !== undefined)
   ) {
     const newHeaders = Headers.fromRecordUnsafe({ ...options.headers }) as any
-    if (self.body.contentType) {
+    if (self.body.contentType && (!preferHeaders || newHeaders["content-type"] === undefined)) {
       newHeaders["content-type"] = self.body.contentType
     }
-    if (self.body.contentLength) {
+    if (self.body.contentLength !== undefined && (!preferHeaders || newHeaders["content-length"] === undefined)) {
       newHeaders["content-length"] = self.body.contentLength.toString()
     }
     self.headers = newHeaders

package/src/unstable/http/Multipart.ts

@@ -34,7 +34,7 @@ import * as UndefinedOr from "../../UndefinedOr.ts"
 import * as IncomingMessage from "./HttpIncomingMessage.ts"
 import * as HttpServerRespondable from "./HttpServerRespondable.ts"
 import * as HttpServerResponse from "./HttpServerResponse.ts"
-import * as MP from "./Multipasta.ts"
+import * as MP from "./MultipartParser.ts"
 
 /**
  * Type identifier used to brand multipart part values.
@@ -678,6 +678,8 @@ export const toPersisted = (
     const path_ = yield* Path.Path
     const dir = yield* fs.makeTempDirectoryScoped()
     const persisted: Record<string, Array<PersistedFile> | Array<string> | string> = Object.create(null)
+    const usedPaths = new Set<string>()
+    let fileIndex = 0
     yield* Stream.runForEach(stream, (part) => {
       if (part._tag === "Field") {
         if (!(part.key in persisted)) {
@@ -692,7 +694,12 @@ export const toPersisted = (
         return Effect.void
       }
       const file = part
-      const path = path_.join(dir, path_.basename(file.name).slice(-128))
+      const fileName = path_.basename(file.name).slice(-128)
+      let path = path_.join(dir, fileName)
+      while (usedPaths.has(path)) {
+        path = path_.join(dir, `${fileIndex++}-${fileName}`)
+      }
+      usedPaths.add(path)
       const filePart = new PersistedFileImpl(
         file.key,
         file.name,

package/src/unstable/http/MultipartParser/HeadersParser.ts

@@ -0,0 +1,68 @@
+/**
+ * Low-level parser for multipart header blocks.
+ *
+ * @since 4.0.0
+ */
+import * as internal from "./internal/headers.ts"
+
+/**
+ * The reason a multipart header block could not be parsed.
+ *
+ * @category errors
+ * @since 4.0.0
+ */
+export type FailureReason =
+  | "TooManyHeaders"
+  | "HeaderTooLarge"
+  | "InvalidHeaderName"
+  | "InvalidHeaderValue"
+
+/**
+ * Indicates that the parser needs more input.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface Continue {
+  readonly _tag: "Continue"
+}
+
+/**
+ * A multipart header parsing failure.
+ *
+ * @category errors
+ * @since 4.0.0
+ */
+export interface Failure {
+  readonly _tag: "Failure"
+  readonly reason: FailureReason
+  readonly headers: Record<string, string | Array<string>>
+}
+
+/**
+ * A successfully parsed multipart header block.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface Headers {
+  readonly _tag: "Headers"
+  readonly headers: Record<string, string | Array<string>>
+  readonly endPosition: number
+}
+
+/**
+ * The result of parsing a multipart header block.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export type ReturnValue = Continue | Failure | Headers
+
+/**
+ * Creates an incremental multipart header parser.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const make: () => (chunk: Uint8Array, start: number) => ReturnValue = internal.make

package/src/unstable/http/MultipartParser/Search.ts

@@ -0,0 +1,17 @@
+/**
+ * Low-level byte search used by the multipart parser.
+ *
+ * @since 4.0.0
+ */
+import * as internal from "./internal/search.ts"
+
+/**
+ * Creates an incremental byte search for a string boundary.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const make: (
+  needle: string,
+  callback: (index: number, chunk: Uint8Array) => void
+) => { readonly write: (chunk: Uint8Array) => void; readonly end: () => void } = internal.make

package/src/unstable/http/MultipartParser/internal/contentType.ts

@@ -0,0 +1,103 @@
+// taken from https://github.com/fastify/fast-content-type-parse
+// under the MIT license
+
+/**
+ * RegExp to match *( ";" parameter ) in RFC 7231 sec 3.1.1.1
+ *
+ * parameter     = token "=" ( token / quoted-string )
+ * token         = 1*tchar
+ * tchar         = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+ *               / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+ *               / DIGIT / ALPHA
+ *               ; any VCHAR, except delimiters
+ * quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE
+ * qdtext        = HTAB / SP / %x21 / %x23-5B / %x5D-7E / obs-text
+ * obs-text      = %x80-FF
+ * quoted-pair   = "\" ( HTAB / SP / VCHAR / obs-text )
+ */
+const paramRE =
+  /; *([!#$%&'*+.^\w`|~-]+)=("(?:[\v\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u{10ffff}]|\\[\v\u0020-\u{10ffff}])*"|[!#$%&'*+.^\w`|~-]+) */gu
+
+/**
+ * RegExp to match quoted-pair in RFC 7230 sec 3.2.6
+ *
+ * quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text )
+ * obs-text    = %x80-FF
+ */
+const quotedPairRE = /\\([\v\u0020-\u{10ffff}])/gu
+
+/**
+ * RegExp to match type in RFC 7231 sec 3.1.1.1
+ *
+ * media-type = type "/" subtype
+ * type       = token
+ * subtype    = token
+ */
+const mediaTypeRE = /^[!#$%&'*+.^\w|~-]+\/[!#$%&'*+.^\w|~-]+$/u
+const mediaTypeRENoSlash = /^[!#$%&'*+.^\w|~-]+$/u
+
+// default ContentType to prevent repeated object creation
+const defaultContentType = { value: "", parameters: Object.create(null) }
+
+export function parse(
+  header: string | undefined,
+  withoutSlash = false
+): {
+  readonly value: string
+  readonly parameters: Record<string, string>
+} {
+  if (typeof header !== "string") {
+    return defaultContentType
+  }
+
+  let index = header.indexOf(";")
+  const type = index !== -1 ? header.slice(0, index).trim() : header.trim()
+  const mediaRE = withoutSlash ? mediaTypeRENoSlash : mediaTypeRE
+
+  if (mediaRE.test(type) === false) {
+    return defaultContentType
+  }
+
+  const result = {
+    value: type.toLowerCase(),
+    parameters: Object.create(null)
+  }
+
+  // parse parameters
+  if (index === -1) {
+    return result
+  }
+
+  let key: string
+  let match: RegExpExecArray | null
+  let value: string
+
+  paramRE.lastIndex = index
+
+  while ((match = paramRE.exec(header))) {
+    if (match.index !== index) {
+      return defaultContentType
+    }
+
+    index += match[0].length
+    key = match[1].toLowerCase()
+    value = match[2]
+
+    if (value[0] === "\"") {
+      // remove quotes and escapes
+      value = value.slice(1, value.length - 1)
+
+      if (!withoutSlash && quotedPairRE.test(value)) {
+        value = value.replace(quotedPairRE, "$1")
+      }
+    }
+
+    result.parameters[key] = value
+  }
+
+  if (index !== header.length) {
+    return defaultContentType
+  }
+
+  return result
+}