@integration-app/react 0.1.1

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

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

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

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

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

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

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

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

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

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

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

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

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

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