@things-factory/dataset 5.0.16 → 6.0.0-alpha.10

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

@@ -8,7 +8,10 @@ import { DataSensorPatch, NewDataSensor } from './data-sensor-type'
 export class DataSensorMutation {
   @Directive('@transaction')
   @Mutation(returns => DataSensor, { description: 'To create new DataSensor' })
-  async createDataSensor(@Arg('dataSensor') dataSensor: NewDataSensor, @Ctx() context: any): Promise<DataSensor> {
+  async createDataSensor(
+    @Arg('dataSensor') dataSensor: NewDataSensor,
+    @Ctx() context: ResolverContext
+  ): Promise<DataSensor> {
     const { domain, user, tx } = context.state
 
     return await tx.getRepository(DataSensor).save({
@@ -24,13 +27,13 @@ export class DataSensorMutation {
   async updateDataSensor(
     @Arg('id') id: string,
     @Arg('patch') patch: DataSensorPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<DataSensor> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(DataSensor)
     const dataSensor = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
 
     return await repository.save({
@@ -44,7 +47,7 @@ export class DataSensorMutation {
   @Mutation(returns => [DataSensor], { description: "To modify multiple DataSensors' information" })
   async updateMultipleDataSensor(
     @Arg('patches', type => [DataSensorPatch]) patches: DataSensorPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<DataSensor[]> {
     const { domain, user, tx } = context.state
 
@@ -71,7 +74,7 @@ export class DataSensorMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const dataSensor = await dataSensorRepo.findOne(newRecord.id)
+        const dataSensor = await dataSensorRepo.findOneBy({ id: newRecord.id })
 
         const result = await dataSensorRepo.save({
           ...dataSensor,
@@ -88,20 +91,23 @@ export class DataSensorMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete DataSensor' })
-  async deleteDataSensor(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteDataSensor(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(DataSensor).delete({ domain, id })
+    await tx.getRepository(DataSensor).delete({ domain: { id: domain.id }, id })
     return true
   }
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple dataSensors' })
-  async deleteDataSensors(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteDataSensors(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(DataSensor).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 

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

@@ -1,8 +1,7 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { Appliance, User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
 
 import { DataSet } from '../data-set/data-set'
 import { DataSensor } from './data-sensor'
@@ -11,16 +10,16 @@ import { DataSensorList } from './data-sensor-type'
 @Resolver(DataSensor)
 export class DataSensorQuery {
   @Query(returns => DataSensor, { description: 'To fetch a DataSensor' })
-  async dataSensor(@Arg('id') id: string, @Ctx() context: any): Promise<DataSensor> {
+  async dataSensor(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<DataSensor> {
     const { domain } = context.state
 
     return await getRepository(DataSensor).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Query(returns => DataSensorList, { description: 'To fetch multiple DataSensors' })
-  async dataSensors(@Args() params: ListParam, @Ctx() context: any): Promise<DataSensorList> {
+  async dataSensors(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<DataSensorList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -37,26 +36,26 @@ export class DataSensorQuery {
 
   @FieldResolver(type => Appliance)
   async appliance(@Root() dataSensor: DataSensor): Promise<Appliance> {
-    return await getRepository(Appliance).findOne(dataSensor.applianceId || '')
+    return await getRepository(Appliance).findOneBy({ id: dataSensor.applianceId || '' })
   }
 
   @FieldResolver(type => Appliance)
   async dataSet(@Root() dataSensor: DataSensor): Promise<DataSet> {
-    return await getRepository(DataSet).findOne(dataSensor.dataSetId || '')
+    return await getRepository(DataSet).findOneBy({ id: dataSensor.dataSetId || '' })
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() dataSensor: DataSensor): Promise<Domain> {
-    return await getRepository(Domain).findOne(dataSensor.domainId)
+    return await getRepository(Domain).findOneBy({ id: dataSensor.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() dataSensor: DataSensor): Promise<User> {
-    return await getRepository(User).findOne(dataSensor.updaterId)
+    return await getRepository(User).findOneBy({ id: dataSensor.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() dataSensor: DataSensor): Promise<User> {
-    return await getRepository(User).findOne(dataSensor.creatorId)
+    return await getRepository(User).findOneBy({ id: dataSensor.creatorId })
   }
 }

package/server/service/data-set/data-set-mutation.ts

@@ -13,7 +13,7 @@ export class DataSetMutation {
   @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
   @Directive('@transaction')
   @Mutation(returns => DataSet, { description: 'To create new DataSet' })
-  async createDataSet(@Arg('dataSet') dataSet: NewDataSet, @Ctx() context: any): Promise<DataSet> {
+  async createDataSet(@Arg('dataSet') dataSet: NewDataSet, @Ctx() context: ResolverContext): Promise<DataSet> {
     const { domain, user, tx } = context.state
     const dataSetRepo = tx.getRepository(DataSet)
 
@@ -33,12 +33,16 @@ export class DataSetMutation {
   @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
   @Directive('@transaction')
   @Mutation(returns => DataSet, { description: 'To modify DataSet information' })
-  async updateDataSet(@Arg('id') id: string, @Arg('patch') patch: DataSetPatch, @Ctx() context: any): Promise<DataSet> {
+  async updateDataSet(
+    @Arg('id') id: string,
+    @Arg('patch') patch: DataSetPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<DataSet> {
     const { domain, user, tx } = context.state
     const dataSetRepo = tx.getRepository(DataSet)
 
     const dataSet = await dataSetRepo.findOne({
-      where: { domain, id },
+      where: { domain: { id: domain.id }, id },
       relations: ['domain', 'dataKeySet', 'entryRole', 'supervisoryRole', 'creator', 'updater']
       /* history에 항상 반영될 수 있도록 relations가 있어야 함. */
     })
@@ -59,7 +63,7 @@ export class DataSetMutation {
   @Mutation(returns => [DataSet], { description: "To modify multiple DataSets' information" })
   async updateMultipleDataSet(
     @Arg('patches', type => [DataSetPatch]) patches: DataSetPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<DataSet[]> {
     const { domain, user, tx } = context.state
     const dataSetRepo = tx.getRepository(DataSet)
@@ -93,7 +97,8 @@ export class DataSetMutation {
       const cuFlag = 'M'
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const dataSet = await dataSetRepo.findOne(newRecord.id, {
+        const dataSet = await dataSetRepo.findOne({
+          where: { id: newRecord.id },
           /* history에 항상 반영될 수 있도록 relations가 있어야 함. */
           relations: ['domain', 'dataKeySet', 'entryRole', 'supervisoryRole', 'creator', 'updater']
         })
@@ -119,10 +124,10 @@ export class DataSetMutation {
   @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete DataSet' })
-  async deleteDataSet(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteDataSet(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(DataSet).delete({ domain, id })
+    await tx.getRepository(DataSet).delete({ domain: { id: domain.id }, id })
     await deleteAttachmentsByRef(null, { refBys: [`report-${id}`] }, context)
     return true
   }
@@ -130,11 +135,11 @@ export class DataSetMutation {
   @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple dataSets' })
-  async deleteDataSets(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteDataSets(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(DataSet).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 
@@ -148,7 +153,7 @@ export class DataSetMutation {
   @Mutation(returns => Boolean, { description: 'To import multiple data-sets' })
   async importDataSets(
     @Arg('dataSets', type => [DataSetPatch]) dataSets: DataSet[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
     const { domain, tx } = context.state
     const dataSetRepo = tx.getRepository(DataSet)
@@ -168,14 +173,14 @@ export class DataSetMutation {
   @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
   @Directive('@transaction')
   @Mutation(returns => [DataSet], { description: 'To copy multiple data-sets' })
-  async copyDataSets(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<DataSet[]> {
+  async copyDataSets(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<DataSet[]> {
     const { domain, user, tx } = context.state
     const dataSetRepo = tx.getRepository(DataSet)
 
     const originals = await dataSetRepo.find({
       where: {
         id: In(ids),
-        domain
+        domain: { id: domain.id }
       },
       relations: ['domain', 'supervisoryRole', 'entryRole', 'dataKeySet']
     })

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

@@ -1,10 +1,9 @@
 import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { Attachment } from '@things-factory/attachment-base'
 import { Role, User } from '@things-factory/auth-base'
 import { Board } from '@things-factory/board-service'
-import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
 
 import { DataKeySet } from '../data-key-set/data-key-set'
 import { DataSample } from '../data-sample/data-sample'
@@ -18,17 +17,17 @@ var parser = require('cron-parser')
 export class DataSetQuery {
   @Directive('@privilege(category: "data-set", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => DataSet, { description: 'To fetch a DataSet' })
-  async dataSet(@Arg('id') id: string, @Ctx() context: any): Promise<DataSet> {
+  async dataSet(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<DataSet> {
     const { domain } = context.state
 
     return await getRepository(DataSet).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Directive('@privilege(category: "data-set", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => DataSetList, { description: 'To fetch multiple DataSets' })
-  async dataSets(@Args() params: ListParam, @Ctx() context: any): Promise<DataSetList> {
+  async dataSets(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<DataSetList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -45,7 +44,7 @@ export class DataSetQuery {
   }
 
   @Query(returns => DataSetList, { description: 'To fetch multiple DataSets for data entry manually' })
-  async dataSetsForEntry(@Args() params: ListParam, @Ctx() context: any): Promise<DataSetList> {
+  async dataSetsForEntry(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<DataSetList> {
     var { domain, user } = context.state
 
     /* 조회한 사용자가 entry-role을 가진 data-set 리스트만 반환 */
@@ -74,7 +73,7 @@ export class DataSetQuery {
   }
 
   @Query(returns => DataSetList, { description: 'To fetch multiple DataSets to see data report' })
-  async dataSetsForReport(@Args() params: ListParam, @Ctx() context: any): Promise<DataSetList> {
+  async dataSetsForReport(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<DataSetList> {
     var { domain, user } = context.state
 
     /* 조회한 사용자가 supervisory 역할을 가진 data-set 리스트만 반환 */
@@ -115,7 +114,7 @@ export class DataSetQuery {
   async entryRole(@Root() dataSet: DataSet): Promise<Role> {
     return (
       dataSet.entryRole ||
-      (await getRepository(Role).findOne({
+      (await getRepository(Role).findOneBy({
         id: dataSet.entryRoleId
       }))
     )
@@ -125,7 +124,7 @@ export class DataSetQuery {
   async supervisoryRole(@Root() dataSet: DataSet): Promise<Role> {
     return (
       dataSet.supervisoryRole ||
-      (await getRepository(Role).findOne({
+      (await getRepository(Role).findOneBy({
         id: dataSet.supervisoryRoleId
       }))
     )
@@ -134,14 +133,14 @@ export class DataSetQuery {
   @FieldResolver(type => Board, { nullable: true })
   async entryBoard(@Root() dataSet: DataSet) {
     if (dataSet.entryType == 'board' && dataSet.entryView) {
-      return await getRepository(Board).findOne({ id: dataSet.entryView })
+      return await getRepository(Board).findOneBy({ id: dataSet.entryView })
     }
   }
 
   @FieldResolver(type => Board, { nullable: true })
   async monitorBoard(@Root() dataSet: DataSet) {
     if (dataSet.monitorType == 'board' && dataSet.monitorView) {
-      return await getRepository(Board).findOne({ id: dataSet.monitorView })
+      return await getRepository(Board).findOneBy({ id: dataSet.monitorView })
     }
   }
 
@@ -149,7 +148,7 @@ export class DataSetQuery {
   async dataKeySet(@Root() dataSet: DataSet) {
     return (
       dataSet.dataKeySet ||
-      (await getRepository(DataKeySet).findOne({
+      (await getRepository(DataKeySet).findOneBy({
         id: dataSet.dataKeySetId
       }))
     )
@@ -157,24 +156,24 @@ export class DataSetQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() dataSet: DataSet): Promise<Domain> {
-    return await getRepository(Domain).findOne(dataSet.domainId)
+    return await getRepository(Domain).findOneBy({ id: dataSet.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() dataSet: DataSet): Promise<User> {
-    return await getRepository(User).findOne(dataSet.updaterId)
+    return await getRepository(User).findOneBy({ id: dataSet.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() dataSet: DataSet): Promise<User> {
-    return await getRepository(User).findOne(dataSet.creatorId)
+    return await getRepository(User).findOneBy({ id: dataSet.creatorId })
   }
 
   @FieldResolver(type => Date, { nullable: true })
   async latestCollectedAt(@Root() dataSet: DataSet): Promise<Date> {
     const sample = await getRepository(DataSample).findOne({
       select: ['collectedAt'],
-      where: { dataSet },
+      where: { dataSet: { id: dataSet.id } },
       order: { collectedAt: 'DESC' }
     })
 
@@ -190,7 +189,7 @@ export class DataSetQuery {
     }
 
     var interval = parser.parseExpression(schedule, {
-      tz: timezone || ((await getRepository(Domain).findOne(domainId)) as Domain).timezone || 'UTC'
+      tz: timezone || ((await getRepository(Domain).findOneBy({ id: domainId })) as Domain).timezone || 'UTC'
     })
 
     return interval.next().toDate()
@@ -205,7 +204,7 @@ export class DataSetQuery {
     }
 
     var interval = parser.parseExpression(schedule, {
-      tz: timezone || ((await getRepository(Domain).findOne(domainId)) as Domain).timezone || 'UTC'
+      tz: timezone || ((await getRepository(Domain).findOneBy({ id: domainId })) as Domain).timezone || 'UTC'
     })
 
     return interval.prev().toDate()
@@ -215,7 +214,7 @@ export class DataSetQuery {
   async reportTemplate(@Root() dataset: DataSet): Promise<string | undefined> {
     const attachment: Attachment = await getRepository(Attachment).findOne({
       where: {
-        domain: dataset.domainId,
+        domain: { id: dataset.domainId },
         refType: `${DataSet.name}-report-template`,
         refBy: dataset.id
       }

package/server/service/data-set-history/data-set-history-query.ts

@@ -1,10 +1,9 @@
 import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { Attachment } from '@things-factory/attachment-base'
 import { Role, User } from '@things-factory/auth-base'
 import { Board } from '@things-factory/board-service'
-import { Domain, getQueryBuilderFromListParams, ListParam, ScalarDate } from '@things-factory/shell'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam, ScalarDate } from '@things-factory/shell'
 
 import { DataKeySet } from '../data-key-set/data-key-set'
 import { DataSet } from '../data-set/data-set'
@@ -18,18 +17,18 @@ export class DataSetHistoryQuery {
   async dataSetHistory(
     @Arg('id') id: string,
     @Arg('timestamp', type => ScalarDate) timestamp: Date,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<DataSetHistory> {
     const { domain } = context.state
 
     return await getRepository(DataSetHistory).findOne({
-      where: { domain, originalId: id, updatedAt: timestamp }
+      where: { domain: { id: domain.id }, originalId: id, updatedAt: timestamp }
     })
   }
 
   @Directive('@privilege(category: "data-set-history", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => DataSetHistoryList, { description: 'To fetch multiple DataSetHistories' })
-  async dataSetHistories(@Args() params: ListParam, @Ctx() context: any): Promise<DataSetHistoryList> {
+  async dataSetHistories(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<DataSetHistoryList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -48,7 +47,7 @@ export class DataSetHistoryQuery {
   async entryRole(@Root() dataSetHistory: DataSetHistory): Promise<Role> {
     return (
       dataSetHistory.entryRole ||
-      (await getRepository(Role).findOne({
+      (await getRepository(Role).findOneBy({
         id: dataSetHistory.entryRoleId
       }))
     )
@@ -58,7 +57,7 @@ export class DataSetHistoryQuery {
   async supervisoryRole(@Root() dataSetHistory: DataSetHistory): Promise<Role> {
     return (
       dataSetHistory.supervisoryRole ||
-      (await getRepository(Role).findOne({
+      (await getRepository(Role).findOneBy({
         id: dataSetHistory.supervisoryRoleId
       }))
     )
@@ -67,14 +66,14 @@ export class DataSetHistoryQuery {
   @FieldResolver(type => Board, { nullable: true })
   async entryBoard(@Root() dataSetHistory: DataSetHistory) {
     if (dataSetHistory.entryType == 'board' && dataSetHistory.entryView) {
-      return await getRepository(Board).findOne({ id: dataSetHistory.entryView })
+      return await getRepository(Board).findOneBy({ id: dataSetHistory.entryView })
     }
   }
 
   @FieldResolver(type => Board, { nullable: true })
   async monitorBoard(@Root() dataSetHistory: DataSetHistory) {
     if (dataSetHistory.monitorType == 'board' && dataSetHistory.monitorView) {
-      return await getRepository(Board).findOne({ id: dataSetHistory.monitorView })
+      return await getRepository(Board).findOneBy({ id: dataSetHistory.monitorView })
     }
   }
 
@@ -82,7 +81,7 @@ export class DataSetHistoryQuery {
   async dataKeySet(@Root() dataSet: DataSet) {
     return (
       dataSet.dataKeySet ||
-      (await getRepository(DataKeySet).findOne({
+      (await getRepository(DataKeySet).findOneBy({
         id: dataSet.dataKeySetId
       }))
     )
@@ -95,24 +94,24 @@ export class DataSetHistoryQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() dataSetHistory: DataSetHistory): Promise<Domain> {
-    return await getRepository(Domain).findOne(dataSetHistory.domainId)
+    return await getRepository(Domain).findOneBy({ id: dataSetHistory.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() dataSetHistory: DataSetHistory): Promise<User> {
-    return await getRepository(User).findOne(dataSetHistory.updaterId)
+    return await getRepository(User).findOneBy({ id: dataSetHistory.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() dataSetHistory: DataSetHistory): Promise<User> {
-    return await getRepository(User).findOne(dataSetHistory.creatorId)
+    return await getRepository(User).findOneBy({ id: dataSetHistory.creatorId })
   }
 
   @FieldResolver(type => String)
   async reportTemplate(@Root() dataSetHistory: DataSetHistory): Promise<string | undefined> {
     const attachment: Attachment = await getRepository(Attachment).findOne({
       where: {
-        domain: dataSetHistory.domainId,
+        domain: { id: dataSetHistory.domainId },
         refType: `${DataSet.name}-report-template`,
         refBy: dataSetHistory.originalId
       }