@things-factory/integration-base 7.0.0-alpha.9 → 7.0.0

package/server/service/scenario/scenario.ts

@@ -26,7 +26,7 @@ export class Scenario {
   id?: string
 
   @ManyToOne(type => Domain)
-  @Field({ nullable: true })
+  @Field(type => Domain)
   domain?: Domain
 
   @RelationId((scenario: Scenario) => scenario.domain)
@@ -64,6 +64,10 @@ export class Scenario {
   @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[]
@@ -81,28 +85,43 @@ export class Scenario {
   updatedAt?: Date
 
   @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
+  @Field(type => User, { nullable: true })
   creator?: User
 
   @RelationId((scenario: Scenario) => scenario.creator)
   creatorId?: string
 
   @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
+  @Field(type => User, { nullable: true })
   updater?: User
 
   @RelationId((scenario: Scenario) => scenario.updater)
   updaterId?: string
 
-  async start(instanceName, variables?: any) {
+  async start(options?: {
+    instanceName?: string;
+    domain?: Domain;
+    user?: User;
+    variables?: any;
+  }) {
     try {
-      await ScenarioEngine.load(instanceName || this.name, this, { domain: this.domain, user: this.updater, variables })
+      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(instanceName?) {
+  async stop(options?: {
+    instanceName?: string;
+    domain?: Domain,
+    user?: User
+  }) {
     try {
-      await ScenarioEngine.unload(this.domain, instanceName || this.name)
+      await ScenarioEngine.unload(options?.domain || this.domain, options?.instanceName || this.name)
     } finally {
     }
   }

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

@@ -2,7 +2,7 @@ import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
 
 import { ScalarObject } from '@things-factory/shell'
 
-import { ScenarioInstance } from './scenario-instance-type'
+import { ScenarioInstance, ScenarioInstanceRunResult } from './scenario-instance-type'
 
 import {
   runScenario as controllerRunScenario,
@@ -12,7 +12,7 @@ import {
 
 @Resolver(ScenarioInstance)
 export class ScenarioInstanceMutation {
-  @Mutation(returns => ScenarioInstance, {
+  @Mutation(returns => ScenarioInstanceRunResult, {
     description: 'To run new scenario instance and will return the result after the scenario stop.'
   })
   async runScenario(
@@ -20,7 +20,7 @@ export class ScenarioInstanceMutation {
     @Arg('scenarioName') scenarioName: string,
     @Arg('variables', type => ScalarObject, { nullable: true }) variables: any,
     @Ctx() context: ResolverContext
-  ): Promise<ScenarioInstance> {
+  ): Promise<ScenarioInstanceRunResult> {
     return await controllerRunScenario(instanceName, scenarioName, variables, context)
   }
 
@@ -35,7 +35,10 @@ export class ScenarioInstanceMutation {
   }
 
   @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> {
+  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

@@ -23,7 +23,10 @@ export class ScenarioInstanceQuery {
   }
 
   @Query(returns => ScenarioInstanceList, { description: 'To fetch multiple scenario instances' })
-  async scenarioInstances(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ScenarioInstanceList> {
+  async scenarioInstances(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<ScenarioInstanceList> {
     const { domain } = context.state
 
     var scenarioInstances = ScenarioEngine.getScenarioInstances(domain)
@@ -36,33 +39,4 @@ export class ScenarioInstanceQuery {
       total: items.length
     }
   }
-
-  @FieldResolver(type => ScenarioInstance)
-  async root(@Root() scenarioInstance: ScenarioInstance): Promise<ScenarioInstance> {
-    return scenarioInstance.context?.root as ScenarioInstance
-  }
-
-  @FieldResolver(type => ScenarioInstanceStatus)
-  async state(@Root() scenarioInstance: ScenarioInstance): Promise<ScenarioInstanceStatus> {
-    return scenarioInstance.context?.state
-  }
-
-  @FieldResolver(type => ScenarioInstanceProgress)
-  progress(@Root() scenarioInstance: ScenarioInstance): ScenarioInstanceProgress {
-    return scenarioInstance.calcProgress()
-  }
-  @FieldResolver(type => ScalarObject)
-  async variables(@Root() scenarioInstance: ScenarioInstance): Promise<Object> {
-    return scenarioInstance.context?.variables
-  }
-
-  @FieldResolver(type => ScalarObject)
-  async data(@Root() scenarioInstance: ScenarioInstance): Promise<Object> {
-    return scenarioInstance.context?.data
-  }
-
-  @FieldResolver()
-  async timestamp(@Root() scenarioInstance: ScenarioInstance): Promise<Date> {
-    return new Date()
-  }
 }

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

@@ -7,18 +7,21 @@ import util from 'util'
 import { createLogger, format, transports } from 'winston'
 
 import { Domain, pubsub, PubSubLogTransport, ScalarObject } from '@things-factory/shell'
+import { cacheService } from '@things-factory/cache-service'
 import { User } from '@things-factory/auth-base'
 import { sleep } from '@things-factory/utils'
 
+import { ConnectionManager } from '../../engine/connection-manager'
 import { TaskRegistry } from '../../engine'
 import { Context } from '../../engine/types'
 import { Step } from '../step/step-type'
+import { handler as edgeHandler } from '../../engine/edge-client'
 
 const debug = require('debug')('things-factory:integration-base:scenario-instance')
-const { combine, timestamp, splat, printf } = format
+const { combine, errors, splat, printf } = format
 
-const LOGFORMAT = printf(({ level, message, timestamp }) => {
-  return `${timestamp} ${level}: ${message}`
+const LOGFORMAT = printf(({ level, message, timestamp, stack }) => {
+  return `${timestamp} ${level}: ${stack || message}`
 })
 
 const SYSTEM_TZ = Intl.DateTimeFormat().resolvedOptions().timeZone
@@ -85,6 +88,33 @@ export class ScenarioInstanceState {
   public timestamp: Date
 }
 
+@ObjectType()
+export class ScenarioInstanceRunResult {
+  @Field({ nullable: true })
+  public scenarioName: string
+
+  @Field({ nullable: true })
+  public instanceName: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  public variables: any
+
+  @Field(type => ScalarObject, { nullable: true })
+  public data: any
+
+  @Field(type => ScalarObject, { nullable: true })
+  public result: any
+
+  @Field({ nullable: true })
+  public timestamp: Date
+
+  @Field({ nullable: true })
+  public message: string
+
+  @Field({ nullable: true })
+  public state: ScenarioInstanceStatus
+}
+
 @ObjectType()
 export class ScenarioInstance {
   private subScenarioInstances: ScenarioInstance[] = [] // TODO Imple by WeakSet
@@ -104,29 +134,43 @@ export class ScenarioInstance {
   public instanceName: string
 
   @Field({ nullable: true })
-  root: ScenarioInstance
+  get root(): ScenarioInstance {
+    return this.context?.root
+  }
 
   @Field({ nullable: true })
-  state: ScenarioInstanceStatus
+  get state(): ScenarioInstanceStatus {
+    return this.context?.state
+  }
 
   @Field(type => ScenarioInstanceProgress, { nullable: true })
-  progress: ScenarioInstanceProgress
+  get progress(): ScenarioInstanceProgress {
+    return this.calcProgress()
+  }
 
   @Field(type => ScalarObject, { nullable: true })
-  variables: any
+  get variables(): any {
+    return this.context?.variables
+  }
 
   @Field(type => ScalarObject, { nullable: true })
-  data: any
+  get data(): any {
+    return this.context?.data
+  }
 
   @Field(type => ScalarObject, { nullable: true })
   result: any
 
   @Field({ nullable: true })
-  timestamp: Date
+  get timestamp(): Date {
+    return new Date()
+  }
 
   @Field({ nullable: true })
   public message: string
 
+  private scenarioId: string
+  private scenarioTtl: number
   private steps: Step[]
   private rounds: number = 0
 
@@ -152,10 +196,22 @@ export class ScenarioInstance {
     }
   }
 
-  constructor(instanceName, { name: scenarioName, steps, domain: scenarioDomain }, context?) {
+  constructor(
+    instanceName,
+    {
+      id: scenarioId,
+      ttl: scenarioTtl,
+      name: scenarioName,
+      steps,
+      domain: scenarioDomain
+    }: { id: string; ttl?: number; name: string; steps: Step[]; domain: Domain },
+    context?
+  ) {
     var { domain, user, lng, unsafeIP, prohibitedPrivileges } = context || {}
     domain ||= scenarioDomain
 
+    this.scenarioId = scenarioId
+    this.scenarioTtl = scenarioTtl
     this.instanceName = instanceName
     this.scenarioName = scenarioName
     this.steps = orderBy(steps || [], step => step.sequence)
@@ -172,7 +228,7 @@ export class ScenarioInstance {
       logger:
         context?.logger ||
         createLogger({
-          format: combine(systemTimestamp({ tz: SYSTEM_TZ }), splat(), LOGFORMAT),
+          format: combine(errors({ stack: true }), systemTimestamp({ tz: SYSTEM_TZ }), splat(), LOGFORMAT),
           transports: [
             new (transports as any).DailyRotateFile({
               filename: `logs/${domain.subdomain}/scenario-${scenarioName}-%DATE%.log`,
@@ -264,10 +320,13 @@ export class ScenarioInstance {
       const message = ex.stack ? ex.stack : ex
       const { scenarioName, domain } = this
 
-      this.context.logger.error(ex.message ? ex.message : ex)
+      this.context.logger.error(ex)
 
       debug('failed to run ', `[ Domain: ${domain.name}, Scenario: ${scenarioName} ]\n`, ex)
-      this.setState(ScenarioInstanceStatus.HALTED, typeof message == 'object' ? JSON.stringify(message, null, 2) : message)
+      this.setState(
+        ScenarioInstanceStatus.HALTED,
+        typeof message == 'object' ? JSON.stringify(message, null, 2) : message
+      )
 
       throw ex
     }
@@ -278,6 +337,26 @@ export class ScenarioInstance {
         sum[step.name] = this.context.data[step.name]
         return sum
       }, {})
+
+    const { scenarioId, scenarioTtl, variables, message, scenarioName, instanceName, result, domain } = this
+    const obj = {
+      scenarioName,
+      instanceName,
+      variables,
+      data: this.data,
+      result,
+      timestamp: new Date(),
+      message,
+      state: ScenarioInstanceStatus.STOPPED /* redundent, no meaning */
+    }
+
+    if (this.scenarioTtl && this.scenarioId) {
+      setTimeout(() => {
+        cacheService.setInCache(scenarioId, { domain: domain.id, variables: variables || {} }, obj, scenarioTtl)
+      })
+    }
+
+    return obj
   }
 
   async loadSubscenario(step, scenarioConfig, context) {
@@ -436,16 +515,23 @@ export class ScenarioInstance {
     try {
       step.params = JSON.parse(step.params)
     } catch (ex) {
-      this.context.logger.error(`params(${step.params}) parsing error. params must be a JSON.`)
+      this.context.logger.error(`params(${step.params}) parsing error. params must be a JSON.`, ex)
     }
     step.params = step.params || {}
 
-    var handler = TaskRegistry.getTaskHandler(step.task)
-    if (!handler) {
-      throw new Error(`no task handler for step '${step.name}'(${step.id})`)
-    }
+    const connection =
+      step.connection && ConnectionManager.getConnectionInstanceEntityByName(this.domain, step.connection)
 
-    var retval: any = await handler(step, context)
+    if (!connection || !connection.edgeId) {
+      var handler = TaskRegistry.getTaskHandler(step.task)
+      if (!handler) {
+        throw new Error(`no task handler for step '${step.name}'(${step.id})`)
+      }
+
+      var retval: any = await handler(step, context)
+    } else {
+      var retval: any = await edgeHandler(step, context)
+    }
 
     if (step.log) {
       var { data } = retval || {}

package/server/service/state-register/state-register-query.ts

@@ -28,7 +28,10 @@ export class StateRegisterQuery {
 
   @Directive('@privilege(category: "state-register", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => StateRegisterList, { description: 'To fetch multiple StateRegisters' })
-  async stateRegisters(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<StateRegisterList> {
+  async stateRegisters(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<StateRegisterList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({

package/server/service/state-register/state-register.ts

@@ -26,7 +26,7 @@ export class StateRegister {
   readonly id: string
 
   @ManyToOne(type => Domain)
-  @Field({ nullable: true })
+  @Field(type => Domain)
   domain?: Domain
 
   @RelationId((stateRegister: StateRegister) => stateRegister.domain)

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

@@ -18,7 +18,7 @@ export class StepQuery {
   }
 
   @Query(returns => StepList, { description: 'To fetch multiple steps' })
-  async steps(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<StepList> {
+  async steps(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<StepList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({

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

@@ -15,113 +15,115 @@ import { Domain } from '@things-factory/shell'
 
 import { Scenario } from '../scenario/scenario'
 
-
 @Entity()
 @Index('ix_step_0', (step: Step) => [step.scenario, step.sequence], { unique: true })
 @ObjectType()
 export class Step {
-  /** 
-    * The unique identifier for each step.
-    */
+  /**
+   * The unique identifier for each step.
+   */
   @PrimaryGeneratedColumn('uuid')
   @Field(type => ID)
-  readonly id: string
+  readonly id?: string
 
-  /** 
-    * The domain to which this step belongs.
-    */
+  /**
+   * The domain to which this step belongs.
+   */
   @ManyToOne(type => Domain)
-  @Field({ nullable: true })
-  domain: Domain
+  @Field(type => Domain, { nullable: true })
+  domain?: Domain
 
-  /** 
-    * The ID of the domain associated with this step.
-    */
+  /**
+   * The ID of the domain associated with this step.
+   */
   @RelationId((step: Step) => step.domain)
-  domainId: string
+  domainId?: string
 
-  /** 
-    * The name of the step.
-    */
+  /**
+   * The name of the step.
+   */
   @Column({ nullable: true })
   @Field()
-  name: string
+  name?: string
 
-  /** 
-    * A description of what the step involves.
-    */
+  /**
+   * A description of what the step involves.
+   */
   @Column({ nullable: true })
   @Field({ nullable: true })
-  description: string
+  description?: string
 
-  /** 
-    * The scenario that includes this step.
-    */
+  /**
+   * The scenario that includes this step.
+   */
   @ManyToOne(type => Scenario, scenario => scenario.steps, { onDelete: 'CASCADE' })
   @Field(type => Scenario, { nullable: true })
-  scenario: Scenario
+  scenario?: Scenario
 
-  /** 
-    * The ID of the scenario associated with this step.
-    */
+  /**
+   * The ID of the scenario associated with this step.
+   */
   @RelationId((step: Step) => step.scenario)
-  scenarioId: string
+  scenarioId?: string
 
-  /** 
-    * The sequence number of the step within its scenario.
-    */
+  /**
+   * The sequence number of the step within its scenario.
+   */
   @Column()
   @Field({ nullable: true })
-  sequence: number
+  sequence?: number
 
-  /** 
-    * The specific task associated with this step.
-    */
+  /**
+   * The specific task associated with this step.
+   */
   @Column()
   @Field({ nullable: true })
-  task: string
+  task?: string
 
-  /** 
-    * Boolean value to indicate if the step should be skipped.
-    */
+  /**
+   * Boolean value to indicate if the step should be skipped.
+   */
   @Column({ nullable: true })
   @Field({ nullable: true })
-  skip: boolean
+  skip?: boolean
 
-  /** 
-    * Boolean value to indicate if the step should be logged.
-    */
+  /**
+   * Boolean value to indicate if the step should be logged.
+   */
   @Column({ nullable: true })
   @Field({ nullable: true })
-  log: boolean
+  log?: boolean
 
-  /** 
-    * The connection details associated with this step.
-    */
+  /**
+   * The connection details associated with this step.
+   */
   @Column({ nullable: true })
   @Field({ nullable: true })
-  connection: string
+  connection?: string
 
-  /** 
-    * The parameters for the step.
-    */
+  /**
+   * The parameters for the step.
+   */
   @Column({ nullable: true })
   @Field({ nullable: true })
-  params: string
+  params?: string
 
-  /** 
-    * A boolean attribute indicating the inclusion status of an element in the result.
-    */
+  /**
+   * A boolean attribute indicating the inclusion status of an element in the result.
+   */
   @Column({ nullable: true, default: true })
-  @Field({ nullable: true, description: 'A boolean attribute indicating the inclusion status of an element in the result' })
-  result: boolean = true
+  @Field({
+    nullable: true,
+    description: 'A boolean attribute indicating the inclusion status of an element in the result'
+  })
+  result?: boolean = true
 
-  /** 
-    * The timestamp when the step was created.
-    */
+  /**
+   * The timestamp when the step was created.
+   */
   @CreateDateColumn()
   @Field({ nullable: true })
-  createdAt: Date
+  createdAt?: Date
 
   /** 
     * The timestamp when
@@ -129,33 +131,33 @@ export class Step {
   */
   @UpdateDateColumn()
   @Field({ nullable: true })
-  updatedAt: Date
+  updatedAt?: Date
 
   /**
-  * The user who created this step.
-  */
+   * The user who created this step.
+   */
   @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  creator: User
+  @Field(type => User, { nullable: true })
+  creator?: User
 
   /**
-  * The ID of the user who created this step.
-  */
+   * The ID of the user who created this step.
+   */
   @RelationId((step: Step) => step.creator)
-  creatorId: string
+  creatorId?: string
 
   /**
-  * The user who last updated this step.
-  */
+   * The user who last updated this step.
+   */
   @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  updater: User
+  @Field(type => User, { nullable: true })
+  updater?: User
 
   /**
-  * The ID of the user who last updated this step.
-  */
+   * The ID of the user who last updated this step.
+   */
   @RelationId((step: Step) => step.updater)
-  updaterId: string
+  updaterId?: string
 }
 
 @InputType()
@@ -197,7 +199,7 @@ export class StepPatch {
 /**
  * Step의 params의 원 타입과 사용 시에 타입 불일치로 인해 임시적으로 생성한 타입으로
  * 추후, 타입 일치를 통해서 제거할 예정임.
- * 
+ *
  */
 export interface InputStep extends Step {
   params: any

package/translations/en.json

@@ -1,8 +1,11 @@
 {
   "error.scenario not found": "scenario '{scenario}' not found.",
+  "error.scenario run error": "an error occurred while processing the '{scenario}' request. please contact the administrator.",
+  "error.scenario run unauthorized": "you do not have permission to run the {scenario} scenario. please contact the administrator.",
   "error.schedule is not set": "schedule should be set for the scenario '{scenario}' in order to register as a schedule",
   "error.timezone is not set": "timezone should be set for the scenario '{scenario}' in order to register as a schedule",
   "error.scenario instance not found": "scenario instance '{instance}' not found.",
   "label.auth-key": "authentication key",
-  "label.subscription-handlers": "subscription handlers"
+  "label.subscription-handlers": "subscription handlers",
+  "label.trust-server-certificate": "trust server certificate"
 }

package/translations/ja.json

@@ -1,8 +1,11 @@
 {
   "error.scenario not found": "シナリオ'{scenario}'が見つかりません.",
+  "error.scenario run error": "シナリオ '{scenario}' のリクエストを処理中にエラーが発生しました。管理者に連絡してください。",
+  "error.scenario run unauthorized": "シナリオ {scenario} を実行する権限がありません。管理者に連絡してください。",
   "error.schedule is not set": "スケジュールとして登録するためにはシナリオ'{scenario}'にスケジュール情報が設定される必要があります.",
   "error.timezone is not set": "スケジュールとして登録するためにはシナリオ'{scenario}'にタイム ゾーン情報が設定される必要があります.",
   "error.scenario instance not found": "シナリオ インスタンス'{instance}'が見つかりません. 既に終了している可能性があります.",
   "label.auth-key": "認証キー",
-  "label.subscription-handlers": "サブスクリプションハンドラー"
+  "label.subscription-handlers": "サブスクリプションハンドラー",
+  "label.trust-server-certificate": "サーバー証明書を信頼する"
 }

package/translations/ko.json

@@ -1,8 +1,11 @@
 {
   "error.scenario not found": "시나리오 '{scenario}'를 찾을 수 없습니다.",
+  "error.scenario run error": "시나리오 '{scenario}' 요청을 처리하는 중 오류가 발생했습니다. 관리자에게 문의하십시오.",
+  "error.scenario run unauthorized": "시나리오 {scenario}를 실행할 권한이 없습니다. 관리자에게 문의하십히오.",
   "error.schedule is not set": "스케쥴로 등록하기 위해서는 시나리오 '{scenario}'에 스케쥴 정보가 설정되어야 합니다.",
   "error.timezone is not set": "스케쥴로 등록하기 위해서는 시나리오 '{scenario}'에 타임존 정보가 설정되어야 합니다.",
   "error.scenario instance not found": "시나리오 인스턴스 '{instance}'를 찾을 수 없습니다. 이미 종료되었을 수 있습니다.",
   "label.auth-key": "인증 키",
-  "label.subscription-handlers": "구독 핸들러"
+  "label.subscription-handlers": "구독 핸들러",
+  "label.trust-server-certificate": "서버 인증서 신뢰"
 }