@integration-app/react 0.1.2 → 0.1.4

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

@@ -0,0 +1,102 @@
+import { ErrorData } from '../errors'
+import { PaginationResponse, PaginationQuery } from '../entity-repository'
+import { FlowNodeRun } from './flow-node-runs'
+import { IntegrationAppClient } from '../client'
+import { User } from '../users'
+import { FlowInstance } from '../flows'
+import { Connection } from '../connections'
+import { Integration } from '../integrations'
+
+/**
+ * Prefix for the realtime updates channel.
+ */
+export const FLOW_RUN_CHANNEL_PREFIX = 'private-flow-runs-'
+
+export enum FlowRunState {
+  RUNNING = 'running',
+  COMPLETED = 'completed',
+  FAILED = 'failed',
+}
+
+export interface FlowRun {
+  id: string
+
+  flowInstanceId: string
+
+  flowInstance?: FlowInstance
+
+  connectionId?: string
+
+  connection?: Connection
+
+  integrationId?: string
+
+  integration?: Integration
+
+  startNodeKey: string
+
+  userId: string
+
+  user?: User
+
+  flowBlueprintKey?: string
+
+  input?: any
+
+  state: FlowRunState
+
+  startTime: Date
+
+  endTime?: Date
+
+  errors?: ErrorData[]
+
+  nodeRuns?: FlowNodeRun[]
+}
+
+export interface CreateFlowRunRequest {
+  flowInstanceId: string
+
+  nodeKey?: string
+
+  input?: any
+}
+
+export class FlowRunsQuery extends PaginationQuery {
+  flowInstanceId?: string
+  flowBlueprintKey?: string
+  userId?: string
+}
+
+export class FindFlowRunsResponse extends PaginationResponse<FlowRun> {}
+
+export class FlowRunsAccessor {
+  constructor(private readonly client: IntegrationAppClient) {}
+
+  async find(query: FlowRunsQuery): Promise<FindFlowRunsResponse> {
+    return this.client.get('/flow-runs', query)
+  }
+
+  async create(request: CreateFlowRunRequest): Promise<FlowRun> {
+    return this.client.post('/flow-runs', request)
+  }
+}
+
+export class FlowRunAccessor {
+  private baseUri: string
+
+  constructor(
+    private readonly client: IntegrationAppClient,
+    public id: string,
+  ) {
+    this.baseUri = `/flow-runs/${id}`
+  }
+
+  async get(): Promise<FlowRun> {
+    return this.client.get(this.baseUri)
+  }
+
+  async getOutput(): Promise<any> {
+    return this.client.get(`${this.baseUri}/output`)
+  }
+}

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

@@ -0,0 +1,246 @@
+import { Channel } from 'pusher-js'
+import { IntegrationAppClient } from '..'
+import { SubscribeOptions } from '../client'
+import { FlowRun, FLOW_RUN_CHANNEL_PREFIX, FlowRunState } from '../flow-runs'
+import { OpenConfigurationOptions, openIframe } from '../iframe'
+import {
+  FlowInstance,
+  FLOW_CHANNEL_PREFIX,
+  FLOW_INSTANCE_CHANNEL_PREFIX,
+  Flow,
+} from '.'
+import {
+  CreateFlowInstanceRequest,
+  CreateFlowRequest,
+  FindFlowInstancesQuery,
+  FindFlowsRequest,
+  FlowInstanceSelector,
+  RunFlowOptions,
+  UpdateFlowInstanceRequest,
+  UpdateFlowRequest,
+} from './api'
+import qs from 'query-string'
+import {
+  ElementAccessor,
+  ElementInstanceAccessor,
+  ElementInstanceListAccessor,
+  ElementListAccessor,
+} from '../accessors'
+
+const MAX_POLLING_ERRORS = 10
+
+export interface OpenFlowInstanceConfigurationOptions
+  extends OpenConfigurationOptions {
+  nodeKey?: string
+}
+
+export class FlowsAccessor extends ElementListAccessor<
+  Flow,
+  FindFlowsRequest,
+  CreateFlowRequest
+> {
+  constructor(client: IntegrationAppClient) {
+    super(client, 'flows')
+  }
+}
+
+export class FlowAccessor extends ElementAccessor<
+  Flow,
+  CreateFlowRequest,
+  UpdateFlowRequest
+> {
+  constructor(private client: IntegrationAppClient, idOrKey: string) {
+    super({
+      client: client,
+      path: 'flows',
+      idOrKey,
+    })
+  }
+
+  async runAll(params: RunFlowOptions): Promise<any[]> {
+    const flow = await this.get()
+    const instancesPage = await this.client.flowInstances.find({
+      flowId: flow.id,
+      enabled: true,
+    })
+    const accessors = instancesPage.items.map(
+      (instance) => new FlowInstanceAccessor(this.client, instance.id),
+    )
+    const runs = await Promise.all(
+      accessors.map((accessor) => accessor.run(params)),
+    )
+    return runs
+  }
+
+  async subscribe(options: SubscribeOptions) {
+    const flow = await this.get()
+    const channelKey = `${FLOW_CHANNEL_PREFIX}${flow.id}`
+    await this.client.subscribeToChannel(channelKey, options)
+  }
+
+  async unsubscribe() {
+    const flow = await this.get()
+    const channelKey = `${FLOW_INSTANCE_CHANNEL_PREFIX}${flow.id}`
+    await this.client.unsubscribeFromChannel(channelKey)
+  }
+}
+
+export class FlowInstancesAccessor extends ElementInstanceListAccessor<
+  FlowInstance,
+  FindFlowInstancesQuery
+> {
+  constructor(client: IntegrationAppClient) {
+    super(client, 'flow-instances')
+  }
+}
+
+export class FlowInstanceAccessor extends ElementInstanceAccessor<
+  FlowInstance,
+  FlowInstanceSelector,
+  CreateFlowInstanceRequest,
+  UpdateFlowInstanceRequest
+> {
+  constructor(
+    protected client: IntegrationAppClient,
+    protected selector: FlowInstanceSelector | string,
+  ) {
+    super({
+      client,
+      selector,
+      listPath: 'flow-instances',
+      selectorPath: 'flow-instance',
+    })
+  }
+
+  async enable(): Promise<FlowInstance> {
+    return this.patch({ enabled: true })
+  }
+
+  async disable(): Promise<FlowInstance> {
+    return this.patch({ enabled: false })
+  }
+
+  async updateToLatestFlow(): Promise<FlowInstance> {
+    const id = await this.getId()
+    return this.client.post(`/flow-instances/${id}/update-to-latest-flow`)
+  }
+
+  async setup(): Promise<FlowInstance> {
+    const id = await this.getId()
+    return this.client.post(`/flow-instances/${id}/setup`)
+  }
+
+  async reset(): Promise<FlowInstance> {
+    const id = await this.getId()
+    return this.client.post(`/flow-instances/${id}/reset`)
+  }
+
+  async openConfiguration(options: OpenFlowInstanceConfigurationOptions = {}) {
+    const id = await this.getId()
+    const queryParams = {
+      nodeKey: options.nodeKey,
+    }
+    const uri = this.client.getEmbedUri(
+      `/flow-instances/${id}/configuration?${qs.stringify(queryParams)}`,
+    )
+    return openIframe(uri, {
+      onClose: options.onClose,
+    })
+  }
+
+  async run(options: RunFlowOptions = {}): Promise<FlowRun> {
+    function onUpdate(flowRun) {
+      options.onUpdate && options.onUpdate(flowRun)
+    }
+
+    const id = await this.getId()
+
+    const flowRun = await this.client.flowRuns.create({
+      flowInstanceId: id,
+      nodeKey: options.nodeKey,
+      input: options.input,
+    })
+
+    onUpdate(flowRun)
+
+    const pusher = await this.client.getPusherInstance()
+    const pusherChannelName = `${FLOW_RUN_CHANNEL_PREFIX}${flowRun.id}`
+    const pusherEventNameFlowRun = 'flow-run-update'
+    let pusherChannel: Channel
+
+    let checkFlowRunInterval: ReturnType<typeof setInterval>
+
+    function cleanup() {
+      checkFlowRunInterval && clearInterval(checkFlowRunInterval)
+
+      pusherChannel && pusherChannel.unbind(pusherEventNameFlowRun)
+      pusher && pusher.unsubscribe(pusherChannelName)
+    }
+
+    return new Promise((resolve, reject) => {
+      const handleFlowRunUpdate = async (flowRun: FlowRun) => {
+        onUpdate(flowRun)
+
+        if (flowRun.state === FlowRunState.COMPLETED) {
+          cleanup()
+          resolve(flowRun)
+        } else if (flowRun.state === FlowRunState.FAILED) {
+          cleanup()
+          reject(
+            new Error(
+              `Flow run ${flowRun.id} failed: ${flowRun.errors?.[0]?.message}`,
+            ),
+          )
+        }
+      }
+
+      const fetchFlowRun = async () => {
+        handleFlowRunUpdate(await this.client.flowRun(flowRun.id).get())
+      }
+
+      /* POLLING */
+
+      // Flags to prevent making mutiple polling requests at the same time
+      let pollingFlowRun = false
+      let errors = 0
+
+      checkFlowRunInterval = setInterval(async () => {
+        if (!pollingFlowRun) {
+          pollingFlowRun = true
+          try {
+            await fetchFlowRun()
+            errors = 0
+          } finally {
+            errors += 1
+            if (errors > MAX_POLLING_ERRORS) {
+              cleanup()
+              reject(
+                new Error(
+                  `Got ${errors} errors while polling flow run ${flowRun.id} state - aborting`,
+                ),
+              )
+            }
+            pollingFlowRun = false
+          }
+        }
+      }, 1000)
+
+      if (pusher) {
+        pusherChannel = pusher.subscribe(pusherChannelName)
+        pusherChannel.bind(pusherEventNameFlowRun, fetchFlowRun)
+      }
+    })
+  }
+
+  async subscribe(options: SubscribeOptions) {
+    const id = await this.getId()
+    const channelKey = `${FLOW_INSTANCE_CHANNEL_PREFIX}${id}`
+    await this.client.subscribeToChannel(channelKey, options)
+  }
+
+  async unsubscribe() {
+    const id = await this.getId()
+    const channelKey = `${FLOW_INSTANCE_CHANNEL_PREFIX}${id}`
+    await this.client.unsubscribeFromChannel(channelKey)
+  }
+}

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

@@ -0,0 +1,71 @@
+import { PaginationQuery, PaginationResponse } from '../entity-repository'
+import { Flow, FlowInstance, FlowNodeLink } from '.'
+import { ConnectionSelector } from '../connections/api'
+
+export interface FindFlowsRequest extends PaginationQuery {}
+
+export interface FindFlowsResponse extends PaginationResponse<Flow> {}
+
+export interface CreateFlowNodeRequest {
+  type: string
+
+  config?: any
+
+  ui?: any
+
+  links?: FlowNodeLink[]
+}
+
+export interface CreateFlowRequest {
+  key: string
+  name: string
+  nodes: Record<string, CreateFlowNodeRequest>
+}
+
+export interface UpdateFlowRequest extends CreateFlowRequest {}
+
+export interface FindFlowInstancesQuery {
+  id?: string
+  userId?: string
+  flowId?: string
+  flowKey?: string
+  integrationKey?: string
+  integrationId?: string
+  connectionId?: string
+  instanceKey?: string
+  enabled?: boolean
+  dependencyInstanceId?: string
+}
+
+export interface FlowInstanceSelector extends ConnectionSelector {
+  flowId?: string
+  flowKey?: string
+
+  instanceKey?: string
+
+  autoCreate?: boolean
+}
+
+export class FindFlowInstancesResponse extends PaginationResponse<FlowInstance> {}
+
+export interface CreateFlowInstanceRequest {
+  flowKey?: string
+
+  name?: string
+
+  parameters?: any
+
+  enabled?: boolean
+}
+
+export interface UpdateFlowInstanceRequest {
+  name?: string
+
+  enabled?: boolean
+}
+
+export interface RunFlowOptions {
+  nodeKey?: string
+  input?: any
+  onUpdate?: (...args: any) => void
+}

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

@@ -0,0 +1,233 @@
+import { JSONSchema } from '../json-schema'
+import { ErrorData } from '../errors'
+import { Connection } from '../connections'
+import { User } from '../users'
+import { IntegrationElementInstance } from '../integration-elements'
+import { Integration } from '../integrations'
+import { DataFilter } from '../data-filter'
+
+export const FLOW_CHANNEL_PREFIX = 'private-flows-'
+export const FLOW_INSTANCE_CHANNEL_PREFIX = 'private-flow-instances-'
+
+export interface FlowNode {
+  /**
+   * Type of the node this blueprint describes.
+   */
+  type: string
+
+  /**
+   * Name of the node summarizing its purpose.
+   */
+  name: string
+
+  /**
+   * Default node configuration.
+   */
+  config?: any
+
+  /**
+   * UI settings for this node.
+   */
+  ui?: any
+
+  /**
+   * Input this node receives from previous nodes (calculated)
+   */
+  inputSchema?: any
+
+  /**
+   * Output this node produces (calculated)
+   */
+  outputSchema?: any
+
+  /**
+   * Example of the output node produces
+   */
+  outputExample?: any
+
+  /**
+   * Links to nodes that run after the current node.
+   */
+  links?: FlowNodeLink[]
+}
+
+export interface Flow {
+  /**
+   * Flow blueprint's unique id. It never changes.
+   */
+  id: string
+
+  /**
+   * Blueprint key to conveniently refer to it by.
+   * Must be unique among all blueprints within an app.
+   * Can be changed.
+   */
+  key: string
+
+  /**
+   * Version. Used to indicate changes in the flow.
+   */
+  version: string
+
+  name: string
+
+  parametersSchema?: JSONSchema
+
+  nodes?: Record<string, FlowNode>
+
+  /**
+   * Instance of this flow when returned in a context of a specific connection.
+   * Populated in some API responses but not others.
+   */
+  instance?: FlowInstance
+
+  /**
+   * Instances of this flow when returned in a context of a specific connection (for a flow that can have multiple instances).
+   * Populated in some API responses but not others.
+   */
+  instances?: FlowInstance[]
+
+  archivedAt?: Date
+}
+
+export enum FlowInstanceState {
+  SETTING_UP = 'SETTING_UP',
+  SETUP_FAILED = 'SETUP_FAILED',
+  READY = 'READY',
+}
+
+export interface FlowInstance {
+  id: string
+
+  userId: string
+
+  user?: User
+
+  connectionId?: string
+
+  connection?: Connection
+
+  flowId?: string
+
+  flowVersion?: string
+
+  integrationId: string
+
+  integration?: Integration
+
+  instanceKey?: string
+
+  /**
+   * This flow's unique user-readable name.
+   */
+  name: string
+
+  /**
+   * This flow's parameters.
+   * Can be used as variables in nodes.
+   */
+  parameters?: any
+
+  /**
+   * Schema of parameters the flow accepts.
+   * Copied from FlowBlueprint
+   */
+  parametersSchema?: JSONSchema
+
+  /**
+   * Dictionary of flow's nodes:
+   * <key>: <node>
+   */
+  nodes?: Record<string, FlowInstanceNode>
+
+  /**
+   * Whether the flow is enabled (i.e. triggers are active)
+   */
+  enabled: boolean
+
+  createdAt: string
+
+  updatedAt: string
+
+  /**
+   * List of dependencies.
+   */
+  dependencies?: IntegrationElementInstance[]
+
+  state?: FlowInstanceState
+}
+
+export enum FlowInstanceNodeState {
+  SETTING_UP = 'SETTING_UP',
+  SETUP_FAILED = 'SETUP_FAILED',
+  READY = 'READY',
+}
+
+export interface FlowInstanceNode extends FlowNode {
+  /**
+   * State of the node.
+   * Set automatically by the engine when something changes about the node or the flow.
+   */
+  state?: FlowInstanceNodeState
+
+  /**
+   * Any data node wants to save during its lifetime.
+   */
+  stateData?: any
+
+  /**
+   * Errors occured during the node's configuration.
+   */
+  errors?: ErrorData[]
+
+  /**
+   * Part of the node's configuration provided by the end-user.
+   */
+  userConfig?: any
+
+  /**
+   * Input to be used for testing the node.
+   * Compiled automatically from test output of the previous nodes.
+   */
+  testInput?: any
+
+  /**
+   * Node's config materialized with the test data. Used for testing the node.
+   */
+  testConfig?: any
+
+  /**
+   * List of dependencies.
+   */
+  dependencies?: IntegrationElementInstance[]
+}
+
+/**
+ * Record of a link between one flow node to another.
+ * When a node run finishes, linked nodes runs start.
+ */
+export interface FlowNodeLink {
+  key: string
+  filter?: DataFilter
+}
+
+export interface OpenFlowInstanceConfigurationOptions {
+  nodeKey?: string
+  onClose?: (...args: any) => void
+}
+
+export interface RunFlowOptions {
+  nodeKey?: string
+  input?: any
+  onUpdate?: (...args: any) => void
+}
+
+export {
+  getFlowNode,
+  getChildNodeKeys,
+  getDownstreamNodeKeys,
+  getParentNodeKeys,
+  getUpstreamNodeKeys,
+  getRootNodeKeys,
+  getOrderedNodeKeys,
+} from './utils'

package/node_modules/@integration-app/sdk/src/flows/nodes/api-trigger.ts

@@ -0,0 +1,7 @@
+import { FlowNodeSpec } from '.'
+
+export default new FlowNodeSpec({
+  name: 'API Trigger',
+  description: 'Launch flow via API',
+  isTrigger: true,
+})

package/node_modules/@integration-app/sdk/src/flows/nodes/app-event-trigger.ts

@@ -0,0 +1,7 @@
+import { FlowNodeSpec } from '.'
+
+export default new FlowNodeSpec({
+  name: 'App Event Trigger',
+  description: 'Trigger flow when a matching App Event is received',
+  isTrigger: true,
+})

package/node_modules/@integration-app/sdk/src/flows/nodes/create-data-link.ts

@@ -0,0 +1,6 @@
+import { FlowNodeSpec } from '.'
+
+export default new FlowNodeSpec({
+  name: 'Create Data Link',
+  description: 'Link records between your app and external app',
+})

package/node_modules/@integration-app/sdk/src/flows/nodes/create-data-record.ts

@@ -0,0 +1,6 @@
+import { FlowNodeSpec } from '.'
+
+export default new FlowNodeSpec({
+  name: 'Create Data Record',
+  description: 'Create a new data record in a collection',
+})

package/node_modules/@integration-app/sdk/src/flows/nodes/data-record-created-trigger.ts

@@ -0,0 +1,8 @@
+import { FlowNodeSpec } from '.'
+
+export default new FlowNodeSpec({
+  name: 'Data Record Created Trigger',
+  description:
+    'Launch flow when a data record is created in a remote data collection',
+  isTrigger: true,
+})

package/node_modules/@integration-app/sdk/src/flows/nodes/data-record-deleted-trigger.ts

@@ -0,0 +1,8 @@
+import { FlowNodeSpec } from '.'
+
+export default new FlowNodeSpec({
+  name: 'Data Record Deleted Trigger',
+  description:
+    'Launch flow when a data record is deleted in a remote data collection',
+  isTrigger: true,
+})

package/node_modules/@integration-app/sdk/src/flows/nodes/data-record-updated-trigger.ts

@@ -0,0 +1,8 @@
+import { FlowNodeSpec } from '.'
+
+export default new FlowNodeSpec({
+  name: 'Data Record Updated Trigger',
+  description:
+    'Launch flow when a data record is updated in a remote data collection',
+  isTrigger: true,
+})