@stackone/transport 1.8.1 → 1.8.3

package/dist/index.d.mts

@@ -1,7 +1,9 @@
-import { z } from "zod";
-import { AxiosInstance } from "axios";
-import https from "https";
+import * as redis from "redis";
+import { AxiosInstance, AxiosInterceptorOptions, AxiosResponse, CreateAxiosDefaults, InternalAxiosRequestConfig } from "axios";
+import { AgentOptions } from "node:http";
 import { ILogger } from "@stackone/logger";
+import { z } from "zod/v4";
+import https from "https";
 
 //#region src/authorization/types.d.ts
 type BasicAuthorizationParams = {
@@ -21,23 +23,203 @@ declare const createAuthorizationHeaders: (authenticationParams: BasicAuthorizat
   authorization: string;
 };
 //#endregion
+//#region src/cacheClient/types.d.ts
+interface ICacheClient<ClientType = unknown> {
+  getData<T>(key: string): Promise<T | null>;
+  listData<T>({
+    partialKey,
+    limit,
+    cursor
+  }: {
+    partialKey: string;
+    limit?: number;
+    cursor?: string;
+  }): Promise<{
+    items: T[] | null;
+    cursor?: string;
+  }>;
+  setData<T>({
+    key,
+    value,
+    cacheTTL,
+    groupKey
+  }: {
+    key: string;
+    value: T;
+    cacheTTL: number;
+    groupKey?: string;
+  }): Promise<boolean>;
+  executeScript?<T>({
+    sha1,
+    keys,
+    args
+  }: {
+    sha1: string;
+    keys: string[];
+    args: string[];
+  }): Promise<T | null>;
+  loadScript?(script: string): Promise<string | null>;
+  increment?(key: string, cacheTTL: number): Promise<number | null>;
+  decrement?(key: string, cacheTTL: number): Promise<number | null>;
+  subscribe?<T extends boolean = false>(pattern: string, listener: PubSubListener<T>): Promise<boolean>;
+  unsubscribe?(pattern: string): Promise<boolean>;
+  publish?(channel: string, message: string): Promise<number | null>;
+  getClient?(): ClientType | null;
+  deleteData?(key: string): Promise<boolean>;
+}
+type PubSubListener<ReturnsBuffer extends boolean = false> = <T extends (ReturnsBuffer extends true ? Buffer : string)>(message: T, channel: T) => unknown;
+//#endregion
+//#region src/redisClient/index.d.ts
+type RedisClientType = redis.RedisClientType;
+interface RedisClientConfig {
+  getRedisClient?: typeof redis.createClient;
+  host?: string;
+  port?: number;
+  tls?: boolean;
+  reconnect?: boolean;
+  database?: number;
+}
+declare const buildRedisClientInstance: (config: RedisClientConfig, logger?: ILogger) => Promise<ICacheClient<RedisClientType> | undefined>;
+declare class RedisClient implements ICacheClient<RedisClientType> {
+  #private;
+  static build({
+    getRedisClient,
+    host,
+    port,
+    tls,
+    reconnect,
+    database
+  }: RedisClientConfig, logger?: ILogger): Promise<ICacheClient<RedisClientType> | null>;
+  getData<T>(key: string): Promise<T | null>;
+  setData<T>({
+    key,
+    value,
+    cacheTTL,
+    groupKey
+  }: {
+    key: string;
+    value: T;
+    cacheTTL: number;
+    groupKey?: string;
+  }): Promise<boolean>;
+  executeScript<T>({
+    sha1,
+    keys,
+    args
+  }: {
+    sha1: string;
+    keys: string[];
+    args: string[];
+  }): Promise<T | null>;
+  loadScript(script: string): Promise<string | null>;
+  increment(key: string, cacheTTL: number): Promise<number | null>;
+  decrement(key: string, cacheTTL: number): Promise<number | null>;
+  subscribe<T extends boolean>(pattern: string, listener: PubSubListener<T>): Promise<boolean>;
+  unsubscribe(pattern: string): Promise<boolean>;
+  publish(channel: string, message: string): Promise<number | null>;
+  getClient(): RedisClientType | null;
+  listData<T>({
+    partialKey,
+    limit,
+    cursor
+  }: {
+    partialKey: string;
+    limit: number;
+    cursor?: string;
+  }): Promise<{
+    items: T[] | null;
+    cursor?: string;
+  }>;
+  deleteData(key: string): Promise<boolean>;
+}
+//#endregion
+//#region src/scriptManager/types.d.ts
+type Scripts<T extends string> = Record<T, string>;
+type ScriptManagerOptions<T extends string> = {
+  redisClientConfig: RedisClientConfig;
+  logger?: ILogger;
+  scriptMap?: Map<T, string>;
+};
+//#endregion
+//#region src/scriptManager/index.d.ts
+declare class ScriptManager<T extends string> {
+  protected cacheClient: ICacheClient<RedisClientType> | null;
+  protected scriptMap: Map<string, string>;
+  protected logger?: ILogger;
+  protected scripts: Scripts<T>;
+  protected redisClientConfig: RedisClientConfig;
+  constructor(preLoadScripts: Scripts<T>);
+  protected initialize({
+    redisClientConfig,
+    logger,
+    scriptMap
+  }: ScriptManagerOptions<T>, ...args: unknown[]): Promise<void>;
+  protected additionalInitialization(..._args: unknown[]): Promise<void>;
+  protected loadScripts<U extends string>(scripts: Scripts<U>, scriptMap?: Map<U, string>): Promise<void>;
+  protected executeScript<X extends string, U>(method: X, keys: string[], args: string[]): Promise<U | null>;
+  protected isReady(): Promise<boolean>;
+}
+//#endregion
+//#region src/concurrencyManager/types.d.ts
+type ConcurrencySubPoolConfig = {
+  subPoolKey: string;
+  urlPattern: RegExp | string;
+  maxConcurrency: number;
+};
+type ConcurrencyConfig = {
+  mainMaxConcurrency: number;
+  subPools?: ConcurrencySubPoolConfig[];
+};
+type RequestMetadata = {
+  requestId: string;
+  targetConcurrencyKey: string;
+  leaseSubscription: boolean;
+  setRemovalSubscription: boolean;
+  queueKey: string;
+  joinCondition?: 'optimistic' | 'attempts' | 'failed';
+  failureReason?: string;
+};
+//#endregion
+//#region src/concurrencyManager/utils/index.d.ts
+declare enum ConcurrencyMethods {
+  tryConcurrency = "tryConcurrency",
+  removeFromSet = "removeFromSet",
+  publishNextItem = "publishNextItem",
+}
+//#endregion
+//#region src/concurrencyManager/index.d.ts
+declare class ConcurrencyManager extends ScriptManager<ConcurrencyMethods> {
+  private static instance;
+  private static asyncInstanceInit;
+  private static hasValidRedisConfig;
+  private static lastInitFailure;
+  private static RETRY_WINDOW_MS;
+  private static logger?;
+  private static initConfig;
+  private subscriptionManager;
+  private queueManager;
+  private generateUUID;
+  static getInstance(config?: RedisClientConfig, logger?: ILogger, scriptMap?: Map<ConcurrencyMethods, string>, generateUUID?: () => string): Promise<ConcurrencyManager>;
+  protected additionalInitialization(generateUUID?: () => string): Promise<void>;
+  private addTestSubscription;
+  private checkRedisEventsEmit;
+  isRedisConfigured(): Promise<boolean>;
+  private subscribeToLeaseExpiry;
+  private subscribeToSetRemoval;
+  registerRequest(requestKey: string, config: ConcurrencyConfig, requestId: string, requestUrl: string | undefined): Promise<RequestMetadata>;
+  releaseRequest(requestId: string, targetConcurrencyKey: string): Promise<boolean>;
+  private readyCheck;
+  static isReady(): Promise<boolean>;
+  static close(): void;
+}
+//#endregion
 //#region src/customErrors/schemas.d.ts
 declare const CUSTOM_ERROR_CONFIG_SCHEMA: z.ZodObject<{
   receivedStatus: z.ZodNumber;
   targetStatus: z.ZodNumber;
   message: z.ZodOptional<z.ZodString>;
   condition: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-  receivedStatus: number;
-  targetStatus: number;
-  message?: string | undefined;
-  condition?: string | undefined;
-}, {
-  receivedStatus: number;
-  targetStatus: number;
-  message?: string | undefined;
-  condition?: string | undefined;
-}>;
+}, z.core.$strip>;
 //#endregion
 //#region src/customErrors/types.d.ts
 type CustomErrorConfig = z.infer<typeof CUSTOM_ERROR_CONFIG_SCHEMA>;
@@ -121,6 +303,38 @@ interface IHttpClient {
     payload?: P;
   }): Promise<HttpResponse<T>>;
 }
+interface OperationSetting {
+  url?: string;
+  query?: Record<string, string>;
+  config?: Partial<APIConfig>;
+  custom_settings?: Record<string, unknown>;
+}
+type OperationSettings = Record<string, OperationSetting>;
+type AccountSettings = Record<string, string | number | boolean | object>;
+type HttpClientBehaviour = 'CONCURRENCY' | 'RETRY';
+type APIConfig = Record<string, unknown>;
+type RequestContext = {
+  accountSecureId?: string;
+  projectSecureId?: string;
+  organizationId?: number;
+  environment?: string;
+  authConfigKey?: string;
+  provider?: string;
+  service?: string;
+  resource?: string;
+  subResource?: string;
+  childResource?: string;
+  operation?: string;
+  action?: string;
+  mode?: string;
+  testerUniqueToken?: string;
+  externalKey?: string;
+  dataKey?: string;
+  isDataSync?: boolean;
+  operationSettings?: OperationSettings;
+  accountSettings?: AccountSettings;
+  behaviours?: HttpClientBehaviour[];
+};
 //#endregion
 //#region src/errors/httpResponseError.d.ts
 declare class HttpResponseError extends Error {
@@ -129,6 +343,70 @@ declare class HttpResponseError extends Error {
   toString(): string;
 }
 //#endregion
+//#region src/lockManager/index.d.ts
+declare class LockManager {
+  private locks;
+  constructor();
+  withLock<T>(key: string, operation: () => Promise<T>): Promise<T>;
+  lock(key: string): Promise<void>;
+  unlock(key: string): void;
+  queueLength(key: string): number | undefined;
+  close(): void;
+}
+//#endregion
+//#region src/memoryStore/types.d.ts
+interface MemoryStoreConfig<T> {
+  instantiator?: string;
+  logger?: ILogger;
+  dataStore?: Map<string, T>;
+  lockManager?: LockManager;
+  expiryMap?: Map<string, number>;
+  evictionFrequency?: number;
+  staleDataThreshold?: number;
+  truncateThreshold?: number;
+  truncationPercentage?: number;
+  typeGuard?: (data: unknown) => data is T;
+  dispose?: (key: string, value: T) => Promise<void> | void;
+}
+type PruneCount = {
+  dataStoreSize: number;
+  prunedDataStoreSize: number;
+};
+//#endregion
+//#region src/eventClient/types.d.ts
+type PromiseExecutorMethods<T> = {
+  resolve?: (value: T) => void;
+  reject?: (reason: unknown) => void;
+};
+type EventClientConfig<T> = {
+  instantiator?: string;
+  defaultTimeoutMS?: number;
+  timeoutResolveValue?: T;
+};
+//#endregion
+//#region src/eventClient/index.d.ts
+declare class EventClient<T> {
+  private executorMethodStore;
+  private promiseStore;
+  private logger;
+  private eventClientConfig?;
+  private executorMethodStoreConfig?;
+  private pendingPromiseStoreConfig?;
+  constructor(eventClientConfig?: EventClientConfig<T>, executorMethodStoreConfig?: MemoryStoreConfig<PromiseExecutorMethods<T> | undefined>, pendingPromiseStoreConfig?: MemoryStoreConfig<Promise<T> | undefined>);
+  setPendingEvent(eventKey: string, timeoutInMS: number): Promise<void>;
+  waitForEvent(eventKey: string, timeoutInMS: number): Promise<T | null>;
+  getPendingEvent(eventKey: string): Promise<T | null>;
+  deleteEvent(eventKey: string): Promise<boolean>;
+  resolveEvent(eventKey: string, value: T): Promise<void>;
+  private defaultExecutorMethodDispose;
+  private defaultExecutorMethodTypeGuard;
+  private defaultPendingPromiseDispose;
+  private defaultPendingPromiseTypeGuard;
+}
+//#endregion
+//#region src/getTransportInstance/index.d.ts
+declare const getTransportInstance: (logger: ILogger, context?: RequestContext) => Promise<AxiosInstance>;
+//#endregion
 //#region src/httpClient/httpClient.d.ts
 declare class HttpClient implements IHttpClient {
   #private;
@@ -204,6 +482,80 @@ declare class HttpClientManager {
   static resetInstance(): void;
 }
 //#endregion
+//#region src/rateLimitManager/types.d.ts
+type RateLimitSubPoolConfig = {
+  subPoolKey: string;
+  urlPattern: RegExp | string;
+  rateLimit: number;
+};
+type RetryUnit = 'seconds' | 'milliseconds' | 'date';
+type MappedRateLimitErrorConfig = {
+  errorStatus: number;
+  errorMessage: string | RegExp;
+  errorMessagePath?: string;
+  retryAfterPath?: string;
+  retryAfterUnit?: RetryUnit;
+  retryAfterValue?: number;
+};
+type RateLimitConfig = {
+  mainRatelimit: number;
+  subPools?: RateLimitSubPoolConfig[];
+  mappedRateLimitErrors?: MappedRateLimitErrorConfig[];
+};
+//#endregion
+//#region src/interceptors/types.d.ts
+type RequestInterceptor = (value: InternalAxiosRequestConfig<unknown>) => InternalAxiosRequestConfig<unknown> | Promise<InternalAxiosRequestConfig<unknown>>;
+type ResponseInterceptor = (value: AxiosResponse<unknown, unknown>) => AxiosResponse<unknown, unknown> | Promise<AxiosResponse<unknown, unknown>>;
+type ErrorInterceptor = (error: unknown) => unknown;
+type Interceptor = RequestInterceptor | ResponseInterceptor | ErrorInterceptor | null;
+interface InterceptorDependencies {
+  axiosInstance?: AxiosInstance;
+  logger?: ILogger;
+  context?: RequestContext;
+  requestConfig?: RequestConfig;
+  [key: string]: unknown;
+}
+type RequestConfig = {
+  rateLimits?: RateLimitConfig;
+  concurrency?: ConcurrencyConfig;
+};
+//#endregion
+//#region src/httpTransportFactory/types.d.ts
+type InterceptorDependencyInjector<T extends Interceptor> = (dependencies: InterceptorDependencies) => T;
+type RequestInterceptorConfig = {
+  onFulfilled: InterceptorDependencyInjector<RequestInterceptor> | RequestInterceptor | null;
+  onRejected: InterceptorDependencyInjector<ErrorInterceptor> | ErrorInterceptor | null;
+  options: AxiosInterceptorOptions | undefined;
+};
+type ResponseInterceptorConfig = {
+  onFulfilled: InterceptorDependencyInjector<ResponseInterceptor> | ResponseInterceptor | null;
+  onRejected: InterceptorDependencyInjector<ErrorInterceptor> | ErrorInterceptor | null;
+};
+type InterceptorConfigs = {
+  requestConfigs?: RequestInterceptorConfig[];
+  responseConfigs?: ResponseInterceptorConfig[];
+};
+type HttpTransportInstanceConfig = {
+  interceptors?: InterceptorConfigs;
+  instanceConfig?: CreateAxiosDefaults;
+  httpAgentConfig?: AgentOptions;
+  logger: ILogger;
+  context?: RequestContext;
+};
+//#endregion
+//#region src/httpTransportFactory/index.d.ts
+declare class HttpTransportFactory {
+  static createInstance({
+    interceptors,
+    instanceConfig,
+    httpAgentConfig,
+    logger,
+    context
+  }: HttpTransportInstanceConfig): AxiosInstance;
+  private static applyInterceptors;
+  private static resolveInterceptorInstance;
+}
+//#endregion
 //#region src/instanceManager/index.d.ts
 declare class InstanceManager {
   private static instance;
@@ -219,82 +571,6 @@ declare class InstanceManager {
   close(): void;
 }
 //#endregion
-//#region src/lockManager/index.d.ts
-declare class LockManager {
-  private locks;
-  constructor();
-  withLock<T>(key: string, operation: () => Promise<T>): Promise<T>;
-  lock(key: string): Promise<void>;
-  unlock(key: string): void;
-  queueLength(key: string): number | undefined;
-  close(): void;
-}
-//#endregion
-//#region src/cacheClient/types.d.ts
-interface ICacheClient<ClientType = unknown> {
-  getData<T>(key: string): Promise<T | null>;
-  listData<T>({
-    partialKey,
-    limit,
-    cursor
-  }: {
-    partialKey: string;
-    limit?: number;
-    cursor?: string;
-  }): Promise<{
-    items: T[] | null;
-    cursor?: string;
-  }>;
-  setData<T>({
-    key,
-    value,
-    cacheTTL,
-    groupKey
-  }: {
-    key: string;
-    value: T;
-    cacheTTL: number;
-    groupKey?: string;
-  }): Promise<boolean>;
-  executeScript?<T>({
-    sha1,
-    keys,
-    args
-  }: {
-    sha1: string;
-    keys: string[];
-    args: string[];
-  }): Promise<T | null>;
-  loadScript?(script: string): Promise<string | null>;
-  increment?(key: string, cacheTTL: number): Promise<number | null>;
-  decrement?(key: string, cacheTTL: number): Promise<number | null>;
-  subscribe?<T extends boolean = false>(pattern: string, listener: PubSubListener<T>): Promise<boolean>;
-  unsubscribe?(pattern: string): Promise<boolean>;
-  publish?(channel: string, message: string): Promise<number | null>;
-  getClient?(): ClientType | null;
-  deleteData?(key: string): Promise<boolean>;
-}
-type PubSubListener<ReturnsBuffer extends boolean = false> = <T extends (ReturnsBuffer extends true ? Buffer : string)>(message: T, channel: T) => unknown;
-//#endregion
-//#region src/memoryStore/types.d.ts
-interface MemoryStoreConfig<T> {
-  instantiator?: string;
-  logger?: ILogger;
-  dataStore?: Map<string, T>;
-  lockManager?: LockManager;
-  expiryMap?: Map<string, number>;
-  evictionFrequency?: number;
-  staleDataThreshold?: number;
-  truncateThreshold?: number;
-  truncationPercentage?: number;
-  typeGuard?: (data: unknown) => data is T;
-  dispose?: (key: string, value: T) => Promise<void> | void;
-}
-type PruneCount = {
-  dataStoreSize: number;
-  prunedDataStoreSize: number;
-};
-//#endregion
 //#region src/memoryStore/index.d.ts
 declare class MemoryStore<T> implements ICacheClient {
   private config;
@@ -357,6 +633,55 @@ type RequestParameter = {
 //#region src/parsers/requestParameters.d.ts
 declare const parseRequestParameters: (parameters: RequestParameter[]) => HttpParameters;
 //#endregion
+//#region src/queueManager/utils/enums.d.ts
+declare enum QueueMethods {
+  rPush = "rPush",
+  lPush = "lPush",
+  lPop = "lPop",
+  llen = "llen",
+}
+//#endregion
+//#region src/queueManager/types.d.ts
+type OnTurnFunction<T> = (queueName: string, value: string) => T | Promise<T>;
+//#endregion
+//#region src/queueManager/index.d.ts
+declare class QueueManager extends ScriptManager<QueueMethods> {
+  private static instance;
+  private static asyncInstanceInit;
+  private static logger?;
+  private static config?;
+  protected logger?: ILogger;
+  private subscriptionManager;
+  private eventClient;
+  static getInstance(config?: RedisClientConfig, logger?: ILogger, scriptMap?: Map<QueueMethods, string>): Promise<QueueManager>;
+  protected additionalInitialization(): Promise<void>;
+  joinAndWaitTurn<T>(queueName: string, value: string, hasPriority: boolean, onTurn: OnTurnFunction<T>, coldStartEnabled?: boolean): Promise<T | null>;
+  pop<T>(queueName: string): Promise<T | null>;
+  length(queueName: string): Promise<number | null>;
+  private readyCheck;
+  isReady(): Promise<boolean>;
+  close(): void;
+}
+//#endregion
+//#region src/rateLimitManager/constants.d.ts
+declare enum RateLimitMethods {
+  incr = "incr",
+}
+//#endregion
+//#region src/rateLimitManager/index.d.ts
+declare class RateLimitManager extends ScriptManager<RateLimitMethods> {
+  private static instance;
+  private static asyncInstanceInit;
+  private static logger?;
+  private static initConfig;
+  static getInstance(config?: RedisClientConfig, logger?: ILogger, scriptMap?: Map<RateLimitMethods, string>): Promise<RateLimitManager>;
+  getDynamicMaxWaitTime(ratelimitConfig: RateLimitConfig, concurrencyConfig: ConcurrencyConfig, requestUrl?: string, cutoffTime?: number, fudgeFactor?: number, ballparkResponseTime?: number): Promise<number>;
+  getWaitTime(requestKey: any, config: RateLimitConfig, requestUrl?: string): Promise<number | null>;
+  private readyCheck;
+  static isReady(): Promise<boolean>;
+  static close(): void;
+}
+//#endregion
 //#region src/requestClient/types.d.ts
 interface IRequestClient {
   performRequest: ({
@@ -383,6 +708,35 @@ declare class RequestClientFactory {
   static build(type?: RequestClientType): IRequestClient;
 }
 //#endregion
+//#region src/redisClient/types.d.ts
+type GetRedisClient = typeof buildRedisClientInstance;
+//#endregion
+//#region src/subscriptionManager/types.d.ts
+type SubscriptionManagerOptions = {
+  config?: RedisClientConfig;
+  getCacheClient?: GetRedisClient;
+  logger?: ILogger;
+  instantiator?: string;
+  subscriptionTTL?: number;
+  staleSubscriptionsThreshold?: number;
+  truncateThreshold?: number;
+  truncationPercentage?: number;
+};
+//#endregion
+//#region src/subscriptionManager/index.d.ts
+declare class SubscriptionManager {
+  private options;
+  private subscriptionMap;
+  private subscriptionClient;
+  private logger?;
+  constructor(options: SubscriptionManagerOptions);
+  initialize(options?: SubscriptionManagerOptions): Promise<void>;
+  subscribe<T extends boolean = false>(key: string, listener: PubSubListener<T>): Promise<boolean>;
+  unsubscribe(key: string): Promise<boolean>;
+  isReady(): boolean;
+  close(): void;
+}
+//#endregion
 //#region src/validators/statusCodes.d.ts
 declare const isSuccessStatusCode: (status: number | undefined) => boolean;
 declare const isFailedStatusCode: (status: number | undefined) => boolean;
@@ -396,4 +750,4 @@ type LockEntry = {
   unlock: Unlock;
 };
 //#endregion
-export { CUSTOM_ERROR_CONFIG_SCHEMA, CustomErrorConfig, HttpClient, HttpClientManager, HttpErrorMessages, HttpHeaders, HttpMethod, HttpMethods, HttpParameters, HttpQueryParams, HttpResponse, HttpResponseError, ICacheClient, IHttpClient, InstanceManager, Lock, LockEntry, LockManager, MemoryStore, MemoryStoreConfig, PruneCount, PubSubListener, RequestClientFactory, RequestParameter, RequestParameterLocations, Unlock, createAuthorizationHeaders, isFailedStatusCode, isInfoStatusCode, isSuccessStatusCode, parseRequestParameters };
+export { CUSTOM_ERROR_CONFIG_SCHEMA, ConcurrencyManager, CustomErrorConfig, EventClient, HttpClient, HttpClientManager, HttpErrorMessages, HttpHeaders, HttpMethod, HttpMethods, HttpParameters, HttpQueryParams, HttpResponse, HttpResponseError, HttpTransportFactory, ICacheClient, IHttpClient, InstanceManager, Lock, LockEntry, LockManager, MemoryStore, MemoryStoreConfig, PruneCount, PubSubListener, QueueManager, RateLimitManager, RedisClient, RequestClientFactory, RequestParameter, RequestParameterLocations, ScriptManager, SubscriptionManager, Unlock, createAuthorizationHeaders, getTransportInstance, isFailedStatusCode, isInfoStatusCode, isSuccessStatusCode, parseRequestParameters };