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

package/src/unstable/http/UrlParams.ts

@@ -16,6 +16,7 @@ import { dual } from "../../Function.ts"
 import * as Hash from "../../Hash.ts"
 import type { Inspectable } from "../../Inspectable.ts"
 import { PipeInspectableProto } from "../../internal/core.ts"
+import * as InternalRecord from "../../internal/record.ts"
 import * as Option from "../../Option.ts"
 import type { Pipeable } from "../../Pipeable.ts"
 import { hasProperty } from "../../Predicate.ts"
@@ -236,15 +237,15 @@ export interface UrlParamsSchema extends Schema.declare<UrlParams, ReadonlyArray
 export const UrlParamsSchema: UrlParamsSchema = Schema.declare(
   isUrlParams,
   {
-    typeConstructor: {
-      _tag: "effect/http/UrlParams"
-    },
-    generation: {
-      runtime: `UrlParams.UrlParamsSchema`,
-      Type: `UrlParams.UrlParams`,
-      Encoded: `typeof UrlParams.UrlParamsSchema["Encoded"]`,
-      importDeclaration: `import * as UrlParams from "effect/unstable/http/UrlParams"`
+    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: () =>
@@ -651,9 +652,8 @@ export const toString = (input: Input): string => new URLSearchParams(fromInput(
  *
  * **Example** (Converting parameters to a record)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { UrlParams } from "effect/unstable/http"
- * import * as assert from "node:assert"
  *
  * const urlParams = UrlParams.fromInput({
  *   a: 1,
@@ -661,12 +661,7 @@ export const toString = (input: Input): string => new URLSearchParams(fromInput(
  *   c: "string",
  *   e: [1, 2, 3]
  * })
- * const result = UrlParams.toRecord(urlParams)
- *
- * assert.deepStrictEqual(
- *   result,
- *   { "a": "1", "b": "true", "c": "string", "e": ["1", "2", "3"] }
- * )
+ * UrlParams.toRecord(urlParams) // => { a: "1", b: "true", c: "string", e: ["1", "2", "3"] }
  * ```
  *
  * @category converting
@@ -675,13 +670,15 @@ export const toString = (input: Input): string => new URLSearchParams(fromInput(
 export const toRecord = (self: UrlParams): Record<string, string | Arr.NonEmptyArray<string>> => {
   const out: Record<string, string | Arr.NonEmptyArray<string>> = {}
   for (const [k, value] of self.params) {
-    const curr = out[k]
-    if (curr === undefined) {
-      out[k] = value
-    } else if (typeof curr === "string") {
-      out[k] = [curr, value]
+    if (!Object.hasOwn(out, k)) {
+      InternalRecord.assignProperty(out, k, value)
     } else {
-      curr.push(value)
+      const current = out[k]
+      if (typeof current === "string") {
+        InternalRecord.assignProperty(out, k, [current, value])
+      } else {
+        current.push(value)
+      }
     }
   }
   return out
@@ -707,7 +704,7 @@ export const toReadonlyRecord: (self: UrlParams) => ReadonlyRecord<string, strin
  * @category schemas
  * @since 4.0.0
  */
-export interface schemaJsonField extends Schema.decodeTo<Schema.UnknownFromJsonString, UrlParamsSchema> {}
+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
@@ -715,7 +712,7 @@ export interface schemaJsonField extends Schema.decodeTo<Schema.UnknownFromJsonS
  *
  * **Example** (Decoding JSON parameter fields)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { UrlParams } from "effect/unstable/http"
  *
@@ -726,12 +723,11 @@ export interface schemaJsonField extends Schema.decodeTo<Schema.UnknownFromJsonS
  *   }))
  * )
  *
- * console.log(
- *   Schema.decodeSync(extractFoo)(UrlParams.fromInput({
- *     foo: JSON.stringify({ some: "bar", number: 42 }),
+ * const decoded = Schema.decodeSync(extractFoo)(UrlParams.fromInput({
+ *     foo: `{"some":"bar","number":42}`,
  *     baz: "qux"
  *   }))
- * )
+ * const result = [decoded.some, decoded.number] // => ["bar", 42]
  * ```
  *
  * @category schemas
@@ -777,7 +773,7 @@ export interface schemaRecord extends
  *
  * **Example** (Decoding URL parameters to a record)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { UrlParams } from "effect/unstable/http"
  *
@@ -788,12 +784,11 @@ export interface schemaRecord extends
  *   }))
  * )
  *
- * console.log(
- *   Schema.decodeSync(toStruct)(UrlParams.fromInput({
+ * const decoded = Schema.decodeSync(toStruct)(UrlParams.fromInput({
  *     some: "value",
  *     number: 42
  *   }))
- * )
+ * const result = [decoded.some, decoded.number] // => ["value", 42]
  * ```
  *
  * @category schemas

package/src/unstable/http/index.ts

@@ -127,7 +127,7 @@ export * as Multipart from "./Multipart.ts"
 /**
  * @since 4.0.0
  */
-export * as Multipasta from "./Multipasta.ts"
+export * as MultipartParser from "./MultipartParser.ts"
 
 /**
  * @since 4.0.0

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/http/internal/httpBody.ts

@@ -0,0 +1,15 @@
+import * as Headers from "../Headers.ts"
+import type * as HttpBody from "../HttpBody.ts"
+
+/** @internal */
+export const updateHeaders = (headers: Headers.Headers, body: HttpBody.HttpBody): Headers.Headers => {
+  if (body._tag === "Empty" || body._tag === "FormData") {
+    return Headers.remove(Headers.remove(headers, "content-type"), "content-length")
+  }
+  headers = body.contentType === undefined
+    ? Headers.remove(headers, "content-type")
+    : Headers.set(headers, "content-type", body.contentType)
+  return body.contentLength === undefined
+    ? Headers.remove(headers, "content-length")
+    : Headers.set(headers, "content-length", body.contentLength.toString())
+}

package/src/unstable/httpapi/HttpApi.ts

@@ -10,12 +10,11 @@
  */
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import * as Context from "../../Context.ts"
-import * as internalRecord from "../../internal/record.ts"
+import * as InternalRecord from "../../internal/record.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Record from "../../Record.ts"
 import type * as Schema from "../../Schema.ts"
-import type * as SchemaAST from "../../SchemaAST.ts"
 import type { PathInput } from "../http/HttpRouter.ts"
 import * as HttpApiEndpoint from "./HttpApiEndpoint.ts"
 import type * as HttpApiGroup from "./HttpApiGroup.ts"
@@ -145,7 +144,7 @@ const Proto = {
   ) {
     const groups = { ...this.groups }
     for (const group of toAdd) {
-      internalRecord.set(groups, group.identifier, group)
+      InternalRecord.assignProperty(groups, group.identifier, group)
     }
     return makeProto({
       ...optionsFromApi(this),
@@ -157,9 +156,9 @@ const Proto = {
     api: Top
   ) {
     const newGroups = { ...this.groups }
-    for (const key in api.groups) {
+    for (const key of Object.keys(api.groups)) {
       const group = api.groups[key]
-      internalRecord.set(
+      InternalRecord.assignProperty(
         newGroups,
         key,
         group.annotateMerge(Context.merge(api.annotations, group.annotations))
@@ -290,11 +289,11 @@ export const reflect = <Id extends string, Groups extends HttpApiGroup.Constrain
         mergedAnnotations: Context.merge(groupAnnotations, endpoint.annotations),
         successes: extractResponseContent(
           HttpApiEndpoint.getSuccessSchemas(endpoint),
-          HttpApiSchema.getStatusSuccess
+          HttpApiSchema.getStatusSuccessSchema
         ),
         errors: extractResponseContent(
           HttpApiEndpoint.getErrorSchemas(endpoint),
-          HttpApiSchema.getStatusError
+          HttpApiSchema.getStatusErrorSchema
         )
       })
     }
@@ -305,7 +304,7 @@ export const reflect = <Id extends string, Groups extends HttpApiGroup.Constrain
 
 const extractResponseContent = (
   schemas: Array<Schema.Top>,
-  getStatus: (ast: SchemaAST.AST) => number
+  getStatus: (schema: Schema.Constraint) => number
 ): ReadonlyMap<number, [Schema.Top, ...Array<Schema.Top>]> => {
   const map = new Map<number, [Schema.Top, ...Array<Schema.Top>]>()
 
@@ -314,9 +313,9 @@ const extractResponseContent = (
   return map
 
   function add(schema: Schema.Top) {
-    if (HttpApiSchema.isStreamSchema(schema)) return
-    const ast = schema.ast
-    const status = getStatus(ast)
+    const body = HttpApiSchema.isWithHeaders(schema) ? schema.schema : schema
+    if (HttpApiSchema.isStreamSchema(body)) return
+    const status = getStatus(schema)
     const schemas = map.get(status)
     if (schemas === undefined) {
       map.set(status, [schema])