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

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

@@ -30,72 +30,126 @@ 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({
     nullable: true
   })
   @Field({ nullable: true })
   description: string
 
+  /** 
+   * The type of the connection.
+   */
   @Column()
   @Field({ nullable: true })
   type: 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() {
     var connector = ConnectionManager.getConnector(this.type)
     var params = {}
@@ -112,6 +166,10 @@ export class Connection {
     })
   }
 
+  /**
+   * @brief Asynchronous method to disconnect the connection.
+   * 
+   */
   async disconnect() {
     try {
       var connector = ConnectionManager.getConnector(this.type)
@@ -121,6 +179,15 @@ export class Connection {
   }
 }
 
+/**
+ * Connection의 params의 원 타입과 사용 시에 타입 불일치로 인해 임시적으로 생성한 타입으로
+ * 추후, 타입 일치를 통해서 제거할 예정임.
+ * 
+ */
+export interface InputConnection extends Connection {
+  params: any;
+}
+
 @ObjectType()
 export class ConnectionState {
   @Field({ nullable: true })

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

@@ -1,5 +1,5 @@
 import { Resolver, Subscription, Root, Arg } from 'type-graphql'
-import { withFilter } from 'graphql-subscriptions'
+import { filter, pipe } from 'graphql-yoga'
 import { pubsub, Log } from '@things-factory/shell'
 import { ScenarioInstance, ScenarioInstanceState } from './scenario-instance-type'
 import { ScenarioEngine } from '../../engine'
@@ -9,7 +9,7 @@ const debug = require('debug')('things-factory:integration:scenario-instance-sub
 @Resolver(ScenarioInstance)
 export class ScenarioInstanceSubscription {
   @Subscription({
-    subscribe: (_, args, context, info) => {
+    subscribe: ({ args, context, info }) => {
       const { domain, user } = context.state
       const { instanceName, scenarioName, level } = args
       const subdomain = domain?.subdomain
@@ -24,11 +24,11 @@ export class ScenarioInstanceSubscription {
         throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
       }
 
-      return withFilter(
-        () => pubsub.asyncIterator('scenario-instance-log'),
-        (payload, variables, context, info) => {
+      return pipe(
+        pubsub.subscribe('scenario-instance-log'),
+        filter((payload: { scenarioInstanceLog: Log }) => {
           const { source, level: plevel } = payload.scenarioInstanceLog
-          const { domain: pdomain, scenarioName: pscenarioName, instanceName: pinstanceName } = source
+          const { domain: pdomain, scenarioName: pscenarioName, instanceName: pinstanceName } = source as any
 
           if (subdomain !== pdomain?.subdomain) {
             return false
@@ -47,8 +47,8 @@ export class ScenarioInstanceSubscription {
           }
 
           return true
-        }
-      )(_, args, context, info)
+        })
+      )
     }
   })
   scenarioInstanceLog(
@@ -61,7 +61,7 @@ export class ScenarioInstanceSubscription {
   }
 
   @Subscription({
-    subscribe: (_, args, context, info) => {
+    subscribe: ({ args, context, info }) => {
       const { domain, user } = context.state
       const { instanceName, scenarioName } = args
       const subdomain = domain?.subdomain
@@ -79,24 +79,17 @@ export class ScenarioInstanceSubscription {
       process.nextTick(() => {
         ScenarioEngine.getScenarioInstances(domain)
           .filter(instance => {
-            return (
-              (!instanceName || instance.instanceName === instanceName) &&
-              (!scenarioName || instance.scenarioName === scenarioName)
-            )
+            return (!instanceName || instance.instanceName === instanceName) && (!scenarioName || instance.scenarioName === scenarioName)
           })
           .forEach(instance => {
             instance.publishState()
           })
       })
 
-      return withFilter(
-        () => pubsub.asyncIterator('scenario-instance-state'),
-        (payload, variables, context, info) => {
-          const {
-            domain: pdomain,
-            scenarioName: pscenarioName,
-            instanceName: pinstanceName
-          } = payload.scenarioInstanceState
+      return pipe(
+        pubsub.subscribe('scenario-instance-state'),
+        filter((payload: { scenarioInstanceState: ScenarioInstanceState }) => {
+          const { domain: pdomain, scenarioName: pscenarioName, instanceName: pinstanceName } = payload.scenarioInstanceState
 
           if (subdomain !== pdomain?.subdomain) {
             return false
@@ -111,8 +104,8 @@ export class ScenarioInstanceSubscription {
           }
 
           return true
-        }
-      )(_, args, context, info)
+        })
+      )
     }
   })
   scenarioInstanceState(

package/server/service/scenario-queue/scenario-queue-subscription.ts

@@ -1,7 +1,7 @@
 import { Resolver, Subscription, Root, Arg } from 'type-graphql'
 import { ScenarioQueueState } from './scenario-queue-type'
 import { pubsub } from '@things-factory/shell'
-import { withFilter } from 'graphql-subscriptions'
+import { filter, pipe } from 'graphql-yoga'
 import { ScenarioEngine } from '../../engine'
 
 const debug = require('debug')('things-factory:integration:connection-subscription')
@@ -9,7 +9,7 @@ const debug = require('debug')('things-factory:integration:connection-subscripti
 @Resolver()
 export class ScenarioQueueSubscription {
   @Subscription({
-    subscribe: (_, args, context, info) => {
+    subscribe: ({ args, context, info }) => {
       const { domain, user } = context.state
       const subdomain = domain?.subdomain
 
@@ -35,9 +35,9 @@ export class ScenarioQueueSubscription {
         }
       })
 
-      return withFilter(
-        () => pubsub.asyncIterator('scenario-queue-state'),
-        (payload, variables, context, info) => {
+      return pipe(
+        pubsub.subscribe('scenario-queue-state'),
+        filter((payload: { scenarioQueueState: ScenarioQueueState }) => {
           const { domain: pdomain } = payload.scenarioQueueState
 
           if (pdomain?.subdomain !== subdomain) {
@@ -45,8 +45,8 @@ export class ScenarioQueueSubscription {
           }
 
           return true
-        }
-      )(_, args, context, info)
+        })
+      )
     }
   })
   scenarioQueueState(@Root() payload: { scenarioQueueState: ScenarioQueueState }): ScenarioQueueState {

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

@@ -15,98 +15,145 @@ import { Domain } from '@things-factory/shell'
 
 import { Scenario } from '../scenario/scenario'
 
+
 @Entity()
 @Index('ix_step_0', (step: Step) => [step.scenario, step.sequence], { unique: true })
 @ObjectType()
 export class Step {
+  /** 
+    * The unique identifier for each step.
+    */
   @PrimaryGeneratedColumn('uuid')
   @Field(type => ID)
   readonly id: string
 
+  /** 
+    * The domain to which this step belongs.
+    */
   @ManyToOne(type => Domain)
   @Field({ nullable: true })
   domain: Domain
 
+  /** 
+    * The ID of the domain associated with this step.
+    */
   @RelationId((step: Step) => step.domain)
   domainId: string
 
-  @Column({
-    nullable: true
-  })
+  /** 
+    * The name of the step.
+    */
+  @Column({ nullable: true })
   @Field()
   name: string
 
-  @Column({
-    nullable: true
-  })
+  /** 
+    * A description of what the step involves.
+    */
+  @Column({ nullable: true })
   @Field({ nullable: true })
   description: string
 
+  /** 
+    * The scenario that includes this step.
+    */
   @ManyToOne(type => Scenario, scenario => scenario.steps, { onDelete: 'CASCADE' })
   @Field(type => Scenario, { nullable: true })
   scenario: Scenario
 
+  /** 
+    * The ID of the scenario associated with this step.
+    */
   @RelationId((step: Step) => step.scenario)
   scenarioId: string
 
+  /** 
+    * The sequence number of the step within its scenario.
+    */
   @Column()
   @Field({ nullable: true })
   sequence: number
 
+  /** 
+    * The specific task associated with this step.
+    */
   @Column()
   @Field({ nullable: true })
   task: string
 
-  @Column({
-    nullable: true
-  })
+  /** 
+    * Boolean value to indicate if the step should be skipped.
+    */
+  @Column({ nullable: true })
   @Field({ nullable: true })
   skip: boolean
 
-  @Column({
-    nullable: true
-  })
+  /** 
+    * Boolean value to indicate if the step should be logged.
+    */
+  @Column({ nullable: true })
   @Field({ nullable: true })
   log: boolean
 
-  @Column({
-    nullable: true
-  })
+  /** 
+    * The connection details associated with this step.
+    */
+  @Column({ nullable: true })
   @Field({ nullable: true })
   connection: string
 
-  @Column({
-    nullable: true
-  })
+  /** 
+    * The parameters for the step.
+    */
+  @Column({ nullable: true })
   @Field({ nullable: true })
   params: string
 
+  /** 
+    * A boolean attribute indicating the inclusion status of an element in the result.
+    */
   @Column({ nullable: true, default: true })
-  @Field({
-    nullable: true,
-    description: 'a boolean attribute indicating the inclusion status of an element in the result'
-  })
+  @Field({ nullable: true, description: 'A boolean attribute indicating the inclusion status of an element in the result' })
   result: boolean = true
 
+  /** 
+    * The timestamp when the step was created.
+    */
   @CreateDateColumn()
   @Field({ nullable: true })
   createdAt: Date
 
+  /** 
+    * The timestamp when
+  the step was last updated.
+  */
   @UpdateDateColumn()
   @Field({ nullable: true })
   updatedAt: Date
 
+  /**
+  * The user who created this step.
+  */
   @ManyToOne(type => User, { nullable: true })
   @Field({ nullable: true })
   creator: User
 
+  /**
+  * The ID of the user who created this step.
+  */
   @RelationId((step: Step) => step.creator)
   creatorId: string
 
+  /**
+  * The user who last updated this step.
+  */
   @ManyToOne(type => User, { nullable: true })
   @Field({ nullable: true })
   updater: User
 
+  /**
+  * The ID of the user who last updated this step.
+  */
   @RelationId((step: Step) => step.updater)
   updaterId: string
 }
@@ -147,6 +194,15 @@ export class StepPatch {
   cuFlag?: string
 }
 
+/**
+ * Step의 params의 원 타입과 사용 시에 타입 불일치로 인해 임시적으로 생성한 타입으로
+ * 추후, 타입 일치를 통해서 제거할 예정임.
+ * 
+ */
+export interface InputStep extends Step {
+  params: any
+}
+
 @ObjectType()
 export class StepList {
   @Field(type => [Step])