effect 4.0.0-rc.112 → 4.0.0-rc.113

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