@integry/sdk 4.5.2 → 4.5.4

package/src/types/index.ts

@@ -0,0 +1,293 @@
+import { type } from 'superstruct';
+
+export type IntegrySDKEventType =
+  | 'authorizations'
+  | 'did-add-authorization'
+  | 'did-begin-remove-authorization'
+  | 'did-change-step'
+  | 'did-fail-authorization-verification'
+  | 'did-load-flow'
+  | 'did-load-flows'
+  | 'did-load-integration'
+  | 'did-load-integrations'
+  | 'did-load-preview'
+  | 'did-remove-authorization'
+  | 'did-save-integration'
+  | 'did-delete-integration'
+  | 'did-select-authorization'
+  | 'ready'
+  | 'should-load-flow'
+  | 'did-click-close-button'
+  | 'did-app-load'
+  | 'did-enable-integration'
+  | 'did-disable-integration'
+  | 'did-rename-integration'
+  | 'did-raise-sdk-embed-warning'
+  | 'app-connected'
+  | 'app-disconnected'
+  | 'modal-closed'
+  | 'integration-created';
+
+export type ConnectedAccount = {
+  id: string;
+  display_name: string;
+  modified_at: string;
+};
+export type IntegrySDKEventPayloads = {
+  ready: {
+    isReady: boolean;
+  };
+  'should-load-flow': {
+    templateId: number;
+    flowId: number;
+  };
+  'did-load-flows': {
+    flows: any[];
+  };
+  'did-load-integrations': {
+    integrations: any[];
+  };
+  'did-load-flow': {
+    flowId: number;
+    flowTitle: string;
+    flowDescription: string;
+    templateId: number;
+    templateTitle: string;
+    templateDescription: string;
+    mode: 'EDIT' | 'CREATE';
+  };
+  'did-load-integration': {
+    flowId: number;
+    integrationId: number;
+  };
+  'did-delete-integration': {
+    flowId: number;
+    flowName: string;
+    flowDescription: string;
+    integrationId: number;
+    integrationName: string;
+  };
+  'did-save-integration': {
+    integrationId: number;
+    name: string;
+    templateId: number;
+    flowId: number;
+    status: string;
+    callbackUrl: string | null;
+    callbackUrlArray: {
+      templateStepId: number;
+      activityId: number;
+      callbackUrl: string | null;
+    }[];
+    authorizations: {
+      authorizationId: number;
+      userIdentity: string;
+      isBrandingAppAuth: boolean;
+    }[];
+    event: 'EDIT' | 'CREATE';
+  };
+  'integration-created': {
+    integrationId: number;
+    name: string;
+    templateId: number;
+    flowId: number;
+    status: string;
+    callbackUrl: string | null;
+    callbackUrlArray: {
+      templateStepId: number;
+      activityId: number;
+      callbackUrl: string | null;
+    }[];
+    authorizations: {
+      authorizationId: number;
+      userIdentity: string;
+      isBrandingAppAuth: boolean;
+    }[];
+    event: 'EDIT' | 'CREATE';
+  };
+  'did-load-preview': {
+    flowId: number;
+    flowTitle: string;
+    flowDescription: string;
+  };
+  'did-change-step': {
+    stepId: number;
+    stepType: 'AUTH' | 'CONFIGURATION' | 'SECTION' | 'CONFIRMATION';
+  };
+  'did-add-authorization': {
+    identity: string;
+    authorizationId: number;
+    flowId: number | null;
+    appIcon: string;
+    alreadyExists: boolean;
+    externalId?: string;
+  };
+  'did-select-authorization': {
+    authorizationId: number;
+  };
+  'did-remove-authorization': {
+    authorizationId: number;
+    appId?: number | null;
+  };
+  'did-begin-remove-authorization': {
+    authorizationId: number;
+  };
+  'did-click-close-button': {
+    isCloseClicked: boolean;
+  };
+  'did-app-load': {
+    appName: string;
+    appId: number;
+    appLogoUrl: string;
+    authorizationId: number | null;
+  };
+  'did-enable-integration': {
+    integrationId: number;
+    name: string;
+    status: string;
+  };
+  'did-disable-integration': {
+    integrationId: number;
+    name: string;
+    status: string;
+  };
+  'did-rename-integration': {
+    integrationId: number;
+    name: string;
+    status: string;
+  };
+  'did-raise-sdk-embed-warning': {
+    type: string;
+    message: string;
+  };
+  'app-connected': {
+    id: number;
+    name: string;
+    title: string;
+    connected_accounts?: ConnectedAccount[];
+    icon_url: string;
+    docs_url: string;
+  } | null;
+  'app-disconnected': {
+    id: number;
+    name: string;
+    title: string;
+    connected_accounts?: ConnectedAccount[];
+    icon_url: string;
+    docs_url: string;
+  } | null;
+};
+
+type EventCallback<P extends IntegrySDKEventType> = (
+  // @ts-expect-error P can index IntegrySDKEventPayloads
+  payload: IntegrySDKEventPayloads[P],
+) => void;
+
+export type IntegrySDKEvents = {
+  authorizations: EventCallback<'authorizations'>;
+  'did-add-authorization': EventCallback<'did-add-authorization'>;
+  'did-begin-remove-authorization': EventCallback<'did-begin-remove-authorization'>;
+  'did-change-step': EventCallback<'did-change-step'>;
+  'did-fail-authorization-verification': EventCallback<'did-fail-authorization-verification'>;
+  'did-load-flow': EventCallback<'did-load-flow'>;
+  'did-load-flows': EventCallback<'did-load-flows'>;
+  'did-load-integration': EventCallback<'did-load-integration'>;
+  'did-delete-integration': EventCallback<'did-delete-integration'>;
+  'did-load-integrations': EventCallback<'did-load-integrations'>;
+  'did-load-preview': EventCallback<'did-load-preview'>;
+  'did-remove-authorization': EventCallback<'did-remove-authorization'>;
+  'did-save-integration': EventCallback<'did-save-integration'>;
+  'integration-created': EventCallback<'integration-created'>;
+  'did-select-authorization': EventCallback<'did-select-authorization'>;
+  ready: EventCallback<'ready'>;
+  'should-load-flow': EventCallback<'should-load-flow'>;
+  'did-click-close-button': EventCallback<'did-click-close-button'>;
+  'did-app-load': EventCallback<'did-app-load'>;
+  'did-enable-integration': EventCallback<'did-enable-integration'>;
+  'did-disable-integration': EventCallback<'did-disable-integration'>;
+  'did-rename-integration': EventCallback<'did-rename-integration'>;
+  'did-raise-sdk-embed-warning': EventCallback<'did-raise-sdk-embed-warning'>;
+  'app-connected': EventCallback<'app-connected'>;
+  'app-disconnected': EventCallback<'app-disconnected'>;
+  'modal-closed': EventCallback<'modal-closed'>;
+};
+
+export enum ViewStyles {
+  COMPACT = 'COMPACT',
+  COMFORTABLE = 'COMFORTABLE',
+}
+
+export enum Layouts {
+  NARROW = 'COMPACT',
+  WIDE = 'COMFORTABLE',
+}
+
+export enum TemplateFormRenderModes {
+  MODAL = 'MODAL',
+  INLINE = 'INLINE',
+  DETACHED = 'DETACHED',
+  CUSTOM = 'CUSTOM',
+}
+
+export enum MarketplaceRenderModes {
+  MODAL = 'MODAL',
+  INLINE = 'INLINE',
+}
+
+export enum RenderModes {
+  MODAL = 'MODAL',
+  INLINE = 'INLINE',
+}
+
+export enum TemplateListingRenderModes {
+  GRID = 'GRID',
+  LIST = 'LIST',
+}
+
+export type AuthorizationTypes =
+  | 'APIKey'
+  | 'OAuth2-1'
+  | 'OAuth2'
+  | 'Basic'
+  | 'APISecret'
+  | 'BasicWithoutURL'
+  | 'APIKeySecretRegion'
+  | 'BasicAndAPIKey'
+  | 'APIKeyWithURL'
+  | 'APIKeySecret';
+
+export type Authorization = {
+  id: number;
+  authorization_type: string;
+  app_user?: number;
+  app_user_id?: number;
+  disable_link?: string;
+  integration_count?: number;
+  user_identity: string;
+  access_token?: string;
+};
+
+export type UnfetchResponse = {
+  ok: boolean;
+  statusText: string;
+  status: number;
+  url: string;
+  text: () => Promise<string>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  json: () => Promise<any>;
+  blob: () => Promise<Blob>;
+  clone: () => UnfetchResponse;
+  headers: {
+    keys: () => string[];
+    entries: () => Array<[string, string]>;
+    get: (key: string) => string | undefined;
+    has: (key: string) => boolean;
+  };
+};
+export type SetupIntegrationOptions = {
+  containerId?: string;
+  renderMode?: RenderModes;
+  layout?: Layouts;
+  integrationId?: number;
+  params?: Record<string, string>;
+};

package/src/types/store.ts

@@ -0,0 +1,366 @@
+/* eslint-disable import/no-cycle */
+import { FlowCardProps } from '@/features/templates/Template';
+import { VNode } from 'preact';
+
+import {
+  Integration,
+  IntegrationResponse,
+  PreviewMetadata,
+  TemplateStep,
+  Template,
+  BundleResponse,
+  TemplateField,
+  App,
+  MarketplaceDetail,
+  MarketplaceAppAuthorizationType,
+  NestedObject,
+  IncomingWebhookPayload,
+} from '../interfaces';
+
+export interface ConfirmationStep {
+  type: 'CONFIRMATION';
+}
+
+export interface StepStateStep {
+  stepId: number;
+  title: string;
+  description?: string;
+  iconUrl: string;
+  type: 'AUTH' | 'CONFIGURATION' | 'SECTION' | 'CONFIRMATION';
+  isCompleted: boolean;
+  isCurrentlyOpen: boolean;
+  requiredFields: number[];
+  isValid: boolean;
+  invalidFields: {
+    [fieldId: number]: string | null;
+  };
+  itemIndex: number;
+}
+
+type StepState = {
+  steps: StepStateStep[];
+  currentStep: StepStateStep | ConfirmationStep | null;
+  fieldsListData:
+    | {
+        id: string;
+        sample_data: string;
+        tag: string;
+        title: string;
+      }[]
+    | null;
+  stepIndex: number;
+  showValidation: boolean;
+  allStepsCompleted: boolean;
+};
+
+export type Authorization = {
+  authorizationId: number;
+  userIdentity: string;
+  disableLink: string;
+  authType: string;
+  isVerified: boolean;
+  didFetchStatus: boolean;
+  isVerifying: boolean;
+  isDeleting: boolean;
+  error: string;
+};
+
+export type EditFieldData = {
+  fieldId: number | string;
+  is_hidden?: boolean;
+  description?: string;
+  default_value?: string | null;
+  stepId?: number;
+  is_mappable?: boolean;
+  is_editable?: boolean;
+  allow_tags_in_text?: boolean;
+  is_default_value_auto_mapped?: boolean;
+};
+
+type State = {
+  genericData: {
+    dFlag?: string;
+    deploymentId?: number | null;
+    authConnection?: {
+      appId?: number | null;
+      authTypeId?: number | null;
+    };
+    templateId: number | null;
+    stepWithActivityOutput: TemplateStep | null;
+    implicitAuthEnabled: boolean;
+    brandingApp: App | null;
+    isPreviewMode: boolean;
+    name: string;
+    authModalId: string;
+    isAnonymous: boolean;
+    showAppAuthModal: boolean;
+    isReadOnly?: boolean;
+    marketplaceId?: number | null;
+    marketplaceDetail?: MarketplaceDetail | null;
+    IUAccountsData?: MarketplaceAppAuthorizationType | null;
+    app_id?: number | string | null;
+    currentIntegrationStatus?: string;
+    isTestIntegration?: boolean;
+    showTemplates?: boolean;
+    keepBackButtonForFlows?: boolean;
+    showApps?: boolean;
+    skipOnDemand?: boolean;
+    skipAccountConnectionOnLoad?: boolean;
+    deploymentIdFromConfig?: number | null;
+    testMultipurpose?: boolean;
+    viewStyle?: string;
+    selfAppName?: string;
+    selfAppId?: number;
+    customerAppName?: string;
+    flowDescription?: string;
+    customFlowSetupRender?: boolean;
+    userVariables?: any;
+    userVariablesValidation?: boolean;
+    storage?: any;
+    flowParameters?: any;
+    flowParametersData?: any;
+  };
+  stepState: StepState;
+  stepMapping: {
+    [stepId: string]: {
+      step: TemplateStep;
+      integrationStepId: number | null;
+      isAuthVerified: boolean;
+      authorizations: Authorization[];
+      selectedAuthId: number;
+      isUserinfoRequired: boolean;
+    };
+  };
+  authMapping: {
+    [appId: string]: {
+      app: App;
+      isAuthVerified: boolean;
+      authorizations: any[];
+      selectedAuthId: number | null;
+      isUserinfoRequired: boolean;
+    };
+  };
+  selectedAuthByAppId: {
+    [appId: string]: number | null;
+  };
+  stepDataMapping: {
+    [stepId: number]: {
+      [fieldId: number]: {
+        integrationFieldId: number | null;
+        fieldId: number;
+        value: string | null;
+        objectValue: Record<string, string | number> | null;
+        machineName: string;
+        isRequired: boolean;
+        isVisible: boolean;
+        isDynamic: boolean;
+        type: string;
+        isAddedInMapping: boolean;
+        regex: string | null;
+        regexErrorMessage: string | null;
+        passesRegexTest: boolean;
+        isChanged: boolean;
+        changedDynamicFields: string[] | null;
+      };
+    };
+  };
+  parentChildMapping: {
+    [stepId: number]: {
+      [machineName: string]: {
+        stepId: number;
+        fieldId: number;
+        childFields: string[];
+        parentFields: string[];
+      };
+    };
+  };
+  conditionalFieldMapping: {
+    [step_id: number]: {
+      [machineName: string]: {
+        value: string;
+        parentMachineName: string;
+        parentFieldId: number;
+      }[];
+    };
+  };
+  fieldListMapping: {
+    [machineName: string]: TemplateField & { stepId: number };
+  };
+  activityOutputData?: {
+    value: string;
+    text: string;
+  }[];
+  appsAuthData?: {
+    appId: number;
+    isVerified: boolean;
+  }[];
+  dynamicFieldData?: {
+    [fieldId: string]: (string | Record<string, string>)[];
+  };
+  incomingWebhookPayload?: IncomingWebhookPayload;
+  userConfig?: {
+    availableFlowsLabel?: string;
+    myFlowsLabel?: string;
+    hideWebhookUrlScreen?: boolean;
+    hideAppConnectionModal?: boolean;
+    autoRedirectToMyFlows?: boolean;
+    marketplaceModalTitle?: string;
+    buttonLabelToSaveIntegration?: string;
+    objects?: NestedObject;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    [other: string]: any;
+  };
+  showSetupModal?: boolean;
+  showSetupInline?: boolean;
+  showFlowsListModal?: boolean;
+  showAppsListModal?: boolean;
+  showAppPageModal?: boolean;
+  integrations: Integration[];
+  integrationIdToEdit: number | null;
+  fetchingIntegrations: boolean;
+  fetchingTemplates: boolean;
+  templates: Template[];
+  mappingInfo: {
+    isNewMapping?: boolean;
+    customFieldsKey?: string;
+  } | null;
+  customComponents?: {
+    flowCard?: (props: FlowCardProps) => VNode;
+  };
+  activatedTab: string;
+  showMarketplaceModal?: boolean;
+  showRequestAppModal?: boolean;
+  requestAppFormData?: {
+    appField?: string;
+    descriptionField?: string;
+  };
+  showMarketplaceAppPageId?: number | null;
+  dFlag?: string;
+  editFieldData?: EditFieldData;
+  xIntegryConfig?: any;
+};
+
+type Actions = {
+  setStoreState(key: Partial<State>): void;
+  setBaseData(bundleResponse: BundleResponse): void;
+  setSteps(templateSteps: TemplateStep[]): void;
+  setIntegrationData(data: IntegrationResponse): void;
+  gotoNextStep(): void;
+  gotoPreviousStep(): void;
+  gotoStep(stepIndex: number): void;
+  setStepMapping(steps: TemplateStep[], integrationId?: number): void;
+  setParentChildMapping(steps: TemplateStep[]): void;
+  setConditionalFieldMapping(steps: TemplateStep[]): void;
+  setStepAuthorization(
+    stepId: number | null,
+    selectedAuthId: number | null,
+    isVerified: boolean,
+    fieldsToReset: number[],
+    override: boolean,
+  ): void;
+  setStepFieldData(data: {
+    stepId: string;
+    fieldId: string;
+    value: string;
+    isRequired: boolean;
+    passesRegexTest?: boolean;
+  }): void;
+  setStepMappingData(data: {
+    stepId: number;
+    fieldId: number;
+    id: string;
+    value: string | null;
+  }): void;
+  setGenericData(
+    genericData: Partial<{
+      deploymentId?: number;
+      templateId: number;
+      isPreviewMode: boolean;
+      name: string;
+      showAppAuthModal: boolean;
+      isReadOnly?: boolean;
+      marketplaceId?: number;
+      marketplaceDetail?: MarketplaceDetail;
+      IUAccountsData?: MarketplaceAppAuthorizationType;
+      currentIntegrationStatus?: string;
+      isTestIntegration?: boolean;
+      app_id?: number | string | null;
+      showTemplates?: boolean;
+      keepBackButtonForFlows?: boolean;
+      skipAccountConnectionOnLoad?: boolean;
+      testMultipurpose?: boolean;
+      selfAppName: string;
+      selfAppId: number;
+      customerAppName: string;
+    }>,
+  ): void;
+  setActivityOutputData(data: {
+    activityOutputData: {
+      text: string;
+      value: string;
+    }[];
+  }): void;
+  setAppsAuthData(data: {
+    appsAuthData: {
+      appId: number;
+      isVerified: boolean;
+    }[];
+  }): void;
+  setDynamicFieldData(data: {
+    dynamicFieldData: {
+      [fieldId: string]: (string | Record<string, string>)[];
+    };
+  }): void;
+  setIncomingWebhookPayload(data: {
+    incomingWebhookPayload: IncomingWebhookPayload;
+  }): void;
+  addAuthorization(params: { stepId: number; authData: Authorization }): void;
+  addAppAuthorization(params: { appId: number; authData: Authorization }): void;
+  setSelectedAuthByAppId: (params: { appId: number; authId: number }) => void;
+  removeAuthorization(params: { stepId: number; authId: number }): void;
+  removeAppAuthorization(params: { appId: number; authId: number }): void;
+  toggleVerifyAuthorizationFlag(params: {
+    stepId: number;
+    authId: number;
+    isVerifying: boolean;
+  }): void;
+  toggleVerifyAppAuthorizationFlag(params: {
+    appId: number;
+    authId: number;
+    isVerifying: boolean;
+  }): void;
+  setIntegrationLoadingState(data: {
+    integrationId: number;
+    isLoading: boolean;
+    op: 'edit' | 'delete' | 'edit-name';
+    nextVal?: boolean;
+    updatedName?: string;
+  }): void;
+  toggleDeleteAuthorizationFlag(params: {
+    stepId: number;
+    authId: number;
+    isDeleting: boolean;
+    error: string;
+  }): void;
+  toggleDeleteAppAuthorizationFlag(params: {
+    appId: number;
+    authId: number;
+    isDeleting: boolean;
+    error: string;
+  }): void;
+  setStepAuthId(params: { stepId: number; authId: number }): void;
+  setAppStepAuthId(params: { appId: number; authId: number }): void;
+  showStepValidationState(): void;
+  hideStepValidationState(): void;
+  gotoStepInPreview(previewMetadata: PreviewMetadata): void;
+  verifyStepValidity(stepId: number): void;
+  resetCustomMappingData(stepId: number): void;
+  reset(): void;
+  resetTemplateFields(): void;
+  clearChildFields(data: { stepId: number; fieldId: number }): void;
+  setEditFieldData(data: { fieldId: number }): void;
+};
+
+type StoreType = State & Actions;
+
+export { State, StepState, Actions, StoreType };

package/src/types/utils.ts

@@ -0,0 +1,19 @@
+/**
+ * Utility types
+ */
+
+export type OrNull<Type> = Type | null;
+
+export type OneOrMany<Type> = Type | Type[];
+
+export type OneOrManyOrNull<Type> = OrNull<OneOrMany<Type>>;
+
+export type Merge<A, B> = {
+  [K in keyof (A | B)]: K extends keyof B ? B[K] : A[K];
+};
+
+export function notEmpty<TValue>(
+  value: TValue | null | undefined,
+): value is TValue {
+  return value !== null && value !== undefined;
+}