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

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

@@ -0,0 +1,78 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { Scenario } from './scenario'
+import { StepPatch } from '../step/step-type'
+
+@InputType()
+export class NewScenario {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field({ nullable: true })
+  schedule?: string
+
+  @Field({ nullable: true })
+  timezone?: string
+
+  @Field({ nullable: true })
+  ttl?: number
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field(type => ObjectRef, { nullable: true })
+  role?: ObjectRef
+}
+
+@InputType()
+export class ScenarioPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field({ nullable: true })
+  schedule?: string
+
+  @Field({ nullable: true })
+  timezone?: string
+
+  @Field({ nullable: true })
+  ttl?: number
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field(type => [StepPatch], { nullable: true })
+  steps?: StepPatch[]
+
+  @Field(type => ObjectRef, { nullable: true })
+  role?: ObjectRef
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class ScenarioList {
+  @Field(type => [Scenario])
+  items: Scenario[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/scenario/scenario.ts

@@ -0,0 +1,124 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { PrivilegeObject, Role, User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { ScenarioEngine } from '../../engine'
+import { Step } from '../step/step-type'
+
+@Entity()
+@Index('ix_scenario_0', (scenario: Scenario) => [scenario.domain, scenario.name], { unique: true })
+@ObjectType()
+export class Scenario {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  id?: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((scenario: Scenario) => scenario.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  type?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'accessible and executable system-wide' })
+  public?: boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: '[will be deprecated] automatically be started when this server start' })
+  active?: boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  schedule?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  scheduleId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  timezone?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  ttl?: number
+
+  @OneToMany(type => Step, step => step.scenario)
+  @Field(type => [Step], { nullable: true })
+  steps?: Step[]
+
+  @Column({ type: 'simple-json', nullable: true })
+  @Field(type => PrivilegeObject, { nullable: true })
+  privilege?: PrivilegeObject
+
+  @ManyToOne(type => Role)
+  @Field(type => Role, { nullable: true })
+  role?: Role
+
+  @RelationId((scenario: Scenario) => scenario.role)
+  roleId?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((scenario: Scenario) => scenario.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((scenario: Scenario) => scenario.updater)
+  updaterId?: string
+
+  async start(options?: { instanceName?: string; domain?: Domain; user?: User; variables?: any }) {
+    try {
+      await ScenarioEngine.load(options?.instanceName || this.name, this, {
+        domain: options?.domain || this.domain,
+        user: options?.user || this.updater,
+        variables: options?.variables
+      })
+    } catch (ex) {}
+  }
+
+  async stop(options?: { instanceName?: string; domain?: Domain; user?: User }) {
+    try {
+      await ScenarioEngine.unload(options?.domain || this.domain, options?.instanceName || this.name)
+    } finally {
+    }
+  }
+}

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

@@ -0,0 +1,17 @@
+import { Domain } from '@things-factory/shell'
+import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
+
+@Entity()
+@Index('ix_scenario_flows_0', (scenarioFlow: ScenarioFlow) => [scenarioFlow.domain], { unique: true })
+export class ScenarioFlow {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @ManyToOne(type => Domain)
+  domain: Domain
+
+  @Column({
+    nullable: true
+  })
+  flow: string
+}

package/server/service/scenario-instance/index.ts

@@ -0,0 +1,6 @@
+import { ScenarioInstanceQuery } from './scenario-instance-query'
+import { ScenarioInstanceMutation } from './scenario-instance-mutation'
+import { ScenarioInstanceSubscription } from './scenario-instance-subscription'
+
+export const entities = []
+export const resolvers = [ScenarioInstanceQuery, ScenarioInstanceMutation, ScenarioInstanceSubscription]

package/server/service/scenario-instance/scenario-instance-mutation.ts

@@ -0,0 +1,44 @@
+import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
+
+import { ScalarObject } from '@things-factory/shell'
+
+import { ScenarioInstance, ScenarioInstanceRunResult } from './scenario-instance-type'
+
+import {
+  runScenario as controllerRunScenario,
+  startScenario as controllerStartScenario,
+  stopScenario as controllerStopScenario
+} from '../../controllers/scenario-controller'
+
+@Resolver(ScenarioInstance)
+export class ScenarioInstanceMutation {
+  @Mutation(returns => ScenarioInstanceRunResult, {
+    description: 'To run new scenario instance and will return the result after the scenario stop.'
+  })
+  async runScenario(
+    @Arg('instanceName', { nullable: true }) instanceName: string,
+    @Arg('scenarioName') scenarioName: string,
+    @Arg('variables', type => ScalarObject, { nullable: true }) variables: any,
+    @Ctx() context: ResolverContext
+  ): Promise<ScenarioInstanceRunResult> {
+    return await controllerRunScenario(instanceName, scenarioName, variables, context)
+  }
+
+  @Mutation(returns => ScenarioInstance, { description: 'To start new scenario instance' })
+  async startScenario(
+    @Arg('instanceName', { nullable: true }) instanceName: string,
+    @Arg('scenarioName') scenarioName: string,
+    @Arg('variables', type => ScalarObject, { nullable: true }) variables: any,
+    @Ctx() context: ResolverContext
+  ): Promise<ScenarioInstance> {
+    return await controllerStartScenario(instanceName, scenarioName, variables, context)
+  }
+
+  @Mutation(returns => ScenarioInstance, { nullable: true, description: 'To start new scenario instance' })
+  async stopScenario(
+    @Arg('instanceName', { nullable: true }) instanceName: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ScenarioInstance | undefined> {
+    return await controllerStopScenario(instanceName, context)
+  }
+}

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

@@ -0,0 +1,42 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { ListParam, ScalarObject } from '@things-factory/shell'
+
+import { ScenarioEngine } from '../../engine'
+import {
+  ScenarioInstance,
+  ScenarioInstanceList,
+  ScenarioInstanceProgress,
+  ScenarioInstanceStatus
+} from './scenario-instance-type'
+
+@Resolver(ScenarioInstance)
+export class ScenarioInstanceQuery {
+  @Query(returns => ScenarioInstance, { description: 'To fetch a scenario instance' })
+  async scenarioInstance(
+    @Arg('instanceName') instanceName: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ScenarioInstance> {
+    const { domain } = context.state
+
+    return ScenarioEngine.getScenarioInstance(domain, instanceName)
+  }
+
+  @Query(returns => ScenarioInstanceList, { description: 'To fetch multiple scenario instances' })
+  async scenarioInstances(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<ScenarioInstanceList> {
+    const { domain } = context.state
+
+    var scenarioInstances = ScenarioEngine.getScenarioInstances(domain)
+
+    /* IMPLEMENT-ME 검색 기능.. */
+    var items = scenarioInstances
+
+    return {
+      items,
+      total: items.length
+    }
+  }
+}

package/server/service/scenario-instance/scenario-instance-subscription.ts

@@ -0,0 +1,118 @@
+import { Resolver, Subscription, Root, Arg } from 'type-graphql'
+import { filter, pipe } from 'graphql-yoga'
+import { pubsub, Log } from '@things-factory/shell'
+import { ScenarioInstance, ScenarioInstanceState } from './scenario-instance-type'
+import { ScenarioEngine } from '../../engine'
+
+const debug = require('debug')('things-factory:integration:scenario-instance-subscription')
+
+@Resolver(ScenarioInstance)
+export class ScenarioInstanceSubscription {
+  @Subscription({
+    subscribe: ({ args, context, info }) => {
+      const { domain, user } = context.state
+      const { instanceName, scenarioName, level } = args
+      const subdomain = domain?.subdomain
+
+      debug('subscribe', subdomain, scenarioName, instanceName)
+
+      if (!domain) {
+        throw new Error('domain required')
+      }
+
+      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
+        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
+      }
+
+      return pipe(
+        pubsub.subscribe('scenario-instance-log'),
+        filter((payload: { scenarioInstanceLog: Log }) => {
+          const { source, level: plevel } = payload.scenarioInstanceLog
+          const { domain: pdomain, scenarioName: pscenarioName, instanceName: pinstanceName } = source as any
+
+          if (subdomain !== pdomain?.subdomain) {
+            return false
+          }
+
+          if (scenarioName && pscenarioName !== scenarioName) {
+            return false
+          }
+
+          if (instanceName && pinstanceName !== instanceName) {
+            return false
+          }
+
+          if (level && level !== plevel) {
+            return false
+          }
+
+          return true
+        })
+      )
+    }
+  })
+  scenarioInstanceLog(
+    @Root() payload: { scenarioInstanceLog: Log },
+    @Arg('scenarioName', { nullable: true }) scenarioName: string,
+    @Arg('instanceName', { nullable: true }) instanceName: string,
+    @Arg('level', { nullable: true }) level: string
+  ): Log {
+    return payload.scenarioInstanceLog
+  }
+
+  @Subscription({
+    subscribe: ({ args, context, info }) => {
+      const { domain, user } = context.state
+      const { instanceName, scenarioName } = args
+      const subdomain = domain?.subdomain
+
+      debug('subscribe', subdomain, scenarioName, instanceName)
+
+      if (!domain) {
+        throw new Error('domain required')
+      }
+
+      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
+        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
+      }
+
+      process.nextTick(() => {
+        ScenarioEngine.getScenarioInstances(domain)
+          .filter(instance => {
+            return (!instanceName || instance.instanceName === instanceName) && (!scenarioName || instance.scenarioName === scenarioName)
+          })
+          .forEach(instance => {
+            instance.publishState()
+          })
+      })
+
+      return pipe(
+        pubsub.subscribe('scenario-instance-state'),
+        filter((payload: { scenarioInstanceState: ScenarioInstanceState }) => {
+          const { domain: pdomain, scenarioName: pscenarioName, instanceName: pinstanceName } = payload.scenarioInstanceState
+
+          if (subdomain !== pdomain?.subdomain) {
+            return false
+          }
+
+          if (scenarioName && pscenarioName !== scenarioName) {
+            return false
+          }
+
+          if (instanceName && pinstanceName !== instanceName) {
+            return false
+          }
+
+          return true
+        })
+      )
+    }
+  })
+  scenarioInstanceState(
+    @Root() payload: { scenarioInstanceState: ScenarioInstanceState },
+    @Arg('scenarioName', { nullable: true }) scenarioName: string,
+    @Arg('instanceName', { nullable: true }) instanceName: string
+  ): ScenarioInstanceState {
+    return payload.scenarioInstanceState
+  }
+}