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

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

@@ -1,87 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { Appliance, User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { ConnectionManager } from '../../engine/connection-manager'
-import { Connection, ConnectionList, ConnectionState, ConnectionStatus } from './connection-type'
-
-@Resolver(Connection)
-export class ConnectionQuery {
-  @Query(returns => Connection, { description: 'To fetch a connection' })
-  async connection(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Connection> {
-    const { domain } = context.state
-
-    var connection = await getRepository(Connection).findOne({
-      where: { domain: { id: domain.id }, name },
-      relations: ['domain']
-    })
-
-    return {
-      ...connection,
-      state: ConnectionManager.getConnectionInstance(connection)
-        ? ConnectionStatus.CONNECTED
-        : ConnectionStatus.DISCONNECTED
-    } as Connection
-  }
-
-  @Query(returns => ConnectionList, { description: 'To fetch multiple connections' })
-  async connections(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<ConnectionList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(Connection),
-      params,
-      domain,
-      alias: 'connection',
-      searchables: ['name', 'description', 'type', 'endpoint']
-    })
-
-    const [items, total] = await queryBuilder.leftJoinAndSelect('connection.domain', 'domain').getManyAndCount()
-
-    items.forEach(connection => {
-      connection['state'] = ConnectionManager.getConnectionInstance(connection)
-        ? ConnectionStatus.CONNECTED
-        : ConnectionStatus.DISCONNECTED
-    })
-
-    return { items, total }
-  }
-
-  @Query(returns => ConnectionState, { description: 'To fetch the state of a connection' })
-  fetchConnectionState(@Arg('name') name: string, @Ctx() context: ResolverContext): ConnectionState {
-    const { domain } = context.state
-
-    const connection = ConnectionManager.getConnectionInstanceEntityByName(domain, name)
-
-    return {
-      ...connection,
-      state: connection ? ConnectionStatus.CONNECTED : ConnectionStatus.DISCONNECTED
-    }
-  }
-
-  @FieldResolver(type => Domain)
-  async edge(@Root() connection: Connection) {
-    return connection.edgeId && (await getRepository(Appliance).findOneBy({ id: connection.edgeId }))
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() connection: Connection) {
-    return (
-      connection.domain || (connection.domainId && (await getRepository(Domain).findOneBy({ id: connection.domainId })))
-    )
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() connection: Connection): Promise<User> {
-    return connection.updaterId && (await getRepository(User).findOneBy({ id: connection.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() connection: Connection): Promise<User> {
-    return connection.creatorId && (await getRepository(User).findOneBy({ id: connection.creatorId }))
-  }
-}

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

@@ -1,104 +0,0 @@
-import { filter, pipe } from 'graphql-yoga'
-import { Arg, Resolver, Root, Subscription } from 'type-graphql'
-
-import { getRepository, Log, pubsub } from '@things-factory/shell'
-
-import { ConnectionManager } from '../../engine/connection-manager'
-import { Connection, ConnectionState, ConnectionStatus } from './connection-type'
-
-const debug = require('debug')('things-factory:integration:connection-subscription')
-
-@Resolver(Connection)
-export class ConnectionSubscription {
-  @Subscription({
-    subscribe: ({ args, context, info }) => {
-      const { domain, user } = context.state
-      const { name } = args
-      const subdomain = domain?.subdomain
-
-      debug('subscribe', subdomain)
-      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(async () => {
-        var where = { domain: { id: domain.id } }
-        if (name) {
-          where['name'] = name
-        }
-
-        var connections = await getRepository(Connection).find({
-          where,
-          relations: ['domain', 'edge']
-        })
-
-        connections.forEach(connection => {
-          pubsub.publish('connection-state', {
-            connectionState: {
-              ...connection,
-              state: ConnectionManager.getConnectionInstance(connection) ? ConnectionStatus.CONNECTED : ConnectionStatus.DISCONNECTED,
-              timestamp: new Date()
-            }
-          })
-        })
-      })
-
-      return pipe(
-        pubsub.subscribe('connection-state'),
-        filter(async (payload: { connectionState: ConnectionState }) => {
-          const { domain: pdomain, name: pname } = payload.connectionState
-
-          return (!name || name === pname) && subdomain === pdomain?.subdomain
-        })
-      )
-    }
-  })
-  connectionState(@Root() payload: { connectionState: ConnectionState }, @Arg('name', { nullable: true }) name: string): ConnectionState {
-    return payload.connectionState
-  }
-
-  @Subscription({
-    subscribe: ({ args, context, info }) => {
-      const { domain, user } = context.state
-      const { level } = args
-
-      const subdomain = domain?.subdomain
-
-      debug('subscribe', subdomain)
-
-      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('connection-log'),
-        filter(async (payload: { log: Log }) => {
-          // TODO support domain filtering
-          const { /* source, */ level: plevel } = payload.log
-          // const { domain: pdomain } = source
-
-          // if (subdomain !== pdomain?.subdomain) {
-          //   return false
-          // }
-
-          if (level && level !== plevel) {
-            return false
-          }
-
-          return true
-        })
-      )
-    }
-  })
-  connectionLog(@Root() payload: { log: Log }, @Arg('level', { nullable: true }) level: string): Log {
-    return payload.log
-  }
-}

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]
-