effect 4.0.0-rc.111 → 4.0.0-rc.113

package/src/unstable/http/Mime.ts

@@ -0,0 +1,76 @@
+/**
+ * Standard MIME type lookup.
+ *
+ * @since 4.0.0
+ */
+import * as Option from "../../Option.ts"
+import standardTypes from "./internal/mimeTypes.ts"
+
+const extensionToType = new Map<string, string>()
+const typeToExtension = new Map<string, string>()
+const typeToExtensions = new Map<string, Set<string>>()
+
+for (const [type, extensions] of Object.entries(standardTypes)) {
+  const allExtensions = new Set<string>()
+  typeToExtensions.set(type, allExtensions)
+  for (let index = 0; index < extensions.length; index++) {
+    let extension: string = extensions[index]
+    const starred = extension.startsWith("*")
+    if (starred) {
+      extension = extension.slice(1)
+    }
+    allExtensions.add(extension)
+    if (index === 0) {
+      typeToExtension.set(type, extension)
+    }
+    if (!starred) {
+      extensionToType.set(extension, type)
+    }
+  }
+}
+
+/**
+ * Returns the standard MIME type associated with a file name or extension.
+ *
+ * @category utilities
+ * @since 4.0.0
+ */
+export const getType = (path: string): Option.Option<string> => {
+  if (typeof path !== "string") {
+    return Option.none()
+  }
+  const last = path.replace(/^.*[/\\]/s, "").toLowerCase()
+  const extension = last.replace(/^.*\./s, "").toLowerCase()
+  const hasPath = last.length < path.length
+  const hasDot = extension.length < last.length - 1
+  if (!hasDot && hasPath) {
+    return Option.none()
+  }
+  return Option.fromUndefinedOr(extensionToType.get(extension))
+}
+
+/**
+ * Returns the default file extension associated with a standard MIME type.
+ *
+ * @category utilities
+ * @since 4.0.0
+ */
+export const getExtension = (type: string): Option.Option<string> => {
+  if (typeof type !== "string") {
+    return Option.none()
+  }
+  return Option.fromUndefinedOr(typeToExtension.get(type.split(";")[0].trim().toLowerCase()))
+}
+
+/**
+ * Returns every file extension associated with a standard MIME type.
+ *
+ * @category utilities
+ * @since 4.0.0
+ */
+export const getAllExtensions = (type: string): Option.Option<ReadonlySet<string>> => {
+  if (typeof type !== "string") {
+    return Option.none()
+  }
+  return Option.fromUndefinedOr(typeToExtensions.get(type.split(";")[0].trim().toLowerCase()))
+}

package/src/unstable/http/Multipart.ts

@@ -11,6 +11,7 @@
  * @since 4.0.0
  */
 import * as Arr from "../../Array.ts"
+import * as ByteSize from "../../ByteSize.ts"
 import * as Cause from "../../Cause.ts"
 import * as Channel from "../../Channel.ts"
 import * as Context from "../../Context.ts"
@@ -30,7 +31,6 @@ import type { ParseOptions } from "../../SchemaAST.ts"
 import * as SchemaTransformation from "../../SchemaTransformation.ts"
 import type * as Scope from "../../Scope.ts"
 import * as Stream from "../../Stream.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 import * as IncomingMessage from "./HttpIncomingMessage.ts"
 import * as HttpServerRespondable from "./HttpServerRespondable.ts"
 import * as HttpServerResponse from "./HttpServerResponse.ts"
@@ -98,13 +98,26 @@ export interface Field extends Part.Proto {
 }
 
 /**
- * Returns `true` when a value is a multipart `Part`.
+ * Returns `true` when a value has the multipart part type identifier.
+ *
+ * **Details**
+ *
+ * This includes `Field`, `File`, and `PersistedFile` values. Use
+ * `isStreamPart` to identify only parsed, streamed parts.
  *
  * @category guards
  * @since 4.0.0
  */
 export const isPart = (u: unknown): u is Part => Predicate.hasProperty(u, TypeId)
 
+/**
+ * Returns `true` when a value is a multipart text `Field` or streamed `File`.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export const isStreamPart = (u: unknown): u is Part => isPart(u) && (u._tag === "Field" || u._tag === "File")
+
 /**
  * Returns `true` when a value is a multipart text `Field`.
  *
@@ -422,9 +435,9 @@ export const makeConfig = (
     return Effect.succeed<MP.BaseConfig>({
       headers,
       maxParts: fiber.getRef(MaxParts),
-      maxFieldSize: Number(fiber.getRef(MaxFieldSize)),
-      maxPartSize: UndefinedOr.map(fiber.getRef(MaxFileSize), Number),
-      maxTotalSize: UndefinedOr.map(fiber.getRef(IncomingMessage.MaxBodySize), Number),
+      maxFieldSize: fiber.getRef(MaxFieldSize),
+      maxPartSize: fiber.getRef(MaxFileSize),
+      maxTotalSize: fiber.getRef(IncomingMessage.MaxBodySize),
       isFile: mimeTypes.length === 0 ? undefined : (info: MP.PartInfo): boolean =>
         !mimeTypes.some(
           (_) => info.contentType.includes(_)
@@ -456,6 +469,7 @@ export const makeChannel = <IE>(headers: Record<string, string>): Channel.Channe
     Effect.map(makeConfig(headers), (config) => {
       let partsBuffer: Array<Part> = []
       let exit = Option.none<Exit.Exit<never, IE | MultipartError | Cause.Done>>()
+      let ended = false
 
       const parser = MP.make({
         ...config,
@@ -503,7 +517,10 @@ export const makeChannel = <IE>(headers: Record<string, string>): Channel.Channe
         }),
         Effect.catchCause((cause) => {
           if (Pull.isDoneCause(cause)) {
-            parser.end()
+            if (!ended) {
+              ended = true
+              parser.end()
+            }
           } else {
             exit = Option.some(Exit.failCause(cause)) as any
           }
@@ -757,9 +774,9 @@ class PersistedFileImpl extends PartBase implements PersistedFile {
  */
 export const limitsServices = (options: {
   readonly maxParts?: number | undefined
-  readonly maxFieldSize?: FileSystem.SizeInput | undefined
-  readonly maxFileSize?: FileSystem.SizeInput | undefined
-  readonly maxTotalSize?: FileSystem.SizeInput | undefined
+  readonly maxFieldSize?: ByteSize.Input | undefined
+  readonly maxFileSize?: ByteSize.Input | undefined
+  readonly maxTotalSize?: ByteSize.Input | undefined
   readonly fieldMimeTypes?: ReadonlyArray<string> | undefined
 }): Context.Context<never> => {
   const map = new Map<string, unknown>()
@@ -767,13 +784,13 @@ export const limitsServices = (options: {
     map.set(MaxParts.key, options.maxParts)
   }
   if (options.maxFieldSize !== undefined) {
-    map.set(MaxFieldSize.key, FileSystem.Size(options.maxFieldSize))
+    map.set(MaxFieldSize.key, ByteSize.fromInputUnsafe(options.maxFieldSize))
   }
   if (options.maxFileSize !== undefined) {
-    map.set(MaxFileSize.key, UndefinedOr.map(options.maxFileSize, FileSystem.Size))
+    map.set(MaxFileSize.key, ByteSize.fromInputUnsafe(options.maxFileSize))
   }
   if (options.maxTotalSize !== undefined) {
-    map.set(IncomingMessage.MaxBodySize.key, UndefinedOr.map(options.maxTotalSize, FileSystem.Size))
+    map.set(IncomingMessage.MaxBodySize.key, ByteSize.fromInputUnsafe(options.maxTotalSize))
   }
   if (options.fieldMimeTypes !== undefined) {
     map.set(FieldMimeTypes.key, options.fieldMimeTypes)
@@ -800,9 +817,9 @@ export declare namespace withLimits {
    */
   export type Options = {
     readonly maxParts?: number | undefined
-    readonly maxFieldSize?: FileSystem.SizeInput | undefined
-    readonly maxFileSize?: FileSystem.SizeInput | undefined
-    readonly maxTotalSize?: FileSystem.SizeInput | undefined
+    readonly maxFieldSize?: ByteSize.Input | undefined
+    readonly maxFileSize?: ByteSize.Input | undefined
+    readonly maxTotalSize?: ByteSize.Input | undefined
     readonly fieldMimeTypes?: ReadonlyArray<string> | undefined
   }
 }
@@ -831,8 +848,8 @@ export const MaxParts = Context.Reference<number | undefined>("effect/http/Multi
  * @category services
  * @since 4.0.0
  */
-export const MaxFieldSize = Context.Reference<FileSystem.SizeInput>("effect/http/Multipart/MaxFieldSize", {
-  defaultValue: constant(FileSystem.Size(10 * 1024 * 1024))
+export const MaxFieldSize = Context.Reference<ByteSize.ByteSize>("effect/http/Multipart/MaxFieldSize", {
+  defaultValue: constant(ByteSize.mebibytes(10))
 })
 
 /**
@@ -845,7 +862,7 @@ export const MaxFieldSize = Context.Reference<FileSystem.SizeInput>("effect/http
  * @category services
  * @since 4.0.0
  */
-export const MaxFileSize = Context.Reference<FileSystem.SizeInput | undefined>(
+export const MaxFileSize = Context.Reference<ByteSize.ByteSize | undefined>(
   "effect/http/Multipart/MaxFileSize",
   { defaultValue: () => undefined }
 )

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

@@ -1,3 +1,4 @@
+import * as ByteSize from "../../../../ByteSize.ts"
 import type { Config, MultipartError, PartInfo } from "../../MultipartParser.ts"
 import * as CT from "./contentType.ts"
 import * as HP from "./headers.ts"
@@ -41,6 +42,9 @@ function parseBoundary(headers: Record<string, string>) {
 
 function noopOnChunk(_chunk: Uint8Array | null) {}
 
+const toLimit = (input: ByteSize.Input): number =>
+  input === Infinity ? Infinity : Number(ByteSize.fromInputUnsafe(input))
+
 export function make({
   headers,
   onFile: onPart,
@@ -49,10 +53,13 @@ export function make({
   onDone,
   isFile = defaultIsFile,
   maxParts = Infinity,
-  maxTotalSize = Infinity,
-  maxPartSize = Infinity,
-  maxFieldSize = 1024 * 1024
+  maxTotalSize: maxTotalSizeInput = Infinity,
+  maxPartSize: maxPartSizeInput = Infinity,
+  maxFieldSize: maxFieldSizeInput = 1024 * 1024
 }: Config) {
+  const maxTotalSize = toLimit(maxTotalSizeInput)
+  const maxPartSize = toLimit(maxPartSizeInput)
+  const maxFieldSize = toLimit(maxFieldSizeInput)
   const boundary = parseBoundary(headers)
   if (boundary === undefined) {
     onError({ _tag: "InvalidBoundary" })

package/src/unstable/http/MultipartParser.ts

@@ -3,6 +3,7 @@
  *
  * @since 4.0.0
  */
+import type * as ByteSize from "../../ByteSize.ts"
 import type * as HeadersParser from "./MultipartParser/HeadersParser.ts"
 import * as internal from "./MultipartParser/internal/multipart.ts"
 
@@ -61,9 +62,9 @@ export type BaseConfig = {
   readonly headers: Record<string, string>
   readonly isFile?: ((info: PartInfo) => boolean) | undefined
   readonly maxParts?: number | undefined
-  readonly maxTotalSize?: number | undefined
-  readonly maxPartSize?: number | undefined
-  readonly maxFieldSize?: number | undefined
+  readonly maxTotalSize?: ByteSize.Input | undefined
+  readonly maxPartSize?: ByteSize.Input | undefined
+  readonly maxFieldSize?: ByteSize.Input | undefined
 }
 
 /**

package/src/unstable/http/UrlParams.ts

@@ -9,7 +9,6 @@
  * @since 4.0.0
  */
 import * as Arr from "../../Array.ts"
-import * as Effect from "../../Effect.ts"
 import * as Equal from "../../Equal.ts"
 import * as Equ from "../../Equivalence.ts"
 import { dual } from "../../Function.ts"
@@ -21,11 +20,7 @@ import * as Option from "../../Option.ts"
 import type { Pipeable } from "../../Pipeable.ts"
 import { hasProperty } from "../../Predicate.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
-import * as Schema from "../../Schema.ts"
-import * as SchemaIssue from "../../SchemaIssue.ts"
-import * as SchemaTransformation from "../../SchemaTransformation.ts"
 import * as Tuple from "../../Tuple.ts"
-import type { JsonOptions } from "./HttpIncomingMessage.ts"
 
 const TypeId = "~effect/http/UrlParams"
 
@@ -186,7 +181,7 @@ const fromInputNested = (input: Input): Array<[string | Array<string>, any]> =>
           out.push([key, String(value[i])])
         }
       }
-    } else if (typeof value === "object") {
+    } else if (value !== null && typeof value === "object") {
       const nested = fromInputNested(value as CoercibleRecord)
       for (const [k, v] of nested) {
         out.push([[key, ...(typeof k === "string" ? [k] : k)], v])
@@ -217,49 +212,6 @@ const arrayEquivalence = Arr.makeEquivalence(
   Tuple.makeEquivalence([Equ.strictEqual<string>(), Equ.strictEqual<string>()])
 )
 
-/**
- * Schema type for `UrlParams`.
- *
- * @category schemas
- * @since 4.0.0
- */
-export interface UrlParamsSchema extends Schema.declare<UrlParams, ReadonlyArray<readonly [string, string]>> {}
-
-/**
- * Schema for `UrlParams`.
- *
- * **Details**
- *
- * The encoded representation is an array of string key-value tuples.
- *
- * @category schemas
- * @since 4.0.0
- */
-export const UrlParamsSchema: UrlParamsSchema = Schema.declare(
-  isUrlParams,
-  {
-    representation: {
-      id: "effect/http/UrlParams",
-      payload: null
-    },
-    toCode: () => ({
-      runtime: "UrlParams.UrlParamsSchema",
-      Type: "UrlParams.UrlParams",
-      importDeclarations: [`import * as UrlParams from "effect/unstable/http/UrlParams"`]
-    }),
-    expected: "UrlParams",
-    toEquivalence: () => Equivalence,
-    toCodec: () =>
-      Schema.link<UrlParams>()(
-        Schema.Array(Schema.Tuple([Schema.String, Schema.String])),
-        SchemaTransformation.transform({
-          decode: make,
-          encode: (self) => self.params
-        })
-      )
-  }
-)
-
 /**
  * An empty `UrlParams` value.
  *
@@ -540,8 +492,7 @@ export const setAll: {
    */
   (self: UrlParams, input: Input): UrlParams
 } = dual(2, (self: UrlParams, input: Input): UrlParams => {
-  const out = fromInput(input)
-  const params = out.params as Array<readonly [string, string]>
+  const params = fromInput(input).params.slice()
   const keys = new Set()
   for (let i = 0; i < params.length; i++) {
     keys.add(params[i][0])
@@ -550,7 +501,7 @@ export const setAll: {
     if (keys.has(self.params[i][0])) continue
     params.push(self.params[i])
   }
-  return out
+  return make(params)
 })
 
 /**
@@ -698,112 +649,3 @@ export const toRecord = (self: UrlParams): Record<string, string | Arr.NonEmptyA
  */
 export const toReadonlyRecord: (self: UrlParams) => ReadonlyRecord<string, string | Arr.NonEmptyReadonlyArray<string>> =
   toRecord as any
-
-/**
- * Schema type for decoding one URL parameter field as JSON.
- *
- * @category schemas
- * @since 4.0.0
- */
-export interface schemaJsonField extends Schema.decodeTo<Schema.fromJsonString<Schema.Unknown>, UrlParamsSchema> {}
-
-/**
- * Extracts a JSON value from the first occurrence of the given `field` in the
- * `UrlParams`.
- *
- * **Example** (Decoding JSON parameter fields)
- *
- * ```ts import.meta.vitest
- * import { Schema } from "effect"
- * import { UrlParams } from "effect/unstable/http"
- *
- * const extractFoo = UrlParams.schemaJsonField("foo").pipe(
- *   Schema.decodeTo(Schema.Struct({
- *     some: Schema.String,
- *     number: Schema.Number
- *   }))
- * )
- *
- * const decoded = Schema.decodeSync(extractFoo)(UrlParams.fromInput({
- *     foo: `{"some":"bar","number":42}`,
- *     baz: "qux"
- *   }))
- * const result = [decoded.some, decoded.number] // => ["bar", 42]
- * ```
- *
- * @category schemas
- * @since 4.0.0
- */
-export const schemaJsonField = (field: string, options?: JsonOptions | undefined): schemaJsonField =>
-  UrlParamsSchema.pipe(
-    Schema.decodeTo(
-      Schema.fromJsonString(Schema.Unknown, options),
-      SchemaTransformation.transformOrFail({
-        decode: (params) =>
-          Option.match(getFirst(params, field), {
-            onNone: () => Effect.fail(new SchemaIssue.Pointer([field], new SchemaIssue.MissingKey(undefined))),
-            onSome: Effect.succeed
-          }),
-        encode: (value) => Effect.succeed(make([[field, value]]))
-      })
-    )
-  )
-
-/**
- * Extract a record of key-value pairs from the `UrlParams`.
- *
- * @category schemas
- * @since 4.0.0
- */
-export interface schemaRecord extends
-  Schema.decodeTo<
-    Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.NonEmptyArray<Schema.String>]>>,
-    UrlParamsSchema,
-    never,
-    never
-  >
-{}
-
-/**
- * Schema that decodes `UrlParams` into a record of key-value pairs.
- *
- * **Details**
- *
- * Keys with one value decode to a string, and keys with multiple values decode to
- * a non-empty readonly array of strings.
- *
- * **Example** (Decoding URL parameters to a record)
- *
- * ```ts import.meta.vitest
- * import { Schema } from "effect"
- * import { UrlParams } from "effect/unstable/http"
- *
- * const toStruct = UrlParams.schemaRecord.pipe(
- *   Schema.decodeTo(Schema.Struct({
- *     some: Schema.String,
- *     number: Schema.FiniteFromString
- *   }))
- * )
- *
- * const decoded = Schema.decodeSync(toStruct)(UrlParams.fromInput({
- *     some: "value",
- *     number: 42
- *   }))
- * const result = [decoded.some, decoded.number] // => ["value", 42]
- * ```
- *
- * @category schemas
- * @since 4.0.0
- */
-export const schemaRecord: schemaRecord = UrlParamsSchema.pipe(
-  Schema.decodeTo(
-    Schema.Record(
-      Schema.String,
-      Schema.Union([Schema.String, Schema.NonEmptyArray(Schema.String)])
-    ),
-    SchemaTransformation.transform({
-      decode: toReadonlyRecord,
-      encode: fromInput
-    })
-  )
-)

package/src/unstable/http/index.ts

@@ -124,6 +124,11 @@ export * as HttpStatus from "./HttpStatus.ts"
  */
 export * as HttpTraceContext from "./HttpTraceContext.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as Mime from "./Mime.ts"
+
 /**
  * @since 4.0.0
  */

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

@@ -7,15 +7,13 @@ import type { Compression, CompressionAlgorithm, CompressionOptions } from "../H
 import * as Response from "../HttpServerResponse.ts"
 
 /** @internal */
-export const varyAcceptEncoding = (headers: Headers.Headers): string | undefined => {
+export const varyWith = (headers: Headers.Headers, dimension: string): string => {
   const vary = headers["vary"]
   if (vary === undefined) {
-    return "Accept-Encoding"
+    return dimension
   }
   const members = vary.split(",").map((member) => member.trim().toLowerCase())
-  return members.includes("*") || members.includes("accept-encoding")
-    ? undefined
-    : `${vary}, Accept-Encoding`
+  return members.includes("*") || members.includes(dimension.toLowerCase()) ? vary : `${vary}, ${dimension}`
 }
 
 /** @internal */
@@ -26,10 +24,9 @@ export const wrapCompression = (impl: Compression): Compression => ({
       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 headers: Record<string, string> = {
+        "content-encoding": algorithm,
+        vary: varyWith(compressed.headers, "Accept-Encoding")
       }
       const etag = compressed.headers["etag"]
       if (etag !== undefined && !etag.startsWith("W/")) {
@@ -70,7 +67,7 @@ export const makeCompressionWeb = (options: {
         return Effect.succeed(streamBody(
           response,
           () => options.transform(algorithm, opts)(singleChunkStream(data)),
-          body.contentType
+          response.headers["content-type"] ?? body.contentType
         ))
       }
       case "Stream": {
@@ -78,7 +75,7 @@ export const makeCompressionWeb = (options: {
         return Effect.succeed(streamBody(
           response,
           () => options.transform(algorithm, opts)(Stream.toReadableStream(stream)),
-          body.contentType
+          response.headers["content-type"] ?? body.contentType
         ))
       }
       case "Raw": {
@@ -88,7 +85,9 @@ export const makeCompressionWeb = (options: {
         }
         return Effect.succeed(setBodyWithoutLength(
           response,
-          HttpBody.raw(options.transform(algorithm, opts)(readable), { contentType: body.contentType })
+          HttpBody.raw(options.transform(algorithm, opts)(readable), {
+            contentType: response.headers["content-type"] ?? body.contentType
+          })
         ))
       }
       default: {

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

@@ -0,0 +1,7 @@
+import type { Mutable } from "../../../Types.ts"
+import * as Headers from "../Headers.ts"
+
+const Proto = Object.getPrototypeOf(Headers.empty)
+
+/** @internal */
+export const emptyMutableUnsafe = (): Mutable<Headers.Headers> => Object.create(Proto)

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

@@ -13,3 +13,12 @@ export const updateHeaders = (headers: Headers.Headers, body: HttpBody.HttpBody)
     ? Headers.remove(headers, "content-length")
     : Headers.set(headers, "content-length", body.contentLength.toString())
 }
+
+/** @internal */
+export const parseContentLength = (contentLength: string | null | undefined): number | undefined => {
+  if (contentLength === null || contentLength === undefined || !/^\d+$/.test(contentLength)) {
+    return undefined
+  }
+  const parsed = Number(contentLength)
+  return Number.isSafeInteger(parsed) ? parsed : undefined
+}