@integration-app/react 0.1.1

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

@@ -0,0 +1,7 @@
+import { User } from '../users'
+import { Workspace } from '../workspaces'
+
+export interface Self {
+  user: User
+  workspace: Workspace
+}

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

@@ -0,0 +1,6 @@
+/**
+ * For loading via <script> tag and for people who just want to `import IntegraionApp from '@integration-app/sdk'`
+ */
+import { IntegrationAppClient } from './client'
+
+module.exports = new IntegrationAppClient({})

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

@@ -0,0 +1,417 @@
+import Pusher, { Channel } from 'pusher-js'
+import Axios, { AxiosError, AxiosRequestConfig } from 'axios'
+import _ from 'lodash'
+import {
+  ConnectionAccessor,
+  ConnectionsAccessor,
+} from './connections/accessors'
+import {
+  FlowInstanceAccessor,
+  FlowAccessor,
+  FlowInstancesAccessor,
+  FlowsAccessor,
+} from './flows/accessors'
+import { getErrorFromData } from './errors'
+import { isJWT } from './jwt'
+import { FlowRunAccessor, FlowRunsAccessor } from './flow-runs'
+import {
+  DataLinkTableInstanceAccessor,
+  DataLinkTableAccessor,
+  DataLinkTableInstancesAccessor,
+  DataLinkTablesAccessor,
+} from './data-links/accessors'
+import {
+  IntegrationsAccessor,
+  IntegrationAccessor,
+} from './integrations/accessors'
+import { ConnectionSelector } from './connections/api'
+import {
+  FieldMappingAccessor,
+  FieldMappingInstanceAccessor,
+  FieldMappingsAccessor,
+  FieldMappingInstancesAccessor,
+} from './field-mappings/accessors'
+import {
+  DataSourcesAccessor,
+  DataSourceAccessor,
+  DataSourceInstancesAccessor,
+  DataSourceInstanceAccessor,
+} from './data-sources/accessors'
+import { FlowInstanceSelector } from './flows/api'
+import { FieldMappingInstanceSelector } from './field-mappings/api'
+import { DataSourceInstanceSelector } from './data-sources/api'
+import { DataLinkTableInstanceSelector } from './data-links/api'
+import {
+  AppEventSubscriptionAccessor,
+  AppEventSubscriptionsAccessor,
+  AppEventTypeAccessor,
+  AppEventTypesAccessor,
+} from './app-events/accessors'
+import { AppEventSubscriptionSelector } from './app-events/api'
+import {
+  AppDataCollectionsAccessor,
+  AppDataCollectionAccessor,
+  AppDataCollectionInstancesAccessor,
+  AppDataCollectionInstanceAccessor,
+} from './app-data-collections/accessors'
+import { AppDataCollectionInstanceSelector } from './app-data-collections/api'
+import {
+  AppDataSchemasAccessor,
+  AppDataSchemaAccessor,
+  AppDataSchemaInstancesAccessor,
+} from './app-data-schemas/accessors'
+import { SelfAccessor } from './auth/accessors'
+import { DataLocationSelector } from './data-locations/api'
+import { DataLocationAccessor } from './data-locations/accessors'
+
+const DEFAULT_API_URI = 'https://engine-api.integration.app'
+const DEFAULT_UI_URI = 'https://ui.integration.app'
+
+export class IntegrationAppClient {
+  public apiUri?: string
+  public uiUri?: string
+  public token: string
+  private pusher: Pusher | undefined
+  private pusherChannels: Record<string, Channel> = {}
+
+  constructor(options: IntegrationAppClientOptions) {
+    this.init(options)
+  }
+
+  public async get(uri: string, queryParams?: Record<string, any>) {
+    if (queryParams) {
+      uri += `?${new URLSearchParams(queryParams).toString()}`
+    }
+    return this.makeApiRequest('GET', { url: uri })
+  }
+
+  public async post(uri: string, data?: any) {
+    return this.makeApiRequest('POST', { url: uri, data })
+  }
+
+  public async put(uri: string, data?: any) {
+    return this.makeApiRequest('PUT', { url: uri, data })
+  }
+
+  public async patch(uri: string, data?: any) {
+    return this.makeApiRequest('PATCH', { url: uri, data })
+  }
+
+  public async delete(uri: string) {
+    return this.makeApiRequest('DELETE', { url: uri })
+  }
+
+  get self(): SelfAccessor {
+    return new SelfAccessor(this)
+  }
+
+  get flows(): FlowsAccessor {
+    return new FlowsAccessor(this)
+  }
+
+  flow(keyOrId: string): FlowAccessor {
+    return new FlowAccessor(this, keyOrId)
+  }
+
+  get flowInstances(): FlowInstancesAccessor {
+    return new FlowInstancesAccessor(this)
+  }
+
+  flowInstance(selector: string | FlowInstanceSelector): FlowInstanceAccessor {
+    return new FlowInstanceAccessor(this, selector)
+  }
+
+  get dataSources(): DataSourcesAccessor {
+    return new DataSourcesAccessor(this)
+  }
+
+  dataSource(idOrKey: string): DataSourceAccessor {
+    return new DataSourceAccessor(this, idOrKey)
+  }
+
+  get dataSourceInstances(): DataSourceInstancesAccessor {
+    return new DataSourceInstancesAccessor(this)
+  }
+
+  dataSourceInstance(
+    selector: string | DataSourceInstanceSelector,
+  ): DataSourceInstanceAccessor {
+    return new DataSourceInstanceAccessor(this, selector)
+  }
+
+  get fieldMappings(): FieldMappingsAccessor {
+    return new FieldMappingsAccessor(this)
+  }
+
+  fieldMapping(idOrKey: string): FieldMappingAccessor {
+    return new FieldMappingAccessor(this, idOrKey)
+  }
+
+  get fieldMappingInstances(): FieldMappingInstancesAccessor {
+    return new FieldMappingInstancesAccessor(this)
+  }
+
+  fieldMappingInstance(
+    selector: string | FieldMappingInstanceSelector,
+  ): FieldMappingInstanceAccessor {
+    return new FieldMappingInstanceAccessor(this, selector)
+  }
+
+  get dataLinkTables(): DataLinkTablesAccessor {
+    return new DataLinkTablesAccessor(this)
+  }
+
+  dataLinkTable(idOrKey: string): DataLinkTableAccessor {
+    return new DataLinkTableAccessor(this, idOrKey)
+  }
+
+  get dataLinkTableInstances(): DataLinkTableInstancesAccessor {
+    return new DataLinkTableInstancesAccessor(this)
+  }
+
+  dataLinkTableInstance(
+    selector: string | DataLinkTableInstanceSelector,
+  ): DataLinkTableInstanceAccessor {
+    return new DataLinkTableInstanceAccessor(this, selector)
+  }
+
+  get integrations(): IntegrationsAccessor {
+    return new IntegrationsAccessor(this)
+  }
+
+  integration(identifier: string): IntegrationAccessor {
+    return new IntegrationAccessor(this, identifier)
+  }
+
+  get connections(): ConnectionsAccessor {
+    return new ConnectionsAccessor(this)
+  }
+
+  connection(selector: string | ConnectionSelector): ConnectionAccessor {
+    return new ConnectionAccessor(this, selector)
+  }
+
+  dataLocation(selector: DataLocationSelector): DataLocationAccessor {
+    return new DataLocationAccessor(this, selector)
+  }
+
+  get appEventTypes(): AppEventTypesAccessor {
+    return new AppEventTypesAccessor(this)
+  }
+
+  appEventType(idOrKey: string): AppEventTypeAccessor {
+    return new AppEventTypeAccessor(this, idOrKey)
+  }
+
+  get appEventSubscriptions(): AppEventSubscriptionsAccessor {
+    return new AppEventSubscriptionsAccessor(this)
+  }
+
+  appEventSubscription(
+    selector: string | AppEventSubscriptionSelector,
+  ): AppEventSubscriptionAccessor {
+    return new AppEventSubscriptionAccessor(this, selector)
+  }
+
+  get flowRuns(): FlowRunsAccessor {
+    return new FlowRunsAccessor(this)
+  }
+
+  flowRun(id: string): FlowRunAccessor {
+    return new FlowRunAccessor(this, id)
+  }
+
+  get appDataCollections(): AppDataCollectionsAccessor {
+    return new AppDataCollectionsAccessor(this)
+  }
+
+  appDataCollection(idOrKey: string): AppDataCollectionAccessor {
+    return new AppDataCollectionAccessor(this, idOrKey)
+  }
+
+  get appDataCollectionInstances(): AppDataCollectionInstancesAccessor {
+    return new AppDataCollectionInstancesAccessor(this)
+  }
+
+  appDataCollectionInstance(
+    selector: string | AppDataCollectionInstanceSelector,
+  ): AppDataCollectionInstanceAccessor {
+    return new AppDataCollectionInstanceAccessor(this, selector)
+  }
+
+  get appDataSchemas(): AppDataSchemasAccessor {
+    return new AppDataSchemasAccessor(this)
+  }
+
+  appDataSchema(idOrKey: string): AppDataSchemaAccessor {
+    return new AppDataSchemaAccessor(this, idOrKey)
+  }
+
+  get appDataSchemaInstances(): AppDataSchemaInstancesAccessor {
+    return new AppDataSchemaInstancesAccessor(this)
+  }
+
+  appDataSchemaInstance(
+    selector: string | AppDataCollectionInstanceSelector,
+  ): AppDataCollectionInstanceAccessor {
+    return new AppDataCollectionInstanceAccessor(this, selector)
+  }
+
+  public init(options: IntegrationAppClientOptions) {
+    const token = options.token ?? options.accessToken
+    if (token !== undefined && !isJWT(token))
+      throw new Error('Access token should be a valid JWT token')
+
+    this.apiUri = options.apiUri || DEFAULT_API_URI
+    this.uiUri = options.uiUri || DEFAULT_UI_URI
+    this.token = token
+  }
+
+  public async subscribeToChannel(
+    channelKey: string,
+    options: SubscribeOptions,
+  ): Promise<void> {
+    if (!this.pusherChannels[channelKey]) {
+      const pusher = await this.getPusherInstance()
+      const newChannel = pusher.subscribe(channelKey)
+      this.pusherChannels[channelKey] = newChannel
+    }
+    const channel = this.pusherChannels[channelKey]
+    if (channel.subscribed) {
+      options.onSubscribe && options.onSubscribe()
+    } else {
+      channel.bind(
+        'pusher:subscription_succeeded',
+        () => options.onSubscribe && options.onSubscribe(),
+      )
+    }
+    if (options.onUpdate) {
+      channel.bind('updated', options.onUpdate)
+    }
+  }
+
+  public async unsubscribeFromChannel(channelKey: string): Promise<void> {
+    if (this.pusherChannels[channelKey]) {
+      const pusher = await this.getPusherInstance()
+      pusher.unsubscribe(channelKey)
+      delete this.pusherChannels[channelKey]
+    }
+  }
+
+  public getEmbedUri(page: string, params?: any) {
+    const embedUrl = new URL(`${this.uiUri}/embed/${page}`)
+
+    if (this.token) {
+      embedUrl.searchParams.set('token', this.token)
+    }
+
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        embedUrl.searchParams.set(key, value as string)
+      }
+    }
+
+    return embedUrl.href
+  }
+
+  public async getPusherInstance(): Promise<Pusher> {
+    if (!this.pusher) {
+      const { key, cluster } = await this.get('pusher/config')
+      this.pusher = new Pusher(key, {
+        cluster: cluster,
+        authEndpoint: this.apiUri + '/pusher/auth',
+        auth: { headers: { Authorization: `Bearer ${this.token}` } },
+      })
+    }
+    return this.pusher
+  }
+
+  public async connectionRequest(
+    connectionId: string,
+    uri: string,
+    data?: any,
+  ): Promise<any> {
+    return this.post(`connections/${connectionId}/execute-request`, {
+      key: uri,
+      payload: data,
+    })
+  }
+
+  private handleRequestError(err) {
+    if (Axios.isAxiosError(err) && err.response.data?.type) {
+      console.error(
+        `Error type: ${err.response.data.type}. ${_.chain(err.response.data)
+          .omit(['type'])
+          .keys()
+          .map(
+            (k) =>
+              `${_.capitalize(k)}: ${(err as AxiosError).response.data[k]}`,
+          )
+          .join('. ')
+          .value()}`,
+      )
+      throw getErrorFromData(err.response.data)
+    }
+    throw err
+  }
+
+  private async makeApiRequest(
+    method: HttpMethod,
+    params: Partial<AxiosRequestConfig> = {},
+  ) {
+    params.method = method
+    params.baseURL = this.apiUri
+    params.headers = {
+      ...(params.headers || {}),
+      Authorization: `Bearer ${this.token}`,
+    }
+    let response
+    try {
+      response = await Axios.request(params)
+    } catch (err) {
+      this.handleRequestError(err)
+    }
+    return response.data
+  }
+}
+
+export interface NewImportOptions {
+  schema: any
+  onData: (...args: any) => void
+  onClose?: (...args: any) => void
+}
+
+export interface OpenFlowConfigurationOptions {
+  onClose?: (...args: any) => void
+}
+
+interface ConnectionOptions {
+  onSuccess?: (connection: any) => void
+  onClose?: () => void
+}
+
+export interface NewConnectionOptions extends ConnectionOptions {
+  integrationKey: string
+  connectorKey: string
+}
+
+export interface RefreshConnectionOptions extends ConnectionOptions {
+  connectionId: string
+}
+
+export interface IntegrationAppClientOptions {
+  token?: string
+  apiUri?: string
+  uiUri?: string
+  /**
+   * @deprecated
+   */
+  accessToken?: string
+}
+
+export interface SubscribeOptions {
+  onSubscribe?: () => void
+  onUpdate?: (update?: any) => void
+}
+
+type HttpMethod = 'GET' | 'POST' | 'DELETE' | 'PUT' | 'PATCH'

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

@@ -0,0 +1,58 @@
+import { IntegrationAppClient } from '..'
+import { Connection } from '.'
+import {
+  ConnectionSelector,
+  CreateConnectionRequest,
+  FindConnectionsQuery,
+  UpdateConnectionRequest,
+} from './api'
+
+import {
+  ElementInstanceListAccessor,
+  ElementInstanceAccessor,
+} from '../accessors'
+import { openIframe } from '../iframe'
+export class ConnectionsAccessor extends ElementInstanceListAccessor<
+  Connection,
+  FindConnectionsQuery
+> {
+  constructor(client: IntegrationAppClient) {
+    super(client, 'connections')
+  }
+}
+
+export class ConnectionAccessor extends ElementInstanceAccessor<
+  Connection,
+  ConnectionSelector,
+  CreateConnectionRequest,
+  UpdateConnectionRequest
+> {
+  constructor(
+    private client: IntegrationAppClient,
+    selector: string | ConnectionSelector,
+  ) {
+    super({
+      client,
+      listPath: 'connections',
+      selectorPath: 'connection',
+      selector,
+    })
+  }
+
+  async request(path): Promise<any> {
+    const id = await this.getId()
+    const pathWithoutSlash = path.startsWith('/') ? path.slice(1) : path
+    return this.client.post(`/connections/${id}/api/${pathWithoutSlash}`)
+  }
+
+  async refresh(): Promise<void> {
+    const id = await this.getId()
+    const uri = this.client.getEmbedUri(`/connections/${id}/refresh`)
+    return new Promise<void>((resolve) => {
+      openIframe(uri, {
+        onClose: () => resolve(null),
+        onSuccess: (connection) => resolve(connection),
+      })
+    })
+  }
+}

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

@@ -0,0 +1,28 @@
+import { PaginationQuery, PaginationResponse } from '../entity-repository'
+import { Connection } from '.'
+import { IntegrationSelector } from '../integrations/api'
+
+export class FindConnectionsQuery extends PaginationQuery {
+  integrationKey?: string
+  includeArchived?: boolean
+  /**
+   * @deprecated - replaced with integrationKey
+   */
+  connectorKey?: string
+}
+
+export class CreateConnectionRequest {
+  name: string
+
+  integrationId: string
+}
+
+export class UpdateConnectionRequest {
+  name?: string
+}
+
+export class FindConnectionsResponse extends PaginationResponse<Connection> {}
+
+export interface ConnectionSelector extends IntegrationSelector {
+  connectionId?: string
+}

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

@@ -0,0 +1,70 @@
+import { User } from '../users'
+import { ConnectionMode, Integration } from '../integrations'
+import { DataLocationSpec } from '../data-locations'
+
+export class Connection {
+  /**
+   * Unique connection id
+   */
+  id: string
+
+  /**
+   * User-readable name of the connection
+   */
+  name: string
+
+  userId: string
+
+  user?: User
+
+  isDefunct?: boolean
+
+  /**
+   * Id of an integration the connection is created with
+   */
+  integrationId: string
+
+  integration?: Integration
+
+  createdAt: string
+
+  updatedAt: string
+
+  archivedAt?: string
+}
+
+export interface ConnectionSpec {
+  name: string
+
+  logoUri: string
+
+  auth: {
+    authorizeUri: string
+    tokenUri: string
+  }
+
+  ui?: {
+    description: string
+    schema: any
+    helpUri?: string
+    test: boolean
+  }
+
+  parametersSchema?: any
+
+  connectionMode?: ConnectionMode
+
+  data?: ConnectionDataSpec
+}
+
+export class ConnectionSpec {
+  constructor(opts: ConnectionSpec) {
+    Object.assign(this, opts)
+  }
+}
+
+export interface ConnectionDataSpec {
+  root: DataLocationSpec
+
+  [key: string]: DataLocationSpec
+}

package/node_modules/@integration-app/sdk/src/connector-api/index.ts

@@ -0,0 +1,44 @@
+export {
+  ConnectionSpec as ConnectorSpec,
+  ConnectionDataSpec as ConnectorDataSpec,
+} from '../connections'
+
+// Backward compatibility
+export {
+  DataLocationType,
+  DataLocationSpec,
+  DataLocation,
+  DataCollectionSpec,
+  DataDirectorySpec,
+  DataCollectionSpec as DataCollection,
+  DataCollectionUdmSpec,
+  DataCollectionFindSpec,
+  DataCollectionFindByIdSpec,
+  DataCollectionCreateSpec,
+  DataCollectionUpdateSpec,
+  DataCollectionDeleteSpec,
+  DataCollectionFindRequest,
+  DataCollectionFindResponse,
+  DataCollectionFindByIdRequest,
+  DataCollectionFindByIdResponse,
+  DataCollectionCreateRequest,
+  DataCollectionCreateResponse,
+  DataCollectionUpdateRequest,
+  DataCollectionUpdateResponse,
+  DataCollectionDeleteRequest,
+  DataCollectionDeleteResponse,
+  DataCollectionSubscribeRequest,
+  DataCollectionSubscribeResponse,
+  DataCollectionUpdateSubscriptionRequest,
+  DataCollectionUpdateSubscriptionResponse,
+  DataCollectionUnsubscribeRequest,
+  DataCollectionUnsubscribeResponse,
+  DataCollectionEventsRequest,
+  DataCollectionEventsResponse,
+  DataEventWebhookPayload,
+  DataCollectionParseUnifiedFieldsRequest,
+  DataCollectionParseUnifiedFieldsResponse,
+  DataDirectoryListRequest,
+  DataDirectoryListResponse,
+  makeCollectionOperationPath,
+} from '../data-locations'

package/node_modules/@integration-app/sdk/src/data-builder/context.ts

@@ -0,0 +1,40 @@
+import { BadRequestError } from '../errors'
+import { DataLocator } from './locators'
+
+class DataBuilderArrayIterator {
+  value: any[]
+  currentIdx: number
+}
+
+export class DataBuilderContext {
+  private currentArrayItems: Record<string, DataBuilderArrayIterator>
+
+  constructor(public variables: any) {
+    this.currentArrayItems = {}
+  }
+
+  public setCurrentArrayItem(locator: string, value: any): void {
+    this.currentArrayItems[this.getKeyByLocator(locator)] = value
+  }
+
+  public getCurrentArrayItem(locator: string): any {
+    const key = this.getKeyByLocator(locator)
+    if (typeof this.currentArrayItems[key] !== 'undefined') {
+      return this.currentArrayItems[key]
+    } else {
+      throw new BadRequestError(
+        `Attempting to access current array item with non-existing locator:\n${JSON.stringify(
+          locator,
+        )}`,
+      )
+    }
+  }
+
+  public unsetCurrentArrayItem(locator: string): void {
+    delete this.currentArrayItems[this.getKeyByLocator(locator)]
+  }
+
+  private getKeyByLocator(locator: DataLocator) {
+    return JSON.stringify(locator)
+  }
+}

package/node_modules/@integration-app/sdk/src/data-builder/formulas/base.test.ts

@@ -0,0 +1,26 @@
+import '.'
+import { DataBuilderContext } from '../context'
+import { getValueByLocator } from './base'
+
+describe('getValueByLocator', () => {
+  it('should return value at object property locator', () => {
+    const context = new DataBuilderContext({
+      a: {
+        b: {
+          c: 'd',
+        },
+      },
+    })
+    expect(getValueByLocator(context, '$.a.b.c')).toEqual('d')
+  })
+
+  it('should return value at array locator', () => {
+    const context = new DataBuilderContext(['a', 'b', 'c'])
+    expect(getValueByLocator(context, '$[1]')).toEqual('b')
+  })
+
+  it('should return false value', () => {
+    const context = new DataBuilderContext({ b: false })
+    expect(getValueByLocator(context, '$.b')).toEqual(false)
+  })
+})