@things-factory/integration-base 7.0.7 → 7.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-base",
-  "version": "7.0.7",
+  "version": "7.0.13",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -27,13 +27,13 @@
   "dependencies": {
     "@apollo/client": "^3.6.9",
     "@operato/moment-timezone-es": "^7.0.0",
-    "@things-factory/api": "^7.0.6",
-    "@things-factory/auth-base": "^7.0.6",
-    "@things-factory/cache-service": "^7.0.6",
+    "@things-factory/api": "^7.0.10",
+    "@things-factory/auth-base": "^7.0.10",
+    "@things-factory/cache-service": "^7.0.10",
     "@things-factory/env": "^7.0.0",
-    "@things-factory/oauth2-client": "^7.0.7",
-    "@things-factory/scheduler-client": "^7.0.6",
-    "@things-factory/shell": "^7.0.6",
+    "@things-factory/oauth2-client": "^7.0.10",
+    "@things-factory/scheduler-client": "^7.0.10",
+    "@things-factory/shell": "^7.0.10",
     "@things-factory/utils": "^7.0.0",
     "async-mqtt": "^2.5.0",
     "chance": "^1.1.11",
@@ -44,5 +44,5 @@
     "readline": "^1.3.0",
     "ses": "^1.5.0"
   },
-  "gitHead": "6c9d22d79abfb199bd741f6504b29add846b46a9"
+  "gitHead": "2bcab979adf08e9561cb6ba2506afa4770b90bbc"
 }

package/server/controllers/index.ts

@@ -1 +1,2 @@
 export * from './scenario-controller'
+export * from './publish-data'

package/server/controllers/publish-data.ts

@@ -0,0 +1,29 @@
+import { Domain, getRepository, pubsub } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+import { StateRegister } from '../service/state-register/state-register'
+
+export async function publishData(tag: string, data: any, { domain, user }: { domain: Domain; user: User }) {
+  const repository = getRepository(StateRegister)
+
+  const stateRegister = await repository.findOne({
+    where: { domain: { id: domain?.id }, name: tag }
+  })
+
+  if (stateRegister) {
+    await repository.save({
+      ...stateRegister,
+      state: data,
+      writer: user,
+      wroteAt: new Date()
+    })
+  }
+
+  pubsub.publish('data', {
+    data: {
+      domain,
+      tag,
+      data
+    }
+  })
+}

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,7 +37,9 @@ import './data-mapper'
 import './headless-post'
 import './headless-scrap'
 import './set-domain'
+import './mssql-procedure'
 import './oracle-procedure'
 import './jsonata'
 import './state-read'
 import './state-write'
+import './state-group-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'
+    }
   }
 ]
 

package/server/engine/task/state-group-read.ts

@@ -0,0 +1,69 @@
+import gql from 'graphql-tag'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function StateGroupRead(step: InputStep, { logger, publish, data, domain, user, client }: Context) {
+  var {
+    params: { group }
+  } = step
+
+  if (!group) {
+    throw Error(`group should be defined: group - '${group}'`)
+  }
+
+  var { data: queryResult, errors } = await client.query({
+    query: gql`
+      query ($filters: [Filter!]) {
+        stateRegisters(filters: $filters) {
+          items {
+            name
+            state
+          }
+        }
+      }
+    `,
+    variables: {
+      filters: [
+        {
+          name: 'group',
+          operator: 'eq',
+          value: group
+        }
+      ]
+    },
+    context: {
+      state: {
+        domain,
+        user
+      }
+    }
+  })
+
+  if (errors) {
+    errors.forEach(error => {
+      logger.error('GraphQL Error: %s', error)
+    })
+  }
+
+  return {
+    data: queryResult?.stateRegisters?.items.reduce((status, item) => {
+      const { name, state } = item
+      status[name] = state
+      return status
+    }, {})
+  }
+}
+
+StateGroupRead.parameterSpec = [
+  {
+    type: 'string',
+    name: 'group',
+    label: 'group'
+  }
+]
+
+StateGroupRead.connectorFree = true
+StateGroupRead.help = 'integration/task/state-group-read'
+
+TaskRegistry.registerTaskHandler('state-group-read', StateGroupRead)

package/server/service/scenario-instance/scenario-instance-type.ts

@@ -11,6 +11,7 @@ import { cacheService } from '@things-factory/cache-service'
 import { User } from '@things-factory/auth-base'
 import { sleep } from '@things-factory/utils'
 
+import { publishData } from '../../controllers/publish-data'
 import { ConnectionManager } from '../../engine/connection-manager'
 import { TaskRegistry } from '../../engine'
 import { Context } from '../../engine/types'
@@ -390,13 +391,7 @@ export class ScenarioInstance {
   }
 
   publishData(tag, data) {
-    pubsub.publish('data', {
-      data: {
-        domain: this.context.domain,
-        tag,
-        data
-      }
-    })
+    publishData(tag, data, this.context)
   }
 
   publishState() {
@@ -498,9 +493,11 @@ export class ScenarioInstance {
       await this.disposer.call(this)
     }
 
-    // {{ CHECKPOINT 본 인스턴스를 위해서 생성된 logger를 닫는다.
+    // {{ CHECKPOINT 본 인스턴스를 위해서 생성된 logger를 닫는다. 사용을 완료하고 닫기위해서 지연해서 수행한다.
     if (this.context?.logger) {
-      this.context.logger.close()
+      setTimeout(() => {
+        this.context.logger.close()
+      }, 300)
     }
     // }}
   }

package/server/service/state-register/data-resolver.ts

@@ -0,0 +1,56 @@
+import { filter, pipe } from 'graphql-yoga'
+import { Arg, Resolver, Root, Subscription } from 'type-graphql'
+
+import { pubsub, Data, getRepository } from '@things-factory/shell'
+import { StateRegister } from './state-register'
+
+/* 이 Resolver는 @things-factory/shell에서 등록한 DataResolver를 Overide 한 것이다. */
+@Resolver()
+export class DataResolver {
+  @Subscription({
+    subscribe: ({ args, context, info }) => {
+      const { domain, user } = context.state
+      const { tag } = args
+      const subdomain = domain?.subdomain
+
+      if (!domain || !tag) {
+        throw new Error('domain and tag required')
+      }
+
+      //@ts-ignore
+      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
+        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
+      }
+
+      process.nextTick(async () => {
+        /* state-register에 등록된 태그라면, 현재 상태값을 publish 한다. */
+        const { domain } = context.state
+
+        const state = await getRepository(StateRegister).findOne({
+          where: { domain: { id: domain.id }, name: tag }
+        })
+
+        if (state) {
+          pubsub.publish('data', {
+            data: {
+              domain,
+              tag,
+              data: state.state
+            }
+          })
+        }
+      })
+
+      return pipe(
+        pubsub.subscribe('data'),
+        filter((payload: { data: Data }) => {
+          const { domain: pdomain, tag: ptag, data } = payload.data
+          return tag === ptag && subdomain === pdomain?.subdomain
+        })
+      )
+    }
+  })
+  data(@Root() payload: { data: Data }, @Arg('tag') tag: string): Data {
+    return payload.data
+  }
+}

package/server/service/state-register/index.ts

@@ -1,7 +1,8 @@
 import { StateRegister } from './state-register'
 import { StateRegisterQuery } from './state-register-query'
 import { StateRegisterMutation } from './state-register-mutation'
+import { DataResolver } from './data-resolver'
 
 export const entities = [StateRegister]
-export const resolvers = [StateRegisterQuery, StateRegisterMutation]
+export const resolvers = [StateRegisterQuery, StateRegisterMutation, DataResolver]
 export const subscribers = []

package/server/service/state-register/state-register-query.ts

@@ -38,7 +38,7 @@ export class StateRegisterQuery {
       domain,
       params,
       repository: await getRepository(StateRegister),
-      searchables: ['name', 'description']
+      searchables: ['name', 'description', 'group']
     })
 
     const [items, total] = await queryBuilder.getManyAndCount()

package/server/service/state-register/state-register-type.ts

@@ -1,64 +1,80 @@
-import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
-import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
 
-import { ObjectRef, ScalarObject } from '@things-factory/shell'
+import { ScalarObject } from '@things-factory/shell'
 
 import { StateRegister } from './state-register'
 
 @InputType()
 export class NewStateRegister {
-  @Field()
+  @Field({ description: 'Name of the state register' })
   name: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Description of the state register' })
   description?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Group name for the state register' })
+  group?: string
+
+  @Field({ nullable: true, description: 'Type of the state' })
   type?: string
 
-  @Field(type => ScalarObject, { nullable: true })
+  @Field({ nullable: true, description: 'Number of decimal places if the state is a number type' })
+  place?: string
+
+  @Field({ nullable: true, description: 'Unit of the state value' })
+  unit?: string
+
+  @Field(type => ScalarObject, { nullable: true, description: 'Current state value' })
   state?: any
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Int, { nullable: true, description: 'Time to live for the state value in seconds' })
   ttl?: number
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Reference to an external entity or data, used as a flexible foreign key' })
   refBy?: string
 }
 
 @InputType()
 export class StateRegisterPatch {
-  @Field(type => ID, { nullable: true })
+  @Field(type => ID, { nullable: true, description: 'ID of the state register' })
   id?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Name of the state register' })
   name?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Description of the state register' })
   description?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Group name for the state register' })
+  group?: string
+
+  @Field({ nullable: true, description: 'Type of the state' })
   type?: string
 
-  @Field(type => ScalarObject, { nullable: true })
+  @Field({ nullable: true, description: 'Number of decimal places if the state is a number type' })
+  place?: string
+
+  @Field({ nullable: true, description: 'Unit of the state value' })
+  unit?: string
+
+  @Field(type => ScalarObject, { nullable: true, description: 'Current state value' })
   state?: any
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Int, { nullable: true, description: 'Time to live for the state value in seconds' })
   ttl?: number
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Reference to an external entity or data, used as a flexible foreign key' })
   refBy?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Flag indicating create/update operations' })
   cuFlag?: string
 }
 
 @ObjectType()
 export class StateRegisterList {
-  @Field(type => [StateRegister])
+  @Field(type => [StateRegister], { description: 'List of state registers' })
   items: StateRegister[]
 
-  @Field(type => Int)
+  @Field(type => Int, { description: 'Total number of state registers' })
   total: number
 }