@integration-app/react 0.1.1

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

@@ -0,0 +1,49 @@
+import { DataBuilderFormulaType, getFormula } from '.'
+import { DataBuilderContext } from '../context'
+import { DataBuilderFormulaExtractDate } from './extractDate'
+
+describe('formulas/extractDate', () => {
+  const DATETIME = '2021-07-06T02:22:22.000Z'
+  const context = new DataBuilderContext({
+    datetime: DATETIME,
+  })
+
+  it('should find extractDate formula', () => {
+    const formula = getFormula({
+      $extractDate: DATETIME,
+    })
+    expect(formula).toBeDefined()
+    expect(formula).not.toBeNull()
+    expect(formula.type).toEqual(DataBuilderFormulaType.EXTRACT_DATE)
+    expect(formula instanceof DataBuilderFormulaExtractDate).toBeTruthy()
+    expect((formula as DataBuilderFormulaExtractDate).value).toEqual(DATETIME)
+  })
+
+  it('should extract date', () => {
+    const formula = new DataBuilderFormulaExtractDate(DATETIME)
+    expect(formula.getValue(context)).toEqual('2021-07-06')
+  })
+
+  it('should extract date from variable', () => {
+    const formula = new DataBuilderFormulaExtractDate({
+      $var: '$.datetime',
+    })
+    expect(formula.getValue(context)).toEqual('2021-07-06')
+  })
+
+  it('should extract date from non-standard date', () => {
+    const formula = new DataBuilderFormulaExtractDate('Jun 25, 2022 10:30')
+    expect(formula.getValue(context)).toEqual('2022-06-25')
+  })
+
+  it('should return undefined when non-date value provided', () => {
+    let formula = new DataBuilderFormulaExtractDate(null)
+    expect(formula.getValue(context)).toBeUndefined()
+
+    formula = new DataBuilderFormulaExtractDate('foo')
+    expect(formula.getValue(context)).toBeUndefined()
+
+    formula = new DataBuilderFormulaExtractDate('25')
+    expect(formula.getValue(context)).toBeUndefined()
+  })
+})

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

@@ -0,0 +1,28 @@
+import { parseDatetime } from '../../datetime'
+import { DataBuilderFormulaType, processValue } from '.'
+import { DataBuilderFormulaBase } from './base'
+import { DataBuilderContext } from '../context'
+
+export class DataBuilderFormulaExtractDate extends DataBuilderFormulaBase {
+  constructor(public value) {
+    super()
+    this.type = DataBuilderFormulaType.EXTRACT_DATE
+  }
+
+  getValue(context: DataBuilderContext) {
+    const value = processValue(this.value, context)
+    const date = parseDatetime(value)
+    if (date) {
+      return date.toISOString().substring(0, 10)
+    } else {
+      return undefined
+    }
+  }
+
+  getSchema() {
+    return {
+      type: 'string',
+      format: 'date',
+    }
+  }
+}

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

@@ -0,0 +1,49 @@
+import { DataBuilderFormulaType, getFormula } from '.'
+import { DataBuilderContext } from '../context'
+import { DataBuilderFormulaExtractTime } from './extractTime'
+
+describe('formulas/extractTime', () => {
+  const DATETIME = '2021-07-06T02:22:22.000Z'
+  const context = new DataBuilderContext({
+    datetime: DATETIME,
+  })
+
+  it('should find extractTime formula', () => {
+    const formula = getFormula({
+      $extractTime: DATETIME,
+    })
+    expect(formula).toBeDefined()
+    expect(formula).not.toBeNull()
+    expect(formula.type).toEqual(DataBuilderFormulaType.EXTRACT_TIME)
+    expect(formula instanceof DataBuilderFormulaExtractTime).toBeTruthy()
+    expect((formula as DataBuilderFormulaExtractTime).value).toEqual(DATETIME)
+  })
+
+  it('should extract date', () => {
+    const formula = new DataBuilderFormulaExtractTime(DATETIME)
+    expect(formula.getValue(context)).toEqual('02:22:22')
+  })
+
+  it('should extract date from variable', () => {
+    const formula = new DataBuilderFormulaExtractTime({
+      $var: '$.datetime',
+    })
+    expect(formula.getValue(context)).toEqual('02:22:22')
+  })
+
+  it('should extract time from non-standard date', () => {
+    const formula = new DataBuilderFormulaExtractTime('Jun 25, 2022 13:30')
+    expect(formula.getValue(context)).toEqual('13:30:00')
+  })
+
+  it('should return undefined when non-date value provided', () => {
+    let formula = new DataBuilderFormulaExtractTime(null)
+    expect(formula.getValue(context)).toBeUndefined()
+
+    formula = new DataBuilderFormulaExtractTime('foo')
+    expect(formula.getValue(context)).toBeUndefined()
+
+    formula = new DataBuilderFormulaExtractTime('25')
+    expect(formula.getValue(context)).toBeUndefined()
+  })
+})

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

@@ -0,0 +1,28 @@
+import { parseDatetime } from '../../datetime'
+import { DataBuilderFormulaType, processValue } from '.'
+import { DataBuilderFormulaBase } from './base'
+import { DataBuilderContext } from '../context'
+
+export class DataBuilderFormulaExtractTime extends DataBuilderFormulaBase {
+  constructor(public value) {
+    super()
+    this.type = DataBuilderFormulaType.EXTRACT_TIME
+  }
+
+  getValue(context: DataBuilderContext): string {
+    const value = processValue(this.value, context)
+    const date = parseDatetime(value)
+    if (date) {
+      return date.toISOString().substring(11, 19)
+    } else {
+      return undefined
+    }
+  }
+
+  getSchema() {
+    return {
+      type: 'string',
+      format: 'time',
+    }
+  }
+}

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

@@ -0,0 +1,30 @@
+import { getFormula } from '.'
+import { buildData } from '..'
+import { DataBuilderFormulaFindAppRecordId } from './findAppRecordId'
+
+describe('data-builder/formulas/findAppRecordId', () => {
+  const args = {
+    dataLinkTable: {
+      key: 'contacts',
+    },
+    recordId: '1234',
+  }
+
+  it('should parse $findAppRecordId formulas', () => {
+    expect(
+      getFormula({
+        $findAppRecordId: args,
+      }),
+    ).toEqual(new DataBuilderFormulaFindAppRecordId(args))
+  })
+
+  it('should resolve into the formula itself', () => {
+    expect(
+      buildData({
+        $findAppRecordId: args,
+      }),
+    ).toEqual({
+      $findAppRecordId: args,
+    })
+  })
+})

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

@@ -0,0 +1,30 @@
+import { DataBuilderFormulaType, processValue } from '.'
+import { DataBuilderFormulaBase } from './base'
+import { DataLinkTableConfig } from '../../data-links'
+import { DataBuilderContext } from '../context'
+
+export interface FindAppRecordIdArgs {
+  dataLinkTable: DataLinkTableConfig
+  recordId: string
+}
+
+export class DataBuilderFormulaFindAppRecordId extends DataBuilderFormulaBase {
+  constructor(public args: FindAppRecordIdArgs) {
+    super()
+    this.type = DataBuilderFormulaType.FIND_APP_RECORD_ID
+  }
+
+  getValue(context: DataBuilderContext) {
+    // Process formulas inside value, but return it within
+    // $lookup for whoever is doing lookup to resolve.
+    return {
+      $findAppRecordId: processValue(this.args, context),
+    }
+  }
+
+  getSchema() {
+    return {
+      type: 'string',
+    }
+  }
+}

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

@@ -0,0 +1,30 @@
+import { getFormula } from '.'
+import { buildData } from '..'
+import { DataBuilderFormulaFindExternalRecordId } from './findExternalRecordId'
+
+describe('data-builder/formulas/findExternalRecordId', () => {
+  const args = {
+    dataLinkTable: {
+      key: 'contacts',
+    },
+    recordId: '1234',
+  }
+
+  it('should parse $findExternalRecordId formulas', () => {
+    expect(
+      getFormula({
+        $findExternalRecordId: args,
+      }),
+    ).toEqual(new DataBuilderFormulaFindExternalRecordId(args))
+  })
+
+  it('should resolve into the formula itself', () => {
+    expect(
+      buildData({
+        $findExternalRecordId: args,
+      }),
+    ).toEqual({
+      $findExternalRecordId: args,
+    })
+  })
+})

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

@@ -0,0 +1,30 @@
+import { DataBuilderFormulaType, processValue } from '.'
+import { DataBuilderFormulaBase } from './base'
+import { DataLinkTableConfig } from '../../data-links'
+import { DataBuilderContext } from '../context'
+
+export interface FindExternalRecordIdArgs {
+  dataLinkTable: DataLinkTableConfig
+  recordId: string
+}
+
+export class DataBuilderFormulaFindExternalRecordId extends DataBuilderFormulaBase {
+  constructor(public args: FindExternalRecordIdArgs) {
+    super()
+    this.type = DataBuilderFormulaType.FIND_EXTERNAL_RECORD_ID
+  }
+
+  getValue(context: DataBuilderContext) {
+    // Process formulas inside value, but return it within
+    // $lookup for whoever is doing lookup to resolve.
+    return {
+      $findExternalRecordId: processValue(this.args, context),
+    }
+  }
+
+  getSchema() {
+    return {
+      type: 'string',
+    }
+  }
+}

package/node_modules/@integration-app/sdk/src/data-builder/formulas/first-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 DataBuilderFormulaFirstName extends DataBuilderFormulaBase {
+  constructor(public value: any) {
+    super()
+    this.type = DataBuilderFormulaType.FIRST_NAME
+  }
+
+  getValue(context: DataBuilderContext) {
+    const value = processValue(this.value, context)
+    const { firstName } = splitName(value?.toString() ?? '')
+    return firstName
+  }
+
+  getSchema() {
+    return { type: 'string' }
+  }
+}

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

@@ -0,0 +1,83 @@
+import { getFormula } from '.'
+import { DataBuilderFormulaPlain } from './plain'
+import { DataBuilderFormulaRecord } from './record'
+import { DataBuilderFormulaSchemaOption } from './schemaOption'
+import { DataBuilderFormulaVar } from './var'
+
+describe('Data Builder Formulas', () => {
+  describe('getFormula', () => {
+    it('should parse $ref formulas', () => {
+      expect(
+        getFormula({
+          $ref: '$.locator',
+        }),
+      ).toEqual(new DataBuilderFormulaVar('$.locator'))
+    })
+
+    it('should parse $var formulas', () => {
+      expect(
+        getFormula({
+          $var: '$.locator',
+        }),
+      ).toEqual(new DataBuilderFormulaVar('$.locator'))
+    })
+
+    it('should parse $plain formulas', () => {
+      expect(
+        getFormula({
+          $plain: {
+            $ref: '$.locator',
+          },
+        }),
+      ).toEqual(
+        new DataBuilderFormulaPlain({
+          $ref: '$.locator',
+        }),
+      )
+    })
+
+    it('should parse $anyOfOption formulas', () => {
+      expect(
+        getFormula({
+          $schemaOption: {
+            key: 'value',
+            value: {
+              $ref: '$.locator',
+            },
+          },
+        }),
+      ).toEqual(
+        new DataBuilderFormulaSchemaOption({
+          key: 'value',
+          value: {
+            $ref: '$.locator',
+          },
+        }),
+      )
+    })
+
+    it('should parse $record formulas', () => {
+      expect(
+        getFormula({
+          $record: {
+            id: 'id',
+            name: 'name',
+          },
+        }),
+      ).toEqual(new DataBuilderFormulaRecord({ id: 'id', name: 'name' }))
+    })
+
+    it('should ignore values with more than one key', () => {
+      expect(
+        getFormula({
+          $ref: '$.locator',
+          a: 'b',
+        }),
+      ).toBeUndefined()
+    })
+
+    it('should handle empty $compose', () => {
+      expect(getFormula({ $compose: null })).toBeUndefined()
+    })
+  })
+})

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

@@ -0,0 +1,190 @@
+import { FlowConfigurationError } from '../../errors'
+import { schemaTypeFromValue } from '../../json-schema'
+import { mergeSchemas } from '../../json-schema/schema-builder'
+import { DataBuilderContext } from '../context'
+import {
+  getFormulaLocators,
+  getValueAtLocator,
+  setValueAtLocator,
+} from '../locators'
+import { DataBuilderFormulaBase } from './base'
+import { DataBuilderFormulaCase } from './case'
+import { DataBuilderFormulaConcat } from './concat'
+import { DataBuilderFormulaCopy } from './copy'
+import { DataBuilderFormulaExtractDate } from './extractDate'
+import { DataBuilderFormulaExtractTime } from './extractTime'
+import { DataBuilderFormulaFindAppRecordId } from './findAppRecordId'
+import { DataBuilderFormulaFindExternalRecordId } from './findExternalRecordId'
+import { DataBuilderFormulaFirstName } from './first-name'
+import { DataBuilderFormulaIterate } from './iterate'
+import { DataBuilderFormulaLastName } from './last-name'
+import { DataBuilderFormulaLookup } from './lookup'
+import { DataBuilderFormulaMap } from './map'
+import { DataBuilderFormulaPlain } from './plain'
+import { DataBuilderFormulaRecord } from './record'
+import { DataBuilderFormulaSchemaOption } from './schemaOption'
+import { DataBuilderFormulaVar } from './var'
+import { DataBuilderFormulaTpl } from './tpl'
+
+export enum DataBuilderFormulaType {
+  VAR = 'var',
+  COPY = 'copy',
+  REF = 'ref',
+  TPL = 'tpl',
+  RECORD = 'record', // DataRecord
+  LOOKUP = 'lookup',
+  SCHEMA_OPTION = 'schemaOption',
+  PLAIN = 'plain', // plain JSON object
+  MAP = 'map',
+  CONCAT = 'concat',
+  FIRST_NAME = 'firstName',
+  LAST_NAME = 'lastName',
+  ITERATE = 'iterate',
+  CASE = 'case',
+  EXTRACT_DATE = 'extractDate',
+  EXTRACT_TIME = 'extractTime',
+  FIND_EXTERNAL_RECORD_ID = 'findExternalRecordId',
+  FIND_APP_RECORD_ID = 'findAppRecordId',
+}
+
+const FORMULAS = {
+  [DataBuilderFormulaType.VAR]: DataBuilderFormulaVar,
+  [DataBuilderFormulaType.REF]: DataBuilderFormulaVar,
+  [DataBuilderFormulaType.RECORD]: DataBuilderFormulaRecord,
+  [DataBuilderFormulaType.TPL]: DataBuilderFormulaTpl,
+  [DataBuilderFormulaType.LOOKUP]: DataBuilderFormulaLookup,
+  [DataBuilderFormulaType.SCHEMA_OPTION]: DataBuilderFormulaSchemaOption,
+  [DataBuilderFormulaType.PLAIN]: DataBuilderFormulaPlain,
+  [DataBuilderFormulaType.MAP]: DataBuilderFormulaMap,
+  [DataBuilderFormulaType.CONCAT]: DataBuilderFormulaConcat,
+  [DataBuilderFormulaType.FIRST_NAME]: DataBuilderFormulaFirstName,
+  [DataBuilderFormulaType.LAST_NAME]: DataBuilderFormulaLastName,
+  [DataBuilderFormulaType.ITERATE]: DataBuilderFormulaIterate,
+  [DataBuilderFormulaType.CASE]: DataBuilderFormulaCase,
+  [DataBuilderFormulaType.EXTRACT_DATE]: DataBuilderFormulaExtractDate,
+  [DataBuilderFormulaType.EXTRACT_TIME]: DataBuilderFormulaExtractTime,
+  [DataBuilderFormulaType.FIND_EXTERNAL_RECORD_ID]:
+    DataBuilderFormulaFindExternalRecordId,
+  [DataBuilderFormulaType.FIND_APP_RECORD_ID]:
+    DataBuilderFormulaFindAppRecordId,
+  [DataBuilderFormulaType.COPY]: DataBuilderFormulaCopy,
+}
+
+export function isFormula(value) {
+  return !!getFormula(value)
+}
+
+export function getFormula(value): DataBuilderFormulaBase {
+  if (typeof value === 'object' && value !== null) {
+    if (Object.keys(value).length === 1) {
+      const key = Object.keys(value)[0]
+      if (key.startsWith('$')) {
+        const formulaType = key.slice(1)
+        const formulaValue = value[key]
+        if (formulaType in FORMULAS) {
+          return new FORMULAS[formulaType](formulaValue)
+        }
+      }
+    }
+  }
+  return undefined
+}
+
+export function processValue(value: any, context: DataBuilderContext): any {
+  if (isFormula(value)) {
+    const formula = getFormula(value)
+
+    return formula.getValue(context)
+  } else {
+    if (typeof value === 'object') {
+      if (Array.isArray(value)) {
+        const result = []
+        for (const valueItem of value) {
+          const processedVal = processValue(valueItem, context)
+          if (processedVal !== undefined) {
+            result.push(processedVal)
+          }
+        }
+        return result.length > 0 ? result : undefined
+      } else if (value === null) {
+        return value
+      } else {
+        const result = {}
+        for (const [key, val] of Object.entries(value)) {
+          const processedVal = processValue(val, context)
+          if (processedVal !== undefined) {
+            result[key] = processedVal
+          }
+        }
+        if (Object.keys(result).length > 0) {
+          return result
+        } else {
+          return undefined
+        }
+      }
+    } else {
+      return value
+    }
+  }
+}
+
+export function processCopy(data: any): any {
+  const copyLocators = getFormulaLocators(DataBuilderFormulaType.COPY, data)
+  for (const locator of copyLocators) {
+    const value = getValueAtLocator(data, locator)
+    const formula = getFormula(value) as DataBuilderFormulaCopy
+    const valueToCopy = getValueAtLocator(data, formula.locator)
+    const valueHasCopy =
+      getFormulaLocators(DataBuilderFormulaType.COPY, valueToCopy).length > 0
+    if (valueHasCopy) {
+      throw new FlowConfigurationError(
+        `${locator} is copying ${formula.locator}, which contains a copy formula`,
+      )
+    }
+    setValueAtLocator(data, locator, valueToCopy)
+  }
+}
+
+export function isEmpty(value: any): boolean {
+  return typeof value == 'undefined'
+}
+
+export function getSchemaFromValue(
+  value: any,
+  variablesSchema: any,
+  ignoreFormulas = false,
+) {
+  if (isFormula(value) && !ignoreFormulas) {
+    return getFormula(value).getSchema(variablesSchema)
+  } else {
+    const type = schemaTypeFromValue(value)
+    switch (type) {
+      case 'object':
+        const properties = {}
+        for (const [propKey, propValue] of Object.entries(value)) {
+          properties[propKey] = getSchemaFromValue(
+            propValue,
+            variablesSchema,
+            ignoreFormulas,
+          )
+        }
+        return {
+          type: 'object',
+          properties,
+        }
+      case 'array':
+        const schemas = []
+        for (const item of value) {
+          schemas.push(
+            getSchemaFromValue(item, variablesSchema, ignoreFormulas),
+          )
+        }
+        return {
+          type: 'array',
+          items: mergeSchemas(schemas),
+        }
+      default:
+        return { type: type }
+    }
+  }
+}