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

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

@@ -1,305 +0,0 @@
-import { Field, ID, InputType, Int, ObjectType, registerEnumType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User, Appliance } from '@things-factory/auth-base'
-import { config } from '@things-factory/env'
-import { Domain, ObjectRef, ScalarObject } from '@things-factory/shell'
-
-import { ConnectionManager } from '../../engine'
-import { ProxyConnector } from '../../engine/connector/proxy-connector'
-
-const ORMCONFIG = config.get('ormconfig', {})
-const DATABASE_TYPE = ORMCONFIG.type
-
-export enum ConnectionStatus {
-  CONNECTED = 'CONNECTED',
-  DISCONNECTED = 'DISCONNECTED'
-}
-
-registerEnumType(ConnectionStatus, {
-  name: 'ConnectionStatus',
-  description: 'state enumeration of a connection'
-})
-
-@Entity()
-@Index('ix_connection_0', (connection: Connection) => [connection.domain, connection.name], { unique: true })
-@ObjectType()
-export class Connection {
-  /**
-   * Unique identifier for the connection, generated in UUID format.
-   */
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  /**
-   * Many-to-One relationship with the Domain entity.
-   */
-  @ManyToOne(type => Domain)
-  @Field(type => Domain, { nullable: true })
-  domain: Domain
-
-  /**
-   * Stores the ID of the associated Domain.
-   */
-  @RelationId((connection: Connection) => connection.domain)
-  domainId: string
-
-  /**
-   * The name of the connection.
-   */
-  @Column()
-  @Field()
-  name: string
-
-  /**
-   * Optional description for the connection.
-   */
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  description: string
-
-  /**
-   * The type of the connection.
-   */
-  @Column()
-  @Field({ nullable: true })
-  type: string
-
-  /**
-   * Many-to-One relationship with the Appliance entity which delegate the connection. Optional field.
-   */
-  @ManyToOne(type => Appliance, { nullable: true })
-  @Field({ nullable: true })
-  edge: Appliance
-
-  /**
-   * Stores the ID of the Appliance who delegate the connection.
-   */
-  @RelationId((connection: Connection) => connection.edge)
-  edgeId: string
-
-  /**
-   * The endpoint for the connection.
-   */
-  @Column()
-  @Field({ nullable: true })
-  endpoint: string
-
-  /**
-   * Indicates the active status of the connection.
-   */
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  active: boolean
-
-  /**
-   * The status of the connection, using the ConnectionStatus type.
-   */
-  @Field({ nullable: true })
-  state: ConnectionStatus
-
-  /**
-   * Additional parameters for the connection, stored as a JSON string.
-   *
-   * [Caution]
-   * 이 컬럼타입은 postgres 데이터베이스에서는 varchar 타입을 유지한다.
-   * 이는 데이터베이스 타입을 변경하면 기존 데이터가 손실될 수 있기 때문이다.
-   * 'simple-json' 타입으로 변경 전에 postgres 데이타베이스에 이미 varchar 타입으로 사용한 사례가 많기 때문이다.
-   */
-  @Column({
-    type: DATABASE_TYPE == 'postgres' ? 'varchar' : 'simple-json',
-    nullable: true,
-    transformer:
-      DATABASE_TYPE == 'postgres'
-        ? {
-            to: (value: any) => JSON.stringify(value),
-            from: (value: string) => {
-              try {
-                return JSON.parse(value)
-              } catch (error) {
-                return null
-              }
-            }
-          }
-        : undefined
-  })
-  @Field(type => ScalarObject, { nullable: true })
-  params: { [key: string]: any }
-
-  /**
-   * The date and time when the connection was created.
-   */
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt: Date
-
-  /**
-   * The date and time when the connection was last updated.
-   */
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt: Date
-
-  /**
-   * Many-to-One relationship with the User entity who created the connection. Optional field.
-   */
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  creator: User
-
-  /**
-   * Stores the ID of the User who created the connection.
-   */
-  @RelationId((connection: Connection) => connection.creator)
-  creatorId: string
-
-  /**
-   * Many-to-One relationship with the User entity who last updated the connection.
-   * Optional field.
-   */
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  updater: User
-
-  /**
-   * Stores the ID of the User who last updated the connection.
-   *
-   */
-  @RelationId((connection: Connection) => connection.updater)
-  updaterId: string
-
-  /**
-   * Asynchronous method to establish the connection.
-   *
-   */
-  async connect() {
-    const { type, edge } = this
-    const connector = edge ? ProxyConnector.instance : ConnectionManager.getConnector(type)
-
-    await connector.connect({
-      ...this,
-      params: this.params || {}
-    })
-  }
-
-  /**
-   * @brief Asynchronous method to disconnect the connection.
-   *
-   */
-  async disconnect() {
-    try {
-      const { type, edge } = this
-      const connector = edge ? ProxyConnector.instance : ConnectionManager.getConnector(type)
-      await connector.disconnect(this)
-    } finally {
-    }
-  }
-}
-
-/**
- * Connection의 params의 원 타입과 사용 시에 타입 불일치로 인해 임시적으로 생성한 타입으로
- * 추후, 타입 일치를 통해서 제거할 예정임.
- *
- */
-export interface InputConnection extends Connection {
-  params: any
-}
-
-@ObjectType()
-export class ConnectionState {
-  @Field(type => Domain)
-  domain?: Domain
-
-  @Field({ nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  type?: string
-
-  @Field(type => Appliance, { nullable: true })
-  edge?: Appliance
-
-  @Field({ nullable: true })
-  state?: ConnectionStatus
-
-  @Field({ nullable: true })
-  timestamp?: Date
-}
-
-@InputType()
-export class NewConnection {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  type?: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  edge?: Appliance
-
-  @Field({ nullable: true })
-  endpoint?: string
-
-  @Field(type => ScalarObject, { nullable: true })
-  params?: { [key: string]: any }
-}
-
-@InputType()
-export class ConnectionPatch {
-  @Field(type => ID, { nullable: true })
-  id: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  type?: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  edge?: Appliance
-
-  @Field({ nullable: true })
-  endpoint?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field(type => ScalarObject, { nullable: true })
-  params?: { [key: string]: any }
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class ConnectionList {
-  @Field(type => [Connection])
-  items: Connection[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/connection/index.ts

@@ -1,7 +0,0 @@
-import { Connection } from './connection-type'
-import { ConnectionQuery } from './connection-query'
-import { ConnectionMutation } from './connection-mutation'
-import { ConnectionSubscription } from './connection-subscription'
-
-export const entities = [Connection]
-export const resolvers = [ConnectionQuery, ConnectionMutation, ConnectionSubscription]

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

@@ -1,62 +0,0 @@
-import { Arg, Ctx, Query, Resolver } from 'type-graphql'
-
-import { getRepository } from '@things-factory/shell'
-
-import { ConnectionManager } from '../../engine/connection-manager'
-import { Connection } from '../connection/connection-type'
-import { ConnectorList, ConnectorType } from './connector-type'
-
-@Resolver(ConnectorType)
-export class ConnectorQuery {
-  @Query(returns => ConnectorType, { description: 'To fetch a connector' })
-  async connection(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ConnectorType> {
-    // @ts-ignore
-    const { description, help, parameterSpec, taskPrefixes } = ConnectionManager.getConnector(name) || {}
-
-    return {
-      name,
-      description,
-      help,
-      parameterSpec,
-      taskPrefixes: taskPrefixes || []
-    }
-  }
-
-  @Query(returns => ConnectorList, { description: 'To fetch multiple connector' })
-  async connectors(): Promise<ConnectorList> {
-    var connectors = ConnectionManager.getConnectors()
-    var items = Object.keys(connectors)
-      .map(name => {
-        var connector = connectors[name]
-        return {
-          name,
-          description: connector.description,
-          help: connector.help,
-          parameterSpec: connector.parameterSpec,
-          taskPrefixes: connector.taskPrefixes || []
-        }
-      })
-      .sort((x, y) => {
-        return x.name < y.name ? -1 : 1
-      })
-
-    return {
-      items,
-      total: items.length
-    }
-  }
-
-  @Query(returns => ConnectorType, { description: 'To fetch the connector from a connection' })
-  async connectorByConnection(
-    @Arg('connectionName') connectionName: string,
-    @Ctx() context: ResolverContext
-  ): Promise<ConnectorType> {
-    const { domain } = context.state
-
-    var connection = await getRepository(Connection).findOne({
-      where: { domain: { id: domain.id }, name: connectionName }
-    })
-
-    return connection && (ConnectionManager.getConnector(connection.type) as any)
-  }
-}

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

@@ -1,29 +0,0 @@
-import { ObjectType, Field, Int } from 'type-graphql'
-import { PropertySpec } from '../property-spec'
-
-@ObjectType()
-export class ConnectorType {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field({ nullable: true })
-  help?: string
-
-  @Field(type => [PropertySpec], { nullable: true })
-  parameterSpec: PropertySpec[]
-
-  @Field(type => [String], { nullable: true })
-  taskPrefixes?: string[]
-}
-
-@ObjectType()
-export class ConnectorList {
-  @Field(type => [ConnectorType])
-  items: ConnectorType[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/connector/index.ts

@@ -1,4 +0,0 @@
-import { ConnectorQuery } from './connector-query'
-
-export const entities = []
-export const resolvers = [ConnectorQuery]

package/server/service/index.ts

@@ -1,52 +0,0 @@
-import { entities as ConnectionEntities, resolvers as ConnectionResolvers } from './connection'
-import { entities as ConnectorEntities, resolvers as ConnectorResolvers } from './connector'
-import { entities as ScenarioEntities, resolvers as ScenarioResolvers } from './scenario'
-import { entities as ScenarioInstanceEntities, resolvers as ScenarioInstanceResolvers } from './scenario-instance'
-import { entities as ScenarioQueueEntities, resolvers as ScenarioQueueResolvers } from './scenario-queue'
-import { entities as StepEntities, resolvers as StepResolvers } from './step'
-import { entities as TaskTypeEntities, resolvers as TaskTypeResolvers } from './task-type'
-import { entities as PayloadLogEntities, resolvers as PayloadLogResolvers } from './payload-log'
-import { entities as StateRegisterEntities, resolvers as StateRegisterResolvers } from './state-register'
-import { resolvers as IntegrationAnalysisQuery } from './analysis'
-
-export * from './property-spec'
-export * from './task-type/task-type-type'
-export * from './connector/connector-type'
-export * from './connection/connection-type'
-export * from './scenario/scenario'
-export * from './scenario-instance/scenario-instance-type'
-export * from './scenario-queue/scenario-queue-type'
-export * from './step/step-type'
-export * from './scenario-flow/scenario-flow'
-export * from './payload-log/payload-log'
-export * from './state-register/state-register'
-
-export const entities = [
-  ...TaskTypeEntities,
-  ...ConnectorEntities,
-  ...ConnectionEntities,
-  ...ScenarioEntities,
-  ...ScenarioInstanceEntities,
-  ...ScenarioQueueEntities,
-  ...StepEntities,
-  ...PayloadLogEntities,
-  ...StateRegisterEntities
-]
-
-export const schema = {
-  resolverClasses: [
-    ...TaskTypeResolvers,
-    ...ConnectorResolvers,
-    ...ConnectionResolvers,
-    ...ScenarioResolvers,
-    ...ScenarioInstanceResolvers,
-    ...ScenarioQueueResolvers,
-    ...StepResolvers,
-    ...PayloadLogResolvers,
-    ...IntegrationAnalysisQuery,
-    ...StateRegisterResolvers
-  ]
-}
-
-export { PayloadType } from './payload-log/payload-log'
-export { createPayloadLog } from './payload-log/payload-log-mutation'

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

@@ -1,7 +0,0 @@
-import { PayloadLog } from './payload-log'
-import { PayloadLogQuery } from './payload-log-query'
-import { PayloadLogMutation } from './payload-log-mutation'
-
-export const entities = [PayloadLog]
-export const resolvers = [PayloadLogQuery, PayloadLogMutation]
-

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

@@ -1,151 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { logger } from '@things-factory/env'
-import { Domain, getRepository } from '@things-factory/shell'
-
-import { PayloadLog, PayloadType } from './payload-log'
-import { NewPayloadLog, PayloadLogPatch } from './payload-log-type'
-
-@Resolver(PayloadLog)
-export class PayloadLogMutation {
-  @Directive('@transaction')
-  @Mutation(returns => PayloadLog, { description: 'To create new PayloadLog' })
-  async createPayloadLog(
-    @Arg('payloadLog') payloadLog: NewPayloadLog,
-    @Ctx() context: ResolverContext
-  ): Promise<PayloadLog> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(PayloadLog).save({
-      ...payloadLog,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => PayloadLog, { description: 'To modify PayloadLog information' })
-  async updatePayloadLog(
-    @Arg('id') id: string,
-    @Arg('patch') patch: PayloadLogPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<PayloadLog> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(PayloadLog)
-    const payloadLog = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    return await repository.save({
-      ...payloadLog,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [PayloadLog], { description: "To modify multiple PayloadLogs' information" })
-  async updateMultiplePayloadLog(
-    @Arg('patches', type => [PayloadLogPatch]) patches: PayloadLogPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<PayloadLog[]> {
-    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 payloadLogRepo = tx.getRepository(PayloadLog)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await payloadLogRepo.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 payloadLog = await payloadLogRepo.findOneBy({ id: newRecord.id })
-
-        const result = await payloadLogRepo.save({
-          ...payloadLog,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete PayloadLog' })
-  async deletePayloadLog(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(PayloadLog).delete({ domain: { id: domain.id }, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple payloadLogs' })
-  async deletePayloadLogs(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(PayloadLog).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-}
-
-export async function createPayloadLog(
-  name: string,
-  endpoint: string,
-  request: string,
-  response: string,
-  context: any,
-  type: PayloadType = PayloadType.EGESTION,
-  src: string = null
-): Promise<void> {
-  try {
-    const { domain, user }: { domain: Domain; user: User } = context?.state
-
-    // disabled due to high db server usage
-    await getRepository(PayloadLog).save({
-      name,
-      domain,
-      endpoint,
-      request,
-      response,
-      type,
-      src,
-      createdBy: user,
-      updatedBy: user,
-      createdAt: new Date(),
-      updatedAt: new Date()
-    })
-  } catch (error) {
-    logger.error(`PayloadLog Error`, error)
-  }
-}

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

@@ -1,49 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, getRepository, ListParam } from '@things-factory/shell'
-
-import { PayloadLog } from './payload-log'
-import { PayloadLogList } from './payload-log-type'
-
-@Resolver(PayloadLog)
-export class PayloadLogQuery {
-  @Query(returns => PayloadLog, { description: 'To fetch a PayloadLog' })
-  async payloadLog(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<PayloadLog> {
-    const { domain } = context.state
-
-    return await getRepository(PayloadLog).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => PayloadLogList, { description: 'To fetch multiple PayloadLogs' })
-  async payloadLogs(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<PayloadLogList> {
-    const { domain } = context.state
-
-    const convertedParams = convertListParams(params, {
-      domain
-    })
-    const [items, total] = await getRepository(PayloadLog).findAndCount(convertedParams)
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() payloadLog: PayloadLog): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: payloadLog.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() payloadLog: PayloadLog): Promise<User> {
-    return await getRepository(User).findOneBy({ id: payloadLog.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() payloadLog: PayloadLog): Promise<User> {
-    return await getRepository(User).findOneBy({ id: payloadLog.creatorId })
-  }
-}

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

@@ -1,36 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
-
-import { PayloadLog } from './payload-log'
-
-@InputType()
-export class NewPayloadLog {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-}
-
-@InputType()
-export class PayloadLogPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field()
-  cuFlag: string
-}
-
-@ObjectType()
-export class PayloadLogList {
-  @Field(type => [PayloadLog])
-  items: PayloadLog[]
-
-  @Field(type => Int)
-  total: number
-}