@things-factory/integration-base 6.2.115 → 6.2.118

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-base",
-  "version": "6.2.115",
+  "version": "6.2.118",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -47,5 +47,5 @@
   "devDependencies": {
     "@types/cron": "^2.0.1"
   },
-  "gitHead": "1daed375a4ad4c542f49ab14495b6613a65b1a04"
+  "gitHead": "3b0a5f498c8fd799c238cec391c8368ec733e901"
 }

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

@@ -5,7 +5,7 @@ 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')
 }
@@ -17,7 +17,7 @@ export class OracleConnector implements Connector {
     ConnectionManager.logger.info('oracle-connector connections are ready')
   }
 
-  async connect(connection: InputConnection) {
+  async recreatePool(connection: InputConnection) {
     const {
       name,
       endpoint,
@@ -25,12 +25,13 @@ export class OracleConnector implements Connector {
       domain
     } = connection
 
-    if (!Client) {
+    if (!oracledb) {
       throw new Error('oracledb module loading failed')
     }
 
     const poolAlias = `${domain.name}-${name}`
-    const client = await Client.createPool({
+    await oracledb.getPool(poolAlias).close(10)
+    await oracledb.createPool({
       user,
       password,
       // when oracle not using default port must add connection string with port like localhost:port
@@ -41,33 +42,106 @@ export class OracleConnector implements Connector {
       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) => {
-        const connection = await Client.getConnection(poolAlias)
-        const result = (
-          await connection.execute(query, params, {
-            outFormat: Client.OBJECT
-          })
-        ).rows
-        await connection.close()
-        return result
+        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;`
-        const connection = await Client.getConnection(poolAlias)
-        const result = await connection.execute(procedure, params, {
-          outFormat: Client.OBJECT
-        })
-        await connection.close()
-        return result
+        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: async () => {
-        await Client.getPool(poolAlias).close(10)
+        await oracledb.getPool(poolAlias).close(10)
       }
     })
 

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

@@ -97,23 +97,8 @@ async function OracleProcedure(step: InputStep, context: 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
   }
 }