@integration-app/react 0.1.26 → 0.2.1

package/README.md

@@ -0,0 +1,83 @@
+## Releasing Package
+
+To release a new version of a package (@integration-app/sdk, @integration-app/ui, @integration-app/react), do the following:
+
+* Go to the package and type `npm version -- patch` (or `npm version -- minor` or `npm version -- major`) to bump the version.
+* Create a PR with the changes.
+* Merge the PR.
+* Run a Github Action to publish a package.
+
+
+# Rollup Configuration
+
+To see the complete configuration, refer to the `rollup.config.mjs` and `rollup.dts.config.mjs` files. Although these files are self-explanatory, here's some additional information:
+
+In `rollup.config.mjs`, we set `{external: [/node_modules/]}` to exclude our dependencies from being bundled.
+
+## Bundle and DTS File Generation
+
+We encountered issues with `rollup-plugin-dts` generating incorrect DTS files when used in the same configuration as `@rollup/plugin-typescript`. To resolve this, we use two Rollup configurations:
+- `rollup.config.mjs` for bundle generation
+- `rollup.dts.config.mjs` for DTS file generation.
+
+## Externals
+
+We set external dependencies in `rollup.config.mjs`:
+- `{external: [/node_modules/]}` to exclude all `node_modules`.
+- `@integration-app/sdk` to prevent Rollup from bundling the `@integration-app/sdk` package during local development, when it is used via a symlink to the SDK in the root folder.
+- `react` and `react/jsx-runtime` are excluded to avoid unresolved dependency errors, as React is a peer dependency.
+
+## Bundle and DTS File Generation Workflow
+
+When using `rollup-plugin-dts` and `@rollup/plugin-typescript` in the same configuration, we experienced issues with generating incorrect DTS files. To solve this, we use two Rollup configurations:
+- `rollup.config.mjs` for generating bundles
+- `rollup.dts.config.mjs` for generating DTS files.
+
+### Build 
+
+For local build, the following steps are taken:
+
+- Clean the `/dist` folder.
+- Install local `@integration-app/sdk` pointed to `sdk` folder
+- Remove `react` and `react-dom` packages from `node_modules` folder
+  - We should do it to allow out package work in `console`, `engine` and other local projects
+- Rollup with `rollup.config.mjs` configuration generates bundle files and basic DTS files, which are placed in the `dist/dts` folder.
+- Rollup with `rollup.dts.config.mjs` configuration uses the basic DTS files to generate `*.d.ts` files for each bundle.
+
+### Development
+
+During development, the following steps are taken:
+
+- Run `build` to generate bundle and DTS files.
+  - If not, Rollup with `rollup.dts.config.mjs` in watch mode fails due to missing DTS files (race condition).
+- Concurrently run two Rollup processes **in watch mode**:
+  - Rollup with `rollup.config.mjs` configuration to generate bundle files and basic DTS files.
+  - Rollup with `rollup.dts.config.mjs` configuration to generate DTS files for each bundle.
+
+### Publish via GitHub
+
+During publishing via GitHub, the following steps are taken:
+
+- Clean the `/dist` folder.
+- Install `@integration-app/sdk@latest` package
+- Rollup with `rollup.config.mjs` configuration generates bundle files and basic DTS files, which are placed in the `dist/dts` folder.
+- Rollup with `rollup.dts.config.mjs` configuration uses the basic DTS files to generate `*.d.ts` files for each bundle.
+
+The `build:publish` command is used in GitHub Actions to ensure that the package uses the latest `@integration-app/sdk` package.
+
+# Package.json exports
+
+```json5
+{
+  "exports": {
+    "types": "./dist/index.d.ts",       // TypeScript typings for NodeNext modules
+    "require": "./dist/index.js",       // used for require() in Node 12+
+    "import": "./dist/index.module.mjs" // ESM bundle
+  },
+  "types": "./dist/index.d.ts",         // TypeScript typings
+  "main": "./dist/index.js",            // CommonJS bundle
+  "module": "./dist/index.module.mjs",  // ESM bundle
+  "unpkg": "./dist/index.umd.js",       // UMD bundle
+}
+```
+

package/dist/index.d.ts

@@ -0,0 +1,302 @@
+import * as _integration_app_sdk from '@integration-app/sdk';
+import { IntegrationAppClient, ConnectionSpec, Integration, IntegrationAccessor, FindIntegrationsQuery, Connection, ConnectionAccessor, FindConnectionsQuery, FieldMapping, FieldMappingAccessor, FindFieldMappingsQuery, FieldMappingInstanceSelector, FieldMappingInstance, FieldMappingInstanceAccessor, OpenFieldMappingInstanceConfigurationOptions, FindFieldMappingInstancesQuery, DataSource, DataSourceAccessor, FindDataSourcesQuery, DataSourceInstanceSelector, DataSourceInstance, DataSourceInstanceAccessor, OpenDataSourceConfigurationOptions, DataCollectionFindRequest, DataCollectionCreateRequest, DataCollectionUpdateRequest, FindDataSourceInstancesQuery, DataCollectionSpec, FindDataSourceEventsQuery, DataSourceEvent, FindAppEventsQuery, AppEvent, AppEventType, AppEventTypeAccessor, FindAppEventTypesQuery, AppEventSubscriptionSelector, AppEventSubscription, AppEventSubscriptionAccessor, FindAppEventSubscriptionsQuery, FlowSelector, Flow, FlowAccessor, FindFlowsRequest, FlowInstanceSelector, FlowInstance, FlowInstanceAccessor, FindFlowInstancesQuery, FlowRun, FlowRunAccessor, FindFlowRunsRequest } from '@integration-app/sdk';
+export { DataForm } from '@integration-app/sdk';
+import { ReactNode } from 'react';
+
+interface IntegrationAppProviderProps {
+    token?: string;
+    fetchToken?: () => Promise<string>;
+    credentials?: any;
+    fetchCredentials?: () => Promise<any>;
+    apiUri?: string;
+    uiUri?: string;
+    children: ReactNode;
+}
+declare const IntegrationAppProvider: ({ token, fetchToken, credentials, fetchCredentials, apiUri, uiUri, children, }: IntegrationAppProviderProps) => JSX.Element;
+declare function useIntegrationApp(): IntegrationAppClient;
+
+declare function useConnectorSpec(integrationKey: string): {
+    data: ConnectionSpec;
+    loading: boolean;
+    error: Error;
+};
+
+declare function useIntegration(idOrKey: string): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.CreateIntegrationRequest) => Promise<Integration>;
+    patch: (data: _integration_app_sdk.UpdateIntegrationRequest) => Promise<Integration>;
+    put: (data: _integration_app_sdk.CreateIntegrationRequest) => Promise<Integration>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: IntegrationAccessor;
+    integration: Integration;
+};
+
+declare function useIntegrations(query?: FindIntegrationsQuery): {
+    items: Integration[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useConnection(id: string): {
+    loading: boolean;
+    error?: Error;
+    create: (data: Partial<Connection>) => Promise<Connection>;
+    patch: (data: Partial<Connection>) => Promise<Connection>;
+    put: (data: Partial<Connection>) => Promise<Connection>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: ConnectionAccessor;
+    connection: Connection;
+};
+
+declare function useConnections(query?: FindConnectionsQuery): {
+    items: Connection[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useFieldMapping(idOrKey: string): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.CreateFieldMappingRequest) => Promise<FieldMapping>;
+    patch: (data: Partial<_integration_app_sdk.CreateFieldMappingRequest>) => Promise<FieldMapping>;
+    put: (data: _integration_app_sdk.CreateFieldMappingRequest) => Promise<FieldMapping>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: FieldMappingAccessor;
+    fieldMapping: FieldMapping;
+};
+
+declare function useFieldMappings(query?: FindFieldMappingsQuery): {
+    items: FieldMapping[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useFieldMappingInstance(selector: FieldMappingInstanceSelector | {
+    id: string;
+}): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.CreateFieldMappingInstanceRequest) => Promise<FieldMappingInstance>;
+    patch: (data: _integration_app_sdk.UpdateFieldMappingInstanceRequest) => Promise<FieldMappingInstance>;
+    put: (data: _integration_app_sdk.CreateFieldMappingInstanceRequest) => Promise<FieldMappingInstance>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: FieldMappingInstanceAccessor;
+    fieldMappingInstance: FieldMappingInstance;
+    setup: () => Promise<void>;
+    reset: () => Promise<void>;
+    openConfiguration: (options?: OpenFieldMappingInstanceConfigurationOptions) => Promise<void>;
+};
+
+declare function useFieldMappingInstances(query?: FindFieldMappingInstancesQuery): {
+    items: FieldMappingInstance[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useDataSource(idOrKey: string): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.CreateDataSourceRequest) => Promise<DataSource>;
+    patch: (data: Partial<_integration_app_sdk.CreateDataSourceRequest>) => Promise<DataSource>;
+    put: (data: _integration_app_sdk.CreateDataSourceRequest) => Promise<DataSource>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: DataSourceAccessor;
+    dataSource: DataSource;
+};
+
+declare function useDataSources(query?: FindDataSourcesQuery): {
+    items: DataSource[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useDataSourceInstance(selector: DataSourceInstanceSelector | {
+    id: string;
+}): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.CreateDataSourceInstanceRequest) => Promise<DataSourceInstance>;
+    patch: (data: _integration_app_sdk.UpdateDataSourceInstanceRequest) => Promise<DataSourceInstance>;
+    put: (data: _integration_app_sdk.CreateDataSourceInstanceRequest) => Promise<DataSourceInstance>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: DataSourceInstanceAccessor;
+    dataSourceInstance: DataSourceInstance;
+    setup: () => Promise<void>;
+    subscribe: (eventType: any) => Promise<void>;
+    resubscribe: (eventType: any) => Promise<void>;
+    unsubscribe: (eventType: any) => Promise<void>;
+    pullUpdates: () => Promise<void>;
+    fullSync: () => Promise<void>;
+    reset: () => Promise<void>;
+    openConfiguration: (options?: OpenDataSourceConfigurationOptions) => Promise<void>;
+    findRecords: (request?: DataCollectionFindRequest) => Promise<_integration_app_sdk.DataCollectionFindResponse>;
+    findRecordById: (id: string) => Promise<_integration_app_sdk.DataCollectionFindByIdResponse>;
+    createRecord: (request?: DataCollectionCreateRequest) => Promise<_integration_app_sdk.DataCollectionCreateResponse>;
+    updateRecord: (request?: DataCollectionUpdateRequest) => Promise<_integration_app_sdk.DataCollectionUpdateResponse>;
+    deleteRecord: (id?: string) => Promise<_integration_app_sdk.DataCollectionDeleteResponse>;
+    unifiedFieldsToNative: (unifiedFields: any) => Promise<any>;
+};
+
+declare function useDataSourceInstances(query?: FindDataSourceInstancesQuery): {
+    items: DataSourceInstance[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useDataSourceInstanceCollection(dataSourceInstance: DataSourceInstance): {
+    loading: boolean;
+    error: Error;
+    refresh: () => void;
+    collection: DataCollectionSpec;
+};
+
+declare function useDataSourceInstanceLocations(dataSourceInstance: DataSourceInstance, args?: {
+    path?: string;
+    cursor?: string;
+}): {
+    loading: boolean;
+    error: Error;
+    refresh: () => void;
+    locations: _integration_app_sdk.DataLocation[];
+};
+
+declare function useDataSourceEvents(query?: FindDataSourceEventsQuery): {
+    items: DataSourceEvent[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useAppEvents(query?: FindAppEventsQuery): {
+    items: AppEvent[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useAppEventType(idOrKey: string): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.CreateAppEventTypeRequest) => Promise<AppEventType>;
+    patch: (data: _integration_app_sdk.CreateAppEventTypeRequest) => Promise<AppEventType>;
+    put: (data: _integration_app_sdk.CreateAppEventTypeRequest) => Promise<AppEventType>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: AppEventTypeAccessor;
+    appEventType: AppEventType;
+};
+
+declare function useAppEventTypes(query?: FindAppEventTypesQuery): {
+    items: AppEventType[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useAppEventSubscription(selector: AppEventSubscriptionSelector | {
+    id: string;
+}): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.IAppEventSubscriptionUpdate) => Promise<AppEventSubscription>;
+    patch: (data: _integration_app_sdk.IAppEventSubscriptionUpdate) => Promise<AppEventSubscription>;
+    put: (data: _integration_app_sdk.IAppEventSubscriptionUpdate) => Promise<AppEventSubscription>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: AppEventSubscriptionAccessor;
+    appEventSubscription: AppEventSubscription;
+};
+
+declare function useAppEventSubscriptions(query?: FindAppEventSubscriptionsQuery): {
+    items: AppEventSubscription[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useFlow(idOrSelector: string | FlowSelector): {
+    loading: boolean;
+    error?: Error;
+    create: (data: Partial<Flow>) => Promise<Flow>;
+    patch: (data: Partial<Flow>) => Promise<Flow>;
+    put: (data: Partial<Flow>) => Promise<Flow>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: FlowAccessor;
+    flow: Flow;
+};
+
+declare function useFlows(query?: FindFlowsRequest): {
+    items: Flow[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useFlowInstance(props: FlowInstanceSelector | {
+    id: string;
+}): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.CreateFlowInstanceRequest) => Promise<FlowInstance>;
+    patch: (data: _integration_app_sdk.UpdateFlowInstanceRequest) => Promise<FlowInstance>;
+    put: (data: _integration_app_sdk.CreateFlowInstanceRequest) => Promise<FlowInstance>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: FlowInstanceAccessor;
+    flowInstance: FlowInstance;
+};
+
+declare function useFlowInstances(query?: FindFlowInstancesQuery): {
+    items: FlowInstance[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useFlowRun(id: string): {
+    loading: boolean;
+    error?: Error;
+    create: (data: Partial<FlowRun>) => Promise<FlowRun>;
+    patch: (data: Partial<FlowRun>) => Promise<FlowRun>;
+    put: (data: Partial<FlowRun>) => Promise<FlowRun>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: FlowRunAccessor;
+    flowRun: FlowRun;
+};
+
+declare function useFlowRuns(query?: FindFlowRunsRequest): {
+    items: FlowRun[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+export { IntegrationAppProvider, useAppEventSubscription, useAppEventSubscriptions, useAppEventType, useAppEventTypes, useAppEvents, useConnection, useConnections, useConnectorSpec, useDataSource, useDataSourceInstanceCollection as useDataSourceCollection, useDataSourceEvents, useDataSourceInstance, useDataSourceInstances, useDataSourceInstanceLocations as useDataSourceLocations, useDataSources, useFieldMapping, useFieldMappingInstance, useFieldMappingInstances, useFieldMappings, useFlow, useFlowInstance, useFlowInstances, useFlowRun, useFlowRuns, useFlows, useIntegration, useIntegrationApp, useIntegrations };