@things-factory/integration-base 6.1.100 → 6.1.103

package/server/engine/analyzer/analyze-integration.ts

@@ -0,0 +1,106 @@
+import uniq from 'lodash/uniq'
+
+import { Domain, getRepository } from '@things-factory/shell'
+import { Scenario } from '../../service/scenario/scenario-type'
+import { Connection } from '../../service/connection/connection-type'
+
+export async function analyzeIntegration(domain: Domain) {
+  const tagNames = []
+
+  const model = {
+    nodes: [],
+    relationships: []
+  }
+
+  var id = 0
+
+  const scenarios = await getRepository(Scenario).find({
+    where: { domain: { id: domain.id } },
+    relations: ['steps']
+  })
+
+  const connections = await getRepository(Connection).find({
+    where: { domain: { id: domain.id } }
+  })
+
+  model.nodes = model.nodes.concat(
+    scenarios.map(scenario => {
+      return {
+        id: scenario.id,
+        labels: ['Scenario'],
+        properties: {
+          scenarioId: scenario.id
+        }
+      }
+    })
+  )
+
+  model.nodes = model.nodes.concat(
+    connections.map(connection => {
+      return {
+        id: ++id,
+        labels: ['Connection'],
+        properties: {
+          connectionId: connection.id
+        }
+      }
+    })
+  )
+
+  scenarios.forEach(scenario => {
+    const connectionNames = uniq(scenario.steps.map(step => step.connection).filter(Boolean))
+    const connectionList = connectionNames
+      .map(connectionName => connections.find(connection => connection.name == connectionName))
+      .filter(Boolean)
+
+    const relationships = connectionList.map(connection => {
+      return {
+        id: ++id,
+        type: 'using',
+        sourceNode: scenario.id,
+        targetNode: connection.id
+      }
+    })
+
+    model.relationships = model.relationships.concat(relationships)
+  })
+
+  scenarios.forEach(scenario => {
+    const tags = uniq(
+      scenario.steps
+        .filter(step => !step.connection && step.task == 'publish')
+        .map(step => JSON.parse(step.params)?.tag)
+        .filter(Boolean)
+    )
+
+    for (const tag of tags) {
+      if (tagNames.includes(tag)) {
+        continue
+      }
+
+      model.nodes.push({
+        id: `tag-${tag}`,
+        labels: ['Tag'],
+        properties: {
+          tag
+        }
+      })
+
+      tagNames.push(tag)
+    }
+
+    const relationships = tags.map(tag => {
+      return {
+        id: ++id,
+        type: 'publish',
+        sourceNode: scenario.id,
+        targetNode: `tag-${tag}`,
+        properties: {}
+      }
+    })
+
+    model.relationships = model.relationships.concat(relationships)
+  })
+
+  return model
+}

package/server/engine/task/http-get.ts

@@ -68,17 +68,11 @@ async function HttpGet(step, { logger, data, domain, variables }) {
 
   var response = await fetch(url, fetchOptions)
 
-  var responseData = await response.text()
-
-  const responseContentType = response.headers.get('content-type')
-  if (responseContentType && responseContentType.indexOf('application/json') !== -1) {
-    responseData = JSON.parse(responseData)
-  }
-
-  logger.info(`http-get : \n${JSON.stringify(responseData, null, 2)}`)
-
   return {
-    data: responseData
+    data:
+      response.ok && response.headers.get('content-type').includes('application/json')
+        ? await response.json()
+        : await response.text()
   }
 }
 
@@ -100,4 +94,6 @@ HttpGet.parameterSpec = [
   }
 ]
 
+HttpGet.help = 'integration/task/http-get'
+
 TaskRegistry.registerTaskHandler('http-get', HttpGet)

package/server/engine/task/http-post.ts

@@ -128,4 +128,6 @@ HttpPost.parameterSpec = [
   }
 ]
 
+HttpPost.help = 'integration/task/http-post'
+
 TaskRegistry.registerTaskHandler('http-post', HttpPost)

package/server/engine/task/log.ts

@@ -1,14 +1,31 @@
-import { access } from '@things-factory/utils'
+import { access, hasTemplateExpression } from '@things-factory/utils'
+import { VM } from 'vm2'
 import { TaskRegistry } from '../task-registry'
 
-async function Log(step, { logger, data }) {
+async function Log(step, { logger, data, variables, domain }) {
   var {
     params: { message, accessor, level = 'info' }
   } = step
 
-  message = access(accessor, data) || message
-  if (typeof message !== 'string') {
-    message = JSON.stringify(message, null, 2)
+  if (hasTemplateExpression(message)) {
+    const vm = new VM({
+      sandbox: {
+        domain,
+        data,
+        variables
+      }
+    })
+
+    message = vm.run('`' + message + '`')
+  }
+
+  accessor = access(accessor, data)
+
+  if (accessor) {
+    if (accessor !== 'string') {
+      accessor = JSON.stringify(accessor, null, 2)
+    }
+    message += ': ' + accessor
   }
 
   switch (level) {
@@ -28,16 +45,16 @@ async function Log(step, { logger, data }) {
 }
 
 Log.parameterSpec = [
-  {
-    type: 'scenario-step-input',
-    name: 'accessor',
-    label: 'accessor'
-  },
   {
     type: 'string',
     name: 'message',
     label: 'message'
   },
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  },
   {
     type: 'select',
     name: 'level',

package/server/service/analysis/analysis-query.ts

@@ -0,0 +1,13 @@
+import { Resolver, Query, Ctx } from 'type-graphql'
+import { ScalarObject } from '@things-factory/shell'
+import { analyzeIntegration } from '../../engine/analyzer/analyze-integration'
+
+@Resolver()
+export class IntegrationAnalysisQuery {
+  @Query(returns => ScalarObject, { description: 'To fetch integration Analyses' })
+  async integrationAnalysis(@Ctx() context: ResolverContext): Promise<any> {
+    const { domain } = context.state
+
+    return await analyzeIntegration(domain)
+  }
+}

package/server/service/analysis/index.ts

@@ -0,0 +1,3 @@
+import { IntegrationAnalysisQuery } from './analysis-query'
+
+export const resolvers = [IntegrationAnalysisQuery]

package/server/service/index.ts

@@ -6,6 +6,7 @@ import { entities as ScenarioQueueEntities, resolvers as ScenarioQueueResolvers
 import { entities as StepEntities, resolvers as StepResolvers } from './step'
 import { entities as TaskTypeEntities, resolvers as TaskTypeResolvers } from './task-type'
 import { entities as PayloadLogEntities, resolvers as PayloadLogResolvers } from './payload-log'
+import { resolvers as IntegrationAnalysisQuery } from './analysis'
 
 export * from './property-spec'
 export * from './task-type/task-type-type'
@@ -38,9 +39,10 @@ export const schema = {
     ...ScenarioInstanceResolvers,
     ...ScenarioQueueResolvers,
     ...StepResolvers,
-    ...PayloadLogResolvers
+    ...PayloadLogResolvers,
+    ...IntegrationAnalysisQuery
   ]
 }
 
 export { PayloadType } from './payload-log/payload-log'
-export { createPayloadLog } from './payload-log/payload-log-mutation'
+export { createPayloadLog } from './payload-log/payload-log-mutation'

package/server/service/scenario/scenario-query.ts

@@ -1,4 +1,5 @@
 import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { Not, IsNull } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
@@ -7,6 +8,7 @@ import { ScenarioEngine } from '../../engine'
 import { ScenarioInstance, ScenarioInstanceStatus } from '../scenario-instance/scenario-instance-type'
 import { Step } from '../step/step-type'
 import { Scenario, ScenarioList } from './scenario-type'
+import { Connection } from '../connection/connection-type'
 
 @Resolver(Scenario)
 export class ScenarioQuery {
@@ -62,7 +64,27 @@ export class ScenarioQuery {
     })
   }
 
-  /* 아래 두개 FieldResolver는 type에는 정의하지 않았지만, 스키마에는 자동으로 추가되는 것으로 보인다. */
+  @FieldResolver(type => [Connection])
+  async connectionNames(@Root() scenario: Scenario, @Ctx() context: ResolverContext) {
+    const { domain } = context.state
+
+    const steps = await getRepository(Step).find({
+      where: { domain: { id: domain.id }, scenario: { id: scenario.id }, connection: Not(IsNull()) }
+    })
+
+    return steps.map(step => step.connection).filter(Boolean)
+  }
+
+  @FieldResolver(type => [Connection])
+  async publishTags(@Root() scenario: Scenario, @Ctx() context: ResolverContext) {
+    const { domain } = context.state
+
+    const steps = await getRepository(Step).find({
+      where: { domain: { id: domain.id }, scenario: { id: scenario.id }, task: 'publish' }
+    })
+
+    return steps.map(step => JSON.parse(step.params)?.tag).filter(Boolean)
+  }
 
   @FieldResolver(type => String, { nullable: true })
   async state(@Root() scenario: Scenario, @Ctx() context: ResolverContext): Promise<string> {