effect 4.0.0-beta.98 → 4.0.0-rc.108

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
+}

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

@@ -0,0 +1,244 @@
+import type { Continue, FailureReason, ReturnValue } from "../HeadersParser.ts"
+
+const constMaxPairs = 100
+const constMaxSize = 16 * 1024
+
+const State = {
+  key: 0,
+  whitespace: 1,
+  value: 2
+} as const
+type State = (typeof State)[keyof typeof State]
+
+const constContinue: Continue = { _tag: "Continue" }
+
+// RFC 7230 token characters, allowed in header names
+// The previous table stopped at byte 126; zero-filled entries for bytes 127-255
+// preserve its rejection behavior because callers accept only entries equal to 1.
+const constNameChars = new Uint8Array(256)
+for (const char of "!#$%&'*+-.^_`|~0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") {
+  constNameChars[char.charCodeAt(0)] = 1
+}
+
+// HTAB, visible ASCII and obs-text, allowed in header values
+const constValueChars = new Uint8Array(256)
+constValueChars[9] = 1
+for (let i = 32; i <= 126; i++) {
+  constValueChars[i] = 1
+}
+for (let i = 128; i <= 255; i++) {
+  constValueChars[i] = 1
+}
+
+export function make() {
+  const decoder = new TextDecoder()
+  const state = {
+    state: State.key as State,
+    headers: Object.create(null) as Record<string, string | Array<string>>,
+    key: "",
+    value: undefined as undefined | Uint8Array,
+    crlf: 0,
+    previousChunk: undefined as undefined | Uint8Array,
+    pairs: 0,
+    size: 0
+  }
+
+  function reset(value: ReturnValue): ReturnValue {
+    state.state = State.key
+    state.headers = Object.create(null)
+    state.key = ""
+    state.value = undefined
+    state.crlf = 0
+    state.previousChunk = undefined
+    state.pairs = 0
+    state.size = 0
+    return value
+  }
+
+  function concatUint8Array(a: Uint8Array, b: Uint8Array): Uint8Array {
+    const newUint8Array = new Uint8Array(a.length + b.length)
+    newUint8Array.set(a)
+    newUint8Array.set(b, a.length)
+    return newUint8Array
+  }
+
+  function error(reason: FailureReason) {
+    return reset({ _tag: "Failure", reason, headers: state.headers })
+  }
+
+  return function write(chunk: Uint8Array, start: number): ReturnValue {
+    let endOffset = 0
+    let previousCursor: number | undefined
+    if (state.previousChunk !== undefined) {
+      endOffset = state.previousChunk.length
+      previousCursor = endOffset
+
+      const newChunk = new Uint8Array(chunk.length + endOffset)
+      newChunk.set(state.previousChunk)
+      newChunk.set(chunk, endOffset)
+      state.previousChunk = undefined
+      chunk = newChunk
+    }
+    const end = chunk.length
+
+    outer: while (start < end) {
+      if (state.state === State.key) {
+        let i = start
+        for (; i < end; i++) {
+          if (state.size++ > constMaxSize) {
+            return error("HeaderTooLarge")
+          }
+
+          if (chunk[i] === 58) {
+            state.key += decoder.decode(chunk.subarray(start, i)).toLowerCase()
+            if (state.key.length === 0) {
+              return error("InvalidHeaderName")
+            }
+
+            if (
+              chunk[i + 1] === 32 &&
+              chunk[i + 2] !== 32 &&
+              chunk[i + 2] !== 9
+            ) {
+              start = i + 2
+              state.state = State.value
+              state.size++
+            } else if (chunk[i + 1] !== 32 && chunk[i + 1] !== 9) {
+              start = i + 1
+              state.state = State.value
+            } else {
+              start = i + 1
+              state.state = State.whitespace
+            }
+
+            break
+          } else if (constNameChars[chunk[i]] !== 1) {
+            return error("InvalidHeaderName")
+          }
+        }
+        if (i === end) {
+          state.key += decoder.decode(chunk.subarray(start, end)).toLowerCase()
+          return constContinue
+        }
+      }
+
+      if (state.state === State.whitespace) {
+        for (; start < end; start++) {
+          if (state.size++ > constMaxSize) {
+            return error("HeaderTooLarge")
+          }
+
+          if (chunk[start] !== 32 && chunk[start] !== 9) {
+            state.state = State.value
+            break
+          }
+        }
+        if (start === end) {
+          return constContinue
+        }
+      }
+
+      if (state.state === State.value) {
+        let i = start
+        if (previousCursor !== undefined) {
+          i = previousCursor
+          previousCursor = undefined
+        }
+        for (; i < end; i++) {
+          if (state.size++ > constMaxSize) {
+            return error("HeaderTooLarge")
+          }
+
+          if (chunk[i] === 13 || state.crlf > 0) {
+            let byte = chunk[i]
+
+            if (byte === 13 && state.crlf === 0) {
+              state.crlf = 1
+              i++
+              state.size++
+              byte = chunk[i]
+            }
+            if (byte === 10 && state.crlf === 1) {
+              state.crlf = 2
+              i++
+              state.size++
+              byte = chunk[i]
+            }
+            if (byte === 13 && state.crlf === 2) {
+              state.crlf = 3
+              i++
+              state.size++
+              byte = chunk[i]
+            }
+            if (byte === 10 && state.crlf === 3) {
+              state.crlf = 4
+              i++
+              state.size++
+            }
+
+            if (state.crlf < 4 && i >= end) {
+              state.previousChunk = chunk.subarray(start)
+              return constContinue
+            } else if (state.crlf >= 2) {
+              state.value = state.value === undefined
+                ? chunk.subarray(start, i - state.crlf)
+                : concatUint8Array(
+                  state.value,
+                  chunk.subarray(start, i - state.crlf)
+                )
+              const value = decoder.decode(state.value)
+              if (state.headers[state.key] === undefined) {
+                state.headers[state.key] = value
+              } else if (typeof state.headers[state.key] === "string") {
+                state.headers[state.key] = [
+                  state.headers[state.key] as string,
+                  value
+                ]
+              } else {
+                ;(state.headers[state.key] as Array<string>).push(value)
+              }
+
+              start = i
+              state.size--
+
+              if (state.crlf !== 4 && state.pairs === constMaxPairs) {
+                return error("TooManyHeaders")
+              } else if (state.crlf === 3) {
+                return error("InvalidHeaderValue")
+              } else if (state.crlf === 4) {
+                return reset({
+                  _tag: "Headers",
+                  headers: state.headers,
+                  endPosition: start - endOffset
+                })
+              }
+
+              state.pairs++
+              state.key = ""
+              state.value = undefined
+              state.crlf = 0
+              state.state = State.key
+
+              continue outer
+            }
+          } else if (constValueChars[chunk[i]] !== 1) {
+            return error("InvalidHeaderValue")
+          }
+        }
+
+        if (i === end) {
+          state.value = state.value === undefined
+            ? chunk.subarray(start, end)
+            : concatUint8Array(state.value, chunk.subarray(start, end))
+          return constContinue
+        }
+      }
+    }
+
+    if (start > end) {
+      state.size += end - start
+    }
+
+    return constContinue
+  }
+}

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

@@ -0,0 +1,279 @@
+import type { Config, MultipartError, PartInfo } from "../../MultipartParser.ts"
+import * as CT from "./contentType.ts"
+import * as HP from "./headers.ts"
+import * as Search from "./search.ts"
+
+const State = {
+  headers: 0,
+  body: 1
+} as const
+type State = (typeof State)[keyof typeof State]
+
+const errInvalidDisposition: MultipartError = { _tag: "InvalidDisposition" }
+const errEndNotReached: MultipartError = { _tag: "EndNotReached" }
+const errMaxParts: MultipartError = { _tag: "ReachedLimit", limit: "MaxParts" }
+const errMaxTotalSize: MultipartError = {
+  _tag: "ReachedLimit",
+  limit: "MaxTotalSize"
+}
+const errMaxPartSize: MultipartError = {
+  _tag: "ReachedLimit",
+  limit: "MaxPartSize"
+}
+const errMaxFieldSize: MultipartError = {
+  _tag: "ReachedLimit",
+  limit: "MaxFieldSize"
+}
+
+const constCR = new TextEncoder().encode("\r\n")
+
+export function defaultIsFile(info: PartInfo) {
+  return (
+    info.filename !== undefined ||
+    info.contentType === "application/octet-stream"
+  )
+}
+
+function parseBoundary(headers: Record<string, string>) {
+  const contentType = CT.parse(headers["content-type"])
+  return contentType.parameters.boundary
+}
+
+function noopOnChunk(_chunk: Uint8Array | null) {}
+
+export function make({
+  headers,
+  onFile: onPart,
+  onField,
+  onError,
+  onDone,
+  isFile = defaultIsFile,
+  maxParts = Infinity,
+  maxTotalSize = Infinity,
+  maxPartSize = Infinity,
+  maxFieldSize = 1024 * 1024
+}: Config) {
+  const boundary = parseBoundary(headers)
+  if (boundary === undefined) {
+    onError({ _tag: "InvalidBoundary" })
+    return {
+      write: noopOnChunk,
+      end() {}
+    }
+  }
+
+  const state = {
+    state: State.headers as State,
+    index: 0,
+    parts: 0,
+    onChunk: noopOnChunk,
+    info: undefined as any as PartInfo,
+    headerSkip: 0,
+    partSize: 0,
+    totalSize: 0,
+    isFile: false,
+    fieldChunks: [] as Array<Uint8Array>,
+    fieldSize: 0,
+    done: false,
+    stopped: false
+  }
+
+  function skipBody() {
+    state.state = State.body
+    state.isFile = true
+    state.onChunk = noopOnChunk
+  }
+
+  function stop(error: MultipartError) {
+    state.stopped = true
+    if (state.state === State.body && state.isFile) {
+      state.onChunk(null)
+    }
+    onError(error)
+  }
+
+  const headerParser = HP.make()
+
+  const split = Search.make(
+    `\r\n--${boundary}`,
+    function(index, chunk) {
+      if (state.stopped) {
+        return
+      }
+
+      if (index === 0) {
+        // data before the first boundary
+        skipBody()
+        return
+      } else if (index !== state.index) {
+        if (state.index > 0) {
+          if (state.isFile) {
+            state.onChunk(null)
+          } else {
+            if (state.fieldChunks.length === 1) {
+              onField(state.info, state.fieldChunks[0])
+            } else {
+              const buf = new Uint8Array(state.fieldSize)
+              let offset = 0
+              for (let i = 0; i < state.fieldChunks.length; i++) {
+                const chunk = state.fieldChunks[i]
+                buf.set(chunk, offset)
+                offset += chunk.length
+              }
+              onField(state.info, buf)
+            }
+            state.fieldSize = 0
+            state.fieldChunks = []
+          }
+        }
+        state.partSize = 0
+
+        state.state = State.headers
+        state.index = index
+        state.headerSkip = 2 // skip the first \r\n
+
+        // trailing --
+        if (chunk[0] === 45 && chunk[1] === 45) {
+          state.done = true
+          return onDone()
+        }
+
+        state.parts++
+        if (state.parts > maxParts) {
+          return stop(errMaxParts)
+        }
+      }
+
+      if ((state.partSize += chunk.length) > maxPartSize) {
+        return stop(errMaxPartSize)
+      }
+
+      if (state.state === State.headers) {
+        const result = headerParser(chunk, state.headerSkip)
+        state.headerSkip = 0
+
+        if (result._tag === "Continue") {
+          return
+        } else if (result._tag === "Failure") {
+          skipBody()
+          return onError({ _tag: "BadHeaders", error: result })
+        }
+
+        const contentType = CT.parse(result.headers["content-type"] as string)
+        const contentDisposition = CT.parse(
+          result.headers["content-disposition"] as string,
+          true
+        )
+
+        if (
+          "form-data" === contentDisposition.value &&
+          !("name" in contentDisposition.parameters)
+        ) {
+          skipBody()
+          return onError(errInvalidDisposition)
+        }
+
+        let encodedFilename: string | undefined
+        if ("filename*" in contentDisposition.parameters) {
+          const parts = contentDisposition.parameters["filename*"].split("''")
+          if (parts.length === 2) {
+            try {
+              encodedFilename = decodeURIComponent(parts[1])
+            } catch {
+              encodedFilename = parts[1]
+            }
+          }
+        }
+
+        state.info = {
+          name: contentDisposition.parameters.name ?? "",
+          filename: encodedFilename ?? contentDisposition.parameters.filename,
+          contentType: contentType.value === ""
+            ? contentDisposition.parameters.filename !== undefined
+              ? "application/octet-stream"
+              : "text/plain"
+            : contentType.value,
+          contentTypeParameters: contentType.parameters,
+          contentDisposition: contentDisposition.value,
+          contentDispositionParameters: contentDisposition.parameters as any,
+          headers: result.headers
+        }
+
+        state.state = State.body
+        state.isFile = isFile(state.info)
+
+        if (state.isFile) {
+          state.onChunk = onPart(state.info)
+        }
+
+        if (result.endPosition < chunk.length) {
+          if (state.isFile) {
+            state.onChunk(chunk.subarray(result.endPosition))
+          } else {
+            const buf = chunk.subarray(result.endPosition)
+            if ((state.fieldSize += buf.length) > maxFieldSize) {
+              return stop(errMaxFieldSize)
+            }
+            state.fieldChunks.push(buf)
+          }
+        }
+      } else if (state.isFile) {
+        state.onChunk(chunk)
+      } else {
+        if ((state.fieldSize += chunk.length) > maxFieldSize) {
+          return stop(errMaxFieldSize)
+        }
+        state.fieldChunks.push(chunk)
+      }
+    },
+    constCR,
+    2
+  )
+
+  return {
+    write(chunk: Uint8Array) {
+      if (state.stopped) {
+        return
+      }
+      if ((state.totalSize += chunk.length) > maxTotalSize) {
+        return stop(errMaxTotalSize)
+      }
+      return split.write(chunk)
+    },
+    end() {
+      split.end()
+      if (!state.done && !state.stopped) {
+        stop(errEndNotReached)
+      }
+
+      state.state = State.headers
+      state.index = 0
+      state.parts = 0
+      state.onChunk = noopOnChunk
+      state.info = undefined as any as PartInfo
+      state.totalSize = 0
+      state.partSize = 0
+      state.fieldChunks = []
+      state.fieldSize = 0
+      state.done = false
+      state.stopped = false
+    }
+  } as const
+}
+
+const utf8Decoder = new TextDecoder("utf-8")
+function getDecoder(charset: string) {
+  if (charset === "utf-8" || charset === "utf8" || charset === "") {
+    return utf8Decoder
+  }
+
+  try {
+    return new TextDecoder(charset)
+  } catch (error) {
+    return utf8Decoder
+  }
+}
+
+export function decodeField(info: PartInfo, value: Uint8Array): string {
+  return getDecoder(info.contentTypeParameters.charset ?? "utf-8").decode(value)
+}