@innvoid/getmarket-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,644 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  HEADER_AUTHORIZATION: () => HEADER_AUTHORIZATION,
+  HEADER_BRANCH_UID: () => HEADER_BRANCH_UID,
+  HEADER_COMPANY_UID: () => HEADER_COMPANY_UID,
+  HEADER_EMPLOYEE_UID: () => HEADER_EMPLOYEE_UID,
+  HEADER_INTERNAL_API_KEY: () => HEADER_INTERNAL_API_KEY,
+  HEADER_REQUEST_ID: () => HEADER_REQUEST_ID,
+  InternalHttp: () => InternalHttp,
+  REQUEST_ID_HEADER: () => REQUEST_ID_HEADER,
+  UpstreamError: () => UpstreamError,
+  closeCache: () => closeCache,
+  createHttpClient: () => createHttpClient,
+  getOrSet: () => getOrSet,
+  getRequestContextFromHeaders: () => getRequestContextFromHeaders,
+  getTwoLevelCache: () => getTwoLevelCache,
+  internalAuth: () => internalAuth,
+  mapAxiosToUpstreamError: () => mapAxiosToUpstreamError,
+  parseHeaders: () => parseHeaders,
+  requestId: () => requestId,
+  sendError: () => sendError,
+  sendOk: () => sendOk,
+  withRequestId: () => withRequestId,
+  withRequestIdConfig: () => withRequestIdConfig
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/cache/redisCacheProvider.ts
+var import_redis = require("redis");
+function buildRedisUrl(opts) {
+  if (opts.url && opts.url.trim()) return opts.url.trim();
+  if (!opts.host) return void 0;
+  const port = opts.port ?? 6379;
+  const db = opts.db ?? 0;
+  const auth = opts.password ? `:${encodeURIComponent(opts.password)}@` : "";
+  return `redis://${auth}${opts.host}:${port}/${db}`;
+}
+var RedisCacheProvider = class {
+  constructor(opts) {
+    this.opts = opts;
+    const url = buildRedisUrl(opts);
+    if (!url) {
+      throw new Error("[RedisCacheProvider] Missing redis config (REDIS_URL or REDIS_HOST)");
+    }
+    this.keyPrefix = opts.keyPrefix?.trim() || void 0;
+    this.client = (0, import_redis.createClient)({
+      url,
+      socket: {
+        connectTimeout: opts.connectTimeoutMs ?? 3e3,
+        tls: opts.tls ? true : void 0
+      }
+    });
+    this.client.on("error", (err) => {
+      const msg = err instanceof Error ? err.message : typeof err === "object" && err !== null && "message" in err ? String(err.message) : String(err);
+      console.error("[redis] error", msg, err);
+    });
+  }
+  kind = "redis";
+  // ✅ tip "amplio" para evitar TS2322 por typings genéricos
+  client;
+  ready = false;
+  keyPrefix;
+  k(key) {
+    if (!this.keyPrefix) return key;
+    return `${this.keyPrefix}:${key}`;
+  }
+  async ensureConnected() {
+    if (this.ready) return;
+    await this.client.connect();
+    this.ready = true;
+  }
+  async get(key) {
+    await this.ensureConnected();
+    const v = await this.client.get(this.k(key));
+    return v ?? null;
+  }
+  async set(key, value, options) {
+    await this.ensureConnected();
+    const ttlMs = options?.ttlMs;
+    if (ttlMs && ttlMs > 0) {
+      await this.client.set(this.k(key), value, { PX: ttlMs });
+      return;
+    }
+    await this.client.set(this.k(key), value);
+  }
+  async del(key) {
+    await this.ensureConnected();
+    await this.client.del(this.k(key));
+  }
+  async close() {
+    try {
+      if (this.ready) await this.client.quit();
+    } catch {
+      try {
+        await this.client.disconnect();
+      } catch {
+      }
+    } finally {
+      this.ready = false;
+    }
+  }
+};
+
+// src/cache/cacheProvider.ts
+var NoopCacheProvider = class {
+  kind = "noop";
+  async get(_key) {
+    return null;
+  }
+  async set(_key, _value, _options) {
+    return;
+  }
+  async del(_key) {
+    return;
+  }
+  async close() {
+    return;
+  }
+};
+function createCacheProvider(opts = {}) {
+  const envHasRedis = Boolean(process.env.REDIS_URL || process.env.REDIS_HOST);
+  const enabled = typeof opts.enabled === "boolean" ? opts.enabled : envHasRedis;
+  if (!enabled) return new NoopCacheProvider();
+  const redisOpts = {
+    url: process.env.REDIS_URL,
+    host: process.env.REDIS_HOST,
+    port: process.env.REDIS_PORT ? Number(process.env.REDIS_PORT) : void 0,
+    password: process.env.REDIS_PASSWORD,
+    db: process.env.REDIS_DB ? Number(process.env.REDIS_DB) : void 0,
+    tls: (process.env.REDIS_TLS || "").toLowerCase() === "true",
+    connectTimeoutMs: process.env.REDIS_CONNECT_TIMEOUT_MS ? Number(process.env.REDIS_CONNECT_TIMEOUT_MS) : 3e3,
+    keyPrefix: opts.keyPrefix || process.env.REDIS_KEY_PREFIX || void 0,
+    ...opts.redis || {}
+  };
+  return new RedisCacheProvider(redisOpts);
+}
+
+// src/cache/ttlCache.ts
+var TtlCache = class {
+  constructor(defaultTtlMs) {
+    this.defaultTtlMs = defaultTtlMs;
+  }
+  store = /* @__PURE__ */ new Map();
+  get(key) {
+    const e = this.store.get(key);
+    if (!e) return null;
+    if (Date.now() > e.expiresAt) {
+      this.store.delete(key);
+      return null;
+    }
+    return e.value;
+  }
+  set(key, value, ttlMs) {
+    this.store.set(key, { value, expiresAt: Date.now() + (ttlMs ?? this.defaultTtlMs) });
+  }
+  del(key) {
+    this.store.delete(key);
+  }
+};
+
+// src/cache/twoLevelCache.ts
+function safeJsonParse(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function safeJsonStringify(v) {
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return null;
+  }
+}
+var TwoLevelCache = class {
+  constructor(l2, opts = {}) {
+    this.l2 = l2;
+    this.opts = opts;
+    const defaultTtl = this.opts.ttlMsL1 ?? 2 * 60 * 1e3;
+    this.l1 = new TtlCache(defaultTtl);
+  }
+  l1;
+  inflight = /* @__PURE__ */ new Map();
+  key(k) {
+    const ns = (this.opts.namespace || "").trim();
+    return ns ? `${ns}:${k}` : k;
+  }
+  /**
+   * GET "best effort": primero L1, luego L2.
+   * (No llama loader)
+   */
+  async get(k) {
+    const key = this.key(k);
+    const v1 = this.l1.get(key);
+    if (v1 !== void 0) return v1;
+    const raw = await this.l2.get(key);
+    if (!raw) return null;
+    const parsed = safeJsonParse(raw);
+    if (parsed === null && raw !== "null") {
+      return null;
+    }
+    this.l1.set(key, parsed, this.opts.ttlMsL1);
+    return parsed;
+  }
+  async set(k, value, ttlOverride) {
+    const key = this.key(k);
+    const ttlL1 = ttlOverride?.ttlMsL1 ?? this.opts.ttlMsL1 ?? 2 * 60 * 1e3;
+    const ttlL2 = ttlOverride?.ttlMsL2 ?? this.opts.ttlMsL2 ?? 10 * 60 * 1e3;
+    this.l1.set(key, value, ttlL1);
+    const raw = safeJsonStringify(value);
+    if (raw == null) return;
+    await this.l2.set(key, raw, { ttlMs: ttlL2 });
+  }
+  async del(k) {
+    const key = this.key(k);
+    this.l1.del?.(key);
+    await this.l2.del(key);
+  }
+  /**
+   * Cache-aside real con L1 + L2 + loader.
+   *
+   * - Dedup de concurrencia por key (inflight)
+   * - Soporta negative caching (si loader retorna null)
+   */
+  async getOrSet(k, loader, options) {
+    const key = this.key(k);
+    const v1 = this.l1.get(key);
+    if (v1 !== void 0) return v1;
+    const raw = await this.l2.get(key);
+    if (raw) {
+      const parsed = safeJsonParse(raw);
+      if (parsed !== null || raw === "null") {
+        this.l1.set(key, parsed, options?.ttlMsL1 ?? this.opts.ttlMsL1);
+        return parsed;
+      }
+    }
+    if (this.inflight.has(key)) {
+      return this.inflight.get(key);
+    }
+    const promise = (async () => {
+      try {
+        const value = await loader();
+        const ttlMsL1 = options?.ttlMsL1 ?? this.opts.ttlMsL1 ?? 2 * 60 * 1e3;
+        const ttlMsL2 = options?.ttlMsL2 ?? this.opts.ttlMsL2 ?? 10 * 60 * 1e3;
+        const negL1 = options?.negativeTtlMsL1 ?? this.opts.negativeTtlMsL1 ?? 0;
+        const negL2 = options?.negativeTtlMsL2 ?? this.opts.negativeTtlMsL2 ?? 0;
+        if (value === null) {
+          if (negL1 > 0) this.l1.set(key, null, negL1);
+          if (negL2 > 0) await this.l2.set(key, "null", { ttlMs: negL2 });
+          return null;
+        }
+        this.l1.set(key, value, ttlMsL1);
+        const rawValue = safeJsonStringify(value);
+        if (rawValue != null) {
+          await this.l2.set(key, rawValue, { ttlMs: ttlMsL2 });
+        }
+        return value;
+      } finally {
+        this.inflight.delete(key);
+      }
+    })();
+    this.inflight.set(key, promise);
+    return promise;
+  }
+};
+
+// src/cache/index.ts
+var envInt = (v, dflt = 0) => {
+  const n = Number(v);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : dflt;
+};
+var DEFAULT_L1_TTL_MS = envInt(process.env.CACHE_L1_DEFAULT_TTL_MS, 3e4);
+var DEFAULT_L2_TTL_MS = envInt(process.env.CACHE_L2_DEFAULT_TTL_MS, 3e5);
+var DEFAULT_NEG_TTL_MS = envInt(process.env.CACHE_NEGATIVE_TTL_MS, 3e4);
+var l2Provider = null;
+var twoLevelByNamespace = /* @__PURE__ */ new Map();
+function getL2() {
+  if (l2Provider) return l2Provider;
+  l2Provider = createCacheProvider();
+  return l2Provider;
+}
+function getTwoLevelCache(namespace, opts = {}) {
+  const existing = twoLevelByNamespace.get(namespace);
+  if (existing) return existing;
+  const l2 = getL2();
+  const cacheOptions = {
+    // ✅ dejamos que TwoLevelCache prefije keys con namespace internamente
+    namespace,
+    ttlMsL1: opts.ttlMsL1 ?? DEFAULT_L1_TTL_MS,
+    ttlMsL2: opts.ttlMsL2 ?? DEFAULT_L2_TTL_MS,
+    // ✅ negative caching
+    negativeTtlMsL1: opts.negativeTtlMsL1 ?? DEFAULT_NEG_TTL_MS,
+    negativeTtlMsL2: opts.negativeTtlMsL2 ?? DEFAULT_NEG_TTL_MS
+  };
+  const cache = new TwoLevelCache(l2, cacheOptions);
+  twoLevelByNamespace.set(namespace, cache);
+  return cache;
+}
+async function getOrSet(namespace, key, loader, opts = {}) {
+  const cache = getTwoLevelCache(namespace, opts);
+  return cache.getOrSet(key, loader, opts);
+}
+async function closeCache() {
+  try {
+    if (l2Provider && typeof l2Provider.close === "function") {
+      await l2Provider.close();
+    }
+  } finally {
+    l2Provider = null;
+    twoLevelByNamespace.clear();
+  }
+}
+
+// src/core/errors.ts
+var UpstreamError = class extends Error {
+  code;
+  status;
+  details;
+  constructor(message, code, status, details) {
+    super(message);
+    this.name = "UpstreamError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+  }
+};
+function mapAxiosToUpstreamError(err, svc) {
+  const status = err?.response?.status;
+  const data = err?.response?.data;
+  const isTimeout = err?.code === "ECONNABORTED" || String(err?.message || "").includes("timeout");
+  if (isTimeout) {
+    return new UpstreamError(`[${svc}] timeout`, "UPSTREAM_TIMEOUT", 504, { cause: err?.message });
+  }
+  if (!err?.response) {
+    return new UpstreamError(`[${svc}] unavailable`, "UPSTREAM_UNAVAILABLE", 503, { cause: err?.message });
+  }
+  if (status === 404) return new UpstreamError(`[${svc}] not found`, "UPSTREAM_NOT_FOUND", 404, data);
+  if (status === 401) return new UpstreamError(`[${svc}] unauthorized`, "UPSTREAM_UNAUTHORIZED", 401, data);
+  if (status === 403) return new UpstreamError(`[${svc}] forbidden`, "UPSTREAM_FORBIDDEN", 403, data);
+  if (status >= 400 && status < 600) {
+    return new UpstreamError(`[${svc}] bad response`, "UPSTREAM_BAD_RESPONSE", status, data);
+  }
+  return new UpstreamError(`[${svc}] unknown error`, "UPSTREAM_UNKNOWN", status, data);
+}
+
+// src/core/http.ts
+var import_axios = __toESM(require("axios"), 1);
+var REQUEST_ID_HEADER = "x-request-id";
+function withRequestId(headers, requestId2) {
+  const h = headers && typeof headers === "object" ? { ...headers } : {};
+  const rid = (requestId2 || "").trim();
+  if (rid) h[REQUEST_ID_HEADER] = rid;
+  return h;
+}
+function withRequestIdConfig(config = {}, requestId2) {
+  return {
+    ...config,
+    headers: withRequestId(config.headers, requestId2)
+  };
+}
+function createHttpClient(opts) {
+  return import_axios.default.create({
+    baseURL: opts.baseURL,
+    timeout: opts.timeoutMs ?? 4e3,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+
+// src/core/internalHttp.ts
+var DEFAULT_RETRY = {
+  retries: 1,
+  baseDelayMs: 150,
+  retryOnStatuses: [429, 502, 503, 504],
+  retryOnNetworkErrors: true
+};
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function safeJsonStringify2(v) {
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+function toHeaders(init) {
+  return new Headers(init || {});
+}
+function isJsonContentType(contentType) {
+  if (!contentType) return false;
+  const ct = contentType.toLowerCase();
+  return ct.includes("application/json") || ct.includes("+json");
+}
+function isAbortError(e) {
+  return e?.name === "AbortError";
+}
+function withJitter(ms) {
+  const jitter = ms * 0.2;
+  const delta = (Math.random() * 2 - 1) * jitter;
+  return Math.max(0, Math.floor(ms + delta));
+}
+var InternalHttp = class {
+  baseUrl;
+  apiKey;
+  timeoutMs;
+  retry;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.apiKey = opts.apiKey;
+    this.timeoutMs = opts.timeoutMs ?? 4e3;
+    this.retry = { ...DEFAULT_RETRY, ...opts.retry || {} };
+  }
+  async request(path, init = {}) {
+    const url = `${this.baseUrl}${path.startsWith("/") ? "" : "/"}${path}`;
+    const baseHeaders = toHeaders(init.headers);
+    if (!baseHeaders.has("Content-Type")) baseHeaders.set("Content-Type", "application/json");
+    if (this.apiKey) baseHeaders.set("x-internal-api-key", this.apiKey);
+    if (init.requestId) baseHeaders.set("x-request-id", init.requestId);
+    if (init.idempotencyKey) baseHeaders.set("Idempotency-Key", init.idempotencyKey);
+    const { headers: _ignored, ...restInit } = init;
+    const doFetchOnce = async () => {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+      try {
+        const res = await fetch(url, {
+          ...restInit,
+          headers: baseHeaders,
+          signal: controller.signal
+        });
+        if (!res.ok) {
+          const text2 = await res.text().catch(() => "");
+          const err = new Error(
+            `HTTP ${res.status} ${res.statusText}${text2 ? ` - ${text2}` : ""}`
+          );
+          err.status = res.status;
+          err.body = text2;
+          throw err;
+        }
+        if (res.status === 204) return void 0;
+        const contentType = res.headers.get("content-type");
+        if (isJsonContentType(contentType)) {
+          return await res.json();
+        }
+        const text = await res.text().catch(() => "");
+        return text;
+      } finally {
+        clearTimeout(timeout);
+      }
+    };
+    let attempt = 0;
+    while (true) {
+      try {
+        return await doFetchOnce();
+      } catch (e) {
+        attempt++;
+        const status = e?.status;
+        const retryableStatus = !!status && this.retry.retryOnStatuses.includes(status);
+        const retryableNetwork = this.retry.retryOnNetworkErrors && (isAbortError(e) || !status);
+        const isRetryable = retryableStatus || retryableNetwork;
+        if (!isRetryable || attempt > this.retry.retries) {
+          console.error(
+            `[InternalHttp] request failed: ${url} attempt=${attempt} status=${status ?? "n/a"} err=${e?.message} body=${safeJsonStringify2(e?.body)}`
+          );
+          throw e;
+        }
+        const backoff = withJitter(this.retry.baseDelayMs * attempt);
+        await sleep(backoff);
+      }
+    }
+  }
+};
+
+// src/headers/constants.ts
+var HEADER_REQUEST_ID = "x-request-id";
+var HEADER_COMPANY_UID = "x-company";
+var HEADER_BRANCH_UID = "x-branch";
+var HEADER_EMPLOYEE_UID = "x-employee-uid";
+var HEADER_INTERNAL_API_KEY = "x-internal-api-key";
+var HEADER_AUTHORIZATION = "authorization";
+
+// src/headers/parse.ts
+function asString(v) {
+  if (typeof v !== "string") return null;
+  const s = v.trim();
+  return s ? s : null;
+}
+function getRequestContextFromHeaders(headers) {
+  return {
+    requestId: asString(headers[HEADER_REQUEST_ID]) ?? null,
+    company_uid: asString(headers[HEADER_COMPANY_UID]) ?? null,
+    branch_uid: asString(headers[HEADER_BRANCH_UID]) ?? null,
+    employee_uid: asString(headers[HEADER_EMPLOYEE_UID]) ?? null
+  };
+}
+
+// src/middlewares/requestId.ts
+var import_crypto = require("crypto");
+var REQUEST_ID_HEADER2 = "x-request-id";
+var REQUEST_ID_HEADER_ALT = "x-requestid";
+var RESPONSE_REQUEST_ID_HEADER = "X-Request-Id";
+function requestId(req, res, next) {
+  const headerId = req.headers[REQUEST_ID_HEADER2] || req.headers[REQUEST_ID_HEADER_ALT];
+  const id = headerId?.trim() || (0, import_crypto.randomUUID)();
+  req.requestId = id;
+  res.locals.requestId = id;
+  res.setHeader(RESPONSE_REQUEST_ID_HEADER, id);
+  next();
+}
+
+// src/middlewares/parseHeaders.ts
+function parseHeaders(req, _res, next) {
+  const context = getRequestContextFromHeaders(req.headers);
+  req.context = context;
+  const auth = req.auth ?? (req.auth = {});
+  if (context.company_uid) auth.company_uid = context.company_uid;
+  if (context.branch_uid) auth.branch_uid = context.branch_uid;
+  if (context.employee_uid) auth.employee_uid = context.employee_uid;
+  next();
+}
+
+// src/middlewares/internalAuth.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_crypto2 = __toESM(require("crypto"), 1);
+
+// src/middlewares/respond.ts
+function sendOk(_req, res, data, statusCode = 200) {
+  return res.status(statusCode).json({ ok: true, data, requestId: res.locals?.requestId ?? null });
+}
+function sendError(_req, res, statusCode, code, message, details) {
+  return res.status(statusCode).json({
+    ok: false,
+    error: { code, message, ...details !== void 0 ? { details } : {} },
+    requestId: res.locals?.requestId ?? null
+  });
+}
+
+// src/middlewares/internalAuth.ts
+function readSecretFile(path) {
+  if (!path) return null;
+  try {
+    const v = import_fs.default.readFileSync(path, "utf8").trim();
+    return v.length ? v : null;
+  } catch {
+    return null;
+  }
+}
+function splitKeys(v) {
+  if (!v) return [];
+  return v.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function getExpectedKeys() {
+  const fileKey = readSecretFile(process.env.INTERNAL_API_KEY_FILE);
+  const envKey = (process.env.INTERNAL_API_KEY || "").trim();
+  const raw = fileKey || envKey;
+  return splitKeys(raw);
+}
+function extractToken(req) {
+  const apiKey = (req.header(HEADER_INTERNAL_API_KEY) || "").trim();
+  return apiKey || null;
+}
+function safeEquals(a, b) {
+  const aa = Buffer.from(a);
+  const bb = Buffer.from(b);
+  if (aa.length !== bb.length) return false;
+  return import_crypto2.default.timingSafeEqual(aa, bb);
+}
+function internalAuth(req, res, next) {
+  const token = extractToken(req);
+  if (!token) {
+    return sendError(req, res, 401, "UNAUTHORIZED", `Missing internal api key (${HEADER_INTERNAL_API_KEY})`);
+  }
+  const expectedKeys = getExpectedKeys();
+  if (expectedKeys.length === 0) {
+    return sendError(
+      req,
+      res,
+      500,
+      "MISCONFIGURED_INTERNAL_AUTH",
+      "Internal api key not configured (INTERNAL_API_KEY or INTERNAL_API_KEY_FILE)"
+    );
+  }
+  const ok = expectedKeys.some((k) => safeEquals(token, k));
+  if (!ok) {
+    return sendError(req, res, 403, "FORBIDDEN", "Invalid internal api key");
+  }
+  return next();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HEADER_AUTHORIZATION,
+  HEADER_BRANCH_UID,
+  HEADER_COMPANY_UID,
+  HEADER_EMPLOYEE_UID,
+  HEADER_INTERNAL_API_KEY,
+  HEADER_REQUEST_ID,
+  InternalHttp,
+  REQUEST_ID_HEADER,
+  UpstreamError,
+  closeCache,
+  createHttpClient,
+  getOrSet,
+  getRequestContextFromHeaders,
+  getTwoLevelCache,
+  internalAuth,
+  mapAxiosToUpstreamError,
+  parseHeaders,
+  requestId,
+  sendError,
+  sendOk,
+  withRequestId,
+  withRequestIdConfig
+});
+//# sourceMappingURL=index.cjs.map