@integration-app/react 0.1.1 → 0.1.2

package/node_modules/@integration-app/sdk/src/data-filter/operators.ts

@@ -1,163 +0,0 @@
-import {
-  schemaAllowsCustomValue,
-  schemaIsNumber,
-  schemaIsScalar,
-} from '../data-schema'
-
-export const DEFAULT_CONDITION_TYPE_KEY = 'equals'
-
-export interface DataFilterOperator {
-  type: string
-  name: string
-  operandSchema: any
-}
-
-export interface DataFilterOperatorSpec {
-  name: string
-  handler: (fieldValue: any, operand: any) => boolean
-  applicableToSchema: (schema: any) => boolean
-  getOperandSchema: (schema: any) => any
-}
-
-export const OPERATORS: Record<string, DataFilterOperatorSpec> = {
-  is: {
-    name: 'is',
-    handler: (value, operand) => value == operand,
-    applicableToSchema: (schema) =>
-      schemaIsScalar(schema) && schema.type !== 'boolean',
-    getOperandSchema: (schema) => schema,
-  },
-  is_not: {
-    name: 'is not',
-    handler: (value, operand) => value != operand,
-    applicableToSchema: (schema) =>
-      schemaIsScalar(schema) && schema.type !== 'boolean',
-    getOperandSchema: (schema) => schema,
-  },
-  is_one_of: {
-    name: 'is one of',
-    handler: (value, operand) =>
-      Array.isArray(operand) && operand.includes(value),
-    applicableToSchema: (schema) =>
-      schemaIsScalar(schema) && schema.type !== 'boolean',
-    getOperandSchema: (schema) => ({ type: 'array', items: schema }),
-  },
-  is_not_one_of: {
-    name: 'is not one of',
-    handler: (value, operand) =>
-      !Array.isArray(operand) || !operand.includes(value),
-    applicableToSchema: (schema) =>
-      schemaIsScalar(schema) && schema.type !== 'boolean',
-    getOperandSchema: (schema) => ({ type: 'array', items: schema }),
-  },
-  is_true: {
-    name: 'is true',
-    handler: (value) => !!value,
-    applicableToSchema: (schema) => schema.type === 'boolean',
-    getOperandSchema: () => null,
-  },
-  is_false: {
-    name: 'is false',
-    handler: (value) => value === false,
-    applicableToSchema: (schema) => schema.type === 'boolean',
-    getOperandSchema: () => null,
-  },
-  contains: {
-    name: 'contains',
-    handler: (value, operand) =>
-      value ? value.toString().includes(operand) : false,
-    applicableToSchema: (schema) =>
-      schema?.type === 'string' && schemaAllowsCustomValue(schema),
-    getOperandSchema: () => ({ type: 'string' }),
-  },
-  does_not_contain: {
-    name: 'does not contain',
-    handler: (value, operand) =>
-      value ? !value.toString().includes(operand) : false,
-    applicableToSchema: (schema) =>
-      schema?.type === 'string' && schemaAllowsCustomValue(schema),
-    getOperandSchema: () => ({ type: 'string' }),
-  },
-  array_includes: {
-    name: 'includes',
-    handler: (value, operand) =>
-      Array.isArray(value) && value.indexOf(operand) !== -1,
-    applicableToSchema: (schema) => schema?.type === 'array' && schema.items,
-    getOperandSchema: (schema) => schema.items,
-  },
-  array_does_not_include: {
-    name: 'does not include',
-    handler: (value, operand) =>
-      !Array.isArray(value) || value.indexOf(operand) === -1,
-    applicableToSchema: (schema) => schema?.type === 'array' && schema.items,
-    getOperandSchema: (schema) => schema.items,
-  },
-  less_than: {
-    name: 'less than',
-    handler: (value, operand) => {
-      return parseFloat(value) === NaN || parseFloat(operand) === NaN
-        ? false
-        : parseFloat(value) < parseFloat(operand)
-    },
-    applicableToSchema: (schema) => schemaIsNumber(schema),
-    getOperandSchema: () => ({ type: 'number' }),
-  },
-  less_than_or_equal: {
-    name: 'less than or equal',
-    handler: (value, operand) => {
-      return parseFloat(value) === NaN || parseFloat(operand) === NaN
-        ? false
-        : parseFloat(value) <= parseFloat(operand)
-    },
-    applicableToSchema: (schema) => schemaIsNumber(schema),
-    getOperandSchema: () => ({ type: 'number' }),
-  },
-  more_than: {
-    name: 'more than',
-    handler: (value, operand) => {
-      return parseFloat(value) === NaN || parseFloat(operand) === NaN
-        ? false
-        : parseFloat(value) > parseFloat(operand)
-    },
-    applicableToSchema: (schema) => schemaIsNumber(schema),
-    getOperandSchema: () => ({ type: 'number' }),
-  },
-  more_than_or_equal: {
-    name: 'more than or equal',
-    handler: (value, operand) => {
-      return parseFloat(value) === NaN || parseFloat(operand) === NaN
-        ? false
-        : parseFloat(value) >= parseFloat(operand)
-    },
-    applicableToSchema: (schema) => schemaIsNumber(schema),
-    getOperandSchema: () => ({ type: 'number' }),
-  },
-  is_not_empty: {
-    name: 'is not empty',
-    handler: (value) => {
-      if (Array.isArray(value)) {
-        return value.length > 0
-      } else if (typeof value === 'object') {
-        return value !== null && Object.keys(value).length > 0
-      } else {
-        return value !== undefined && value !== ''
-      }
-    },
-    applicableToSchema: () => true,
-    getOperandSchema: () => null,
-  },
-  is_empty: {
-    name: 'is empty',
-    handler: (value) => {
-      if (Array.isArray(value)) {
-        return value.length === 0
-      } else if (typeof value === 'object') {
-        return value === null || Object.keys(value).length === 0
-      } else {
-        return value === undefined || value === ''
-      }
-    },
-    applicableToSchema: () => true,
-    getOperandSchema: () => null,
-  },
-}

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

@@ -1,108 +0,0 @@
-import { IntegrationAppClient } from '..'
-import { DataLink, DataLinkTable, DataLinkTableInstance } from '.'
-import {
-  CreateDataLinkTableInstanceRequest,
-  CreateDataLinkTableRequest,
-  DataLinkInTableSelector,
-  DataLinkTableInstanceSelector,
-  FindDataLinksInTableQuery,
-  FindDataLinksResponse,
-  FindDataLinkTableInstancesQuery,
-  FindDataLinkTablesQuery,
-  UpdateDataLinkTableInstanceRequest,
-  UpdateDataLinkTableRequest,
-} from './api'
-import qs from 'query-string'
-import {
-  ElementAccessor,
-  ElementInstanceAccessor,
-  ElementInstanceListAccessor,
-  ElementListAccessor,
-} from '../accessors'
-
-export class DataLinkTablesAccessor extends ElementListAccessor<
-  DataLinkTable,
-  FindDataLinkTablesQuery,
-  CreateDataLinkTableRequest
-> {
-  constructor(client: IntegrationAppClient) {
-    super(client, 'data-link-tables')
-  }
-}
-
-export class DataLinkTableAccessor extends ElementAccessor<
-  DataLinkTable,
-  CreateDataLinkTableRequest,
-  UpdateDataLinkTableRequest
-> {
-  constructor(client: IntegrationAppClient, idOrKey: string) {
-    super({
-      client,
-      path: 'data-link-tables',
-      idOrKey,
-    })
-  }
-}
-
-export class DataLinkTableInstancesAccessor extends ElementInstanceListAccessor<
-  DataLinkTableInstance,
-  FindDataLinkTableInstancesQuery
-> {
-  constructor(client: IntegrationAppClient) {
-    super(client, 'data-link-table-instances')
-  }
-}
-
-export class DataLinkTableInstanceAccessor extends ElementInstanceAccessor<
-  DataLinkTableInstance,
-  DataLinkTableInstanceSelector,
-  CreateDataLinkTableInstanceRequest,
-  UpdateDataLinkTableInstanceRequest
-> {
-  constructor(
-    private client: IntegrationAppClient,
-    selector: string | DataLinkTableInstanceSelector,
-  ) {
-    super({
-      client,
-      listPath: 'data-link-table-instances',
-      selectorPath: 'data-link-table-instance',
-      selector,
-    })
-  }
-
-  async findLinks(
-    query: FindDataLinksInTableQuery,
-  ): Promise<FindDataLinksResponse> {
-    const id = await this.getId()
-    return this.client.get(
-      '/data-links?' +
-        qs.stringify({
-          ...query,
-          dataLinkTableInstanceId: id,
-        }),
-    )
-  }
-
-  async addLink(selector: DataLinkInTableSelector): Promise<DataLink> {
-    const id = await this.getId()
-    return this.client.post(
-      '/data-links?' +
-        qs.stringify({
-          ...selector,
-          dataLinkTableInstanceId: id,
-        }),
-    )
-  }
-
-  async removeLink(selector: DataLinkInTableSelector): Promise<DataLink> {
-    const id = await this.getId()
-    return this.client.delete(
-      '/data-links?' +
-        qs.stringify({
-          ...selector,
-          dataLinkTableInstanceId: id,
-        }),
-    )
-  }
-}

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

@@ -1,75 +0,0 @@
-import {
-  DataLink,
-  DataLinkDirection,
-  DataLinkTable,
-  DataLinkTableInstance,
-} from '.'
-import { ConnectionSelector } from '../connections/api'
-import { PaginationQuery, PaginationResponse } from '../entity-repository'
-
-export type CreateDataLinkTableRequest = Omit<DataLink, 'id' | 'userId'>
-
-export type UpdateDataLinkTableRequest = CreateDataLinkTableRequest
-
-export interface FindDataLinkTablesQuery extends PaginationQuery {}
-
-export type FindDataLinkTablesResponse = PaginationResponse<DataLinkTable>
-
-export interface FindDataLinkTableInstancesQuery extends PaginationQuery {
-  connectionId?: string
-  integrationId?: string
-  dataLinkTableId?: string
-}
-
-export interface FindDataLinkTableInstancesResponse
-  extends PaginationResponse<DataLinkTableInstance> {}
-
-export interface DataLinkTableInstanceSelector extends ConnectionSelector {
-  dataLinkTableId?: string
-  dataLinkTableKey?: string
-
-  autoCreate?: boolean
-}
-
-export interface CreateDataLinkTableInstanceRequest {
-  name?: string
-}
-
-export interface UpdateDataLinkTableInstanceRequest
-  extends CreateDataLinkTableInstanceRequest {}
-
-export interface FindDataLinksInTableQuery extends PaginationQuery {
-  direction?: DataLinkDirection
-
-  appRecordId?: string
-
-  externalRecordId?: string
-}
-
-export interface FindDataLinksQuery
-  extends PaginationQuery,
-    FindDataLinksInTableQuery {
-  dataLinkTableInstanceId?: string
-}
-
-export interface FindDataLinksResponse extends PaginationResponse<DataLink> {}
-
-export interface FindDataLinkQuery extends PaginationQuery {
-  dataLinkTableInstanceId: string
-
-  externalRecordId: string
-
-  appRecordId: string
-
-  direction: DataLinkDirection
-}
-
-export interface DataLinkInTableSelector {
-  appRecordId: string
-  externalRecordId: string
-  direction: DataLinkDirection
-}
-
-export interface DataLinkSelector extends DataLinkInTableSelector {
-  dataLinkTableInstanceId: string
-}

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

@@ -1,55 +0,0 @@
-import { User } from '../users'
-import { Connection } from '../connections'
-import { Integration } from '../integrations'
-
-export enum DataLinkDirection {
-  IMPORT = 'import',
-  EXPORT = 'export',
-  BOTH = 'both',
-}
-
-export interface DataLinkTable {
-  id: string
-
-  key: string
-
-  name: string
-}
-
-export interface DataLinkTableInstance {
-  id: string
-
-  dataLinkTableId?: string
-
-  dataLinkTable?: DataLinkTable
-
-  connectionId?: string
-
-  connection?: Connection
-
-  integrationId: string
-
-  integration?: Integration
-
-  userId: string
-
-  user?: User
-
-  name: string
-}
-
-export interface DataLink {
-  id: string
-
-  dataLinkTableInstanceId: string
-
-  externalRecordId: string
-
-  appRecordId: string
-
-  direction: DataLinkDirection
-}
-
-export interface DataLinkTableConfig {
-  key: string
-}

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

@@ -1,24 +0,0 @@
-import { IntegrationAppClient } from '../client'
-import { DataLocationSelector } from './api'
-import qs from 'query-string'
-
-export class DataLocationAccessor {
-  constructor(
-    private client: IntegrationAppClient,
-    private selector: DataLocationSelector,
-  ) {}
-
-  async get() {
-    return this.client.get(this.getPath())
-  }
-
-  async list() {
-    return this.client.get(this.getPath('list'))
-  }
-
-  private getPath(subpath = '') {
-    return `/data-location${subpath ? `/${subpath}` : ''}?${qs.stringify(
-      this.selector,
-    )}`
-  }
-}

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

@@ -1,5 +0,0 @@
-import { ConnectionSelector } from '../connections/api'
-
-export interface DataLocationSelector extends ConnectionSelector {
-  path: string
-}

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

@@ -1,209 +0,0 @@
-import urljoin from 'url-join'
-import { DataCollectionEvent, DataRecord } from '../data-collections'
-
-export { DataLocationSelector } from './api'
-
-export enum DataLocationType {
-  directory = 'directory',
-  collection = 'collection',
-}
-
-export interface DataLocation {
-  path?: string
-
-  name?: string
-
-  type?: DataLocationType
-
-  isDefault?: boolean
-
-  read?: boolean
-
-  write?: boolean
-}
-
-export type DataLocationSpec = DataCollectionSpec | DataDirectorySpec
-
-export interface DataCollectionSpec {
-  type: DataLocationType.collection
-
-  name: string
-
-  fieldsSchema?: any
-
-  find?: DataCollectionFindSpec
-
-  findById?: DataCollectionFindByIdSpec
-
-  create?: DataCollectionCreateSpec
-
-  update?: DataCollectionUpdateSpec
-
-  delete?: DataCollectionDeleteSpec
-
-  udm?: DataCollectionUdmSpec
-}
-
-/**
- * @deprecated
- */
-export type DataCollection = DataCollectionSpec
-
-export interface DataDirectorySpec {
-  type: DataLocationType.directory
-  name?: string
-}
-
-interface DataCollectionOperationResponse {
-  logs?: any[]
-}
-
-export interface DataCollectionFindSpec {
-  queryFields?: string[]
-}
-
-export interface DataCollectionFindByIdSpec {}
-
-export interface DataCollectionCreateSpec {
-  fields?: string[]
-  requiredFields?: string[]
-  excludedFields?: string[]
-  /**
-   * @deprecated
-   */
-  excludeFields?: string[]
-}
-
-export interface DataCollectionUpdateSpec {
-  fields?: string[]
-  excludedFields?: string[]
-  /**
-   * @deprecated
-   */
-  excludeFields?: string[]
-}
-
-export interface DataCollectionDeleteSpec {}
-
-export type DataCollectionUdmSpec = Record<string, Record<string, any>>
-
-export interface DataCollectionFindRequest {
-  query?: any
-  cursor?: string
-  udm?: string
-}
-
-export interface DataCollectionFindResponse
-  extends DataCollectionOperationResponse {
-  records: DataRecord[]
-  cursor?: string
-}
-
-export interface DataCollectionFindByIdRequest {
-  id: string
-  udm?: string
-}
-
-export interface DataCollectionFindByIdResponse
-  extends DataCollectionOperationResponse {
-  record: DataRecord
-}
-
-export interface DataCollectionCreateRequest {
-  fields: Record<string, any>
-}
-
-export interface DataCollectionCreateResponse
-  extends DataCollectionOperationResponse,
-    DataRecord {}
-
-export interface DataCollectionUpdateRequest {
-  id: string
-  fields: Record<string, any>
-}
-
-export interface DataCollectionUpdateResponse
-  extends DataCollectionOperationResponse,
-    DataRecord {}
-
-export interface DataCollectionDeleteRequest {
-  id: string
-}
-
-export interface DataCollectionDeleteResponse
-  extends DataCollectionOperationResponse {}
-
-export interface DataCollectionSubscribeRequest {
-  events?: {
-    created?: boolean
-    updated?: boolean
-    deleted?: boolean
-  }
-  udm?: string
-  webhookUri: string
-}
-
-export interface DataCollectionSubscribeResponse {
-  subscriptionId: string
-  pullIntervalSeconds?: number
-  cursor?: string
-}
-
-export interface DataCollectionUpdateSubscriptionRequest
-  extends DataCollectionSubscribeRequest {
-  subscriptionId: string
-  cursor?: string
-}
-
-export interface DataCollectionUpdateSubscriptionResponse
-  extends Omit<DataCollectionSubscribeResponse, 'subscriptionId'> {}
-
-export interface DataCollectionUnsubscribeRequest {
-  subscriptionId: string
-}
-
-export interface DataCollectionUnsubscribeResponse {}
-
-export interface DataCollectionEventsRequest {
-  subscriptionId: string
-  cursor: string
-}
-
-export interface DataCollectionEventsResponse {
-  events: DataCollectionEvent[]
-  cursor: string
-}
-
-export interface DataEventWebhookPayload {
-  subscriptionId: string
-  events: DataCollectionEvent[]
-}
-
-export interface DataCollectionParseUnifiedFieldsRequest {
-  udm: string
-  unifiedFields: Record<string, any>
-}
-
-export interface DataCollectionParseUnifiedFieldsResponse {
-  fields: any
-}
-
-export interface DataDirectoryListRequest {
-  cursor?: string
-}
-
-export interface DataDirectoryListResponse {
-  locations: DataLocationSpec[]
-  cursor?: string
-}
-
-export function makeDataLocationOperationPath(
-  collectionPath: string,
-  operation: string,
-) {
-  const [path, query] = (collectionPath ?? '').split('?')
-  return urljoin(path, operation, query ? `?${query}` : '')
-}
-
-// Backward compatibility
-export const makeCollectionOperationPath = makeDataLocationOperationPath