@things-factory/integration-base 8.0.40 → 9.0.0-9.0.0-beta.59.0

package/server/engine/task/floating-point.ts

@@ -1,71 +0,0 @@
-import ieee754 from 'ieee754'
-import { access } from '@things-factory/utils'
-import { TaskRegistry } from '../task-registry'
-
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
-
-async function FloatingPoint(step: InputStep, { logger, data }: Context) {
-  var {
-    params: { accessor, operation, endian, floatType }
-  } = step
-
-  const value = access(accessor, data)
-  if (typeof value === 'undefined') {
-    throw new Error('accessor value not a found')
-  }
-
-  const isLE = endian === 'little'
-  const nBytes = floatType === 'float' ? 4 : 8
-  const mantissa = floatType === 'float' ? 23 : 52
-
-  var result
-
-  if (operation == 'write') {
-    result = Buffer.alloc(nBytes)
-    ieee754.write(result, value, 0, isLE, mantissa, nBytes)
-  } else {
-    result = ieee754.read(value, 0, isLE, mantissa, nBytes)
-  }
-
-  return {
-    data: result
-  }
-}
-
-FloatingPoint.parameterSpec = [
-  {
-    type: 'scenario-step-input',
-    name: 'accessor',
-    label: 'accessor'
-  },
-  {
-    type: 'select',
-    name: 'operation',
-    label: 'operation',
-    property: {
-      options: ['read', 'write']
-    }
-  },
-  {
-    type: 'select',
-    name: 'endian',
-    label: 'endian',
-    property: {
-      options: ['little', 'big']
-    }
-  },
-  {
-    type: 'select',
-    name: 'floatType',
-    label: 'float type',
-    property: {
-      options: ['float', 'double']
-    }
-  }
-]
-
-FloatingPoint.connectorFree = true
-FloatingPoint.help = 'integration/task/floating-point'
-
-TaskRegistry.registerTaskHandler('floating-point', FloatingPoint)

package/server/engine/task/goto.ts

@@ -1,27 +0,0 @@
-import { TaskRegistry } from '../task-registry'
-
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
-
-async function Goto(step: InputStep, { logger }: Context) {
-  var {
-    params: { goto }
-  } = step
-
-  return {
-    next: goto
-  }
-}
-
-Goto.parameterSpec = [
-  {
-    type: 'scenario-step-input',
-    name: 'goto',
-    label: 'goto'
-  }
-]
-
-Goto.connectorFree = true
-Goto.help = 'integration/task/goto'
-
-TaskRegistry.registerTaskHandler('goto', Goto)

package/server/engine/task/graphql-mutate.ts

@@ -1,79 +0,0 @@
-import gql from 'graphql-tag'
-import 'ses'
-
-import { access } from '@things-factory/utils'
-import { ConnectionManager } from '../connection-manager'
-import { TaskRegistry } from '../task-registry'
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
-
-async function GraphqlMutate(step: InputStep, context: Context) {
-  var { connection: connectionName, params: stepOptions } = step
-  var { mutation, variables: variablesAccessorMap, headers } = stepOptions || {}
-
-  var { domain, user, data, variables, lng } = context
-
-  const compartment = new Compartment({
-    domain,
-    user,
-    lng,
-    data,
-    variables,
-    console
-  })
-
-  let evalMutation
-  try {
-    evalMutation = compartment.evaluate('`' + mutation + '`')
-  } catch (err) {
-    throw new Error(`Failed to evaluate mutation: ${err.message}`)
-  }
-
-  var client = ConnectionManager.getConnectionInstanceByName(context.domain, connectionName)
-
-  const queryVariables = Object.keys(variablesAccessorMap || {}).reduce((variables, key) => {
-    const accessor = variablesAccessorMap[key]
-    variables[key] = access(accessor, data)
-    return variables
-  }, {})
-
-  var { data: mutateResult } = await client.mutate({
-    mutation: gql`
-      ${evalMutation}
-    `,
-    variables: queryVariables,
-    headers
-  })
-
-  return {
-    data: mutateResult
-  }
-}
-
-GraphqlMutate.parameterSpec = [
-  {
-    type: 'graphql',
-    name: 'mutation',
-    label: 'mutation',
-    property: {
-      showLineNumbers: true
-    },
-    styles: {
-      flex: 1
-    }
-  },
-  {
-    type: 'key-values',
-    name: 'variables',
-    label: 'variables'
-  },
-  {
-    type: 'key-values',
-    name: 'headers',
-    label: 'headers'
-  }
-]
-
-GraphqlMutate.help = 'integration/task/graphql-mutate'
-
-TaskRegistry.registerTaskHandler('graphql-mutate', GraphqlMutate)

package/server/engine/task/graphql-query.ts

@@ -1,78 +0,0 @@
-import gql from 'graphql-tag'
-import 'ses'
-
-import { access } from '@things-factory/utils'
-import { ConnectionManager } from '../connection-manager'
-import { TaskRegistry } from '../task-registry'
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
-
-async function GraphqlQuery(step: InputStep, context: Context) {
-  var { connection: connectionName, params: stepOptions } = step
-  var { query, variables: variablesAccessorMap, headers } = stepOptions || {}
-  var { domain, user, data, variables, lng } = context
-
-  const compartment = new Compartment({
-    domain,
-    user,
-    lng,
-    data,
-    variables,
-    console
-  })
-
-  let evalQuery
-  try {
-    evalQuery = compartment.evaluate('`' + query + '`')
-  } catch (err) {
-    throw new Error(`Failed to evaluate query: ${err.message}`)
-  }
-
-  var client = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
-
-  const queryVariables = Object.keys(variablesAccessorMap || {}).reduce((variables, key) => {
-    const accessor = variablesAccessorMap[key]
-    variables[key] = access(accessor, data)
-    return variables
-  }, {})
-
-  var { data: queryResult } = await client.query({
-    query: gql`
-      ${evalQuery}
-    `,
-    variables: queryVariables,
-    headers
-  })
-
-  return {
-    data: queryResult
-  }
-}
-
-GraphqlQuery.parameterSpec = [
-  {
-    type: 'graphql',
-    name: 'query',
-    label: 'query',
-    property: {
-      showLineNumbers: true
-    },
-    styles: {
-      flex: 1
-    }
-  },
-  {
-    type: 'key-values',
-    name: 'variables',
-    label: 'variables'
-  },
-  {
-    type: 'key-values',
-    name: 'headers',
-    label: 'headers'
-  }
-]
-
-GraphqlQuery.help = 'integration/task/graphql-query'
-
-TaskRegistry.registerTaskHandler('graphql-query', GraphqlQuery)

package/server/engine/task/headless-post.ts

@@ -1,147 +0,0 @@
-import https from 'https'
-import { URL } from 'url'
-
-import { access } from '@things-factory/utils'
-import { TaskRegistry } from '../task-registry'
-import { ConnectionManager } from '../connection-manager'
-
-import { getHeadlessPool } from './utils/headless-pool-for-scenario'
-
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
-
-async function HeadlessPost(step: InputStep, { logger, data, domain }: Context) {
-  var { connection: connectionName, params: stepOptions } = step
-  var { headers: requestHeaders, contentType, path, accessor } = stepOptions || {}
-
-  var connection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
-
-  if (!connection) {
-    throw new Error(`connection '${connectionName}' is not established.`)
-  }
-
-  var { endpoint, params: connectionParams, authHeaders = {} } = connection
-
-  var headers = {
-    ...authHeaders,
-    ...requestHeaders
-  }
-
-  var body = access(accessor, data)
-  if (contentType && body) {
-    headers['content-type'] = contentType
-    switch (contentType) {
-      case 'text/plain':
-        body = JSON.stringify(body)
-        break
-      case 'application/json':
-        body = JSON.stringify(body)
-        break
-      case 'application/x-www-form-urlencoded':
-        const searchParams = new URLSearchParams()
-        for (const prop in body) {
-          searchParams.set(prop, body[prop])
-        }
-        body = searchParams
-        break
-    }
-  }
-
-  var options: any = {
-    method: 'POST',
-    headers,
-    body
-  }
-
-  var { rejectUnauthorized } = connectionParams
-
-  if (!rejectUnauthorized) {
-    const httpsAgent = new https.Agent({
-      rejectUnauthorized
-    })
-    options.agent = httpsAgent
-  }
-
-  const browser = (await getHeadlessPool().acquire()) as any
-  const page = await browser.newPage()
-
-  try {
-    page.on('console', async msg => {
-      console.log(`[browser ${msg.type()}] ${msg.text()}`)
-    })
-
-    page.on('requestfailed', request => {
-      console.log('Request failed:', request.url())
-    })
-
-    await page.goto(endpoint, { waitUntil: 'networkidle2' })
-
-    const response = await page.evaluate(
-      async (urlString, options) => {
-        const response = await fetch(urlString, options)
-
-        if (response.ok && response.headers.get('content-type').includes('application/json')) {
-          return await response.json()
-        } else {
-          return await response.text()
-        }
-      },
-      new URL(path, endpoint),
-      options
-    )
-
-    return {
-      data: response
-    }
-  } catch (e) {
-    console.error(e)
-  } finally {
-    page.close()
-    getHeadlessPool().release(browser)
-  }
-}
-
-HeadlessPost.parameterSpec = [
-  {
-    type: 'string',
-    name: 'path',
-    label: 'path'
-  },
-  {
-    type: 'http-headers',
-    name: 'headers',
-    label: 'headers'
-  },
-  {
-    type: 'select',
-    name: 'contentType',
-    label: 'content-type',
-    property: {
-      options: [
-        {
-          display: '',
-          value: ''
-        },
-        {
-          display: 'application/json',
-          value: 'application/json'
-        },
-        {
-          display: 'text/plain',
-          value: 'text/plain'
-        },
-        {
-          display: 'application/x-www-form-urlencoded',
-          value: 'application/x-www-form-urlencoded'
-        }
-      ]
-    }
-  },
-  {
-    type: 'scenario-step-input',
-    name: 'accessor',
-    label: 'accessor'
-  }
-]
-
-TaskRegistry.registerTaskHandler('headless-post', HeadlessPost)

package/server/engine/task/headless-scrap.ts

@@ -1,80 +0,0 @@
-import { URL } from 'url'
-
-import { TaskRegistry } from '../task-registry'
-import { ConnectionManager } from '../connection-manager'
-
-import { getHeadlessPool } from './utils/headless-pool-for-scenario'
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
-
-async function HeadlessScrap(step: InputStep, { logger, data, domain }: Context) {
-  var { connection: connectionName, params: stepOptions } = step
-  var { headers: requestHeaders, path, selectors = [] } = stepOptions || {}
-
-  var connection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
-
-  if (!connection) {
-    throw new Error(`connection '${connectionName}' is not established.`)
-  }
-
-  var { endpoint, params: connectionParams, authHeaders = {} } = connection
-
-  var headers = {
-    ...authHeaders,
-    ...requestHeaders
-  }
-
-  const browser = (await getHeadlessPool().acquire()) as any
-  const page = await browser.newPage()
-
-  try {
-    page.on('console', async msg => {
-      console.log(`[browser ${msg.type()}] ${msg.text()}`)
-    })
-
-    page.on('requestfailed', request => {
-      console.log('Request failed:', request.url())
-    })
-
-    await page.setExtraHTTPHeaders(headers)
-    await page.goto(new URL(path, endpoint), { waitUntil: 'networkidle2' })
-
-    const result = {}
-
-    for (const selector of selectors) {
-      const { text, value } = selector
-      result[text] = await page.$$eval(value, elements => {
-        return elements.map(element => element.textContent.trim())
-      })
-    }
-
-    return {
-      data: result
-    }
-  } catch (e) {
-    console.error(e)
-  } finally {
-    page.close()
-    getHeadlessPool().release(browser)
-  }
-}
-
-HeadlessScrap.parameterSpec = [
-  {
-    type: 'string',
-    name: 'path',
-    label: 'path'
-  },
-  {
-    type: 'http-headers',
-    name: 'headers',
-    label: 'headers'
-  },
-  {
-    type: 'options',
-    name: 'selectors',
-    label: 'selectors'
-  }
-]
-
-TaskRegistry.registerTaskHandler('headless-scrap', HeadlessScrap)

package/server/engine/task/http-get.ts

@@ -1,117 +0,0 @@
-import fetch from 'node-fetch'
-import 'ses'
-import { URL } from 'url'
-import https from 'https'
-import { TaskRegistry } from '../task-registry'
-import { ConnectionManager } from '../connection-manager'
-import { substitute } from './utils/substitute'
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
-
-async function HttpGet(step: InputStep, { logger, data, domain, user, variables, lng }: Context) {
-  var { connection: connectionName, params: stepOptions } = step
-  var { headers: requestHeaders, searchParams = {}, path } = stepOptions || {}
-  var connection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
-
-  if (!connection) {
-    throw new Error(`connection '${connectionName}' is not established.`)
-  }
-
-  var { endpoint, params: connectionParams, authHeaders = {} } = connection
-
-  const compartment = new Compartment({
-    domain,
-    user,
-    lng,
-    data,
-    variables,
-    console
-  })
-
-  let evalPath
-  try {
-    evalPath = compartment.evaluate('`' + path + '`')
-  } catch (err) {
-    throw new Error(`Failed to evaluate path: ${err.message}`)
-  }
-
-  path = evalPath
-
-  requestHeaders =
-    requestHeaders &&
-    Object.entries(requestHeaders as { [key: string]: string }).reduce((sum, [key, value]) => {
-      try {
-        sum[key] = compartment.evaluate('`' + value + '`')
-      } catch (err) {
-        throw new Error(`Failed to evaluate header value: ${err.message}`)
-      }
-      return sum
-    }, {})
-
-  searchParams =
-    searchParams &&
-    Object.entries(searchParams as { [key: string]: string }).reduce((sum, [key, value]) => {
-      try {
-        sum[key] = compartment.evaluate('`' + value + '`')
-      } catch (err) {
-        throw new Error(`Failed to evaluate search param value: ${err.message}`)
-      }
-      return sum
-    }, {})
-
-  var url = new URL(path, endpoint)
-  if (searchParams) {
-    Object.keys(searchParams).forEach(key => {
-      let value = substitute(searchParams[key], data)
-      url.searchParams.append(key, value)
-    })
-  }
-
-  var fetchOptions: any = {
-    method: 'GET',
-    headers: {
-      ...requestHeaders,
-      ...authHeaders
-    }
-  }
-
-  var { rejectUnauthorized } = connectionParams
-
-  if (!rejectUnauthorized) {
-    const httpsAgent = new https.Agent({
-      rejectUnauthorized
-    })
-    fetchOptions.agent = httpsAgent
-  }
-
-  var response = await fetch(url, fetchOptions)
-
-  return {
-    data:
-      response.ok && response.headers.get('content-type').includes('application/json')
-        ? await response.json()
-        : await response.text()
-  }
-}
-
-HttpGet.parameterSpec = [
-  {
-    type: 'string',
-    name: 'path',
-    label: 'path'
-  },
-  {
-    type: 'http-headers',
-    name: 'headers',
-    label: 'headers'
-  },
-  {
-    type: 'http-parameters',
-    name: 'searchParams',
-    label: 'search-params'
-  }
-]
-
-HttpGet.help = 'integration/task/http-get'
-
-TaskRegistry.registerTaskHandler('http-get', HttpGet)