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

package/server/engine/connector/echo-back-connector.ts

@@ -3,6 +3,7 @@ import PromiseSocket from 'promise-socket'
 
 import { Connector } from '../types'
 import { ConnectionManager } from '../connection-manager'
+import { InputConnection } from '../../service/connection/connection-type'
 
 export class EchoBack implements Connector {
   async ready(connectionConfigs) {
@@ -11,12 +12,12 @@ export class EchoBack implements Connector {
     ConnectionManager.logger.info('echo-back connections are ready')
   }
 
-  async connect(connection) {
+  async connect(connection: InputConnection) {
     let socket = new PromiseSocket(new net.Socket())
     let [host, port = 8124] = connection.endpoint.split(':')
 
     try {
-      await socket.connect(port, host)
+      await socket.connect(Number(port), host)
       ConnectionManager.addConnectionInstance(connection, socket)
 
       ConnectionManager.logger.info(
@@ -29,7 +30,7 @@ export class EchoBack implements Connector {
     }
   }
 
-  async disconnect(connection) {
+  async disconnect(connection: InputConnection) {
     let socket = ConnectionManager.removeConnectionInstance(connection)
 
     await socket.destroy()

package/server/engine/connector/echo-back-server.ts

@@ -3,15 +3,16 @@ import PromiseSocket from 'promise-socket'
 
 import { Connector } from '../types'
 import { ConnectionManager } from '../connection-manager'
+import { InputConnection } from '../../service/connection/connection-type'
 
 export class EchoBack implements Connector {
-  async ready(connectionConfigs) {
+  async ready(connectionConfigs: InputConnection[]) {
     await Promise.all(connectionConfigs.map(this.connect.bind(this)))
 
     ConnectionManager.logger.info('echo-back-servers are ready')
   }
 
-  async connect(config): Promise<void> {
+  async connect(config: InputConnection): Promise<void> {
     var [host = '0.0.0.0', port = 8124] = config.endpoint.split(':')
 
     return new Promise((resolve, reject) => {
@@ -35,7 +36,7 @@ export class EchoBack implements Connector {
 
         try {
           let promiseSocket = new PromiseSocket(socket)
-          await promiseSocket.connect(port, 'localhost')
+          await promiseSocket.connect(Number(port), 'localhost')
           promiseSocket['__server__'] = server
 
           ConnectionManager.addConnectionInstance(config, promiseSocket)
@@ -53,7 +54,7 @@ export class EchoBack implements Connector {
     })
   }
 
-  async disconnect(connection) {
+  async disconnect(connection: InputConnection) {
     let socket = ConnectionManager.removeConnectionInstance(connection)
     var server = socket['__server__']
 

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

@@ -7,6 +7,7 @@ import { getRepository } from '@things-factory/shell'
 
 import { ConnectionManager } from '../connection-manager'
 import { Connector } from '../types'
+import { InputConnection } from '../../service/connection/connection-type'
 
 const defaultOptions: any = {
   watchQuery: {
@@ -22,24 +23,20 @@ const defaultOptions: any = {
   }
 }
 
-const cache = new InMemoryCache({
-  addTypename: false
-})
-
 export class GraphqlConnector implements Connector {
-  async ready(connectionConfigs) {
+  async ready(connectionConfigs: InputConnection[]) {
     await Promise.all(connectionConfigs.map(this.connect.bind(this)))
 
     ConnectionManager.logger.info('graphql-connector connections are ready')
   }
 
-  async connect(connection) {
-    var {
+  async connect(connection: InputConnection) {
+    const {
       endpoint: uri,
       params: { authClient }
     } = connection
 
-    var ERROR_HANDLER: any = ({ graphQLErrors, networkError }) => {
+    const ERROR_HANDLER: any = ({ graphQLErrors, networkError }) => {
       if (graphQLErrors)
         graphQLErrors.map(({ message, locations, path }) => {
           ConnectionManager.logger.error(`[GraphQL error] Message: ${message}, Location: ${locations}, Path: ${path}`)
@@ -64,6 +61,10 @@ export class GraphqlConnector implements Connector {
       return forward(operation)
     })
 
+    const cache = new InMemoryCache({
+      addTypename: false
+    })
+
     ConnectionManager.addConnectionInstance(
       connection,
       new ApolloClient({
@@ -80,13 +81,11 @@ export class GraphqlConnector implements Connector {
       })
     )
 
-    ConnectionManager.logger.info(
-      `graphql-connector connection(${connection.name}:${connection.endpoint}) is connected`
-    )
+    ConnectionManager.logger.info(`graphql-connector connection(${connection.name}:${connection.endpoint}) is connected`)
   }
 
-  async disconnect(connection) {
-    var client = ConnectionManager.getConnectionInstance(connection)
+  async disconnect(connection: InputConnection) {
+    const client = ConnectionManager.getConnectionInstance(connection)
     client.stop()
     ConnectionManager.removeConnectionInstance(connection)
 

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

@@ -3,15 +3,16 @@ import { getRepository } from '@things-factory/shell'
 
 import { ConnectionManager } from '../connection-manager'
 import { Connector } from '../types'
+import { InputConnection } from '../../service/connection/connection-type'
 
 export class HttpConnector implements Connector {
-  async ready(connectionConfigs) {
+  async ready(connectionConfigs: InputConnection[]) {
     await Promise.all(connectionConfigs.map(this.connect.bind(this)))
 
     ConnectionManager.logger.info('http-connector connections are ready')
   }
 
-  async connect(connection) {
+  async connect(connection: InputConnection) {
     var { params } = connection
     params.rejectUnauthorized = (params.rejectUnauthorized || 'Y') === 'Y'
 
@@ -29,7 +30,7 @@ export class HttpConnector implements Connector {
     ConnectionManager.logger.info(`http-connector connection(${connection.name}:${connection.endpoint}) is connected`)
   }
 
-  async disconnect(connection) {
+  async disconnect(connection: InputConnection) {
     ConnectionManager.removeConnectionInstance(connection)
 
     ConnectionManager.logger.info(`http-connector connection(${connection.name}) is disconnected`)

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

@@ -1,16 +1,17 @@
 import { Connector } from '../types'
 import { ConnectionManager } from '../connection-manager'
+import { InputConnection } from '../../service/connection/connection-type'
 
 import mqtt from 'async-mqtt'
 
 export class MqttConnector implements Connector {
-  async ready(connectionConfigs) {
+  async ready(connectionConfigs: InputConnection[]) {
     await Promise.all(connectionConfigs.map(this.connect.bind(this)))
 
     ConnectionManager.logger.info('mqtt-connector connections are ready')
   }
 
-  async connect(connection) {
+  async connect(connection: InputConnection) {
     const {
       endpoint: uri,
       params: { user, password }
@@ -43,7 +44,7 @@ export class MqttConnector implements Connector {
     }
   }
 
-  async disconnect(connection) {
+  async disconnect(connection: InputConnection) {
     const { client } = ConnectionManager.removeConnectionInstance(connection)
 
     client && (await client.end())

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

@@ -2,6 +2,7 @@ import { logger } from '@things-factory/env'
 
 import { ConnectionManager } from '../connection-manager'
 import { Connector } from '../types'
+import { InputConnection } from '../../service/connection/connection-type'
 
 try {
   var Client = require('mssql')
@@ -10,13 +11,13 @@ try {
 }
 
 export class MssqlConnector implements Connector {
-  async ready(connectionConfigs) {
+  async ready(connectionConfigs: InputConnection[]) {
     await Promise.all(connectionConfigs.map(this.connect))
 
     ConnectionManager.logger.info('mssql-connector connections are ready')
   }
 
-  async connect(connection) {
+  async connect(connection: InputConnection) {
     const {
       endpoint,
       params: { user, password, database, encrypt = 'Y' }
@@ -50,7 +51,7 @@ export class MssqlConnector implements Connector {
     ConnectionManager.logger.info(`MSSql Database(${connection.name}:${database}) at ${endpoint} connected.`)
   }
 
-  async disconnect(connection) {
+  async disconnect(connection: InputConnection) {
     var client = ConnectionManager.getConnectionInstance(connection)
     try {
       await client.close()

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

@@ -1,20 +1,22 @@
+import Mysql from "mysql2/promise";
+
 import { Connector } from '../types'
 import { ConnectionManager } from '../connection-manager'
-import Mysql from "mysql2/promise";
+import { InputConnection } from '../../service/connection/connection-type'
 
 export class mysqlConnector implements Connector {
-  async ready(connectionConfigs) {
+  async ready(connectionConfigs: InputConnection[]) {
     await Promise.all(connectionConfigs.map(this.connect));
     ConnectionManager.logger.info("mysql-connector connections are ready");
   }
 
-  async connect(connection) {
+  async connect(connection: InputConnection) {
     const {
       endpoint,
       params: { user, password, database },
     } = connection;
 
-    const [host, port = 3306] = endpoint.split(":");
+    let [host, port = '3306'] = endpoint.split(":");
 
     if (!Mysql) {
       throw new Error("mysql module loading failed");
@@ -24,7 +26,7 @@ export class mysqlConnector implements Connector {
       user,
       password,
       host,
-      port,
+      port: Number(port),
       database,
     });
 
@@ -50,7 +52,7 @@ export class mysqlConnector implements Connector {
     );
   }
 
-  async disconnect(connection) {
+  async disconnect(connection: InputConnection) {
     var client = ConnectionManager.getConnectionInstance(connection);
     try {
       await client.close();

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

@@ -3,7 +3,6 @@ import 'cross-fetch/polyfill'
 import { ApolloClient, InMemoryCache, createHttpLink, split } from '@apollo/client/core'
 import { setContext } from '@apollo/client/link/context'
 
-// for subscription
 import WebSocket from 'ws'
 import { createClient } from 'graphql-ws'
 import { GraphQLWsLink } from '@apollo/client/link/subscriptions'
@@ -12,13 +11,15 @@ import gql from 'graphql-tag'
 
 import { ConnectionManager } from '../connection-manager'
 import { Connector } from '../types'
+import { InputConnection } from '../../service/connection/connection-type'
+
 import { Scenario } from '../../service/scenario/scenario'
 import { ScenarioInstance } from '../../service/scenario-instance/scenario-instance-type'
 
 import { getRepository, GraphqlLocalClient, Domain } from '@things-factory/shell'
 import { User, checkPermission } from '@things-factory/auth-base'
 
-const debug = require('debug')('things-factory:integration-base:operato-connector-subscription')
+const debug = require('debug')('things-factory:integration-base:operato-connector')
 
 const defaultOptions: any = {
   watchQuery: {
@@ -34,10 +35,6 @@ const defaultOptions: any = {
   }
 }
 
-const cache = new InMemoryCache({
-  addTypename: false
-})
-
 export const GRAPHQL_URI = '/graphql'
 export const SUBSCRIPTION_URI = GRAPHQL_URI
 
@@ -46,19 +43,18 @@ interface SubscriberData {
   scenario: any
   subscriptionObserver: any
 }
-;``
 
 export class OperatoConnector implements Connector {
   private context: any
 
-  async ready(connectionConfigs) {
+  async ready(connectionConfigs: InputConnection[]) {
     await Promise.all(connectionConfigs.map(this.connect.bind(this)))
 
-    ConnectionManager.logger.info('graphql-connector connections are ready')
+    ConnectionManager.logger.info('operato-connector connections are ready')
   }
 
-  async connect(connection) {
-    var {
+  async connect(connection: InputConnection) {
+    const {
       endpoint: uri,
       params: { authKey, domain, subscriptionHandlers = {} }
     } = connection
@@ -67,7 +63,7 @@ export class OperatoConnector implements Connector {
       throw new Error('some connection paramter missing.')
     }
 
-    var domainOwner = await getRepository(User).findOne({
+    const domainOwner = await getRepository(User).findOne({
       where: {
         id: connection.domain.owner
       }
@@ -123,20 +119,24 @@ export class OperatoConnector implements Connector {
       }).concat(httpLink)
     )
 
-    var client = new ApolloClient({
+    const cache = new InMemoryCache({
+      addTypename: false
+    })
+
+    const client = new ApolloClient({
       defaultOptions,
       cache,
       link: splitLink
     })
 
-    var subscriptions: SubscriberData[] = []
+    const subscriptions: SubscriberData[] = []
     Object.keys(subscriptionHandlers).forEach(async tag => {
       if (!tag || !subscriptionHandlers[tag]) return
 
-      let scenarioName = subscriptionHandlers[tag]
+      const scenarioName = subscriptionHandlers[tag]
 
       // fetch a scenario
-      var selectedScenario = await getRepository(Scenario).findOne({
+      const selectedScenario = await getRepository(Scenario).findOne({
         where: {
           name: scenarioName
         },
@@ -154,7 +154,7 @@ export class OperatoConnector implements Connector {
         `
       })
 
-      var subscriptionObserver = subscription.subscribe({
+      const subscriptionObserver = subscription.subscribe({
         next: async data => {
           debug('received pubsub msg.:', data?.data)
           await this.runScenario(subscriptions, data?.data?.data)
@@ -167,9 +167,7 @@ export class OperatoConnector implements Connector {
         }
       })
 
-      ConnectionManager.logger.info(
-        `(${connection.name}:${connection.endpoint}) subscription closed flag: ${subscriptionObserver.closed}`
-      )
+      ConnectionManager.logger.info(`(${connection.name}:${connection.endpoint}) subscription closed flag: ${subscriptionObserver.closed}`)
 
       subscriptions.push({
         tag,
@@ -182,19 +180,17 @@ export class OperatoConnector implements Connector {
     client['subscriptions'] = subscriptions
     ConnectionManager.addConnectionInstance(connection, client)
 
-    ConnectionManager.logger.info(
-      `graphql-connector connection(${connection.name}:${connection.endpoint}) is connected`
-    )
+    ConnectionManager.logger.info(`operato-connector connection(${connection.name}:${connection.endpoint}) is connected`)
   }
 
-  async disconnect(connection) {
-    var client = ConnectionManager.getConnectionInstance(connection)
-    let subscriptions: SubscriberData[] = client['subscriptions']
+  async disconnect(connection: InputConnection) {
+    const client = ConnectionManager.getConnectionInstance(connection)
+    const subscriptions: SubscriberData[] = client['subscriptions']
     subscriptions.forEach(subscription => subscription.subscriptionObserver.unsubscribe())
     client.stop()
     ConnectionManager.removeConnectionInstance(connection)
 
-    ConnectionManager.logger.info(`graphql-connector connection(${connection.name}) is disconnected`)
+    ConnectionManager.logger.info(`operato-connector connection(${connection.name}) is disconnected`)
   }
 
   async runScenario(subscriptions: SubscriberData[], variables: any): Promise<ScenarioInstance> {
@@ -205,23 +201,19 @@ export class OperatoConnector implements Connector {
       throw new Error(`tag is invalid - ${tag}`)
     }
 
-    var scenario = subscriptions.find(subscription => subscription.tag === tag)?.scenario
+    const scenario = subscriptions.find(subscription => subscription.tag === tag)?.scenario
     if (!scenario) {
       throw new Error(`scenario is not found - ${tag}`)
     }
 
     if (!(await checkPermission(scenario.privilege, user, domain, unsafeIP, prohibitedPrivileges))) {
       const { category, privilege } = scenario.privilege || {}
-      throw new Error(
-        `Unauthorized! ${
-          category && privilege ? category + ':' + privilege + ' privilege' : 'ownership granted'
-        } required`
-      )
+      throw new Error(`Unauthorized! ${category && privilege ? category + ':' + privilege + ' privilege' : 'ownership granted'} required`)
     }
 
     /* create a scenario instance */
-    let instanceName = scenario.name + '-' + String(Date.now())
-    var instance = new ScenarioInstance(instanceName, scenario, {
+    const instanceName = scenario.name + '-' + String(Date.now())
+    const instance = new ScenarioInstance(instanceName, scenario, {
       user,
       domain,
       variables,

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

@@ -2,63 +2,155 @@ import { logger } from '@things-factory/env'
 
 import { ConnectionManager } from '../connection-manager'
 import { Connector } from '../types'
+import { InputConnection } from '../../service/connection/connection-type'
 
 try {
-  var Client = require('oracledb')
+  var oracledb = require('oracledb')
 } catch (err) {
   logger.error('oracledb module loading failed')
 }
 
 export class OracleConnector implements Connector {
-  async ready(connectionConfigs) {
+  async ready(connectionConfigs: InputConnection[]) {
     await Promise.all(connectionConfigs.map(this.connect))
 
     ConnectionManager.logger.info('oracle-connector connections are ready')
   }
 
-  async connect(connection) {
+  async recreatePool(connection: InputConnection) {
     const {
+      name,
       endpoint,
-      params: { user, password, database }
+      params: { user, password, database, poolMin, poolMax, poolIncrement },
+      domain
     } = connection
 
-    if (!Client) {
+    if (!oracledb) {
       throw new Error('oracledb module loading failed')
     }
 
-    //when oracle not using default port must add connection string with port like localhsot:port
-    const client = await Client.getConnection({
+    const poolAlias = `${domain.name}-${name}`
+    await oracledb.getPool(poolAlias).close(10)
+    await oracledb.createPool({
       user,
       password,
-      connectString: `${endpoint.trim()}/${database}`
+      // when oracle not using default port must add connection string with port like localhost:port
+      connectString: `${endpoint.trim()}/${database}`,
+      poolMin,
+      poolMax,
+      poolIncrement,
+      poolAlias
     })
 
+    ConnectionManager.logger.info(`Oracle Database(${connection.name}:${database}) at ${endpoint} recreated.`)
+  }
+
+  async connect(connection: InputConnection) {
+    const {
+      name,
+      endpoint,
+      params: { user, password, database, poolMin, poolMax, poolIncrement },
+      domain
+    } = connection
+
+    if (!oracledb) {
+      throw new Error('oracledb module loading failed')
+    }
+
+    const poolAlias = `${domain.name}-${name}`
+
+    var enableStatistics = true
+    const pool = await oracledb.createPool({
+      user,
+      password,
+      // when oracle not using default port must add connection string with port like localhost:port
+      connectString: `${endpoint.trim()}/${database}`,
+      poolMin,
+      poolMax,
+      poolIncrement,
+      poolAlias,
+      enableStatistics
+    })
+    
     ConnectionManager.addConnectionInstance(connection, {
       query: async (query, params) => {
-        return (
-          await client.execute(query, params, {
-            outFormat: Client.OBJECT
-          })
-        ).rows
+        let dbConnection: any = {}
+        let taskResult: any = {}
+        try {
+          dbConnection = await oracledb.getConnection(poolAlias)
+
+          taskResult = (
+            await dbConnection.execute(query, params, {
+              outFormat: oracledb.OBJECT
+            })
+          ).rows
+        } catch (e) {
+          if (e.name === 'Error' && e.message.includes('NJS-040')) {
+            await this.recreatePool(connection)
+          }
+          throw e
+        }
+        finally {
+          await dbConnection.close()
+        }
+        return taskResult
+        
       },
       execute: async (procedure, params) => {
-        // TODO: need to check if this is available when procedure string is a common query.
-        procedure = `BEGIN
-          ${procedure}
-        END;`
-
-        return await client.execute(procedure, params, {
-          outFormat: Client.OBJECT
-        })
+        let dbConnection: any = {}
+        let taskResult: any = {}
+        try {
+          // TODO: need to check if this is available when procedure string is a common query.
+          procedure = `BEGIN
+            ${procedure}
+          END;`
+          dbConnection = await oracledb.getConnection(poolAlias)
+          
+          // console.log('\n************* stat after get ****************')
+          // await oracledb.getPool(poolAlias).logStatistics()
+
+          const result = await dbConnection.execute(procedure, params, {
+            outFormat: oracledb.OBJECT
+          })
+
+          let paramKeys = Object.keys(params)
+
+          for (const paramKey of paramKeys) {
+            if (params[paramKey].dir === oracledb?.BIND_OUT) {
+              if (params[paramKey].type === oracledb?.CURSOR) {
+                const resultSetTemp = result.outBinds[paramKey]
+                taskResult[paramKey] = await resultSetTemp.getRows()
+                await resultSetTemp.close()
+              } else {
+                taskResult[paramKey] = result.outBinds[paramKey]
+              }
+            }
+          }
+        } catch (e) {
+          if (e.name === 'Error' && e.message.includes('NJS-040')) {
+            await this.recreatePool(connection)
+          }
+          throw e
+        }
+        finally {
+          await dbConnection.close()
+
+          // console.log('\n************* stat after close ****************')
+          // await oracledb.getPool(poolAlias).logStatistics()
+        }
+        return taskResult
       },
-      close: client.close.bind(client)
+      close: async () => {
+        await oracledb.getPool(poolAlias).close(10)
+      }
     })
 
     ConnectionManager.logger.info(`Oracle Database(${connection.name}:${database}) at ${endpoint} connected.`)
   }
 
-  async disconnect(connection) {
+  async disconnect(connection: InputConnection) {
     var client = ConnectionManager.getConnectionInstance(connection)
+
     try {
       await client.close()
       ConnectionManager.logger.info(`Oracle Database(${connection.name}) closed.`)
@@ -86,6 +178,27 @@ export class OracleConnector implements Connector {
         name: 'database',
         placeholder: 'SID',
         label: 'database'
+      },
+      {
+        type: 'number',
+        name: 'poolMin',
+        placeholder: 'minimum connection-pool size',
+        label: 'pool-min',
+        value: 0
+      },
+      {
+        type: 'number',
+        name: 'poolMax',
+        placeholder: 'maximum connection-pool size',
+        label: 'pool-max',
+        value: 4
+      },
+      {
+        type: 'number',
+        name: 'poolIncrement',
+        placeholder: 'connection incremental size',
+        label: 'pool-increment',
+        value: 1
       }
     ]
   }

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

@@ -2,6 +2,7 @@ import { logger } from '@things-factory/env'
 
 import { ConnectionManager } from '../connection-manager'
 import { Connector } from '../types'
+import { InputConnection } from '../../service/connection/connection-type'
 
 try {
   var { Client } = require('pg')
@@ -10,13 +11,13 @@ try {
 }
 
 export class PostgresqlConnector implements Connector {
-  async ready(connectionConfigs) {
+  async ready(connectionConfigs: InputConnection[]) {
     await Promise.all(connectionConfigs.map(this.connect.bind(this)))
 
     ConnectionManager.logger.info('postgresql-connector connections are ready')
   }
 
-  async connect(connection) {
+  async connect(connection: InputConnection) {
     const {
       endpoint,
       params: { user, password, database }
@@ -59,7 +60,7 @@ export class PostgresqlConnector implements Connector {
     }
   }
 
-  async disconnect(connection) {
+  async disconnect(connection: InputConnection) {
     var client = ConnectionManager.getConnectionInstance(connection)
     try {
       await client.close()