@things-factory/integration-base 8.0.40 → 9.0.0-9.0.0-beta.59.0

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

@@ -1,396 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import {
-  Application,
-  getCallbackBaseWithDomainContext,
-  registerSchedule,
-  unregisterSchedule
-} from '@things-factory/scheduler-client'
-
-import { Step } from '../step/step-type'
-import { Scenario } from './scenario'
-import { NewScenario, ScenarioPatch } from './scenario-type'
-
-const crypto = require('crypto')
-
-@Resolver(Scenario)
-export class ScenarioMutation {
-  @Directive('@transaction')
-  @Directive('@privilege(category: "scenario", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Scenario, { description: 'To create new scenario' })
-  async createScenario(
-    @Arg('scenario', type => NewScenario) scenario: NewScenario,
-    @Ctx() context: ResolverContext
-  ): Promise<Scenario> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(Scenario).save({
-      ...scenario,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "scenario", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Scenario, { description: 'To modify scenario information' })
-  async updateScenario(
-    @Arg('name') name: string,
-    @Arg('patch', type => ScenarioPatch) patch: ScenarioPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Scenario> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Scenario)
-    const scenario = await repository.findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-
-    if (!scenario) {
-      throw new Error(
-        context.t('error.scenario not found', {
-          scenario: name
-        })
-      )
-    }
-
-    return await repository.save({
-      ...scenario,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "scenario", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => [Scenario], { description: "To modify multiple scenarios' information" })
-  async updateMultipleScenario(
-    @Arg('patches', type => [ScenarioPatch]) patches: ScenarioPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Scenario[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const scenarioRepo = tx.getRepository(Scenario)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await scenarioRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const scenario = await scenarioRepo.findOneBy({ id: newRecord.id })
-
-        const result = await scenarioRepo.save({
-          ...scenario,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "scenario", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete scenario' })
-  async deleteScenario(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Scenario).delete({ domain: { id: domain.id }, name })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "scenario", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete multiple scenarios' })
-  async deleteScenarios(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Scenario).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "scenario", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To import multiple scenarios' })
-  async importScenarios(
-    @Arg('scenarios', type => [ScenarioPatch]) scenarios: Scenario[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { tx, domain, user } = context.state
-
-    const repository = tx.getRepository(Scenario)
-
-    await Promise.all(
-      scenarios.map(async (scenario: Scenario) => {
-        const { id, name } = scenario
-        var savedScenario
-
-        if (id) {
-          const sameId = await repository.findOneBy({ id })
-
-          if (sameId) {
-            if (sameId.domainId != domain.id) {
-              throw `Scenario with id '${id}:${name}' is already taken by another domain`
-            }
-
-            const sameName = await repository.findOneBy({ domain: { id: domain.id }, name })
-            if (sameName && sameName.id != id) {
-              throw `Scenario Name '${name}' is already taken by another scenario`
-            }
-
-            savedScenario = await repository.save({
-              ...sameId,
-              ...scenario,
-              domain,
-              updater: user
-            })
-          } else {
-            savedScenario = await repository.save({
-              ...scenario,
-              domain,
-              updater: user,
-              creator: user
-            })
-          }
-        } else {
-          savedScenario = await repository.save({
-            ...scenario,
-            domain,
-            updater: user,
-            creator: user
-          })
-        }
-
-        await tx.getRepository(Step).delete({ domain: { id: domain.id }, scenario: { id: savedScenario.id } })
-        await tx.getRepository(Step).save(
-          scenario.steps.map((step: Step) => {
-            return {
-              ...step,
-              domain,
-              scenario: savedScenario,
-              updater: user
-            }
-          })
-        )
-      })
-    )
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "scenario", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => [Scenario], { description: 'To import multiple scenarios' })
-  async copyScenarios(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<Scenario[]> {
-    const { domain, user, tx } = context.state
-
-    const originals = await tx.getRepository(Scenario).find({
-      where: {
-        id: In(ids),
-        domain: { id: domain.id }
-      },
-      relations: ['domain', 'steps']
-    })
-
-    if (originals.length == 0) {
-      return []
-    }
-
-    var newSteps = []
-
-    var newCopys = originals.map(scenario => {
-      let scenarioId = crypto.randomUUID()
-      newSteps.push(
-        ...scenario.steps.map(step => {
-          return {
-            scenario: scenarioId,
-            name: step.name,
-            description: step.description,
-            sequence: step.sequence,
-            task: step.task,
-            connection: step.connection,
-            params: step.params,
-
-            domain,
-            creator: user,
-            updater: user
-          }
-        })
-      )
-
-      return {
-        id: scenarioId,
-        name: scenario.name + ' (' + scenarioId + ')',
-        type: scenario.type,
-        description: scenario.description,
-        active: false, // deprecated
-        schedule: scenario.schedule,
-        timezone: scenario.timezone,
-
-        domain,
-        creator: user,
-        updater: user
-      }
-    })
-
-    var copiedScenarios = await tx.getRepository(Scenario).save(newCopys)
-    var copiedSteps = await tx.getRepository(Step).save(newSteps)
-
-    return copiedScenarios.map(scenario => {
-      scenario.steps = copiedSteps.filter(step => step.scenario == scenario.id)
-      return scenario
-    })
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "scenario", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Scenario, {
-    description: 'To start posting scenario based on the schedule of the given scenario'
-  })
-  async startScenarioSchedule(
-    @Arg('scenarioId') scenarioId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<Scenario> {
-    const { domain, user, tx } = context.state
-
-    var repository = tx.getRepository(Scenario)
-    var scenario = await repository.findOne({
-      where: { domain: { id: domain.id }, id: scenarioId }
-    })
-
-    if (!scenario) {
-      throw new Error(
-        context.t('error.scenario not found', {
-          scenario: scenarioId
-        })
-      )
-    }
-
-    if (!scenario.schedule) {
-      throw new Error(
-        context.t('error.schedule is not set', {
-          scenario: scenario.name
-        })
-      )
-    }
-
-    if (!scenario.timezone) {
-      throw new Error(
-        context.t('error.timezone is not set', {
-          scenario: scenario.name
-        })
-      )
-    }
-
-    try {
-      var handle = await registerSchedule({
-        name: scenario.name,
-        client: {
-          application: Application,
-          group: `${domain.id}`,
-          type: 'scenario',
-          key: scenario.id,
-          operation: 'start'
-        },
-        type: 'cron',
-        schedule: scenario.schedule,
-        timezone: scenario.timezone,
-        task: {
-          type: 'rest',
-          connection: {
-            host: `${getCallbackBaseWithDomainContext(domain)}/callback-schedule-for-scenario`,
-            headers: {
-              'Content-Type': 'application/json',
-              accept: '*/*'
-            }
-          },
-          data: {
-            domainId: domain.id,
-            userId: user.id,
-            scenarioId
-          },
-          history_check: true,
-          failed_policy: 'retry_dlq',
-          max_retry_count: -1,
-          retry_period: 60
-        }
-      })
-
-      return await repository.save({
-        ...scenario,
-        scheduleId: handle
-      })
-    } catch (err) {
-      console.error('startScenarioSchedule', err)
-    }
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "scenario", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Scenario, {
-    nullable: true,
-    description: 'To stop posting scenario based on the schedule of the given scenario'
-  })
-  async stopScenarioSchedule(
-    @Arg('scenarioId') scenarioId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<Scenario | undefined> {
-    const { domain, tx } = context.state
-
-    var repository = tx.getRepository(Scenario)
-    var scenario = await repository.findOne({
-      where: { domain: { id: domain.id }, id: scenarioId }
-    })
-
-    if (!scenario) {
-      throw new Error(
-        context.t('error.scenario not found', {
-          scenario: scenarioId
-        })
-      )
-    }
-
-    try {
-      await unregisterSchedule(scenario.scheduleId)
-
-      return await repository.save({
-        ...scenario,
-        scheduleId: null
-      })
-    } catch (err) {
-      console.error('stopScenarioSchedule', err)
-    }
-  }
-}

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

@@ -1,109 +0,0 @@
-import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { Not, IsNull } from 'typeorm'
-
-import { User, Role } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { ScenarioEngine } from '../../engine'
-import { ScenarioInstance, ScenarioInstanceStatus } from '../scenario-instance/scenario-instance-type'
-import { Step } from '../step/step-type'
-import { Scenario } from './scenario'
-import { ScenarioList } from './scenario-type'
-import { Connection } from '../connection/connection-type'
-
-@Resolver(Scenario)
-export class ScenarioQuery {
-  @Directive('@privilege(category: "scenario", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => Scenario, { description: 'To fetch a scenario' })
-  async scenario(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Scenario> {
-    const { domain } = context.state
-
-    const scenario = await getRepository(Scenario).findOne({ where: { id } })
-    if (domain.id == scenario.domainId || domain.parentId == scenario.domainId) {
-      return scenario
-    }
-  }
-
-  @Directive('@privilege(category: "scenario", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => ScenarioList, { description: 'To fetch multiple scenarios' })
-  async scenarios(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<ScenarioList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(Scenario),
-      params,
-      domain,
-      searchables: ['name', 'description', 'type']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() scenario: Scenario) {
-    return await getRepository(Domain).findOneBy({ id: scenario.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() scenario: Scenario): Promise<User> {
-    return await getRepository(User).findOneBy({ id: scenario.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() scenario: Scenario): Promise<User> {
-    return await getRepository(User).findOneBy({ id: scenario.creatorId })
-  }
-
-  @FieldResolver(type => [Step])
-  async steps(@Root() scenario: Scenario, @Ctx() context: ResolverContext): Promise<Step[]> {
-    const { domain } = context.state
-
-    return await getRepository(Step).find({
-      where: { domain: { id: domain.id }, scenario: { id: scenario.id } }
-    })
-  }
-
-  @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 => step.params?.tag).filter(Boolean)
-  }
-
-  @FieldResolver(type => String, { nullable: true })
-  async state(@Root() scenario: Scenario, @Ctx() context: ResolverContext): Promise<string> {
-    const { domain } = context.state
-
-    var instance = ScenarioEngine.getScenarioInstance(domain, scenario.name)
-    return instance && ScenarioInstanceStatus[instance.context?.state]
-  }
-
-  @FieldResolver(type => [ScenarioInstance], { nullable: true })
-  async instances(@Root() scenario: Scenario, @Ctx() context: ResolverContext): Promise<ScenarioInstance[]> {
-    const { domain } = context.state
-
-    return ScenarioEngine.getScenarioInstances(domain, scenario.name)
-  }
-
-  @FieldResolver(type => Role)
-  async role(@Root() scenario: Scenario) {
-    return scenario.roleId && (await getRepository(Role).findOneBy({ id: scenario.roleId }))
-  }
-}

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