@integration-app/react 0.1.1

package/node_modules/@integration-app/sdk/src/data-schema/index.test.ts

@@ -0,0 +1,90 @@
+import { excludeFieldsFromSchema, pickFieldsFromSchema } from '.'
+
+describe('pickFieldsFromSchema', () => {
+  const schema = {
+    type: 'object',
+    properties: {
+      key: {
+        type: 'string',
+        title: 'Key',
+      },
+      objKey: {
+        type: 'object',
+        title: 'Obj Key',
+        properties: {
+          subKey: { type: 'number', title: 'Sub Key of Obj Key' },
+        },
+      },
+    },
+  }
+
+  it('should pick top-level fields', () => {
+    expect(pickFieldsFromSchema(schema, ['key'])).toEqual({
+      type: 'object',
+      properties: {
+        key: schema.properties.key,
+      },
+    })
+
+    expect(pickFieldsFromSchema(schema, ['key', 'objKey'])).toEqual({
+      type: 'object',
+      properties: {
+        key: schema.properties.key,
+        objKey: schema.properties.objKey,
+      },
+    })
+  })
+
+  it('should pick a nested key', () => {
+    expect(pickFieldsFromSchema(schema, ['objKey.subKey'])).toEqual({
+      type: 'object',
+      properties: {
+        objKey: {
+          type: 'object',
+          properties: {
+            subKey: schema.properties.objKey.properties.subKey,
+          },
+        },
+      },
+    })
+  })
+})
+
+describe('excludeFieldsFromSchema', () => {
+  it('should exclude fields', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        key: {
+          type: 'string',
+          title: 'Key',
+        },
+        objKey: {
+          type: 'object',
+          title: 'Obj Key',
+          properties: {
+            subKey: { type: 'number', title: 'Sub Key of Obj Key' },
+          },
+        },
+      },
+    }
+
+    expect(excludeFieldsFromSchema(schema, ['key'])).toEqual({
+      type: 'object',
+      properties: {
+        objKey: schema.properties.objKey,
+      },
+    })
+
+    expect(excludeFieldsFromSchema(schema, ['objKey.subKey'])).toEqual({
+      type: 'object',
+      properties: {
+        key: schema.properties.key,
+        objKey: {
+          ...schema.properties.objKey,
+          properties: {},
+        },
+      },
+    })
+  })
+})

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

@@ -0,0 +1,185 @@
+import {
+  getLocatorsFromSchema,
+  getNameForLocator,
+  getSchemaByLocator,
+  setSchemaAtLocator,
+} from '../data-builder/locators'
+import { DataRecord } from '../data-collections'
+
+export type DataSchemaType =
+  | 'object'
+  | 'array'
+  | 'string'
+  | 'number'
+  | 'integer'
+  | 'boolean'
+  | 'null'
+
+export interface DataSchema {
+  /**
+   * Key used to identify this schema.
+   * Used, for example, in anyOf / oneOf schemas.
+   */
+  key?: string
+  /**
+   * Schema type.
+   *
+   * It is `string` instead of DataSchemaType because Typescript
+   * interpreter type auto-detection identifies type values as `string` type
+   * and can't math it to DataSchemaType
+   */
+  type?: string
+  /**
+   * Format for strings.
+   */
+  format?: string
+  /**
+   * Properties for `object` schema
+   */
+  properties?: { [key: string]: DataSchema }
+  /**
+   * Schema for array items
+   */
+  items?: DataSchema
+  /**
+   * For `object` schemas - whether value can contain properties besides
+   * ones listed in `properties`.
+   */
+  additionalProperties?: boolean
+  /**
+   * List of possible values for `string` schema.
+   */
+  enum?: string[]
+  /**
+   * List of Data Records that can be used as possible values.
+   */
+  referenceRecords?: DataRecord[]
+  /**
+   * Path of a Data Collection containing possible values.
+   */
+  referenceCollectionPath?: string
+  /**
+   * For UDM schemas - reference to another UDM
+   */
+  referenceUdm?: string
+  /**
+   * Default value that will be used if none is provided.
+   */
+  default?: any
+  /**
+   * If `true`, schema allows custom values besides ones in
+   * `enum`, `referenceRecords`, or `refrenceCollectionPath`.
+   */
+  allowCustom?: boolean
+  /**
+   * Schema that may be one of the listed schemas.
+   */
+  oneOf?: DataSchema[]
+  anyOf?: DataSchema[]
+  /**
+   * @deprecated - use referenceCollectionPath instead
+   */
+  referenceCollectionUri?: string
+}
+
+export function schemaIsScalar(schema: DataSchema) {
+  return (
+    schema.type != 'array' && schema.type != 'object' && schema.type != 'null'
+  )
+}
+
+export function schemaHasFixedValues(schema: DataSchema) {
+  if (!schema) {
+    return false
+  }
+
+  return (
+    schema.enum ||
+    schema.referenceCollectionUri ||
+    schema.referenceCollectionPath ||
+    schema.referenceRecords ||
+    schema.type === 'boolean'
+  )
+}
+
+export function schemaAllowsCustomValue(schema: DataSchema) {
+  return !schemaHasFixedValues(schema) || schema.allowCustom
+}
+
+export function schemaIsNumber(schema: DataSchema) {
+  return schema && (schema.type === 'number' || schema.type === 'integer')
+}
+
+export function schemaWithTitle(schema: DataSchema, title: string) {
+  return typeof schema === 'object'
+    ? {
+        ...schema,
+        title,
+      }
+    : schema
+}
+
+/**
+ * Creates an object schema with `fields` picked from the source `schema`.
+ */
+export function pickFieldsFromSchema(
+  schema: DataSchema,
+  fields: string[],
+): any {
+  const result = {
+    type: 'object',
+    properties: {},
+  }
+  if (schema?.type === 'object' && schema?.properties) {
+    for (const field of fields) {
+      setSchemaAtLocator(result, field, getSchemaByLocator(schema, field))
+    }
+  }
+  return result
+}
+
+/**
+ * Returns copy of `schema` without `fields`
+ */
+export function excludeFieldsFromSchema(
+  schema: DataSchema,
+  fields: string[],
+): any {
+  let result = JSON.parse(JSON.stringify(schema))
+  for (const field of fields ?? []) {
+    result = setSchemaAtLocator(result, field, undefined)
+  }
+  return result
+}
+
+export function findSchemaOption(schema: DataSchema, key: string) {
+  const options = schema?.anyOf ?? schema?.oneOf
+  if (!Array.isArray(options)) {
+    return null
+  }
+  let option = options.find((option) => option.key === key)
+  if (!option) {
+    const index = Number(key)
+    if (index !== NaN) {
+      option = options[index]
+    }
+  }
+  return option
+}
+
+/**
+ * Fills schema fields with human-readable titles.
+ */
+export function populateSchemaTitles(schema: any): void {
+  if (!schema || typeof schema !== 'object') {
+    return
+  }
+  const fields = getLocatorsFromSchema(schema)
+  for (const field of fields) {
+    const fieldSchema = getSchemaByLocator(schema, field)
+    if (!fieldSchema?.title) {
+      fieldSchema.title = getNameForLocator(schema, field)
+      setSchemaAtLocator(schema, field, fieldSchema)
+    }
+  }
+}

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

@@ -0,0 +1,133 @@
+import { IntegrationAppClient } from '..'
+import { DataSource, DataSourceInstance } from '.'
+import {
+  FindDataSourcesQuery,
+  UpdateDataSourceRequest,
+  FindDataSourceInstancesQuery,
+  UpdateDataSourceInstanceRequest,
+  DataSourceInstanceSelector,
+  CreateDataSourceRequest,
+  CreateDataSourceInstanceRequest,
+} from './api'
+import {
+  DataCollectionCreateRequest,
+  DataCollectionCreateResponse,
+  DataCollectionDeleteRequest,
+  DataCollectionDeleteResponse,
+  DataCollectionFindRequest,
+  DataCollectionFindResponse,
+  DataCollectionUpdateRequest,
+  DataCollectionUpdateResponse,
+} from '../connector-api'
+import { OpenConfigurationOptions, openIframe } from '../iframe'
+import {
+  ElementListAccessor,
+  ElementAccessor,
+  ElementInstanceListAccessor,
+  ElementInstanceAccessor,
+} from '../accessors'
+
+interface OpenDataSourceInstanceConfiguration
+  extends OpenConfigurationOptions {}
+
+export class DataSourcesAccessor extends ElementListAccessor<
+  DataSource,
+  FindDataSourcesQuery,
+  CreateDataSourceRequest
+> {
+  constructor(client: IntegrationAppClient) {
+    super(client, 'data-sources')
+  }
+}
+
+export class DataSourceAccessor extends ElementAccessor<
+  DataSource,
+  CreateDataSourceRequest,
+  UpdateDataSourceRequest
+> {
+  constructor(client: IntegrationAppClient, idOrKey: string) {
+    super({
+      client,
+      path: 'data-sources',
+      idOrKey,
+    })
+  }
+}
+
+export class DataSourceInstancesAccessor extends ElementInstanceListAccessor<
+  DataSourceInstance,
+  FindDataSourceInstancesQuery
+> {
+  constructor(client: IntegrationAppClient) {
+    super(client, 'data-source-instances')
+  }
+}
+
+export class DataSourceInstanceAccessor extends ElementInstanceAccessor<
+  DataSourceInstance,
+  DataSourceInstanceSelector,
+  CreateDataSourceInstanceRequest,
+  UpdateDataSourceInstanceRequest
+> {
+  constructor(
+    private client: IntegrationAppClient,
+    selector: string | DataSourceInstanceSelector,
+  ) {
+    super({
+      client,
+      listPath: 'data-source-instances',
+      selectorPath: 'data-source-instance',
+      selector,
+    })
+  }
+
+  async setup(): Promise<void> {
+    const id = await this.getId()
+    await this.client.post(`/data-source-instances/${id}/setup`)
+  }
+
+  async openConfiguration(
+    options?: OpenDataSourceInstanceConfiguration,
+  ): Promise<void> {
+    const id = await this.getId()
+    const uri = this.client.getEmbedUri(
+      `/data-source-instances/${id}/configuration`,
+    )
+    return openIframe(uri, {
+      onClose: options?.onClose,
+    })
+  }
+
+  async findRecords(
+    request: DataCollectionFindRequest = {},
+  ): Promise<DataCollectionFindResponse> {
+    const baseUri = await this.getRecordsBaseUri()
+    return this.client.get(baseUri, request)
+  }
+
+  async createRecord(
+    request: DataCollectionCreateRequest,
+  ): Promise<DataCollectionCreateResponse> {
+    const baseUri = await this.getRecordsBaseUri()
+    return this.client.post(baseUri, request)
+  }
+
+  async updateRecord(
+    request: DataCollectionUpdateRequest,
+  ): Promise<DataCollectionUpdateResponse> {
+    const baseUri = await this.getRecordsBaseUri()
+    return this.client.patch(`${baseUri}/${request.id}`, request)
+  }
+
+  async deleteRecord(
+    request: DataCollectionDeleteRequest,
+  ): Promise<DataCollectionDeleteResponse> {
+    const baseUri = await this.getRecordsBaseUri()
+    return this.client.patch(`${baseUri}/${request.id}`, request)
+  }
+
+  private async getRecordsBaseUri() {
+    const id = await this.getId()
+    return `/data-source-instances/${id}/records`
+  }
+}

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

@@ -0,0 +1,59 @@
+import { PaginationQuery, PaginationResponse } from '../entity-repository'
+import {
+  DataSource,
+  DataSourceEvent,
+  DataSourceInstance,
+  IDataSourceInstanceConfig,
+} from '.'
+import { ConnectionSelector } from '../connections/api'
+
+export interface DataSourceInstanceSelector extends ConnectionSelector {
+  dataSourceKey?: string
+  dataSourceId?: string
+
+  instanceKey?: string
+
+  autoCreate?: boolean
+}
+
+export interface FindDataSourcesQuery extends PaginationQuery {}
+
+export type FindDataSourcesResponse = PaginationResponse<DataSource>
+
+export interface FindDataSourceInstancesQuery extends PaginationQuery {
+  userId?: string
+
+  dataSourceId?: string
+
+  connectionId?: string
+}
+
+export type FindDataSourceInstancesResponse =
+  PaginationResponse<DataSourceInstance>
+
+export type CreateDataSourceRequest = Omit<DataSource, 'id'>
+
+export type UpdateDataSourceRequest = Partial<CreateDataSourceRequest>
+
+export interface CreateDataSourceInstanceRequest {
+  dataSourceId: string
+
+  connectionId: string
+
+  config?: IDataSourceInstanceConfig
+}
+
+export interface UpdateDataSourceInstanceRequest {
+  config?: IDataSourceInstanceConfig
+}
+
+export interface FindDataSourceEventsQuery extends PaginationQuery {
+  userId?: string
+  dataSourceId?: string
+  dataSourceInstanceId?: string
+  startDatetime?: string
+  endDatetime?: string
+}
+
+export interface FindDataSourceEventsResponse
+  extends PaginationResponse<DataSourceEvent> {}

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

@@ -0,0 +1,103 @@
+import { User } from '../users'
+import { Connection } from '../connections'
+import { Integration } from '../integrations'
+import { ErrorData } from '../errors'
+
+export interface DataSource {
+  id: string
+
+  name: string
+
+  key: string
+
+  udm?: string
+}
+
+export interface IDataSourceInstanceConfig {
+  path?: string
+}
+
+export interface DataSourceInstance {
+  id: string
+
+  uuid: string
+
+  userId: string
+
+  user?: User
+
+  dataSourceId?: string
+
+  dataSource?: DataSource
+
+  instanceKey?: string
+
+  connectionId: string
+
+  connection?: Connection
+
+  integrationId: string
+
+  integration?: Integration
+
+  udm?: string
+
+  /**
+   * Path to the root of the data source (where user can choose the specific path from)
+   */
+  rootPath?: string
+
+  /**
+   * Calculated based on config and `defaultPath`
+   */
+  path?: string
+
+  /**
+   * Default path of the instance - used if user doesn't set up one.
+   */
+  defaultPath?: string
+
+  config?: IDataSourceInstanceConfig
+
+  error?: ErrorData
+
+  subscribedTo?: {
+    created?: boolean
+    updated?: boolean
+    deleted?: boolean
+  }
+
+  nextPullTimestamp?: number
+
+  pullAttempts?: number
+}
+
+export interface DataSourceEvent {
+  id: string
+
+  userId: string
+
+  user?: User
+
+  dataSourceId: string
+
+  dataSource?: DataSource
+
+  dataSourceInstanceId: string
+
+  dataSourceInstance?: DataSourceInstance
+
+  integrationId: string
+
+  integration?: Integration
+
+  connectionId: string
+
+  connection?: Connection
+
+  event: any
+
+  datetime: string
+
+  launchedFlowRunIds: string[]
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Parses string into a date object, taking timezones in account.
+ * @param str
+ * @returns
+ */
+export function parseDatetime(str: string): Date {
+  // Set timezone to UTC to avoid issues with different timezones
+  process.env.TZ = 'UTC'
+
+  const timestamp = Date.parse(str)
+  if (!isNaN(timestamp)) {
+    return new Date(timestamp)
+  } else {
+    return null
+  }
+}

package/node_modules/@integration-app/sdk/src/entity-repository.ts

@@ -0,0 +1,12 @@
+export class PaginationQuery {
+  limit?: number
+  offset?: number
+}
+
+export class PaginationResponse<T> {
+  items: T[]
+  nextPage: {
+    offset: string
+    path: string
+  }
+}