@things-factory/integration-base 8.0.0-beta.9 → 8.0.2

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

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

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

@@ -0,0 +1,148 @@
+import fetch from 'node-fetch'
+import { URL } from 'url'
+import 'ses'
+import { access } from '@things-factory/utils'
+import { TaskRegistry } from '../task-registry'
+import { ConnectionManager } from '../connection-manager'
+import https from 'https'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function HttpPost(step: InputStep, { logger, data, domain, user, variables, lng }: 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
+
+  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
+    }, {})
+
+  var url = new URL(path, endpoint)
+  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 fetchOptions: any = {
+    method: 'POST',
+    headers,
+    body
+  }
+
+  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()
+  }
+}
+
+HttpPost.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'
+  }
+]
+
+HttpPost.help = 'integration/task/http-post'
+
+TaskRegistry.registerTaskHandler('http-post', HttpPost)

package/server/engine/task/index.ts

@@ -0,0 +1,45 @@
+import './echo-send'
+import './echo-receive'
+import './sleep'
+import './log'
+import './publish'
+import './http-get'
+import './http-post'
+import './graphql-query'
+import './graphql-mutate'
+import './local-graphql-query'
+import './local-graphql-mutate'
+import './sub-scenario'
+import './stop-scenario'
+import './book-up-scenario'
+import './pick-pending-scenario'
+import './reset-pending-queue'
+import './empty-check'
+import './goto'
+import './end'
+import './switch-goto'
+import './switch-range-goto'
+import './switch-scenario'
+import './switch-range-scenario'
+import './switch-set'
+import './switch-range-set'
+import './script'
+import './database-query'
+import './mqtt-subscribe'
+import './mqtt-publish'
+import './throw'
+import './variables'
+import './floating-point'
+import './socket-listener'
+import './random'
+import './csv-readline'
+import './data-mapper'
+import './headless-post'
+import './headless-scrap'
+import './set-domain'
+import './mssql-procedure'
+import './oracle-procedure'
+import './jsonata'
+import './state-read'
+import './state-write'
+import './state-group-read'

package/server/engine/task/jsonata.ts

@@ -0,0 +1,45 @@
+import jsonata from 'jsonata'
+
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function JSonata(step: InputStep, context: Context) {
+  var {
+    params: { expression }
+  } = step
+
+  const { domain, user, data, variables, lng, logger } = context
+
+  var result = jsonata(expression).evaluate({
+    domain,
+    user,
+    lng,
+    data,
+    variables
+  })
+
+  return {
+    data: result
+  }
+}
+
+JSonata.parameterSpec = [
+  {
+    type: 'textarea',
+    name: 'expression',
+    label: 'jsonata-expression',
+    property: {
+      language: 'javascript',
+      showLineNumbers: true
+    },
+    styles: {
+      flex: '1'
+    }
+  }
+]
+
+JSonata.connectorFree = true
+JSonata.help = 'integration/task/jsonata'
+
+TaskRegistry.registerTaskHandler('jsonata', JSonata)

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

@@ -0,0 +1,100 @@
+import gql from 'graphql-tag'
+import 'ses'
+
+import { User } from '@things-factory/auth-base'
+import { getRepository } from '@things-factory/shell'
+import { access } from '@things-factory/utils'
+
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function LocalGraphqlMutate(step: InputStep, context: Context) {
+  var { params, updaterId } = step
+  var { mutation, variables: variablesAccessorMap, headers } = params || {}
+  var { logger, client, domain, user, data, variables, lng } = context
+
+  user =
+    user ||
+    (await getRepository(User).findOne({
+      where: { id: updaterId },
+      relations: ['domains']
+    }))
+
+  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}`)
+  }
+
+  mutation = evalMutation
+
+  const queryVariables = Object.keys(variablesAccessorMap || {}).reduce((variables, key) => {
+    const accessor = variablesAccessorMap[key]
+    variables[key] = access(accessor, data)
+    return variables
+  }, {})
+
+  var { data: mutateResult, errors } = await client.mutate({
+    mutation: gql`
+      ${mutation}
+    `,
+    variables: queryVariables,
+    headers,
+    context: {
+      state: {
+        domain,
+        user
+      }
+    }
+  })
+
+  if (errors) {
+    errors.forEach(error => {
+      logger.error('GraphQL Error: %s', error)
+    })
+  }
+
+  return {
+    data: mutateResult
+  }
+}
+
+LocalGraphqlMutate.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'
+  }
+]
+
+LocalGraphqlMutate.connectorFree = true
+LocalGraphqlMutate.help = 'integration/task/local-graphql-mutate'
+
+TaskRegistry.registerTaskHandler('local-graphql-mutate', LocalGraphqlMutate)

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

@@ -0,0 +1,100 @@
+import gql from 'graphql-tag'
+import 'ses'
+
+import { User } from '@things-factory/auth-base'
+import { getRepository } from '@things-factory/shell'
+import { access } from '@things-factory/utils'
+
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function LocalGraphqlQuery(step: InputStep, context: Context) {
+  var { params, updaterId } = step
+  var { query, variables: variablesAccessorMap, headers } = params || {}
+  var { logger, client, domain, user, data, variables, lng } = context
+
+  user =
+    user ||
+    (await getRepository(User).findOne({
+      where: { id: updaterId },
+      relations: ['domains']
+    }))
+
+  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}`)
+  }
+
+  query = evalQuery
+
+  const queryVariables = Object.keys(variablesAccessorMap || {}).reduce((variables, key) => {
+    const accessor = variablesAccessorMap[key]
+    variables[key] = access(accessor, data)
+    return variables
+  }, {})
+
+  var { data: queryResult, errors } = await client.query({
+    query: gql`
+      ${query}
+    `,
+    variables: queryVariables,
+    headers,
+    context: {
+      state: {
+        domain,
+        user
+      }
+    }
+  })
+
+  if (errors) {
+    errors.forEach(error => {
+      logger.error('GraphQL Error: %s', error)
+    })
+  }
+
+  return {
+    data: queryResult
+  }
+}
+
+LocalGraphqlQuery.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'
+  }
+]
+
+LocalGraphqlQuery.connectorFree = true
+LocalGraphqlQuery.help = 'integration/task/local-graphql-query'
+
+TaskRegistry.registerTaskHandler('local-graphql-query', LocalGraphqlQuery)

package/server/engine/task/log.ts

@@ -0,0 +1,78 @@
+import { access, hasTemplateExpression } from '@things-factory/utils'
+import 'ses'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function Log(step: InputStep, { logger, data, variables, domain, user, lng }: Context) {
+  var {
+    params: { message, accessor, level = 'info' }
+  } = step
+
+  if (hasTemplateExpression(message)) {
+    const compartment = new Compartment({
+      domain,
+      user,
+      lng,
+      data,
+      variables,
+      console
+    })
+
+    try {
+      message = compartment.evaluate('`' + message + '`')
+    } catch (err) {
+      throw new Error(`Failed to evaluate message: ${err.message}`)
+    }
+  }
+
+  accessor = access(accessor, data)
+
+  if (accessor) {
+    if (typeof accessor !== 'string') {
+      accessor = JSON.stringify(accessor, null, 2)
+    }
+    message += ': ' + accessor
+  }
+
+  switch (level) {
+    case 'error':
+      logger.error(message)
+      return
+    case 'warn':
+      logger.warn(message)
+      return
+    default:
+      logger.info(message)
+  }
+
+  return {
+    data: message
+  }
+}
+
+Log.parameterSpec = [
+  {
+    type: 'string',
+    name: 'message',
+    label: 'message'
+  },
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  },
+  {
+    type: 'select',
+    name: 'level',
+    label: 'level',
+    property: {
+      options: ['info', 'warn', 'error']
+    }
+  }
+]
+
+Log.connectorFree = true
+Log.help = 'integration/task/log'
+
+TaskRegistry.registerTaskHandler('log', Log)

package/server/engine/task/mqtt-publish.ts

@@ -0,0 +1,45 @@
+import { access } from '@things-factory/utils'
+import { TaskRegistry } from '../task-registry'
+import { ConnectionManager } from '../connection-manager'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function MqttPublish(step: InputStep, { logger, data, domain }: Context) {
+  var {
+    connection: connectionName,
+    params: { topic, accessor }
+  } = step
+
+  const { client } = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
+  if (!client) {
+    throw Error(`connection is not found : ${connectionName}`)
+  }
+
+  if (!topic || !accessor) {
+    throw Error(`topic and accessor should be defined: : topic - '${topic}', accessor - '${accessor}'`)
+  }
+
+  var message = JSON.stringify(access(accessor, data))
+  await client.publish(topic, message)
+
+  return {
+    data: message
+  }
+}
+
+MqttPublish.parameterSpec = [
+  {
+    type: 'string',
+    name: 'topic',
+    label: 'topic'
+  },
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  }
+]
+
+MqttPublish.help = 'integration/task/mqtt-publish'
+
+TaskRegistry.registerTaskHandler('mqtt-publish', MqttPublish)