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

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

@@ -0,0 +1,56 @@
+import { ConnectionManager } from '../connection-manager'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+import 'ses'
+
+async function DatabaseQuery(step: InputStep, context: Context) {
+  var { domain, user, data, variables, lng } = context
+  var {
+    connection: connectionName,
+    params: { query }
+  } = step
+
+  var dbconnection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
+
+  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 queryResult = await dbconnection.query(evalQuery, [])
+
+  return {
+    data: queryResult
+  }
+}
+
+DatabaseQuery.parameterSpec = [
+  {
+    type: 'textarea',
+    name: 'query',
+    label: 'query',
+    property: {
+      language: 'sql',
+      showLineNumbers: true
+    },
+    styles: {
+      flex: '1'
+    }
+  }
+]
+
+DatabaseQuery.help = 'integration/task/database-query'
+
+TaskRegistry.registerTaskHandler('database-query', DatabaseQuery)

package/server/engine/task/echo-receive.ts

@@ -0,0 +1,21 @@
+import { TaskRegistry } from '../task-registry'
+import { ConnectionManager } from '../connection-manager'
+
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function EchoReceive(step: InputStep, { logger, domain }: Context) {
+  var { connection: connectionName } = step
+
+  var connection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
+
+  var message = await connection.read()
+
+  return {
+    data: message.toString()
+  }
+}
+
+EchoReceive.parameterSpec = []
+
+TaskRegistry.registerTaskHandler('echo-receive', EchoReceive)

package/server/engine/task/echo-send.ts

@@ -0,0 +1,32 @@
+import { TaskRegistry } from '../task-registry'
+import { ConnectionManager } from '../connection-manager'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function EchoSend(step: InputStep, { logger, domain }: Context) {
+  var {
+    connection: connectionName,
+    params: { message }
+  } = step
+
+  var connection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
+  if (!connection) {
+    throw Error(`connection is not found : ${connectionName}`)
+  }
+
+  var data = await connection.write(message)
+
+  return {
+    data
+  }
+}
+
+EchoSend.parameterSpec = [
+  {
+    type: 'string',
+    name: 'message',
+    label: 'message'
+  }
+]
+
+TaskRegistry.registerTaskHandler('echo-send', EchoSend)

package/server/engine/task/empty-check.ts

@@ -0,0 +1,38 @@
+import { TaskRegistry } from '../task-registry'
+import { access } from '@things-factory/utils'
+
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function EmptyCheck(step: InputStep, { logger, data }: Context) {
+  var {
+    params: { accessor, goto }
+  } = step
+
+  const value = access(accessor, data)
+  if ([null, undefined, NaN, ''].indexOf(value) !== -1) {
+    return {
+      next: goto
+    }
+  }
+
+  return {}
+}
+
+EmptyCheck.parameterSpec = [
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  },
+  {
+    type: 'scenario-step-input',
+    name: 'goto',
+    label: 'goto'
+  }
+]
+
+EmptyCheck.connectorFree = true
+EmptyCheck.help = 'integration/task/empty-check'
+
+TaskRegistry.registerTaskHandler('empty-check', EmptyCheck)

package/server/engine/task/end.ts

@@ -0,0 +1,18 @@
+import { TaskRegistry } from '../task-registry'
+import { ScenarioInstanceStatus } from '../../service'
+
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function End(step: InputStep, { logger }: Context) {
+  return {
+    state: ScenarioInstanceStatus.STOPPED
+  }
+}
+
+End.parameterSpec = []
+
+End.connectorFree = true
+End.help = 'integration/task/end'
+
+TaskRegistry.registerTaskHandler('end', End)

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

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

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

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

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

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

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