@stackone/connect-sdk 1.38.0 → 1.40.0

package/dist/index.d.ts

@@ -1,7 +1,549 @@
-import { Account, Block, BlockContext, Category, Connector, Cursor, Operation, Step, StepFunctionName, StepFunctionParams, StepFunctionsFactory } from "@stackone/core";
-import { ILogger } from "@stackone/logger";
-import { HttpMethod, IHttpClient } from "@stackone/transport";
+import { ZodType } from "zod/v4";
+import http from "node:http";
+import https from "node:https";
 
+//#region ../core/src/categories/types.d.ts
+type Category = 'hris' | 'crm' | 'ats' | 'lms' | 'marketing' | 'filestorage' | 'internal';
+//#endregion
+//#region ../core/src/compositeIds/types.d.ts
+
+type ComponentConfig = {
+  name: string;
+  alias?: string;
+};
+type ComponentFieldConfig = {
+  targetFieldKey: string;
+  remote?: string;
+  components: ComponentConfig[];
+};
+type CompositeIdentifierConnectorConfig = {
+  enabled: boolean;
+  version?: number;
+  fields?: ComponentFieldConfig[];
+};
+//#endregion
+//#region ../core/src/cursor/types.d.ts
+type Position = {
+  pageNumber?: number | null;
+  providerPageCursor?: string | null;
+  position?: number | null;
+};
+type Cursor = {
+  remote: Record<number, Position>;
+  version: number;
+  timestamp: number;
+};
+//#endregion
+//#region ../logger/src/types.d.ts
+interface ILogger {
+  debug({
+    category,
+    message,
+    traceId,
+    context
+  }: {
+    category?: string;
+    message: string;
+    traceId?: string;
+    context?: Record<string, unknown>;
+  }): void;
+  info({
+    category,
+    message,
+    traceId,
+    context
+  }: {
+    category?: string;
+    message: string;
+    traceId?: string;
+    context?: Record<string, unknown>;
+  }): void;
+  warning({
+    category,
+    message,
+    traceId,
+    error,
+    code,
+    context
+  }: {
+    category?: string;
+    message: string;
+    traceId?: string;
+    error?: LogError;
+    code?: string;
+    context?: Record<string, unknown>;
+  }): void;
+  error({
+    category,
+    message,
+    traceId,
+    error,
+    code,
+    context
+  }: {
+    category?: string;
+    message: string;
+    traceId?: string;
+    error?: LogError;
+    code: string;
+    context?: Record<string, unknown>;
+  }): void;
+}
+type LogError = Error & {
+  response?: {
+    data?: unknown;
+  };
+  context?: Record<string, unknown>;
+  url?: string;
+};
+//#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/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;
+};
+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>>;
+}
+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 ../core/src/schema/types.d.ts
+type Schema = {
+  name: string;
+  key: string;
+  version: string;
+  description?: string;
+  category: Category;
+  fields: {
+    [name: string]: SchemaField;
+  };
+};
+type SchemaField = {
+  name: string;
+  type: string;
+  required: boolean;
+  description?: string;
+};
+//#endregion
+//#region ../core/src/stepFunctions/stepFunctionsList.d.ts
+declare enum StepFunctionName {
+  TYPECAST = "typecast",
+  MAP_FIELDS = "map_fields",
+  GROUP_DATA = "group_data",
+  REQUEST = "request",
+  PAGINATED_REQUEST = "paginated_request",
+}
+//#endregion
+//#region ../core/src/stepFunctions/types.d.ts
+type StepFunction = ({
+  block,
+  params
+}: {
+  block: Readonly<Block>;
+  params?: StepFunctionParams;
+}) => Promise<StepFunctionOutput>;
+type StepFunctionParams = {
+  [key: string]: unknown;
+};
+type StepFunctionMeta = {
+  functionName: StepFunctionName;
+  params?: StepFunctionParams;
+  version?: string;
+};
+type StepFunctionInstance = {
+  fn: StepFunction;
+  inputSchema?: ZodType;
+  outputSchema?: ZodType;
+};
+type StepFunctionOutput = {
+  block: Block;
+  successful: boolean;
+  errors?: StepError[];
+  output?: {
+    [name: string]: unknown;
+  };
+};
+//#endregion
+//#region ../core/src/steps/types.d.ts
+type StepSnapshot = {
+  output?: {
+    [name: string]: unknown;
+  };
+  successful: boolean;
+  skipped?: boolean;
+  message?: string;
+  errors?: StepError[];
+};
+type StepsSnapshots = {
+  [stepId: string]: StepSnapshot;
+};
+type StepError = {
+  [key: string]: unknown;
+};
+type Step = {
+  id: string;
+  description: string;
+  stepFunction: StepFunctionMeta;
+  ignoreError?: boolean;
+  async?: boolean;
+  successCriteria?: string;
+  condition?: string;
+};
+//#endregion
+//#region ../core/src/connector/types.d.ts
+type Connector = {
+  title: string;
+  version: string;
+  key: string;
+  assets: Assets;
+  description?: string;
+  categories?: Category[];
+  authentication?: Authentication;
+  operations?: {
+    [entrypointUrl: string]: Operation;
+  };
+};
+type Assets = {
+  icon: string;
+};
+type OperationType = 'list' | 'get' | 'create' | 'update' | 'delete' | 'custom' | 'refresh_token' | 'unknown';
+type InputLocation = 'body' | 'query' | 'path' | 'headers';
+type Input = {
+  name: string;
+  type: string;
+  required: boolean;
+  description: string;
+  in: InputLocation;
+};
+type Operation = {
+  id: string;
+  categories: Category[];
+  description: string;
+  schema?: Schema;
+  operationType: OperationType;
+  entrypointUrl?: string;
+  entrypointHttpMethod?: HttpMethod;
+  inputs?: Input[];
+  steps: {
+    [stepId: string]: Step;
+  };
+  result?: string | Record<string, unknown>;
+  responses: {
+    success: OperationResponse;
+    errors: Record<number, OperationResponse>;
+  };
+  cursor: {
+    enabled: boolean;
+    pageSize: number;
+  };
+  compositeIdentifiers: CompositeIdentifierConnectorConfig;
+  scheduledJobs?: ScheduledJobConfig[];
+};
+type ScheduledJobConfig = {
+  enabled: boolean;
+  type: ScheduledJobType;
+  schedule: string;
+  description: string;
+  requestParams?: ScheduledJobRequestParams;
+  syncFilter?: SyncFilterConfig;
+};
+type ScheduledJobRequestParams = {
+  fields?: string[];
+  expand?: string[];
+  filter?: Record<string, string>;
+};
+type ScheduledJobType = 'data_sync';
+type SyncFilterName = 'updated_after' | 'created_after';
+type SyncFilterConfig = {
+  name: SyncFilterName;
+  initialLoopbackPeriod: string;
+  incrementalLoopbackPeriod: string;
+};
+type OperationResponse = {
+  statusCode: number;
+  description?: string;
+};
+type AuthenticationField = {
+  key: string;
+  label: string;
+  type: 'text' | 'password' | 'select';
+  options?: {
+    value: string;
+    label: string;
+  }[];
+  required: boolean;
+  secret: boolean;
+  readOnly: boolean;
+  placeholder?: string;
+  description?: string;
+  tooltip?: string;
+};
+type SupportConfig = {
+  link: string;
+  description?: string;
+};
+type AuthenticationConfig = {
+  envKey: string;
+  envName: string;
+  type: 'custom' | 'oauth2';
+  label: string;
+  authorization: {
+    type: 'basic' | 'bearer' | 'oauth2';
+    [authParam: string]: unknown;
+  };
+  support?: SupportConfig;
+  configFields?: AuthenticationField[];
+  setupFields?: AuthenticationField[];
+  refreshAuthentication?: {
+    schedule?: string;
+    operation: Operation;
+  };
+  testOperationsIds?: string[];
+};
+type Authentication = {
+  [authType: string]: {
+    production: AuthenticationConfig;
+    [envKey: string]: AuthenticationConfig;
+  };
+};
+//#endregion
+//#region ../core/src/blocks/types.d.ts
+type Block = {
+  inputs?: {
+    [key: string]: unknown;
+  };
+  connector?: Connector;
+  context: BlockContext;
+  debug?: DebugParams;
+  steps?: StepsSnapshots;
+  httpClient?: IHttpClient;
+  logger?: ILogger;
+  operation?: Operation;
+  credentials?: Credentials;
+  outputs?: unknown;
+  nextCursor?: Cursor | null;
+  response?: {
+    statusCode: number;
+    successful: boolean;
+    message?: string;
+  };
+  fieldConfigs?: FieldConfig[];
+  result?: BlockIndexedRecord[] | BlockIndexedRecord;
+};
+type BlockContext = {
+  projectSecureId: string;
+  accountSecureId: string;
+  connectorKey: string;
+  connectorVersion: string;
+  category: Category;
+  schema?: string;
+  operationType: OperationType;
+  authenticationType: string;
+  environment: string;
+  service: string;
+  resource: string;
+  subResource?: string;
+  childResource?: string;
+};
+type BlockIndexedRecord = {
+  id: string;
+  remote_id?: string;
+  [key: string]: unknown;
+  unified_custom_fields?: {
+    [key: string]: unknown;
+  };
+};
+type EnumMatcherExpression = {
+  matchExpression: string;
+  value: string;
+};
+type FieldConfig = {
+  expression?: string;
+  targetFieldKey: string;
+  alias?: string;
+  type: string;
+  custom: boolean;
+  hidden: boolean;
+  enumMapper?: {
+    matcher: string | EnumMatcherExpression[];
+  };
+};
+type DebugParams = {
+  custom_mappings?: 'disabled' | 'enabled';
+};
+type Credentials = Record<string, unknown>;
+//#endregion
+//#region ../core/src/stepFunctions/factory.d.ts
+declare const StepFunctionsFactory: {
+  build({
+    functionName,
+    version,
+    validateSchemas,
+    stepFunctionsList
+  }: {
+    functionName: StepFunctionName;
+    version?: string;
+    validateSchemas?: boolean;
+    stepFunctionsList?: Record<string, Record<string, StepFunctionInstance>>;
+  }): StepFunctionInstance;
+};
+//#endregion
+//#region ../core/src/accounts/types.d.ts
+type Account = {
+  providerKey: string;
+  providerVersion: string;
+  authConfigKey: string;
+  environment: string;
+  organizationId: number;
+  secureId: string;
+  credentials?: Record<string, unknown>;
+  projectSecureId: string;
+};
+//#endregion
 //#region src/blocks/createBlock.d.ts
 declare const createBlock: ({
   inputs,
@@ -21,6 +563,9 @@ declare const createBlock: ({
   getHttpClient?: () => Promise<IHttpClient>;
 }) => Promise<Block>;
 //#endregion
+//#region src/connectors/fileReader.d.ts
+declare const loadConnector: (filePath: string) => string;
+//#endregion
 //#region src/connectors/operations.d.ts
 declare const getOperationFromUrl: (connector: Connector, url: string, method: HttpMethod) => {
   operation: Operation;
@@ -153,4 +698,4 @@ declare const runConnectorOperation: ({
   runStepOperationFn?: typeof runStepOperation;
 }) => Promise<Block>;
 //#endregion
-export { ConnectSDKError, ErrorType, createBlock, executeStepFunction, getOperationFromUrl, parseOperationInputs, parseYamlConnector, runConnectorOperation, runStepOperation, validateYamlConnector };
+export { ConnectSDKError, type ErrorType, createBlock, executeStepFunction, getOperationFromUrl, loadConnector, parseOperationInputs, parseYamlConnector, runConnectorOperation, runStepOperation, validateYamlConnector };