@things-factory/integration-base 6.1.101 → 6.1.104

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-base",
-  "version": "6.1.101",
+  "version": "6.1.104",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -46,5 +46,5 @@
   "devDependencies": {
     "@types/cron": "^2.0.1"
   },
-  "gitHead": "1ecb1d6fca22c20751878c234b9139ff0dac7766"
+  "gitHead": "d2f776fe1904d0dc944ba9937da78c8a1e9873a9"
 }

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

@@ -0,0 +1,112 @@
+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'],
+        text: scenario.name,
+        properties: {
+          name: scenario.name,
+          description: scenario.description
+        }
+      }
+    })
+  )
+
+  model.nodes = model.nodes.concat(
+    connections.map(connection => {
+      return {
+        id: connection.id,
+        labels: ['Connection'],
+        text: connection.name,
+        properties: {
+          name: connection.name,
+          description: connection.description
+        }
+      }
+    })
+  )
+
+  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',
+        startNode: scenario.id,
+        endNode: connection.id,
+        properties: {}
+      }
+    })
+
+    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'],
+        text: tag,
+        properties: {
+          tag
+        }
+      })
+
+      tagNames.push(tag)
+    }
+
+    const relationships = tags.map(tag => {
+      return {
+        id: ++id,
+        type: 'publish',
+        startNode: scenario.id,
+        endNode: `tag-${tag}`,
+        properties: {}
+      }
+    })
+
+    model.relationships = model.relationships.concat(relationships)
+  })
+
+  return model
+}

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> {