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

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

@@ -0,0 +1,288 @@
+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 { logger } from '@things-factory/env'
+import { Domain, ObjectRef } from '@things-factory/shell'
+
+import { ConnectionManager } from '../../engine'
+import { ProxyConnector } from '../../engine/connector/proxy-connector'
+
+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.
+   */
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  params: string
+
+  /**
+   * 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)
+    var params = {}
+
+    try {
+      params = JSON.parse(this.params || '{}')
+    } catch (ex) {
+      logger.error(`connection '${this.name}' params should be JSON format`, ex)
+    }
+
+    await connector.connect({
+      ...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({ nullable: true })
+  params?: string
+}
+
+@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({ nullable: true })
+  params?: string
+
+  @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

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

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

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

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

package/server/service/index.ts

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

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

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

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

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