@things-factory/integration-base 7.0.0-alpha.0 → 7.0.0-alpha.18

package/server/engine/connector/proxy-connector.ts

@@ -0,0 +1,53 @@
+import { ConnectionManager } from '../connection-manager'
+import { Connector } from '../types'
+import { InputConnection } from '../../service/connection/connection-type'
+import { connectConnections, disconnectConnections } from '../edge-client'
+
+/**
+ * This connector is a proxy connector installed on the edge server to manage connections from the host.
+ * It interacts with connections established on the edge server and provides synchronization functionality.
+ */
+export class ProxyConnector implements Connector {
+  public static instance = new ProxyConnector()
+
+  async ready(connectionConfigs: InputConnection[]) {
+    await Promise.all(connectionConfigs.map(this.connect.bind(this)))
+
+    ConnectionManager.logger.info('proxy-connector connections are ready')
+  }
+
+  async connect(connection: InputConnection) {
+    // TODO 원래 커넥션과 에지설정을 참고하여, 에지 서버로 CONNECT/DISCONNECT 명령을 보낸다.
+    const proxy = {
+      disconnect: async () => {
+        ConnectionManager.logger.info('[proxy-connector] trying disconnect')
+        await disconnectConnections([connection])
+      }
+    }
+
+    await connectConnections([connection])
+
+    ConnectionManager.addConnectionInstance(connection, proxy)
+
+    ConnectionManager.logger.info(`proxy-connector connection(${connection.name}:${connection.endpoint}) is connected`)
+  }
+
+  async disconnect(connection: InputConnection) {
+    const proxy = ConnectionManager.removeConnectionInstance(connection)
+    await proxy.disconnect()
+
+    ConnectionManager.logger.info(`proxy-connector connection(${connection.name}) is disconnected`)
+  }
+
+  get parameterSpec() {
+    return []
+  }
+
+  get taskPrefixes() {
+    return []
+  }
+
+  get description() {
+    return 'Operato Proxy Connector'
+  }
+}

package/server/engine/connector/socket-server.ts

@@ -1,18 +1,19 @@
 import net from 'net'
+import { EventEmitter } from 'events'
 
 import { Connector } from '../types'
 import { ConnectionManager } from '../connection-manager'
-import { EventEmitter } from 'events'
+import { InputConnection } from '../../service/connection/connection-type'
 
 export class SocketServer implements Connector {
   // socket: any
 
-  async ready(connectionConfigs) {
+  async ready(connectionConfigs: InputConnection[]) {
     await Promise.all(connectionConfigs.map(this.connect))
     ConnectionManager.logger.info('socket servers are ready')
   }
 
-  async connect(config): Promise<void> {
+  async connect(config: InputConnection): Promise<void> {
     var em = new EventEmitter()
     var [host = '0.0.0.0', port = 8124] = config.endpoint.split(':')
     return new Promise((resolve, reject) => {
@@ -62,7 +63,7 @@ export class SocketServer implements Connector {
     })
   }
 
-  async disconnect(connection) {
+  async disconnect(connection: InputConnection) {
     let em = ConnectionManager.removeConnectionInstance(connection)
     var tcp = em['__tcp__']
     var server = em['__server__']

package/server/engine/connector/sqlite-connector.ts

@@ -4,6 +4,8 @@ import { logger } from '@things-factory/env'
 
 import { ConnectionManager } from '../connection-manager'
 import { Connector } from '../types'
+import { InputConnection } from '../../service/connection/connection-type'
+
 
 try {
   var sqlite3 = require('sqlite3').verbose()
@@ -12,13 +14,13 @@ try {
 }
 
 export class SqliteConnector implements Connector {
-  async ready(connectionConfigs) {
+  async ready(connectionConfigs: InputConnection[]) {
     await Promise.all(connectionConfigs.map(this.connect.bind(this)))
 
     ConnectionManager.logger.info('sqlite-connector connections are ready')
   }
 
-  async connect(connection) {
+  async connect(connection: InputConnection) {
     var { endpoint } = connection
 
     if (!sqlite3) {
@@ -42,7 +44,7 @@ export class SqliteConnector implements Connector {
     })
   }
 
-  async disconnect(connection) {
+  async disconnect(connection: InputConnection) {
     var database = ConnectionManager.getConnectionInstance(connection)
     try {
       await database.close()

package/server/engine/edge-client.ts

@@ -0,0 +1,45 @@
+import { Connection } from '../service/connection/connection-type'
+import { Step } from '../service/step/step-type'
+import { Context, TaskHandler } from './types'
+
+export type EdgeClient = {
+  handler: TaskHandler
+  syncConnections(connections: Connection[], context?: ResolverContext): Promise<any>
+  connectConnections(connections: Connection[], context?: ResolverContext): Promise<any>
+  disconnectConnections(connections: Connection[], context?: ResolverContext): Promise<any>
+}
+
+var edgeClient: EdgeClient = {
+  async handler(step: Step, scenarioContext: Context) {
+    throw 'edgeClient not supported'
+  },
+  async syncConnections(connections: Connection[], context: ResolverContext): Promise<any> {
+    throw 'edgeClient not supported'
+  },
+  async connectConnections(connections: Connection[], context: ResolverContext): Promise<any> {
+    throw 'edgeClient not supported'
+  },
+  async disconnectConnections(connections: Connection[], context: ResolverContext): Promise<any> {
+    throw 'edgeClient not supported'
+  }
+}
+
+export async function handler(step: Step, scenarioContext: Context) {
+  return await edgeClient.handler(step, scenarioContext)
+}
+
+export async function syncConnections(connections: Connection[], context?: ResolverContext): Promise<any> {
+  return await edgeClient.syncConnections(connections, context)
+}
+
+export async function connectConnections(connections: Connection[], context?: ResolverContext): Promise<any> {
+  return await edgeClient.connectConnections(connections, context)
+}
+
+export async function disconnectConnections(connections: Connection[], context?: ResolverContext): Promise<any> {
+  return await edgeClient.disconnectConnections(connections, context)
+}
+
+export function setEdgeClient(edge: EdgeClient) {
+  edgeClient = edge
+}

package/server/engine/index.ts

@@ -5,5 +5,6 @@ export * from './connection-manager'
 export * from './scenario-engine'
 export * from './task-registry'
 export * from './analyzer/analyze-integration'
+export * from './edge-client'
 
 export { Connector } from './types'

package/server/engine/task/book-up-scenario.ts

@@ -2,10 +2,12 @@ import { access, deepClone } from '@things-factory/utils'
 import { TaskRegistry } from '../task-registry'
 import { substitute } from './utils/substitute'
 import { ScenarioEngine } from '../scenario-engine'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
 
 const debug = require('debug')('things-factory:integration-base:book-up-scenarios')
 
-async function BookUpScenario(step, { logger, data, domain }) {
+async function BookUpScenario(step: InputStep, { logger, data, domain }: Context) {
   var {
     params: { scenario, delay, priority, variables, tag }
   } = step

package/server/engine/task/csv-readline.ts

@@ -6,6 +6,9 @@ const { Readable } = require('stream')
 
 import { TaskRegistry } from '../task-registry'
 
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
 async function createReadStream(source) {
   let stream
 
@@ -37,7 +40,7 @@ async function createReadStream(source) {
   return stream
 }
 
-async function CsvReadline(step, context) {
+async function CsvReadline(step: InputStep, context: Context) {
   var {
     params: { path }
   } = step

package/server/engine/task/data-accessor.ts

@@ -1,7 +1,10 @@
 import { access } from '@things-factory/utils'
 import { TaskRegistry } from '../task-registry'
 
-async function DataAccessor(step, { logger, data }) {
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function DataAccessor(step: InputStep, { logger, data }: Context) {
   var {
     params: { target, accessor }
   } = step

package/server/engine/task/data-mapper.ts

@@ -1,6 +1,9 @@
 import { access } from '@things-factory/utils'
 import { TaskRegistry } from '../task-registry'
 
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
 function mapping(rule, input) {
   if (Array.isArray(input)) {
     return input.map(i => mapping(rule, i))
@@ -12,7 +15,7 @@ function mapping(rule, input) {
   }, {} as any)
 }
 
-async function DataMapper(step, { logger, data }) {
+async function DataMapper(step: InputStep, { logger, data }: Context) {
   var {
     params: { accessor, mappingRule }
   } = step

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

@@ -1,8 +1,10 @@
 import { VM } from 'vm2'
 import { ConnectionManager } from '../connection-manager'
 import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
 
-async function DatabaseQuery(step, context) {
+async function DatabaseQuery(step: InputStep, context: Context) {
   var { domain, user, data, variables, lng } = context
   var {
     connection: connectionName,

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

@@ -1,7 +1,10 @@
 import { TaskRegistry } from '../task-registry'
 import { ConnectionManager } from '../connection-manager'
 
-async function EchoReceive(step, { logger, domain }) {
+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)

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

@@ -1,7 +1,9 @@
 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, { logger, domain }) {
+async function EchoSend(step: InputStep, { logger, domain }: Context) {
   var {
     connection: connectionName,
     params: { message }

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

@@ -1,7 +1,10 @@
 import { TaskRegistry } from '../task-registry'
 import { access } from '@things-factory/utils'
 
-async function EmptyCheck(step, { logger, data }) {
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function EmptyCheck(step: InputStep, { logger, data }: Context) {
   var {
     params: { accessor, goto }
   } = step

package/server/engine/task/end.ts

@@ -1,7 +1,10 @@
 import { TaskRegistry } from '../task-registry'
 import { ScenarioInstanceStatus } from '../../service'
 
-async function End(step, { logger }) {
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function End(step: InputStep, { logger }: Context) {
   return {
     state: ScenarioInstanceStatus.STOPPED
   }

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

@@ -2,7 +2,10 @@ import ieee754 from 'ieee754'
 import { access } from '@things-factory/utils'
 import { TaskRegistry } from '../task-registry'
 
-async function FloatingPoint(step, { logger, data }) {
+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

package/server/engine/task/goto.ts

@@ -1,6 +1,9 @@
 import { TaskRegistry } from '../task-registry'
 
-async function Goto(step, { logger }) {
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function Goto(step: InputStep, { logger }: Context) {
   var {
     params: { goto }
   } = step

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

@@ -5,8 +5,10 @@ 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, context) {
+async function GraphqlMutate(step: InputStep, context: Context) {
   var { connection: connectionName, params: stepOptions } = step
   var { mutation, variables: variablesAccessorMap, headers } = stepOptions || {}
 

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

@@ -5,8 +5,10 @@ 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, context) {
+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

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

@@ -7,7 +7,10 @@ import { ConnectionManager } from '../connection-manager'
 
 import { getHeadlessPool } from './utils/headless-pool-for-scenario'
 
-async function HeadlessPost(step, { logger, data, domain }) {
+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 || {}
 

package/server/engine/task/headless-scrap.ts

@@ -4,8 +4,10 @@ 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, { logger, data, domain }) {
+async function HeadlessScrap(step: InputStep, { logger, data, domain }: Context) {
   var { connection: connectionName, params: stepOptions } = step
   var { headers: requestHeaders, path, selectors = [] } = stepOptions || {}
 

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

@@ -5,8 +5,10 @@ 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, { logger, data, domain, user, variables, lng }) {
+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)

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

@@ -5,8 +5,10 @@ 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, { logger, data, domain, user, variables, lng }) {
+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 || {}
 

package/server/engine/task/jsonata.ts

@@ -1,7 +1,10 @@
-import { TaskRegistry } from '../task-registry'
 import jsonata from 'jsonata'
 
-async function JSonata(step, context) {
+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

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

@@ -6,8 +6,12 @@ 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, context) {
+
+
+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

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

@@ -6,8 +6,10 @@ 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, context) {
+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

package/server/engine/task/log.ts

@@ -1,8 +1,10 @@
 import { access, hasTemplateExpression } from '@things-factory/utils'
 import { VM } from 'vm2'
 import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
 
-async function Log(step, { logger, data, variables, domain, user, lng }) {
+async function Log(step: InputStep, { logger, data, variables, domain, user, lng }: Context) {
   var {
     params: { message, accessor, level = 'info' }
   } = step

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

@@ -1,8 +1,10 @@
 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, { logger, data, domain }) {
+async function MqttPublish(step: InputStep, { logger, data, domain }: Context) {
   var {
     connection: connectionName,
     params: { topic, accessor }

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

@@ -3,6 +3,8 @@ import mqtt from 'async-mqtt'
 import { TaskRegistry } from '../task-registry'
 import { ConnectionManager } from '../connection-manager'
 import { sleep } from '@things-factory/utils'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
 
 function convertDataFormat(data, format) {
   if (format == 'json') {
@@ -12,7 +14,7 @@ function convertDataFormat(data, format) {
   }
 }
 
-async function MqttSubscribe(step, context) {
+async function MqttSubscribe(step: InputStep, context: Context) {
   const {
     connection: connectionName,
     params: { topic, dataFormat },

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

@@ -3,6 +3,8 @@ 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'
 
 try {
   var oracledb = require('oracledb')
@@ -41,7 +43,7 @@ const DIR = {
   Out: oracledb?.BIND_OUT
 }
 
-async function OracleProcedure(step, context) {
+async function OracleProcedure(step: InputStep, context: Context) {
   var { domain, user, data, variables, lng } = context
   var { connection: connectionName, params } = step
 
@@ -95,23 +97,8 @@ async function OracleProcedure(step, context) {
 
   const result = await dbconnection.execute(code, procedureParameters)
 
-  var taskResult = {}
-  let paramKeys = Object.keys(procedureParameters)
-
-  for (const paramKey of paramKeys) {
-    if (procedureParameters[paramKey].dir === oracledb?.BIND_OUT) {
-      if (procedureParameters[paramKey].type === oracledb?.CURSOR) {
-        const resultSetTemp = result.outBinds[paramKey]
-        taskResult[paramKey] = await resultSetTemp.getRows()
-        await resultSetTemp.close()
-      } else {
-        taskResult[paramKey] = result.outBinds[paramKey]
-      }
-    }
-  }
-
   return {
-    data: taskResult
+    data: result
   }
 }
 

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

@@ -4,10 +4,12 @@ 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, context) {
+async function PickPendingScenario(step: InputStep, context: Context) {
   var { logger, load, domain } = context
   var { params } = step
   var { tag = '', waitFor = -1 } = params || {}

package/server/engine/task/publish.ts

@@ -1,7 +1,9 @@
 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, { logger, publish, data }) {
+async function Publish(step: InputStep, { logger, publish, data }: Context) {
   var {
     params: { tag, accessor }
   } = step

package/server/engine/task/random.ts

@@ -1,6 +1,9 @@
 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',
@@ -15,7 +18,7 @@ const formats = [
   .join(',')
   .split(',')
 
-async function Random(step, { logger, publish, data }) {
+async function Random(step: InputStep, { logger, publish, data }: Context) {
   var {
     params: { format = 'integer', count = 1 }
   } = step

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

@@ -1,7 +1,9 @@
 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, { domain }) {
+async function ResetPendingScenario(step: InputStep, { domain }: Context) {
   const pendingQueue = ScenarioEngine.getPendingQueue(domain)
   pendingQueue.reset()
 

package/server/engine/task/script.ts

@@ -1,7 +1,10 @@
 import { TaskRegistry } from '../task-registry'
 import { NodeVM } from 'vm2'
 
-async function Script(step, context) {
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function Script(step: InputStep, context: Context) {
   var {
     params: { script }
   } = step
@@ -16,6 +19,7 @@ async function Script(step, context) {
       domain,
       user,
       lng,
+      logger,
       data,
       variables
     }

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

@@ -1,7 +1,10 @@
 import { TaskRegistry } from '../task-registry'
 import { Domain, getRepository } from '@things-factory/shell'
 
-async function SetDomain(step, context) {
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function SetDomain(step: InputStep, context: Context) {
   var {
     params: { subdomain }
   } = step

package/server/engine/task/sleep.ts

@@ -1,7 +1,9 @@
 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, { logger }) {
+async function Sleep(step: InputStep, { logger }: Context) {
   var {
     params: { duration }
   } = step