@things-factory/integration-base 7.0.0-alpha.1 → 7.0.0-alpha.18

package/server/index.ts

@@ -1,5 +1,6 @@
 export * from './migrations'
 export * from './engine'
+export * from './controllers'
 export * from './service'
 
 import './routes'

package/server/restful/unstable/run-scenario.ts

@@ -1,7 +1,6 @@
 import gql from 'graphql-tag'
 
 import { restfulApiRouter as router } from '@things-factory/api'
-import { ScenarioInstanceStatus } from '../../service/scenario-instance/scenario-instance-type'
 
 const debug = require('debug')('things-factory:integration-base:restful:unstable:run-scenario')
 

package/server/restful/unstable/start-scenario.ts

@@ -12,7 +12,7 @@ router.post('/unstable/start-scenario/:scenarioName', async (context, next) => {
 
   context.body = await client.mutate({
     mutation: gql`
-      mutation($instanceName: String, $scenarioName: String!, $variables: Object) {
+      mutation ($instanceName: String, $scenarioName: String!, $variables: Object) {
         startScenario(instanceName: $instanceName, scenarioName: $scenarioName, variables: $variables) {
           instanceName
           scenarioName

package/server/restful/unstable/stop-scenario.ts

@@ -11,7 +11,7 @@ router.post('/unstable/stop-scenario/:instanceName', async (context, next) => {
 
   context.body = await client.mutate({
     mutation: gql`
-      mutation($instanceName: String!) {
+      mutation ($instanceName: String!) {
         stopScenario(instanceName: $instanceName) {
           instanceName
           scenarioName

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

@@ -26,14 +26,14 @@ export class ConnectionSubscription {
       }
 
       process.nextTick(async () => {
-        var where = { domain }
+        var where = { domain: { id: domain.id } }
         if (name) {
           where['name'] = name
         }
 
         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-mutation.ts

@@ -1,35 +1,14 @@
 import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
 
-import { getRepository, Domain, GraphqlLocalClient, ScalarObject } from '@things-factory/shell'
+import { ScalarObject } from '@things-factory/shell'
 
-import { ScenarioEngine } from '../../engine'
-import { Scenario } from '../scenario/scenario'
 import { ScenarioInstance } from './scenario-instance-type'
-import { PrivilegeObject, User, checkPermission } from '@things-factory/auth-base'
-import { Step } from '../step/step-type'
 
-const debug = require('debug')('things-factory:integration-base:scenario-instance-mutation')
-
-async function findScenario(
-  scenarioName: string,
-  domain: Domain
-): Promise<{ name: string; steps: Step[]; domain: Domain; privilege?: PrivilegeObject }> {
-  var repository = getRepository(Scenario)
-
-  var scenario = await repository.findOne({
-    where: { domain: { id: domain.id }, name: scenarioName },
-    relations: ['domain', 'steps', 'creator', 'updater']
-  })
-
-  if (!scenario && domain.parentId) {
-    scenario = await repository.findOne({
-      where: { domain: { id: domain.parentId }, name: scenarioName },
-      relations: ['domain', 'steps', 'creator', 'updater']
-    })
-  }
-
-  return scenario as any
-}
+import {
+  runScenario as controllerRunScenario,
+  startScenario as controllerStartScenario,
+  stopScenario as controllerStopScenario
+} from '../../controllers/scenario-controller'
 
 @Resolver(ScenarioInstance)
 export class ScenarioInstanceMutation {
@@ -42,42 +21,7 @@ export class ScenarioInstanceMutation {
     @Arg('variables', type => ScalarObject, { nullable: true }) variables: any,
     @Ctx() context: ResolverContext
   ): Promise<ScenarioInstance> {
-    const { domain, user, lng, unsafeIP, prohibitedPrivileges } = context.state
-
-    debug('runScenario', scenarioName, instanceName, variables)
-
-    var scenario = await findScenario(scenarioName, domain)
-
-    if (!scenario) {
-      throw new Error(
-        context.t('error.scenario not found', {
-          scenario: scenarioName
-        })
-      )
-    }
-
-    if (!(await checkPermission(scenario.privilege, user, domain, unsafeIP, prohibitedPrivileges))) {
-      const { category, privilege } = scenario.privilege || {}
-      throw new Error(
-        `Unauthorized! ${
-          category && privilege ? category + ':' + privilege + ' privilege' : 'ownership granted'
-        } required`
-      )
-    }
-
-    /* 시나리오 인스턴스를 생성한다. */
-    instanceName = instanceName || scenarioName + '-' + String(Date.now())
-    var instance = new ScenarioInstance(instanceName, scenario, {
-      domain,
-      user,
-      lng,
-      variables,
-      client: GraphqlLocalClient.client
-    })
-
-    await instance.run()
-
-    return instance
+    return await controllerRunScenario(instanceName, scenarioName, variables, context)
   }
 
   @Mutation(returns => ScenarioInstance, { description: 'To start new scenario instance' })
@@ -87,66 +31,11 @@ export class ScenarioInstanceMutation {
     @Arg('variables', type => ScalarObject, { nullable: true }) variables: any,
     @Ctx() context: ResolverContext
   ): Promise<ScenarioInstance> {
-    const { domain, user, lng, unsafeIP, prohibitedPrivileges } = context.state
-
-    debug('startScenario', instanceName, scenarioName, variables)
-
-    var scenario = await findScenario(scenarioName, domain)
-
-    if (!scenario) {
-      throw new Error(
-        context.t('error.scenario not found', {
-          scenario: scenarioName
-        })
-      )
-    }
-
-    if (!(await checkPermission(scenario.privilege, user, domain, unsafeIP, prohibitedPrivileges))) {
-      const { category, privilege } = scenario.privilege || {}
-      throw new Error(
-        `Unauthorized! ${
-          category && privilege ? category + ':' + privilege + ' privilege' : 'ownership granted'
-        } required`
-      )
-    }
-
-    instanceName = instanceName || scenarioName
-    return await ScenarioEngine.load(instanceName, scenario, { domain, user, lng, variables })
+    return await controllerStartScenario(instanceName, scenarioName, variables, context)
   }
 
   @Mutation(returns => ScenarioInstance, { nullable: true, description: 'To start new scenario instance' })
-  async stopScenario(
-    @Arg('instanceName', { nullable: true }) instanceName: string,
-    @Ctx() context: ResolverContext
-  ): Promise<ScenarioInstance | undefined> {
-    const { domain, user, unsafeIP, prohibitedPrivileges } = context.state
-
-    debug('stopScenario', instanceName)
-
-    var scenarioInstance = ScenarioEngine.getScenarioInstance(domain, instanceName)
-
-    if (!scenarioInstance) {
-      debug('stopScenario', `ScenarioInstance(${instanceName}) Not Found.`)
-      throw new Error(
-        context.t('error.scenario instance not found', {
-          instance: instanceName
-        })
-      )
-    }
-
-    var scenario = await findScenario(scenarioInstance.scenarioName, domain)
-
-    if (!(await checkPermission(scenario.privilege, user, domain, unsafeIP, prohibitedPrivileges))) {
-      const { category, privilege } = scenario.privilege || {}
-      throw new Error(
-        `Unauthorized! ${
-          category && privilege ? category + ':' + privilege + ' privilege' : 'ownership granted'
-        } required`
-      )
-    }
-
-    await ScenarioEngine.unload(domain, instanceName)
-
-    return scenarioInstance
+  async stopScenario(@Arg('instanceName', { nullable: true }) instanceName: string, @Ctx() context: ResolverContext): Promise<ScenarioInstance | undefined> {
+    return await controllerStopScenario(instanceName, context)
   }
 }