@things-factory/integration-base 7.0.0-alpha.8 → 7.0.1-alpha.0

package/server/engine/edge-client.ts

@@ -0,0 +1,45 @@
+import { Connection } from '../service/connection/connection-type'
+import { Step } from '../service/step/step-type'
+import { Context, TaskHandler } from './types'
+
+export type EdgeClient = {
+  handler: TaskHandler
+  syncConnections(connections: Connection[], context?: ResolverContext): Promise<any>
+  connectConnections(connections: Connection[], context?: ResolverContext): Promise<any>
+  disconnectConnections(connections: Connection[], context?: ResolverContext): Promise<any>
+}
+
+var edgeClient: EdgeClient = {
+  async handler(step: Step, scenarioContext: Context) {
+    throw 'edgeClient not supported'
+  },
+  async syncConnections(connections: Connection[], context: ResolverContext): Promise<any> {
+    throw 'edgeClient not supported'
+  },
+  async connectConnections(connections: Connection[], context: ResolverContext): Promise<any> {
+    throw 'edgeClient not supported'
+  },
+  async disconnectConnections(connections: Connection[], context: ResolverContext): Promise<any> {
+    throw 'edgeClient not supported'
+  }
+}
+
+export async function handler(step: Step, scenarioContext: Context) {
+  return await edgeClient.handler(step, scenarioContext)
+}
+
+export async function syncConnections(connections: Connection[], context?: ResolverContext): Promise<any> {
+  return await edgeClient.syncConnections(connections, context)
+}
+
+export async function connectConnections(connections: Connection[], context?: ResolverContext): Promise<any> {
+  return await edgeClient.connectConnections(connections, context)
+}
+
+export async function disconnectConnections(connections: Connection[], context?: ResolverContext): Promise<any> {
+  return await edgeClient.disconnectConnections(connections, context)
+}
+
+export function setEdgeClient(edge: EdgeClient) {
+  edgeClient = edge
+}

package/server/engine/index.ts

@@ -5,5 +5,6 @@ export * from './connection-manager'
 export * from './scenario-engine'
 export * from './task-registry'
 export * from './analyzer/analyze-integration'
+export * from './edge-client'
 
 export { Connector } from './types'

package/server/engine/task/script.ts

@@ -19,6 +19,7 @@ async function Script(step: InputStep, context: Context) {
       domain,
       user,
       lng,
+      logger,
       data,
       variables
     }

package/server/engine/types.ts

@@ -13,79 +13,79 @@ export interface Connector {
 }
 
 export type Context = {
-  /** 
-    * Represents the domain context.
-    */
+  /**
+   * Represents the domain context.
+   */
   domain: Domain
 
-  /** 
-    * User information.
-    */
+  /**
+   * User information.
+   */
   user: User
 
-  /** 
-    * Language code, for example 'en', 'ko'.
-    */
+  /**
+   * Language code, for example 'en', 'ko'.
+   */
   lng: string
 
-  /** 
-    * Flag to indicate if the IP is unsafe, can be undefined.
-    */
+  /**
+   * Flag to indicate if the IP is unsafe, can be undefined.
+   */
   unsafeIP: boolean | undefined
 
-  /** 
-    * List of prohibited privileges, can be undefined.
-    */
+  /**
+   * List of prohibited privileges, can be undefined.
+   */
   prohibitedPrivileges: { category: string; privilege: string }[] | undefined
 
-  /** 
-    * Logger for logging purposes.
-    */
+  /**
+   * Logger for logging purposes.
+   */
   logger: any
 
-  /** 
-    * Function to publish events or messages.
-    */
+  /**
+   * Function to publish events or messages.
+   */
   publish: Function
 
-  /** 
-    * Function to load resources or data.
-    */
+  /**
+   * Function to load resources or data.
+   */
   load: Function
 
-  /** 
-    * Current status of the scenario instance.
-    */
+  /**
+   * Current status of the scenario instance.
+   */
   state: ScenarioInstanceStatus
 
-  /** 
-    * General data storage object.
-    */
+  /**
+   * General data storage object.
+   */
   data: any
 
-  /** 
-    * Variables related to the context.
-    */
+  /**
+   * Variables related to the context.
+   */
   variables: Object
 
-  /** 
-    * Local GraphQL client object.
-    */
+  /**
+   * Local GraphQL client object.
+   */
   client: any /* graphql local client */
 
-  /** 
-    * Root object, can be used for various purposes.
-    */
+  /**
+   * Root object, can be used for various purposes.
+   */
   root: Object
 
-  /** 
-    * Array of function closures.
-    */
+  /**
+   * Array of function closures.
+   */
   closures: Function[]
 
-  /** 
-    * Function to check the state.
-    */
+  /**
+   * Function to check the state.
+   */
   checkState: Function
 
   /**
@@ -104,7 +104,6 @@ export type Context = {
   __csv_resources?: any
 }
 
-
 export type TaskHandler = (
   step: Step,
   context: Context

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

@@ -10,10 +10,7 @@ import { Connection, ConnectionPatch, ConnectionStatus, NewConnection } from './
 export class ConnectionMutation {
   @Directive('@transaction')
   @Mutation(returns => Connection, { description: 'To create new connection' })
-  async createConnection(
-    @Arg('connection') connection: NewConnection,
-    @Ctx() context: ResolverContext
-  ): Promise<Connection> {
+  async createConnection(@Arg('connection') connection: NewConnection, @Ctx() context: ResolverContext): Promise<Connection> {
     const { domain, user, tx } = context.state
 
     return await tx.getRepository(Connection).save({
@@ -26,11 +23,7 @@ export class ConnectionMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Connection, { description: 'To modify connection information' })
-  async updateConnection(
-    @Arg('name') name: string,
-    @Arg('patch') patch: ConnectionPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Connection> {
+  async updateConnection(@Arg('name') name: string, @Arg('patch') patch: ConnectionPatch, @Ctx() context: ResolverContext): Promise<Connection> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(Connection)
@@ -47,10 +40,7 @@ export class ConnectionMutation {
 
   @Directive('@transaction')
   @Mutation(returns => [Connection], { description: "To modify multiple connections' information" })
-  async updateMultipleConnection(
-    @Arg('patches', type => [ConnectionPatch]) patches: ConnectionPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Connection[]> {
+  async updateMultipleConnection(@Arg('patches', type => [ConnectionPatch]) patches: ConnectionPatch[], @Ctx() context: ResolverContext): Promise<Connection[]> {
     const { domain, user, tx } = context.state
 
     let results = []
@@ -102,10 +92,7 @@ export class ConnectionMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple connections' })
-  async deleteConnections(
-    @Arg('names', type => [String]) names: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
+  async deleteConnections(@Arg('names', type => [String]) names: string[], @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(Connection).delete({
@@ -122,7 +109,7 @@ export class ConnectionMutation {
     var repository = getRepository(Connection)
     var connection = await repository.findOne({
       where: { domain: { id: domain.id }, name },
-      relations: ['domain']
+      relations: ['domain', 'edge']
     })
 
     await connection.connect()
@@ -130,9 +117,7 @@ export class ConnectionMutation {
 
     return {
       ...connection,
-      state: ConnectionManager.getConnectionInstance(connection)
-        ? ConnectionStatus.CONNECTED
-        : ConnectionStatus.DISCONNECTED
+      state: ConnectionManager.getConnectionInstance(connection) ? ConnectionStatus.CONNECTED : ConnectionStatus.DISCONNECTED
     } as Connection
   }
 
@@ -143,7 +128,7 @@ export class ConnectionMutation {
     var repository = getRepository(Connection)
     var connection = await repository.findOne({
       where: { domain: { id: domain.id }, name },
-      relations: ['domain']
+      relations: ['domain', 'edge']
     })
 
     await connection.disconnect()
@@ -151,19 +136,14 @@ export class ConnectionMutation {
 
     return {
       ...connection,
-      state: ConnectionManager.getConnectionInstance(connection)
-        ? ConnectionStatus.CONNECTED
-        : ConnectionStatus.DISCONNECTED
+      state: ConnectionManager.getConnectionInstance(connection) ? ConnectionStatus.CONNECTED : ConnectionStatus.DISCONNECTED
     }
   }
 
   @Directive('@transaction')
   // @Directive('@privilege(category: "connection", privilege: "mutation", domainOwnerGranted: true)')
   @Mutation(returns => Boolean, { description: 'To import multiple connections' })
-  async importConnections(
-    @Arg('connections', type => [ConnectionPatch]) connections: Connection[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
+  async importConnections(@Arg('connections', type => [ConnectionPatch]) connections: Connection[], @Ctx() context: ResolverContext): Promise<boolean> {
     const { tx, domain, user } = context.state
 
     const repository = tx.getRepository(Connection)

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

@@ -1,6 +1,6 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
 
-import { User } from '@things-factory/auth-base'
+import { Appliance, User } from '@things-factory/auth-base'
 import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
 
 import { ConnectionManager } from '../../engine/connection-manager'
@@ -19,9 +19,7 @@ export class ConnectionQuery {
 
     return {
       ...connection,
-      state: ConnectionManager.getConnectionInstance(connection)
-        ? ConnectionStatus.CONNECTED
-        : ConnectionStatus.DISCONNECTED
+      state: ConnectionManager.getConnectionInstance(connection) ? ConnectionStatus.CONNECTED : ConnectionStatus.DISCONNECTED
     } as Connection
   }
 
@@ -40,9 +38,7 @@ export class ConnectionQuery {
     const [items, total] = await queryBuilder.leftJoinAndSelect('connection.domain', 'domain').getManyAndCount()
 
     items.forEach(connection => {
-      connection['state'] = ConnectionManager.getConnectionInstance(connection)
-        ? ConnectionStatus.CONNECTED
-        : ConnectionStatus.DISCONNECTED
+      connection['state'] = ConnectionManager.getConnectionInstance(connection) ? ConnectionStatus.CONNECTED : ConnectionStatus.DISCONNECTED
     })
 
     return { items, total }
@@ -52,26 +48,31 @@ export class ConnectionQuery {
   fetchConnectionState(@Arg('name') name: string, @Ctx() context: ResolverContext): ConnectionState {
     const { domain } = context.state
 
-    var connection = ConnectionManager.getConnectionInstanceByName(domain, name)
+    const connection = ConnectionManager.getConnectionInstanceEntityByName(domain, name)
 
     return {
-      name,
+      ...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 || (await getRepository(Domain).findOneBy({ id: connection.domainId }))
+    return connection.domain || (connection.domainId && (await getRepository(Domain).findOneBy({ id: connection.domainId })))
   }
 
   @FieldResolver(type => User)
   async updater(@Root() connection: Connection): Promise<User> {
-    return await getRepository(User).findOneBy({ id: connection.updaterId })
+    return connection.updaterId && (await getRepository(User).findOneBy({ id: connection.updaterId }))
   }
 
   @FieldResolver(type => User)
   async creator(@Root() connection: Connection): Promise<User> {
-    return await getRepository(User).findOneBy({ id: connection.creatorId })
+    return connection.creatorId && (await getRepository(User).findOneBy({ id: connection.creatorId }))
   }
 }

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

@@ -33,7 +33,7 @@ export class ConnectionSubscription {
 
         var connections = await getRepository(Connection).find({
           where,
-          relations: ['domain']
+          relations: ['domain', 'edge']
         })
 
         connections.forEach(connection => {

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

@@ -1,20 +1,12 @@
 import { Field, ID, InputType, Int, ObjectType, registerEnumType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
+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 } from '@things-factory/shell'
+import { Domain, ObjectRef } from '@things-factory/shell'
 
 import { ConnectionManager } from '../../engine'
+import { ProxyConnector } from '../../engine/connector/proxy-connector'
 
 export enum ConnectionStatus {
   CONNECTED = 'CONNECTED',
@@ -30,34 +22,34 @@ registerEnumType(ConnectionStatus, {
 @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({ 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({
@@ -66,72 +58,81 @@ export class Connection {
   @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
-  })
+  @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
-  })
+  @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.
    */
@@ -141,17 +142,18 @@ export class Connection {
 
   /**
    * 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() {
-    var connector = ConnectionManager.getConnector(this.type)
+    const { type, edge } = this
+    const connector = edge ? ProxyConnector.instance : ConnectionManager.getConnector(type)
     var params = {}
 
     try {
@@ -168,11 +170,12 @@ export class Connection {
 
   /**
    * @brief Asynchronous method to disconnect the connection.
-   * 
+   *
    */
   async disconnect() {
     try {
-      var connector = ConnectionManager.getConnector(this.type)
+      const { type, edge } = this
+      const connector = edge ? ProxyConnector.instance : ConnectionManager.getConnector(type)
       await connector.disconnect(this)
     } finally {
     }
@@ -182,10 +185,10 @@ export class Connection {
 /**
  * Connection의 params의 원 타입과 사용 시에 타입 불일치로 인해 임시적으로 생성한 타입으로
  * 추후, 타입 일치를 통해서 제거할 예정임.
- * 
+ *
  */
 export interface InputConnection extends Connection {
-  params: any;
+  params: any
 }
 
 @ObjectType()
@@ -205,6 +208,9 @@ export class ConnectionState {
   @Field({ nullable: true })
   type?: string
 
+  @Field(type => Appliance, { nullable: true })
+  edge?: Appliance
+
   @Field({ nullable: true })
   state?: ConnectionStatus
 
@@ -223,6 +229,9 @@ export class NewConnection {
   @Field({ nullable: true })
   type?: string
 
+  @Field(type => ObjectRef, { nullable: true })
+  edge?: Appliance
+
   @Field({ nullable: true })
   endpoint?: string
 
@@ -244,6 +253,9 @@ export class ConnectionPatch {
   @Field({ nullable: true })
   type?: string
 
+  @Field(type => ObjectRef, { nullable: true })
+  edge?: Appliance
+
   @Field({ nullable: true })
   endpoint?: string
 

package/server/service/scenario-instance/scenario-instance-type.ts

@@ -10,9 +10,11 @@ import { Domain, pubsub, PubSubLogTransport, ScalarObject } from '@things-factor
 import { User } from '@things-factory/auth-base'
 import { sleep } from '@things-factory/utils'
 
+import { ConnectionManager } from '../../engine/connection-manager'
 import { TaskRegistry } from '../../engine'
 import { Context } from '../../engine/types'
 import { Step } from '../step/step-type'
+import { handler as edgeHandler } from '../../engine/edge-client'
 
 const debug = require('debug')('things-factory:integration-base:scenario-instance')
 const { combine, timestamp, splat, printf } = format
@@ -440,12 +442,18 @@ export class ScenarioInstance {
     }
     step.params = step.params || {}
 
-    var handler = TaskRegistry.getTaskHandler(step.task)
-    if (!handler) {
-      throw new Error(`no task handler for step '${step.name}'(${step.id})`)
-    }
+    const connection = step.connection && ConnectionManager.getConnectionInstanceEntityByName(this.domain, step.connection)
+
+    if (!connection || !connection.edgeId) {
+      var handler = TaskRegistry.getTaskHandler(step.task)
+      if (!handler) {
+        throw new Error(`no task handler for step '${step.name}'(${step.id})`)
+      }
 
-    var retval: any = await handler(step, context)
+      var retval: any = await handler(step, context)
+    } else {
+      var retval: any = await edgeHandler(step, context)
+    }
 
     if (step.log) {
       var { data } = retval || {}