@integration-app/react 0.1.4 → 0.1.6

package/node_modules/@integration-app/sdk/src/connector-api/index.ts

@@ -1,44 +0,0 @@
-export {
-  ConnectionSpec as ConnectorSpec,
-  ConnectionDataSpec as ConnectorDataSpec,
-} from '../connections'
-
-// Backward compatibility
-export {
-  DataLocationType,
-  DataLocationSpec,
-  DataLocation,
-  DataCollectionSpec,
-  DataDirectorySpec,
-  DataCollectionSpec as DataCollection,
-  DataCollectionUdmSpec,
-  DataCollectionFindSpec,
-  DataCollectionFindByIdSpec,
-  DataCollectionCreateSpec,
-  DataCollectionUpdateSpec,
-  DataCollectionDeleteSpec,
-  DataCollectionFindRequest,
-  DataCollectionFindResponse,
-  DataCollectionFindByIdRequest,
-  DataCollectionFindByIdResponse,
-  DataCollectionCreateRequest,
-  DataCollectionCreateResponse,
-  DataCollectionUpdateRequest,
-  DataCollectionUpdateResponse,
-  DataCollectionDeleteRequest,
-  DataCollectionDeleteResponse,
-  DataCollectionSubscribeRequest,
-  DataCollectionSubscribeResponse,
-  DataCollectionUpdateSubscriptionRequest,
-  DataCollectionUpdateSubscriptionResponse,
-  DataCollectionUnsubscribeRequest,
-  DataCollectionUnsubscribeResponse,
-  DataCollectionEventsRequest,
-  DataCollectionEventsResponse,
-  DataEventWebhookPayload,
-  DataCollectionParseUnifiedFieldsRequest,
-  DataCollectionParseUnifiedFieldsResponse,
-  DataDirectoryListRequest,
-  DataDirectoryListResponse,
-  makeCollectionOperationPath,
-} from '../data-locations'

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

@@ -1,40 +0,0 @@
-import { BadRequestError } from '../errors'
-import { DataLocator } from './locators'
-
-class DataBuilderArrayIterator {
-  value: any[]
-  currentIdx: number
-}
-
-export class DataBuilderContext {
-  private currentArrayItems: Record<string, DataBuilderArrayIterator>
-
-  constructor(public variables: any) {
-    this.currentArrayItems = {}
-  }
-
-  public setCurrentArrayItem(locator: string, value: any): void {
-    this.currentArrayItems[this.getKeyByLocator(locator)] = value
-  }
-
-  public getCurrentArrayItem(locator: string): any {
-    const key = this.getKeyByLocator(locator)
-    if (typeof this.currentArrayItems[key] !== 'undefined') {
-      return this.currentArrayItems[key]
-    } else {
-      throw new BadRequestError(
-        `Attempting to access current array item with non-existing locator:\n${JSON.stringify(
-          locator,
-        )}`,
-      )
-    }
-  }
-
-  public unsetCurrentArrayItem(locator: string): void {
-    delete this.currentArrayItems[this.getKeyByLocator(locator)]
-  }
-
-  private getKeyByLocator(locator: DataLocator) {
-    return JSON.stringify(locator)
-  }
-}

package/node_modules/@integration-app/sdk/src/data-builder/formulas/base.test.ts

@@ -1,26 +0,0 @@
-import '.'
-import { DataBuilderContext } from '../context'
-import { getValueByLocator } from './base'
-
-describe('getValueByLocator', () => {
-  it('should return value at object property locator', () => {
-    const context = new DataBuilderContext({
-      a: {
-        b: {
-          c: 'd',
-        },
-      },
-    })
-    expect(getValueByLocator(context, '$.a.b.c')).toEqual('d')
-  })
-
-  it('should return value at array locator', () => {
-    const context = new DataBuilderContext(['a', 'b', 'c'])
-    expect(getValueByLocator(context, '$[1]')).toEqual('b')
-  })
-
-  it('should return false value', () => {
-    const context = new DataBuilderContext({ b: false })
-    expect(getValueByLocator(context, '$.b')).toEqual(false)
-  })
-})

package/node_modules/@integration-app/sdk/src/data-builder/formulas/base.ts

@@ -1,95 +0,0 @@
-import { BadRequestError } from '../../errors'
-import { DataBuilderFormulaType, isEmpty } from '.'
-import { DataBuilderContext } from '../context'
-import {
-  DataLocator,
-  DataLocatorStepArrayItem,
-  DataLocatorStepObjectProperty,
-  DataLocatorStepType,
-  locatorToSteps,
-  locatorToString,
-} from '../locators'
-
-export abstract class DataBuilderFormulaBase {
-  type: DataBuilderFormulaType
-
-  abstract getValue(context: DataBuilderContext): any
-
-  abstract getSchema(variablesSchema): any
-}
-
-export function getValueByLocator(
-  context: DataBuilderContext,
-  locator: DataLocator,
-): DataBuilderContext {
-  let curValue = context.variables
-  const curLocator = []
-  const locatorSteps = locatorToSteps(locator)
-  for (let i = 0; i < locatorSteps.length; ++i) {
-    const locatorStep = locatorSteps[i]
-    if (locatorStep.type == DataLocatorStepType.OBJECT_PROPERTY) {
-      curValue = executeLocatorStepObjectProperty(
-        curValue,
-        locatorStep as DataLocatorStepObjectProperty,
-      )
-    } else if (locatorStep.type == DataLocatorStepType.ARRAY_ITEM) {
-      curValue = executeLocatorStepArrayItem(
-        curValue,
-        locatorStep as DataLocatorStepArrayItem,
-      )
-    } else if (locatorStep.type == DataLocatorStepType.CURRENT_ARRAY_ITEM) {
-      curValue = executeLocatorStepCurrentArrayItem(
-        context,
-        locatorToString(curLocator),
-      )
-    } else if (locatorStep.type == DataLocatorStepType.SCHEMA_OPTION) {
-      // This step is only meaningful when working with schemas,
-      // but does nothing when composing data.
-    } else {
-      // ToDo: this is an internal engine exception because it allowed an invalid
-      // formula to be saved.
-      throw new BadRequestError(
-        `Unexpected locator step type: ${locatorStep.type}`,
-      )
-    }
-    if (isEmpty(curValue)) {
-      // If we reached a non-value, stop here and just return the non-value back
-      break
-    }
-    curLocator.push(locatorStep)
-  }
-  return isEmpty(curValue) ? undefined : curValue
-}
-
-function executeLocatorStepObjectProperty(
-  value: DataBuilderContext,
-  step: DataLocatorStepObjectProperty,
-): any {
-  if (typeof value == 'object' && value !== null) {
-    // Resolve value once in case it's lazy-loaded
-    value[step.propertyName] = value[step.propertyName]
-    return value[step.propertyName]
-  } else {
-    return undefined
-  }
-}
-
-function executeLocatorStepArrayItem(
-  value: DataBuilderContext,
-  step: DataLocatorStepArrayItem,
-): any {
-  if (Array.isArray(value) && value[step.index]) {
-    // Resolve value once in case it's lazy-loaded
-    value[step.index] = value[step.index]
-    return value[step.index]
-  } else {
-    return undefined
-  }
-}
-
-function executeLocatorStepCurrentArrayItem(
-  context: DataBuilderContext,
-  locator: string,
-): any {
-  return context.getCurrentArrayItem(locator)
-}

package/node_modules/@integration-app/sdk/src/data-builder/formulas/case.test.ts

@@ -1,158 +0,0 @@
-import { DataBuilderFormulaType, getFormula } from '.'
-import { DataBuilderContext } from '../context'
-import { DataBuilderFormulaCase } from './case'
-
-describe('data-builder/formulas/case', () => {
-  const context = new DataBuilderContext({
-    key: 'value',
-    obj: {
-      objKey: 'objValue',
-    },
-  })
-
-  it('should find case formula in value', () => {
-    const formula = getFormula({
-      $case: [
-        {
-          filter: null,
-          value: 'foo',
-        },
-      ],
-    })
-    expect(formula).toBeDefined()
-    expect(formula).not.toBeNull()
-    expect(formula.type).toEqual(DataBuilderFormulaType.CASE)
-    expect((formula as DataBuilderFormulaCase).value).toEqual([
-      {
-        filter: null,
-        value: 'foo',
-      },
-    ])
-  })
-
-  it('should work with undefined value', () => {
-    const formula = new DataBuilderFormulaCase(undefined)
-    expect(formula.getValue(context)).toBeUndefined()
-  })
-
-  it('should work with empty value', () => {
-    const formula = new DataBuilderFormulaCase([])
-    expect(formula.getValue(context)).toBeUndefined()
-  })
-
-  it('should work without filter', () => {
-    const formula = new DataBuilderFormulaCase([
-      {
-        value: 'foo',
-      },
-    ])
-    expect(formula.getValue(context)).toEqual('foo')
-  })
-
-  it('should work with formula value', () => {
-    const formula = new DataBuilderFormulaCase([
-      {
-        value: {
-          $var: '$.obj.objKey',
-        },
-      },
-    ])
-    expect(formula.getValue(context)).toEqual('objValue')
-  })
-
-  it('should take filter in account', () => {
-    const formula = new DataBuilderFormulaCase([
-      {
-        filter: [
-          {
-            field: 'key',
-            operator: 'is',
-            value: 'notValue',
-          },
-        ],
-        value: 'incorrectValue',
-      },
-      {
-        filter: [
-          {
-            field: 'key',
-            operator: 'is',
-            value: 'value',
-          },
-        ],
-        value: 'correctValue',
-      },
-    ])
-    expect(formula.getValue(context)).toEqual('correctValue')
-  })
-
-  it('should use "else" value correctly', () => {
-    const formula = new DataBuilderFormulaCase([
-      {
-        filter: [
-          {
-            field: 'key',
-            operator: 'is',
-            value: 'notValue',
-          },
-        ],
-        value: 'incorrectValue',
-      },
-      {
-        filter: [
-          {
-            field: 'key',
-            operator: 'is',
-            value: 'anotherNotValue',
-          },
-        ],
-        value: 'anotherIncorrectValue',
-      },
-      {
-        value: 'elseValue',
-      },
-    ])
-    expect(formula.getValue(context)).toEqual('elseValue')
-  })
-
-  it('should combine schemas of all option', () => {
-    const variablesSchema = {
-      type: 'object',
-      properties: {
-        obj: {
-          type: 'object',
-          properties: {
-            objKey: { type: 'string' },
-          },
-        },
-        obj2: {
-          type: 'object',
-          properties: {
-            obj2Key: { type: 'string' },
-          },
-        },
-      },
-    }
-    const formula = new DataBuilderFormulaCase([
-      {
-        value: {
-          $var: '$.obj',
-        },
-        filter: [],
-      },
-      {
-        value: {
-          $var: '$.obj2',
-        },
-        filter: [],
-      },
-    ])
-    expect(formula.getSchema(variablesSchema)).toEqual({
-      type: 'object',
-      properties: {
-        objKey: { type: 'string' },
-        obj2Key: { type: 'string' },
-      },
-    })
-  })
-})

package/node_modules/@integration-app/sdk/src/data-builder/formulas/case.ts

@@ -1,53 +0,0 @@
-import { DataFilter, doesMatchFilter } from '../../data-filter'
-import { DataBuilderFormulaType, processValue } from '.'
-import { buildDataSchema } from '..'
-import { DataBuilderContext } from '../context'
-import { DataBuilderFormulaBase } from './base'
-import { mergeSchemas } from '../../json-schema/schema-builder'
-
-export interface CaseFormulaValueItem {
-  filter?: DataFilter
-  value: any
-}
-
-export type CaseFormulaValue = CaseFormulaValueItem[]
-
-export class DataBuilderFormulaCase extends DataBuilderFormulaBase {
-  constructor(public value: CaseFormulaValue) {
-    super()
-
-    this.type = DataBuilderFormulaType.CASE
-
-    if (!Array.isArray(value)) {
-      this.value = []
-    }
-  }
-
-  getValue(context: DataBuilderContext) {
-    if (!Array.isArray(this.value)) {
-      return undefined
-    }
-    for (const item of this.value) {
-      if (!item || typeof item !== 'object') {
-        continue
-      }
-      if (doesMatchFilter(context.variables, item.filter)) {
-        return processValue(item.value, context)
-      }
-    }
-  }
-
-  getSchema(variablesSchema) {
-    if (Array.isArray(this.value)) {
-      const values = this.value
-        .map((item) => item.value)
-        .filter((value) => value !== undefined)
-      const schemas = values.map((value) =>
-        buildDataSchema(value, variablesSchema),
-      )
-      return mergeSchemas(schemas)
-    } else {
-      return undefined
-    }
-  }
-}

package/node_modules/@integration-app/sdk/src/data-builder/formulas/concat.test.ts

@@ -1,117 +0,0 @@
-import { buildData } from '..'
-
-describe('data-builder/formulas/concat', () => {
-  it('should return null if no arguments', () => {
-    expect(
-      buildData({
-        $concat: null,
-      }),
-    ).toEqual(null)
-    expect(
-      buildData({
-        $concat: {},
-      }),
-    ).toEqual(null)
-    expect(
-      buildData({
-        $concat: {
-          values: [],
-        },
-      }),
-    ).toEqual(null)
-    expect(
-      buildData({
-        $concat: {
-          delimiter: '',
-        },
-      }),
-    ).toEqual(null)
-    expect(
-      buildData({
-        $concat: {
-          values: [],
-          delimiter: '',
-        },
-      }),
-    ).toEqual(null)
-  })
-
-  it('should return string itself with one argument', () => {
-    expect(
-      buildData({
-        $concat: {
-          values: ['value'],
-        },
-      }),
-    ).toEqual('value')
-  })
-
-  it('should concatenate strings without delimiter', () => {
-    expect(
-      buildData({
-        $concat: {
-          values: ['1', '2'],
-        },
-      }),
-    ).toEqual('12')
-  })
-
-  it('should concatenate strings with delimiter', () => {
-    expect(
-      buildData({
-        $concat: {
-          values: ['1', '2'],
-          delimiter: '-',
-        },
-      }),
-    ).toEqual('1-2')
-
-    expect(
-      buildData({
-        $concat: {
-          values: ['1', '2'],
-          delimiter: '',
-        },
-      }),
-    ).toEqual('12')
-
-    expect(
-      buildData({
-        $concat: {
-          values: ['1', '2'],
-          delimiter: null,
-        },
-      }),
-    ).toEqual('12')
-  })
-
-  it('should resolve formulas in arguments', () => {
-    expect(
-      buildData(
-        {
-          $concat: {
-            delimiter: '-',
-            values: [
-              '1',
-              {
-                $var: '$.key',
-              },
-            ],
-          },
-        },
-        { key: '2' },
-      ),
-    ).toEqual('1-2')
-  })
-
-  it('should return empty result with delimiter but empty arguments', () => {
-    expect(
-      buildData({
-        $concat: {
-          delimiter: '-',
-          values: [{ $var: '$.key' }, '', null],
-        },
-      }),
-    ).toEqual('')
-  })
-})

package/node_modules/@integration-app/sdk/src/data-builder/formulas/concat.ts

@@ -1,49 +0,0 @@
-import { DataBuilderFormulaType, processValue } from '.'
-import { DataBuilderContext } from '../context'
-import { DataBuilderFormulaBase } from './base'
-
-const DEFAULT_DELIMITER = ''
-
-type AnyValue = any
-
-type ConcatFormulaOptions = {
-  delimiter?: AnyValue
-  values?: AnyValue[]
-}
-
-export class DataBuilderFormulaConcat extends DataBuilderFormulaBase {
-  private readonly delimiter: AnyValue = DEFAULT_DELIMITER
-  private readonly values: AnyValue[] = []
-
-  constructor(public options: ConcatFormulaOptions | null) {
-    super()
-
-    this.type = DataBuilderFormulaType.CONCAT
-
-    if (options === null) {
-      return
-    }
-
-    this.values = options.values ?? []
-    this.delimiter = options.delimiter ?? DEFAULT_DELIMITER
-  }
-
-  getValue(context: DataBuilderContext) {
-    if (!this.values.length) {
-      return null
-    }
-
-    const computedValues = this.values.map((value) =>
-      processValue(value, context),
-    )
-    const computedDelimiter = processValue(this.delimiter, context)
-
-    return computedValues
-      .filter((v) => v !== null && v !== undefined && v.toString() !== '')
-      .join(computedDelimiter)
-  }
-
-  getSchema() {
-    return { type: 'string' }
-  }
-}

package/node_modules/@integration-app/sdk/src/data-builder/formulas/copy.test.ts

@@ -1,70 +0,0 @@
-import { FlowConfigurationError } from '../../errors'
-import { DataBuilderFormulaType, getFormula } from '.'
-import { buildData } from '..'
-import { DataBuilderContext } from '../context'
-import { DataBuilderFormulaCopy } from './copy'
-
-describe('data-builder/formulas/copy', () => {
-  it('should parse $copy formula', () => {
-    const formula = getFormula({
-      $copy: 'field',
-    })
-    expect(formula).toBeDefined()
-    expect(formula).not.toBeNull()
-    expect(formula.type).toEqual(DataBuilderFormulaType.COPY)
-    expect(formula instanceof DataBuilderFormulaCopy).toBeTruthy()
-    expect((formula as DataBuilderFormulaCopy).locator).toEqual('field')
-  })
-
-  const data = {
-    fieldName: 'field',
-  }
-
-  it('should resolve into itself', () => {
-    const formula = getFormula({
-      $copy: {
-        $var: 'fieldName',
-      },
-    })
-    expect(formula.getValue(new DataBuilderContext(data))).toEqual({
-      $copy: 'field',
-    })
-  })
-
-  it('should copy the field', () => {
-    expect(
-      buildData(
-        {
-          field: 'value',
-          field2: {
-            $copy: {
-              $var: 'fieldName',
-            },
-          },
-        },
-        data,
-      ),
-    ).toEqual({ field: 'value', field2: 'value' })
-  })
-
-  it('should error if trying to copy another $copy field', () => {
-    const brokenRecipe = {
-      field1: {
-        $copy: 'field2',
-      },
-      field2: {
-        $copy: 'field1',
-      },
-    }
-    try {
-      buildData(brokenRecipe)
-      throw new Error('should have thrown an error')
-    } catch (e) {
-      if (e instanceof FlowConfigurationError) {
-        // It's ok
-      } else {
-        throw e
-      }
-    }
-  })
-})

package/node_modules/@integration-app/sdk/src/data-builder/formulas/copy.ts

@@ -1,20 +0,0 @@
-import { DataBuilderFormulaType, processValue } from '.'
-import { DataBuilderContext } from '../context'
-import { DataBuilderFormulaBase } from './base'
-
-export class DataBuilderFormulaCopy extends DataBuilderFormulaBase {
-  constructor(public locator: string) {
-    super()
-    this.type = DataBuilderFormulaType.COPY
-  }
-
-  getValue(context: DataBuilderContext) {
-    return {
-      $copy: processValue(this.locator, context),
-    }
-  }
-
-  getSchema() {
-    return null
-  }
-}