brass-runtime 1.16.1 → 1.18.0

package/dist/http/index.js

@@ -1,126 +1,125 @@
 import {
-  makeCircuitBreaker,
-  resource
-} from "../chunk-B33ICAKP.js";
+  makeCircuitBreaker
+} from "../chunk-YM3EDNYD.js";
 import {
+  healthToHttpResponse,
+  makeRuntimeHealth,
+  runObservedHttpServerEffect
+} from "../chunk-4YQHPIWJ.js";
+import "../chunk-AADFFVYS.js";
+import {
+  AdaptiveLimiter,
   DEFAULT_CACHE_RELEVANT_HEADERS,
+  EmaComputer,
+  HttpClientService,
+  HttpConcurrencyPool,
   LRUCache,
+  LatencyWindow,
   LifecycleStatsTracker,
   PriorityQueue,
+  Request,
   SEPARATOR,
   SUPPORTED_ENCODINGS,
-  buildHttpRequest,
-  clampPriority,
-  computeCacheKey,
-  decodeJsonBody,
-  decodeJsonBodyEffect,
-  defaultHttpClientPreset,
-  detectPlatform,
-  encodeJsonBodyEffect,
-  executeProbe,
-  makeBudgetSemaphore,
-  makeCompressionMiddleware,
-  makeConnectionStateMap,
-  makeDefaultHttpClient,
-  makeHttpClient,
-  makeLifecycleClient,
-  makePrewarmManager,
-  makeRequestCompressionMiddleware,
-  makeResponseCompressionMiddleware,
-  now,
-  parseCacheKey,
-  validateFetchAvailable,
-  validateOrigin,
-  validatedJson,
-  validatedJsonResponse,
-  withBatch,
-  withCache,
-  withDedup,
-  withPriority
-} from "../chunk-74ZTY6CP.js";
-import {
-  AdaptiveLimiter,
-  EmaComputer,
-  HttpConcurrencyPool,
-  LatencyWindow,
   abortErrorForSignal,
   adaptiveLimiterPresets,
   backoffDelayMs,
+  buildHttpRequest,
+  clampPriority,
+  computeCacheKey,
   computeGradient,
   computeNewLimit,
+  decodeJsonBody,
+  decodeJsonBodyEffect,
   decorate,
+  defaultHttpClientPreset,
   defaultRetryOnError,
   defaultRetryOnStatus,
   defaultRetryableMethods,
+  defineHttpPolicyPresets,
+  detectPlatform,
+  encodeJsonBodyEffect,
+  executeProbe,
+  formatHttpError,
+  getHttpRequestPolicy,
   headersOf,
+  httpErrorStatus,
+  httpPolicy,
   isAbortError,
+  isAbortHttpError,
+  isCircuitBreakerOpen,
+  isExternalAbortError,
+  isExternalTimeoutError,
+  isFetchHttpError,
+  isHttpError,
+  isKnownHttpError,
+  isRetryableHttpError,
+  isRetryableHttpStatus,
   isTaggedHttpError,
+  isTimeoutHttpError,
+  isValidationError,
   linkAbortSignals,
   makeAdaptiveLimiterConfig,
+  makeBudgetSemaphore,
+  makeCompressionMiddleware,
+  makeConnectionStateMap,
+  makeDefaultHttpClient,
+  makeDefaultHttpClientLayer,
   makeFetchStreamTransport,
   makeFetchTransport,
   makeHttp,
+  makeHttpClient,
   makeHttpStream,
+  makeJsonParseValidationError,
+  makeLifecycleClient,
+  makePrewarmManager,
   makePromiseHttpTransport,
+  makeRequestCompressionMiddleware,
+  makeResponseCompressionMiddleware,
+  matchHttpError,
   normalizeHeadersInit,
   normalizeHttpError,
   normalizeHttpHeaders,
   normalizeRetryBudget,
+  now,
+  parseCacheKey,
   promiseHttpTransport,
   resolveConfig,
   resolveHttpPoolKey,
+  resolveHttpRequestPolicyPresets,
   retryAfterMs,
   setHeaderIfMissing,
+  toHttpError,
   validateConfig,
+  validateFetchAvailable,
+  validateOrigin,
+  validatedJson,
+  validatedJsonResponse,
+  withBatch,
+  withCache,
+  withDedup,
+  withHttpPolicyPresets,
+  withHttpRequestPolicy,
   withMiddleware,
+  withPriority,
   withRetry,
   withRetryStream
-} from "../chunk-MIIYDLGM.js";
+} from "../chunk-H5GYX7RZ.js";
 import {
   registerHttpEffect
 } from "../chunk-TRM4JUZQ.js";
-import "../chunk-7JIJOVCT.js";
+import "../chunk-JH4GI3DW.js";
 import "../chunk-UCUBNWM2.js";
 import {
   fixed,
   makeScheduleDriver,
+  resource,
   take
-} from "../chunk-6IXXWIUM.js";
-import "../chunk-L2SYFEBS.js";
-import {
-  healthToHttpResponse,
-  makeRuntimeHealth,
-  runObservedHttpServerEffect
-} from "../chunk-CIZFIMK5.js";
-import "../chunk-RKGKFN2A.js";
-import {
-  defineHttpPolicyPresets,
-  formatHttpError,
-  getHttpRequestPolicy,
-  httpErrorStatus,
-  httpPolicy,
-  isAbortHttpError,
-  isCircuitBreakerOpen,
-  isExternalAbortError,
-  isExternalTimeoutError,
-  isFetchHttpError,
-  isHttpError,
-  isKnownHttpError,
-  isRetryableHttpError,
-  isRetryableHttpStatus,
-  isTimeoutHttpError,
-  isValidationError,
-  matchHttpError,
-  resolveHttpRequestPolicyPresets,
-  toHttpError,
-  withHttpPolicyPresets,
-  withHttpRequestPolicy
-} from "../chunk-3Y2RIUMM.js";
+} from "../chunk-IBRHSH5H.js";
 import {
   Runtime,
   fromPromiseAbortable,
   toPromise
-} from "../chunk-FH2X7BVP.js";
+} from "../chunk-XSAHV5HQ.js";
 import {
   Cause,
   asyncEffect,
@@ -144,9 +143,142 @@ import {
   s,
   schema,
   validateValue
-} from "../chunk-C3MDXTRZ.js";
+} from "../chunk-HCJ4S3YB.js";
 import "../chunk-3RG5ZIWI.js";
 
+// src/http/nodeTransport.ts
+import {
+  Agent as HttpAgent,
+  request as httpRequest
+} from "http";
+import {
+  Agent as HttpsAgent,
+  request as httpsRequest
+} from "https";
+var nowMs = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+var toAgentOptions = (config) => ({
+  keepAlive: config.keepAlive ?? true,
+  ...config.maxSockets !== void 0 ? { maxSockets: config.maxSockets } : {},
+  ...config.maxFreeSockets !== void 0 ? { maxFreeSockets: config.maxFreeSockets } : {}
+});
+var isError = (value) => value instanceof Error;
+function unsupportedProtocol(url) {
+  return {
+    _tag: "BadUrl",
+    message: `Unsupported URL protocol for node HTTP transport: ${url.protocol}`
+  };
+}
+function runNodeRequest(context, config, httpAgent, httpsAgent) {
+  return asyncEffect((_env, cb) => {
+    const { request, url, signal } = context;
+    const isHttps = url.protocol === "https:";
+    const isHttp = url.protocol === "http:";
+    if (!isHttp && !isHttps) {
+      cb({ _tag: "Failure", cause: Cause.fail(unsupportedProtocol(url)) });
+      return;
+    }
+    if (signal.aborted) {
+      cb({ _tag: "Failure", cause: Cause.fail(abortErrorForSignal(signal)) });
+      return;
+    }
+    const started = nowMs();
+    const chunks = [];
+    let byteLength = 0;
+    let done = false;
+    let abort = () => void 0;
+    const finish = (exit) => {
+      if (done) return;
+      done = true;
+      signal.removeEventListener("abort", abort);
+      cb(exit);
+    };
+    const fail = (error) => {
+      finish({
+        _tag: "Failure",
+        cause: Cause.fail(normalizeHttpError(error, { signal }))
+      });
+    };
+    const options = {
+      method: request.method,
+      headers: Request.headers.get(request),
+      agent: isHttps ? httpsAgent : httpAgent,
+      signal
+    };
+    const nodeRequest = (isHttps ? httpsRequest : httpRequest)(url, options, (response) => {
+      response.on("data", (chunk) => {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        chunks.push(buffer);
+        byteLength += buffer.length;
+      });
+      response.on("end", () => {
+        finish({
+          _tag: "Success",
+          value: {
+            status: response.statusCode ?? 0,
+            statusText: response.statusMessage ?? "",
+            headers: normalizeHttpHeaders(response.headers),
+            bodyText: Buffer.concat(chunks, byteLength).toString("utf8"),
+            ms: Math.round(nowMs() - started)
+          }
+        });
+      });
+      response.on("error", fail);
+    });
+    abort = () => {
+      nodeRequest.destroy(isError(signal.reason) ? signal.reason : void 0);
+      finish({ _tag: "Failure", cause: Cause.fail(abortErrorForSignal(signal)) });
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    nodeRequest.on("error", fail);
+    if (config.socketTimeoutMs !== void 0 && config.socketTimeoutMs > 0) {
+      nodeRequest.setTimeout(config.socketTimeoutMs, () => {
+        nodeRequest.destroy(Object.assign(new Error("Node HTTP socket timed out"), {
+          code: "ETIMEDOUT"
+        }));
+      });
+    }
+    if (request.body !== void 0) {
+      nodeRequest.write(request.body);
+    }
+    nodeRequest.end();
+    return () => {
+      if (done) return;
+      nodeRequest.destroy(Object.assign(new Error("Node HTTP transport aborted"), {
+        name: "AbortError",
+        code: "ABORT_ERR"
+      }));
+      finish({ _tag: "Failure", cause: Cause.fail({ _tag: "Abort" }) });
+    };
+  });
+}
+function makeNodeHttpTransport(config = {}) {
+  const agentOptions = toAgentOptions(config);
+  const httpAgent = config.httpAgent ?? new HttpAgent(agentOptions);
+  const httpsAgent = config.httpsAgent ?? new HttpsAgent(agentOptions);
+  const ownsHttpAgent = config.httpAgent === void 0;
+  const ownsHttpsAgent = config.httpsAgent === void 0;
+  const transport = (context) => runNodeRequest(context, config, httpAgent, httpsAgent);
+  return Object.assign(transport, {
+    destroy: () => {
+      if (ownsHttpAgent) httpAgent.destroy();
+      if (ownsHttpsAgent) httpsAgent.destroy();
+    }
+  });
+}
+function makeNodeHttpProxyClient(config = {}) {
+  const {
+    preset = "highThroughputProxy",
+    transport,
+    nodeTransport,
+    ...clientConfig
+  } = config;
+  return makeDefaultHttpClient({
+    ...clientConfig,
+    preset,
+    transport: transport ?? makeNodeHttpTransport(nodeTransport)
+  });
+}
+
 // src/http/httpClient.ts
 var resolveFinalUrl = (baseUrl, url) => {
   try {
@@ -941,6 +1073,7 @@ function makeBuilder(config) {
     transport: (transport) => replace({ transport }),
     preset: (preset) => replace({ preset }),
     minimal: () => replace({ preset: "minimal" }),
+    proxy: () => replace({ preset: "proxy" }),
     balanced: () => replace({ preset: "balanced" }),
     defaultPreset: () => replace({ preset: "default" }),
     production: () => replace({ preset: "production" }),
@@ -1504,7 +1637,12 @@ function normalizeRouteMethod(method) {
 function normalizeRoutePath(path) {
   if (!path || path === "*") return "/";
   const withSlash = path.startsWith("/") ? path : `/${path}`;
-  return withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
+  if (withSlash.length <= 1) return withSlash;
+  let end = withSlash.length;
+  while (end > 0 && withSlash.charCodeAt(end - 1) === 47) {
+    end -= 1;
+  }
+  return withSlash.slice(0, end);
 }
 function parseRequestUrl(target, host) {
   try {
@@ -1569,6 +1707,7 @@ export {
   ConfigValidationError,
   DEFAULT_CACHE_RELEVANT_HEADERS,
   EmaComputer,
+  HttpClientService,
   HttpConcurrencyPool,
   HttpServer,
   LRUCache,
@@ -1633,6 +1772,7 @@ export {
   makeCompressionMiddleware,
   makeConnectionStateMap,
   makeDefaultHttpClient,
+  makeDefaultHttpClientLayer,
   makeFetchStreamTransport,
   makeFetchTransport,
   makeHttp,
@@ -1641,9 +1781,12 @@ export {
   makeHttpRouter,
   makeHttpServerResource,
   makeHttpStream,
+  makeJsonParseValidationError,
   makeLifecycleClient,
+  makeNodeHttpProxyClient,
   makeNodeHttpServer,
   makeNodeHttpServerResource,
+  makeNodeHttpTransport,
   makePrewarmManager,
   makePromiseHttpTransport,
   makeRequestCompressionMiddleware,