@effect/platform 0.18.4 → 0.18.6

package/internal/http/client.esm.js

@@ -1,157 +0,0 @@
-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/etag.esm.js

@@ -1,19 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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 };

package/internal/http/platform.esm.js

@@ -1,52 +0,0 @@
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import { pipe } from 'effect/Function';
-import { FileSystem } from '../../FileSystem/dist/effect-platform-FileSystem.esm.js';
-import { Generator, toString } from '../../Http/Http/Etag/dist/effect-platform-Http-Etag.esm.js';
-
-/** @internal */
-const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/Platform");
-
-/** @internal */
-const tag = /*#__PURE__*/Context.Tag(TypeId);
-
-/** @internal */
-const make = impl => Effect.gen(function* (_) {
-  const fs = yield* _(FileSystem);
-  const etagGen = yield* _(Generator);
-  return tag.of({
-    [TypeId]: TypeId,
-    fileResponse(path, options) {
-      return pipe(Effect.bindTo(fs.stat(path), "info"), Effect.bind("etag", ({
-        info
-      }) => etagGen.fromFileInfo(info)), Effect.map(({
-        etag,
-        info
-      }) => {
-        const start = Number(options?.offset ?? 0);
-        const end = options?.bytesToRead !== undefined ? start + Number(options.bytesToRead) : undefined;
-        const headers = {
-          ...(options?.headers ?? {}),
-          etag: toString(etag)
-        };
-        if (info.mtime._tag === "Some") {
-          headers["last-modified"] = info.mtime.value.toUTCString();
-        }
-        const contentLength = end !== undefined ? end - start : Number(info.size) - start;
-        return impl.fileResponse(path, options?.status ?? 200, options?.statusText, headers, start, end, contentLength);
-      }));
-    },
-    fileWebResponse(file, options) {
-      return Effect.map(etagGen.fromFileWeb(file), etag => {
-        const headers = {
-          ...(options?.headers ?? {}),
-          etag: toString(etag),
-          "last-modified": new Date(file.lastModified).toUTCString()
-        };
-        return impl.fileWebResponse(file, options?.status ?? 200, options?.statusText, headers, options);
-      });
-    }
-  });
-});
-
-export { TypeId, make, tag };

package/internal/http/router.esm.js

@@ -1,199 +0,0 @@
-import * as Schema from '@effect/schema/Schema';
-import * as Chunk from 'effect/Chunk';
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Effectable from 'effect/Effectable';
-import { dual } from 'effect/Function';
-import * as Inspectable from 'effect/Inspectable';
-import * as Option from 'effect/Option';
-import FindMyWay from 'find-my-way';
-import { RouteNotFound } from '../../Http/Http/ServerError/dist/effect-platform-Http-ServerError.esm.js';
-import { ServerRequest } from '../../Http/Http/ServerRequest/dist/effect-platform-Http-ServerRequest.esm.js';
-
-/** @internal */
-const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/Router");
-
-/** @internal */
-const RouteTypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/Router/Route");
-
-/** @internal */
-const RouteContextTypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/Router/RouteContext");
-
-/** @internal */
-const RouteContext = /*#__PURE__*/Context.Tag("@effect/platform/Http/Router/RouteContext");
-
-/** @internal */
-const params = /*#__PURE__*/Effect.map(RouteContext, _ => _.params);
-
-/** @internal */
-const searchParams = /*#__PURE__*/Effect.map(RouteContext, _ => _.searchParams);
-
-/** @internal */
-const schemaParams = schema => {
-  const parse = Schema.parse(schema);
-  return Effect.flatMap(RouteContext, _ => parse({
-    ..._.searchParams,
-    ..._.params
-  }));
-};
-class RouterImpl extends Effectable.Effectable {
-  constructor(routes, mounts) {
-    super();
-    this.routes = routes;
-    this.mounts = mounts;
-    this[TypeId] = TypeId;
-  }
-  commit() {
-    if (this.httpApp === undefined) {
-      this.httpApp = toHttpApp(this);
-    }
-    return this.httpApp;
-  }
-  toJSON() {
-    return {
-      _id: "Router",
-      routes: this.routes.toJSON(),
-      mounts: this.mounts.toJSON()
-    };
-  }
-  toString() {
-    return Inspectable.toString(this);
-  }
-  [Inspectable.NodeInspectSymbol]() {
-    return this.toJSON();
-  }
-}
-const toHttpApp = self => {
-  const router = FindMyWay();
-  const mounts = Chunk.toReadonlyArray(self.mounts);
-  const mountsLen = mounts.length;
-  Chunk.forEach(self.routes, route => {
-    function fn() {
-      return route;
-    }
-    if (route.method === "*") {
-      router.all(route.path, fn);
-    } else {
-      router.on(route.method, route.path, fn);
-    }
-  });
-  return Effect.flatMap(ServerRequest, request => {
-    if (mountsLen > 0) {
-      for (let i = 0; i < mountsLen; i++) {
-        const [path, app] = mounts[i];
-        if (request.url.startsWith(path)) {
-          return Effect.provideService(app, ServerRequest, sliceRequestUrl(request, path));
-        }
-      }
-    }
-    let result = router.find(request.method, request.url);
-    if (result === null && request.method === "HEAD") {
-      result = router.find("GET", request.url);
-    }
-    if (result === null) {
-      return Effect.fail(RouteNotFound({
-        request
-      }));
-    }
-    const route = result.handler();
-    if (route.prefix._tag === "Some") {
-      request = sliceRequestUrl(request, route.prefix.value);
-    }
-    return Effect.mapInputContext(route.handler, context => Context.add(Context.add(context, ServerRequest, request), RouteContext, new RouteContextImpl(result.params, result.searchParams)));
-  });
-};
-function sliceRequestUrl(request, prefix) {
-  const prefexLen = prefix.length;
-  return request.modify({
-    url: request.url.length <= prefexLen ? "/" : request.url.slice(prefexLen)
-  });
-}
-class RouteImpl {
-  constructor(method, path, handler, prefix = Option.none()) {
-    this.method = method;
-    this.path = path;
-    this.handler = handler;
-    this.prefix = prefix;
-    this[RouteTypeId] = RouteTypeId;
-  }
-}
-class RouteContextImpl {
-  constructor(params, searchParams) {
-    this.params = params;
-    this.searchParams = searchParams;
-    this[RouteContextTypeId] = RouteContextTypeId;
-  }
-}
-
-/** @internal */
-const empty = /*#__PURE__*/new RouterImpl( /*#__PURE__*/Chunk.empty(), /*#__PURE__*/Chunk.empty());
-
-/** @internal */
-const fromIterable = routes => new RouterImpl(Chunk.fromIterable(routes), Chunk.empty());
-
-/** @internal */
-const makeRoute = (method, path, handler, prefix = Option.none()) => new RouteImpl(method, path, handler, prefix);
-
-/** @internal */
-const concat = /*#__PURE__*/dual(2, (self, that) => new RouterImpl(Chunk.appendAll(self.routes, that.routes), self.mounts));
-const removeTrailingSlash = path => path.endsWith("/") ? path.slice(0, -1) : path;
-
-/** @internal */
-const prefixAll = /*#__PURE__*/dual(2, (self, prefix) => {
-  prefix = removeTrailingSlash(prefix);
-  return new RouterImpl(Chunk.map(self.routes, route => new RouteImpl(route.method, route.path === "/" ? prefix : prefix + route.path, route.handler, Option.orElse(Option.map(route.prefix, _ => prefix + _), () => Option.some(prefix)))), Chunk.map(self.mounts, ([path, app]) => [path === "/" ? prefix : prefix + path, app]));
-});
-
-/** @internal */
-const mount = /*#__PURE__*/dual(3, (self, path, that) => concat(self, prefixAll(that, path)));
-
-/** @internal */
-const mountApp = /*#__PURE__*/dual(3, (self, path, that) => new RouterImpl(self.routes, Chunk.append(self.mounts, [removeTrailingSlash(path), that])));
-
-/** @internal */
-const route = method => dual(3, (self, path, handler) => new RouterImpl(Chunk.append(self.routes, new RouteImpl(method, path, handler)), self.mounts));
-
-/** @internal */
-const all = /*#__PURE__*/route("*");
-
-/** @internal */
-const get = /*#__PURE__*/route("GET");
-
-/** @internal */
-const post = /*#__PURE__*/route("POST");
-
-/** @internal */
-const put = /*#__PURE__*/route("PUT");
-
-/** @internal */
-const patch = /*#__PURE__*/route("PATCH");
-
-/** @internal */
-const del = /*#__PURE__*/route("DELETE");
-
-/** @internal */
-const head = /*#__PURE__*/route("HEAD");
-
-/** @internal */
-const options = /*#__PURE__*/route("OPTIONS");
-
-/** @internal */
-const use = /*#__PURE__*/dual(2, (self, f) => new RouterImpl(Chunk.map(self.routes, route => new RouteImpl(route.method, route.path, f(route.handler), route.prefix)), Chunk.map(self.mounts, ([path, app]) => [path, f(app)])));
-
-/** @internal */
-const catchAll = /*#__PURE__*/dual(2, (self, f) => use(self, Effect.catchAll(f)));
-
-/** @internal */
-const catchAllCause = /*#__PURE__*/dual(2, (self, f) => use(self, Effect.catchAllCause(f)));
-
-/** @internal */
-const catchTag = /*#__PURE__*/dual(3, (self, k, f) => use(self, Effect.catchTag(k, f)));
-
-/** @internal */
-const catchTags = /*#__PURE__*/dual(2, (self, cases) => use(self, Effect.catchTags(cases)));
-const provideService = /*#__PURE__*/dual(3, (self, tag, service) => use(self, Effect.provideService(tag, service)));
-
-/* @internal */
-const provideServiceEffect = /*#__PURE__*/dual(3, (self, tag, effect) => use(self, Effect.provideServiceEffect(tag, effect)));
-
-export { RouteContext, RouteContextTypeId, RouteTypeId, TypeId, all, catchAll, catchAllCause, catchTag, catchTags, concat, del, empty, fromIterable, get, head, makeRoute, mount, mountApp, options, params, patch, post, prefixAll, provideService, provideServiceEffect, put, route, schemaParams, searchParams, use };

package/internal/http/server.esm.js

@@ -1,20 +0,0 @@
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import { dual } from 'effect/Function';
-
-/** @internal */
-const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/Server");
-
-/** @internal */
-const serverTag = /*#__PURE__*/Context.Tag(TypeId);
-const serverProto = {
-  [TypeId]: TypeId
-};
-
-/** @internal */
-const make = options => Object.assign(Object.create(serverProto), options);
-
-/** @internal */
-const serve = /*#__PURE__*/dual(args => Effect.isEffect(args[0]), (httpApp, middleware) => Effect.flatMap(serverTag, server => server.serve(httpApp, middleware)));
-
-export { TypeId, make, serve, serverTag };

package/internal/http/serverError.esm.js

@@ -1,23 +0,0 @@
-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");
-
-/** @internal */
-const routeNotFound = /*#__PURE__*/make("RouteNotFound");
-
-/** @internal */
-const serveError = /*#__PURE__*/make("ServeError");
-
-export { TypeId, requestError, responseError, routeNotFound, serveError };

package/internal/http/serverRequest.esm.js

@@ -1,50 +0,0 @@
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import { toRecord, schemaRecord, schemaJson } from '../../Http/Http/FormData/dist/effect-platform-Http-FormData.esm.js';
-import { schemaHeaders as schemaHeaders$1, schemaBodyJson as schemaBodyJson$1, schemaBodyUrlParams as schemaBodyUrlParams$1 } from '../../Http/Http/IncomingMessage/dist/effect-platform-Http-IncomingMessage.esm.js';
-import { RequestError } from '../../Http/Http/ServerError/dist/effect-platform-Http-ServerError.esm.js';
-
-/** @internal */
-const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/ServerRequest");
-
-/** @internal */
-const serverRequestTag = /*#__PURE__*/Context.Tag(TypeId);
-
-/** @internal */
-const formDataRecord = /*#__PURE__*/Effect.map( /*#__PURE__*/Effect.flatMap(serverRequestTag, request => request.formData), toRecord);
-
-/** @internal */
-const schemaHeaders = schema => {
-  const parse = schemaHeaders$1(schema);
-  return Effect.flatMap(serverRequestTag, parse);
-};
-
-/** @internal */
-const schemaBodyJson = schema => {
-  const parse = schemaBodyJson$1(schema);
-  return Effect.flatMap(serverRequestTag, parse);
-};
-
-/** @internal */
-const schemaBodyUrlParams = schema => {
-  const parse = schemaBodyUrlParams$1(schema);
-  return Effect.flatMap(serverRequestTag, parse);
-};
-
-/** @internal */
-const schemaFormData = schema => {
-  const parse = schemaRecord(schema);
-  return Effect.flatMap(Effect.flatMap(serverRequestTag, request => request.formData), parse);
-};
-
-/** @internal */
-const schemaFormDataJson = schema => {
-  const parse = schemaJson(schema);
-  return field => Effect.flatMap(serverRequestTag, request => Effect.flatMap(request.formData, formData => Effect.catchTag(parse(formData, field), "FormDataError", error => Effect.fail(RequestError({
-    reason: "Decode",
-    request,
-    error: error.error
-  })))));
-};
-
-export { TypeId, formDataRecord, schemaBodyJson, schemaBodyUrlParams, schemaFormData, schemaFormDataJson, schemaHeaders, serverRequestTag };