@integration-app/react 0.1.4 → 0.1.5

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

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

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

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

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

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

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

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

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

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

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

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