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

package/server/service/payload-log/payload-log.ts

@@ -0,0 +1,100 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+
+import { config } from '@things-factory/env'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+export enum PayloadType {
+  INGESTION = 'ingestion',
+  EGESTION = 'egestion'
+}
+@Entity()
+@Index('ix_payload_log_0', (payloadLog: PayloadLog) => [payloadLog.domain])
+@Index('ix_payload_log_1', (payloadLog: PayloadLog) => [payloadLog.domain, payloadLog.endpoint])
+@ObjectType({ description: 'Entity for PayloadLog' })
+export class PayloadLog {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((payloadLog: PayloadLog) => payloadLog.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({
+    nullable: true,
+    type:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'enum'
+        : DATABASE_TYPE == 'oracle'
+          ? 'varchar2'
+          : DATABASE_TYPE == 'mssql'
+            ? 'nvarchar'
+            : 'varchar',
+    enum:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? PayloadType : undefined,
+    length: DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? undefined : 32,
+    default: PayloadType.EGESTION
+  })
+  @Field(type => String)
+  type: PayloadType
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  src: string
+
+  @Column()
+  @Field()
+  endpoint: string
+
+  @Column()
+  @Field()
+  request: string
+
+  @Column()
+  @Field()
+  response: 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((payloadLog: PayloadLog) => payloadLog.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((payloadLog: PayloadLog) => payloadLog.updater)
+  updaterId?: string
+}

package/server/service/property-spec.ts

@@ -0,0 +1,24 @@
+import { Field, ObjectType } from 'type-graphql'
+
+import { ScalarObject } from '@things-factory/shell'
+
+@ObjectType()
+export class PropertySpec {
+  @Field()
+  type: string
+
+  @Field()
+  label: string
+
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  placeholder?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  property?: { [key: string]: any }
+
+  @Field(type => ScalarObject, { nullable: true })
+  styles?: { [key: string]: any }
+}

package/server/service/scenario/index.ts

@@ -0,0 +1,6 @@
+import { Scenario } from './scenario'
+import { ScenarioQuery } from './scenario-query'
+import { ScenarioMutation } from './scenario-mutation'
+
+export const entities = [Scenario]
+export const resolvers = [ScenarioQuery, ScenarioMutation]

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

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

@@ -0,0 +1,109 @@
+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 => JSON.parse(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 }))
+  }
+}