@integration-app/react 0.1.1 → 0.1.2

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

@@ -1,74 +0,0 @@
-export enum DataCollectionEventType {
-  CREATED = 'created',
-  UPDATED = 'updated',
-  DELETED = 'deleted',
-}
-
-export interface DataRecord {
-  /**
-   * Unique record id
-   */
-  id?: string
-  /**
-   * Human-readable name of the record.
-   */
-  name?: string
-  /**
-   * Record's URI avialable in a browser.
-   */
-  uri?: string
-  /**
-   * Record's icon.
-   */
-  iconUri?: string
-  /**
-   * Record's fields.
-   */
-  fields?: Record<string, any>
-  /**
-   * Unified Data Model this record is transformed to.
-   * It is `string` and not `UDM` type to avoid nasty problems with mismatched SDK versions in different parts of the system.
-   * (as soon as one SDK version has a new value in UDM, all other instances of SDK should have the same).
-   * (alternatively it could be solved by making SDK into peer dependencies - we may have to do it later)
-   */
-  udm?: string
-  /**
-   * Fields of Unified Data Model associated with the record.
-   */
-  unifiedFields?: Record<string, any>
-  /**
-   * Original fields coming from the source, before any mapping happens.
-   */
-  rawFields?: Record<string, any>
-}
-
-export interface DataCollection {
-  id: string
-
-  key: string
-
-  udm: string
-}
-
-export interface DataCollectionInstance {
-  id: string
-
-  dataCollectionId?: string
-
-  connectionId: string
-
-  udm?: string
-
-  path: string
-}
-
-export enum DataEventType {
-  CREATED = 'created',
-  UPDATED = 'updated',
-  DELETED = 'deleted',
-}
-
-export interface DataCollectionEvent {
-  type: DataCollectionEventType
-  record: DataRecord
-}

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

@@ -1,48 +0,0 @@
-import { DataFilterCondition } from './index'
-import { doesMatchFilter } from './index'
-
-describe('data-filter', () => {
-  it('should match any data to empty filter', () => {
-    expect(doesMatchFilter(null, null)).toBe(true)
-    expect(doesMatchFilter('string', null)).toBe(true)
-    expect(doesMatchFilter({ key: 'value' }, null)).toBe(true)
-  })
-
-  it('should match any data to filter with zero conditions', () => {
-    expect(doesMatchFilter(null, [])).toBe(true)
-    expect(doesMatchFilter('string', [])).toBe(true)
-    expect(doesMatchFilter({ key: 'value' }, [])).toBe(true)
-  })
-
-  it('should match scalar data', () => {
-    const data = 'value'
-    const condition = new DataFilterCondition('$', 'is', data)
-    expect(doesMatchFilter(data, [condition])).toBe(true)
-  })
-
-  it('should match object with field', () => {
-    const data = {
-      key: 'value',
-    }
-    const condition = new DataFilterCondition('$.key', 'is', 'value')
-    expect(doesMatchFilter(data, [condition])).toBe(true)
-  })
-
-  it('should match array with one item of a neseted object mathing the value', () => {
-    const data = [{ key: 'not value' }, { key: 'value' }]
-    const condition = new DataFilterCondition('$.key', 'is', 'value')
-    expect(doesMatchFilter(data, [condition])).toBe(true)
-
-    const condition2 = new DataFilterCondition('$.$current.key', 'is', 'value')
-    expect(doesMatchFilter(data, [condition2])).toBe(true)
-  })
-
-  it('should correctly match array if locator explicitly specifies an array item', () => {
-    const data = [{ key: 'not value' }, { key: 'value' }]
-    const condition = new DataFilterCondition('$[0].key', 'is', 'value')
-    expect(doesMatchFilter(data, [condition])).toBe(false)
-
-    const condition2 = new DataFilterCondition('$[1].key', 'is', 'value')
-    expect(doesMatchFilter(data, [condition2])).toBe(true)
-  })
-})

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

@@ -1,127 +0,0 @@
-import {
-  DataLocator,
-  DataLocatorStepArrayItem,
-  DataLocatorStepObjectProperty,
-  DataLocatorStepType,
-  locatorToSteps,
-} from '../data-builder/locators'
-import { DataFilterOperator, OPERATORS } from './operators'
-
-export function doesMatchFilter(data: any, filter: DataFilter): boolean {
-  if (filter && Array.isArray(filter)) {
-    for (const condition of filter) {
-      const operator = OPERATORS[condition.operator]
-      if (!operator) {
-        continue
-      }
-      // If there are multiple field values, it means locator is pointing to an array
-      // - in this case test if any of them matches the filter.
-      let fieldValues = getFilterFieldValuesByLocator(data, condition.field)
-      // If no field values found - test one value that equals `undefined` - in case the filter is something like "is empty"
-      if (!fieldValues?.length) {
-        fieldValues = [undefined]
-      }
-      const conditionMatches = fieldValues.some((fieldValue) =>
-        operator.handler(fieldValue, condition.value),
-      )
-      if (!conditionMatches) {
-        return false
-      }
-    }
-    return true
-  } else {
-    return true
-  }
-}
-
-export class DataFilterCondition {
-  constructor(
-    public field: string,
-    public operator: string,
-    public value?: any,
-  ) {}
-}
-
-export type DataFilter = DataFilterCondition[]
-
-export function getOperatorsBySchema(schema: any): DataFilterOperator[] {
-  if (!schema || typeof schema !== 'object') {
-    return []
-  }
-  const results = []
-  for (const [type, operator] of Object.entries(OPERATORS)) {
-    if (operator.applicableToSchema(schema)) {
-      results.push({
-        type,
-        name: operator.name,
-        operandSchema: operator.getOperandSchema(schema),
-      })
-    }
-  }
-  return results
-}
-
-export function getFilterFieldValuesByLocator(
-  data,
-  locator: DataLocator,
-): any[] {
-  const locatorSteps = locatorToSteps(locator)
-  const result: any[] = []
-  let curValue = data
-
-  for (let idx = 0; idx < locatorSteps.length; ++idx) {
-    if (curValue === null || curValue === undefined) {
-      return []
-    }
-
-    const locatorStep = locatorSteps[idx]
-    switch (locatorStep.type) {
-      case DataLocatorStepType.SCHEMA_OPTION:
-        continue
-      case DataLocatorStepType.CURRENT_ARRAY_ITEM:
-        if (Array.isArray(curValue)) {
-          // if <array>.$current locator is used - iterate over all elements
-          // of the array and see if any of them match
-          for (const val of curValue) {
-            result.push(
-              ...getFilterFieldValuesByLocator(
-                val,
-                locatorSteps.slice(idx + 1),
-              ),
-            )
-          }
-          return result
-        } else {
-          return []
-        }
-      case DataLocatorStepType.ARRAY_ITEM:
-        if (Array.isArray(curValue)) {
-          curValue = curValue[(locatorStep as DataLocatorStepArrayItem).index]
-          break
-        } else {
-          return []
-        }
-      case DataLocatorStepType.OBJECT_PROPERTY:
-        if (Array.isArray(curValue)) {
-          // If we are trying to get object property of an array,
-          // return values from the given property of all the array items
-          for (const val of curValue) {
-            result.push(
-              ...getFilterFieldValuesByLocator(val, locatorSteps.slice(idx)),
-            )
-          }
-          return result
-        } else {
-          curValue =
-            curValue[
-              (locatorStep as DataLocatorStepObjectProperty).propertyName
-            ]
-          break
-        }
-    }
-  }
-  if (curValue !== null && curValue !== undefined) {
-    result.push(curValue)
-  }
-  return result
-}