@innvoid/getmarket-sdk 0.2.2 → 0.2.4

package/dist/clients/index.cjs

@@ -0,0 +1,699 @@
+"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/clients/index.ts
+var clients_exports = {};
+__export(clients_exports, {
+  createBulkRefsClient: () => createBulkRefsClient,
+  createFisClient: () => createFisClient,
+  createMdClient: () => createMdClient,
+  createMediaClient: () => createMediaClient,
+  createMkpClient: () => createMkpClient,
+  createPlatformClient: () => createPlatformClient,
+  createResClient: () => createResClient,
+  readServiceEnv: () => readServiceEnv
+});
+module.exports = __toCommonJS(clients_exports);
+
+// 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/internalHttpClient.ts
+var import_fs = __toESM(require("fs"), 1);
+
+// 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";
+
+// src/internalHttpClient.ts
+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 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 getInternalApiKey(override) {
+  if (override && override.trim()) return override.trim();
+  const fileKey = readSecretFile(process.env.INTERNAL_API_KEY_FILE);
+  const envKey = (process.env.INTERNAL_API_KEY || "").trim();
+  const raw = fileKey || envKey;
+  const keys = splitKeys(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 h = {
+    "Content-Type": "application/json"
+  };
+  if (ctx?.requestId) h[HEADER_REQUEST_ID] = String(ctx.requestId);
+  if (ctx?.company_uid) h[HEADER_COMPANY_UID] = String(ctx.company_uid);
+  if (ctx?.branch_uid) h[HEADER_BRANCH_UID] = String(ctx.branch_uid);
+  if (ctx?.employee_uid) h[HEADER_EMPLOYEE_UID] = String(ctx.employee_uid);
+  if (idempotencyKey && idempotencyKey.trim()) {
+    h["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;
+    h[k] = vv;
+  }
+  return h;
+}
+async function sleep(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 sleep(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 sleep(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/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);
+
+// 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 = {
+  createBulkRefsClient,
+  createFisClient,
+  createMdClient,
+  createMediaClient,
+  createMkpClient,
+  createPlatformClient,
+  createResClient,
+  readServiceEnv
+});
+//# sourceMappingURL=index.cjs.map