brass-runtime 1.13.5 → 1.13.7

package/dist/http/index.cjs

@@ -0,0 +1,453 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkZTDK2DLGcjs = require('../chunk-ZTDK2DLG.cjs');
+
+
+
+
+
+
+
+
+
+var _chunk2P4PD6D7cjs = require('../chunk-2P4PD6D7.cjs');
+
+// src/http/optics/lens.ts
+var Lens = {
+  make(get, set) {
+    return { get, set };
+  },
+  over(ln, f) {
+    return (s) => ln.set(f(ln.get(s)))(s);
+  },
+  compose(ab, sa) {
+    return Lens.make(
+      (s) => ab.get(sa.get(s)),
+      (b) => (s) => sa.set(ab.set(b)(sa.get(s)))(s)
+    );
+  }
+};
+
+// src/http/optics/request.ts
+var Request = {
+  headers: Lens.make(
+    (req) => _nullishCoalesce(req.headers, () => ( {})),
+    (headers) => (req) => ({ ...req, headers })
+  )
+};
+var mergeHeaders = (extra) => (req) => Lens.over(Request.headers, (h) => ({ ...h, ...extra }))(req);
+var mergeHeadersUnder = (under) => (req) => Lens.over(Request.headers, (h) => ({ ...under, ...h }))(req);
+var setHeaderIfMissing = (k, v) => (req) => Lens.over(Request.headers, (h) => h[k] ? h : { ...h, [k]: v })(req);
+
+// src/http/sleep.ts
+var isHttpError = (e) => typeof e === "object" && e !== null && "_tag" in e;
+var normalizeHttpError = (e) => {
+  if (isHttpError(e)) return e;
+  if (typeof e === "object" && e !== null && e.name === "AbortError") {
+    return { _tag: "Abort" };
+  }
+  return { _tag: "FetchError", message: String(e) };
+};
+var sleepMs = (ms) => _chunk2P4PD6D7cjs.fromPromiseAbortable.call(void 0, 
+  (signal) => new Promise((resolve, reject) => {
+    if (signal.aborted) return reject({ _tag: "Abort" });
+    const id = setTimeout(resolve, ms);
+    const onAbort = () => {
+      clearTimeout(id);
+      reject({ _tag: "Abort" });
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  }),
+  normalizeHttpError
+);
+
+// src/http/client.ts
+var withMiddleware = (mw) => (c) => decorate(mw(c));
+var decorate = (run) => Object.assign(((req) => run(req)), {
+  with: (mw) => decorate(mw(run))
+});
+var normalizeHttpError2 = (e) => {
+  if (e instanceof DOMException && e.name === "AbortError") return { _tag: "Abort" };
+  if (typeof e === "object" && e && "_tag" in e) return e;
+  return { _tag: "FetchError", message: String(e) };
+};
+var normalizeHeadersInit = (h) => {
+  if (!h) return void 0;
+  if (typeof Headers !== "undefined" && h instanceof Headers) {
+    const out = {};
+    h.forEach((v, k) => out[k] = v);
+    return out;
+  }
+  if (Array.isArray(h)) return Object.fromEntries(h);
+  if (typeof h === "object") return { ...h };
+  return void 0;
+};
+var normalizeRequest = (defaultHeaders) => (req0) => {
+  let req = Object.keys(defaultHeaders).length ? mergeHeadersUnder(defaultHeaders)(req0) : req0;
+  const initHeaders = normalizeHeadersInit(_optionalChain([req0, 'access', _ => _.init, 'optionalAccess', _2 => _2.headers]));
+  if (initHeaders && Object.keys(initHeaders).length) {
+    req = mergeHeadersUnder(initHeaders)(req);
+  }
+  return req;
+};
+function makeHttpStream(cfg = {}) {
+  const baseUrl = _nullishCoalesce(cfg.baseUrl, () => ( ""));
+  const defaultHeaders = _nullishCoalesce(cfg.headers, () => ( {}));
+  const normalize = normalizeRequest(defaultHeaders);
+  return (req0) => _chunk2P4PD6D7cjs.fromPromiseAbortable.call(void 0, 
+    async (signal) => {
+      const req = normalize(req0);
+      let url;
+      try {
+        url = new URL(req.url, baseUrl);
+      } catch (e2) {
+        throw { _tag: "BadUrl", message: `URL inv\xE1lida: ${req.url}` };
+      }
+      const started = performance.now();
+      const res = await fetch(url, {
+        ..._nullishCoalesce(req.init, () => ( {})),
+        method: req.method,
+        headers: Request.headers.get(req),
+        // 👈 optics: headers ya normalizados
+        body: req.body,
+        signal
+      });
+      const headers = {};
+      res.headers.forEach((v, k) => headers[k] = v);
+      const body = _chunkZTDK2DLGcjs.streamFromReadableStream.call(void 0, res.body, normalizeHttpError2);
+      return {
+        status: res.status,
+        statusText: res.statusText,
+        headers,
+        body,
+        ms: Math.round(performance.now() - started)
+      };
+    },
+    normalizeHttpError2
+  );
+}
+function makeHttp(cfg = {}) {
+  const baseUrl = _nullishCoalesce(cfg.baseUrl, () => ( ""));
+  const defaultHeaders = _nullishCoalesce(cfg.headers, () => ( {}));
+  const normalize = normalizeRequest(defaultHeaders);
+  const run = (req0) => _chunk2P4PD6D7cjs.fromPromiseAbortable.call(void 0, 
+    async (signal) => {
+      const req = normalize(req0);
+      let url;
+      try {
+        url = new URL(req.url, baseUrl);
+      } catch (e3) {
+        throw { _tag: "BadUrl", message: `URL inv\xE1lida: ${req.url}` };
+      }
+      const started = performance.now();
+      const res = await fetch(url, {
+        ..._nullishCoalesce(req.init, () => ( {})),
+        method: req.method,
+        headers: Request.headers.get(req),
+        // 👈 optics
+        body: req.body,
+        signal
+      });
+      const bodyText = await res.text();
+      const headers = {};
+      res.headers.forEach((v, k) => headers[k] = v);
+      return {
+        status: res.status,
+        statusText: res.statusText,
+        headers,
+        bodyText,
+        ms: Math.round(performance.now() - started)
+      };
+    },
+    normalizeHttpError2
+  );
+  return decorate(run);
+}
+var clamp = (n, min, max) => Math.max(min, Math.min(max, n));
+var defaultRetryOnError = (e) => e._tag === "FetchError";
+var defaultRetryOnStatus = (s) => s === 408 || s === 429 || s === 500 || s === 502 || s === 503 || s === 504;
+var backoffDelayMs = (attempt, base, cap) => {
+  const exp = base * Math.pow(2, attempt);
+  const lim = clamp(exp, 0, cap);
+  return Math.floor(Math.random() * lim);
+};
+var retryAfterMs = (headers) => {
+  const key = Object.keys(headers).find((k) => k.toLowerCase() === "retry-after");
+  if (!key) return void 0;
+  const v = _optionalChain([headers, 'access', _3 => _3[key], 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]);
+  if (!v) return void 0;
+  const secs = Number(v);
+  if (Number.isFinite(secs)) return Math.max(0, Math.floor(secs * 1e3));
+  const t = Date.parse(v);
+  if (Number.isFinite(t)) return Math.max(0, t - Date.now());
+  return void 0;
+};
+var withRetryStream = (p) => (next) => ((req) => {
+  const loop = (attempt) => _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
+    next(req),
+    (e) => {
+      if (e._tag === "Abort" || e._tag === "BadUrl") return _chunk2P4PD6D7cjs.asyncFail.call(void 0, e);
+      const canRetry = attempt < p.maxRetries && (_nullishCoalesce(p.retryOnError, () => ( defaultRetryOnError)))(e);
+      if (!canRetry) return _chunk2P4PD6D7cjs.asyncFail.call(void 0, e);
+      const d = backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs);
+      return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, sleepMs(d), () => loop(attempt + 1));
+    },
+    (w) => {
+      const canRetry = attempt < p.maxRetries && (_nullishCoalesce(p.retryOnStatus, () => ( defaultRetryOnStatus)))(w.status);
+      if (!canRetry) return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, w);
+      const ra = retryAfterMs(w.headers);
+      const d = _nullishCoalesce(ra, () => ( backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs)));
+      return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, sleepMs(d), () => loop(attempt + 1));
+    }
+  );
+  return loop(0);
+});
+
+// src/http/retry/retry.ts
+var defaultRetryableMethods = ["GET", "HEAD", "OPTIONS"];
+var defaultRetryOnStatus2 = (s) => s === 408 || s === 429 || s === 500 || s === 502 || s === 503 || s === 504;
+var defaultRetryOnError2 = (e) => e._tag === "FetchError";
+var clamp2 = (n, min, max) => Math.max(min, Math.min(max, n));
+var backoffDelayMs2 = (attempt, base, cap) => {
+  const b = Math.max(0, base);
+  const c = Math.max(0, cap);
+  const exp = b * Math.pow(2, attempt);
+  const lim = clamp2(exp, 0, c);
+  return Math.floor(Math.random() * lim);
+};
+var headerCI = (h, name) => {
+  const k = Object.keys(h).find((x) => x.toLowerCase() === name.toLowerCase());
+  return k ? h[k] : void 0;
+};
+var retryAfterMs2 = (headers) => {
+  const v = _optionalChain([headerCI, 'call', _6 => _6(headers, "retry-after"), 'optionalAccess', _7 => _7.trim, 'call', _8 => _8()]);
+  if (!v) return void 0;
+  const secs = Number(v);
+  if (Number.isFinite(secs)) return Math.max(0, Math.floor(secs * 1e3));
+  const t = Date.parse(v);
+  if (Number.isFinite(t)) return Math.max(0, t - Date.now());
+  return void 0;
+};
+var withRetry = (p) => (next) => {
+  const retryOnMethods = _nullishCoalesce(p.retryOnMethods, () => ( defaultRetryableMethods));
+  const retryOnStatus = _nullishCoalesce(p.retryOnStatus, () => ( defaultRetryOnStatus2));
+  const retryOnError = _nullishCoalesce(p.retryOnError, () => ( defaultRetryOnError2));
+  const isMethodRetryable = (req) => retryOnMethods.includes(req.method);
+  const loop = (req, attempt) => {
+    if (!isMethodRetryable(req)) return next(req);
+    return _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
+      next(req),
+      (e) => {
+        if (e._tag === "Abort" || e._tag === "BadUrl") return _chunk2P4PD6D7cjs.asyncFail.call(void 0, e);
+        const canRetry = attempt < p.maxRetries && retryOnError(e);
+        if (!canRetry) return _chunk2P4PD6D7cjs.asyncFail.call(void 0, e);
+        const d = backoffDelayMs2(attempt, p.baseDelayMs, p.maxDelayMs);
+        return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, sleepMs(d), () => loop(req, attempt + 1));
+      },
+      (w) => {
+        const canRetry = attempt < p.maxRetries && retryOnStatus(w.status);
+        if (!canRetry) return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, w);
+        const ra = retryAfterMs2(w.headers);
+        const d = _nullishCoalesce(ra, () => ( backoffDelayMs2(attempt, p.baseDelayMs, p.maxDelayMs)));
+        return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, sleepMs(d), () => loop(req, attempt + 1));
+      }
+    );
+  };
+  return (req) => loop(req, 0);
+};
+
+// src/http/httpClient.ts
+var resolveFinalUrl = (baseUrl, url) => {
+  try {
+    return new URL(url, _nullishCoalesce(baseUrl, () => ( ""))).toString();
+  } catch (e4) {
+    return (_nullishCoalesce(baseUrl, () => ( ""))) + url;
+  }
+};
+var createHttpCore = (cfg = {}) => {
+  const wire = makeHttp(cfg);
+  const withPromise = (eff) => _chunk2P4PD6D7cjs.withAsyncPromise.call(void 0, (e, env) => _chunk2P4PD6D7cjs.toPromise.call(void 0, e, env))(eff);
+  const requestRaw = (req) => wire(req);
+  const splitInit = (init) => {
+    const { headers, ...rest } = _nullishCoalesce(init, () => ( {}));
+    return {
+      headers: normalizeHeadersInit(headers),
+      init: rest
+    };
+  };
+  const applyInitHeaders = (headers) => (req) => headers ? mergeHeaders(headers)(req) : req;
+  const buildReq = (method, url, init, body) => {
+    const s = splitInit(init);
+    const req = {
+      method,
+      url,
+      ...body && body.length > 0 ? { body } : {},
+      init: s.init
+    };
+    return applyInitHeaders(s.headers)(req);
+  };
+  const toResponse = (w, body) => ({
+    status: w.status,
+    statusText: w.statusText,
+    headers: w.headers,
+    body
+  });
+  return {
+    cfg,
+    wire,
+    withPromise,
+    requestRaw,
+    splitInit,
+    applyInitHeaders,
+    buildReq,
+    toResponse
+  };
+};
+function httpClient(cfg = {}) {
+  const core = createHttpCore(cfg);
+  const make = (wire) => {
+    const requestRaw = (req) => wire(req);
+    const request = (req) => core.withPromise(requestRaw(req));
+    const get = (url, init) => request(core.buildReq("GET", url, init));
+    const post = (url, body, init) => request(core.buildReq("POST", url, init, body));
+    const getText = (url, init) => {
+      const req = core.buildReq("GET", url, init);
+      return core.withPromise(_chunk2P4PD6D7cjs.mapTryAsync.call(void 0, requestRaw(req), (w) => core.toResponse(w, w.bodyText)));
+    };
+    const getJson = (url, init) => {
+      const base = core.buildReq("GET", url, init);
+      const req = setHeaderIfMissing("accept", "application/json")(base);
+      return core.withPromise(_chunk2P4PD6D7cjs.mapTryAsync.call(void 0, requestRaw(req), (w) => core.toResponse(w, JSON.parse(w.bodyText))));
+    };
+    const postJson = (url, bodyObj, init) => {
+      const base = core.buildReq("POST", url, init, JSON.stringify(_nullishCoalesce(bodyObj, () => ( {}))));
+      const req = setHeaderIfMissing("content-type", "application/json")(
+        setHeaderIfMissing("accept", "application/json")(base)
+      );
+      return core.withPromise(
+        _chunk2P4PD6D7cjs.mapTryAsync.call(void 0, requestRaw(req), (w) => core.toResponse(w, JSON.parse(w.bodyText)))
+      );
+    };
+    return {
+      request,
+      get,
+      post,
+      getText,
+      getJson,
+      postJson,
+      with: (mw) => make(wire.with(mw)),
+      withRetry: (p) => make(wire.with(withRetry(p))),
+      wire
+    };
+  };
+  return make(core.wire);
+}
+function httpClientWithMeta(cfg = {}) {
+  const core = createHttpCore(cfg);
+  const mkMeta = (req, w, startedAt) => ({
+    request: req,
+    urlFinal: resolveFinalUrl(core.cfg.baseUrl, req.url),
+    startedAt,
+    durationMs: w.ms
+  });
+  const request = (req) => {
+    const startedAt = Date.now();
+    return core.withPromise(
+      _chunk2P4PD6D7cjs.mapTryAsync.call(void 0, core.requestRaw(req), (w) => ({
+        wire: w,
+        meta: mkMeta(req, w, startedAt)
+      }))
+    );
+  };
+  const get = (url, init) => {
+    const req = core.buildReq("GET", url, init);
+    return request(req);
+  };
+  const post = (url, body, init) => {
+    const req = core.buildReq("POST", url, init, body);
+    return request(req);
+  };
+  const postJson = (url, bodyObj, init) => {
+    const base = core.buildReq("POST", url, init, JSON.stringify(_nullishCoalesce(bodyObj, () => ( {}))));
+    const req = setHeaderIfMissing("content-type", "application/json")(
+      setHeaderIfMissing("accept", "application/json")(base)
+    );
+    const startedAt = Date.now();
+    return core.withPromise(
+      _chunk2P4PD6D7cjs.mapTryAsync.call(void 0, core.requestRaw(req), (w) => ({
+        wire: w,
+        response: core.toResponse(w, JSON.parse(w.bodyText)),
+        meta: mkMeta(req, w, startedAt)
+      }))
+    );
+  };
+  const getText = (url, init) => {
+    const req = core.buildReq("GET", url, init);
+    const startedAt = Date.now();
+    return core.withPromise(
+      _chunk2P4PD6D7cjs.mapTryAsync.call(void 0, core.requestRaw(req), (w) => ({
+        wire: w,
+        response: core.toResponse(w, w.bodyText),
+        meta: mkMeta(req, w, startedAt)
+      }))
+    );
+  };
+  const getJson = (url, init) => {
+    const base = core.buildReq("GET", url, init);
+    const req = setHeaderIfMissing("accept", "application/json")(base);
+    const startedAt = Date.now();
+    return core.withPromise(
+      _chunk2P4PD6D7cjs.mapTryAsync.call(void 0, core.requestRaw(req), (w) => ({
+        wire: w,
+        response: core.toResponse(w, JSON.parse(w.bodyText)),
+        meta: mkMeta(req, w, startedAt)
+      }))
+    );
+  };
+  return {
+    request,
+    // => { wire, meta }
+    get,
+    // => { wire, meta }
+    getText,
+    // => { wire, response(text), meta }
+    getJson,
+    // => { wire, response(json), meta }
+    post,
+    // => { wire, meta }
+    postJson
+    // => { wire, meta } (y además setea headers via optics)
+  };
+}
+function httpClientStream(cfg = {}) {
+  const wire = makeHttpStream(cfg);
+  const make = (w) => {
+    const withPromise = (eff) => _chunk2P4PD6D7cjs.withAsyncPromise.call(void 0, (e, env) => _chunk2P4PD6D7cjs.toPromise.call(void 0, e, env))(eff);
+    const request = (req) => withPromise(w(req));
+    const getStream = (url, init) => {
+      const base = { method: "GET", url, init };
+      const req = setHeaderIfMissing("accept", "*/*")(base);
+      return request(req);
+    };
+    return {
+      request,
+      getStream,
+      get: getStream,
+      with: (mw) => make(mw(w)),
+      withRetry: (p) => make(withRetryStream(p)(w)),
+      wire: w
+    };
+  };
+  return make(wire);
+}
+
+
+
+
+
+
+
+
+
+
+exports.decorate = decorate; exports.httpClient = httpClient; exports.httpClientStream = httpClientStream; exports.httpClientWithMeta = httpClientWithMeta; exports.makeHttp = makeHttp; exports.makeHttpStream = makeHttpStream; exports.normalizeHeadersInit = normalizeHeadersInit; exports.withMiddleware = withMiddleware; exports.withRetryStream = withRetryStream;