@burdenoff/be-sdk 2026.510.79

package/dist/index-RU_M5c74.d.ts

@@ -0,0 +1,163 @@
+import { f as GatewayRequestHeaders, S as ServiceLayer, C as CircuitBreakerConfig, g as GatewayRetryConfig } from './layer-DDip18KY.js';
+import { i as index$1 } from './index-UhkH2eaB.js';
+
+interface GatewayClientConfig {
+    layer: ServiceLayer;
+    serviceName: string;
+    serviceIdentity?: string;
+    internalGatewayUrl?: string;
+    crossLayerGatewayUrl?: string;
+    timeout?: number;
+    circuitBreaker?: Partial<CircuitBreakerConfig>;
+    retry?: Partial<GatewayRetryConfig>;
+    enableLogging?: boolean;
+    defaultHeaders?: GatewayRequestHeaders;
+}
+declare enum CircuitState {
+    CLOSED = "CLOSED",
+    OPEN = "OPEN",
+    HALF_OPEN = "HALF_OPEN"
+}
+interface ICircuitBreaker {
+    getState(): CircuitState;
+    recordSuccess(): void;
+    recordFailure(): void;
+    allowRequest(): boolean;
+    forceOpen(): void;
+    forceClose(): void;
+    getStats(): CircuitBreakerStats;
+}
+interface CircuitBreakerStats {
+    state: CircuitState;
+    failures: number;
+    successes: number;
+    consecutiveFailures: number;
+    lastFailureTime: number | null;
+    lastSuccessTime: number | null;
+    openedAt: number | null;
+}
+interface GraphQLRequestOptions {
+    query: string;
+    variables?: Record<string, unknown>;
+    operationName?: string;
+    headers?: GatewayRequestHeaders;
+    timeout?: number;
+    skipCircuitBreaker?: boolean;
+    skipRetry?: boolean;
+}
+interface GraphQLResponse<T = unknown> {
+    data?: T;
+    errors?: GraphQLError[];
+}
+interface GraphQLError {
+    message: string;
+    locations?: Array<{
+        line: number;
+        column: number;
+    }>;
+    path?: Array<string | number>;
+    extensions?: Record<string, unknown>;
+}
+interface IGatewayClient {
+    internalQuery<T = unknown>(options: GraphQLRequestOptions): Promise<GraphQLResponse<T>>;
+    crossLayerQuery<T = unknown>(options: GraphQLRequestOptions): Promise<GraphQLResponse<T>>;
+    query<T = unknown>(gatewayUrl: string, options: GraphQLRequestOptions): Promise<GraphQLResponse<T>>;
+    getInternalCircuitBreaker(): ICircuitBreaker;
+    getCrossLayerCircuitBreaker(): ICircuitBreaker;
+    getHealthStatus(): GatewayClientHealth;
+    updateDefaultHeaders(headers: Partial<GatewayRequestHeaders>): void;
+}
+interface GatewayClientHealth {
+    internal: {
+        url: string;
+        circuitState: CircuitState;
+        stats: CircuitBreakerStats;
+    };
+    crossLayer: {
+        url: string;
+        circuitState: CircuitState;
+        stats: CircuitBreakerStats;
+    };
+}
+declare enum GatewayErrorType {
+    NETWORK_ERROR = "NETWORK_ERROR",
+    TIMEOUT_ERROR = "TIMEOUT_ERROR",
+    CIRCUIT_OPEN = "CIRCUIT_OPEN",
+    GRAPHQL_ERROR = "GRAPHQL_ERROR",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+}
+declare class GatewayError extends Error {
+    type: GatewayErrorType;
+    gatewayUrl: string;
+    statusCode?: number;
+    graphqlErrors?: GraphQLError[];
+    cause?: Error;
+    constructor(message: string, type: GatewayErrorType, gatewayUrl: string, options?: {
+        statusCode?: number;
+        graphqlErrors?: GraphQLError[];
+        cause?: Error;
+    });
+}
+interface RequestContext {
+    requestId: string;
+    actorId?: string;
+    workspaceId?: string;
+    startTime: number;
+    callType: 'internal' | 'cross-layer' | 'direct';
+}
+
+declare class GatewayClient implements IGatewayClient {
+    private config;
+    private layerManager;
+    private internalCircuitBreaker;
+    private crossLayerCircuitBreaker;
+    private retryConfig;
+    private defaultHeaders;
+    constructor(config: GatewayClientConfig);
+    private getInternalUrl;
+    private getCrossLayerUrl;
+    internalQuery<T = unknown>(options: GraphQLRequestOptions): Promise<GraphQLResponse<T>>;
+    crossLayerQuery<T = unknown>(options: GraphQLRequestOptions): Promise<GraphQLResponse<T>>;
+    query<T = unknown>(gatewayUrl: string, options: GraphQLRequestOptions): Promise<GraphQLResponse<T>>;
+    getInternalCircuitBreaker(): ICircuitBreaker;
+    getCrossLayerCircuitBreaker(): ICircuitBreaker;
+    getHealthStatus(): GatewayClientHealth;
+    updateDefaultHeaders(headers: Partial<GatewayRequestHeaders>): void;
+    private createRequestContext;
+    private shouldRetryError;
+    private calculateRetryDelay;
+    private logRetryAttempt;
+    private executeWithRetry;
+    private buildRequestHeaders;
+    private handleGraphQLErrors;
+    private handleFetchError;
+    private executeRequest;
+    private sleep;
+}
+declare function createGatewayClient(config: GatewayClientConfig): GatewayClient;
+declare function createGatewayClientFromEnv(): GatewayClient;
+
+type index_CircuitBreakerStats = CircuitBreakerStats;
+type index_CircuitState = CircuitState;
+declare const index_CircuitState: typeof CircuitState;
+type index_GatewayClient = GatewayClient;
+declare const index_GatewayClient: typeof GatewayClient;
+type index_GatewayClientConfig = GatewayClientConfig;
+type index_GatewayClientHealth = GatewayClientHealth;
+type index_GatewayError = GatewayError;
+declare const index_GatewayError: typeof GatewayError;
+type index_GatewayErrorType = GatewayErrorType;
+declare const index_GatewayErrorType: typeof GatewayErrorType;
+type index_GraphQLError = GraphQLError;
+type index_GraphQLRequestOptions = GraphQLRequestOptions;
+type index_GraphQLResponse<T = unknown> = GraphQLResponse<T>;
+type index_ICircuitBreaker = ICircuitBreaker;
+type index_IGatewayClient = IGatewayClient;
+type index_RequestContext = RequestContext;
+declare const index_createGatewayClient: typeof createGatewayClient;
+declare const index_createGatewayClientFromEnv: typeof createGatewayClientFromEnv;
+declare namespace index {
+  export { type index_CircuitBreakerStats as CircuitBreakerStats, index_CircuitState as CircuitState, index_GatewayClient as GatewayClient, type index_GatewayClientConfig as GatewayClientConfig, type index_GatewayClientHealth as GatewayClientHealth, index_GatewayError as GatewayError, index_GatewayErrorType as GatewayErrorType, type index_GraphQLError as GraphQLError, type index_GraphQLRequestOptions as GraphQLRequestOptions, type index_GraphQLResponse as GraphQLResponse, type index_ICircuitBreaker as ICircuitBreaker, type index_IGatewayClient as IGatewayClient, type index_RequestContext as RequestContext, index$1 as Security, index_createGatewayClient as createGatewayClient, index_createGatewayClientFromEnv as createGatewayClientFromEnv };
+}
+
+export { type CircuitBreakerStats as C, GatewayClient as G, type ICircuitBreaker as I, type RequestContext as R, CircuitState as a, type GatewayClientConfig as b, type GatewayClientHealth as c, GatewayError as d, GatewayErrorType as e, type GraphQLError as f, type GraphQLRequestOptions as g, type GraphQLResponse as h, index as i, type IGatewayClient as j, createGatewayClient as k, createGatewayClientFromEnv as l };

package/dist/index-UhkH2eaB.d.ts

@@ -0,0 +1,192 @@
+import { Plugin } from 'graphql-yoga';
+
+type Tier = 'public' | 'user' | 'app' | 'service' | 'super_admin';
+interface TierLimits {
+    points: number;
+    duration: number;
+    burst: number;
+}
+interface ActorContext {
+    tier: Tier;
+    identity: string;
+    headers: {
+        actorId?: string;
+        actorType?: string;
+        actorRole?: string;
+        workspaceId?: string;
+        tenantId?: string;
+        orgId?: string;
+        appId?: string;
+        ip?: string;
+    };
+}
+type CostMap = Record<string, number>;
+interface RateLimitResult {
+    allowed: boolean;
+    remaining: number;
+    resetAtMs: number;
+    limit: number;
+}
+interface ArmorConfig {
+    maxAliases: number;
+    maxTokens: number;
+    maxDirectives: number;
+    characterLimit: number;
+    costLimit: number;
+    observe: boolean;
+}
+interface QueryComplexityConfig {
+    enabled: boolean;
+    maxCost: number;
+    costMap: CostMap;
+    observe: boolean;
+}
+interface RateLimitConfig {
+    tiers: Record<Tier, TierLimits>;
+    keyPrefix: string;
+    observeOnly: boolean;
+    failClosed: boolean;
+}
+interface OperationTimeoutConfig {
+    timeoutMs: number;
+}
+interface OtelConfig {
+    enabled: boolean;
+    serviceName: string;
+    endpoint: string;
+    environment: string;
+    version?: string;
+}
+interface GatewaySecurityOptions {
+    gatewayName: string;
+    enabled: boolean;
+    armor: ArmorConfig;
+    queryComplexity: QueryComplexityConfig;
+    rateLimit: RateLimitConfig;
+    operationTimeout: OperationTimeoutConfig;
+    otel: OtelConfig;
+}
+interface SecurityValkeyClient {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options?: {
+        EX?: number;
+    }): Promise<string | null>;
+    incrBy(key: string, amount: number): Promise<number>;
+    expire(key: string, seconds: number): Promise<boolean>;
+    ttl(key: string): Promise<number>;
+    ping(): Promise<string>;
+}
+
+type HeaderGetter = (name: string) => string | null | undefined;
+declare const resolveActor: (getHeader: HeaderGetter) => ActorContext;
+
+declare const DEFAULT_COST_MAP: CostMap;
+declare const mergeCostMap: (base: CostMap, override: CostMap) => CostMap;
+
+declare const DEFAULT_ARMOR_CONFIG: ArmorConfig;
+declare const resolveSecurityOptionsFromEnv: (gatewayName: string, costMapOverride?: CostMap) => GatewaySecurityOptions;
+
+declare const DEFAULT_TIERS: Record<Tier, TierLimits>;
+declare const resolveTiersFromEnv: (base?: Record<Tier, TierLimits>) => Record<Tier, TierLimits>;
+
+declare class MemoryValkey implements SecurityValkeyClient {
+    private store;
+    private prune;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options?: {
+        EX?: number;
+    }): Promise<string | null>;
+    incrBy(key: string, amount: number): Promise<number>;
+    expire(key: string, seconds: number): Promise<boolean>;
+    ttl(key: string): Promise<number>;
+    ping(): Promise<string>;
+}
+declare const initializeSecurityValkey: (gatewayName: string) => Promise<SecurityValkeyClient>;
+declare const getSecurityValkey: () => SecurityValkeyClient;
+declare const __setSecurityValkeyForTest: (client: SecurityValkeyClient | null) => void;
+
+type CounterLike = {
+    inc(labels?: Record<string, string>, value?: number): void;
+};
+interface Metrics {
+    rateLimit: CounterLike;
+    complexityRejected: CounterLike;
+    armorRejected: CounterLike;
+    valkeyFailover: CounterLike;
+    operationTimeout: CounterLike;
+}
+declare const initializeMetrics: () => Promise<Metrics>;
+declare const getMetrics: () => Metrics;
+declare const scrapeMetrics: () => Promise<{
+    body: string;
+    contentType: string;
+} | null>;
+declare const __resetMetricsForTest: () => void;
+
+declare const createArmorPlugins: (cfg: ArmorConfig) => Promise<Plugin[]>;
+
+interface OperationTimeoutPluginDeps {
+    config: OperationTimeoutConfig;
+}
+declare const createOperationTimeoutPlugin: (deps: OperationTimeoutPluginDeps) => Plugin;
+
+declare const initializeOtel: (cfg: OtelConfig) => Promise<void>;
+declare const shutdownOtel: () => Promise<void>;
+declare const createOtelPlugin: (cfg: OtelConfig) => Promise<Plugin>;
+
+interface QueryComplexityPluginDeps {
+    config: QueryComplexityConfig;
+}
+declare const createQueryComplexityPlugin: (deps: QueryComplexityPluginDeps) => Plugin;
+
+interface RateLimitPluginDeps {
+    valkey: SecurityValkeyClient;
+    config: RateLimitConfig;
+}
+declare const checkRateLimit: (deps: RateLimitPluginDeps, actor: ActorContext) => Promise<RateLimitResult>;
+declare const createRateLimitPlugin: (deps: RateLimitPluginDeps) => Plugin;
+
+declare const buildSecurityPlugins: (options: GatewaySecurityOptions) => Promise<Plugin[]>;
+
+type index_ActorContext = ActorContext;
+type index_ArmorConfig = ArmorConfig;
+type index_CostMap = CostMap;
+declare const index_DEFAULT_ARMOR_CONFIG: typeof DEFAULT_ARMOR_CONFIG;
+declare const index_DEFAULT_COST_MAP: typeof DEFAULT_COST_MAP;
+declare const index_DEFAULT_TIERS: typeof DEFAULT_TIERS;
+type index_GatewaySecurityOptions = GatewaySecurityOptions;
+type index_MemoryValkey = MemoryValkey;
+declare const index_MemoryValkey: typeof MemoryValkey;
+type index_OperationTimeoutConfig = OperationTimeoutConfig;
+type index_OtelConfig = OtelConfig;
+type index_QueryComplexityConfig = QueryComplexityConfig;
+type index_RateLimitConfig = RateLimitConfig;
+type index_RateLimitResult = RateLimitResult;
+type index_SecurityValkeyClient = SecurityValkeyClient;
+type index_Tier = Tier;
+type index_TierLimits = TierLimits;
+declare const index___resetMetricsForTest: typeof __resetMetricsForTest;
+declare const index___setSecurityValkeyForTest: typeof __setSecurityValkeyForTest;
+declare const index_buildSecurityPlugins: typeof buildSecurityPlugins;
+declare const index_checkRateLimit: typeof checkRateLimit;
+declare const index_createArmorPlugins: typeof createArmorPlugins;
+declare const index_createOperationTimeoutPlugin: typeof createOperationTimeoutPlugin;
+declare const index_createOtelPlugin: typeof createOtelPlugin;
+declare const index_createQueryComplexityPlugin: typeof createQueryComplexityPlugin;
+declare const index_createRateLimitPlugin: typeof createRateLimitPlugin;
+declare const index_getMetrics: typeof getMetrics;
+declare const index_getSecurityValkey: typeof getSecurityValkey;
+declare const index_initializeMetrics: typeof initializeMetrics;
+declare const index_initializeOtel: typeof initializeOtel;
+declare const index_initializeSecurityValkey: typeof initializeSecurityValkey;
+declare const index_mergeCostMap: typeof mergeCostMap;
+declare const index_resolveActor: typeof resolveActor;
+declare const index_resolveSecurityOptionsFromEnv: typeof resolveSecurityOptionsFromEnv;
+declare const index_resolveTiersFromEnv: typeof resolveTiersFromEnv;
+declare const index_scrapeMetrics: typeof scrapeMetrics;
+declare const index_shutdownOtel: typeof shutdownOtel;
+declare namespace index {
+  export { type index_ActorContext as ActorContext, type index_ArmorConfig as ArmorConfig, type index_CostMap as CostMap, index_DEFAULT_ARMOR_CONFIG as DEFAULT_ARMOR_CONFIG, index_DEFAULT_COST_MAP as DEFAULT_COST_MAP, index_DEFAULT_TIERS as DEFAULT_TIERS, type index_GatewaySecurityOptions as GatewaySecurityOptions, index_MemoryValkey as MemoryValkey, type index_OperationTimeoutConfig as OperationTimeoutConfig, type index_OtelConfig as OtelConfig, type index_QueryComplexityConfig as QueryComplexityConfig, type index_RateLimitConfig as RateLimitConfig, type index_RateLimitResult as RateLimitResult, type index_SecurityValkeyClient as SecurityValkeyClient, type index_Tier as Tier, type index_TierLimits as TierLimits, index___resetMetricsForTest as __resetMetricsForTest, index___setSecurityValkeyForTest as __setSecurityValkeyForTest, index_buildSecurityPlugins as buildSecurityPlugins, index_checkRateLimit as checkRateLimit, index_createArmorPlugins as createArmorPlugins, index_createOperationTimeoutPlugin as createOperationTimeoutPlugin, index_createOtelPlugin as createOtelPlugin, index_createQueryComplexityPlugin as createQueryComplexityPlugin, index_createRateLimitPlugin as createRateLimitPlugin, index_getMetrics as getMetrics, index_getSecurityValkey as getSecurityValkey, index_initializeMetrics as initializeMetrics, index_initializeOtel as initializeOtel, index_initializeSecurityValkey as initializeSecurityValkey, index_mergeCostMap as mergeCostMap, index_resolveActor as resolveActor, index_resolveSecurityOptionsFromEnv as resolveSecurityOptionsFromEnv, index_resolveTiersFromEnv as resolveTiersFromEnv, index_scrapeMetrics as scrapeMetrics, index_shutdownOtel as shutdownOtel };
+}
+
+export { type ActorContext as A, type CostMap as C, DEFAULT_ARMOR_CONFIG as D, type GatewaySecurityOptions as G, MemoryValkey as M, type OperationTimeoutConfig as O, type QueryComplexityConfig as Q, type RateLimitConfig as R, type SecurityValkeyClient as S, type Tier as T, __resetMetricsForTest as _, type ArmorConfig as a, DEFAULT_COST_MAP as b, DEFAULT_TIERS as c, type OtelConfig as d, type RateLimitResult as e, type TierLimits as f, __setSecurityValkeyForTest as g, buildSecurityPlugins as h, index as i, checkRateLimit as j, createArmorPlugins as k, createOperationTimeoutPlugin as l, createOtelPlugin as m, createQueryComplexityPlugin as n, createRateLimitPlugin as o, getMetrics as p, getSecurityValkey as q, initializeMetrics as r, initializeOtel as s, initializeSecurityValkey as t, mergeCostMap as u, resolveActor as v, resolveSecurityOptionsFromEnv as w, resolveTiersFromEnv as x, scrapeMetrics as y, shutdownOtel as z };

package/dist/index-e_18DzAg.d.ts

@@ -0,0 +1,18 @@
+declare function encrypt(text: string, key: string): string;
+declare function decrypt(encryptedText: string, key: string): string;
+declare function generateEncryptionKey(): string;
+declare function isEncrypted(text: string): boolean;
+declare function encryptIfNeeded(text: string, key: string): string;
+declare function decryptIfNeeded(text: string, key: string): string;
+
+declare const index_decrypt: typeof decrypt;
+declare const index_decryptIfNeeded: typeof decryptIfNeeded;
+declare const index_encrypt: typeof encrypt;
+declare const index_encryptIfNeeded: typeof encryptIfNeeded;
+declare const index_generateEncryptionKey: typeof generateEncryptionKey;
+declare const index_isEncrypted: typeof isEncrypted;
+declare namespace index {
+  export { index_decrypt as decrypt, index_decryptIfNeeded as decryptIfNeeded, index_encrypt as encrypt, index_encryptIfNeeded as encryptIfNeeded, index_generateEncryptionKey as generateEncryptionKey, index_isEncrypted as isEncrypted };
+}
+
+export { decryptIfNeeded as a, encryptIfNeeded as b, isEncrypted as c, decrypt as d, encrypt as e, generateEncryptionKey as g, index as i };

package/dist/index-jOuh_TKn.d.ts

@@ -0,0 +1,59 @@
+type FlagType = 'BOOLEAN' | 'STRING' | 'NUMBER' | 'JSON';
+interface EvaluationContext {
+    actorId?: string;
+    actorType?: 'user' | 'app' | 'service' | 'super_admin';
+    workspaceId: string;
+}
+interface ResolutionDetails<T> {
+    value: T;
+    variant?: string;
+    reason: string;
+    flagType: FlagType;
+    errorCode?: string;
+}
+interface FlagEvaluation {
+    key: string;
+    value: unknown;
+    variant: string | null;
+    reason: string;
+    flagType: FlagType;
+    errorCode: string | null;
+}
+interface FeatureFlagProviderConfig {
+    gatewayUrl: string;
+    cacheTtlSeconds?: number;
+    serviceToken?: string;
+    defaultActorType?: 'user' | 'app' | 'service' | 'super_admin';
+}
+
+declare class FeatureFlagProvider {
+    private readonly gatewayUrl;
+    private readonly cacheTtlMs;
+    private readonly serviceToken?;
+    private readonly defaultActorType;
+    private readonly cache;
+    constructor(config: FeatureFlagProviderConfig);
+    resolveBoolean(flagKey: string, defaultValue: boolean, context: EvaluationContext): Promise<ResolutionDetails<boolean>>;
+    resolveString(flagKey: string, defaultValue: string, context: EvaluationContext): Promise<ResolutionDetails<string>>;
+    resolveNumber(flagKey: string, defaultValue: number, context: EvaluationContext): Promise<ResolutionDetails<number>>;
+    resolveObject<T extends Record<string, unknown>>(flagKey: string, defaultValue: T, context: EvaluationContext): Promise<ResolutionDetails<T>>;
+    isEnabled(flagKey: string, context?: EvaluationContext): Promise<boolean>;
+    evaluateAll(context: EvaluationContext, keys?: string[]): Promise<Map<string, ResolutionDetails<unknown>>>;
+    invalidateCache(context?: EvaluationContext): void;
+    private getEvaluation;
+    private fetchEvaluations;
+    private buildCacheKey;
+}
+
+type index_EvaluationContext = EvaluationContext;
+type index_FeatureFlagProvider = FeatureFlagProvider;
+declare const index_FeatureFlagProvider: typeof FeatureFlagProvider;
+type index_FeatureFlagProviderConfig = FeatureFlagProviderConfig;
+type index_FlagEvaluation = FlagEvaluation;
+type index_FlagType = FlagType;
+type index_ResolutionDetails<T> = ResolutionDetails<T>;
+declare namespace index {
+  export { type index_EvaluationContext as EvaluationContext, index_FeatureFlagProvider as FeatureFlagProvider, type index_FeatureFlagProviderConfig as FeatureFlagProviderConfig, type index_FlagEvaluation as FlagEvaluation, type index_FlagType as FlagType, type index_ResolutionDetails as ResolutionDetails };
+}
+
+export { type EvaluationContext as E, FeatureFlagProvider as F, type ResolutionDetails as R, type FeatureFlagProviderConfig as a, type FlagEvaluation as b, type FlagType as c, index as i };