@things-factory/integration-base 8.0.0 → 9.0.0-beta.3

package/server/engine/task/mssql-procedure.ts

@@ -1,128 +0,0 @@
-import { logger } from '@things-factory/env'
-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'
-import 'ses'
-
-try {
-  var mssql = require('mssql')
-} catch (err) {
-  logger.error('mssql module loading failed', err)
-}
-
-type ProcedureParameterType = {
-  name: string
-  dir: string
-  type: string
-  val?: any
-  accessor?: string
-  maxSize?: number
-}
-
-type ValueType = {
-  code?: string
-  procedure?: string
-  parameters?: ProcedureParameterType[]
-}
-
-const DIR = {
-  In: 'in',
-  Out: 'out',
-  Inout: 'inout' /* 초기값이 있는 out 파라미터 */
-}
-
-const NUMBER_TYPES = [
-  'TINYINT',
-  'SMALLINT',
-  'INT',
-  'BIGINT',
-  'FLOAT',
-  'READ',
-  'DECIMAL',
-  'NUMERIC',
-  'MONEY',
-  'SMALLMONEY'
-]
-
-const DATE_TYPES = ['DATE', 'TIME', 'DATETIME', 'SMALLDATETIME', 'DATETIME2']
-const PARAMETERIZED_STRINGS = ['NCHAR', 'NVARCHAR', 'NTEXT', 'DECIMAL', 'NUMERIC']
-
-async function MssqlProcedure(step: InputStep, context: Context) {
-  var { domain, user, data, variables, lng } = context
-  var { connection: connectionName, params } = step
-
-  var { code = '', procedure = '', parameters = [] } = params.parameters as ValueType
-
-  var dbconnection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
-
-  if (!code) {
-    throw 'procedure code not defined'
-  }
-
-  const compartment = new Compartment({
-    domain,
-    user,
-    lng,
-    data,
-    variables,
-    console
-  })
-
-  let evalCode
-  try {
-    evalCode = compartment.evaluate('`' + code + '`')
-  } catch (err) {
-    throw new Error(`Failed to evaluate code: ${err.message}`)
-  }
-
-  code = evalCode
-
-  const procedureParameters =
-    parameters &&
-    parameters.reduce((sum, { name, val, dir, type, accessor, maxSize }) => {
-      sum[name] = {
-        dir: DIR[dir],
-        type
-      }
-
-      const calculated = accessor ? access(accessor, data) || val : val
-
-      if (calculated !== undefined) {
-        sum[name].val = NUMBER_TYPES.includes(type)
-          ? Number(calculated)
-          : DATE_TYPES.includes(type)
-            ? new Date(calculated)
-            : String(calculated)
-      }
-
-      if ((dir == DIR.In || dir == DIR.Inout) && maxSize > 0 && type == 'String') {
-        sum[name].type = mssql?.VarChar(maxSize)
-        sum[name].maxSize = maxSize
-      }
-
-      return sum
-    }, {})
-
-  const result = await dbconnection.execute(procedure, procedureParameters)
-
-  return {
-    data: result
-  }
-}
-
-MssqlProcedure.parameterSpec = [
-  {
-    type: 'procedure-parameters',
-    name: 'parameters',
-    label: '',
-    property: {
-      dbtype: 'mssql'
-    }
-  }
-]
-
-MssqlProcedure.help = 'integration/task/mssql-procedure'
-
-TaskRegistry.registerTaskHandler('mssql-procedure', MssqlProcedure)

package/server/engine/task/oracle-procedure.ts

@@ -1,124 +0,0 @@
-import { logger } from '@things-factory/env'
-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'
-import 'ses'
-
-try {
-  var oracledb = require('oracledb')
-} catch (err) {
-  logger.error('oracledb module loading failed', err)
-}
-
-type ProcedureParameterType = {
-  name: string
-  dir: string
-  type: string
-  val?: any
-  accessor?: string
-  maxSize?: number
-}
-
-type ValueType = {
-  code?: string
-  procedure?: string
-  parameters?: ProcedureParameterType[]
-}
-
-const TYPES = {
-  Number: oracledb?.NUMBER,
-  String: oracledb?.STRING,
-  Date: oracledb?.DATE,
-  Buffer: oracledb?.BUFFER,
-  Blob: oracledb?.BLOB,
-  Clob: oracledb?.CLOB,
-  Cursor: oracledb?.CURSOR
-}
-
-const DIR = {
-  In: oracledb?.BIND_IN,
-  Inout: oracledb?.BIND_INOUT,
-  Out: oracledb?.BIND_OUT
-}
-
-async function OracleProcedure(step: InputStep, context: Context) {
-  var { domain, user, data, variables, lng } = context
-  var { connection: connectionName, params } = step
-
-  var { code = '', parameters = [] } = params.parameters as ValueType
-
-  var dbconnection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
-
-  if (!code) {
-    throw 'procedure code not defined'
-  }
-
-  const compartment = new Compartment({
-    domain,
-    user,
-    lng,
-    data,
-    variables,
-    console
-  })
-
-  let evalCode
-  try {
-    evalCode = compartment.evaluate('`' + code + '`')
-  } catch (err) {
-    throw new Error(`Failed to evaluate code: ${err.message}`)
-  }
-
-  code = evalCode
-
-  const procedureParameters =
-    parameters &&
-    parameters.reduce((sum, { name, val, dir, type, accessor, maxSize }) => {
-      sum[name] = {
-        dir: DIR[dir],
-        type: TYPES[type]
-      }
-
-      const calculated = accessor ? access(accessor, data) || val : val
-
-      if (calculated !== undefined) {
-        sum[name].val =
-          type === 'Date'
-            ? new Date(calculated)
-            : type == 'Number'
-              ? Number(calculated)
-              : type == 'String'
-                ? String(calculated)
-                : calculated
-      }
-
-      if (maxSize) {
-        sum[name].maxSize = maxSize
-      }
-
-      return sum
-    }, {})
-
-  const result = await dbconnection.execute(code, procedureParameters)
-
-  return {
-    data: result
-  }
-}
-
-OracleProcedure.parameterSpec = [
-  {
-    type: 'procedure-parameters',
-    name: 'parameters',
-    label: '',
-    property: {
-      dbtype: 'oracle'
-    }
-  }
-]
-
-OracleProcedure.help = 'integration/task/oracle-procedure'
-
-TaskRegistry.registerTaskHandler('oracle-procedure', OracleProcedure)

package/server/engine/task/pick-pending-scenario.ts

@@ -1,80 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-import { sleep } from '@things-factory/utils'
-
-import { Scenario } from '../../service/scenario/scenario'
-import { ScenarioEngine } from '../scenario-engine'
-import { TaskRegistry } from '../task-registry'
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
-
-const debug = require('debug')('things-factory:integration-base:pick-pending-scenario')
-
-async function PickPendingScenario(step: InputStep, context: Context) {
-  var { logger, load, domain } = context
-  var { params } = step
-  var { tag = '', waitFor = -1 } = params || {}
-
-  waitFor = Number(waitFor) || -1
-  const till = Date.now() + waitFor
-
-  const pendingQueue = ScenarioEngine.getPendingQueue(domain)
-
-  // long-term task need to check state whether this scenario is still going.
-  while (true && context.checkState()) {
-    var { stuff } = pendingQueue.pick(tag) || {}
-    if (stuff) {
-      break
-    }
-
-    let toTill = waitFor == -1 ? 1000 : till - Date.now()
-    if (toTill <= 0) {
-      return {}
-    }
-
-    await sleep(Math.min(1000, toTill))
-  }
-
-  if (!stuff) {
-    return
-  }
-
-  var { scenario, variables } = stuff
-
-  var subscenario = await getRepository(Scenario).findOne({
-    where: {
-      id: scenario
-    },
-    relations: ['steps', 'domain']
-  })
-
-  logger.info(`Scenario '${subscenario.name}' Started.`)
-  var subContext = await load(step, subscenario, {
-    ...context,
-    data: {},
-    variables
-  })
-  logger.info(`Scenario '${subscenario.name}' done.`)
-
-  return {
-    data: subContext.data
-  }
-}
-
-PickPendingScenario.parameterSpec = [
-  {
-    type: 'string',
-    name: 'tag',
-    label: 'tag'
-  },
-  {
-    type: 'number',
-    name: 'waitFor',
-    label: 'wait-for',
-    placeHolder: 'milli-seconds'
-  }
-]
-
-PickPendingScenario.connectorFree = true
-PickPendingScenario.help = 'integration/task/pick-pending-scenario'
-
-TaskRegistry.registerTaskHandler('pick-pending-scenario', PickPendingScenario)

package/server/engine/task/publish.ts

@@ -1,40 +0,0 @@
-import { access } from '@things-factory/utils'
-import { TaskRegistry } from '../task-registry'
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
-
-async function Publish(step: InputStep, { logger, publish, data }: Context) {
-  var {
-    params: { tag, accessor }
-  } = step
-
-  if (!tag || !accessor) {
-    throw Error(`tag and accessor should be defined: tag - '${tag}', accessor - '${accessor}'`)
-  }
-
-  var value = access(accessor, data)
-
-  publish(tag, value)
-
-  return {
-    data: value
-  }
-}
-
-Publish.parameterSpec = [
-  {
-    type: 'string',
-    name: 'tag',
-    label: 'tag'
-  },
-  {
-    type: 'scenario-step-input',
-    name: 'accessor',
-    label: 'accessor'
-  }
-]
-
-Publish.connectorFree = true
-Publish.help = 'integration/task/publish'
-
-TaskRegistry.registerTaskHandler('publish', Publish)

package/server/engine/task/random.ts

@@ -1,53 +0,0 @@
-import { TaskRegistry } from '../task-registry'
-import Chance from 'chance'
-
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
-
-const formats = [
-  'bool,character,floating,integer,letter,natural,string',
-  'paragraph,sentence,syllable,word',
-  'age,birthday,cf,cpf,first,gender,last,name,prefix,ssn,suffix',
-  'android_id,apple_token,bb_pin,wp7_anid,wp8_anid2,avatar,color',
-  'company,domain,email,fbid,google_analytics,hashtag,ip,ipv6,klout,profession,tld,twitter,url',
-  'address,altitude,areacode,city,coordinates,country,depth,geohash,latitude,longitude,phone,postal,province,state,street,zip',
-  'ampm,date,hammertime,hour,millisecond,minute,month,second,timestamp,timezone,weekday,year',
-  'cc,cc_type,currency,currency_pair,dollar,euro,exp,exp_month,exp_year',
-  'coin,d4,d6,d8,d10,d12,d20,d30,d100,guid,hash'
-]
-  .join(',')
-  .split(',')
-
-async function Random(step: InputStep, { logger, publish, data }: Context) {
-  var {
-    params: { format = 'integer', count = 1 }
-  } = step
-
-  const chance = new Chance()
-
-  return {
-    data: chance.n(chance[format], count)
-  }
-}
-
-Random.parameterSpec = [
-  {
-    type: 'select',
-    label: 'format',
-    name: 'format',
-    property: {
-      options: formats.map(format => ({ display: format, value: format }))
-    }
-  },
-  {
-    type: 'number',
-    label: 'count',
-    name: 'count',
-    placeholder: '1'
-  }
-]
-
-Random.connectorFree = true
-Random.help = 'integration/task/random'
-
-TaskRegistry.registerTaskHandler('random', Random)

package/server/engine/task/reset-pending-queue.ts

@@ -1,17 +0,0 @@
-import { TaskRegistry } from '../task-registry'
-import { ScenarioEngine } from '../scenario-engine'
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
-
-async function ResetPendingScenario(step: InputStep, { domain }: Context) {
-  const pendingQueue = ScenarioEngine.getPendingQueue(domain)
-  pendingQueue.reset()
-
-  return {}
-}
-
-ResetPendingScenario.parameterSpec = []
-
-ResetPendingScenario.connectorFree = true
-
-TaskRegistry.registerTaskHandler('reset-pending-scenario', ResetPendingScenario)

package/server/engine/task/script.ts

@@ -1,63 +0,0 @@
-import { TaskRegistry } from '../task-registry'
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
-import 'ses'
-
-async function Script(step: InputStep, context: Context) {
-  const {
-    params: { script }
-  } = step
-
-  const { domain, user, data, variables, lng, logger } = context
-
-  const compartment = new Compartment({
-    domain,
-    user,
-    data,
-    variables,
-    logger,
-    lng,
-    console,
-    Math,
-    JSON,
-    Date,
-    setTimeout,
-    setInterval,
-    clearTimeout,
-    clearInterval
-  })
-
-  const scriptSource = `
-    (async () => {
-      ${script}
-    })();
-  `
-
-  try {
-    return {
-      data: await compartment.evaluate(scriptSource)
-    }
-  } catch (err) {
-    throw new Error(`Script execution failed: ${err.message}`)
-  }
-}
-
-Script.parameterSpec = [
-  {
-    type: 'textarea',
-    name: 'script',
-    label: 'script',
-    property: {
-      language: 'javascript',
-      showLineNumbers: true
-    },
-    styles: {
-      flex: '1'
-    }
-  }
-]
-
-Script.connectorFree = true
-Script.help = 'integration/task/script'
-
-TaskRegistry.registerTaskHandler('script', Script)

package/server/engine/task/set-domain.ts

@@ -1,37 +0,0 @@
-import { TaskRegistry } from '../task-registry'
-import { Domain, getRepository } from '@things-factory/shell'
-
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
-
-async function SetDomain(step: InputStep, context: Context) {
-  var {
-    params: { subdomain }
-  } = step
-
-  var { logger, domain } = context || {}
-
-  logger.info(`domain => ${subdomain}`)
-
-  if (subdomain) {
-    context.domain = (await getRepository(Domain).findOneBy({ subdomain })) || domain
-  }
-
-  return {
-    data: domain.subdomain // previous domain
-  }
-}
-
-SetDomain.parameterSpec = [
-  {
-    type: 'string',
-    name: 'subdomain',
-    placeholder: 'subdomain',
-    label: 'subdomain'
-  }
-]
-
-SetDomain.connectorFree = true
-SetDomain.help = 'integration/task/set-domain'
-
-TaskRegistry.registerTaskHandler('set-domain', SetDomain)

package/server/engine/task/sleep.ts

@@ -1,34 +0,0 @@
-import { sleep } from '@things-factory/utils'
-import { TaskRegistry } from '../task-registry'
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
-
-async function Sleep(step: InputStep, { logger }: Context) {
-  var {
-    params: { duration }
-  } = step
-
-  logger.info(`sleep ${duration}ms`)
-
-  if (duration) {
-    await sleep(duration)
-  }
-
-  return {
-    data: duration
-  }
-}
-
-Sleep.parameterSpec = [
-  {
-    type: 'number',
-    name: 'duration',
-    placeholder: 'milli-seconds',
-    label: 'duration'
-  }
-]
-
-Sleep.connectorFree = true
-Sleep.help = 'integration/task/sleep'
-
-TaskRegistry.registerTaskHandler('sleep', Sleep)

package/server/engine/task/socket-listener.ts

@@ -1,96 +0,0 @@
-import { sleep } 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'
-
-function convertDataFormat(data, format) {
-  try {
-    if (format == 'json') {
-      return JSON.parse(data)
-    } else if (format == 'csv') {
-      return data.split(',')
-    }
-  } catch (e) {
-    return data.toString()
-  }
-
-  return data
-}
-
-async function SocketListener(step: InputStep, context: Context) {
-  //get connection data
-  const {
-    connection: connectionName,
-    params: { dataFormat = 'JSON' },
-    name
-  } = step
-
-  const { domain, logger, closures, __socket_listener } = context
-  logger.info('\r\n')
-  if (!__socket_listener) {
-    context.__socket_listener = {}
-  }
-
-  // get socket information from connection
-  var connection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
-  if (!connection) {
-    throw new Error(`connector '${connectionName}' is not established.`)
-  }
-
-  /*
-   * 1. listner list에서 listner를 찾는다. 없으면, 생성한다.
-   */
-  if (!context.__socket_listener[name]) {
-    try {
-      var MESSAGES = []
-      context.__socket_listener[name] = async () => {
-        while (MESSAGES.length == 0) {
-          await sleep(100)
-        }
-        var message = MESSAGES.shift()
-        return {
-          message
-        }
-      }
-
-      await connection.addListener('socket-message-arrive', async message => {
-        logger.info(message.toString())
-        MESSAGES.push(convertDataFormat(message.toString(), dataFormat))
-      })
-    } catch (e) {
-      logger.error(e)
-    }
-  }
-
-  var { message } = await context.__socket_listener[name]()
-
-  return {
-    data: message
-  }
-}
-
-SocketListener.parameterSpec = [
-  {
-    type: 'select',
-    label: 'data-format',
-    name: 'dataFormat',
-    property: {
-      options: [
-        {
-          display: 'CSV',
-          value: 'csv'
-        },
-        {
-          display: 'JSON',
-          value: 'json'
-        },
-        {
-          display: 'String',
-          value: 'string'
-        }
-      ]
-    }
-  }
-]
-TaskRegistry.registerTaskHandler('socket-listener', SocketListener)