@integration-app/react 0.1.4 → 0.1.6

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

@@ -1,75 +0,0 @@
-import { PaginationQuery, PaginationResponse } from '../entity-repository'
-import { HttpRequestSpec } from '../http-requests'
-import { User } from '../users'
-
-export interface AppEventType {
-  id: string
-
-  key: string
-
-  name: string
-
-  subscribeRequest?: HttpRequestSpec
-
-  example?: any
-
-  schema?: any
-
-  globalWebhookUri: string
-
-  userIdFormula?: any
-}
-
-export interface AppEventSubscription {
-  id: string
-
-  appEventTypeId: string
-
-  appEventType?: AppEventType
-
-  userId: string
-
-  user?: User
-
-  instanceKey?: string
-
-  isSubscribed: boolean
-
-  webhookUri: string
-
-  subscriptionRequest: HttpRequestSpec
-
-  subscriptionResponse?: any
-}
-
-export interface AppEvent {
-  id: string
-
-  userId: string
-
-  user?: User
-
-  appEventTypeId: string
-
-  appEventType?: AppEventType
-
-  appEventSubscriptionId: string
-
-  appEventSubscription?: AppEventSubscription
-
-  event: any
-
-  datetime: string
-
-  launchedFlowRunIds: string[]
-}
-
-export interface FindAppEventsQuery extends PaginationQuery {
-  userId?: string
-  appEventId?: string
-  appEventInstanceId?: string
-  startDatetime?: string
-  endDatetime?: string
-}
-
-export interface FindAppEventsResponse extends PaginationResponse<AppEvent> {}

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

@@ -1,10 +0,0 @@
-import { Self } from '.'
-import { IntegrationAppClient } from '../client'
-
-export class SelfAccessor {
-  constructor(private client: IntegrationAppClient) {}
-
-  async get(): Promise<Self> {
-    return this.client.get('self')
-  }
-}

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

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

@@ -1,6 +0,0 @@
-/**
- * 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

@@ -1,417 +0,0 @@
-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 {
-  private apiUri?: string
-  private uiUri?: string
-  private 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

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

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

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