@integration-app/react 0.1.1 → 0.1.2

package/node_modules/@integration-app/sdk/src/errors.ts

@@ -1,154 +0,0 @@
-export enum ErrorType {
-  BAD_REQUEST = 'bad_request', // Something is wrong with the input received by the API.
-  CONNECTION = 'connection', // An error with a Connection.
-  FLOW_CONFIGURATION = 'flow_configuration', // Incorrect / broken flow configuration.
-  FLOW_RUN = 'flow_run', // Erorr with the flow's runtime data that prevents it from being completed.
-  INTERNAL = 'internal', // Error within an engine (catch-all).
-}
-
-export enum BadRequestErrorKey {
-  NOT_FOUND = 'not_found',
-  NOT_AUTHENTICATED = 'not_authenticated',
-  ACCESS_DENIED = 'access_denied',
-  ALREADY_EXISTS = 'already_exists',
-}
-
-export enum ConnectionErrorKey {
-  CONNECTION_IS_DEFUNCT = 'connection_is_defunct',
-  ACCESS_TOKEN_EXPIRED = 'access_token_expired',
-}
-
-interface ErrorDataFields {
-  type?: ErrorType
-  key?: string
-  message: string
-  data?: any
-  stack?: any
-  causedByError?: ErrorData
-}
-
-type ErrorConstructorArg = string | ErrorDataFields | Error
-
-export function isIntegrationAppError(error) {
-  return error && error.isIntegrationAppError
-}
-
-export class ErrorData implements ErrorDataFields {
-  constructor(arg: ErrorConstructorArg) {
-    if (arg instanceof Error) {
-      this.message = arg.message
-      this.stack = arg.stack
-      this.type = ErrorType.INTERNAL
-    } else if (typeof arg === 'string') {
-      this.message = arg
-      this.type = ErrorType.INTERNAL
-    } else if (typeof arg === 'object' && arg !== null) {
-      Object.assign(this, arg)
-    } else {
-      throw new Error(
-        'Invalid argument when creating BaseErrorData: ' + JSON.stringify(arg),
-      )
-    }
-  }
-}
-
-export interface ErrorData extends ErrorDataFields {}
-
-export class IntegrationAppError extends Error {
-  public isIntegrationAppError: true
-  public data: ErrorData
-
-  constructor(arg: ErrorConstructorArg) {
-    const errorData = new ErrorData(arg)
-    super(errorData.message)
-    this.isIntegrationAppError = true
-    this.data = errorData
-
-    if (!this.data.type) {
-      this.data.type = ErrorType.INTERNAL
-    }
-  }
-}
-
-export class InternalError extends IntegrationAppError {
-  constructor(arg: ErrorConstructorArg) {
-    super(arg)
-    this.data.type = ErrorType.INTERNAL
-  }
-}
-
-export class BadRequestError extends IntegrationAppError {
-  constructor(arg: ErrorConstructorArg) {
-    super(arg)
-    this.data.type = ErrorType.BAD_REQUEST
-  }
-}
-
-export class FlowConfigurationError extends BadRequestError {
-  constructor(arg: ErrorConstructorArg) {
-    super(arg)
-    this.data.type = ErrorType.FLOW_CONFIGURATION
-  }
-}
-
-export class FlowRunError extends IntegrationAppError {
-  constructor(arg: ErrorConstructorArg) {
-    super(arg)
-    this.data.type = ErrorType.FLOW_RUN
-  }
-}
-
-export class ConnectionError extends IntegrationAppError {
-  constructor(arg: ErrorConstructorArg) {
-    super(arg)
-    this.data.type = ErrorType.CONNECTION
-  }
-}
-
-export class NotFoundError extends BadRequestError {
-  constructor(arg: ErrorConstructorArg) {
-    super(arg)
-    this.data.key = BadRequestErrorKey.NOT_FOUND
-  }
-}
-
-export class NotAuthenticatedError extends BadRequestError {
-  constructor(arg: ErrorConstructorArg) {
-    super(arg)
-    this.data.key = BadRequestErrorKey.NOT_AUTHENTICATED
-  }
-}
-
-export class AccessDeniedError extends BadRequestError {
-  constructor(arg: ErrorConstructorArg) {
-    super(arg)
-    this.data.key = BadRequestErrorKey.ACCESS_DENIED
-  }
-}
-
-export function getErrorFromData(data: any) {
-  if (
-    typeof data === 'object' &&
-    data !== null &&
-    Object.values(ErrorType).includes(data.type)
-  ) {
-    return new IntegrationAppError(data)
-  }
-  return null
-}
-
-export function extractIntegrationAppErrorData(error: any) {
-  const data: ErrorData = error.isIntegrationAppError
-    ? (error as IntegrationAppError).data
-    : new ErrorData({
-        message: error.message,
-        type: ErrorType.INTERNAL,
-      })
-  if (!data.message) {
-    data.message = error.message
-  }
-  if (!data.stack) {
-    data.stack = error.stack
-  }
-  return data
-}

package/node_modules/@integration-app/sdk/src/field-mappings/accessors.ts

@@ -1,100 +0,0 @@
-import { FieldMapping, FieldMappingInstance } from '.'
-import { IntegrationAppClient } from '..'
-import {
-  FindFieldMappingInstancesQuery,
-  FindFieldMappingsQuery,
-  FieldMappingInstanceSelector,
-  UpdateFieldMappingInstanceRequest,
-  UpdateFieldMappingRequest,
-  CreateFieldMappingInstanceRequest,
-  CreateFieldMappingRequest,
-} from './api'
-import { OpenConfigurationOptions, openIframe } from '../iframe'
-import {
-  ElementAccessor,
-  ElementInstanceAccessor,
-  ElementInstanceListAccessor,
-  ElementListAccessor,
-} from '../accessors'
-
-interface OpenFieldMappingInstanceConfigurationOptions
-  extends OpenConfigurationOptions {}
-
-export class FieldMappingsAccessor extends ElementListAccessor<
-  FieldMapping,
-  FindFieldMappingsQuery,
-  CreateFieldMappingRequest
-> {
-  constructor(client: IntegrationAppClient) {
-    super(client, 'field-mappings')
-  }
-}
-
-export class FieldMappingAccessor extends ElementAccessor<
-  FieldMapping,
-  CreateFieldMappingRequest,
-  UpdateFieldMappingRequest
-> {
-  constructor(client: IntegrationAppClient, idOrKey: string) {
-    super({
-      client,
-      path: 'field-mappings',
-      idOrKey,
-    })
-  }
-}
-
-export class FieldMappingInstancesAccessor extends ElementInstanceListAccessor<
-  FieldMappingInstance,
-  FindFieldMappingInstancesQuery
-> {
-  constructor(client: IntegrationAppClient) {
-    super(client, 'field-mapping-instances')
-  }
-}
-
-export class FieldMappingInstanceAccessor extends ElementInstanceAccessor<
-  FieldMappingInstance,
-  FieldMappingInstanceSelector,
-  CreateFieldMappingInstanceRequest,
-  UpdateFieldMappingInstanceRequest
-> {
-  constructor(
-    private client: IntegrationAppClient,
-    selector: string | FieldMappingInstanceSelector,
-  ) {
-    super({
-      client,
-      listPath: 'field-mapping-instances',
-      selectorPath: 'field-mapping-instance',
-      selector,
-    })
-  }
-
-  async get(): Promise<FieldMappingInstance> {
-    const data = await super.get()
-    return new FieldMappingInstance(data)
-  }
-
-  async setup(): Promise<void> {
-    const id = await this.getId()
-    return this.client.post(`/field-mapping-instances/${id}/setup`)
-  }
-
-  async reset(): Promise<void> {
-    const id = await this.getId()
-    return this.client.post(`/field-mapping-instances/${id}/reset`)
-  }
-
-  async openConfiguration(
-    options?: OpenFieldMappingInstanceConfigurationOptions,
-  ): Promise<void> {
-    const id = await this.getId()
-    const uri = this.client.getEmbedUri(
-      `/field-mapping-instances/${id}/configuration`,
-    )
-    return openIframe(uri, {
-      onClose: options?.onClose,
-    })
-  }
-}

package/node_modules/@integration-app/sdk/src/field-mappings/api.ts

@@ -1,61 +0,0 @@
-import { PaginationQuery, PaginationResponse } from '../entity-repository'
-import {
-  AdHocFieldMapping,
-  FieldMapping,
-  FieldMappingInstance,
-  IFieldMappingInstanceConfig,
-} from '.'
-import { ConnectionSelector } from '../connections/api'
-
-export interface FindFieldMappingsQuery extends PaginationQuery {}
-
-export type FindFieldMappingsResponse = PaginationResponse<FieldMapping>
-
-export interface FindFieldMappingInstancesQuery extends PaginationQuery {
-  userId?: string
-
-  fieldMappingId?: string
-
-  connectionId?: string
-}
-
-export type FindFieldMappingInstancesResponse =
-  PaginationResponse<FieldMappingInstance>
-
-export type CreateFieldMappingRequest = Omit<FieldMapping, 'id'>
-
-export type UpdateFieldMappingRequest = Partial<CreateFieldMappingRequest>
-
-export interface CreateFieldMappingInstanceRequest {
-  connectionId: string
-
-  fieldMappingId?: string
-
-  adHocFieldMapping?: AdHocFieldMapping
-
-  instanceKey?: string
-
-  externalElementInstanceKey?: string
-
-  appElementInstanceKey?: string
-
-  config?: IFieldMappingInstanceConfig
-}
-
-export interface UpdateFieldMappingInstanceRequest {
-  config?: IFieldMappingInstanceConfig
-}
-
-export interface FieldMappingInstanceSelector extends ConnectionSelector {
-  fieldMappingKey?: string
-
-  fieldMappingId?: string
-
-  externalElementInstanceKey?: string
-
-  appElementInstanceKey?: string
-
-  instanceKey?: string
-
-  autoCreate?: boolean
-}

package/node_modules/@integration-app/sdk/src/field-mappings/index.ts

@@ -1,341 +0,0 @@
-import {
-  IntegrationElement,
-  IntegrationElementInstance,
-} from '../integration-elements'
-import { User } from '../users'
-import { Connection } from '../connections'
-import { Integration } from '../integrations'
-import {
-  getLocatorsFromSchema,
-  getSchemaByLocator,
-  getValueAtLocator,
-  locatorToField,
-  setValueAtLocator,
-} from '../data-builder/locators'
-import { DataBuilderFormulaType, getFormula } from '../data-builder/formulas'
-import { DataBuilderFormulaVar } from '../data-builder/formulas/var'
-import { ErrorData } from '../errors'
-import { populateSchemaTitles } from '../data-schema'
-
-export enum FieldMappingDirection {
-  IMPORT = 'import',
-  EXPORT = 'export',
-  BOTH = 'both',
-}
-
-export interface FieldMapping {
-  id: string
-
-  name: string
-
-  key: string
-
-  externalElement: IntegrationElement
-
-  appElement: IntegrationElement
-
-  direction: FieldMappingDirection
-
-  defaultImportValue?: any
-
-  defaultExportValue?: any
-
-  archivedAt?: Date
-}
-
-export interface AdHocFieldMapping {
-  direction: FieldMappingDirection
-  appElement?: IntegrationElement
-  externalElement?: IntegrationElement
-  defaultExportValue?: any
-  defaultImportValue?: any
-}
-
-export interface IFieldMappingInstanceConfig {
-  importValue?: any
-  exportValue?: any
-}
-
-export interface IFieldMappingInstance {
-  id: string
-
-  userId: string
-
-  user?: User
-
-  connectionId: string
-
-  connection?: Connection
-
-  integrationId: string
-
-  integration?: Integration
-
-  fieldMappingId?: string
-
-  fieldMapping?: FieldMapping
-
-  instanceKey?: string
-
-  adHocFieldMapping?: AdHocFieldMapping
-
-  externalElementInstanceKey?: string
-
-  externalElementInstance?: IntegrationElementInstance
-
-  externalSchema?: any
-
-  appElementInstanceKey?: string
-
-  appElementInstance?: IntegrationElementInstance
-
-  appSchema?: any
-
-  /**
-   * Value used for app element fields. Can use external element fields in its formulas.
-   * Calculated based on defaultImportValue and `config`.
-   */
-  importValue?: any
-
-  /**
-   * Value used for external element fields. Can use app element fields in its formulas.
-   * Calculated based on defaultExportValue and `config`.
-   */
-  exportValue?: any
-
-  /**
-   * Default value for `importValue` if none set by the user.
-   */
-  defaultImportValue?: any
-
-  /**
-   * Default value for `exportValue` if none set by the user.
-   */
-  defaultExportValue?: any
-
-  config?: IFieldMappingInstanceConfig
-
-  error?: ErrorData
-}
-
-export interface FieldMappingInstance extends IFieldMappingInstance {}
-
-export interface FieldLink {
-  externalField: string
-  appField: string
-  direction: FieldMappingDirection
-}
-
-interface GetExternalFieldsOptions {
-  includeSubfields?: boolean
-  includeUnifiedFields?: boolean
-}
-
-export class FieldMappingInstance {
-  constructor(data: FieldMappingInstance) {
-    Object.assign(this, data)
-    populateSchemaTitles(this.appSchema)
-    populateSchemaTitles(this.externalSchema)
-  }
-
-  getAppFields(): string[] {
-    return this.getFieldsFromSchema(this.appSchema)
-  }
-
-  getExternalFields(options: GetExternalFieldsOptions = {}): string[] {
-    return this.getFieldsFromSchema(this.externalSchema, options)
-  }
-
-  getAppFieldSchema(field: string) {
-    return getSchemaByLocator(this.appSchema, field)
-  }
-
-  getExternalFieldSchema(field: string) {
-    return getSchemaByLocator(this.externalSchema, field)
-  }
-
-  setImportValue(value: any) {
-    this.config = {
-      ...(this.config ?? {}),
-      importValue: value,
-    }
-  }
-
-  setExportValue(value: any) {
-    this.config = {
-      ...(this.config ?? {}),
-      exportValue: value,
-    }
-  }
-
-  patchConfig(patch: any) {
-    if (typeof patch === 'object') {
-      this.config = {
-        ...(this.config ?? {}),
-        ...(patch ?? {}),
-      }
-    }
-  }
-
-  setImportValueForField(field: string, value: any) {
-    const newImportValue = setValueAtLocator(this.importValue, field, value)
-    this.patchConfig({
-      importValue: newImportValue,
-    })
-    this.importValue = newImportValue
-  }
-
-  setExportValueForField(field: string, value: any) {
-    const newExportValue = setValueAtLocator(this.exportValue, field, value)
-    this.patchConfig({
-      exportValue: newExportValue,
-    })
-    this.exportValue = newExportValue
-  }
-
-  getAppFieldLink(field: string): string {
-    const importFieldValue = getValueAtLocator(this.importValue, field)
-    const formula = getFormula(importFieldValue)
-    if (formula && formula.type === DataBuilderFormulaType.VAR) {
-      const externalField = (formula as DataBuilderFormulaVar).locator
-      return locatorToField(externalField)
-    } else {
-      return null
-    }
-  }
-
-  getAppFieldLinks(): Record<string, string> {
-    const result = {}
-    this.getAppFields().forEach((field) => {
-      const link = this.getAppFieldLink(field)
-      if (link) {
-        result[field] = link
-      }
-    })
-    return result
-  }
-
-  getExternalFieldLinks(): Record<string, string> {
-    const result = {}
-    this.getExternalFields().forEach((field) => {
-      const link = this.getExternalFieldLink(field)
-      if (link) {
-        result[field] = link
-      }
-    })
-    return result
-  }
-
-  getExternalFieldLink(field: string): string {
-    const exportFieldValue = getValueAtLocator(this.exportValue, field)
-    const formula = getFormula(exportFieldValue)
-    if (formula && formula.type === DataBuilderFormulaType.VAR) {
-      const appField = (formula as DataBuilderFormulaVar).locator
-      return locatorToField(appField)
-    } else {
-      return null
-    }
-  }
-
-  getFieldLinks(): FieldLink[] {
-    const appFieldLinks = this.getAppFieldLinks()
-    const externalFieldLinks = this.getExternalFieldLinks()
-    const results: FieldLink[] = []
-    for (const [appField, externalField] of Object.entries(appFieldLinks)) {
-      const matchingExternalLink = externalFieldLinks[externalField]
-      if (matchingExternalLink == appField) {
-        results.push({
-          appField,
-          externalField,
-          direction: FieldMappingDirection.BOTH,
-        })
-        delete externalFieldLinks[externalField]
-      } else {
-        results.push({
-          appField,
-          externalField,
-          direction: FieldMappingDirection.IMPORT,
-        })
-      }
-    }
-    for (const [externalField, appField] of Object.entries(
-      externalFieldLinks,
-    )) {
-      results.push({
-        appField,
-        externalField,
-        direction: FieldMappingDirection.EXPORT,
-      })
-    }
-    return results
-  }
-
-  /**
-   * @deprecated
-   */
-  setFieldLink(link: FieldLink) {
-    this.addFieldLink(link)
-  }
-
-  addFieldLink(link: FieldLink) {
-    const { appField, externalField, direction } = link
-
-    const isImport =
-      direction === FieldMappingDirection.IMPORT ||
-      direction === FieldMappingDirection.BOTH
-    const isExport =
-      direction === FieldMappingDirection.EXPORT ||
-      direction === FieldMappingDirection.BOTH
-
-    if (appField) {
-      if (isImport) {
-        this.setImportValueForField(appField, {
-          $var: externalField,
-        })
-      } else {
-        this.setImportValueForField(appField, null)
-      }
-    }
-
-    if (externalField) {
-      if (isExport) {
-        this.setExportValueForField(externalField, { $var: appField })
-      } else {
-        this.setExportValueForField(externalField, null)
-      }
-    }
-  }
-
-  removeFieldLink(link: FieldLink) {
-    const { appField, externalField, direction } = link
-
-    const isImport =
-      direction === FieldMappingDirection.IMPORT ||
-      direction === FieldMappingDirection.BOTH
-    const isExport =
-      direction === FieldMappingDirection.EXPORT ||
-      direction === FieldMappingDirection.BOTH
-
-    if (appField && isImport) {
-      this.setImportValueForField(appField, null)
-    }
-    if (externalField && isExport) {
-      this.setExportValueForField(externalField, null)
-    }
-  }
-
-  private getFieldsFromSchema(schema, options: GetExternalFieldsOptions = {}) {
-    let fields = getLocatorsFromSchema(schema)
-    fields = fields.map(locatorToField)
-    if (!options.includeSubfields) {
-      fields = fields.filter(
-        (f) =>
-          !f.replace('fields.', '').replace('unifiedFields.', '').includes('.'),
-      )
-    }
-    if (!options.includeUnifiedFields) {
-      fields = fields.filter((f) => !f.startsWith('unifiedFields'))
-    }
-    return fields
-  }
-}

package/node_modules/@integration-app/sdk/src/flow-runs/flow-node-runs.ts

@@ -1,53 +0,0 @@
-import { ErrorData } from '../errors'
-import { PaginationResponse, PaginationQuery } from '../entity-repository'
-
-export enum FlowNodeRunState {
-  RUNNING = 'running',
-  COMPLETED = 'completed',
-  FAILED = 'failed',
-}
-
-export const FLOW_NODE_RUN_CHANNEL_PREFIX = 'private-flow-node-runs-'
-
-export interface FlowNodeRun {
-  id: string
-
-  flowInstanceId: string
-
-  nodeKey: string
-
-  flowRunId?: string
-
-  input?: any
-
-  /**
-   * Node run that feeds into this node run.
-   */
-  previousFlowNodeRunId: string
-
-  state: FlowNodeRunState
-
-  startTime: Date
-
-  endTime?: Date
-
-  /**
-   * List of errors that happened during this run.
-   */
-  errors?: ErrorData[]
-}
-
-export interface CreateFlowNodeRunRequest {
-  flowInstanceId: string
-
-  nodeKey: string
-
-  input?: any
-}
-
-export interface FlowNodeRunsQuery extends PaginationQuery {
-  flowRunId: string
-}
-
-export interface FindFlowNodeRunsResponse
-  extends PaginationResponse<FlowNodeRun> {}