@integration-app/react 0.1.2 → 0.1.3

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

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

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

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

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

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

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

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

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

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

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