@effect/platform 0.18.1 → 0.18.3

package/internal/http/client.esm.js

@@ -0,0 +1,157 @@
+import * as Schema from '@effect/schema/Schema';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import { dual, pipe } from 'effect/Function';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+import { pipeArguments } from 'effect/Pipeable';
+import * as Stream from 'effect/Stream';
+import { schemaExternalSpan } from '../../Http/Http/IncomingMessage/dist/effect-platform-Http-IncomingMessage.esm.js';
+import { hasBody } from '../../Http/Http/Method/dist/effect-platform-Http-Method.esm.js';
+import { makeUrl } from '../../Http/Http/UrlParams/dist/effect-platform-Http-UrlParams.esm.js';
+import { uint8Array } from './body.esm.js';
+import { requestError, responseError } from './clientError.esm.js';
+import { setHeader, setBody } from './clientRequest.esm.js';
+import { fromWeb } from './clientResponse.esm.js';
+
+/** @internal */
+const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/Client");
+
+/** @internal */
+const tag = /*#__PURE__*/Context.Tag(TypeId);
+const clientProto = {
+  [TypeId]: TypeId,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+
+/** @internal */
+const make = f => {
+  Object.setPrototypeOf(f, clientProto);
+  return f;
+};
+
+/** @internal */
+const fetch = (options = {}) => make(request => Effect.flatMap(makeUrl(request.url, request.urlParams, _ => requestError({
+  request,
+  reason: "InvalidUrl",
+  error: _
+})), url => Effect.suspend(() => {
+  const headers = new Headers(request.headers);
+  const send = body => Effect.map(Effect.tryPromise({
+    try: signal => globalThis.fetch(url, {
+      ...options,
+      method: request.method,
+      headers,
+      body,
+      signal
+    }),
+    catch: _ => requestError({
+      request,
+      reason: "Transport",
+      error: _
+    })
+  }), _ => fromWeb(request, _));
+  if (hasBody(request.method)) {
+    return send(convertBody(request.body));
+  }
+  return send(undefined);
+})));
+const convertBody = body => {
+  switch (body._tag) {
+    case "Empty":
+      return undefined;
+    case "Raw":
+      return body.body;
+    case "Uint8Array":
+      return body.body;
+    case "FormData":
+      return body.formData;
+    case "Stream":
+      return Stream.toReadableStream(body.stream);
+  }
+};
+
+/** @internal */
+const fetchOk = (options = {}) => filterStatusOk(fetch(options));
+
+/** @internal */
+const layer = /*#__PURE__*/Layer.succeed(tag, /*#__PURE__*/fetch());
+
+/** @internal */
+const transform = /*#__PURE__*/dual(2, (self, f) => make(f(self)));
+
+/** @internal */
+const transformResponse = /*#__PURE__*/dual(2, (self, f) => make(request => f(self(request))));
+
+/** @internal */
+const catchTag = /*#__PURE__*/dual(3, (self, tag, f) => make(request => Effect.catchTag(self(request), tag, f)));
+
+/** @internal */
+const catchTags = /*#__PURE__*/dual(2, (self, cases) => make(request => Effect.catchTags(self(request), cases)));
+
+/** @internal */
+const catchAll = /*#__PURE__*/dual(2, (self, f) => make(request => Effect.catchAll(self(request), f)));
+
+/** @internal */
+const filterOrElse = /*#__PURE__*/dual(3, (self, f, orElse) => make(request => Effect.filterOrElse(self(request), f, orElse)));
+
+/** @internal */
+const filterOrFail = /*#__PURE__*/dual(3, (self, f, orFailWith) => make(request => Effect.filterOrFail(self(request), f, orFailWith)));
+
+/** @internal */
+const filterStatus = /*#__PURE__*/dual(2, (self, f) => make(request => Effect.filterOrFail(self(request), response => f(response.status), response => responseError({
+  request,
+  response,
+  reason: "StatusCode",
+  error: "non 2xx status code"
+}))));
+
+/** @internal */
+const filterStatusOk = /*#__PURE__*/filterStatus(status => status >= 200 && status < 300);
+
+/** @internal */
+const map = /*#__PURE__*/dual(2, (self, f) => make(request => Effect.map(self(request), f)));
+
+/** @internal */
+const mapEffect = /*#__PURE__*/dual(2, (self, f) => make(request => Effect.flatMap(self(request), f)));
+
+/** @internal */
+const mapRequest = /*#__PURE__*/dual(2, (self, f) => make(request => self(f(request))));
+
+/** @internal */
+const mapRequestEffect = /*#__PURE__*/dual(2, (self, f) => make(request => Effect.flatMap(f(request), self)));
+
+/** @internal */
+const withB3Propagation = self => make(req => pipe(Effect.map(Effect.currentSpan, Option.match({
+  onNone: () => req,
+  onSome: span => {
+    const parentId = span.parent._tag === "Some" ? `-${span.parent.value.spanId}` : "";
+    return setHeader(req, "b3", `${span.traceId}-${span.spanId}-1${parentId}`);
+  }
+})), Effect.flatMap(self), Effect.tap(res => Effect.ignore(Effect.flatMap(schemaExternalSpan(res), Effect.withParentSpanScoped)))));
+
+/** @internal */
+const retry = /*#__PURE__*/dual(2, (self, policy) => make(request => Effect.retry(self(request), policy)));
+
+/** @internal */
+const schemaFunction = /*#__PURE__*/dual(2, (self, schema) => {
+  const encode = Schema.encode(schema);
+  return request => a => Effect.flatMap(Effect.tryMap(encode(a), {
+    try: body => new TextEncoder().encode(JSON.stringify(body)),
+    catch: error => requestError({
+      request,
+      reason: "Encode",
+      error
+    })
+  }), body => self(setBody(request, uint8Array(body, "application/json"))));
+});
+
+/** @internal */
+const tap = /*#__PURE__*/dual(2, (self, f) => make(request => Effect.tap(self(request), f)));
+
+/** @internal */
+const tapRequest = /*#__PURE__*/dual(2, (self, f) => make(request => Effect.zipRight(f(request), self(request))));
+
+export { TypeId, catchAll, catchTag, catchTags, fetch, fetchOk, filterOrElse, filterOrFail, filterStatus, filterStatusOk, layer, make, map, mapEffect, mapRequest, mapRequestEffect, retry, schemaFunction, tag, tap, tapRequest, transform, transformResponse, withB3Propagation };

package/internal/http/clientError.esm.js

@@ -0,0 +1,17 @@
+import * as Data from 'effect/Data';
+
+/** @internal */
+const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/Error");
+const make = tag => props => Data.struct({
+  [TypeId]: TypeId,
+  _tag: tag,
+  ...props
+});
+
+/** @internal */
+const requestError = /*#__PURE__*/make("RequestError");
+
+/** @internal */
+const responseError = /*#__PURE__*/make("ResponseError");
+
+export { TypeId, requestError, responseError };

package/internal/http/clientRequest.esm.js

@@ -0,0 +1,184 @@
+import * as Effect from 'effect/Effect';
+import { dual } from 'effect/Function';
+import { pipeArguments } from 'effect/Pipeable';
+import { set, setAll, remove, empty as empty$2 } from '../../Http/Http/Headers/dist/effect-platform-Http-Headers.esm.js';
+import { append, appendAll, set as set$1, setAll as setAll$1, toString, fromInput, empty as empty$1 } from '../../Http/Http/UrlParams/dist/effect-platform-Http-UrlParams.esm.js';
+import { uint8Array, text, json, unsafeJson, file, fileWeb, jsonSchema, formData, stream, empty as empty$3 } from './body.esm.js';
+
+/** @internal */
+const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/ClientRequest");
+class ClientRequestImpl {
+  constructor(method, url, urlParams, headers, body) {
+    this.method = method;
+    this.url = url;
+    this.urlParams = urlParams;
+    this.headers = headers;
+    this.body = body;
+    this[TypeId] = TypeId;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+}
+
+/** @internal */
+const isClientRequest = u => typeof u === "object" && u !== null && TypeId in u;
+
+/** @internal */
+const empty = /*#__PURE__*/new ClientRequestImpl("GET", "", empty$1, empty$2, empty$3);
+
+/** @internal */
+const make = method => (url, options) => modify(empty, {
+  method,
+  url,
+  ...(options ?? {})
+});
+
+/** @internal */
+const get = /*#__PURE__*/make("GET");
+
+/** @internal */
+const post = /*#__PURE__*/make("POST");
+
+/** @internal */
+const put = /*#__PURE__*/make("PUT");
+
+/** @internal */
+const patch = /*#__PURE__*/make("PATCH");
+
+/** @internal */
+const del = /*#__PURE__*/make("DELETE");
+
+/** @internal */
+const head = /*#__PURE__*/make("HEAD");
+
+/** @internal */
+const options = /*#__PURE__*/make("OPTIONS");
+
+/** @internal */
+const modify = /*#__PURE__*/dual(2, (self, options) => {
+  let result = self;
+  if (options.method) {
+    result = setMethod(result, options.method);
+  }
+  if (options.url) {
+    result = setUrl(result, options.url);
+  }
+  if (options.headers) {
+    result = setHeaders(result, options.headers);
+  }
+  if (options.urlParams) {
+    result = setUrlParams(result, options.urlParams);
+  }
+  if (options.body) {
+    result = setBody(result, options.body);
+  }
+  if (options.accept) {
+    result = accept(result, options.accept);
+  }
+  if (options.acceptJson) {
+    result = acceptJson(result);
+  }
+  return result;
+});
+
+/** @internal */
+const setHeader = /*#__PURE__*/dual(3, (self, key, value) => new ClientRequestImpl(self.method, self.url, self.urlParams, set(self.headers, key, value), self.body));
+
+/** @internal */
+const setHeaders = /*#__PURE__*/dual(2, (self, input) => new ClientRequestImpl(self.method, self.url, self.urlParams, setAll(self.headers, input), self.body));
+
+/** @internal */
+const basicAuth = /*#__PURE__*/dual(3, (self, username, password) => setHeader(self, "Authorization", `Basic ${btoa(`${username}:${password}`)}`));
+
+/** @internal */
+const bearerToken = /*#__PURE__*/dual(2, (self, token) => setHeader(self, "Authorization", `Bearer ${token}`));
+
+/** @internal */
+const accept = /*#__PURE__*/dual(2, (self, mediaType) => setHeader(self, "Accept", mediaType));
+
+/** @internal */
+const acceptJson = /*#__PURE__*/accept("application/json");
+
+/** @internal */
+const setMethod = /*#__PURE__*/dual(2, (self, method) => new ClientRequestImpl(method, self.url, self.urlParams, self.headers, self.body));
+
+/** @internal */
+const setUrl = /*#__PURE__*/dual(2, (self, url) => new ClientRequestImpl(self.method, url, self.urlParams, self.headers, self.body));
+
+/** @internal */
+const appendUrl = /*#__PURE__*/dual(2, (self, url) => new ClientRequestImpl(self.method, self.url + url, self.urlParams, self.headers, self.body));
+
+/** @internal */
+const prependUrl = /*#__PURE__*/dual(2, (self, url) => new ClientRequestImpl(self.method, url + self.url, self.urlParams, self.headers, self.body));
+
+/** @internal */
+const updateUrl = /*#__PURE__*/dual(2, (self, f) => new ClientRequestImpl(self.method, f(self.url), self.urlParams, self.headers, self.body));
+
+/** @internal */
+const appendUrlParam = /*#__PURE__*/dual(3, (self, key, value) => new ClientRequestImpl(self.method, self.url, append(self.urlParams, key, value), self.headers, self.body));
+
+/** @internal */
+const appendUrlParams = /*#__PURE__*/dual(2, (self, input) => new ClientRequestImpl(self.method, self.url, appendAll(self.urlParams, input), self.headers, self.body));
+
+/** @internal */
+const setUrlParam = /*#__PURE__*/dual(3, (self, key, value) => new ClientRequestImpl(self.method, self.url, set$1(self.urlParams, key, value), self.headers, self.body));
+
+/** @internal */
+const setUrlParams = /*#__PURE__*/dual(2, (self, input) => new ClientRequestImpl(self.method, self.url, setAll$1(self.urlParams, input), self.headers, self.body));
+
+/** @internal */
+const setBody = /*#__PURE__*/dual(2, (self, body) => {
+  let headers = self.headers;
+  if (body._tag === "Empty") {
+    headers = remove(remove(headers, "Content-Type"), "Content-length");
+  } else {
+    const contentType = body.contentType;
+    if (contentType) {
+      headers = set(headers, "content-type", contentType);
+    }
+    const contentLength = body.contentLength;
+    if (contentLength) {
+      headers = set(headers, "content-length", contentLength.toString());
+    }
+  }
+  return new ClientRequestImpl(self.method, self.url, self.urlParams, headers, body);
+});
+
+/** @internal */
+const uint8ArrayBody = /*#__PURE__*/dual(args => isClientRequest(args[0]), (self, body, contentType = "application/octet-stream") => setBody(self, uint8Array(body, contentType)));
+
+/** @internal */
+const textBody = /*#__PURE__*/dual(args => isClientRequest(args[0]), (self, body, contentType = "text/plain") => setBody(self, text(body, contentType)));
+
+/** @internal */
+const jsonBody = /*#__PURE__*/dual(2, (self, body) => Effect.map(json(body), body => setBody(self, body)));
+
+/** @internal */
+const unsafeJsonBody = /*#__PURE__*/dual(2, (self, body) => setBody(self, unsafeJson(body)));
+
+/** @internal */
+const fileBody = /*#__PURE__*/dual(args => isClientRequest(args[0]), (self, path, options) => Effect.map(file(path, options), body => setBody(self, body)));
+
+/** @internal */
+const fileWebBody = /*#__PURE__*/dual(2, (self, file) => setBody(self, fileWeb(file)));
+
+/** @internal */
+const schemaBody = schema => {
+  const encode = jsonSchema(schema);
+  return dual(2, (self, body) => Effect.map(encode(body), body => setBody(self, body)));
+};
+
+/** @internal */
+const urlParamsBody = /*#__PURE__*/dual(2, (self, body) => setBody(self, text(toString(fromInput(body)), "application/x-www-form-urlencoded")));
+
+/** @internal */
+const formDataBody = /*#__PURE__*/dual(2, (self, body) => setBody(self, formData(body)));
+
+/** @internal */
+const streamBody = /*#__PURE__*/dual(args => isClientRequest(args[0]), (self, body, {
+  contentLength,
+  contentType = "application/octet-stream"
+} = {}) => setBody(self, stream(body, contentType, contentLength)));
+
+export { TypeId, accept, acceptJson, appendUrl, appendUrlParam, appendUrlParams, basicAuth, bearerToken, del, empty, fileBody, fileWebBody, formDataBody, get, head, isClientRequest, jsonBody, make, modify, options, patch, post, prependUrl, put, schemaBody, setBody, setHeader, setHeaders, setMethod, setUrl, setUrlParam, setUrlParams, streamBody, textBody, uint8ArrayBody, unsafeJsonBody, updateUrl, urlParamsBody };

package/{mjs/internal/http/clientResponse.mjs → internal/http/clientResponse.esm.js}

@@ -1,38 +1,40 @@
-import * as Headers from "@effect/platform/Http/Headers";
-import * as IncomingMessage from "@effect/platform/Http/IncomingMessage";
-import * as UrlParams from "@effect/platform/Http/UrlParams";
-import * as internalError from "@effect/platform/internal/http/clientError";
-import * as Schema from "@effect/schema/Schema";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Stream from "effect/Stream";
+import * as Schema from '@effect/schema/Schema';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import * as Stream from 'effect/Stream';
+import { fromInput } from '../../Http/Http/Headers/dist/effect-platform-Http-Headers.esm.js';
+import { TypeId as TypeId$1 } from '../../Http/Http/IncomingMessage/dist/effect-platform-Http-IncomingMessage.esm.js';
+import { fromInput as fromInput$1 } from '../../Http/Http/UrlParams/dist/effect-platform-Http-UrlParams.esm.js';
+import { responseError } from './clientError.esm.js';
+
 /** @internal */
-export const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/ClientResponse");
+const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/ClientResponse");
+
 /** @internal */
-export const fromWeb = (request, source) => new ClientResponseImpl(request, source);
+const fromWeb = (request, source) => new ClientResponseImpl(request, source);
 class ClientResponseImpl {
   constructor(request, source) {
     this.request = request;
     this.source = source;
-    this[IncomingMessage.TypeId] = IncomingMessage.TypeId;
+    this[TypeId$1] = TypeId$1;
     this[TypeId] = TypeId;
   }
   get status() {
     return this.source.status;
   }
   get headers() {
-    return Headers.fromInput(this.source.headers);
+    return fromInput(this.source.headers);
   }
   get remoteAddress() {
     return Option.none();
   }
   get stream() {
-    return this.source.body ? Stream.fromReadableStream(() => this.source.body, _ => internalError.responseError({
+    return this.source.body ? Stream.fromReadableStream(() => this.source.body, _ => responseError({
       request: this.request,
       response: this,
       reason: "Decode",
       error: _
-    })) : Stream.fail(internalError.responseError({
+    })) : Stream.fail(responseError({
       request: this.request,
       response: this,
       reason: "EmptyBody",
@@ -42,7 +44,7 @@ class ClientResponseImpl {
   get json() {
     return Effect.tryPromise({
       try: () => this.source.json(),
-      catch: _ => internalError.responseError({
+      catch: _ => responseError({
         request: this.request,
         response: this,
         reason: "Decode",
@@ -53,7 +55,7 @@ class ClientResponseImpl {
   get text() {
     return Effect.tryPromise({
       try: () => this.source.text(),
-      catch: _ => internalError.responseError({
+      catch: _ => responseError({
         request: this.request,
         response: this,
         reason: "Decode",
@@ -63,8 +65,8 @@ class ClientResponseImpl {
   }
   get urlParamsBody() {
     return Effect.flatMap(this.text, _ => Effect.try({
-      try: () => UrlParams.fromInput(new URLSearchParams(_)),
-      catch: _ => internalError.responseError({
+      try: () => fromInput$1(new URLSearchParams(_)),
+      catch: _ => responseError({
         request: this.request,
         response: this,
         reason: "Decode",
@@ -75,7 +77,7 @@ class ClientResponseImpl {
   get formData() {
     return Effect.tryPromise({
       try: () => this.source.formData(),
-      catch: _ => internalError.responseError({
+      catch: _ => responseError({
         request: this.request,
         response: this,
         reason: "Decode",
@@ -86,7 +88,7 @@ class ClientResponseImpl {
   get arrayBuffer() {
     return Effect.tryPromise({
       try: () => this.source.arrayBuffer(),
-      catch: _ => internalError.responseError({
+      catch: _ => responseError({
         request: this.request,
         response: this,
         reason: "Decode",
@@ -95,9 +97,9 @@ class ClientResponseImpl {
     });
   }
 }
-IncomingMessage.TypeId;
+
 /** @internal */
-export const schemaJson = schema => {
+const schemaJson = schema => {
   const parse = Schema.parse(schema);
   return self => Effect.flatMap(self.json, body => parse({
     status: self.status,
@@ -105,4 +107,5 @@ export const schemaJson = schema => {
     body
   }));
 };
-//# sourceMappingURL=clientResponse.mjs.map
+
+export { TypeId, fromWeb, schemaJson };

package/internal/http/etag.esm.js

@@ -0,0 +1,19 @@
+import * as Context from 'effect/Context';
+
+/** @internal */
+const GeneratorTypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/Etag/Generator");
+
+/** @internal */
+const tag = /*#__PURE__*/Context.Tag(GeneratorTypeId);
+
+/** @internal */
+const toString = self => {
+  switch (self._tag) {
+    case "Weak":
+      return `W/"${self.value}"`;
+    case "Strong":
+      return `"${self.value}"`;
+  }
+};
+
+export { GeneratorTypeId, tag, toString };

package/internal/http/formData.esm.js

@@ -0,0 +1,95 @@
+import * as Schema from '@effect/schema/Schema';
+import * as Chunk from 'effect/Chunk';
+import * as Data from 'effect/Data';
+import * as Effect from 'effect/Effect';
+import * as FiberRef from 'effect/FiberRef';
+import { dual, pipe } from 'effect/Function';
+import { globalValue } from 'effect/GlobalValue';
+import * as Option from 'effect/Option';
+import * as Predicate from 'effect/Predicate';
+import * as ReadonlyArray from 'effect/ReadonlyArray';
+import { Size } from '../../FileSystem/dist/effect-platform-FileSystem.esm.js';
+
+/** @internal */
+const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/FormData");
+
+/** @internal */
+const ErrorTypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/FormData/FormDataError");
+
+/** @internal */
+const FormDataError = (reason, error) => Data.struct({
+  [ErrorTypeId]: ErrorTypeId,
+  _tag: "FormDataError",
+  reason,
+  error
+});
+
+/** @internal */
+const maxParts = /*#__PURE__*/globalValue("@effect/platform/Http/FormData/maxParts", () => FiberRef.unsafeMake(Option.none()));
+
+/** @internal */
+const withMaxParts = /*#__PURE__*/dual(2, (effect, count) => Effect.locally(effect, maxParts, count));
+
+/** @internal */
+const maxFieldSize = /*#__PURE__*/globalValue("@effect/platform/Http/FormData/maxFieldSize", () => FiberRef.unsafeMake(Size(10 * 1024 * 1024)));
+
+/** @internal */
+const withMaxFieldSize = /*#__PURE__*/dual(2, (effect, size) => Effect.locally(effect, maxFieldSize, Size(size)));
+
+/** @internal */
+const maxFields = /*#__PURE__*/globalValue("@effect/platform/Http/FormData/maxFields", () => FiberRef.unsafeMake(Option.none()));
+
+/** @internal */
+const withMaxFields = /*#__PURE__*/dual(2, (effect, count) => Effect.locally(effect, maxFields, count));
+
+/** @internal */
+const maxFiles = /*#__PURE__*/globalValue("@effect/platform/Http/FormData/maxFiles", () => FiberRef.unsafeMake(Option.none()));
+
+/** @internal */
+const withMaxFiles = /*#__PURE__*/dual(2, (effect, count) => Effect.locally(effect, maxFiles, count));
+
+/** @internal */
+const maxFileSize = /*#__PURE__*/globalValue("@effect/platform/Http/FormData/maxFileSize", () => FiberRef.unsafeMake(Option.none()));
+
+/** @internal */
+const withMaxFileSize = /*#__PURE__*/dual(2, (effect, size) => Effect.locally(effect, maxFileSize, Option.map(size, Size)));
+
+/** @internal */
+const fieldMimeTypes = /*#__PURE__*/globalValue("@effect/platform/Http/FormData/fieldMimeTypes", () => FiberRef.unsafeMake(Chunk.make("application/json")));
+
+/** @internal */
+const withFieldMimeTypes = /*#__PURE__*/dual(2, (effect, mimeTypes) => Effect.locally(effect, fieldMimeTypes, Chunk.fromIterable(mimeTypes)));
+
+/** @internal */
+const toRecord = formData => ReadonlyArray.reduce(formData.entries(), {}, (acc, [key, value]) => {
+  if (Predicate.isString(value)) {
+    acc[key] = value;
+  } else {
+    const existing = acc[key];
+    if (Array.isArray(existing)) {
+      existing.push(value);
+    } else {
+      acc[key] = [value];
+    }
+  }
+  return acc;
+});
+/** @internal */
+const filesSchema = /*#__PURE__*/Schema.array( /*#__PURE__*/pipe( /*#__PURE__*/Schema.instanceOf(Blob), /*#__PURE__*/Schema.filter(blob => "name" in blob)));
+
+/** @internal */
+const schemaRecord = schema => {
+  const parse = Schema.parse(schema);
+  return formData => parse(toRecord(formData));
+};
+
+/** @internal */
+const schemaJson = schema => {
+  const parse = Schema.parse(schema);
+  return dual(2, (formData, field) => pipe(Effect.succeed(formData.get(field)), Effect.filterOrFail(field => Predicate.isString(field), () => FormDataError("Parse", `schemaJson: field was not a string`)), Effect.tryMap({
+    try: field => JSON.parse(field),
+    catch: error => FormDataError("Parse", `schemaJson: field was not valid json: ${error}`)
+  }), Effect.flatMap(parse)));
+};
+
+export { ErrorTypeId, FormDataError, TypeId, fieldMimeTypes, filesSchema, maxFieldSize, maxFields, maxFileSize, maxFiles, maxParts, schemaJson, schemaRecord, toRecord, withFieldMimeTypes, withMaxFieldSize, withMaxFields, withMaxFileSize, withMaxFiles, withMaxParts };

package/internal/http/middleware.esm.js

@@ -0,0 +1,46 @@
+import * as Effect from 'effect/Effect';
+import { flow } from 'effect/Function';
+import { set } from '../../Http/Http/Headers/dist/effect-platform-Http-Headers.esm.js';
+import { schemaExternalSpan } from '../../Http/Http/IncomingMessage/dist/effect-platform-Http-IncomingMessage.esm.js';
+import { ServerRequest } from '../../Http/Http/ServerRequest/dist/effect-platform-Http-ServerRequest.esm.js';
+import { setHeader } from '../../Http/Http/ServerResponse/dist/effect-platform-Http-ServerResponse.esm.js';
+
+/** @internal */
+const make = middleware => middleware;
+
+/** @internal */
+const logger = /*#__PURE__*/make(httpApp => {
+  let counter = 0;
+  return Effect.flatMap(ServerRequest, request => Effect.withLogSpan(Effect.onExit(httpApp, exit => exit._tag === "Failure" ? Effect.annotateLogs(Effect.log(exit.cause), {
+    "http.method": request.method,
+    "http.url": request.url,
+    "http.status": 500
+  }) : Effect.annotateLogs(Effect.log(""), {
+    "http.method": request.method,
+    "http.url": request.url,
+    "http.status": exit.value.status
+  })), `http.span.${++counter}`));
+});
+
+/** @internal */
+const tracer = /*#__PURE__*/make(httpApp => Effect.flatMap(ServerRequest, request => Effect.flatMap(Effect.orElseSucceed(schemaExternalSpan(request), () => undefined), parent => Effect.withSpan(Effect.tap(httpApp, response => Effect.annotateCurrentSpan("http.status", response.status)), `http ${request.method}`, {
+  attributes: {
+    "http.method": request.method,
+    "http.url": request.url
+  },
+  parent
+}))));
+
+/** @internal */
+const b3Response = /*#__PURE__*/make(httpApp => Effect.flatMap(Effect.currentSpan, span => span._tag === "Some" ? Effect.map(httpApp, res => setHeader(res, "b3", `${span.value.traceId}-${span.value.spanId}-1${span.value.parent._tag === "Some" ? `-${span.value.parent.value.spanId}` : ""}`)) : httpApp));
+
+/** @internal */
+const xForwardedHeaders = /*#__PURE__*/make(httpApp => Effect.updateService(httpApp, ServerRequest, request => request.headers["x-forwarded-host"] ? request.modify({
+  headers: set(request.headers, "host", request.headers["x-forwarded-host"]),
+  remoteAddress: request.headers["x-forwarded-for"]?.split(",")[0].trim()
+}) : request));
+
+/** @internal */
+const loggerTracer = /*#__PURE__*/flow(tracer, logger);
+
+export { b3Response, logger, loggerTracer, make, tracer, xForwardedHeaders };