@things-factory/dataset 7.0.0-alpha.0 → 7.0.0-alpha.18

package/server/routes.ts

@@ -2,13 +2,13 @@ import { In } from 'typeorm'
 
 import { Domain, getDataSource } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
-import { Activity } from '@things-factory/worklist'
-import { issue } from '@things-factory/worklist/dist-server/controllers/activity-instance/issue'
+import { runScenario } from '@things-factory/integration-base'
 import { ScheduleRegisterRequest } from '@things-factory/scheduler-client'
 
 import { createDataSample } from './controllers/create-data-sample'
 import { renderJasperReport } from './controllers/jasper-report'
 import { renderShinyReport } from './controllers/shiny-report'
+import { issueCollectData } from './controllers/issue-collect-data'
 import { DataSensor } from './service/data-sensor/data-sensor'
 import { DataSet } from './service/data-set/data-set'
 
@@ -23,8 +23,8 @@ process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRout
   globalPublicRouter.post('/sensor-data', async (context, next) => {
     // 데이타 검증
     const { deviceId, data, rawData, timestamp = Date.now() } = context.request.body
-    if (!deviceId || !data) {
-      throw new Error(`deviceId(${deviceId}) and data(${JSON.stringify(data)}) properties are mandatory`)
+    if (!deviceId) {
+      throw new Error(`The deviceId(${deviceId}) property are mandatory`)
     }
 
     // make new data-sample
@@ -32,7 +32,7 @@ process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRout
       // find sensor through deviceId
       const sensor = await tx.getRepository(DataSensor).findOne({
         where: { deviceId },
-        relations: ['domain', 'appliance', 'dataSet']
+        relations: ['domain', 'appliance', 'dataSet', 'decoder']
       })
 
       if (!sensor) {
@@ -47,18 +47,18 @@ process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRout
         throw new Error(`Appliance of the sensor given deviceId(${deviceId}) is not set up`)
       }
 
-      if (!sensor.dataSet) {
-        throw new Error(`DataSet of the sensor given deviceId(${deviceId}) is not set up`)
-      }
+      // if (!sensor.dataSet) {
+      //   throw new Error(`DataSet of the sensor given deviceId(${deviceId}) is not set up`)
+      // }
 
       const domain = sensor.domain
       const dataSet = sensor.dataSet
-      const user: User = await tx.getRepository(User).findOne({
-        where: {
-          reference: sensor.appliance.id,
-          userType: 'appliance'
-        }
-      })
+      // const user: User = await tx.getRepository(User).findOne({
+      //   where: {
+      //     reference: sensor.appliance.id,
+      //     userType: 'appliance'
+      //   }
+      // })
 
       context.state = {
         ...context.state,
@@ -66,19 +66,40 @@ process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRout
         tx
       }
 
-      return await createDataSample(
-        {
-          dataSet,
+      var decoded
+      if (sensor.decoder) {
+        const { name: scenarioName } = sensor.decoder
+        const variables = {
+          dataSensor: sensor,
+          source: deviceId,
           data,
           rawData,
-          source: deviceId,
-          collectedAt: new Date(timestamp)
-        },
-        context
-      )
-    })
+          timestamp
+        }
 
-    context.status = 200
+        decoded = (await runScenario(null, scenarioName, variables, context))?.result
+      }
+
+      if (dataSet) {
+        await createDataSample(
+          {
+            dataSet,
+            data,
+            rawData,
+            source: deviceId,
+            collectedAt: new Date(timestamp),
+            ...decoded
+          },
+          context
+        )
+      }
+
+      context.status = 200
+      context.body = {
+        data,
+        ...decoded
+      }
+    })
   })
 
   /* When a callback occurs from the scheduler when a scheduled dataset is on schedule, data collection task for the dataset should be issued. */
@@ -95,55 +116,7 @@ process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRout
       throw new Error(`group(${domainId}) and key(${dataSetId}) properties should not be empty`)
     }
 
-    await getDataSource().transaction(async tx => {
-      const domain = await tx.getRepository(Domain).findOneBy({ id: domainId })
-
-      if (!domain) {
-        throw new Error(`domain(${domainId}) not found`)
-      }
-
-      const dataSet = await tx
-        .getRepository(DataSet)
-        .findOne({ where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id: dataSetId } })
-
-      const activity = (await tx.getRepository(Activity).findOneBy({
-        domain: { id: domainId },
-        name: 'Collect Data'
-      })) as Activity
-
-      if (activity) {
-        const { assignees } = dataSet
-
-        /* 해당 dataset에 대한 데이타 수집 태스크를 dataset assignees에게 할당한다. */
-        if (assignees && assignees instanceof Array && assignees.length > 0) {
-          const activityInstance = {
-            name: `[Data 수집] ${dataSet.name}`,
-            description: dataSet.description,
-            activityId: activity.id,
-            dueAt: new Date(Date.now() + 24 * 60 * 60 * 1000),
-            input: {
-              dataSetId: dataSet.id,
-              dataSetName: dataSet.name
-            },
-            assignees
-          }
-
-          context.state = {
-            ...context.state,
-            domain,
-            tx
-          }
-
-          await issue(activityInstance, context)
-        } else {
-          throw new Error(
-            `Assignees not set. So Data Collect Activity for ${dataSet.name}($dataSet.id) could not be issued.`
-          )
-        }
-      } else {
-        throw new Error(`Data Collect Activity is not installed.`)
-      }
-    })
+    await issueCollectData(domainId, dataSetId, context)
 
     context.status = 200
   })
@@ -169,9 +142,7 @@ process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRout
         throw new Error(`domain(${domainId}) not found`)
       }
 
-      const dataSet = await tx
-        .getRepository(DataSet)
-        .findOne({ where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id: dataSetId } })
+      const dataSet = await tx.getRepository(DataSet).findOne({ where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id: dataSetId } })
 
       // do what you gotta do
     })

package/server/service/data-ooc/data-ooc-query.ts

@@ -2,10 +2,12 @@ import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from
 
 import { User } from '@things-factory/auth-base'
 import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { ActivityInstance } from '@things-factory/worklist'
 
 import { DataSetHistory } from '../data-set-history/data-set-history'
 import { DataItem } from '../data-set/data-item-type'
 import { DataSet } from '../data-set/data-set'
+import { DataSample } from '../data-sample/data-sample'
 import { DataOoc } from './data-ooc'
 import { DataOocList } from './data-ooc-type'
 
@@ -51,11 +53,26 @@ export class DataOocQuery {
     return dataSetHistory?.dataItems || []
   }
 
+  @FieldResolver(type => DataSample)
+  async dataSample(@Root() dataOoc: DataOoc): Promise<DataSample> {
+    return dataOoc.dataSampleId && (await getRepository(DataSample).findOneBy({ id: dataOoc.dataSampleId }))
+  }
+
   @FieldResolver(type => DataSet)
   async dataSet(@Root() dataOoc: DataOoc): Promise<DataSet> {
     return dataOoc.dataSetId && (await getRepository(DataSet).findOneBy({ id: dataOoc.dataSetId }))
   }
 
+  @FieldResolver(type => ActivityInstance)
+  async reviewActivityInstance(@Root() dataOoc: DataOoc): Promise<ActivityInstance> {
+    return dataOoc.reviewActivityInstanceId && (await getRepository(ActivityInstance).findOneBy({ id: dataOoc.reviewActivityInstanceId }))
+  }
+
+  @FieldResolver(type => ActivityInstance)
+  async resolveActivityInstance(@Root() dataOoc: DataOoc): Promise<ActivityInstance> {
+    return dataOoc.resolveActivityInstanceId && (await getRepository(ActivityInstance).findOneBy({ id: dataOoc.resolveActivityInstanceId }))
+  }
+
   @FieldResolver(type => User)
   async corrector(@Root() dataOoc: DataOoc): Promise<User> {
     return dataOoc.correctorId && (await getRepository(User).findOneBy({ id: dataOoc.correctorId }))

package/server/service/data-ooc/data-ooc-subscription.ts

@@ -1,4 +1,4 @@
-import { withFilter } from 'graphql-subscriptions'
+import { filter, pipe } from 'graphql-yoga'
 import { Resolver, Root, Subscription } from 'type-graphql'
 
 import { User } from '@things-factory/auth-base'
@@ -9,7 +9,7 @@ import { DataOoc } from './data-ooc'
 @Resolver(DataOoc)
 export class DataOocSubscription {
   @Subscription({
-    subscribe: (_, args, context, info) => {
+    subscribe: ({ args, context, info }) => {
       const { domain, user } = context.state
       const subdomain = domain?.subdomain
 
@@ -21,9 +21,9 @@ export class DataOocSubscription {
         throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
       }
 
-      return withFilter(
-        () => pubsub.asyncIterator('data-ooc'),
-        async (payload, variables, context, info) => {
+      return pipe(
+        pubsub.subscribe('data-ooc'),
+        filter(async (payload: { dataOoc: DataOoc; supervisoryRoleId: string }) => {
           const { dataOoc, supervisoryRoleId } = payload
           const { domain } = dataOoc
 
@@ -38,8 +38,8 @@ export class DataOocSubscription {
           })
 
           return !!userWithRoles.roles.find(role => role.id === supervisoryRoleId)
-        }
-      )(_, args, context, info)
+        })
+      )
     }
   })
   dataOoc(@Root() payload: { dataOoc: DataOoc; supervisoryRoleId: string }): DataOoc {

package/server/service/data-ooc/data-ooc.ts

@@ -1,21 +1,14 @@
 import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
+import { Column, CreateDateColumn, Entity, Index, JoinColumn, ManyToOne, OneToOne, PrimaryGeneratedColumn, RelationId, UpdateDateColumn } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { config } from '@things-factory/env'
 import { Domain, ScalarObject } from '@things-factory/shell'
+import { ActivityInstance } from '@things-factory/worklist'
 
 import { DataItem } from '../data-set/data-item-type'
 import { DataSet } from '../data-set/data-set'
+import { DataSample } from '../data-sample/data-sample'
 
 const ORMCONFIG = config.get('ormconfig', {})
 const DATABASE_TYPE = ORMCONFIG.type
@@ -47,12 +40,10 @@ export class DataOoc {
   domainId?: string
 
   @Column()
-  @Field()
-  name: string
+  @Field({ nullable: true })
+  name?: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   description?: string
 
@@ -67,57 +58,37 @@ export class DataOoc {
   @Field({ nullable: true })
   dataSetVersion?: number
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   ooc?: boolean
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   oos?: boolean
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   state?: DataOocStatus
 
   @Column({
     nullable: true,
-    type:
-      DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? 'longtext'
-        : DATABASE_TYPE == 'oracle'
-        ? 'clob'
-        : 'varchar'
+    type: DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? 'longtext' : DATABASE_TYPE == 'oracle' ? 'clob' : 'varchar'
   })
   @Field({ nullable: true })
   correctiveInstruction?: string
 
   @Column({
     nullable: true,
-    type:
-      DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? 'longtext'
-        : DATABASE_TYPE == 'oracle'
-        ? 'clob'
-        : 'varchar'
+    type: DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? 'longtext' : DATABASE_TYPE == 'oracle' ? 'clob' : 'varchar'
   })
   @Field({ nullable: true })
   correctiveAction?: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   type?: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   useCase?: string
 
@@ -162,22 +133,39 @@ export class DataOoc {
 
   @Column({
     nullable: true,
-    type:
-      DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? 'longtext'
-        : DATABASE_TYPE == 'oracle'
-        ? 'clob'
-        : 'varchar'
+    type: DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? 'longtext' : DATABASE_TYPE == 'oracle' ? 'clob' : 'varchar'
   })
   @Field({ nullable: true })
   rawData?: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   source?: string
 
+  @OneToOne(type => DataSample, { nullable: true })
+  @JoinColumn()
+  @Field(type => DataSample, { nullable: true })
+  dataSample?: DataSample
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.dataSample)
+  dataSampleId?: string
+
+  @OneToOne(type => ActivityInstance, { nullable: true })
+  @JoinColumn()
+  @Field({ nullable: true })
+  reviewActivityInstance?: ActivityInstance
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.reviewActivityInstance)
+  reviewActivityInstanceId?: string
+
+  @OneToOne(type => ActivityInstance, { nullable: true })
+  @JoinColumn()
+  @Field({ nullable: true })
+  resolveActivityInstance?: ActivityInstance
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.resolveActivityInstance)
+  resolveActivityInstanceId?: string
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   workDate?: string

package/server/service/data-sample/data-sample-query.ts

@@ -2,18 +2,14 @@ import { In } from 'typeorm'
 import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
 
 import { User } from '@things-factory/auth-base'
-import {
-  Domain,
-  getQueryBuilderFromListParams,
-  getRepository,
-  getISOStringsForPeriod,
-  ListParam
-} from '@things-factory/shell'
+import { Domain, getQueryBuilderFromListParams, getRepository, getISOStringsForPeriod, ListParam } from '@things-factory/shell'
+import { ActivityInstance } from '@things-factory/worklist'
 
 import { DataKeySet } from '../data-key-set/data-key-set'
 import { DataSetHistory } from '../data-set-history/data-set-history'
 import { DataItem } from '../data-set/data-item-type'
 import { DataSet } from '../data-set/data-set'
+import { DataOoc } from '../data-ooc/data-ooc'
 import { DataSample } from './data-sample'
 import { DataSampleList } from './data-sample-type'
 
@@ -48,11 +44,7 @@ export class DataSampleQuery {
 
   @Directive('@privilege(category: "data-sample", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => DataSampleList, { description: 'To fetch multiple data samples by data set' })
-  async dataSamplesByDataSet(
-    @Arg('dataSetId') dataSetId: string,
-    @Args() params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<DataSampleList> {
+  async dataSamplesByDataSet(@Arg('dataSetId') dataSetId: string, @Args() params: ListParam, @Ctx() context: ResolverContext): Promise<DataSampleList> {
     const { domain } = context.state
 
     const dataSet = await getRepository(DataSet).findOne({
@@ -84,11 +76,7 @@ export class DataSampleQuery {
 
   @Directive('@privilege(category: "data-sample", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => DataSampleList, { description: 'To fetch multiple data samples by data key set' })
-  async dataSamplesByDataKeySet(
-    @Arg('dataKeySetId') dataKeySetId: string,
-    @Args() params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<DataSampleList> {
+  async dataSamplesByDataKeySet(@Arg('dataKeySetId') dataKeySetId: string, @Args() params: ListParam, @Ctx() context: ResolverContext): Promise<DataSampleList> {
     const { domain } = context.state
 
     const dataKeySet = await getRepository(DataKeySet).findOneBy({ id: dataKeySetId })
@@ -178,6 +166,18 @@ export class DataSampleQuery {
     return dataSample.dataSetId && (await getRepository(DataSet).findOneBy({ id: dataSample.dataSetId }))
   }
 
+  @FieldResolver(type => DataOoc)
+  async dataOoc(@Root() dataSample: DataSample): Promise<DataOoc> {
+    if (dataSample.ooc || dataSample.oos) {
+      return await getRepository(DataOoc).findOneBy({ dataSample: { id: dataSample.id } })
+    }
+  }
+
+  @FieldResolver(type => ActivityInstance)
+  async reviewActivityInstance(@Root() dataSample: DataSample): Promise<ActivityInstance> {
+    return dataSample.reviewActivityInstanceId && (await getRepository(ActivityInstance).findOneBy({ id: dataSample.reviewActivityInstanceId }))
+  }
+
   @FieldResolver(type => Domain)
   async domain(@Root() dataSample: DataSample): Promise<Domain> {
     return dataSample.domainId && (await getRepository(Domain).findOneBy({ id: dataSample.domainId }))

package/server/service/data-sample/data-sample.ts

@@ -1,41 +1,22 @@
 import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
+import { Column, CreateDateColumn, Entity, Index, JoinColumn, ManyToOne, OneToOne, PrimaryGeneratedColumn, RelationId, UpdateDateColumn } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { config } from '@things-factory/env'
-import { Domain, ScalarObject } from '@things-factory/shell'
+import { Domain, ScalarObject, json5Transformer } from '@things-factory/shell'
+import { ActivityInstance } from '@things-factory/worklist'
 
 import { DataItem } from '../data-set/data-item-type'
 import { DataSet } from '../data-set/data-set'
+import { DataOoc } from '../data-ooc/data-ooc'
 
 const ORMCONFIG = config.get('ormconfig', {})
 const DATABASE_TYPE = ORMCONFIG.type
 @Entity()
-@Index(
-  'ix_data_sample_0',
-  (dataSample: DataSample) => [
-    dataSample.domain,
-    dataSample.dataSet,
-    dataSample.workDate,
-    dataSample.workShift,
-    dataSample.collectedAt
-  ],
-  { unique: false }
-)
-@Index(
-  'ix_data_sample_1',
-  (dataSample: DataSample) => [dataSample.domain, dataSample.dataSet, dataSample.collectedAt],
-  { unique: false }
-)
+@Index('ix_data_sample_0', (dataSample: DataSample) => [dataSample.domain, dataSample.dataSet, dataSample.workDate, dataSample.workShift, dataSample.collectedAt], {
+  unique: false
+})
+@Index('ix_data_sample_1', (dataSample: DataSample) => [dataSample.domain, dataSample.dataSet, dataSample.collectedAt], { unique: false })
 @ObjectType({ description: 'Entity for DataSample' })
 export class DataSample {
   @PrimaryGeneratedColumn('uuid')
@@ -50,24 +31,18 @@ export class DataSample {
   domainId?: string
 
   @Column()
-  @Field()
+  @Field({ nullable: true })
   name: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   description?: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   type?: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   useCase?: string
 
@@ -99,31 +74,21 @@ export class DataSample {
 
   @Column({
     nullable: true,
-    type:
-      DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? 'longtext'
-        : DATABASE_TYPE == 'oracle'
-        ? 'clob'
-        : 'varchar'
+    type: DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? 'longtext' : DATABASE_TYPE == 'oracle' ? 'clob' : 'varchar',
+    transformer: json5Transformer
   })
   @Field({ nullable: true })
   rawData?: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   source?: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   ooc?: boolean
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   oos?: boolean
 
@@ -155,6 +120,18 @@ export class DataSample {
   @Field({ nullable: true })
   workShift?: string
 
+  @OneToOne(type => ActivityInstance, { nullable: true })
+  @JoinColumn()
+  @Field({ nullable: true })
+  reviewActivityInstance?: ActivityInstance
+
+  @RelationId((dataSample: DataSample) => dataSample.reviewActivityInstance)
+  reviewActivityInstanceId?: string
+
+  @OneToOne(type => DataOoc, dataOoc => dataOoc.dataSample, { nullable: true })
+  @Field(type => DataOoc, { nullable: true })
+  dataOoc?: DataOoc
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   collectedAt?: Date

package/server/service/data-sensor/data-sensor-query.ts

@@ -2,6 +2,7 @@ import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graph
 
 import { Appliance, User } from '@things-factory/auth-base'
 import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { Scenario } from '@things-factory/integration-base'
 
 import { DataSet } from '../data-set/data-set'
 import { DataSensor } from './data-sensor'
@@ -39,11 +40,22 @@ export class DataSensorQuery {
     return dataSensor.applianceId && (await getRepository(Appliance).findOneBy({ id: dataSensor.applianceId }))
   }
 
-  @FieldResolver(type => Appliance)
+  @FieldResolver(type => DataSet)
   async dataSet(@Root() dataSensor: DataSensor): Promise<DataSet> {
     return dataSensor.dataSetId && (await getRepository(DataSet).findOneBy({ id: dataSensor.dataSetId }))
   }
 
+  @FieldResolver(type => Scenario)
+  async decoder(@Root() dataSensor: DataSensor): Promise<Scenario> {
+    return (
+      dataSensor.decoder ||
+      (dataSensor.decoderId &&
+        (await getRepository(Scenario).findOneBy({
+          id: dataSensor.decoderId
+        })))
+    )
+  }
+
   @FieldResolver(type => Domain)
   async domain(@Root() dataSensor: DataSensor): Promise<Domain> {
     return dataSensor.domainId && (await getRepository(Domain).findOneBy({ id: dataSensor.domainId }))

package/server/service/data-sensor/data-sensor-type.ts

@@ -41,6 +41,9 @@ export class NewDataSensor {
 
   @Field(type => ObjectRef, { nullable: true })
   dataSet?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  decoder?: ObjectRef
 }
 
 @InputType()
@@ -84,6 +87,9 @@ export class DataSensorPatch {
   @Field(type => ObjectRef, { nullable: true })
   dataSet?: ObjectRef
 
+  @Field(type => ObjectRef, { nullable: true })
+  decoder?: ObjectRef
+
   @Field()
   cuFlag: string
 }