@things-factory/integration-base 7.0.1-rc.8 → 7.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-base",
-  "version": "7.0.1-rc.8",
+  "version": "7.0.1",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -26,15 +26,15 @@
   },
   "dependencies": {
     "@apollo/client": "^3.6.9",
-    "@operato/moment-timezone-es": "^7.0.0-rc",
-    "@things-factory/api": "^7.0.1-rc.8",
-    "@things-factory/auth-base": "^7.0.1-rc.8",
-    "@things-factory/cache-service": "^7.0.1-rc.8",
-    "@things-factory/env": "^7.0.1-rc.8",
-    "@things-factory/oauth2-client": "^7.0.1-rc.8",
-    "@things-factory/scheduler-client": "^7.0.1-rc.8",
-    "@things-factory/shell": "^7.0.1-rc.8",
-    "@things-factory/utils": "^7.0.1-rc.7",
+    "@operato/moment-timezone-es": "^7.0.0",
+    "@things-factory/api": "^7.0.0",
+    "@things-factory/auth-base": "^7.0.0",
+    "@things-factory/cache-service": "^7.0.0",
+    "@things-factory/env": "^7.0.0",
+    "@things-factory/oauth2-client": "^7.0.0",
+    "@things-factory/scheduler-client": "^7.0.0",
+    "@things-factory/shell": "^7.0.0",
+    "@things-factory/utils": "^7.0.0",
     "async-mqtt": "^2.5.0",
     "chance": "^1.1.11",
     "cross-fetch": "^3.0.4",
@@ -44,5 +44,5 @@
     "readline": "^1.3.0",
     "ses": "^1.5.0"
   },
-  "gitHead": "cf1d0f8f261c73eadecb517fc6c82e92e50d6caf"
+  "gitHead": "02f50498ba92589813db2d13907894d2b9220d8c"
 }

package/server/engine/connection-manager.ts

@@ -138,14 +138,22 @@ export class ConnectionManager {
   }
 
   static getConnectionInstanceEntityByName(domain: Domain, name: string): any {
-    const entities = ConnectionManager.entities[domain.id]
-    return entities?.[name]
+    const connection = ConnectionManager.entities[domain.id]?.[name]
+    if(connection) {
+      return connection
+    }
+
+    if(domain.parentId) {
+      return ConnectionManager.entities[domain.id]?.[name]
+    }    
   }
 
   static getConnectionInstances(domain: Domain): { [connectionName: string]: any } {
     const connections = ConnectionManager.connections[domain.id]
+    const parentConnections = domain.parentId && ConnectionManager.connections[domain.parentId]
 
     return {
+      ...parentConnections,
       ...connections
     }
   }

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

@@ -5,7 +5,7 @@ import { Connector } from '../types'
 import { InputConnection } from '../../service/connection/connection-type'
 
 try {
-  var { Client } = require('pg')
+  var { Client, Pool } = require('pg')
 } catch (err) {
   logger.error('postgresql module loading failed', err)
 }
@@ -20,35 +20,66 @@ export class PostgresqlConnector implements Connector {
   async connect(connection: InputConnection) {
     const {
       endpoint,
-      params: { user, password, database }
+      params: { user, password, database, maxPoolConnection, idleTimeoutMillis, connectionTimeoutMillis }
     } = connection
     const [host, port = 5432] = endpoint.split(':')
 
-    if (!Client) {
+    if (!Pool) {
       throw new Error('postgresql module loading failed')
     }
 
-    const client = new Client({
+    // create a new pool
+    const pool = new Pool({
       user,
       host,
       database,
       password,
-      port: Number(port)
+      port: Number(port),
+      max: maxPoolConnection || 10,
+      idleTimeoutMillis: idleTimeoutMillis || 30000,
+      connectionTimeoutMillis: connectionTimeoutMillis || 2000
     })
 
-    client.on('error', async err => {
-      // create a new database clinet and reconnect to server at an unexpected error
-      this.connect(connection)
+    pool.on('error', (err, client) => {
+      logger.error('unexpected error on postgres pool.', err)
     })
 
     try {
-      await client.connect()
+      // try to connect to database to check the connection at initial time
+      const entryConnection = await pool.connect().catch(async e => {
+        ConnectionManager.logger.error(e)
+        throw e
+      })
+      entryConnection.release()
+
       ConnectionManager.addConnectionInstance(connection, {
         query: async (query, params) => {
-          return (await client.query(query, params)).rows
+          try {
+            // get a connection from the pool
+            var client = await pool.connect().catch(async e => {
+              ConnectionManager.logger.error(e)
+              throw e
+            })
+
+            client?.on('error', async err => {
+              logger.error('unexpected error on postgres client.', err)
+              ConnectionManager.logger.error(err)
+            })
+
+            // try to query
+            var result = (await client.query(query, params)).rows
+          } catch (e) {
+            ConnectionManager.logger.error(e)
+            throw e
+          } finally {
+            // release the connection back to the pool
+            client?.release()
+          }
+          return result
         },
         close: async () => {
-          await client.end()
+          // close the pool
+          await pool?.end()
         }
       })
 
@@ -62,9 +93,9 @@ export class PostgresqlConnector implements Connector {
   }
 
   async disconnect(connection: InputConnection) {
-    var client = ConnectionManager.getConnectionInstance(connection)
+    var connectionInstance = ConnectionManager.getConnectionInstance(connection)
     try {
-      await client.close()
+      await connectionInstance.close()
       ConnectionManager.logger.info(`PostgresSQL Database(${connection.name}) closed.`)
     } catch (e) {
       ConnectionManager.logger.error(e)
@@ -88,6 +119,23 @@ export class PostgresqlConnector implements Connector {
         type: 'string',
         name: 'database',
         label: 'database'
+      },
+      {
+        type: 'number',
+        name: 'maxPoolConnection',
+        label: 'maxPoolConnection'
+      },
+      {
+        type: 'number',
+        name: 'idleTimeoutMillis',
+        label: 'idleTimeoutMillis',
+        placeHolder: 'milli-seconds'
+      },
+      {
+        type: 'number',
+        name: 'connectionTimeoutMillis',
+        label: 'connectionTimeoutMillis',
+        placeHolder: 'milli-seconds'
       }
     ]
   }

package/server/service/scenario/scenario.ts

@@ -98,15 +98,30 @@ export class Scenario {
   @RelationId((scenario: Scenario) => scenario.updater)
   updaterId?: string
 
-  async start(instanceName, variables?: any) {
+  async start(options?: {
+    instanceName?: string;
+    domain?: Domain;
+    user?: User;
+    variables?: any;
+  }) {
     try {
-      await ScenarioEngine.load(instanceName || this.name, this, { domain: this.domain, user: this.updater, variables })
+      await ScenarioEngine.load(options?.instanceName || this.name, 
+        this, 
+        { 
+          domain: options?.domain || this.domain, 
+          user: options?.user || this.updater, 
+          variables: options?.variables 
+        })
     } catch (ex) {}
   }
 
-  async stop(instanceName?) {
+  async stop(options?: {
+    instanceName?: string;
+    domain?: Domain,
+    user?: User
+  }) {
     try {
-      await ScenarioEngine.unload(this.domain, instanceName || this.name)
+      await ScenarioEngine.unload(options?.domain || this.domain, options?.instanceName || this.name)
     } finally {
     }
   }

package/translations/en.json

@@ -7,5 +7,8 @@
   "error.scenario instance not found": "scenario instance '{instance}' not found.",
   "label.auth-key": "authentication key",
   "label.subscription-handlers": "subscription handlers",
-  "label.trust-server-certificate": "trust server certificate"
+  "label.trust-server-certificate": "trust server certificate",
+  "label.maxPoolConnection": "Max Pool Connection",
+  "label.idleTimeoutMillis": "Idle Timeout (milliseconds)",
+  "label.connectionTimeoutMillis": "Connection Timeout (milliseconds)"
 }

package/translations/ja.json

@@ -7,5 +7,8 @@
   "error.scenario instance not found": "シナリオ インスタンス'{instance}'が見つかりません. 既に終了している可能性があります.",
   "label.auth-key": "認証キー",
   "label.subscription-handlers": "サブスクリプションハンドラー",
-  "label.trust-server-certificate": "サーバー証明書を信頼する"
+  "label.trust-server-certificate": "サーバー証明書を信頼する",
+  "label.maxPoolConnection": "最大プール接続数",
+  "label.idleTimeoutMillis": "アイドルタイムアウト（ミリ秒）",
+  "label.connectionTimeoutMillis": "接続タイムアウト（ミリ秒）"
 }

package/translations/ko.json

@@ -7,5 +7,8 @@
   "error.scenario instance not found": "시나리오 인스턴스 '{instance}'를 찾을 수 없습니다. 이미 종료되었을 수 있습니다.",
   "label.auth-key": "인증 키",
   "label.subscription-handlers": "구독 핸들러",
-  "label.trust-server-certificate": "서버 인증서 신뢰"
+  "label.trust-server-certificate": "서버 인증서 신뢰",
+  "label.maxPoolConnection": "최대 풀 연결 수",
+  "label.idleTimeoutMillis": "유휴 시간 제한 (밀리초)",
+  "label.connectionTimeoutMillis": "연결 시간 제한 (밀리초)"
 }

package/translations/ms.json

@@ -7,5 +7,8 @@
   "error.scenario instance not found": "Tidak dapat mencari instans senario '{instance}'. Mungkin telah berakhir.",
   "label.auth-key": "Kunci pengesahan",
   "label.subscription-handlers": "pengendali langganan",
-  "label.trust-server-certificate": "percaya sijil pelayan"
+  "label.trust-server-certificate": "percaya sijil pelayan",
+  "label.maxPoolConnection": "Sambungan Pool Maksimum",
+  "label.idleTimeoutMillis": "Had Masa Tanpa Aktiviti (milisaat)",
+  "label.connectionTimeoutMillis": "Had Masa Sambungan (milisaat)"
 }

package/translations/zh.json

@@ -7,5 +7,8 @@
   "error.scenario instance not found": "无法找到场景实例 '{instance}'。它可能已经结束。",
   "label.auth-key": "认证密钥",
   "label.subscription-handlers": "订阅处理程序",
-  "label.trust-server-certificate": "信任服务器证书"
+  "label.trust-server-certificate": "信任服务器证书",
+  "label.maxPoolConnection": "最大连接池连接数",
+  "label.idleTimeoutMillis": "空闲超时时间（毫秒）",
+  "label.connectionTimeoutMillis": "连接超时时间（毫秒）"
 }