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

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

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

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

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

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

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

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

@@ -1,69 +0,0 @@
-import { access } from '@things-factory/utils'
-import { TaskRegistry } from '../task-registry.js'
-import { ConnectionManager } from '../connection-manager.js'
-import { InputStep } from '../../service/step/step-type.js'
-import { Context } from '../types.js'
-
-async function MqttPublish(step: InputStep, { logger, data, domain }: Context) {
-  var {
-    connection: connectionName,
-    params: { topic, accessor, dataFormat = 'json' }
-  } = 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 = access(accessor, data)
-
-  if (dataFormat === 'text') {
-    message = String(message)
-  } else {
-    message = JSON.stringify(message)
-  }
-
-  await client.publish(topic, message)
-
-  return {
-    data: message
-  }
-}
-
-MqttPublish.parameterSpec = [
-  {
-    type: 'string',
-    name: 'topic',
-    label: 'topic'
-  },
-  {
-    type: 'scenario-step-input',
-    name: 'accessor',
-    label: 'accessor'
-  },
-  {
-    type: 'select',
-    label: 'data-format',
-    name: 'dataFormat',
-    property: {
-      options: [
-        {
-          display: 'Plain Text',
-          value: 'text'
-        },
-        {
-          display: 'JSON',
-          value: 'json'
-        }
-      ]
-    }
-  }
-]
-
-MqttPublish.help = 'integration/task/mqtt-publish'
-
-TaskRegistry.registerTaskHandler('mqtt-publish', MqttPublish)