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

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

@@ -1,291 +0,0 @@
-import mqtt from 'async-mqtt'
-
-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'
-
-function convertDataFormat(data, format) {
-  if (format == 'json') {
-    try {
-      return JSON.parse(data)
-    } catch (e) {
-      console.error('JSON 파싱 오류:', e.message)
-      return data.toString()
-    }
-  } else {
-    return data.toString()
-  }
-}
-
-// MQTT 연결을 위한 브로커 관리 클래스
-class MqttBrokerManager {
-  private static brokers: Record<
-    string,
-    {
-      client: mqtt.AsyncMqttClient
-      topics: Set<string>
-      messageHandlers: Map<string, (topic: string, message: Buffer) => void>
-    }
-  > = {}
-
-  // 브로커 연결 (또는 기존 연결 반환)
-  static async getBroker(uri: string, options?: mqtt.IClientOptions) {
-    const brokerKey = `${uri}_${JSON.stringify(options || {})}`
-
-    if (!this.brokers[brokerKey]) {
-      const client = await mqtt.connectAsync(uri, options)
-
-      this.brokers[brokerKey] = {
-        client,
-        topics: new Set<string>(),
-        messageHandlers: new Map()
-      }
-
-      // 메시지 수신 핸들러
-      client.on('message', (topic, message) => {
-        // 해당 토픽에 등록된 핸들러가 있으면 호출
-        this.brokers[brokerKey].messageHandlers.forEach((handler, handlerId) => {
-          if (handlerId.startsWith(`${topic}:`)) {
-            handler(topic, message)
-          }
-        })
-      })
-    }
-
-    return this.brokers[brokerKey]
-  }
-
-  // 토픽 구독 등록
-  static async subscribe(brokerKey: string, topic: string) {
-    const broker = this.brokers[brokerKey]
-    if (!broker) {
-      throw new Error(`브로커가 연결되지 않음: ${brokerKey}`)
-    }
-
-    // 새 토픽인 경우 구독
-    if (!broker.topics.has(topic)) {
-      await broker.client.subscribe(topic)
-      broker.topics.add(topic)
-    }
-  }
-
-  // 메시지 핸들러 등록
-  static registerMessageHandler(
-    brokerKey: string,
-    topic: string,
-    handlerId: string,
-    handler: (topic: string, message: Buffer) => void
-  ) {
-    const broker = this.brokers[brokerKey]
-    if (!broker) {
-      throw new Error(`브로커가 연결되지 않음: ${brokerKey}`)
-    }
-
-    // 핸들러 ID는 topic:handlerId 형식으로 저장
-    const fullHandlerId = `${topic}:${handlerId}`
-    broker.messageHandlers.set(fullHandlerId, handler)
-
-    return () => {
-      // 핸들러 제거 함수 반환
-      broker.messageHandlers.delete(fullHandlerId)
-    }
-  }
-
-  // 연결 종료
-  static async disconnect(brokerKey: string) {
-    const broker = this.brokers[brokerKey]
-    if (broker) {
-      await broker.client.end()
-      delete this.brokers[brokerKey]
-    }
-  }
-
-  // 브로커 키 생성 유틸리티
-  static getBrokerKey(uri: string, options?: any) {
-    return `${uri}_${JSON.stringify(options || {})}`
-  }
-}
-
-interface MqttContext extends Context {
-  __mqtt_connections?: Set<string>
-  __mqtt_handlers?: Map<string, () => void>
-  __mqtt_resolvers?: Map<string, (result: any) => void>
-}
-
-async function MqttSubscribe(step: InputStep, context: MqttContext) {
-  const {
-    connection: connectionName,
-    params: { topic, dataFormat },
-    name: stepName
-  } = step
-
-  const { domain, logger, closures } = context
-
-  // MQTT 브로커 접속 정보 가져오기
-  const {
-    connection: {
-      endpoint: uri,
-      params: { user, password }
-    }
-  } = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
-
-  if (!topic) {
-    throw Error(`토픽이 지정되지 않음: ${connectionName}`)
-  }
-
-  // 브로커 연결 키 생성
-  const connectionOptions = user && password ? { username: user, password } : undefined
-  const brokerKey = MqttBrokerManager.getBrokerKey(uri, connectionOptions)
-
-  // 구독자 ID 생성 (도메인, 연결명, 토픽, 스텝명 조합)
-  const subscriberId = `${domain}_${connectionName}_${topic}_${stepName}`
-
-  try {
-    // 브로커 연결 (또는 기존 연결 가져오기)
-    await MqttBrokerManager.getBroker(uri, connectionOptions)
-    logger.info(`MQTT 연결 완료: ${connectionName}:${uri}`)
-
-    // 토픽 구독 등록
-    await MqttBrokerManager.subscribe(brokerKey, topic)
-    logger.info(`토픽 구독 완료: ${topic}`)
-
-    // 리졸버 저장소 초기화
-    if (!context.__mqtt_resolvers) {
-      context.__mqtt_resolvers = new Map()
-    }
-
-    // 클로저에 연결 종료 함수 등록
-    if (!context.__mqtt_connections) {
-      context.__mqtt_connections = new Set()
-    }
-
-    if (!context.__mqtt_handlers) {
-      context.__mqtt_handlers = new Map()
-    }
-
-    // 연결 추적 (중복 종료 방지)
-    if (!context.__mqtt_connections.has(brokerKey)) {
-      context.__mqtt_connections.add(brokerKey)
-
-      // 연결 종료 함수 등록
-      closures.push(async () => {
-        try {
-          // 핸들러 모두 제거
-          if (context.__mqtt_handlers) {
-            context.__mqtt_handlers.forEach(removeHandler => {
-              removeHandler()
-            })
-            context.__mqtt_handlers.clear()
-          }
-
-          // 대기 중인 모든 Promise 해결
-          if (context.__mqtt_resolvers) {
-            context.__mqtt_resolvers.forEach(resolver => {
-              resolver({ data: null, terminated: true })
-            })
-            context.__mqtt_resolvers.clear()
-          }
-
-          // 연결 종료
-          await MqttBrokerManager.disconnect(brokerKey)
-          logger.info(`MQTT 연결 종료: ${connectionName}:${uri}`)
-        } catch (e) {
-          logger.error(`MQTT 연결 종료 오류: ${e.message}`)
-        }
-      })
-    }
-
-    // Promise로 메시지 수신 대기
-    return new Promise(resolve => {
-      // 이 태스크의 resolver 저장
-      if (context.__mqtt_resolvers) {
-        context.__mqtt_resolvers.set(subscriberId, resolve)
-      }
-
-      // 이미 등록된 핸들러가 있으면 제거
-      if (context.__mqtt_handlers?.has(subscriberId)) {
-        const removeHandler = context.__mqtt_handlers.get(subscriberId)
-        if (removeHandler) {
-          removeHandler()
-        }
-      }
-
-      // 새로운 메시지 핸들러 등록
-      const removeHandler = MqttBrokerManager.registerMessageHandler(
-        brokerKey,
-        topic,
-        subscriberId,
-        (messageTopic, message) => {
-          try {
-            // 메시지 변환
-            const convertedMessage = convertDataFormat(message, dataFormat)
-
-            // resolver 가져오기 및 삭제
-            if (context.__mqtt_resolvers?.has(subscriberId)) {
-              const resolver = context.__mqtt_resolvers.get(subscriberId)
-              context.__mqtt_resolvers.delete(subscriberId)
-
-              // 이 태스크에 대한 핸들러 제거 (한 번만 실행되도록)
-              if (context.__mqtt_handlers?.has(subscriberId)) {
-                const removeHandler = context.__mqtt_handlers.get(subscriberId)
-                if (removeHandler) {
-                  removeHandler()
-                }
-                context.__mqtt_handlers.delete(subscriberId)
-              }
-
-              // Promise 해결
-              if (resolver) {
-                resolver({
-                  data: convertedMessage
-                })
-              }
-            }
-          } catch (error) {
-            logger.error(`메시지 처리 오류: ${error.message}`)
-          }
-        }
-      )
-
-      // 핸들러 제거 함수 저장
-      if (context.__mqtt_handlers) {
-        context.__mqtt_handlers.set(subscriberId, removeHandler)
-      }
-
-      logger.info(`MQTT 메시지 대기 중: ${topic}`)
-    })
-  } catch (e) {
-    logger.error(`MQTT 구독 오류: ${e.message}`)
-    throw e
-  }
-}
-
-MqttSubscribe.parameterSpec = [
-  {
-    type: 'string',
-    name: 'topic',
-    label: 'topic'
-  },
-  {
-    type: 'select',
-    label: 'data-format',
-    name: 'dataFormat',
-    property: {
-      options: [
-        {
-          display: 'Plain Text',
-          value: 'text'
-        },
-        {
-          display: 'JSON',
-          value: 'json'
-        }
-      ]
-    }
-  }
-]
-
-MqttSubscribe.help = 'integration/task/mqtt-subscribe'
-
-TaskRegistry.registerTaskHandler('mqtt-subscribe', MqttSubscribe)

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)