@innvoid/getmarket-sdk 0.2.2 → 0.2.4

package/dist/index.cjs

@@ -37,6 +37,7 @@ __export(src_exports, {
   HEADER_INTERNAL_API_KEY: () => HEADER_INTERNAL_API_KEY,
   HEADER_REQUEST_ID: () => HEADER_REQUEST_ID,
   InternalHttp: () => InternalHttp,
+  InternalHttpError: () => InternalHttpError,
   TwoLevelCache: () => TwoLevelCache,
   UpstreamError: () => UpstreamError,
   allowAuthAdminOrPerm: () => allowAuthAdminOrPerm,
@@ -48,10 +49,19 @@ __export(src_exports, {
   authCustomerRequired: () => authCustomerRequired,
   authEmployeeAllowFirebase: () => authEmployeeAllowFirebase,
   authEmployeeRequired: () => authEmployeeRequired,
+  buildInternalHeaders: () => buildInternalHeaders,
   closeCache: () => closeCache,
   createAuthMiddleware: () => createAuthMiddleware,
   createAuthMiddlewareLegacySimple: () => createAuthMiddleware2,
+  createBulkRefsClient: () => createBulkRefsClient,
+  createFisClient: () => createFisClient,
   createHttpClient: () => createHttpClient,
+  createInternalHttpClient: () => createInternalHttpClient,
+  createMdClient: () => createMdClient,
+  createMediaClient: () => createMediaClient,
+  createMkpClient: () => createMkpClient,
+  createPlatformClient: () => createPlatformClient,
+  createResClient: () => createResClient,
   getOrSet: () => getOrSet,
   getRequestContextFromHeaders: () => getRequestContextFromHeaders,
   getTwoLevelCache: () => getTwoLevelCache,
@@ -59,6 +69,7 @@ __export(src_exports, {
   mapAxiosToUpstreamError: () => mapAxiosToUpstreamError,
   parseHeaders: () => parseHeaders,
   readRs256PublicKey: () => readRs256PublicKey,
+  readServiceEnv: () => readServiceEnv,
   requestId: () => requestId,
   requireAnyPermission: () => requireAnyPermission,
   requireAuthContext: () => requireAuthContext,
@@ -67,9 +78,7 @@ __export(src_exports, {
   requireRolesOrAnyPermission: () => requireRolesOrAnyPermission,
   sendError: () => sendError,
   sendOk: () => sendOk,
-  verifyBackendJwtRS256: () => verifyBackendJwtRS256,
-  withRequestId: () => withRequestId,
-  withRequestIdConfig: () => withRequestIdConfig
+  verifyBackendJwtRS256: () => verifyBackendJwtRS256
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -394,39 +403,11 @@ function mapAxiosToUpstreamError(err, svc) {
 
 // src/core/http.ts
 var import_axios = __toESM(require("axios"), 1);
-
-// src/middlewares/requestId.ts
-var import_crypto = require("crypto");
-var REQUEST_ID_HEADER = "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_HEADER] || 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/core/http.ts
-function withRequestId(headers, requestId2) {
-  const h2 = headers && typeof headers === "object" ? { ...headers } : {};
-  const rid = (requestId2 || "").trim();
-  if (rid) h2[REQUEST_ID_HEADER] = rid;
-  return h2;
-}
-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" }
+    baseURL: opts.baseURL.replace(/\/+$/, ""),
+    timeout: opts.timeoutMs ?? 8e3,
+    headers: opts.headers ?? {}
   });
 }
 
@@ -569,6 +550,20 @@ function parseHeaders(req, _res, next) {
   next();
 }
 
+// src/middlewares/requestId.ts
+var import_crypto = require("crypto");
+var REQUEST_ID_HEADER = "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_HEADER] || 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/internalAuth.ts
 var import_fs = __toESM(require("fs"), 1);
 var import_crypto2 = __toESM(require("crypto"), 1);
@@ -1183,6 +1178,393 @@ function allowSysAdminOrRolesOrAnyPermission(roles, permissions) {
 function allowAuthAdminOrPerm(permission) {
   return allowSysAdminOrRolesOrAnyPermission(["AUTH_ADMIN"], [permission]);
 }
+
+// src/internalHttpClient.ts
+var import_fs4 = __toESM(require("fs"), 1);
+var InternalHttpError = class extends Error {
+  status;
+  code;
+  details;
+  constructor(status, code, message, details) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.details = details ?? null;
+  }
+};
+function readSecretFile2(path) {
+  if (!path) return null;
+  try {
+    const v = import_fs4.default.readFileSync(path, "utf8").trim();
+    return v.length ? v : null;
+  } catch {
+    return null;
+  }
+}
+function splitKeys2(v) {
+  if (!v) return [];
+  return v.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function getInternalApiKey(override) {
+  if (override && override.trim()) return override.trim();
+  const fileKey = readSecretFile2(process.env.INTERNAL_API_KEY_FILE);
+  const envKey = (process.env.INTERNAL_API_KEY || "").trim();
+  const raw = fileKey || envKey;
+  const keys = splitKeys2(raw);
+  return keys[0] || null;
+}
+function normalizeBaseURL(baseURL) {
+  const b = (baseURL || "").trim();
+  if (!b) throw new Error("InternalHttpClient: baseURL is required");
+  return b.replace(/\/+$/g, "");
+}
+function normalizePrefix(prefix) {
+  const p = (prefix || "").trim();
+  if (!p) return "";
+  const withSlash = p.startsWith("/") ? p : `/${p}`;
+  return withSlash.replace(/\/+$/g, "");
+}
+function buildQuery(query) {
+  if (!query) return "";
+  const params = new URLSearchParams();
+  for (const [k, v] of Object.entries(query)) {
+    if (v === null || v === void 0) continue;
+    params.set(k, String(v));
+  }
+  const s = params.toString();
+  return s ? `?${s}` : "";
+}
+function buildInternalHeaders(ctx, extra, idempotencyKey) {
+  const h2 = {
+    "Content-Type": "application/json"
+  };
+  if (ctx?.requestId) h2[HEADER_REQUEST_ID] = String(ctx.requestId);
+  if (ctx?.company_uid) h2[HEADER_COMPANY_UID] = String(ctx.company_uid);
+  if (ctx?.branch_uid) h2[HEADER_BRANCH_UID] = String(ctx.branch_uid);
+  if (ctx?.employee_uid) h2[HEADER_EMPLOYEE_UID] = String(ctx.employee_uid);
+  if (idempotencyKey && idempotencyKey.trim()) {
+    h2["Idempotency-Key"] = idempotencyKey.trim();
+  }
+  for (const [k, v] of Object.entries(extra || {})) {
+    if (v === void 0) continue;
+    const vv = String(v).trim();
+    if (!vv) continue;
+    h2[k] = vv;
+  }
+  return h2;
+}
+async function sleep2(ms) {
+  await new Promise((r) => setTimeout(r, ms));
+}
+function shouldRetry(status, err) {
+  if (err?.name === "AbortError") return true;
+  if (!status) return true;
+  if (status >= 500) return true;
+  if (status === 429) return true;
+  return false;
+}
+async function safeReadJson(res) {
+  const text = await res.text();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}
+function createInternalHttpClient(opts) {
+  const baseURL = normalizeBaseURL(opts.baseURL);
+  const apiPrefix = normalizePrefix(opts.apiPrefix);
+  const timeoutMs = typeof opts.timeoutMs === "number" ? opts.timeoutMs : 15e3;
+  const retries = typeof opts.retries === "number" ? opts.retries : 2;
+  const retryDelayMs = typeof opts.retryDelayMs === "number" ? opts.retryDelayMs : 250;
+  const apiKey = getInternalApiKey(opts.apiKey ?? null);
+  if (!apiKey) {
+    throw new Error(
+      "InternalHttpClient: INTERNAL_API_KEY or INTERNAL_API_KEY_FILE is required to call internal endpoints."
+    );
+  }
+  async function request(r) {
+    const path = (r.path || "").trim();
+    if (!path.startsWith("/")) {
+      throw new Error(`InternalHttpClient: path must start with '/': ${path}`);
+    }
+    const url = `${baseURL}${apiPrefix}${path}${buildQuery(r.query)}`;
+    const headers = buildInternalHeaders(r.ctx ?? null, r.headers, r.idempotencyKey ?? null);
+    if (apiKey != null) {
+      headers[HEADER_INTERNAL_API_KEY] = apiKey;
+    }
+    const method = r.method;
+    const expectJson = r.expectJson !== false;
+    const body = method === "GET" || method === "DELETE" ? void 0 : r.body !== void 0 ? JSON.stringify(r.body) : void 0;
+    let attempt = 0;
+    let lastErr = null;
+    while (attempt <= retries) {
+      attempt++;
+      const ac = new AbortController();
+      const to = setTimeout(() => ac.abort(), timeoutMs);
+      try {
+        const res = await fetch(url, {
+          method,
+          headers,
+          body,
+          signal: ac.signal
+        });
+        clearTimeout(to);
+        if (res.ok) {
+          if (!expectJson) return void 0;
+          const data = await safeReadJson(res);
+          return data;
+        }
+        const errBody = await safeReadJson(res);
+        const status = res.status;
+        if (attempt <= retries && shouldRetry(status, null)) {
+          lastErr = new InternalHttpError(
+            status,
+            "INTERNAL_HTTP_RETRY",
+            `Retryable internal HTTP error (${status})`,
+            { url, status, response: errBody, attempt }
+          );
+          await sleep2(retryDelayMs * attempt);
+          continue;
+        }
+        throw new InternalHttpError(
+          status,
+          "INTERNAL_HTTP_ERROR",
+          `Internal HTTP error (${status})`,
+          { url, status, response: errBody }
+        );
+      } catch (e) {
+        clearTimeout(to);
+        if (attempt <= retries && shouldRetry(null, e)) {
+          lastErr = e;
+          await sleep2(retryDelayMs * attempt);
+          continue;
+        }
+        if (e instanceof InternalHttpError) throw e;
+        throw new InternalHttpError(
+          0,
+          "INTERNAL_HTTP_NETWORK_ERROR",
+          e?.message || "Internal HTTP network error",
+          { url, attempt, error: String(e) }
+        );
+      }
+    }
+    throw lastErr || new InternalHttpError(0, "INTERNAL_HTTP_FAILED", "Internal request failed");
+  }
+  return {
+    request,
+    get: (path, o) => request({ ...o || {}, method: "GET", path }),
+    post: (path, body, o) => request({ ...o || {}, method: "POST", path, body }),
+    put: (path, body, o) => request({ ...o || {}, method: "PUT", path, body }),
+    patch: (path, body, o) => request({ ...o || {}, method: "PATCH", path, body }),
+    del: (path, o) => request({ ...o || {}, method: "DELETE", path })
+  };
+}
+
+// src/clients/env.ts
+function must(v, name) {
+  const s = (v || "").trim();
+  if (!s) throw new Error(`Missing env var: ${name}`);
+  return s;
+}
+function readServiceEnv(prefix, defaults) {
+  const baseURL = (process.env[`${prefix}_BASE_URL`] || defaults?.baseURL || "").trim();
+  const apiPrefix = (process.env[`${prefix}_API_PREFIX`] || defaults?.apiPrefix || "/internal/v1").trim();
+  return {
+    baseURL: must(baseURL, `${prefix}_BASE_URL`),
+    apiPrefix
+  };
+}
+
+// src/clients/cacheFactory.ts
+function makeRefsCache(namespace) {
+  const l2 = createCacheProvider();
+  return new TwoLevelCache(l2, {
+    namespace,
+    ttlMsL1: 3e4,
+    ttlMsL2: 3e5,
+    negativeTtlMsL1: 3e4,
+    negativeTtlMsL2: 3e4
+  });
+}
+
+// src/clients/bulkRefsClient.ts
+function uniq(arr) {
+  return Array.from(new Set(arr.filter(Boolean)));
+}
+function createBulkRefsClient(args) {
+  const http = createInternalHttpClient({
+    baseURL: args.baseURL,
+    apiPrefix: args.apiPrefix
+  });
+  const cache = makeRefsCache(args.namespace);
+  async function bulkRefs(uids, opts) {
+    const list = uniq(uids);
+    if (list.length === 0) {
+      return { ok: true, refs: [], meta: { requested: 0, returned: 0, missing: [] } };
+    }
+    const hits = [];
+    const missing = [];
+    for (const uid of list) {
+      const v = await cache.get(uid);
+      if (v) hits.push(v);
+      else missing.push(uid);
+    }
+    let fetched = [];
+    if (missing.length) {
+      const resp = await http.post(
+        args.path,
+        { uids: missing },
+        {
+          ctx: opts?.ctx ?? null
+        }
+      );
+      const refs = resp.refs ?? resp.items ?? [];
+      fetched = refs;
+      const ttlMsL1 = opts?.ttlMsL1 ?? args.defaultTtlMsL1;
+      const ttlMsL2 = opts?.ttlMsL2 ?? args.defaultTtlMsL2;
+      for (const ref of refs) {
+        const uid = String(ref?.uid || "").trim();
+        if (!uid) continue;
+        await cache.set(uid, ref, {
+          ttlMsL1,
+          ttlMsL2
+        });
+      }
+    }
+    const all = [...hits, ...fetched];
+    const returnedSet = new Set(all.map((r) => String(r?.uid || "")));
+    const missingFinal = list.filter((u) => !returnedSet.has(u));
+    return {
+      ok: true,
+      refs: all,
+      meta: {
+        requested: list.length,
+        returned: all.length,
+        missing: missingFinal
+      }
+    };
+  }
+  return { bulkRefs };
+}
+
+// src/clients/platformClient.ts
+function createPlatformClient(env) {
+  const http = createInternalHttpClient(env);
+  const cache = makeRefsCache("platform:tenant");
+  async function resolveTenant(input, ctx) {
+    const key = `${input.company_uid}:${input.service}`;
+    const cached = await cache.get(key);
+    if (cached) return cached;
+    const resp = await http.post(
+      "/tenants/resolve",
+      input,
+      { ctx: ctx ?? null }
+    );
+    await cache.set(key, resp);
+    return resp;
+  }
+  return { resolveTenant };
+}
+
+// src/clients/resClient.ts
+function createResClient() {
+  const env = readServiceEnv("RES", { apiPrefix: "/internal/v1" });
+  const varieties = createBulkRefsClient({
+    namespace: "res:variety",
+    baseURL: env.baseURL,
+    apiPrefix: env.apiPrefix,
+    path: "/refs/varieties"
+  });
+  return {
+    varietiesRefs: (uids, opts) => varieties.bulkRefs(uids, opts)
+  };
+}
+
+// src/clients/mdClient.ts
+function createMdClient() {
+  const env = readServiceEnv("MD", { apiPrefix: "/internal/v1" });
+  const measures = createBulkRefsClient({
+    namespace: "md:measure",
+    baseURL: env.baseURL,
+    apiPrefix: env.apiPrefix,
+    path: "/refs/measures"
+  });
+  const measureTypes = createBulkRefsClient({
+    namespace: "md:measure_type",
+    baseURL: env.baseURL,
+    apiPrefix: env.apiPrefix,
+    path: "/refs/measure-types"
+  });
+  const countries = createBulkRefsClient({
+    namespace: "md:country",
+    baseURL: env.baseURL,
+    apiPrefix: env.apiPrefix,
+    path: "/refs/countries"
+  });
+  return {
+    measuresRefs: (uids, opts) => measures.bulkRefs(uids, opts),
+    measureTypesRefs: (uids, opts) => measureTypes.bulkRefs(uids, opts),
+    countriesRefs: (uids, opts) => countries.bulkRefs(uids, opts)
+  };
+}
+
+// src/clients/fisClient.ts
+function createFisClient() {
+  const env = readServiceEnv("FIS", { apiPrefix: "/internal/v1" });
+  const taxes = createBulkRefsClient({
+    namespace: "fis:tax",
+    baseURL: env.baseURL,
+    apiPrefix: env.apiPrefix,
+    path: "/refs/taxes"
+  });
+  return {
+    taxesRefs: (uids, opts) => taxes.bulkRefs(uids, opts)
+  };
+}
+
+// src/clients/mediaClient.ts
+function createMediaClient() {
+  const env = readServiceEnv("MEDIA", { apiPrefix: "/internal/v1" });
+  const files = createBulkRefsClient({
+    namespace: "media:file",
+    baseURL: env.baseURL,
+    apiPrefix: env.apiPrefix,
+    path: "/refs/files"
+  });
+  return {
+    filesRefs: (uids, opts) => files.bulkRefs(uids, opts)
+  };
+}
+
+// src/clients/mkpClient.ts
+function createMkpClient() {
+  const env = readServiceEnv("MKP", { apiPrefix: "/internal/v1" });
+  const publications = createBulkRefsClient({
+    namespace: "mkp:publication",
+    baseURL: env.baseURL,
+    apiPrefix: env.apiPrefix,
+    path: "/refs/publications"
+  });
+  const events = createBulkRefsClient({
+    namespace: "mkp:event",
+    baseURL: env.baseURL,
+    apiPrefix: env.apiPrefix,
+    path: "/refs/events"
+  });
+  const promotions = createBulkRefsClient({
+    namespace: "mkp:promotion",
+    baseURL: env.baseURL,
+    apiPrefix: env.apiPrefix,
+    path: "/refs/promotions"
+  });
+  return {
+    publicationsRefs: (uids, opts) => publications.bulkRefs(uids, opts),
+    eventsRefs: (uids, opts) => events.bulkRefs(uids, opts),
+    promotionsRefs: (uids, opts) => promotions.bulkRefs(uids, opts)
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HEADER_AUTHORIZATION,
@@ -1192,6 +1574,7 @@ function allowAuthAdminOrPerm(permission) {
   HEADER_INTERNAL_API_KEY,
   HEADER_REQUEST_ID,
   InternalHttp,
+  InternalHttpError,
   TwoLevelCache,
   UpstreamError,
   allowAuthAdminOrPerm,
@@ -1203,10 +1586,19 @@ function allowAuthAdminOrPerm(permission) {
   authCustomerRequired,
   authEmployeeAllowFirebase,
   authEmployeeRequired,
+  buildInternalHeaders,
   closeCache,
   createAuthMiddleware,
   createAuthMiddlewareLegacySimple,
+  createBulkRefsClient,
+  createFisClient,
   createHttpClient,
+  createInternalHttpClient,
+  createMdClient,
+  createMediaClient,
+  createMkpClient,
+  createPlatformClient,
+  createResClient,
   getOrSet,
   getRequestContextFromHeaders,
   getTwoLevelCache,
@@ -1214,6 +1606,7 @@ function allowAuthAdminOrPerm(permission) {
   mapAxiosToUpstreamError,
   parseHeaders,
   readRs256PublicKey,
+  readServiceEnv,
   requestId,
   requireAnyPermission,
   requireAuthContext,
@@ -1222,8 +1615,6 @@ function allowAuthAdminOrPerm(permission) {
   requireRolesOrAnyPermission,
   sendError,
   sendOk,
-  verifyBackendJwtRS256,
-  withRequestId,
-  withRequestIdConfig
+  verifyBackendJwtRS256
 });
 //# sourceMappingURL=index.cjs.map