@stackone/transport 1.7.0 → 1.8.1

package/dist/index.d.mts

@@ -0,0 +1,399 @@
+import { z } from "zod";
+import { AxiosInstance } from "axios";
+import https from "https";
+import { ILogger } from "@stackone/logger";
+
+//#region src/authorization/types.d.ts
+type BasicAuthorizationParams = {
+  type: 'basic';
+  username?: string;
+  password?: string;
+  encoding?: string;
+};
+type BearerAuthorizationParams = {
+  type: 'bearer';
+  token: string;
+  includeBearer?: boolean;
+};
+//#endregion
+//#region src/authorization/authorizationHeaders.d.ts
+declare const createAuthorizationHeaders: (authenticationParams: BasicAuthorizationParams | BearerAuthorizationParams) => {
+  authorization: string;
+};
+//#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;
+}>;
+//#endregion
+//#region src/customErrors/types.d.ts
+type CustomErrorConfig = z.infer<typeof CUSTOM_ERROR_CONFIG_SCHEMA>;
+declare const HttpErrorMessages: Record<number, string>;
+//#endregion
+//#region src/httpClient/types.d.ts
+type HttpHeaders = {
+  [key: string]: string;
+};
+type HttpQueryParams = {
+  [key: string]: string;
+};
+declare const HttpMethods: readonly ["get", "post", "put", "delete", "patch"];
+type HttpMethod = (typeof HttpMethods)[number];
+type HttpResponse<T = any> = {
+  data: T;
+  status: number;
+  headers: HttpHeaders;
+  requestUrl: string;
+  responseType?: string;
+  responseTime?: Date;
+  message?: string;
+};
+type HttpParameters = {
+  query: HttpQueryParams;
+  body: Record<string, unknown>;
+  headers: HttpHeaders;
+};
+interface IHttpClient {
+  request<P, T>({
+    headers,
+    url,
+    method,
+    queryParams,
+    maxRedirects,
+    responseType,
+    cacheTTL,
+    context,
+    payload,
+    httpsAgent
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    method?: HttpMethod;
+    queryParams?: HttpQueryParams;
+    maxRedirects?: number;
+    responseType?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text';
+    cacheTTL?: number;
+    context?: unknown;
+    payload?: P;
+    httpsAgent?: https.Agent;
+  }): Promise<HttpResponse<T>>;
+  get<T>({
+    headers,
+    url,
+    queryParams,
+    maxRedirects,
+    cacheTTL,
+    context
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    queryParams?: HttpQueryParams;
+    maxRedirects?: number;
+    cacheTTL?: number;
+    context?: unknown;
+  }): Promise<HttpResponse<T>>;
+  post<P, T>({
+    headers,
+    url,
+    maxRedirects,
+    cacheTTL,
+    context,
+    payload
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    maxRedirects?: number;
+    cacheTTL?: number;
+    context?: unknown;
+    payload?: P;
+  }): Promise<HttpResponse<T>>;
+}
+//#endregion
+//#region src/errors/httpResponseError.d.ts
+declare class HttpResponseError extends Error {
+  readonly response: HttpResponse;
+  constructor(response: HttpResponse, message?: string);
+  toString(): string;
+}
+//#endregion
+//#region src/httpClient/httpClient.d.ts
+declare class HttpClient implements IHttpClient {
+  #private;
+  constructor({
+    transportInstance
+  }?: {
+    transportInstance?: AxiosInstance;
+  });
+  request<P, T>({
+    headers,
+    url,
+    method,
+    queryParams,
+    maxRedirects,
+    responseType,
+    cacheTTL,
+    context,
+    payload,
+    httpsAgent
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    method?: HttpMethod;
+    queryParams?: HttpQueryParams;
+    maxRedirects?: number;
+    responseType?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text';
+    cacheTTL?: number;
+    context?: unknown;
+    payload?: P;
+    httpsAgent?: https.Agent;
+  }): Promise<HttpResponse<T>>;
+  get<T>({
+    headers,
+    url,
+    queryParams,
+    maxRedirects,
+    cacheTTL,
+    context
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    queryParams?: HttpQueryParams;
+    maxRedirects?: number;
+    cacheTTL?: number;
+    context?: unknown;
+  }): Promise<HttpResponse<T>>;
+  post<P, T>({
+    headers,
+    url,
+    maxRedirects,
+    cacheTTL,
+    context,
+    payload
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    maxRedirects?: number;
+    cacheTTL?: number;
+    context?: unknown;
+    payload?: P;
+  }): Promise<HttpResponse<T>>;
+}
+//#endregion
+//#region src/httpClient/httpClientManager.d.ts
+declare const buildHttpClientInstance: () => IHttpClient;
+declare class HttpClientManager {
+  private static httpClientInstance;
+  static getInstance({
+    getHttpClient
+  }?: {
+    getHttpClient?: typeof buildHttpClientInstance;
+  }): Promise<IHttpClient>;
+  static resetInstance(): void;
+}
+//#endregion
+//#region src/instanceManager/index.d.ts
+declare class InstanceManager {
+  private static instance;
+  private static logger;
+  private dataStore;
+  private constructor();
+  static getInstance(logger?: ILogger): InstanceManager;
+  private initialize;
+  get<T>(key: string): Promise<T | null>;
+  set<T>(key: string, value: T, cacheTTL?: number): Promise<boolean>;
+  private ensureReady;
+  isReady(): boolean;
+  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;
+  private instantiator;
+  private dataStore;
+  private lockManager;
+  private expiryMap;
+  private evictionFrequency;
+  private staleDataThreshold;
+  private truncateThreshold;
+  private truncationPercentage;
+  private logger?;
+  private typeGuard?;
+  private dispose?;
+  private evictionInterval?;
+  private lastAccessedAt;
+  constructor(config?: MemoryStoreConfig<T>);
+  private initialize;
+  getData<U = T>(key: string): Promise<U | null>;
+  setData<U = T>({
+    key,
+    value,
+    cacheTTL
+  }: {
+    key: string;
+    value: U;
+    cacheTTL?: number;
+  }): Promise<boolean>;
+  private typeGuardBypass;
+  delete(key: string): Promise<boolean>;
+  pruneExpiredKeys(): Promise<PruneCount | undefined>;
+  private startEvictionTask;
+  private stopEvictionTask;
+  private updateLastAccessedAt;
+  isReady(): boolean;
+  close(): void;
+  listData<T>({
+    partialKey,
+    cursor,
+    limit
+  }: {
+    partialKey: string;
+    cursor?: string;
+    limit: number;
+  }): Promise<{
+    items: T[] | null;
+    cursor?: string;
+  }>;
+}
+//#endregion
+//#region src/parsers/types.d.ts
+declare const RequestParameterLocations: readonly ["query", "body", "headers"];
+type RequestParameterLocation = (typeof RequestParameterLocations)[number];
+type RequestParameter = {
+  name: string;
+  in: RequestParameterLocation;
+  value?: unknown;
+};
+//#endregion
+//#region src/parsers/requestParameters.d.ts
+declare const parseRequestParameters: (parameters: RequestParameter[]) => HttpParameters;
+//#endregion
+//#region src/requestClient/types.d.ts
+interface IRequestClient {
+  performRequest: ({
+    httpClient,
+    url,
+    method,
+    headers,
+    body,
+    customErrorConfigs
+  }: {
+    httpClient: IHttpClient;
+    url: string;
+    method: HttpMethod;
+    headers: HttpHeaders;
+    queryParams?: HttpQueryParams;
+    body: unknown;
+    customErrorConfigs?: CustomErrorConfig[];
+  }) => Promise<HttpResponse>;
+}
+type RequestClientType = 'rest' | 'soap';
+//#endregion
+//#region src/requestClient/requestClientFactory.d.ts
+declare class RequestClientFactory {
+  static build(type?: RequestClientType): IRequestClient;
+}
+//#endregion
+//#region src/validators/statusCodes.d.ts
+declare const isSuccessStatusCode: (status: number | undefined) => boolean;
+declare const isFailedStatusCode: (status: number | undefined) => boolean;
+declare const isInfoStatusCode: (status: number | undefined) => boolean;
+//#endregion
+//#region src/lockManager/types.d.ts
+type Lock = Promise<void>;
+type Unlock = () => void;
+type LockEntry = {
+  lock: Lock;
+  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 };