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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-influxdb",
-  "version": "8.0.0-beta.8",
+  "version": "8.0.0",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -27,8 +27,8 @@
   },
   "dependencies": {
     "@influxdata/influxdb-client": "^1.33.2",
-    "@things-factory/integration-base": "^8.0.0-beta.8",
+    "@things-factory/integration-base": "^8.0.0",
     "ses": "^1.5.0"
   },
-  "gitHead": "bf5206511b2d84dfb95edc3dae7f54f6cbb9bcca"
+  "gitHead": "07ef27d272dd9a067a9648ac7013748510556a18"
 }

package/server/engine/connector/index.ts

@@ -0,0 +1 @@
+import './influxdb'

package/server/engine/connector/influxdb.ts

@@ -0,0 +1,69 @@
+import { InfluxDB } from '@influxdata/influxdb-client'
+
+import { Connection, ConnectionManager, Connector } from '@things-factory/integration-base'
+
+export class InfluxDBConnector implements Connector {
+  async ready(connectionConfigs) {
+    await Promise.all(connectionConfigs.map(this.connect.bind(this)))
+
+    ConnectionManager.logger.info('influxdb connections are ready')
+  }
+
+  checkConnectionInstance(domain, connectionName): boolean {
+    try {
+      const connection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
+
+      return !!(connection?.client?.connectionState !== 'online')
+    } catch (e) {
+      return false
+    }
+  }
+
+  async connect(connection) {
+    var {
+      endpoint,
+      params: { token }
+    } = connection
+
+    try {
+      const client = new InfluxDB({ url: endpoint, token })
+
+      ConnectionManager.addConnectionInstance(connection, client)
+
+      ConnectionManager.logger.info(`influxdb connection(${connection.name}:${connection.endpoint}) is connected`)
+    } catch (ex) {
+      ConnectionManager.logger.info(
+        `influxdb connection(${connection.name}:${connection.endpoint}) failed to connect`,
+        ex
+      )
+      throw ex
+    }
+  }
+
+  async disconnect(connection: Connection) {
+    var client = ConnectionManager.removeConnectionInstance(connection)
+    // client.close()
+
+    ConnectionManager.logger.info(`influxdb connection(${connection.name}) is disconnected`)
+  }
+
+  get parameterSpec() {
+    return [
+      {
+        type: 'string',
+        name: 'token',
+        label: 'influxdb.token'
+      }
+    ]
+  }
+
+  get taskPrefixes() {
+    return ['influxdb']
+  }
+
+  get help() {
+    return 'integration/connector/influxdb-connector'
+  }
+}
+
+ConnectionManager.registerConnector('influxdb-connector', new InfluxDBConnector())

package/server/engine/index.ts

@@ -0,0 +1,2 @@
+import './connector'
+import './task'

package/server/engine/task/index.ts

@@ -0,0 +1,2 @@
+import './influxdb-write-point'
+import './influxdb-query'

package/server/engine/task/influxdb-query.ts

@@ -0,0 +1,104 @@
+import 'ses'
+import { InfluxDB, FluxTableMetaData } from '@influxdata/influxdb-client'
+import { ConnectionManager, Context, TaskRegistry } from '@things-factory/integration-base'
+
+const debug = require('debug')('things-factory:influxdb-query')
+
+interface InfluxData {
+  measurement: string
+  tags: { [key: string]: string }
+  fields: { [key: string]: number | string | boolean }
+  timestamp: string
+}
+
+interface InfluxRaw {
+  _time: string
+  _start: string
+  _stop: string
+  _measurement: string
+  _field: string
+  _value: any
+  table: any
+  result: any
+  [tag: string]: string
+}
+
+function processInfluxData(raws: InfluxRaw[]): InfluxData[] {
+  const result: { [time: string]: InfluxData } = {}
+
+  raws.forEach(raw => {
+    const { _time, _field, _value, _measurement, _start, _stop, result: _result, table, ...tags } = raw
+
+    result[_time] ||= {
+      timestamp: _time,
+      measurement: _measurement,
+      tags,
+      fields: {}
+    }
+
+    result[_time].fields[_field] = _value
+  })
+
+  return Object.values(result)
+}
+
+async function influxdbQuery(step, { domain, user, data, variables, lng }: Context) {
+  const {
+    connection,
+    params: { organization, query }
+  } = step
+
+  const client = ConnectionManager.getConnectionInstanceByName(domain, connection) as InfluxDB
+  if (!client) {
+    debug(`no connection : ${connection}`)
+    throw new Error(`no connection : ${connection}`)
+  }
+
+  const compartment = new Compartment({
+    domain,
+    user,
+    lng,
+    data,
+    variables,
+    console
+  })
+
+  let fluxQuery
+  try {
+    fluxQuery = compartment.evaluate('`' + query + '`')
+  } catch (err) {
+    throw new Error(`Failed to evaluate query: ${err.message}`)
+  }
+
+  const queryApi = client.getQueryApi(organization)
+
+  const result = await queryApi.collectRows(fluxQuery)
+
+  return {
+    data: processInfluxData(result as InfluxRaw[])
+  }
+}
+
+influxdbQuery.parameterSpec = [
+  {
+    type: 'string',
+    name: 'organization',
+    label: 'influxdb.organization'
+  },
+  {
+    type: 'textarea',
+    name: 'query',
+    label: 'influxdb.query',
+    property: {
+      language: 'text',
+      showLineNumbers: true
+    },
+    styles: {
+      flex: '1'
+    }
+  }
+]
+
+influxdbQuery.help = 'integration/task/influxdb-query'
+
+TaskRegistry.registerTaskHandler('influxdb-query', influxdbQuery)

package/server/engine/task/influxdb-write-point.ts

@@ -0,0 +1,89 @@
+import { Point } from '@influxdata/influxdb-client'
+
+import { access } from '@things-factory/utils'
+import { ConnectionManager, TaskRegistry } from '@things-factory/integration-base'
+
+const debug = require('debug')('things-factory:influxdb-write-point')
+
+type InfluxDBPointScheme = {
+  name: string
+  type: string
+  val?: any
+  accessor?: string
+}
+
+async function influxdbWritePoint(step, { logger, domain, data }) {
+  const {
+    connection,
+    params: { organization, bucket, measurement, scheme }
+  } = step
+
+  const client = ConnectionManager.getConnectionInstanceByName(domain, connection)
+  if (!client) {
+    debug(`no connection : ${connection}`)
+    throw new Error(`no connection : ${connection}`)
+  }
+
+  const writeClient = client.getWriteApi(organization, bucket, 'ns')
+  const point = new Point(measurement)
+
+  scheme.forEach((field: InfluxDBPointScheme) => {
+    const { name, val, type, accessor } = field
+    const calculated = accessor ? access(accessor, data) || val : val
+
+    switch (type) {
+      case 'Tag':
+        point.tag(name, calculated)
+        break
+      case 'String':
+        point.stringField(name, calculated)
+        break
+      case 'Integer':
+        point.intField(name, calculated)
+        break
+      case 'Unsigned':
+        point.uintField(name, calculated)
+        break
+      case 'Float':
+        point.floatField(name, calculated)
+        break
+      case 'Boolean':
+        point.booleanField(name, calculated)
+        break
+    }
+  })
+
+  await writeClient.writePoint(point)
+  await writeClient.close()
+
+  return {
+    data: point.fields
+  }
+}
+
+influxdbWritePoint.parameterSpec = [
+  {
+    type: 'string',
+    name: 'organization',
+    label: 'influxdb.organization'
+  },
+  {
+    type: 'string',
+    name: 'bucket',
+    label: 'influxdb.bucket'
+  },
+  {
+    type: 'string',
+    name: 'measurement',
+    label: 'influxdb.measurement'
+  },
+  {
+    type: 'influxdb-point-scheme',
+    name: 'scheme',
+    label: 'influxdb.point-scheme'
+  }
+]
+
+influxdbWritePoint.help = 'integration/task/influxdb-write-point'
+
+TaskRegistry.registerTaskHandler('influxdb-write-point', influxdbWritePoint)

package/server/index.ts

@@ -0,0 +1 @@
+import './engine'