@useparagon/connect 1.0.24-experimental.12 → 1.0.24-experimental.13

package/dist/src/src/types/connect.d.ts

@@ -0,0 +1,226 @@
+import { ConnectCredentialProviderData, CredentialStatus, IConnectCredential } from '../entities/connectCredential.interface';
+import { ConnectCredentialConfigMeta, IConnectCredentialConfig } from '../entities/connectCredentialConfig.interface';
+import { PersonaMeta } from '../entities/persona.interface';
+import { AccountType, DataSource, IntegrationConnectInput, SidebarInputType } from './action';
+import { OrConditions } from './resolvers';
+import { CredentialConfigOptions } from './sdk';
+export interface SDKConnectCredentialConfig {
+    sharedSettings?: IntegrationSharedInputStateMap;
+    workflowSettings?: IntegrationWorkflowStateMap;
+    configMeta?: ConnectCredentialConfigMeta;
+    /**
+     * this refer `externalId` of credential config containing shared/workflow settings
+     */
+    externalId?: string;
+    /**
+     * @deprecated -  use `workflowSettings`
+     */
+    configuredWorkflows?: IntegrationWorkflowStateMap;
+}
+type ConnectInputValue = string | number | boolean | FieldMappingValue | ComboInputValue | undefined;
+type FieldMappingValue = {
+    objectMapping?: string;
+    fieldMappings?: {
+        [label: string]: string | undefined;
+    };
+    dynamicMappings?: {
+        [mappingKey: string]: {
+            applicationField?: string;
+            integrationField?: string;
+        };
+    };
+    userCreatedFields?: string[];
+    /**
+     * Type of field mapper used for creating field mappings
+     * @default STATIC
+     */
+    mappingType?: 'STATIC' | 'DYNAMIC';
+};
+type ComboInputValue = {
+    mainInput?: string;
+    dependentInput?: string;
+    fieldMappings?: {
+        [label: string]: string | undefined;
+    };
+};
+export type IntegrationWorkflowStateMap = {
+    [workflowId: string]: IntegrationWorkflowState | undefined;
+};
+export type IntegrationSharedInputStateMap = {
+    [inputId: string]: ConnectInputValue | undefined;
+};
+export type IntegrationWorkflowState = {
+    enabled: boolean;
+    settings: {
+        [inputId: string]: ConnectInputValue | undefined;
+    };
+};
+export type ModalConfig = {
+    /**
+     * A primary color for the background color of the Connect modal.
+     */
+    accentColor?: string;
+    /**
+     * A boolean to show / hide paragon link in footer section. (default true)
+     */
+    paragonLink?: boolean;
+    /**
+     * A description for the integration's purpose. Appears just below the integration name.
+     */
+    description?: string;
+    /**
+     * A long-form description for the integration's purpose. Appears in the Overview tab of the
+     * Connect modal.
+     */
+    overview?: string;
+    /**
+     * Inputs and metadata about this integration's workflows.
+     */
+    workflowMeta?: IntegrationWorkflowMetaMap;
+    /**
+     * Inputs metadata for shared workflow settings
+     */
+    sharedMeta?: IntegrationSharedMeta;
+};
+type IntegrationSharedMeta = {
+    /**
+     * Inputs to intake global/shared user settings, configured in the Portal Editor.
+     */
+    inputs?: SerializedConnectInput[];
+};
+declare const SupportedConnectInputTypes: readonly [SidebarInputType.ValueText, SidebarInputType.DynamicEnum, SidebarInputType.Enum, SidebarInputType.Number, SidebarInputType.Email, SidebarInputType.URL, SidebarInputType.FieldMapper, SidebarInputType.BooleanInput, SidebarInputType.ComboInput, SidebarInputType.Password, SidebarInputType.Switch, SidebarInputType.ValueTextArea];
+type SupportedConnectInputType = (typeof SupportedConnectInputTypes)[number];
+export type SidebarInput = IntegrationConnectInput;
+type SupportedConnectInput<T extends SidebarInput = SidebarInput> = Extract<T, {
+    type: SupportedConnectInputType;
+}>;
+/**
+ * A SerializedConnectInput is one that excludes the properties of a DynamicDataSource, which are
+ * loaded in at runtime rather than saved in the DB.
+ */
+type SerializedConnectInput<TInputType extends SupportedConnectInputType = SupportedConnectInputType> = {
+    [T in SupportedConnectInputType]: Extract<SupportedConnectInput, {
+        type: T;
+    }> extends {
+        source: DataSource;
+    } | {
+        getValues: Function;
+    } ? Omit<Extract<SupportedConnectInput, {
+        type: T;
+    }>, 'source' | 'getValues'> & {
+        /**
+         * If a Connect input is dynamic and uses a DynamicDataSource, `sourceType` will match the
+         * `cacheKey` property of the source specified in the action's sources module.
+         *
+         * If it uses a FieldMapperDataSource, `sourceType` will match the `id` property of the source.
+         */
+        sourceType?: string;
+        fallbackText?: string;
+    } : Extract<SupportedConnectInput, {
+        type: T;
+    }>;
+}[TInputType] & {
+    tooltip?: string;
+};
+type IntegrationWorkflowMetaMap = {
+    [id: string]: IntegrationWorkflowMeta;
+};
+type IntegrationWorkflowMeta = {
+    /**
+     * The ID of the WorkflowEntity.
+     */
+    id: string;
+    /**
+     * A longer-form description for the Workflow's functionality. Acts as a "subtitle" to the
+     * WorkflowEntity's `description` property.
+     */
+    infoText?: string;
+    /**
+     * Determine whether or not to enable workflow for connected user
+     *  @default false
+     */
+    defaultEnabled?: boolean;
+    /**
+     * Determines whether or not the workflow displays in the Connect Portal.
+     * @default false
+     */
+    hidden?: boolean;
+    /**
+     * An index to track the positional order of a workflow in the list of displayed workflows.
+     * If `order` is undefined, the workflow will be sorted by its `createdAt` property (after those
+     * that are sorted manually by `order`.)
+     */
+    order?: number;
+    /**
+     * Inputs to intake workflow-specific settings, configured in the Portal Editor.
+     */
+    inputs: SerializedConnectInput[];
+    /**
+     * Conditions to evaluate permission for endUser based on persona metadata.
+     */
+    permissions?: OrConditions;
+};
+export type DynamicMappingField = {
+    label: string;
+    value: string;
+};
+export type DynamicMappingOptions = {
+    fields: DynamicMappingField[];
+    userCanRemoveMappings?: boolean;
+    userCanCreateFields?: boolean;
+    defaultFields?: string[];
+};
+export type AuthenticatedConnectUser = {
+    authenticated: true;
+    token: string;
+    userId: string;
+    integrations: SDKIntegrationState;
+    meta: PersonaMeta;
+    resources: SDKResourceState[];
+};
+export type SDKResourceState = {
+    id: string;
+    slug: string;
+    credentialId?: string;
+    credentialStatus?: CredentialStatus;
+};
+export type SDKIntegration = {
+    enabled: boolean;
+    credentialId?: string;
+    credentialConfigId?: string;
+    credentialStatus?: CredentialStatus;
+    providerId?: string;
+    providerData?: ConnectCredentialProviderData;
+    allCredentials: IConnectCredential[];
+    allConfigurations: IConnectCredentialConfig[];
+} & SDKConnectCredentialConfig;
+export type SDKIntegrationConfig = {
+    oauthInputs: IntegrationConnectInput[];
+    accountTypes: AccountType[];
+    authConfigInputs: IntegrationConnectInput[];
+    postOauthInputs: IntegrationConnectInput[];
+    dataSources: {
+        [key: string]: DataSource;
+    };
+};
+/**
+ * The contents of the `integrations` field for an authenticated ConnectUser.
+ *
+ * The fields from `ConnectCredentialConfig` are stored; all other fields are computed from other
+ * available entities.
+ */
+export type SDKIntegrationState = Partial<Record<string, SDKIntegration>>;
+export type UninstallOptions = Pick<CredentialConfigOptions, 'selectedCredentialId'>;
+export type DisableWorkflowOptions = CredentialConfigOptions;
+/**
+ * method options for getIntegrationAccount in sdk
+ */
+export type GetIntegrationAccountOptions = {
+    includeAccountAuth?: boolean;
+    selectedCredentialId?: string;
+};
+export type IConnectUser = Omit<AuthenticatedConnectUser, 'token'>;
+export declare const INFER_CONTENT_TYPE_FROM_CONNECT_OPTIONS = "auto";
+export declare const SELECTED_CREDENTIAL_ID_HEADER = "X-Paragon-Credential";
+export declare const SELECTED_CREDENTIAL_CONFIG_ID_HEADER = "X-Paragon-Configuration-Id";
+export {};

package/dist/src/src/types/connectModal.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="react" />
+import { IPublishedCustomIntegration } from '../entities/customIntegration.interface';
+import { IConnectIntegrationWithCredentialInfo } from '../entities/integration.interface';
+import { AccountType } from './action';
+import { ModalConfig } from './connect';
+import { InstallOptions, ModalView } from './sdk';
+type ModalApiInstallationOptions = InstallOptions & {
+    selectedAccountConfig?: AccountType;
+};
+export type Props = {
+    integration: IConnectIntegrationWithCredentialInfo | null;
+    customIntegration?: IPublishedCustomIntegration;
+    config?: ModalConfig;
+    contentStyle?: React.CSSProperties;
+    overlayStyle?: React.CSSProperties;
+    popupProps?: Record<string, string>;
+    hideCross?: boolean;
+    tabView?: ModalView;
+    isPreviewMode?: boolean;
+    onBeforeEnableIntegration?: () => void | Promise<void>;
+    onClose?: () => void;
+    onOpen?: () => void;
+    onTabViewChange?: (view: ModalView) => void;
+    /**
+     * this flag is for controlling the enabling behavior from outside this component.
+     * It is currently used in BYO to show input settings while adding them live
+     */
+    previewSettings?: {
+        isEnabling: boolean;
+    };
+    apiInstallationOptions?: ModalApiInstallationOptions;
+    connectionError?: string;
+    selectedCredentialId?: string;
+};
+export {};

package/dist/src/src/types/environment.d.ts

@@ -0,0 +1,16 @@
+export declare enum NODE_ENV {
+    PRODUCTION = "production",
+    DEVELOPMENT = "development",
+    TEST = "test"
+}
+export declare enum PLATFORM_ENV {
+    PRODUCTION = "production",
+    PRODUCTION_MIRROR_1 = "p-m1",
+    STAGING = "staging",
+    STAGING_MIRROR_1 = "s-m1",
+    DEVELOPMENT = "dev",
+    TEST = "test",
+    SANDBOX = "sandbox",
+    RELEASE = "release",
+    ENTERPRISE = "enterprise"
+}

package/dist/src/src/types/execution.d.ts

@@ -0,0 +1,5 @@
+export type FanoutStackEntry = {
+    stepId: string;
+    instanceId: string;
+    index: number;
+};

package/dist/src/src/types/index.d.ts

@@ -0,0 +1,9 @@
+export * from './action';
+export * from './billing';
+export * from './connect';
+export * from './connectModal';
+export * from './environment';
+export * from './execution';
+export * from './resolvers';
+export * from './sdk';
+export * from './stripe';

package/dist/src/src/types/resolvers.d.ts

@@ -0,0 +1,297 @@
+/// <reference types="node" />
+import { TokenType } from './action';
+import { FanoutStackEntry } from './execution';
+export declare enum DataType {
+    STRING = "STRING",
+    NUMBER = "NUMBER",
+    DATE = "DATE",
+    BOOLEAN = "BOOLEAN",
+    EMAIL = "EMAIL",
+    OBJECT = "OBJECT",
+    ARRAY = "ARRAY",
+    ANY = "ANY",
+    FILE = "FILE",
+    NON_DECIMAL = "NON_DECIMAL"
+}
+export type TokenizedSource<T extends DataType = DataType> = {
+    dataType?: T;
+    type: 'TOKENIZED';
+    parts: TokenizedValue[];
+};
+type TokenizedValue<T extends DataType = DataType> = ValueSource<T> | VariableSource<T> | SecretSource | ConnectCredentialSource | ObjectValueSource | PersonaMetadataSource;
+type ObjectValueSource<T extends DataType = DataType> = {
+    type: 'OBJECT_VALUE';
+    name: string;
+    path: string[];
+    dataType?: T;
+};
+type VariableSource<T extends DataType = DataType> = {
+    dataType?: T;
+    type: 'VARIABLE';
+    stepId: string;
+    path: string[];
+};
+type SecretSource = {
+    type: 'ENVIRONMENT_SECRET';
+    environmentSecretId: string;
+};
+type ValueSource<T extends DataType = DataType> = {
+    dataType?: T;
+    type: 'VALUE';
+    value: DataTypeValues[T];
+};
+type ConnectCredentialSource = {
+    type: 'CONNECT_CREDENTIAL_FIELD';
+    fieldType: 'WORKFLOW_SETTING';
+    inputId: string;
+    /**
+     * @since PARA-3065: ConnectInputValue can now include more than a string/number type, so a
+     * path is specified similarly to VariableSource to traverse object types.
+     */
+    path?: string[];
+} | {
+    type: 'CONNECT_CREDENTIAL_FIELD';
+    fieldType: 'SHARED_WORKFLOW_SETTING';
+    inputId: string;
+    path?: string[];
+} | {
+    type: 'CONNECT_CREDENTIAL_FIELD';
+    fieldType: 'EXTERNAL_USER_ID';
+} | {
+    type: 'CONNECT_CREDENTIAL_FIELD';
+    fieldType: 'EXTERNAL_USER_PROVIDER_ID';
+} | {
+    type: 'CONNECT_CREDENTIAL_FIELD';
+    fieldType: 'OAUTH_ACCESS_TOKEN';
+} | {
+    type: 'CONNECT_CREDENTIAL_FIELD';
+    fieldType: 'EXTERNAL_USER_PROVIDER_DATA';
+    dataKey: string;
+};
+type PersonaMetadataSource = {
+    type: 'PERSONA_METADATA';
+    path?: string[];
+};
+type DataTypeValues = {
+    [DataType.STRING]: string;
+    [DataType.NUMBER]: number;
+    [DataType.DATE]: Date;
+    [DataType.BOOLEAN]: boolean;
+    [DataType.EMAIL]: string;
+    [DataType.OBJECT]: object;
+    [DataType.ARRAY]: any[];
+    [DataType.ANY]: any;
+    [DataType.FILE]: FileValue;
+    [DataType.NON_DECIMAL]: number;
+};
+type FileDataType = Buffer;
+type FileValue = {
+    data: FileDataType;
+    dataType: DataType.FILE;
+    encoding?: string;
+    id?: string;
+    mimeType?: string;
+    name?: string;
+    size?: string;
+};
+export type KeyedSource<T extends DataType = DataType> = {
+    key: string;
+    source: Source<T>;
+};
+export type Source<T extends DataType = DataType> = ValueSource<T> | VariableSource<T> | TokenizedSource<T> | ConditionSource | SecretSource | ExecutionSource | FanoutExecutionSource | UserSuppliedCredentialSource | ConnectCredentialSource | ObjectValueSource | PersonaMetadataSource;
+type ConditionSource = {
+    type: 'CONDITION';
+    condition: ConditionWrapper;
+};
+type ConditionWrapper = JoinedConditions | OperatorCondition;
+type JoinedConditions = AndConditions | OrConditions;
+type AndConditions = {
+    type: 'JOIN';
+    join: 'AND';
+    conditions: ConditionWrapper[];
+};
+export type OrConditions = {
+    type: 'JOIN';
+    join: 'OR';
+    conditions: ConditionWrapper[];
+};
+type OperatorCondition = {
+    type: 'OPERATOR';
+    condition: Condition;
+};
+type Condition = {
+    operator: Operator.None;
+    variable: Source<DataType.ANY>;
+} | {
+    operator: Operator.StringContains;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringDoesNotContain;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringExactlyMatches;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringDoesNotExactlyMatch;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringIsIn;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringIsNotIn;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringStartsWith;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringDoesNotStartWith;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringEndsWith;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringDoesNotEndWith;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.NumberGreaterThan;
+    variable: Source<DataType.NUMBER>;
+    argument: Source<DataType.NUMBER>;
+} | {
+    operator: Operator.NumberLessThan;
+    variable: Source<DataType.NUMBER>;
+    argument: Source<DataType.NUMBER>;
+} | {
+    operator: Operator.NumberGreaterThanOrEqualTo;
+    variable: Source<DataType.NUMBER>;
+    argument: Source<DataType.NUMBER>;
+} | {
+    operator: Operator.NumberLessThanOrEqualTo;
+    variable: Source<DataType.NUMBER>;
+    argument: Source<DataType.NUMBER>;
+} | {
+    operator: Operator.NumberEquals;
+    variable: Source<DataType.NUMBER>;
+    argument: Source<DataType.NUMBER>;
+} | {
+    operator: Operator.NumberDoesNotEqual;
+    variable: Source<DataType.NUMBER>;
+    argument: Source<DataType.NUMBER>;
+} | {
+    operator: Operator.DateTimeAfter;
+    variable: Source<DataType.DATE>;
+    argument: Source<DataType.DATE>;
+} | {
+    operator: Operator.DateTimeBefore;
+    variable: Source<DataType.DATE>;
+    argument: Source<DataType.DATE>;
+} | {
+    operator: Operator.DateTimeEquals;
+    variable: Source<DataType.DATE>;
+    argument: Source<DataType.DATE>;
+} | {
+    operator: Operator.BooleanTrue;
+    variable: Source<DataType.BOOLEAN>;
+} | {
+    operator: Operator.BooleanFalse;
+    variable: Source<DataType.BOOLEAN>;
+} | {
+    operator: Operator.IsNull;
+    variable: Source;
+} | {
+    operator: Operator.IsNotNull;
+    variable: Source;
+} | {
+    operator: Operator.Exists;
+    variable: Source;
+} | {
+    operator: Operator.DoesNotExist;
+    variable: Source;
+} | {
+    operator: Operator.ArrayIsEmpty;
+    variable: Source<DataType.ARRAY>;
+} | {
+    operator: Operator.ArrayIsNotEmpty;
+    variable: Source<DataType.ARRAY>;
+} | {
+    operator: Operator.StringGreaterThan;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringLessThan;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+};
+declare enum Operator {
+    'None' = "$none",
+    'StringContains' = "$stringContains",
+    'StringDoesNotContain' = "$stringDoesNotContain",
+    'StringExactlyMatches' = "$stringExactlyMatches",
+    'StringDoesNotExactlyMatch' = "$stringDoesNotExactlyMatch",
+    'StringIsIn' = "$stringIsIn",
+    'StringIsNotIn' = "$stringIsNotIn",
+    'StringStartsWith' = "$stringStartsWith",
+    'StringDoesNotStartWith' = "$stringDoesNotStartWith",
+    'StringEndsWith' = "$stringEndsWith",
+    'StringDoesNotEndWith' = "$stringDoesNotEndWith",
+    'NumberGreaterThan' = "$numberGreaterThan",
+    'NumberLessThan' = "$numberLessThan",
+    'NumberEquals' = "$numberEquals",
+    'NumberDoesNotEqual' = "$numberDoesNotEqual",
+    'NumberLessThanOrEqualTo' = "$numberLessThanOrEqualTo",
+    'NumberGreaterThanOrEqualTo' = "$numberGreaterThanOrEqualTo",
+    'DateTimeAfter' = "$dateTimeAfter",
+    'DateTimeBefore' = "$dateTimeBefore",
+    'DateTimeEquals' = "$dateTimeEquals",
+    'BooleanTrue' = "$booleanTrue",
+    'BooleanFalse' = "$booleanFalse",
+    /** (PARA-5551) previously operators for Does Exist / Does Not Exist do a strict check for equality to null, resulting in a bug where value is undefined
+     * to handle this situation, we are adding 2 new operators IsNotNull and IsNull and changing functionality of
+     * Exist and DoesNotExist operators to handle undefined values
+     */
+    'IsNotNull' = "$exists",
+    'IsNull' = "$doesNotExist",
+    'Exists' = "$isNotUndefinedOrNull",
+    'DoesNotExist' = "$isUndefinedOrNull",
+    'ArrayIsIn' = "$arrayIsIn",
+    'ArrayIsNotIn' = "$arrayIsNotIn",
+    'ArrayIsEmpty' = "$arrayIsEmpty",
+    'ArrayIsNotEmpty' = "$arrayIsNotEmpty",
+    'StringGreaterThan' = "$stringGreaterThan",
+    'StringLessThan' = "$stringLessThan"
+}
+type ExecutionSource = {
+    type: 'EXECUTION';
+    id: string;
+    stepId: string;
+    /**
+     * a timestamp representing when the execution occurred
+     */
+    start: number;
+    fanoutStack: FanoutStackEntry[];
+    /**
+     * This flag suggests that the content of the variable will be stored on remmote storage service
+     * such as s3
+     */
+    remoteCached?: boolean;
+};
+type FanoutExecutionSource = {
+    type: 'FANOUT_EXECUTION';
+    stepId: string;
+};
+type UserSuppliedCredentialSource = {
+    type: 'USER_SUPPLIED_CREDENTIAL';
+    tokenType: TokenType;
+    providerType: string;
+    credential: TokenizedSource<DataType.STRING>;
+};
+export {};