@integration-app/react 0.1.1 → 0.1.2

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,260 +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', () => {
-    // argument as object
-    const formula = getFormula({
-      $case: {
-        cases: [
-          {
-            filter: null,
-            value: 'foo',
-          },
-        ],
-        default: 'bar',
-      },
-    })
-    expect(formula).toBeDefined()
-    expect(formula).not.toBeNull()
-    expect(formula.type).toEqual(DataBuilderFormulaType.CASE)
-    expect((formula as DataBuilderFormulaCase).value).toEqual({
-      cases: [
-        {
-          filter: null,
-          value: 'foo',
-        },
-      ],
-      default: 'bar',
-    })
-
-    // argument as array
-    const formula2 = getFormula({
-      $case: [
-        {
-          filter: null,
-          value: 'foo',
-        },
-      ],
-    })
-    expect(formula2).toBeDefined()
-    expect(formula2).not.toBeNull()
-    expect(formula2.type).toEqual(DataBuilderFormulaType.CASE)
-    expect((formula2 as DataBuilderFormulaCase).value).toEqual({
-      cases: [
-        {
-          filter: null,
-          value: 'foo',
-        },
-      ],
-      default: undefined,
-    })
-  })
-
-  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')
-
-    const formula2 = new DataBuilderFormulaCase({
-      cases: [],
-      default: {
-        $var: '$.obj.objKey',
-      },
-    })
-    expect(formula2.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 use default value correctly', () => {
-    const formula = new DataBuilderFormulaCase({
-      default: 'defaultValue',
-      cases: [
-        {
-          filter: [
-            {
-              field: 'key',
-              operator: 'is',
-              value: 'notValue',
-            },
-          ],
-          value: 'incorrectValue',
-        },
-        {
-          filter: [
-            {
-              field: 'key',
-              operator: 'is',
-              value: 'anotherNotValue',
-            },
-          ],
-          value: 'anotherIncorrectValue',
-        },
-      ],
-    })
-    expect(formula.getValue(context)).toEqual('defaultValue')
-  })
-
-  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' },
-          },
-        },
-        obj3: {
-          type: 'object',
-          properties: {
-            obj3Key: { type: 'string' },
-          },
-        },
-      },
-    }
-
-    const formula = new DataBuilderFormulaCase({
-      cases: [
-        {
-          value: {
-            $var: '$.obj',
-          },
-          filter: [],
-        },
-        {
-          value: {
-            $var: '$.obj2',
-          },
-          filter: [],
-        },
-      ],
-      default: {
-        $var: '$.obj3',
-      },
-    })
-    expect(formula.getSchema(variablesSchema)).toEqual({
-      type: 'object',
-      properties: {
-        objKey: { type: 'string' },
-        obj2Key: { type: 'string' },
-        obj3Key: { type: 'string' },
-      },
-    })
-
-    // without default value
-    const formula2 = new DataBuilderFormulaCase([
-      {
-        value: {
-          $var: '$.obj',
-        },
-        filter: [],
-      },
-      {
-        value: {
-          $var: '$.obj2',
-        },
-        filter: [],
-      },
-    ])
-    expect(formula2.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,77 +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 = {
-  cases: CaseFormulaValueItem[]
-  default?: any
-}
-
-export class DataBuilderFormulaCase extends DataBuilderFormulaBase {
-  public value: CaseFormulaValue
-
-  constructor(value: CaseFormulaValueItem[] | CaseFormulaValue) {
-    super()
-
-    this.type = DataBuilderFormulaType.CASE
-
-    if (!value && !Array.isArray(value) && typeof value !== 'object') {
-      this.value = {
-        cases: [],
-        default: undefined,
-      }
-    } else if (Array.isArray(value)) {
-      this.value = {
-        cases: value,
-        default: undefined,
-      }
-    } else if (typeof value === 'object' && Array.isArray(value.cases)) {
-      this.value = value
-    }
-  }
-
-  getValue(context: DataBuilderContext) {
-    if (!this.isValueValid()) return undefined
-
-    for (const item of this.value.cases) {
-      if (!item || typeof item !== 'object') continue
-
-      if (doesMatchFilter(context.variables, item.filter)) {
-        return processValue(item.value, context)
-      }
-    }
-
-    return processValue(this.value.default, context) ?? undefined
-  }
-
-  getSchema(variablesSchema) {
-    if (!this.isValueValid()) return undefined
-
-    const schemas = this.value.cases
-      .map((item) => item.value)
-      .filter((value) => value !== undefined)
-      .map((value) => buildDataSchema(value, variablesSchema))
-
-    if (this.value.default) {
-      schemas.push(buildDataSchema(this.value.default, variablesSchema))
-    }
-
-    return mergeSchemas(schemas)
-  }
-
-  isValueValid() {
-    return (
-      this.value &&
-      typeof this.value === 'object' &&
-      Array.isArray(this.value.cases)
-    )
-  }
-}

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
-  }
-}