@integration-app/react 0.1.3 → 0.1.5

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

@@ -1,154 +0,0 @@
-import { getFormula } from '.'
-import { buildData } from '..'
-import { DataBuilderFormulaIterate } from './iterate'
-
-describe('data-builder/formulas/iterate', () => {
-  it('should parse $iterate formulas', () => {
-    expect(
-      getFormula({
-        $iterate: {
-          locator: '$.list',
-          items: '$.list.$current',
-        },
-      }),
-    ).toEqual(
-      new DataBuilderFormulaIterate({
-        locator: '$.list',
-        items: '$.list.$current',
-      }),
-    )
-  })
-
-  it('should return undefined if args are not provided', () => {
-    expect(
-      buildData({
-        $iterate: null,
-      }),
-    ).toEqual(undefined)
-    expect(
-      buildData({
-        $iterate: [],
-      }),
-    ).toEqual(undefined)
-    expect(
-      buildData({
-        $iterate: {
-          locator: null,
-        },
-      }),
-    ).toEqual(undefined)
-    expect(
-      buildData({
-        $iterate: {
-          locator: '$.list',
-          items: null,
-        },
-      }),
-    ).toEqual(undefined)
-  })
-
-  it('should return undefined if not pointing to an array', () => {
-    expect(
-      buildData({
-        $iterate: {
-          locator: '$.list',
-          items: '$.list.$current',
-        },
-      }),
-    ).toEqual(undefined)
-  })
-
-  it('should produce empty list for an empty list', () => {
-    expect(
-      buildData(
-        {
-          $iterate: {
-            locator: '$.list',
-            items: '$.list.$current',
-          },
-        },
-        { list: [] },
-      ),
-    ).toEqual([])
-  })
-
-  it('should replicate list', () => {
-    const list = [1, 2, 3]
-    expect(
-      buildData(
-        {
-          $iterate: {
-            locator: '$.list',
-            items: {
-              $var: '$.list.$current',
-            },
-          },
-        },
-        { list },
-      ),
-    ).toEqual(list)
-  })
-
-  it('should take subfields from the list', () => {
-    const list = [
-      {
-        key: 'value1',
-      },
-      {
-        key: 'value2',
-      },
-      {
-        key: 'value3',
-      },
-    ]
-    expect(
-      buildData(
-        {
-          $iterate: {
-            locator: '$.list',
-            items: {
-              $var: '$.list.$current.key',
-            },
-          },
-        },
-        { list },
-      ),
-    ).toEqual(['value1', 'value2', 'value3'])
-  })
-
-  it('should iterate over two lists', () => {
-    const outerList = [1, 2, 3]
-    const innerList = ['a', 'b', 'c']
-
-    const expectedResult = outerList.map((outerItem) =>
-      innerList.map((innerItem) => ({
-        outer: outerItem,
-        inner: innerItem,
-      })),
-    )
-
-    expect(
-      buildData(
-        {
-          $iterate: {
-            locator: '$.outerList',
-            items: {
-              $iterate: {
-                locator: '$.innerList',
-                items: {
-                  outer: {
-                    $var: '$.outerList.$current',
-                  },
-                  inner: {
-                    $var: '$.innerList.$current',
-                  },
-                },
-              },
-            },
-          },
-        },
-        { outerList, innerList },
-      ),
-    ).toEqual(expectedResult)
-  })
-})

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

@@ -1,46 +0,0 @@
-import { DataBuilderFormulaType, processValue } from '.'
-import { DataBuilderFormulaBase, getValueByLocator } from './base'
-import { locatorToSteps } from '../locators'
-import { buildDataSchema } from '..'
-import { DataBuilderContext } from '../context'
-
-export interface IterateArguments {
-  locator: string
-  items: any
-}
-
-export class DataBuilderFormulaIterate extends DataBuilderFormulaBase {
-  constructor(public args: IterateArguments) {
-    super()
-    this.type = DataBuilderFormulaType.ITERATE
-  }
-
-  getValue(context: DataBuilderContext) {
-    if (!this.args?.locator || !this.args?.items) {
-      return undefined
-    }
-
-    const list = getValueByLocator(context, locatorToSteps(this.args.locator))
-
-    if (!Array.isArray(list)) {
-      return undefined
-    }
-
-    const result = []
-    for (const item of list) {
-      context.setCurrentArrayItem(this.args.locator, item)
-      const value = processValue(this.args.items, context)
-      result.push(value)
-    }
-    context.unsetCurrentArrayItem(this.args.locator)
-
-    return result
-  }
-
-  getSchema(variablesSchema) {
-    return {
-      type: 'array',
-      items: buildDataSchema(this.args?.items, variablesSchema),
-    }
-  }
-}

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

@@ -1,21 +0,0 @@
-import { DataBuilderFormulaType, processValue } from '.'
-import { DataBuilderFormulaBase } from './base'
-import splitName from 'split-human-name'
-import { DataBuilderContext } from '../context'
-
-export class DataBuilderFormulaLastName extends DataBuilderFormulaBase {
-  constructor(public value: any) {
-    super()
-    this.type = DataBuilderFormulaType.LAST_NAME
-  }
-
-  getValue(context: DataBuilderContext) {
-    const value = processValue(this.value, context)
-    const { lastName } = splitName(value?.toString() ?? '')
-    return lastName
-  }
-
-  getSchema() {
-    return { type: 'string' }
-  }
-}

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

@@ -1,20 +0,0 @@
-import { getFormula } from '.'
-import { DataBuilderFormulaLookup } from './lookup'
-
-describe('data-builder/formulas/lookup', () => {
-  it('should parse $lookup formulas', () => {
-    expect(
-      getFormula({
-        $lookup: {
-          query: { key: 'value' },
-          createIfNotFound: true,
-        },
-      }),
-    ).toEqual(
-      new DataBuilderFormulaLookup({
-        query: { key: 'value' },
-        createIfNotFound: true,
-      }),
-    )
-  })
-})

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

@@ -1,33 +0,0 @@
-import { DataBuilderFormulaType, processValue } from '.'
-import { DataBuilderContext } from '../context'
-import { DataBuilderFormulaBase } from './base'
-
-export interface LookupValue {
-  collectionPath?: string
-  query: Record<string, any>
-  createIfNotFound?: boolean
-  create?: {
-    fields: any
-  }
-}
-
-export class DataBuilderFormulaLookup extends DataBuilderFormulaBase {
-  constructor(public value: LookupValue) {
-    super()
-    this.type = DataBuilderFormulaType.LOOKUP
-  }
-
-  getValue(context: DataBuilderContext) {
-    // Process formulas inside value, but return it within
-    // $lookup for whoever is doing lookup to resolve.
-    return {
-      $lookup: processValue(this.value, context),
-    }
-  }
-
-  getSchema() {
-    return {
-      type: 'string',
-    }
-  }
-}

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

@@ -1,125 +0,0 @@
-import { getFormula } from '.'
-import { DataBuilderContext } from '../context'
-import { DataBuilderFormulaMap, MapFormulaValue } from './map'
-
-describe('data-builder/formulas/map', () => {
-  it('should parse $map formulas', () => {
-    const mapValue: MapFormulaValue = {
-      value: 'value',
-      mapping: [
-        {
-          from: 'from',
-          to: 'to',
-        },
-      ],
-    }
-    expect(
-      getFormula({
-        $map: mapValue,
-      }),
-    ).toEqual(new DataBuilderFormulaMap(mapValue))
-  })
-
-  it('should work with undefined value', () => {
-    const formula = new DataBuilderFormulaMap(undefined)
-    expect(formula.getValue(null)).toBeUndefined()
-  })
-
-  it('should work with undefined mapping', () => {
-    const formula = new DataBuilderFormulaMap({
-      value: 'foo',
-      mapping: undefined,
-    })
-    expect(formula.getValue(null)).toBeUndefined()
-  })
-
-  it('should work with empty mapping', () => {
-    const formula = new DataBuilderFormulaMap({
-      value: 'foo',
-      mapping: [],
-    })
-    expect(formula.getValue(null)).toBeUndefined()
-  })
-
-  it('should apply mapping', () => {
-    const formula = new DataBuilderFormulaMap({
-      value: 'foo',
-      mapping: [
-        {
-          from: 'bar',
-          to: 'buzz',
-        },
-        {
-          from: 'foo',
-          to: 'bar',
-        },
-        {
-          from: 'bar',
-          to: 'foo',
-        },
-      ],
-    })
-    expect(formula.getValue(null)).toEqual('bar')
-  })
-
-  it('should apply default if no mapping matches', () => {
-    const formula = new DataBuilderFormulaMap({
-      value: 'notfoo',
-      mapping: [
-        {
-          from: 'bar',
-          to: 'buzz',
-        },
-        {
-          from: 'foo',
-          to: 'bar',
-        },
-        {
-          from: 'bar',
-          to: 'foo',
-        },
-      ],
-      default: 'notbar',
-    })
-    expect(formula.getValue(null)).toEqual('notbar')
-  })
-
-  it('should use variables in value', () => {
-    const formula = new DataBuilderFormulaMap({
-      value: {
-        $var: '$.key',
-      },
-      mapping: [
-        {
-          from: 'bar',
-          to: 'buzz',
-        },
-        {
-          from: 'foo',
-          to: 'bar',
-        },
-        {
-          from: 'bar',
-          to: 'foo',
-        },
-      ],
-      default: 'notbar',
-    })
-    expect(formula.getValue(new DataBuilderContext({ key: 'foo' }))).toEqual(
-      'bar',
-    )
-  })
-
-  it('should use variables in default', () => {
-    const formula = new DataBuilderFormulaMap({
-      value: 'unknown',
-      mapping: [],
-      default: {
-        $var: '$.key',
-      },
-    })
-    expect(formula.getValue(new DataBuilderContext({ key: 'foo' }))).toEqual(
-      'foo',
-    )
-  })
-})

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

@@ -1,42 +0,0 @@
-import _ from 'lodash'
-import { DataBuilderFormulaType, getSchemaFromValue, processValue } from '.'
-import { DataBuilderContext } from '../context'
-import { DataBuilderFormulaBase } from './base'
-
-export interface MappingItem {
-  from: any
-  to?: any
-}
-
-export interface MapFormulaValue {
-  value: any
-  mapping: MappingItem[]
-  default?: any
-}
-
-export class DataBuilderFormulaMap extends DataBuilderFormulaBase {
-  constructor(public value: MapFormulaValue) {
-    super()
-    this.type = DataBuilderFormulaType.MAP
-  }
-
-  getValue(context: DataBuilderContext) {
-    if (!this.value || typeof this.value !== 'object') {
-      return
-    }
-    const value = processValue(this.value.value, context)
-    if (Array.isArray(this.value.mapping)) {
-      for (const mappingItem of this.value.mapping) {
-        const from = processValue(mappingItem.from, context)
-        if (_.isEqual(value, from)) {
-          return processValue(mappingItem.to, context)
-        }
-      }
-    }
-    return processValue(this.value.default, context)
-  }
-
-  getSchema(variablesSchema) {
-    return getSchemaFromValue(this.value.value, variablesSchema)
-  }
-}

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

@@ -1,17 +0,0 @@
-import { DataBuilderFormulaType, getSchemaFromValue } from '.'
-import { DataBuilderFormulaBase } from './base'
-
-export class DataBuilderFormulaPlain extends DataBuilderFormulaBase {
-  constructor(public value) {
-    super()
-    this.type = DataBuilderFormulaType.PLAIN
-  }
-
-  getValue() {
-    return this.value
-  }
-
-  getSchema() {
-    return getSchemaFromValue(this.value, null, true)
-  }
-}

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

@@ -1,20 +0,0 @@
-import { DataRecord } from '../../data-collections'
-import { DataBuilderFormulaType } from '.'
-import { DataBuilderFormulaBase } from './base'
-
-export class DataBuilderFormulaRecord extends DataBuilderFormulaBase {
-  constructor(public record: DataRecord) {
-    super()
-    this.type = DataBuilderFormulaType.RECORD
-  }
-
-  getValue() {
-    return this.record?.id
-  }
-
-  getSchema() {
-    return {
-      type: 'string',
-    }
-  }
-}

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

@@ -1,26 +0,0 @@
-/**
- * When field has multiple options of its schema, this formula indicates which one is chosen
- */
-import { DataBuilderFormulaType, getSchemaFromValue, processValue } from '.'
-import { DataBuilderContext } from '../context'
-import { DataBuilderFormulaBase } from './base'
-
-export interface SchemaOptionFormulaValue {
-  key: string
-  value: any
-}
-
-export class DataBuilderFormulaSchemaOption extends DataBuilderFormulaBase {
-  constructor(public value: SchemaOptionFormulaValue) {
-    super()
-    this.type = DataBuilderFormulaType.SCHEMA_OPTION
-  }
-
-  getValue(context: DataBuilderContext) {
-    return processValue(this.value?.value, context)
-  }
-
-  getSchema(variablesSchema) {
-    return getSchemaFromValue(this.value?.value, variablesSchema)
-  }
-}

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

@@ -1,51 +0,0 @@
-import { DataBuilderFormulaType, getFormula } from '.'
-import { DataBuilderFormulaTpl } from './tpl'
-
-describe('data-builder/formulas/tpl', () => {
-  it('should extract $tpl formula', () => {
-    const formula = getFormula({
-      $tpl: {
-        template: 'foo',
-        values: {},
-      },
-    })
-    expect(formula).toBeTruthy()
-    expect(formula.type).toEqual(DataBuilderFormulaType.TPL)
-    expect(formula instanceof DataBuilderFormulaTpl).toBeTruthy()
-    expect((formula as DataBuilderFormulaTpl).args).toEqual({
-      template: 'foo',
-      values: {},
-    })
-  })
-
-  it('should work with empty args', () => {
-    const formula = new DataBuilderFormulaTpl(undefined)
-    expect(formula.getValue(null)).toBeUndefined()
-  })
-
-  it('should work with empty template', () => {
-    const formula = new DataBuilderFormulaTpl({
-      template: '',
-      values: {},
-    })
-    expect(formula.getValue(null)).toEqual('')
-  })
-
-  it('should work with empty values', () => {
-    const formula = new DataBuilderFormulaTpl({
-      template: '{key}',
-      values: null,
-    })
-    expect(formula.getValue(null)).toEqual('{key}')
-  })
-
-  it('should replace every instance of value', () => {
-    const formula = new DataBuilderFormulaTpl({
-      template: '{key} {key}',
-      values: {
-        key: 'value',
-      },
-    })
-    expect(formula.getValue(null)).toEqual('value value')
-  })
-})

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

@@ -1,33 +0,0 @@
-import { DataBuilderFormulaType, processValue } from '.'
-import { DataBuilderContext } from '../context'
-import { DataBuilderFormulaBase } from './base'
-
-type TplFormulaArgs = {
-  template: string
-  values: Record<string, any>
-}
-
-export class DataBuilderFormulaTpl extends DataBuilderFormulaBase {
-  constructor(public args: TplFormulaArgs) {
-    super()
-    this.type = DataBuilderFormulaType.TPL
-  }
-
-  getValue(context: DataBuilderContext) {
-    let result = this.args?.template
-    if (typeof result !== 'string') {
-      return result
-    }
-    for (const key of Object.keys(this.args?.values ?? {})) {
-      const value = processValue(this.args.values[key], context)
-      result = result.replace(new RegExp(`\\{${key}\\}`, 'g'), value)
-    }
-    return result
-  }
-
-  getSchema() {
-    return {
-      type: 'string',
-    }
-  }
-}

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

@@ -1,19 +0,0 @@
-import { DataBuilderFormulaType } from '.'
-import { DataBuilderContext } from '../context'
-import { getSchemaByLocator, locatorToSteps } from '../locators'
-import { DataBuilderFormulaBase, getValueByLocator } from './base'
-
-export class DataBuilderFormulaVar extends DataBuilderFormulaBase {
-  constructor(public locator: string) {
-    super()
-    this.type = DataBuilderFormulaType.VAR
-  }
-
-  getValue(context: DataBuilderContext) {
-    return getValueByLocator(context, locatorToSteps(this.locator))
-  }
-
-  getSchema(variablesSchema) {
-    return getSchemaByLocator(variablesSchema, this.locator)
-  }
-}