@things-factory/integration-base 8.0.39 → 9.0.0-9.0.0-beta.59.0

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

@@ -1,152 +0,0 @@
-import { logger } from '@things-factory/env'
-
-import { ConnectionManager } from '../connection-manager'
-import { Connector } from '../types'
-import { InputConnection } from '../../service/connection/connection-type'
-
-try {
-  var mssql = require('mssql')
-} catch (err) {
-  logger.error('mssql module loading failed', err)
-}
-
-export class MssqlConnector implements Connector {
-  async ready(connectionConfigs: InputConnection[]) {
-    await Promise.all(connectionConfigs.map(this.connect))
-
-    ConnectionManager.logger.info('mssql-connector connections are ready')
-  }
-
-  async connect(connection: InputConnection) {
-    const {
-      endpoint,
-      params: { user, password, database, poolMin = 0, poolMax = 4, encrypt = 'Y', trustServerCertificate }
-    } = connection
-
-    const [host, port = 1433] = endpoint.split(':')
-
-    if (!mssql) {
-      throw new Error('mssql module loading failed')
-    }
-
-    const pool = await mssql.connect({
-      user,
-      password,
-      server: host,
-      port: Number(port),
-      database,
-      pool: {
-        max: Math.max(2, poolMax),
-        min: Math.max(0, poolMin),
-        idleTimeoutMillis: 30000
-      },
-      options: {
-        encrypt: encrypt === 'Y',
-        trustServerCertificate: trustServerCertificate === 'Y'
-      }
-    })
-
-    ConnectionManager.addConnectionInstance(connection, {
-      query: async (query, params) => {
-        var result = await pool.request().query(query)
-        return result.recordset
-      },
-      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.`)
-  }
-
-  async disconnect(connection: InputConnection) {
-    var client = ConnectionManager.getConnectionInstance(connection)
-    try {
-      await client.close()
-      ConnectionManager.logger.info(`MSSql Database(${connection.name}) closed.`)
-    } catch (e) {
-      ConnectionManager.logger.error(e)
-    }
-
-    ConnectionManager.removeConnectionInstance(connection)
-  }
-
-  get parameterSpec() {
-    return [
-      {
-        type: 'string',
-        name: 'user',
-        label: 'user'
-      },
-      {
-        type: 'password',
-        name: 'password',
-        label: 'password'
-      },
-      {
-        type: 'string',
-        name: 'database',
-        placeholder: 'SID',
-        label: 'database'
-      },
-      {
-        type: 'select',
-        name: 'encrypt',
-        label: 'encrypt',
-        property: {
-          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',
-        label: 'trust-server-certificate',
-        property: {
-          options: ['Y', 'N']
-        }
-      }
-    ]
-  }
-
-  get taskPrefixes() {
-    return ['database', 'mssql']
-  }
-
-  get help() {
-    return 'integration/connector/mssql-connector'
-  }
-}
-
-ConnectionManager.registerConnector('mssql-connector', new MssqlConnector())

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

@@ -1,94 +0,0 @@
-import Mysql from "mysql2/promise";
-
-import { Connector } from '../types'
-import { ConnectionManager } from '../connection-manager'
-import { InputConnection } from '../../service/connection/connection-type'
-
-export class mysqlConnector implements Connector {
-  async ready(connectionConfigs: InputConnection[]) {
-    await Promise.all(connectionConfigs.map(this.connect));
-    ConnectionManager.logger.info("mysql-connector connections are ready");
-  }
-
-  async connect(connection: InputConnection) {
-    const {
-      endpoint,
-      params: { user, password, database },
-    } = connection;
-
-    let [host, port = '3306'] = endpoint.split(":");
-
-    if (!Mysql) {
-      throw new Error("mysql module loading failed");
-    }
-
-    let pool = await Mysql.createPool({
-      user,
-      password,
-      host,
-      port: Number(port),
-      database,
-    });
-
-    const client = await pool.getConnection();
-    ConnectionManager.addConnectionInstance(connection, {
-      query: async (query, params) => {
-        var result;
-        try {
-          const results = await client.query(query);
-          if (results && results.length > 0) {
-            result = results[0];
-          }
-        } catch (e) {
-          ConnectionManager.logger.error(e);
-        }
-        return result;
-      },
-      close: client.end(),
-    });
-
-    ConnectionManager.logger.info(
-      `mysql Database(${connection.name}:${database}) at ${endpoint} connected.`
-    );
-  }
-
-  async disconnect(connection: InputConnection) {
-    var client = ConnectionManager.getConnectionInstance(connection);
-    try {
-      await client.close();
-      ConnectionManager.logger.info(
-        `mysql Database(${connection.name}) closed.`
-      );
-    } catch (e) {
-      ConnectionManager.logger.error(e);
-    }
-
-    ConnectionManager.removeConnectionInstance(connection);
-  }
-
-  get parameterSpec() {
-    return [
-      {
-        type: "string",
-        name: "user",
-        label: "user",
-      },
-      {
-        type: "password",
-        name: "password",
-        label: "password",
-      },
-      {
-        type: "string",
-        name: "database",
-        label: "database",
-      },
-    ];
-  }
-
-  get taskPrefixes() {
-    return ["database"];
-  }
-}
-
-ConnectionManager.registerConnector("mysql-connector", new mysqlConnector());

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

@@ -1,264 +0,0 @@
-import 'cross-fetch/polyfill'
-
-import { ApolloClient, InMemoryCache, createHttpLink, split } from '@apollo/client/core'
-import { setContext } from '@apollo/client/link/context'
-
-import WebSocket from 'ws'
-import { createClient } from 'graphql-ws'
-import { GraphQLWsLink } from '@apollo/client/link/subscriptions'
-import { getMainDefinition } from '@apollo/client/utilities'
-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, checkUserHasRole } from '@things-factory/auth-base'
-
-const debug = require('debug')('things-factory:integration-base:operato-connector')
-
-const defaultOptions: any = {
-  watchQuery: {
-    fetchPolicy: 'no-cache',
-    errorPolicy: 'ignore'
-  },
-  query: {
-    fetchPolicy: 'no-cache', //'network-only'
-    errorPolicy: 'all'
-  },
-  mutate: {
-    errorPolicy: 'all'
-  }
-}
-
-export const GRAPHQL_URI = '/graphql'
-export const SUBSCRIPTION_URI = GRAPHQL_URI
-
-interface SubscriberData {
-  tag: string
-  scenario: any
-  subscriptionObserver: any
-}
-
-export class OperatoConnector implements Connector {
-  private context: any
-
-  async ready(connectionConfigs: InputConnection[]) {
-    await Promise.all(connectionConfigs.map(this.connect.bind(this)))
-
-    ConnectionManager.logger.info('operato-connector connections are ready')
-  }
-
-  async connect(connection: InputConnection) {
-    const {
-      endpoint: uri,
-      params: { authKey, domain, subscriptionHandlers = {} }
-    } = connection
-
-    if (!authKey || !domain) {
-      throw new Error('some connection paramter missing.')
-    }
-
-    const domainOwner = await getRepository(User).findOne({
-      where: {
-        id: connection.domain.owner
-      }
-    })
-
-    this.context = {
-      domain: connection.domain,
-      user: domainOwner
-      /* TODO: domainOwner 대신 특정 유저를 지정할 수 있도록 개선해야함. 모든 커넥션에 유저를 지정하는 기능으로 일반화할 필요가 있는 지 고민해야함 */
-    }
-
-    const httpLink = createHttpLink({
-      uri: uri
-    })
-
-    /* 
-    CHECKPOINT: 
-      1. GraphqQLWsLink를 사용하면 setContext를 통한 추가 헤더 설정이 무시됩니다.
-      따라서, GraphQLWsLink를 사용하려면, connectionParams를 통해 헤더를 설정해야 합니다.
-    
-      2. 서버에서 실행시, webSocketImpl을 명시적으로 지정해야 합니다.
-    */
-    const wsLink = new GraphQLWsLink(
-      createClient({
-        url: uri.replace(/^http/, 'ws'),
-        keepAlive: 10_000,
-        retryAttempts: 1_000_000,
-        shouldRetry: e => true,
-        webSocketImpl: WebSocket,
-        connectionParams: {
-          headers: {
-            'x-things-factory-domain': domain,
-            authorization: authKey ? `Bearer ${authKey}` : ''
-          }
-        }
-      })
-    )
-
-    const splitLink = split(
-      ({ query }) => {
-        const def = getMainDefinition(query)
-        return def.kind === 'OperationDefinition' && def.operation === 'subscription'
-      },
-      wsLink,
-      setContext((_, { headers }) => {
-        return {
-          headers: {
-            ...headers,
-            'x-things-factory-domain': domain,
-            authorization: authKey ? `Bearer ${authKey}` : ''
-          }
-        }
-      }).concat(httpLink)
-    )
-
-    const cache = new InMemoryCache({
-      addTypename: false
-    })
-
-    const client = new ApolloClient({
-      defaultOptions,
-      cache,
-      link: splitLink
-    })
-
-    const subscriptions: SubscriberData[] = []
-    Object.keys(subscriptionHandlers).forEach(async tag => {
-      if (!tag || !subscriptionHandlers[tag]) return
-
-      const scenarioName = subscriptionHandlers[tag]
-
-      // fetch a scenario
-      const selectedScenario = await getRepository(Scenario).findOne({
-        where: {
-          name: scenarioName
-        },
-        relations: ['steps', 'domain']
-      })
-
-      const subscription = client.subscribe({
-        query: gql`
-          subscription {
-            data(tag: "${tag}") {
-              tag
-              data
-            }
-          }
-        `
-      })
-
-      const subscriptionObserver = subscription.subscribe({
-        next: async data => {
-          debug('received pubsub msg.:', data?.data)
-          await this.runScenario(subscriptions, data?.data?.data)
-        },
-        error: error => {
-          ConnectionManager.logger.error(`(${connection.name}:${connection.endpoint}) subscription error`, error)
-        },
-        complete: () => {
-          ConnectionManager.logger.info(`(${connection.name}:${connection.endpoint}) subscription complete`)
-        }
-      })
-
-      ConnectionManager.logger.info(
-        `(${connection.name}:${connection.endpoint}) subscription closed flag: ${subscriptionObserver.closed}`
-      )
-
-      subscriptions.push({
-        tag,
-        scenario: selectedScenario,
-        subscriptionObserver
-      })
-      ConnectionManager.logger.info(`(${tag}:${scenarioName}) subscription closed flag: ${subscriptionObserver.closed}`)
-    })
-
-    client['subscriptions'] = subscriptions
-    ConnectionManager.addConnectionInstance(connection, client)
-
-    ConnectionManager.logger.info(
-      `operato-connector connection(${connection.name}:${connection.endpoint}) is connected`
-    )
-  }
-
-  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(`operato-connector connection(${connection.name}) is disconnected`)
-  }
-
-  async runScenario(subscriptions: SubscriberData[], variables: any): Promise<ScenarioInstance> {
-    const { domain, user } = this.context
-    const { tag } = variables
-
-    if (!tag) {
-      throw new Error(`tag is invalid - ${tag}`)
-    }
-
-    const scenario = subscriptions.find(subscription => subscription.tag === tag)?.scenario
-    if (!scenario) {
-      throw new Error(`scenario is not found - ${tag}`)
-    }
-
-    if (!(await checkUserHasRole(scenario.roleId, domain, user))) {
-      throw new Error(`Unauthorized! ${scenario.name} doesn't have required role.`)
-    }
-
-    /* create a scenario instance */
-    const instanceName = scenario.name + '-' + String(Date.now())
-    const instance = new ScenarioInstance(instanceName, scenario, {
-      user,
-      domain,
-      variables,
-      client: GraphqlLocalClient.client
-    })
-
-    // run scenario
-    await instance.run()
-    return instance
-  }
-
-  get parameterSpec() {
-    return [
-      {
-        type: 'string',
-        name: 'authKey',
-        label: 'auth-key'
-      },
-      {
-        type: 'string',
-        name: 'domain',
-        label: 'domain'
-      },
-      {
-        type: 'tag-scenarios',
-        name: 'subscriptionHandlers',
-        label: 'subscription-handlers'
-      }
-    ]
-  }
-
-  get taskPrefixes() {
-    return ['graphql']
-  }
-
-  get help() {
-    return 'integration/connector/operato-connector'
-  }
-
-  get description() {
-    return 'Operato Graphql Connector'
-  }
-}
-
-ConnectionManager.registerConnector('operato-connector', new OperatoConnector())