@things-factory/integration-base 8.0.0-beta.1 → 8.0.0-beta.2

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

@@ -1,78 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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
-  }
-}