@integration-app/react 0.1.2 → 0.1.4

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

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

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

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

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

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

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

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

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