@things-factory/integration-base 8.0.0-beta.1 → 8.0.0-beta.2

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

@@ -1,126 +0,0 @@
-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/headless-connector.ts

@@ -1,341 +0,0 @@
-import { ConnectionManager } from '../connection-manager'
-import { Connector } from '../types'
-import { getHeadlessPool } from '../resource-pool/headless-pool'
-import { Browser, Page } from 'puppeteer'
-
-/*
-  Functionality of the headless-connector:
-  - Provides a mechanism to acquire an active session page.
-  - Performs login when necessary to obtain valid cookies.
-    - Applies these cookies to the page for session management.
-  - Pages are acquired from the `headlessPool`, which manages browser instances.
-  - During the login process, pages from the pool are used for actions like form filling and navigation.
-  - Valid cookies are saved after login and reused for subsequent page acquisitions.
-  - Users must explicitly release the page after use through the `releasePage` method.
-  - Released pages are returned to the `headlessPool` for reuse.
-*/
-
-export class HeadlessConnector implements Connector {
-  async ready(connectionConfigs) {
-    await Promise.all(connectionConfigs.map(this.connect.bind(this)))
-    ConnectionManager.logger.info('headless-connector connections are ready')
-  }
-
-  async connect(connection) {
-    const {
-      endpoint: uri = '1',
-      params: {
-        username = '',
-        password = '',
-        loginPath = '/login',
-        usernameSelector = '#username',
-        passwordSelector = '#password',
-        submitSelector = '#submit',
-        successSelector = null,
-        shadowDomSelectors = '', // Comma separated shadow DOM selectors
-        timeout = 15000, // Default timeout for operations
-        retries = 3 // Default number of retries for login or page actions
-      } = {}
-    } = connection
-
-    const loginInfo = {
-      loginRequired: Boolean(username), // Determine if login is required
-      username,
-      password,
-      loginPath,
-      timeout,
-      retries,
-      loginSelectors: {
-        usernameSelector,
-        passwordSelector,
-        submitSelector,
-        successSelector,
-        shadowDomSelectors: shadowDomSelectors
-          .split(',')
-          .map(selector => selector.trim())
-          .filter(Boolean)
-      }
-    }
-
-    async function acquireBrowser() {
-      try {
-        const pool = getHeadlessPool()
-        const browser = await pool.acquire()
-        return browser
-      } catch (error) {
-        ConnectionManager.logger.error('Failed to acquire browser:', error)
-        throw error
-      }
-    }
-
-    async function releaseBrowser(browser: Browser) {
-      try {
-        const pool = getHeadlessPool()
-        await pool.release(browser)
-      } catch (error) {
-        ConnectionManager.logger.error('Failed to release browser:', error)
-      }
-    }
-
-    ConnectionManager.addConnectionInstance(connection, {
-      endpoint: connection.endpoint,
-      params: connection.params,
-      acquireSessionPage: async () => {
-        const browser = await acquireBrowser()
-        let page
-        let cookies = connection.cookies
-
-        try {
-          page = await browser.newPage()
-
-          page.on('console', async msg => {
-            console.log(`[browser ${msg.type()}] ${msg.text()}`)
-          })
-
-          await page.setRequestInterception(true)
-
-          // page.on('request', request => {
-          //   const resourceType = request.resourceType()
-          //   if (resourceType === 'image' || resourceType === 'stylesheet' || resourceType === 'font') {
-          //     request.abort() // 이미지, 스타일시트, 폰트 요청 차단
-          //   } else {
-          //     request.continue() // 나머지 요청은 진행
-          //   }
-          // })
-
-          page.on('requestfailed', request => {
-            console.log('Request failed:')
-            console.log(`- URL: ${request.url()}`)
-            console.log(`- Method: ${request.method()}`)
-            console.log(`- Failure Text: ${request.failure()?.errorText}`)
-            console.log(`- Headers:`, request.headers())
-
-            // POST 데이터 (필요한 경우)
-            if (request.postData()) {
-              console.log(`- Post Data: ${request.postData()}`)
-            }
-          })
-
-          if (cookies && isCookieValid(cookies)) {
-            await this.applyCookiesAndVerifySession(page, cookies, loginInfo)
-            return page
-          }
-
-          if (loginInfo.loginRequired) {
-            await this.performLogin(page, uri, loginInfo)
-            cookies = await page.cookies()
-            connection.cookies = cookies
-          }
-
-          return page
-        } catch (error) {
-          ConnectionManager.logger.error('Failed to acquire session page:', error)
-          throw error
-        }
-      },
-      releasePage: async (page: Page) => {
-        try {
-          if (page) {
-            const browser = page.browser()
-            await page.close()
-            await releaseBrowser(browser)
-          }
-        } catch (error) {
-          ConnectionManager.logger.error('Failed to release page:', error)
-        }
-      },
-      acquireBrowser,
-      releaseBrowser
-    })
-
-    ConnectionManager.logger.info(
-      `headless-connector connection(${connection.name}:${connection.endpoint}) is connected`
-    )
-  }
-
-  async applyCookiesAndVerifySession(page, cookies, loginInfo) {
-    await page.setCookie(...cookies)
-    await page.reload({ waitUntil: 'networkidle2', timeout: loginInfo.timeout })
-
-    if (loginInfo.loginRequired && loginInfo.loginSelectors.successSelector) {
-      const success = await this.resolveShadowDom(
-        page,
-        loginInfo.loginSelectors.shadowDomSelectors,
-        loginInfo.loginSelectors.successSelector
-      )
-      if (!success) {
-        throw new Error('Session invalid, login required')
-      }
-    }
-  }
-
-  async performLogin(page, uri, loginInfo) {
-    for (let attempt = 1; attempt <= loginInfo.retries; attempt++) {
-      try {
-        await page.goto(`${uri}${loginInfo.loginPath}`, { waitUntil: 'networkidle2', timeout: loginInfo.timeout })
-
-        const usernameInput = await this.resolveShadowDom(
-          page,
-          loginInfo.loginSelectors.shadowDomSelectors,
-          loginInfo.loginSelectors.usernameSelector
-        )
-        const passwordInput = await this.resolveShadowDom(
-          page,
-          loginInfo.loginSelectors.shadowDomSelectors,
-          loginInfo.loginSelectors.passwordSelector
-        )
-        const submitButton = await this.resolveShadowDom(
-          page,
-          loginInfo.loginSelectors.shadowDomSelectors,
-          loginInfo.loginSelectors.submitSelector
-        )
-
-        if (!usernameInput || !passwordInput || !submitButton) {
-          throw new Error('Failed to locate input elements in shadow DOM')
-        }
-
-        await usernameInput.type(loginInfo.username)
-        await passwordInput.type(loginInfo.password)
-
-        // Capture the response of the form submission
-        const [response] = await Promise.all([
-          page.waitForNavigation({ waitUntil: 'networkidle2', timeout: loginInfo.timeout }),
-          submitButton.click()
-        ])
-
-        // Check response status code
-        if (response) {
-          const status = response.status()
-          if (status >= 200 && status < 300) {
-            ConnectionManager.logger.info(`Login successful with status code: ${status}`)
-            return // Login successful
-          } else if (status >= 400) {
-            throw new Error(`Login failed with status code: ${status}`)
-          }
-        } else {
-          throw new Error('No response received during login')
-        }
-
-        if (loginInfo.loginSelectors.successSelector) {
-          const success = await this.resolveShadowDom(
-            page,
-            loginInfo.loginSelectors.shadowDomSelectors,
-            loginInfo.loginSelectors.successSelector
-          )
-          if (!success) {
-            throw new Error('Login failed: Success selector not found')
-          }
-        }
-      } catch (error) {
-        ConnectionManager.logger.warn(`Login attempt ${attempt} failed:`, error)
-
-        if (attempt === loginInfo.retries) {
-          throw new Error(`Login failed after ${loginInfo.retries} attempts`)
-        }
-      }
-    }
-  }
-
-  async resolveShadowDom(page, shadowSelectors, targetSelector) {
-    let context
-
-    if (!shadowSelectors || shadowSelectors.length === 0) {
-      // No Shadow DOM path; use document root as the context
-      context = page.mainFrame() // Puppeteer uses frames to represent document
-      return context.$(targetSelector) // Search directly in the document root
-    }
-
-    context = page // Start with the page as the context
-    for (const selector of shadowSelectors) {
-      const shadowHost = await context.$(selector)
-      if (!shadowHost) {
-        throw new Error(`Shadow host not found: ${selector}`)
-      }
-      context = await page.evaluateHandle(host => host.shadowRoot, shadowHost)
-    }
-    return context.evaluateHandle((shadowRoot, selector) => shadowRoot.querySelector(selector), targetSelector)
-  }
-
-  async disconnect(connection) {
-    const connectionInstance = ConnectionManager.getConnectionInstance(connection)
-    ConnectionManager.removeConnectionInstance(connection)
-    ConnectionManager.logger.info(`headless-connector connection(${connection.name}) is disconnected`)
-  }
-
-  get parameterSpec() {
-    return [
-      {
-        type: 'string',
-        name: 'username',
-        label: 'username'
-      },
-      {
-        type: 'password',
-        name: 'password',
-        label: 'password'
-      },
-      {
-        type: 'string',
-        name: 'loginPath',
-        label: 'login-path'
-      },
-      {
-        type: 'string',
-        name: 'usernameSelector',
-        label: 'username-selector'
-      },
-      {
-        type: 'string',
-        name: 'passwordSelector',
-        label: 'password-selector'
-      },
-      {
-        type: 'string',
-        name: 'submitSelector',
-        label: 'submit-selector'
-      },
-      {
-        type: 'string',
-        name: 'successSelector',
-        label: 'success-selector'
-      },
-      {
-        type: 'string',
-        name: 'shadowDomSelectors',
-        label: 'shadow-dom-selectors'
-      },
-      {
-        type: 'number',
-        name: 'timeout',
-        label: 'timeout',
-        value: 15000
-      },
-      {
-        type: 'number',
-        name: 'retries',
-        label: 'maximum-retries',
-        value: 3
-      }
-    ]
-  }
-
-  get taskPrefixes() {
-    return ['headless']
-  }
-
-  get description() {
-    return 'Headless Pool Connector with login capabilities'
-  }
-
-  get help() {
-    return 'integration/connector/headless-connector'
-  }
-}
-
-ConnectionManager.registerConnector('headless-connector', new HeadlessConnector())
-
-function isCookieValid(cookies) {
-  if (!cookies || cookies.length === 0) return false
-  const now = Date.now() / 1000 // Current time in seconds
-  return cookies.some(cookie => cookie.expires && cookie.expires > now)
-}

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

@@ -1,65 +0,0 @@
-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']
-  }
-}
-
-ConnectionManager.registerConnector('http-connector', new HttpConnector())

package/server/engine/connector/index.ts

@@ -1,13 +0,0 @@
-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'
-import './headless-connector'

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

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