@stackone/olap 1.15.0 → 1.17.0

package/dist/index.d.cts

@@ -1,4 +1,9 @@
 import { S3Client } from "@aws-sdk/client-s3";
+import * as redis from "redis";
+import { AxiosInstance } from "axios";
+import http from "node:http";
+import https from "node:https";
+import { Readable } from "node:stream";
 import { Kafka } from "kafkajs";
 
 //#region rolldown:runtime
@@ -85,10 +90,487 @@ type DefenderOptions = {
   enabled?: boolean;
 };
 //#endregion
+//#region ../transport/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>;
+  scriptExists?(shas: string[]): Promise<boolean[]>;
+  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>;
+  close?(): Promise<void> | void;
+}
+type PubSubListener<ReturnsBuffer extends boolean = false> = <T extends (ReturnsBuffer extends true ? Buffer : string)>(message: T, channel: T) => unknown;
+//#endregion
+//#region ../transport/src/redisClient/types.d.ts
+type RedisClientType = redis.RedisClientType;
+interface RedisClientConfig {
+  getRedisClient?: typeof redis.createClient;
+  host?: string;
+  port?: number;
+  tls?: boolean;
+  reconnect?: boolean;
+  database?: number;
+}
+type RedisClientBuilder = (config: RedisClientConfig, logger?: ILogger, invoker?: string) => Promise<ICacheClient<RedisClientType> | undefined>;
+//#endregion
+//#region ../transport/src/concurrencyManager/types.d.ts
+type ConcurrencySubPoolConfig = {
+  subPoolKey: string;
+  urlPattern: RegExp | string;
+  maxConcurrency: number;
+};
+type ConcurrencyConfig = {
+  mainMaxConcurrency: number;
+  subPools?: ConcurrencySubPoolConfig[];
+};
+//#endregion
+//#region ../transport/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 ../transport/src/interceptors/types.d.ts
+type RequestConfig = {
+  rateLimits?: RateLimitConfig;
+  concurrency?: ConcurrencyConfig;
+};
+//#endregion
+//#region ../transport/src/parsers/types.d.ts
+declare const QueryArrayFormats: readonly ["repeat", "brackets", "comma"];
+type QueryArrayFormat = (typeof QueryArrayFormats)[number];
+//#endregion
+//#region ../transport/src/httpClient/types.d.ts
+type HttpHeader = string | string[];
+type HttpHeaders = {
+  [key: string]: HttpHeader;
+};
+type HttpQueryParamValue = {
+  value: string | string[];
+  arrayFormat?: QueryArrayFormat;
+};
+type HttpQueryParams = {
+  [key: string]: string | string[] | HttpQueryParamValue;
+};
+declare const HttpMethods: readonly ["get", "post", "put", "delete", "patch"];
+type HttpMethod = (typeof HttpMethods)[number];
+type HttpResponse<T = any, P = any> = {
+  data: T;
+  status: number;
+  headers: HttpHeaders;
+  requestUrl: string;
+  responseType?: string;
+  responseTime?: Date;
+  message?: string;
+  body?: P;
+};
+type StreamHttpResponse = {
+  status: number;
+  headers: HttpHeaders;
+  stream: Readable;
+  requestUrl: string;
+};
+interface IHttpClient {
+  request<P, T>({
+    headers,
+    url,
+    method,
+    queryParams,
+    maxRedirects,
+    responseType,
+    cacheTTL,
+    context,
+    payload,
+    httpsAgent,
+    httpAgent,
+    requestConfig,
+    httpsAgentConfig
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    method?: HttpMethod;
+    queryParams?: HttpQueryParams;
+    maxRedirects?: number;
+    responseType?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text';
+    cacheTTL?: number;
+    context?: RequestContext;
+    payload?: P;
+    httpsAgent?: https.Agent;
+    httpAgent?: http.Agent;
+    requestConfig?: RequestConfig;
+    httpsAgentConfig?: https.AgentOptions;
+  }): Promise<HttpResponse<T>>;
+  get<T>({
+    headers,
+    url,
+    queryParams,
+    maxRedirects,
+    cacheTTL,
+    context,
+    requestConfig
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    queryParams?: HttpQueryParams;
+    maxRedirects?: number;
+    cacheTTL?: number;
+    context?: RequestContext;
+    requestConfig?: RequestConfig;
+  }): Promise<HttpResponse<T>>;
+  post<P, T>({
+    headers,
+    url,
+    maxRedirects,
+    cacheTTL,
+    context,
+    payload,
+    requestConfig
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    maxRedirects?: number;
+    cacheTTL?: number;
+    context?: RequestContext;
+    payload?: P;
+    requestConfig?: RequestConfig;
+  }): Promise<HttpResponse<T>>;
+  requestStream({
+    headers,
+    url,
+    method,
+    queryParams,
+    maxRedirects,
+    context,
+    traceId,
+    payload,
+    httpsAgent,
+    httpAgent,
+    requestConfig,
+    httpsAgentConfig
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    method?: HttpMethod;
+    queryParams?: HttpQueryParams;
+    maxRedirects?: number;
+    context?: RequestContext;
+    traceId?: string;
+    payload?: unknown;
+    httpsAgent?: https.Agent;
+    httpAgent?: http.Agent;
+    requestConfig?: RequestConfig;
+    httpsAgentConfig?: https.AgentOptions;
+  }): Promise<StreamHttpResponse>;
+}
+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 | string;
+  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[];
+};
+type ErrorMappingFn<TError extends Error = Error> = (error: Error) => TError | undefined;
+type TransportFactory = ({
+  logger,
+  redisClientConfig,
+  context,
+  requestConfig,
+  httpsAgentConfig
+}: {
+  logger?: ILogger;
+  redisClientConfig?: RedisClientConfig;
+  context?: RequestContext;
+  requestConfig?: RequestConfig;
+  httpsAgentConfig?: https.AgentOptions;
+}) => Promise<AxiosInstance>;
+//#endregion
+//#region ../transport/src/httpClient/httpClient.d.ts
+declare class HttpClient<TError extends Error = Error> implements IHttpClient {
+  #private;
+  name: string;
+  constructor({
+    transportFactory,
+    getRedisClient,
+    logger,
+    redisClientConfig,
+    errorMappingFn
+  }?: {
+    transportFactory?: TransportFactory;
+    getRedisClient?: RedisClientBuilder;
+    logger?: ILogger;
+    redisClientConfig?: RedisClientConfig;
+    errorMappingFn?: ErrorMappingFn<TError>;
+  });
+  request<P, T>({
+    headers,
+    url,
+    method,
+    queryParams,
+    maxRedirects,
+    responseType,
+    cacheTTL,
+    context,
+    traceId,
+    payload,
+    httpsAgent,
+    httpAgent,
+    requestConfig,
+    httpsAgentConfig
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    method?: HttpMethod;
+    queryParams?: HttpQueryParams;
+    maxRedirects?: number;
+    responseType?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text';
+    cacheTTL?: number;
+    context?: RequestContext;
+    traceId?: string;
+    payload?: P;
+    httpsAgent?: https.Agent;
+    httpAgent?: http.Agent;
+    requestConfig?: RequestConfig;
+    httpsAgentConfig?: https.AgentOptions;
+  }): Promise<HttpResponse<T>>;
+  get<T>({
+    headers,
+    url,
+    queryParams,
+    maxRedirects,
+    cacheTTL,
+    context,
+    traceId,
+    requestConfig
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    queryParams?: HttpQueryParams;
+    maxRedirects?: number;
+    cacheTTL?: number;
+    context?: RequestContext;
+    traceId?: string;
+    requestConfig?: RequestConfig;
+  }): Promise<HttpResponse<T>>;
+  post<P, T>({
+    headers,
+    url,
+    maxRedirects,
+    cacheTTL,
+    context,
+    traceId,
+    payload,
+    requestConfig
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    maxRedirects?: number;
+    cacheTTL?: number;
+    context?: RequestContext;
+    traceId?: string;
+    payload?: P;
+    requestConfig?: RequestConfig;
+  }): Promise<HttpResponse<T>>;
+  requestStream({
+    headers,
+    url,
+    method,
+    queryParams,
+    maxRedirects,
+    context,
+    traceId,
+    payload,
+    httpsAgent,
+    httpAgent,
+    requestConfig,
+    httpsAgentConfig
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    method?: HttpMethod;
+    queryParams?: HttpQueryParams;
+    maxRedirects?: number;
+    context?: RequestContext;
+    traceId?: string;
+    payload?: unknown;
+    httpsAgent?: https.Agent;
+    httpAgent?: http.Agent;
+    requestConfig?: RequestConfig;
+    httpsAgentConfig?: https.AgentOptions;
+  }): Promise<StreamHttpResponse>;
+}
+//#endregion
+//#region src/logs/types.d.ts
+type ActionsQuery = {
+  organizationId?: string | string[];
+  projectSecureId?: string | string[];
+  actionRunId?: string | string[];
+  accountSecureId?: string | string[];
+  actionId?: string | string[];
+  connectorKey?: string | string[];
+  mode?: string | string[];
+  category?: string | string[];
+  success?: boolean;
+  startTime?: Date;
+  endTime?: Date;
+  pageNumber?: number;
+  pageSize?: number;
+};
+type ActionsQueryResult = {
+  actionLogs: ActionLog[];
+  total: number;
+  pageNumber: number;
+  pageSize: number;
+};
+type StepsQuery = {
+  organizationId?: string | string[];
+  projectSecureId?: string | string[];
+  accountSecureId?: string | string[];
+  actionRunId?: string | string[];
+  stepId?: string | string[];
+  success?: boolean;
+  startTime?: Date;
+  endTime?: Date;
+  pageNumber?: number;
+  pageSize?: number;
+};
+type StepsQueryResult = {
+  stepLogs: StepLog[];
+  total: number;
+  pageNumber: number;
+  pageSize: number;
+};
+type HttpClientBuilder = (logger?: ILogger) => HttpClient | undefined;
+interface KafkaClientConfig {
+  brokers: string[];
+}
+type KafkaClientBuilder = (config?: KafkaClientConfig, logger?: ILogger) => Kafka | undefined;
+type ActionLog = {
+  actionRunId: string;
+  actionId: string;
+  connectorKey: string;
+  connectorVersion: string;
+  organizationId: string;
+  projectSecureId: string;
+  accountSecureId: string;
+  mode?: string;
+  category?: string;
+  originOwnerId?: string;
+  originOwnerName?: string;
+  httpMethod?: string;
+  url?: string;
+  sourceType?: string;
+  sourceId?: string;
+  sourceValue?: string;
+  success?: boolean;
+  statusCode?: number;
+  startTime?: Date;
+  endTime?: Date;
+  durationMs?: number;
+  eventTime?: Date;
+  riskLevel?: string;
+  tier2Score?: number;
+};
+type StepLog = {
+  actionRunId: string;
+  stepIndex: number;
+  stepId: string;
+  organizationId: string;
+  projectSecureId: string;
+  accountSecureId: string;
+  skipped?: boolean;
+  success?: boolean;
+  message?: string;
+  startTime?: Date;
+  endTime?: Date;
+  durationMs?: number;
+  eventTime?: Date;
+};
+//#endregion
 //#region src/types.d.ts
 interface IOlapClient {
   recordAction(actionInput: ActionInput, actionResult: ActionResult, options?: OlapOptions): void;
   recordStep(stepInput: StepInput, stepResult: StepResult, options?: OlapOptions): void;
+  getActions(organizationId: string, projectSecureId: string, query: ActionsQuery): Promise<ActionsQueryResult>;
+  getAction(organizationId: string, projectSecureId: string, actionRunId: string): Promise<ActionLog | undefined>;
+  getAdvanced(organizationId: string, projectSecureId: string, actionRunId: string): Promise<string | undefined>;
+  getDefender(organizationId: string, projectSecureId: string, actionRunId: string): Promise<string | undefined>;
 }
 type DefenderContext = {
   riskLevel: string;
@@ -161,11 +643,30 @@ interface S3ClientConfig {
 }
 type S3ClientBuilder = (config?: S3ClientConfig, logger?: ILogger) => S3Client | undefined;
 //#endregion
-//#region src/logs/types.d.ts
-interface KafkaClientConfig {
-  brokers: string[];
+//#region src/logs/tinybirdClient.d.ts
+interface TinybirdConfig {
+  baseUrl: string;
+  token: string;
+  allowHttp?: boolean;
+}
+interface TinybirdResponse<T> {
+  meta: Array<{
+    name: string;
+    type: string;
+  }>;
+  data: T;
+  rows: number;
+  rows_before_limit_at_least?: number;
+  statistics?: {
+    elapsed: number;
+    rows_read: number;
+    bytes_read: number;
+  };
+}
+interface TinybirdQueryOptions<TParams = Record<string, unknown>> {
+  endpoint: string;
+  params?: TParams;
 }
-type KafkaClientBuilder = (config?: KafkaClientConfig, logger?: ILogger) => Kafka | undefined;
 //#endregion
 //#region src/olap/olapClient.d.ts
 declare class OlapClient implements IOlapClient {
@@ -173,54 +674,70 @@ declare class OlapClient implements IOlapClient {
   name: string;
   constructor({
     getKafkaClient,
+    getHttpClient,
     getS3Client,
     kafkaClientConfig,
     s3ClientConfig,
+    tinybirdConfig,
     logger
   }?: {
     getKafkaClient?: KafkaClientBuilder;
+    getHttpClient?: HttpClientBuilder;
     getS3Client?: S3ClientBuilder;
     kafkaClientConfig?: KafkaClientConfig;
     s3ClientConfig?: S3ClientConfig;
+    tinybirdConfig?: TinybirdConfig;
     logger?: ILogger;
   });
   initialize(): Promise<void>;
   recordAction(actionInput: ActionInput, actionResult: ActionResult, options?: OlapOptions): Promise<void>;
   recordStep(stepInput: StepInput, stepResult: StepResult, options?: OlapOptions): Promise<void>;
+  getActions(organizationId: string, projectSecureId: string, query: ActionsQuery): Promise<ActionsQueryResult>;
+  getAction(organizationId: string, projectSecureId: string, actionRunId: string): Promise<ActionLog | undefined>;
+  getAdvanced(organizationId: string, projectSecureId: string, actionRunId: string): Promise<string | undefined>;
+  getDefender(organizationId: string, projectSecureId: string, actionRunId: string): Promise<string | undefined>;
 }
 //#endregion
 //#region src/olap/olapClientManager.d.ts
 declare const buildOlapClientInstance: ({
   getKafkaClient,
+  getHttpClient,
   getS3Client,
   kafkaClientConfig,
   s3ClientConfig,
+  tinybirdConfig,
   logger
 }?: {
   getKafkaClient?: KafkaClientBuilder;
+  getHttpClient?: HttpClientBuilder;
   getS3Client?: S3ClientBuilder;
   kafkaClientConfig?: KafkaClientConfig;
   s3ClientConfig?: S3ClientConfig;
+  tinybirdConfig?: TinybirdConfig;
   logger?: ILogger;
 }) => Promise<IOlapClient>;
 declare class OlapClientManager {
   private static olapClientPromise;
   static getInstance({
     getKafkaClient,
+    getHttpClient,
     getS3Client,
     kafkaClientConfig,
     s3ClientConfig,
+    tinybirdConfig,
     logger,
     getOlapClient
   }?: {
     getKafkaClient?: KafkaClientBuilder;
+    getHttpClient?: HttpClientBuilder;
     getS3Client?: S3ClientBuilder;
     kafkaClientConfig?: KafkaClientConfig;
     s3ClientConfig?: S3ClientConfig;
+    tinybirdConfig?: TinybirdConfig;
     logger?: ILogger;
     getOlapClient?: typeof buildOlapClientInstance;
   }): Promise<IOlapClient>;
   static resetInstance(): void;
 }
 //#endregion
-export { type ActionInput, type ActionResult, type AdvancedOptions, type DefenderContext, type DefenderOptions, type IOlapClient, type LogsOptions, OlapClient, OlapClientManager, type OlapOptions, type StepInput, type StepResult };
+export { type ActionInput, type ActionLog, type ActionResult, type ActionsQuery, type ActionsQueryResult, type AdvancedOptions, type DefenderContext, type DefenderOptions, type IOlapClient, type LogsOptions, OlapClient, OlapClientManager, type OlapOptions, type StepInput, type StepLog, type StepResult, type StepsQuery, type StepsQueryResult, type TinybirdConfig, type TinybirdQueryOptions, type TinybirdResponse };