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

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

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

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

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

@@ -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 }))
-  }
-}