@things-factory/integration-base 5.0.11 → 6.0.0-alpha.3

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

@@ -16,21 +16,20 @@ export class ScenarioMutation {
   @Mutation(returns => Scenario, { description: 'To create new scenario' })
   async createScenario(
     @Arg('scenario', type => NewScenario) scenario: NewScenario,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Scenario> {
     const { domain, user, tx } = context.state
 
-    const saved = await tx.getRepository(Scenario).save({
+    return await tx.getRepository(Scenario).save({
       ...scenario,
       domain,
       creator: user,
       updater: user
     })
-
-    return {
-      ...saved,
-      state: 'UNLOADED' // ScenarioInstanceStatus.UNLOADED
-    }
+    // return {
+    //   ...saved,
+    //   state: 'UNLOADED' // ScenarioInstanceStatus.UNLOADED
+    // }
   }
 
   @Directive('@transaction')
@@ -38,13 +37,13 @@ export class ScenarioMutation {
   async updateScenario(
     @Arg('name') name: string,
     @Arg('patch', type => ScenarioPatch) patch: ScenarioPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Scenario> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(Scenario)
     const scenario = await repository.findOne({
-      where: { domain, name }
+      where: { domain: { id: domain.id }, name }
     })
 
     if (!scenario) {
@@ -66,7 +65,7 @@ export class ScenarioMutation {
   @Mutation(returns => [Scenario], { description: "To modify multiple scenarios' information" })
   async updateMultipleScenario(
     @Arg('patches', type => [ScenarioPatch]) patches: ScenarioPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Scenario[]> {
     const { domain, user, tx } = context.state
 
@@ -93,7 +92,7 @@ export class ScenarioMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const scenario = await scenarioRepo.findOne(newRecord.id)
+        const scenario = await scenarioRepo.findOneBy({ id: newRecord.id })
 
         const result = await scenarioRepo.save({
           ...scenario,
@@ -110,7 +109,7 @@ export class ScenarioMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete scenario' })
-  async deleteScenario(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+  async deleteScenario(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(Scenario).delete({ domain, name })
@@ -120,11 +119,14 @@ export class ScenarioMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple scenarios' })
-  async deleteScenarios(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteScenarios(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(Scenario).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 
@@ -135,7 +137,7 @@ export class ScenarioMutation {
   @Mutation(returns => Boolean, { description: 'To import multiple scenarios' })
   async importScenarios(
     @Arg('scenarios', type => [ScenarioPatch]) scenarios: Scenario[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
     const tx: EntityManager = context.state.tx
     const domain: Domain = context.state.domain
@@ -159,7 +161,10 @@ export class ScenarioMutation {
 
   @Directive('@transaction')
   @Mutation(returns => [Scenario], { description: 'To import multiple scenarios' })
-  async copyScenarios(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Scenario[]> {
+  async copyScenarios(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Scenario[]> {
     const { domain, user, tx } = context.state
 
     const originals = await tx.getRepository(Scenario).find({
@@ -216,10 +221,11 @@ export class ScenarioMutation {
 
     return copiedScenarios.map(scenario => {
       scenario.steps = copiedSteps.filter(step => step.scenario == scenario.id)
-      return {
-        ...scenario,
-        state: 'UNLOADED' // ScenarioInstanceStatus.UNLOADED
-      }
+      return scenario
+      // return {
+      //   ...scenario,
+      //   state: 'UNLOADED' // ScenarioInstanceStatus.UNLOADED
+      // }
     })
   }
 }

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

@@ -1,8 +1,7 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
 
 import { ScenarioEngine } from '../../engine'
 import { ScenarioInstance, ScenarioInstanceStatus } from '../scenario-instance/scenario-instance-type'
@@ -12,16 +11,16 @@ import { Scenario, ScenarioList } from './scenario-type'
 @Resolver(Scenario)
 export class ScenarioQuery {
   @Query(returns => Scenario, { description: 'To fetch a scenario' })
-  async scenario(@Arg('id') id: string, @Ctx() context: any): Promise<Scenario> {
+  async scenario(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Scenario> {
     const { domain } = context.state
 
     return await getRepository(Scenario).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Query(returns => ScenarioList, { description: 'To fetch multiple scenarios' })
-  async scenarios(@Args() params: ListParam, @Ctx() context: any): Promise<ScenarioList> {
+  async scenarios(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ScenarioList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -38,32 +37,32 @@ export class ScenarioQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() scenario: Scenario) {
-    return await getRepository(Domain).findOne(scenario.domainId)
+    return await getRepository(Domain).findOneBy({ id: scenario.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() scenario: Scenario): Promise<User> {
-    return await getRepository(User).findOne(scenario.updaterId)
+    return await getRepository(User).findOneBy({ id: scenario.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() scenario: Scenario): Promise<User> {
-    return await getRepository(User).findOne(scenario.creatorId)
+    return await getRepository(User).findOneBy({ id: scenario.creatorId })
   }
 
   @FieldResolver(type => [Step])
-  async steps(@Root() scenario: Scenario, @Ctx() context: any): Promise<Step[]> {
+  async steps(@Root() scenario: Scenario, @Ctx() context: ResolverContext): Promise<Step[]> {
     const { domain } = context.state
 
     return await getRepository(Step).find({
-      where: { domain, scenario }
+      where: { domain: { id: domain.id }, scenario: { id: scenario.id } }
     })
   }
 
   /* 아래 두개 FieldResolver는 type에는 정의하지 않았지만, 스키마에는 자동으로 추가되는 것으로 보인다. */
 
   @FieldResolver(type => String, { nullable: true })
-  async state(@Root() scenario: Scenario, @Ctx() context: any): Promise<string> {
+  async state(@Root() scenario: Scenario, @Ctx() context: ResolverContext): Promise<string> {
     const { domain } = context.state
 
     var instance = ScenarioEngine.getScenarioInstance(domain, scenario.name)
@@ -71,7 +70,7 @@ export class ScenarioQuery {
   }
 
   @FieldResolver(type => [ScenarioInstance], { nullable: true })
-  async instances(@Root() scenario: Scenario, @Ctx() context: any): Promise<ScenarioInstance[]> {
+  async instances(@Root() scenario: Scenario, @Ctx() context: ResolverContext): Promise<ScenarioInstance[]> {
     const { domain } = context.state
 
     return ScenarioEngine.getScenarioInstances(domain, scenario.name)

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

@@ -1,7 +1,6 @@
 import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
-import { GraphqlLocalClient, ScalarObject } from '@things-factory/shell'
+import { getRepository, GraphqlLocalClient, ScalarObject } from '@things-factory/shell'
 
 import { ScenarioEngine } from '../../engine'
 import { Scenario } from '../scenario/scenario-type'
@@ -18,7 +17,7 @@ export class ScenarioInstanceMutation {
     @Arg('instanceName', { nullable: true }) instanceName: string,
     @Arg('scenarioName') scenarioName: string,
     @Arg('variables', type => ScalarObject, { nullable: true }) variables: any,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ScenarioInstance> {
     const { domain } = context.state
 
@@ -26,7 +25,7 @@ export class ScenarioInstanceMutation {
 
     var repository = getRepository(Scenario)
     var scenario = await repository.findOne({
-      where: { domain, name: scenarioName },
+      where: { domain: { id: domain.id }, name: scenarioName },
       relations: ['domain', 'steps', 'creator', 'updater']
     })
 
@@ -55,7 +54,7 @@ export class ScenarioInstanceMutation {
     @Arg('instanceName', { nullable: true }) instanceName: string,
     @Arg('scenarioName') scenarioName: string,
     @Arg('variables', type => ScalarObject, { nullable: true }) variables: any,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ScenarioInstance> {
     const { domain } = context.state
 
@@ -63,7 +62,7 @@ export class ScenarioInstanceMutation {
 
     var repository = getRepository(Scenario)
     var scenario = await repository.findOne({
-      where: { domain, name: scenarioName },
+      where: { domain: { id: domain.id }, name: scenarioName },
       relations: ['domain', 'steps', 'creator', 'updater']
     })
 
@@ -82,7 +81,7 @@ export class ScenarioInstanceMutation {
   @Mutation(returns => ScenarioInstance, { nullable: true, description: 'To start new scenario instance' })
   async stopScenario(
     @Arg('instanceName', { nullable: true }) instanceName: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ScenarioInstance | undefined> {
     const { domain } = context.state
 

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

@@ -13,14 +13,17 @@ import {
 @Resolver(ScenarioInstance)
 export class ScenarioInstanceQuery {
   @Query(returns => ScenarioInstance, { description: 'To fetch a scenario instance' })
-  async scenarioInstance(@Arg('instanceName') instanceName: string, @Ctx() context: any): Promise<ScenarioInstance> {
+  async scenarioInstance(
+    @Arg('instanceName') instanceName: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ScenarioInstance> {
     const { domain } = context.state
 
     return ScenarioEngine.getScenarioInstance(domain, instanceName)
   }
 
   @Query(returns => ScenarioInstanceList, { description: 'To fetch multiple scenario instances' })
-  async scenarioInstances(@Args() params: ListParam, @Ctx() context: any): Promise<ScenarioInstanceList> {
+  async scenarioInstances(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ScenarioInstanceList> {
     const { domain } = context.state
 
     var scenarioInstances = ScenarioEngine.getScenarioInstances(domain)

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

@@ -11,15 +11,15 @@ export class StepMutation {
   async updateMultipleStep(
     @Arg('scenarioId') scenarioId: string,
     @Arg('patches', type => [StepPatch]) patches: StepPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Step[]> {
     const { domain, user, tx } = context.state
 
     let results = []
     const stepRepo = tx.getRepository(Step)
-    const scenario = await tx.getRepository(Scenario).findOne(scenarioId)
+    const scenario = await tx.getRepository(Scenario).findOneBy({ id: scenarioId })
 
-    await stepRepo.delete({ domain, scenario: scenarioId })
+    await stepRepo.delete({ domain: { id: domain.id }, scenario: { id: scenarioId } })
 
     for (let i = 0; i < patches.length; i++) {
       const result = await stepRepo.save({
@@ -39,11 +39,11 @@ export class StepMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple steps' })
-  async deleteSteps(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteSteps(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(Step).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 

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

@@ -1,8 +1,7 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
 
 import { Scenario } from '../scenario/scenario-type'
 import { Step, StepList } from './step-type'
@@ -10,16 +9,16 @@ import { Step, StepList } from './step-type'
 @Resolver(Step)
 export class StepQuery {
   @Query(returns => Step, { description: 'To fetch a step' })
-  async step(@Arg('name') name: string, @Ctx() context: any): Promise<Step> {
+  async step(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Step> {
     const { domain } = context.state
 
     return await getRepository(Step).findOne({
-      where: { domain, name }
+      where: { domain: { id: domain.id }, name }
     })
   }
 
   @Query(returns => StepList, { description: 'To fetch multiple steps' })
-  async steps(@Args() params: ListParam, @Ctx() context: any): Promise<StepList> {
+  async steps(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<StepList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -36,21 +35,21 @@ export class StepQuery {
 
   @FieldResolver(type => Scenario)
   async scenario(@Root() step: Step) {
-    return await getRepository(Scenario).findOne(step.scenarioId)
+    return await getRepository(Scenario).findOneBy({ id: step.scenarioId })
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() step: Step) {
-    return await getRepository(Domain).findOne(step.domainId)
+    return await getRepository(Domain).findOneBy({ id: step.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() step: Step): Promise<User> {
-    return await getRepository(User).findOne(step.updaterId)
+    return await getRepository(User).findOneBy({ id: step.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() step: Step): Promise<User> {
-    return await getRepository(User).findOne(step.creatorId)
+    return await getRepository(User).findOneBy({ id: step.creatorId })
   }
 }

package/server/service/task-type/task-type-query.ts

@@ -1,14 +1,16 @@
-import { Resolver, Query, Arg, Ctx } from 'type-graphql'
-import { getRepository } from 'typeorm'
+import { Arg, Ctx, Query, Resolver } from 'type-graphql'
+
+import { getRepository } from '@things-factory/shell'
+
+import { ConnectionManager } from '../../engine/connection-manager'
+import { TaskRegistry } from '../../engine/task-registry'
 import { Connection } from '../connection/connection-type'
 import { TaskType, TaskTypeList } from './task-type-type'
-import { TaskRegistry } from '../../engine/task-registry'
-import { ConnectionManager } from '../../engine/connection-manager'
 
 @Resolver(TaskType)
 export class TaskTypeQuery {
   @Query(returns => TaskType, { description: 'To fetch a task-type' })
-  taskType(@Arg('name') name: string, @Ctx() context: any): TaskType {
+  taskType(@Arg('name') name: string, @Ctx() context: ResolverContext): TaskType {
     const { description, help, parameterSpec, connectorFree } = (TaskRegistry.getTaskHandler(name) || {}) as any
 
     return {
@@ -21,7 +23,7 @@ export class TaskTypeQuery {
   }
 
   @Query(returns => TaskTypeList, { description: 'To fetch multiple task-type' })
-  taskTypes(@Ctx() context: any): TaskTypeList {
+  taskTypes(@Ctx() context: ResolverContext): TaskTypeList {
     var taskTypes = TaskRegistry.getTaskHandlers()
     var items = Object.keys(taskTypes)
       .map(name => {
@@ -47,13 +49,13 @@ export class TaskTypeQuery {
   @Query(returns => TaskTypeList, { description: 'To fetch the connector from a task-type' })
   async taskTypesByConnection(
     @Arg('connectionName') connectionName: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<TaskTypeList> {
     var taskPrefixes = []
 
     if (connectionName) {
       var connection = await getRepository(Connection).findOne({
-        where: { domain: context.state.domain, name: connectionName }
+        where: { domain: { id: context.state.domain.id }, name: connectionName }
       })
 
       if (connection) {