@things-factory/integration-base 7.0.1-beta.9 → 7.0.1-rc.0

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

@@ -7,6 +7,7 @@ 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'
 
@@ -87,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
@@ -106,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
 
@@ -154,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)
@@ -269,7 +323,10 @@ export class ScenarioInstance {
       this.context.logger.error(ex.message ? ex.message : 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
     }
@@ -280,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) {
@@ -442,7 +519,8 @@ export class ScenarioInstance {
     }
     step.params = step.params || {}
 
-    const connection = step.connection && ConnectionManager.getConnectionInstanceEntityByName(this.domain, step.connection)
+    const connection =
+      step.connection && ConnectionManager.getConnectionInstanceEntityByName(this.domain, step.connection)
 
     if (!connection || !connection.edgeId) {
       var handler = TaskRegistry.getTaskHandler(step.task)

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

@@ -24,89 +24,89 @@ export class Step {
    */
   @PrimaryGeneratedColumn('uuid')
   @Field(type => ID)
-  readonly id: string
+  readonly id?: string
 
   /**
    * The domain to which this step belongs.
    */
   @ManyToOne(type => Domain)
   @Field(type => Domain, { nullable: true })
-  domain: Domain
+  domain?: Domain
 
   /**
    * The ID of the domain associated with this step.
    */
   @RelationId((step: Step) => step.domain)
-  domainId: string
+  domainId?: string
 
   /**
    * The name of the step.
    */
   @Column({ nullable: true })
   @Field()
-  name: string
+  name?: string
 
   /**
    * A description of what the step involves.
    */
   @Column({ nullable: true })
   @Field({ nullable: true })
-  description: string
+  description?: string
 
   /**
    * 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.
    */
   @RelationId((step: Step) => step.scenario)
-  scenarioId: string
+  scenarioId?: string
 
   /**
    * The sequence number of the step within its scenario.
    */
   @Column()
   @Field({ nullable: true })
-  sequence: number
+  sequence?: number
 
   /**
    * 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.
    */
   @Column({ nullable: true })
   @Field({ nullable: true })
-  skip: boolean
+  skip?: boolean
 
   /**
    * 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.
    */
   @Column({ nullable: true })
   @Field({ nullable: true })
-  connection: string
+  connection?: string
 
   /**
    * 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.
@@ -116,14 +116,14 @@ export class Step {
     nullable: true,
     description: 'A boolean attribute indicating the inclusion status of an element in the result'
   })
-  result: boolean = true
+  result?: boolean = true
 
   /**
    * The timestamp when the step was created.
    */
   @CreateDateColumn()
   @Field({ nullable: true })
-  createdAt: Date
+  createdAt?: Date
 
   /** 
     * The timestamp when
@@ -131,33 +131,33 @@ export class Step {
   */
   @UpdateDateColumn()
   @Field({ nullable: true })
-  updatedAt: Date
+  updatedAt?: Date
 
   /**
    * 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.
    */
   @RelationId((step: Step) => step.creator)
-  creatorId: string
+  creatorId?: string
 
   /**
    * 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.
    */
   @RelationId((step: Step) => step.updater)
-  updaterId: string
+  updaterId?: string
 }
 
 @InputType()