@integration-app/react 0.1.1

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

@@ -0,0 +1,154 @@
+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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,341 @@
+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

@@ -0,0 +1,53 @@
+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> {}