@integration-app/react 0.2.0 → 0.3.1

package/src/data-sources/useDataSourceInstance.ts

@@ -6,43 +6,137 @@ import {
   DataSourceInstanceSelector,
   OpenDataSourceConfigurationOptions,
   DataSourceInstance,
+  UpdateDataSourceInstanceRequest,
+  DataDirectoryListRequest,
+  DataCollectionListRequest,
+  CreateDataSourceInstanceRequest,
 } from '@integration-app/sdk'
 import { useElement } from '../hooks/useElement'
 
 export function useDataSourceInstance(
-  selector: DataSourceInstanceSelector | { id: string },
+  selector: string | DataSourceInstanceSelector,
 ) {
-  const { data: dataSourceInstance, ...rest } = useElement<
+  const {
+    item: dataSourceInstance,
+    accessor,
+    refresh,
+    ...rest
+  } = useElement<
     DataSourceInstance,
-    DataSourceInstanceSelector,
+    UpdateDataSourceInstanceRequest,
+    CreateDataSourceInstanceRequest,
     DataSourceInstanceAccessor
-  >(selector, (integrationApp) =>
-    integrationApp.dataSourceInstance.bind(integrationApp),
-  )
+  >(selector, (integrationApp) => integrationApp.dataSourceInstance(selector))
 
-  const accessor = rest.accessor
+  async function setup() {
+    await accessor?.setup()
+    await refresh()
+  }
+
+  async function reset() {
+    await accessor?.reset()
+    await refresh()
+  }
+
+  async function subscribe(eventType) {
+    await accessor?.subscribe(eventType)
+    await refresh()
+  }
+
+  async function resubscribe(eventType) {
+    await accessor?.resubscribe(eventType)
+    await refresh()
+  }
+
+  async function unsubscribe(eventType) {
+    await accessor?.unsubscribe(eventType)
+    await refresh()
+  }
+
+  async function pullUpdates() {
+    await accessor?.pullUpdates()
+    await refresh()
+  }
+
+  async function fullSync() {
+    await accessor?.fullSync()
+    await refresh()
+  }
+
+  async function getSyncsList() {
+    return await accessor?.getSyncsList()
+  }
+
+  async function openConfiguration(
+    options?: OpenDataSourceConfigurationOptions,
+  ) {
+    return accessor?.openConfiguration(options)
+  }
+
+  async function listRecords(request?: DataCollectionListRequest) {
+    return accessor?.listRecords(request)
+  }
+
+  async function findRecords(request?: DataCollectionFindRequest) {
+    return accessor?.findRecords(request)
+  }
+
+  async function findRecordById(id: string) {
+    return accessor?.findRecordById(id)
+  }
+
+  async function createRecord(request?: DataCollectionCreateRequest) {
+    return accessor?.createRecord(request)
+  }
+
+  async function updateRecord(request?: DataCollectionUpdateRequest) {
+    return accessor?.updateRecord(request)
+  }
+
+  async function deleteRecord(id?: string) {
+    return accessor?.deleteRecord(id)
+  }
+
+  async function unifiedFieldsToNative(unifiedFields: any) {
+    return accessor?.unifiedFieldsToNative(unifiedFields)
+  }
+
+  async function getCollection() {
+    return accessor?.getCollection()
+  }
+
+  async function getLocations(
+    request: DataDirectoryListRequest & {
+      path?: string
+    },
+  ) {
+    return accessor?.getLocations(request)
+  }
 
   return {
     dataSourceInstance,
-    setup: () => accessor.setup(),
-    subscribe: (eventType) => accessor.subscribe(eventType),
-    resubscribe: (eventType) => accessor.resubscribe(eventType),
-    unsubscribe: (eventType) => accessor.unsubscribe(eventType),
-    pullUpdates: () => accessor.pullUpdates(),
-    fullSync: () => accessor.fullSync(),
-    reset: () => accessor.reset(),
-    openConfiguration: (options?: OpenDataSourceConfigurationOptions) =>
-      accessor.openConfiguration(options),
-    findRecords: (request?: DataCollectionFindRequest) =>
-      accessor.findRecords(request),
-    findRecordById: (id: string) => accessor.findRecordById(id),
-    createRecord: (request?: DataCollectionCreateRequest) =>
-      accessor.createRecord(request),
-    updateRecord: (request?: DataCollectionUpdateRequest) =>
-      accessor.updateRecord(request),
-    deleteRecord: (id?: string) => accessor.deleteRecord(id),
-    unifiedFieldsToNative: (unifiedFields: any) =>
-      accessor.unifiedFieldsToNative(unifiedFields),
+    accessor,
+    refresh,
+
+    setup,
+    reset,
+    subscribe,
+    resubscribe,
+    unsubscribe,
+    pullUpdates,
+    fullSync,
+    getSyncsList,
+    openConfiguration,
+    listRecords,
+    findRecords,
+    findRecordById,
+    createRecord,
+    updateRecord,
+    deleteRecord,
+    unifiedFieldsToNative,
+    getLocations,
+    getCollection,
+
     ...rest,
   }
 }

package/src/data-sources/useDataSourceInstanceCollection.ts

@@ -1,19 +1,29 @@
 import { DataCollectionSpec, DataSourceInstance } from '@integration-app/sdk'
 import { useIntegrationApp } from '../contexts/integration-app-context'
-import useGetter from '../hooks/useGetter'
+import useSWR from 'swr'
 
 export function useDataSourceInstanceCollection(
   dataSourceInstance: DataSourceInstance,
 ) {
   const integrationApp = useIntegrationApp()
-  const { data: collection, ...rest } = useGetter<DataCollectionSpec>(
-    dataSourceInstance?.id,
+
+  const { data, error, isLoading, mutate } = useSWR<DataCollectionSpec>(
+    dataSourceInstance ? `${dataSourceInstance.id}/collection` : null,
     () =>
       integrationApp.dataSourceInstance(dataSourceInstance.id).getCollection(),
   )
 
+  async function refresh() {
+    return await mutate()
+  }
+
+  const collection = data
+
   return {
     collection,
-    ...rest,
+
+    refresh,
+    error,
+    loading: isLoading,
   }
 }

package/src/data-sources/useDataSourceInstanceLocations.ts

@@ -3,7 +3,8 @@ import {
   DataSourceInstance,
 } from '@integration-app/sdk'
 import { useIntegrationApp } from '../contexts/integration-app-context'
-import useGetter from '../hooks/useGetter'
+import useSWR from 'swr'
+import qs from 'query-string'
 
 export function useDataSourceInstanceLocations(
   dataSourceInstance: DataSourceInstance,
@@ -13,18 +14,28 @@ export function useDataSourceInstanceLocations(
   },
 ) {
   const integrationApp = useIntegrationApp()
-  const { data, ...rest } = useGetter<DataDirectoryListResponse>(
+
+  const { data, error, isLoading, mutate } = useSWR<DataDirectoryListResponse>(
     dataSourceInstance
-      ? `${dataSourceInstance.id}/${JSON.stringify(args)}`
-      : undefined,
+      ? `${dataSourceInstance.id}/locations?${qs.stringify(args)}`
+      : null,
     () =>
       integrationApp
         .dataSourceInstance(dataSourceInstance.id)
         .getLocations(args),
   )
 
+  async function refresh() {
+    return await mutate()
+  }
+
+  const locations = data?.locations ?? []
+
   return {
-    locations: data?.locations ?? [],
-    ...rest,
+    locations,
+
+    refresh,
+    error,
+    loading: isLoading,
   }
 }

package/src/data-sources/useDataSourceInstances.ts

@@ -0,0 +1,17 @@
+import {
+  FindDataSourceInstancesQuery,
+  DataSourceInstance,
+} from '@integration-app/sdk'
+import { useElements } from '../hooks/useElements'
+
+export function useDataSourceInstances(query?: FindDataSourceInstancesQuery) {
+  const { ...rest } = useElements<DataSourceInstance>(
+    'data-source-instances',
+    query,
+  )
+
+  return {
+    dataSourceInstances: rest.items,
+    ...rest,
+  }
+}

package/src/data-sources/useDataSources.ts

@@ -2,12 +2,10 @@ import { DataSource, FindDataSourcesQuery } from '@integration-app/sdk'
 import { useElements } from '../hooks/useElements'
 
 export function useDataSources(query?: FindDataSourcesQuery) {
-  const { ...rest } = useElements<DataSource, FindDataSourcesQuery>(
-    query,
-    (integrationApp) => integrationApp.dataSources,
-  )
+  const { ...rest } = useElements<DataSource>('data-sources', query)
 
   return {
+    dataSources: rest.items,
     ...rest,
   }
 }

package/src/field-mappings/useFieldMapping.ts

@@ -1,14 +1,35 @@
-import { FieldMapping, FieldMappingAccessor } from '@integration-app/sdk'
+import {
+  CreateFieldMappingRequest,
+  FieldMapping,
+  FieldMappingAccessor,
+  FieldMappingSelector,
+  UpdateFieldMappingRequest,
+} from '@integration-app/sdk'
 import { useElement } from '../hooks/useElement'
 
-export function useFieldMapping(idOrKey: string) {
-  const { data: fieldMapping, ...rest } = useElement<
+export function useFieldMapping(selector: FieldMappingSelector | string) {
+  const {
+    item: fieldMapping,
+    accessor,
+    refresh,
+    ...rest
+  } = useElement<
     FieldMapping,
-    string,
+    UpdateFieldMappingRequest,
+    CreateFieldMappingRequest,
     FieldMappingAccessor
-  >(idOrKey, (integrationApp) =>
-    integrationApp.fieldMapping.bind(integrationApp),
-  )
+  >(selector, (integrationApp) => integrationApp.fieldMapping(selector))
 
-  return { fieldMapping, ...rest }
+  async function apply(integrationKeys: string[]): Promise<FieldMapping[]> {
+    const result = await accessor?.apply(integrationKeys)
+    await refresh()
+    return result
+  }
+
+  async function reset() {
+    await accessor?.reset()
+    await refresh()
+  }
+
+  return { fieldMapping, apply, reset, refresh, accessor, ...rest }
 }

package/src/field-mappings/useFieldMappingInstance.ts

@@ -1,31 +1,54 @@
 import {
   FieldMappingInstanceAccessor,
   FieldMappingInstanceSelector,
-  IFieldMappingInstance,
+  FieldMappingInstance,
   OpenFieldMappingInstanceConfigurationOptions,
+  UpdateFieldMappingInstanceRequest,
+  CreateFieldMappingInstanceRequest,
 } from '@integration-app/sdk'
 import { useElement } from '../hooks/useElement'
 
 export function useFieldMappingInstance(
-  selector: FieldMappingInstanceSelector | { id: string },
+  selector: string | FieldMappingInstanceSelector,
 ) {
-  const { data: fieldMappingInstance, ...rest } = useElement<
-    IFieldMappingInstance,
-    FieldMappingInstanceSelector,
+  const {
+    item: fieldMappingInstance,
+    accessor,
+    refresh,
+    ...rest
+  } = useElement<
+    FieldMappingInstance,
+    UpdateFieldMappingInstanceRequest,
+    CreateFieldMappingInstanceRequest,
     FieldMappingInstanceAccessor
-  >(selector, (integrationApp) =>
-    integrationApp.fieldMappingInstance.bind(integrationApp),
-  )
+  >(selector, (integrationApp) => integrationApp.fieldMappingInstance(selector))
 
-  const accessor = rest.accessor
+  async function setup() {
+    await accessor?.setup()
+    await refresh()
+  }
+
+  async function reset() {
+    await accessor?.reset()
+    await refresh()
+  }
+
+  async function openConfiguration(
+    options?: OpenFieldMappingInstanceConfigurationOptions,
+  ) {
+    return accessor?.openConfiguration(options)
+  }
 
   return {
     fieldMappingInstance,
-    setup: () => accessor.setup(),
-    reset: () => accessor.reset(),
-    openConfiguration: (
-      options?: OpenFieldMappingInstanceConfigurationOptions,
-    ) => accessor.openConfiguration(options),
+
+    accessor,
+    refresh,
+
+    setup,
+    reset,
+    openConfiguration,
+
     ...rest,
   }
 }

package/src/field-mappings/useFieldMappingInstances.ts

@@ -1,18 +1,19 @@
 import {
   FindFieldMappingInstancesQuery,
-  IFieldMappingInstance,
+  FieldMappingInstance,
 } from '@integration-app/sdk'
 import { useElements } from '../hooks/useElements'
 
 export function useFieldMappingInstances(
   query?: FindFieldMappingInstancesQuery,
 ) {
-  const { ...rest } = useElements<
-    IFieldMappingInstance,
-    FindFieldMappingInstancesQuery
-  >(query, (integrationApp) => integrationApp.fieldMappingInstances)
+  const { ...rest } = useElements<FieldMappingInstance>(
+    'field-mapping-instances',
+    query,
+  )
 
   return {
+    fieldMappingInstances: rest.items,
     ...rest,
   }
 }

package/src/field-mappings/useFieldMappings.ts

@@ -2,12 +2,10 @@ import { FieldMapping, FindFieldMappingsQuery } from '@integration-app/sdk'
 import { useElements } from '../hooks/useElements'
 
 export function useFieldMappings(query?: FindFieldMappingsQuery) {
-  const { ...rest } = useElements<FieldMapping, FindFieldMappingsQuery>(
-    query,
-    (integrationApp) => integrationApp.fieldMappings,
-  )
+  const { ...rest } = useElements<FieldMapping>('field-mappings', query)
 
   return {
+    fieldMappings: rest.items,
     ...rest,
   }
 }

package/src/flows/useFlow.ts

@@ -1,11 +1,33 @@
-import { Flow, FlowAccessor } from '@integration-app/sdk'
+import {
+  CreateFlowRequest,
+  Flow,
+  FlowAccessor,
+  FlowSelector,
+  UpdateFlowRequest,
+} from '@integration-app/sdk'
 import { useElement } from '../hooks/useElement'
 
-export function useFlow(idOrKey: string) {
-  const { data: flow, ...rest } = useElement<Flow, string, FlowAccessor>(
-    idOrKey,
-    (integrationApp) => integrationApp.flow.bind(integrationApp),
+export function useFlow(selector: string | FlowSelector) {
+  const {
+    item: flow,
+    accessor,
+    refresh,
+    ...rest
+  } = useElement<Flow, UpdateFlowRequest, CreateFlowRequest, FlowAccessor>(
+    selector,
+    (integrationApp) => integrationApp.flow(selector),
   )
 
-  return { flow, ...rest }
+  async function apply(integrationKeys: string[]): Promise<Flow[]> {
+    const result = await accessor?.apply(integrationKeys)
+    await refresh()
+    return result
+  }
+
+  async function reset(): Promise<Flow> {
+    await accessor?.reset()
+    return await refresh()
+  }
+
+  return { flow, apply, reset, refresh, accessor, ...rest }
 }

package/src/flows/useFlowInstance.ts

@@ -2,15 +2,72 @@ import {
   FlowInstance,
   FlowInstanceAccessor,
   FlowInstanceSelector,
+  OpenFlowInstanceConfigurationOptions,
+  RunFlowOptions,
+  UpdateFlowInstanceRequest,
 } from '@integration-app/sdk'
 import { useElement } from '../hooks/useElement'
 
-export function useFlowInstance(props: FlowInstanceSelector | { id: string }) {
-  const { data: flowInstance, ...rest } = useElement<
+export function useFlowInstance(selector: string | FlowInstanceSelector) {
+  const {
+    item: flowInstance,
+    accessor,
+    refresh,
+    ...rest
+  } = useElement<
     FlowInstance,
-    FlowInstanceSelector,
+    UpdateFlowInstanceRequest,
+    UpdateFlowInstanceRequest,
     FlowInstanceAccessor
-  >(props, (integrationApp) => integrationApp.flowInstance.bind(integrationApp))
+  >(selector, (integrationApp) => integrationApp.flowInstance(selector))
 
-  return { flowInstance, ...rest }
+  async function enable() {
+    await accessor?.enable()
+    await refresh()
+  }
+
+  async function disable() {
+    await accessor?.disable()
+    await refresh()
+  }
+
+  async function reset() {
+    await accessor?.reset()
+    await refresh()
+  }
+
+  async function setup() {
+    await accessor?.setup()
+    await refresh()
+  }
+
+  async function openConfiguration(
+    options: OpenFlowInstanceConfigurationOptions,
+  ) {
+    return accessor?.openConfiguration(options)
+  }
+
+  async function run(options: RunFlowOptions = {}) {
+    return accessor?.run(options)
+  }
+
+  async function startRun(options: RunFlowOptions = {}) {
+    return accessor?.startRun(options)
+  }
+
+  return {
+    flowInstance,
+    accessor,
+    refresh,
+
+    enable,
+    disable,
+    reset,
+    setup,
+    openConfiguration,
+    run,
+    startRun,
+
+    ...rest,
+  }
 }

package/src/flows/useFlowInstances.ts

@@ -2,12 +2,10 @@ import { FindFlowInstancesQuery, FlowInstance } from '@integration-app/sdk'
 import { useElements } from '../hooks/useElements'
 
 export function useFlowInstances(query?: FindFlowInstancesQuery) {
-  const { ...rest } = useElements<FlowInstance, FindFlowInstancesQuery>(
-    query,
-    (integrationApp) => integrationApp.flowInstances,
-  )
+  const { ...rest } = useElements<FlowInstance>('flow-instances', query)
 
   return {
+    flowInstances: rest.items,
     ...rest,
   }
 }

package/src/flows/useFlowRun.ts

@@ -2,11 +2,23 @@ import { FlowRun, FlowRunAccessor } from '@integration-app/sdk'
 import { useElement } from '../hooks/useElement'
 
 export function useFlowRun(id: string) {
-  const { data: flowRun, ...rest } = useElement<
-    FlowRun,
-    string,
-    FlowRunAccessor
-  >(id, (integrationApp) => integrationApp.flowRun.bind(integrationApp))
+  const {
+    item: flowRun,
+    archive,
+    refresh,
+    error,
+    loading,
+  } = useElement<FlowRun, never, never, FlowRunAccessor>(id, (integrationApp) =>
+    integrationApp.flowRun(id),
+  )
 
-  return { flowRun, ...rest }
+  return {
+    flowRun,
+
+    error,
+    loading,
+
+    refresh,
+    archive,
+  }
 }

package/src/flows/useFlowRuns.ts

@@ -2,10 +2,10 @@ import { FindFlowRunsRequest, FlowRun } from '@integration-app/sdk'
 import { useElements } from '../hooks/useElements'
 
 export function useFlowRuns(query?: FindFlowRunsRequest) {
-  const { ...rest } = useElements<FlowRun, FindFlowRunsRequest>(
-    query,
-    (integrationApp) => integrationApp.flowRuns,
-  )
+  const { ...rest } = useElements<FlowRun>('flow-runs', query)
 
-  return { ...rest }
+  return {
+    flowRuns: rest.items,
+    ...rest,
+  }
 }

package/src/flows/useFlows.ts

@@ -2,10 +2,10 @@ import { useElements } from '../hooks/useElements'
 import { FindFlowsRequest, Flow } from '@integration-app/sdk'
 
 export function useFlows(query?: FindFlowsRequest) {
-  const { ...rest } = useElements<Flow, FindFlowsRequest>(
-    query,
-    (integrationApp) => integrationApp.flows,
-  )
+  const { ...rest } = useElements<Flow>('flows', query)
 
-  return { ...rest }
+  return {
+    flows: rest.items,
+    ...rest,
+  }
 }