@burdenoff/be-sdk 2026.525.1 → 2026.527.1

package/dist/index.js

@@ -42,7 +42,7 @@ export { DEFAULT_CIRCUIT_BREAKER_CONFIG, DEFAULT_GATEWAY_RETRY_CONFIG, DEFAULT_G
 import { logger } from './chunk-CBZNP6RF.js';
 export { logger_exports as Logger } from './chunk-CBZNP6RF.js';
 export { dataloader_exports as DataLoader } from './chunk-NUB5GQTU.js';
-import { __name } from './chunk-XE4OXN2W.js';
+import { __name, __export } from './chunk-XE4OXN2W.js';
 import { GraphQLClient } from 'graphql-request';
 import { AsyncLocalStorage } from 'async_hooks';
 
@@ -2192,6 +2192,475 @@ function createTenantBackendClient(config) {
 }
 __name(createTenantBackendClient, "createTenantBackendClient");
 
+// src/platform/index.ts
+var platform_exports = {};
+__export(platform_exports, {
+  CircuitBreakerOpenError: () => CircuitBreakerOpenError,
+  LLMRouter: () => LLMRouter,
+  __resetHttpClientBreakers: () => __resetHttpClientBreakers,
+  buildCacheKey: () => buildCacheKey,
+  buildLoaders: () => buildLoaders,
+  clampLimit: () => clampLimit,
+  createHttpClient: () => createHttpClient,
+  dropOldPartitions: () => dropOldPartitions,
+  ensureMonthlyPartitions: () => ensureMonthlyPartitions,
+  getNamespaceVersion: () => getNamespaceVersion,
+  httpClient: () => httpClient,
+  invalidateNamespace: () => invalidateNamespace,
+  monthlyPartitionName: () => monthlyPartitionName,
+  paginate: () => paginate,
+  rateLimitIncr: () => rateLimitIncr,
+  resolveReferenceLoader: () => resolveReferenceLoader,
+  withLeaderLock: () => withLeaderLock
+});
+
+// src/platform/httpClient.ts
+var breakers = /* @__PURE__ */ new Map();
+function hostOf(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+__name(hostOf, "hostOf");
+function getBreaker(host) {
+  let b = breakers.get(host);
+  if (!b) {
+    b = {
+      failures: 0,
+      openedAt: null,
+      state: "CLOSED"
+    };
+    breakers.set(host, b);
+  }
+  return b;
+}
+__name(getBreaker, "getBreaker");
+function defaultRetryOn(status) {
+  return status === 408 || status === 425 || status === 429 || status >= 500 && status <= 599;
+}
+__name(defaultRetryOn, "defaultRetryOn");
+function jitter(delay) {
+  return Math.floor(Math.random() * delay);
+}
+__name(jitter, "jitter");
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+__name(sleep, "sleep");
+var CircuitBreakerOpenError = class extends Error {
+  static {
+    __name(this, "CircuitBreakerOpenError");
+  }
+  constructor(host) {
+    super(`circuit breaker OPEN for host=${host}`);
+    this.name = "CircuitBreakerOpenError";
+  }
+};
+function __resetHttpClientBreakers() {
+  breakers.clear();
+}
+__name(__resetHttpClientBreakers, "__resetHttpClientBreakers");
+async function executeOnce(url, init, timeoutMs) {
+  const signal = init.signal ?? AbortSignal.timeout(timeoutMs);
+  return fetch(url, {
+    ...init,
+    signal
+  });
+}
+__name(executeOnce, "executeOnce");
+async function httpClient(url, init = {}, config = {}) {
+  const fullUrl = config.baseUrl && !/^https?:\/\//i.test(url) ? `${config.baseUrl.replace(/\/$/, "")}/${url.replace(/^\//, "")}` : url;
+  const host = hostOf(fullUrl);
+  const breaker = getBreaker(host);
+  const breakerThreshold = config.breaker?.threshold ?? 5;
+  const cooldownMs = config.breaker?.cooldownMs ?? 3e4;
+  if (breaker.state === "OPEN") {
+    if (breaker.openedAt && Date.now() - breaker.openedAt >= cooldownMs) {
+      breaker.state = "HALF_OPEN";
+      logger.info("httpClient.breaker.halfOpen", {
+        host
+      });
+    } else {
+      throw new CircuitBreakerOpenError(host);
+    }
+  }
+  const attempts = init.retry?.attempts ?? config.retry?.attempts ?? 3;
+  const initialDelay = init.retry?.initialDelayMs ?? config.retry?.initialDelayMs ?? 100;
+  const maxDelay = init.retry?.maxDelayMs ?? config.retry?.maxDelayMs ?? 2e3;
+  const retryOn = init.retry?.retryOn ?? config.retry?.retryOn ?? defaultRetryOn;
+  const timeoutMs = init.timeoutMs ?? config.defaultTimeoutMs ?? 5e3;
+  const headers = {
+    ...config.defaultHeaders ?? {},
+    ...init.headers ?? {}
+  };
+  let lastErr;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      const response = await executeOnce(fullUrl, {
+        ...init,
+        headers
+      }, timeoutMs);
+      if (response.status >= 500) {
+        breaker.failures += 1;
+        if (breaker.failures >= breakerThreshold) {
+          breaker.state = "OPEN";
+          breaker.openedAt = Date.now();
+          logger.warn("httpClient.breaker.open", {
+            host,
+            failures: breaker.failures
+          });
+        }
+        if (attempt < attempts && retryOn(response.status)) {
+          const delay = Math.min(initialDelay * 2 ** (attempt - 1), maxDelay);
+          await sleep(jitter(delay));
+          continue;
+        }
+        return response;
+      }
+      breaker.failures = 0;
+      if (breaker.state === "HALF_OPEN") {
+        breaker.state = "CLOSED";
+        breaker.openedAt = null;
+        logger.info("httpClient.breaker.closed", {
+          host
+        });
+      }
+      if (attempt < attempts && retryOn(response.status)) {
+        const delay = Math.min(initialDelay * 2 ** (attempt - 1), maxDelay);
+        await sleep(jitter(delay));
+        continue;
+      }
+      return response;
+    } catch (err) {
+      lastErr = err;
+      breaker.failures += 1;
+      if (breaker.failures >= breakerThreshold) {
+        breaker.state = "OPEN";
+        breaker.openedAt = Date.now();
+        logger.warn("httpClient.breaker.open", {
+          host,
+          failures: breaker.failures
+        });
+      }
+      if (attempt >= attempts) break;
+      const delay = Math.min(initialDelay * 2 ** (attempt - 1), maxDelay);
+      await sleep(jitter(delay));
+    }
+  }
+  logger.error("httpClient.exhausted", {
+    url: fullUrl,
+    attempts,
+    host
+  });
+  throw lastErr instanceof Error ? lastErr : new Error(`httpClient failed: ${String(lastErr)}`);
+}
+__name(httpClient, "httpClient");
+function createHttpClient(config = {}) {
+  return (url, init = {}) => httpClient(url, init, config);
+}
+__name(createHttpClient, "createHttpClient");
+
+// src/platform/leaderLock.ts
+var RELEASE_LUA = `
+if redis.call("get", KEYS[1]) == ARGV[1] then
+  return redis.call("del", KEYS[1])
+else
+  return 0
+end
+`;
+var RENEW_LUA = `
+if redis.call("get", KEYS[1]) == ARGV[1] then
+  return redis.call("pexpire", KEYS[1], ARGV[2])
+else
+  return 0
+end
+`;
+function generateToken() {
+  return `${Date.now()}-${Math.random().toString(36).slice(2)}-${process.pid}`;
+}
+__name(generateToken, "generateToken");
+async function withLeaderLock(redis, name, fn, options) {
+  const key = `besdk:leader:${name}`;
+  const token = generateToken();
+  const ttlMs = options.ttlMs;
+  const renewMs = options.renewMs ?? Math.max(1e3, Math.floor(ttlMs / 3));
+  const ttlSeconds = Math.max(1, Math.ceil(ttlMs / 1e3));
+  const acquired = await redis.set(key, token, "EX", ttlSeconds, "NX");
+  if (acquired !== "OK") {
+    return {
+      acquired: false
+    };
+  }
+  logger.info("leaderLock.acquired", {
+    name,
+    token,
+    ttlMs
+  });
+  let stopped = false;
+  const renewTimer = setInterval(() => {
+    if (stopped) return;
+    redis.eval(RENEW_LUA, 1, key, token, String(ttlMs)).catch((err) => {
+      logger.warn("leaderLock.renew.failed", {
+        name,
+        err: String(err)
+      });
+    });
+  }, renewMs);
+  if (typeof renewTimer.unref === "function") {
+    renewTimer.unref();
+  }
+  try {
+    const result = await fn();
+    return {
+      acquired: true,
+      result
+    };
+  } finally {
+    stopped = true;
+    clearInterval(renewTimer);
+    try {
+      await redis.eval(RELEASE_LUA, 1, key, token);
+      logger.info("leaderLock.released", {
+        name,
+        token
+      });
+    } catch (err) {
+      logger.warn("leaderLock.release.failed", {
+        name,
+        err: String(err)
+      });
+    }
+  }
+}
+__name(withLeaderLock, "withLeaderLock");
+
+// src/platform/rateLimit.ts
+async function rateLimitIncr(redis, input) {
+  const fullKey = `besdk:rl:${input.key}`;
+  const count = await redis.incr(fullKey);
+  if (count === 1) {
+    await redis.pexpire(fullKey, input.windowMs);
+  }
+  let ttl = -1;
+  try {
+    ttl = await redis.pttl(fullKey);
+  } catch {
+    ttl = input.windowMs;
+  }
+  const resetAt = Date.now() + (ttl > 0 ? ttl : input.windowMs);
+  const remaining = Math.max(0, input.limit - count);
+  return {
+    allowed: count <= input.limit,
+    count,
+    remaining,
+    resetAt
+  };
+}
+__name(rateLimitIncr, "rateLimitIncr");
+
+// src/platform/paginator.ts
+function clampLimit(input, opts = {}) {
+  const def = opts.defaultLimit ?? 50;
+  const max = opts.maxLimit ?? 200;
+  const min = opts.minLimit ?? 1;
+  if (input == null || Number.isNaN(input)) return def;
+  return Math.min(Math.max(Math.floor(input), min), max);
+}
+__name(clampLimit, "clampLimit");
+async function paginate(model, input, opts = {}) {
+  const take = clampLimit(input.take ?? void 0, opts);
+  const items = await model.findMany({
+    take: take + 1,
+    skip: input.cursor ? 1 : 0,
+    cursor: input.cursor ? {
+      id: input.cursor
+    } : void 0,
+    where: input.where,
+    orderBy: input.orderBy
+  });
+  const hasMore = items.length > take;
+  const trimmed = hasMore ? items.slice(0, take) : items;
+  const nextCursor = hasMore && trimmed.length > 0 ? trimmed[trimmed.length - 1].id : null;
+  return {
+    items: trimmed,
+    hasMore,
+    nextCursor
+  };
+}
+__name(paginate, "paginate");
+
+// src/platform/dataLoaderFactory.ts
+function buildLoaders(ctx, builder) {
+  return builder(ctx);
+}
+__name(buildLoaders, "buildLoaders");
+function resolveReferenceLoader(loaderName, keyField = "id") {
+  return async (reference, ctx) => {
+    const loader = ctx.loaders[loaderName];
+    if (!loader) {
+      throw new Error(`resolveReferenceLoader: loader "${loaderName}" not found on ctx.loaders`);
+    }
+    const key = reference[keyField];
+    if (typeof key !== "string") {
+      return null;
+    }
+    return loader.load(key);
+  };
+}
+__name(resolveReferenceLoader, "resolveReferenceLoader");
+
+// src/platform/cacheInvalidation.ts
+var VERSION_PREFIX = "besdk:cv:";
+async function getNamespaceVersion(redis, namespace) {
+  const v = await redis.get(`${VERSION_PREFIX}${namespace}`);
+  if (!v) return 1;
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) && n > 0 ? n : 1;
+}
+__name(getNamespaceVersion, "getNamespaceVersion");
+async function buildCacheKey(redis, namespace, ...parts) {
+  const ver = await getNamespaceVersion(redis, namespace);
+  return `${namespace}:v${ver}:${parts.join(":")}`;
+}
+__name(buildCacheKey, "buildCacheKey");
+async function invalidateNamespace(redis, namespace) {
+  return redis.incr(`${VERSION_PREFIX}${namespace}`);
+}
+__name(invalidateNamespace, "invalidateNamespace");
+
+// src/platform/pgPartition.ts
+function pad2(n) {
+  return n < 10 ? `0${n}` : `${n}`;
+}
+__name(pad2, "pad2");
+function monthlyPartitionName(table, year, month) {
+  return `${table}_y${year}m${pad2(month)}`;
+}
+__name(monthlyPartitionName, "monthlyPartitionName");
+async function ensureMonthlyPartitions(prisma, opts) {
+  const created = [];
+  const cur = new Date(Date.UTC(opts.from.getUTCFullYear(), opts.from.getUTCMonth(), 1));
+  const end = new Date(Date.UTC(opts.to.getUTCFullYear(), opts.to.getUTCMonth(), 1));
+  while (cur <= end) {
+    const y = cur.getUTCFullYear();
+    const m = cur.getUTCMonth() + 1;
+    const next = new Date(Date.UTC(y, m, 1));
+    const partition = monthlyPartitionName(opts.table, y, m);
+    const lower = `${y}-${pad2(m)}-01`;
+    const upper = `${next.getUTCFullYear()}-${pad2(next.getUTCMonth() + 1)}-01`;
+    await prisma.$executeRawUnsafe(`CREATE TABLE IF NOT EXISTS "${partition}" PARTITION OF "${opts.table}" FOR VALUES FROM ('${lower}') TO ('${upper}');`);
+    created.push(partition);
+    cur.setUTCMonth(cur.getUTCMonth() + 1);
+  }
+  return created;
+}
+__name(ensureMonthlyPartitions, "ensureMonthlyPartitions");
+async function dropOldPartitions(prisma, opts) {
+  const rows = await prisma.$queryRawUnsafe(`SELECT child.relname AS partition_name
+     FROM pg_inherits
+     JOIN pg_class parent  ON pg_inherits.inhparent = parent.oid
+     JOIN pg_class child   ON pg_inherits.inhrelid  = child.oid
+     WHERE parent.relname = $1`, opts.table);
+  const dropped = [];
+  const cutoffYear = opts.beforeDate.getUTCFullYear();
+  const cutoffMonth = opts.beforeDate.getUTCMonth() + 1;
+  for (const row of rows) {
+    const m = row.partition_name.match(/_y(\d{4})m(\d{2})$/);
+    if (!m) continue;
+    const y = Number(m[1]);
+    const mo = Number(m[2]);
+    if (y < cutoffYear || y === cutoffYear && mo < cutoffMonth) {
+      await prisma.$executeRawUnsafe(`DROP TABLE IF EXISTS "${row.partition_name}";`);
+      dropped.push(row.partition_name);
+    }
+  }
+  return dropped;
+}
+__name(dropOldPartitions, "dropOldPartitions");
+
+// src/platform/llmClient.ts
+var DEFAULTS = {
+  timeoutMs: 3e4,
+  maxAttempts: 3,
+  initialDelayMs: 500,
+  maxOutputTokensCap: 4096
+};
+function jitter2(n) {
+  return Math.floor(Math.random() * n);
+}
+__name(jitter2, "jitter");
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+__name(sleep2, "sleep");
+var LLMRouter = class {
+  static {
+    __name(this, "LLMRouter");
+  }
+  adapters = /* @__PURE__ */ new Map();
+  opts;
+  constructor(opts = {}) {
+    this.opts = {
+      ...DEFAULTS,
+      ...opts
+    };
+  }
+  register(adapter) {
+    this.adapters.set(adapter.name, adapter);
+  }
+  resolveChain() {
+    const envChain = process.env["LLM_PROVIDER_CHAIN"]?.trim();
+    if (envChain) {
+      return envChain.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+    return Array.from(this.adapters.keys());
+  }
+  async complete(req) {
+    const cappedReq = {
+      ...req,
+      maxTokens: Math.min(req.maxTokens ?? this.opts.maxOutputTokensCap, this.opts.maxOutputTokensCap)
+    };
+    const chain = this.resolveChain();
+    if (chain.length === 0) {
+      throw new Error("LLMRouter: no providers registered");
+    }
+    let lastErr = null;
+    for (let attempt = 0; attempt < this.opts.maxAttempts; attempt++) {
+      const providerName = chain[attempt % chain.length];
+      const adapter = providerName ? this.adapters.get(providerName) : void 0;
+      if (!adapter) {
+        logger.warn("llmRouter.provider.notRegistered", {
+          providerName
+        });
+        continue;
+      }
+      const timeoutMs = req.timeoutMs ?? this.opts.timeoutMs;
+      const ctrl = new AbortController();
+      const t2 = setTimeout(() => ctrl.abort(), timeoutMs);
+      try {
+        const response = await adapter.complete(cappedReq, ctrl.signal);
+        return response;
+      } catch (err) {
+        lastErr = err;
+        logger.warn("llmRouter.attempt.failed", {
+          provider: adapter.name,
+          attempt,
+          err: String(err)
+        });
+        if (attempt < this.opts.maxAttempts - 1) {
+          const delay = this.opts.initialDelayMs * 2 ** attempt;
+          await sleep2(jitter2(delay));
+        }
+      } finally {
+        clearTimeout(t2);
+      }
+    }
+    throw lastErr instanceof Error ? lastErr : new Error(`LLMRouter exhausted ${this.opts.maxAttempts} attempts`);
+  }
+};
+
 // src/index.ts
 var BurdenoffSDK = class {
   static {
@@ -2623,6 +3092,6 @@ function createSDK(config, context) {
 }
 __name(createSDK, "createSDK");
 
-export { BootstrapModule, BurdenoffGraphQLClient, BurdenoffSDK, ContextManager, PaymentsModule, SearchModule, TenantBackendClient, TranslationModule, createBootstrap, createSDK, createTenantBackendClient, index_default as default };
+export { BootstrapModule, BurdenoffGraphQLClient, BurdenoffSDK, ContextManager, PaymentsModule, platform_exports as Platform, SearchModule, TenantBackendClient, TranslationModule, createBootstrap, createSDK, createTenantBackendClient, index_default as default };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map