@things-factory/integration-base 7.0.10 → 7.0.13

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

@@ -5,7 +5,7 @@ import { Connector } from '../types'
 import { InputConnection } from '../../service/connection/connection-type'
 
 try {
-  var Client = require('mssql')
+  var mssql = require('mssql')
 } catch (err) {
   logger.error('mssql module loading failed', err)
 }
@@ -20,24 +20,23 @@ export class MssqlConnector implements Connector {
   async connect(connection: InputConnection) {
     const {
       endpoint,
-      params: { user, password, database, encrypt = 'Y', trustServerCertificate }
+      params: { user, password, database, poolMin = 0, poolMax = 4, encrypt = 'Y', trustServerCertificate }
     } = connection
 
     const [host, port = 1433] = endpoint.split(':')
 
-    if (!Client) {
+    if (!mssql) {
       throw new Error('mssql module loading failed')
     }
 
-    const client = await Client.connect({
-      // client is pool
+    const pool = await mssql.connect({
       user,
       password,
       server: host,
       database,
       pool: {
-        max: 10,
-        min: 0,
+        max: Math.max(2, poolMax),
+        min: Math.max(0, poolMin),
         idleTimeoutMillis: 30000
       },
       options: {
@@ -48,12 +47,30 @@ export class MssqlConnector implements Connector {
 
     ConnectionManager.addConnectionInstance(connection, {
       query: async (query, params) => {
-        var result = await client.query(query)
+        var result = await pool.request().query(query)
         return result.recordset
-
-        // return (await client.query(query))
       },
-      close: client.close.bind(client)
+      execute: async (procedure, params) => {
+        let request = pool.request()
+
+        Object.keys(params).forEach(key => {
+          let { dir, type, val } = params[key]
+
+          if (dir === 'in' || dir === 'inout') {
+            request.input(key, type, val)
+          } else if (dir === 'out') {
+            request.output(key, type)
+          } else {
+            console.error(`Invalid parameter direction(${dir}) for mssql stored procedure`)
+          }
+        })
+
+        var result = await request.execute(procedure)
+        return result
+      },
+      close: () => {
+        pool.close()
+      }
     })
 
     ConnectionManager.logger.info(`MSSql Database(${connection.name}:${database}) at ${endpoint} connected.`)
@@ -97,6 +114,20 @@ export class MssqlConnector implements Connector {
           options: ['Y', 'N']
         }
       },
+      {
+        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: 'select',
         name: 'trustServerCertificate',
@@ -109,7 +140,7 @@ export class MssqlConnector implements Connector {
   }
 
   get taskPrefixes() {
-    return ['database']
+    return ['database', 'mssql']
   }
 
   get help() {

package/server/engine/task/index.ts

@@ -37,6 +37,7 @@ import './data-mapper'
 import './headless-post'
 import './headless-scrap'
 import './set-domain'
+import './mssql-procedure'
 import './oracle-procedure'
 import './jsonata'
 import './state-read'

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

@@ -0,0 +1,128 @@
+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

@@ -112,7 +112,10 @@ OracleProcedure.parameterSpec = [
   {
     type: 'procedure-parameters',
     name: 'parameters',
-    label: ''
+    label: '',
+    property: {
+      dbtype: 'oracle'
+    }
   }
 ]