@things-factory/integration-base 8.0.0-beta.8 → 8.0.0

package/server/engine/connector/echo-back-server.ts

@@ -0,0 +1,72 @@
+import net from 'net'
+import PromiseSocket from 'promise-socket'
+
+import { Connector } from '../types'
+import { ConnectionManager } from '../connection-manager'
+import { InputConnection } from '../../service/connection/connection-type'
+
+export class EchoBack implements Connector {
+  async ready(connectionConfigs: InputConnection[]) {
+    await Promise.all(connectionConfigs.map(this.connect.bind(this)))
+
+    ConnectionManager.logger.info('echo-back-servers are ready')
+  }
+
+  async connect(config: InputConnection): Promise<void> {
+    var [host = '0.0.0.0', port = 8124] = config.endpoint.split(':')
+
+    return new Promise((resolve, reject) => {
+      var server = net.createServer(socket => {
+        socket.on('data', function (data) {
+          socket.write(data.toString())
+        })
+
+        socket.on('error', function (err) {
+          ConnectionManager.logger.error(err)
+          reject(err)
+        })
+      })
+
+      server.listen(port, async () => {
+        ConnectionManager.logger.info(`Echo-back server listening on ${host}:${port}`)
+
+        /* default client connection */
+        let socket = new net.Socket()
+        socket.on('error', console.error)
+
+        try {
+          let promiseSocket = new PromiseSocket(socket)
+          await promiseSocket.connect(Number(port), 'localhost')
+          promiseSocket['__server__'] = server
+
+          ConnectionManager.addConnectionInstance(config, promiseSocket)
+
+          ConnectionManager.logger.info(`echo-back-server connection(${config.name}:${config.endpoint}) is connected`)
+
+          resolve()
+        } catch (err) {
+          ConnectionManager.logger.error(
+            `echo-back-server connection(${config.name}:${config.endpoint}) is connected.\ncause: ${err}`
+          )
+          reject(err)
+        }
+      })
+    })
+  }
+
+  async disconnect(connection: InputConnection) {
+    let socket = ConnectionManager.removeConnectionInstance(connection)
+    var server = socket['__server__']
+
+    await socket.destroy()
+    server && (await server.close())
+
+    ConnectionManager.logger.info(`echo-back-server connection(${connection.name}) is disconnected`)
+  }
+
+  get parameterSpec() {
+    return []
+  }
+}
+
+ConnectionManager.registerConnector('echo-back-server', new EchoBack())

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

@@ -0,0 +1,126 @@
+import 'cross-fetch/polyfill'
+
+import { ApolloClient, ApolloLink, from, HttpLink, InMemoryCache } from '@apollo/client/core'
+import { onError } from '@apollo/client/link/error'
+import { Oauth2Client } from '@things-factory/oauth2-client'
+import { getRepository } from '@things-factory/shell'
+
+import { ConnectionManager } from '../connection-manager'
+import { Connector } from '../types'
+import { InputConnection } from '../../service/connection/connection-type'
+
+const defaultOptions: any = {
+  watchQuery: {
+    fetchPolicy: 'no-cache',
+    errorPolicy: 'ignore'
+  },
+  query: {
+    fetchPolicy: 'no-cache', //'network-only'
+    errorPolicy: 'all'
+  },
+  mutate: {
+    errorPolicy: 'all'
+  }
+}
+
+export class GraphqlConnector implements Connector {
+  async ready(connectionConfigs: InputConnection[]) {
+    await Promise.all(connectionConfigs.map(this.connect.bind(this)))
+
+    ConnectionManager.logger.info('graphql-connector connections are ready')
+  }
+
+  async connect(connection: InputConnection) {
+    const {
+      endpoint: uri,
+      params: { authClient }
+    } = connection
+
+    const ERROR_HANDLER: any = ({ graphQLErrors, networkError }) => {
+      if (graphQLErrors)
+        graphQLErrors.map(({ message, locations, path }) => {
+          ConnectionManager.logger.error(
+            `[GraphQL error] Message: ${message}, Location: ${locations}, Path: ${path}`,
+            graphQLErrors
+          )
+        })
+
+      if (networkError) {
+        ConnectionManager.logger.error(`[Network error - ${networkError.statusCode}]`, networkError)
+      }
+    }
+
+    const oauth2Client: Oauth2Client = await getRepository(Oauth2Client).findOneBy({ id: authClient })
+
+    const authMiddleware = new ApolloLink((operation, forward) => {
+      // add the authorization to the headers
+      operation.setContext(({ headers = {} }) => ({
+        headers: {
+          ...headers,
+          ...oauth2Client.getAuthHeaders()
+        }
+      }))
+
+      return forward(operation)
+    })
+
+    const cache = new InMemoryCache({
+      addTypename: false
+    })
+
+    ConnectionManager.addConnectionInstance(
+      connection,
+      new ApolloClient({
+        defaultOptions,
+        cache,
+        link: from([
+          authMiddleware,
+          onError(ERROR_HANDLER),
+          new HttpLink({
+            uri,
+            credentials: 'include'
+          })
+        ])
+      })
+    )
+
+    ConnectionManager.logger.info(
+      `graphql-connector connection(${connection.name}:${connection.endpoint}) is connected`
+    )
+  }
+
+  async disconnect(connection: InputConnection) {
+    const client = ConnectionManager.getConnectionInstance(connection)
+    client.stop()
+    ConnectionManager.removeConnectionInstance(connection)
+
+    ConnectionManager.logger.info(`graphql-connector connection(${connection.name}) is disconnected`)
+  }
+
+  get parameterSpec() {
+    return [
+      {
+        type: 'entity-selector',
+        name: 'authClient',
+        label: 'auth-client',
+        property: {
+          queryName: 'oauth2Clients'
+        }
+      }
+    ]
+  }
+
+  get taskPrefixes() {
+    return ['graphql']
+  }
+
+  get description() {
+    return 'Graphql Http Connector'
+  }
+
+  get help() {
+    return 'integration/connector/graphql-connector'
+  }
+}
+
+ConnectionManager.registerConnector('graphql-connector', new GraphqlConnector())

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

@@ -0,0 +1,65 @@
+import { Oauth2Client } from '@things-factory/oauth2-client'
+import { getRepository } from '@things-factory/shell'
+
+import { ConnectionManager } from '../connection-manager'
+import { Connector } from '../types'
+import { InputConnection } from '../../service/connection/connection-type'
+
+export class HttpConnector implements Connector {
+  async ready(connectionConfigs: InputConnection[]) {
+    await Promise.all(connectionConfigs.map(this.connect.bind(this)))
+
+    ConnectionManager.logger.info('http-connector connections are ready')
+  }
+
+  async connect(connection: InputConnection) {
+    var { params } = connection
+    params.rejectUnauthorized = (params.rejectUnauthorized || 'Y') === 'Y'
+
+    if (params.authClient) {
+      const oauth2Client: Oauth2Client = await getRepository(Oauth2Client).findOneBy({ id: params.authClient })
+      var authHeaders = oauth2Client.getAuthHeaders()
+    }
+
+    ConnectionManager.addConnectionInstance(connection, {
+      ...connection,
+      authHeaders: authHeaders || {},
+      params
+    })
+
+    ConnectionManager.logger.info(`http-connector connection(${connection.name}:${connection.endpoint}) is connected`)
+  }
+
+  async disconnect(connection: InputConnection) {
+    ConnectionManager.removeConnectionInstance(connection)
+
+    ConnectionManager.logger.info(`http-connector connection(${connection.name}) is disconnected`)
+  }
+
+  get parameterSpec() {
+    return [
+      {
+        type: 'entity-selector',
+        name: 'authClient',
+        label: 'auth-client',
+        property: {
+          queryName: 'oauth2Clients'
+        }
+      },
+      {
+        type: 'select',
+        name: 'rejectUnauthorized',
+        label: 'reject-unauthorized',
+        property: {
+          options: ['Y', 'N']
+        }
+      }
+    ]
+  }
+
+  get taskPrefixes() {
+    return ['http', 'headless-post', 'headless-scrap']
+  }
+}
+
+ConnectionManager.registerConnector('http-connector', new HttpConnector())

package/server/engine/connector/index.ts

@@ -0,0 +1,12 @@
+import './echo-back-server'
+import './echo-back-connector'
+import './http-connector'
+import './graphql-connector'
+import './sqlite-connector'
+import './postgresql-connector'
+import './mqtt-connector'
+import './mssql-connector'
+import './oracle-connector'
+import './mysql-connector'
+import './socket-server'
+import './operato-connector'

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

@@ -0,0 +1,78 @@
+import { Connector } from '../types'
+import { ConnectionManager } from '../connection-manager'
+import { InputConnection } from '../../service/connection/connection-type'
+
+import mqtt from 'async-mqtt'
+
+export class MqttConnector implements Connector {
+  async ready(connectionConfigs: InputConnection[]) {
+    await Promise.all(connectionConfigs.map(this.connect.bind(this)))
+
+    ConnectionManager.logger.info('mqtt-connector connections are ready')
+  }
+
+  async connect(connection: InputConnection) {
+    const {
+      endpoint: uri,
+      params: { user, password }
+    } = connection
+
+    try {
+      var client = null
+      if (user && password) {
+        client = await mqtt.connectAsync(uri, { username: user, password: password })
+      } else {
+        client = await mqtt.connectAsync(uri)
+      }
+
+      if (!client) {
+        throw new Error(
+          `the initialization of mqtt connector is failed. uri: ${uri}, user: ${user} password: ${password}`
+        )
+      }
+
+      ConnectionManager.addConnectionInstance(connection, {
+        client,
+        connection
+      })
+
+      ConnectionManager.logger.info(`mqtt-connector connection(${connection.name}:${connection.endpoint}) is connected`)
+    } catch (err) {
+      ConnectionManager.logger.error(
+        `mqtt-connector connection(${connection.name}:${connection.endpoint}) is failed.`,
+        err
+      )
+    }
+  }
+
+  async disconnect(connection: InputConnection) {
+    const { client } = ConnectionManager.removeConnectionInstance(connection)
+
+    client && (await client.end())
+  }
+
+  get parameterSpec() {
+    return [
+      {
+        type: 'string',
+        name: 'user',
+        label: 'user'
+      },
+      {
+        type: 'password',
+        name: 'password',
+        label: 'password'
+      }
+    ]
+  }
+
+  get taskPrefixes() {
+    return ['mqtt']
+  }
+
+  get help() {
+    return 'integration/connector/mqtt-connector'
+  }
+}
+
+ConnectionManager.registerConnector('mqtt-connector', new MqttConnector())

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

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

@@ -0,0 +1,94 @@
+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());