@integration-app/react 0.1.1 → 0.1.2

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

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

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

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

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

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

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

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