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

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@things-factory/dataset",
-  "version": "5.0.16",
+  "version": "6.0.0-alpha.10",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
   "license": "MIT",
-  "author": "heartyoh",
+  "author": "heartyoh <heartyoh@hatiolab.com>",
   "description": "module for handling data collection",
   "publishConfig": {
     "access": "public",
@@ -34,14 +34,14 @@
     "@operato/shell": "^1.0.1",
     "@operato/styles": "^1.0.0",
     "@operato/utils": "^1.0.1",
-    "@things-factory/auth-base": "^5.0.15",
-    "@things-factory/aws-base": "^5.0.15",
-    "@things-factory/board-service": "^5.0.15",
-    "@things-factory/env": "^5.0.0",
-    "@things-factory/shell": "^5.0.15",
-    "@things-factory/work-shift": "^5.0.15",
+    "@things-factory/auth-base": "^6.0.0-alpha.10",
+    "@things-factory/aws-base": "^6.0.0-alpha.10",
+    "@things-factory/board-service": "^6.0.0-alpha.10",
+    "@things-factory/env": "^6.0.0-alpha.8",
+    "@things-factory/shell": "^6.0.0-alpha.8",
+    "@things-factory/work-shift": "^6.0.0-alpha.10",
     "cron-parser": "^4.3.0",
     "moment-timezone": "^0.5.34"
   },
-  "gitHead": "5abf91bd3004098a71b1cca6f155281188da0006"
+  "gitHead": "9ec9c564e157ebe830839e5a9cf8cfd6ec4e44b1"
 }

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

@@ -1,32 +1,48 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-import fetch from 'node-fetch'
 import i18next from 'i18next'
+import fetch from 'node-fetch'
+import {
+  Arg,
+  Ctx,
+  Directive,
+  Mutation,
+  Resolver
+} from 'type-graphql'
+import { In } from 'typeorm'
 
-import { DataArchive } from './data-archive'
-import { DataArchivePatch, NewDataArchive } from './data-archive-type'
 import { getEndpointUrl } from '../../utils/config-resolver'
+import { DataArchive } from './data-archive'
+import {
+  DataArchivePatch,
+  NewDataArchive
+} from './data-archive-type'
 
 const { config } = require('@things-factory/env')
 const crypto = require('crypto')
 
 @Resolver(DataArchive)
 export class DataArchiveMutation {
-
-  /** 
-   * It may use 'func-[dev]-data-set-download' in https://github.com/operatochef/serverless 
+  /**
+   * It may use 'func-[dev]-data-set-download' in https://github.com/operatochef/serverless
    * This function requests athena query and save the result as csv.gz in s3
-  */
+   */
   @Directive('@privilege(category: "data-archive", privilege: "mutation", domainOwnerGranted: true)')
   @Directive('@transaction')
   @Mutation(returns => DataArchive, { description: 'To create new DataArchive' })
-  async generatePresignedUrl(@Arg('patch') patch: DataArchivePatch, @Ctx() context: any): Promise<DataArchive> {
+  async generatePresignedUrl(
+    @Arg('patch') patch: DataArchivePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<DataArchive> {
     const { domain, user, tx, notify, lng } = context.state
     // const dataArchiveRepo = tx.getRepository(DataArchive)
     const t = i18next.getFixedT(lng, 'translations')
-    const { dataset: { endpoint, datasource: { database } }} = config.get('dataArchive')
-    
-    const body = JSON.stringify({ 
+    const {
+      dataset: {
+        endpoint,
+        datasource: { database }
+      }
+    } = config.get('dataArchive')
+
+    const body = JSON.stringify({
       domain: domain?.subdomain,
       database,
       ...patch?.requestParams
@@ -36,10 +52,10 @@ export class DataArchiveMutation {
 
     const fetched = await fetch(`${url}`, {
       method: 'POST',
-      headers: {'Content-Type': 'application/json'},
+      headers: { 'Content-Type': 'application/json' },
       body
     })
-    
+
     const message = {
       receivers: [user.email],
       mode: 'in-app',
@@ -59,7 +75,7 @@ export class DataArchiveMutation {
       const error = await fetched.text()
       console.log(error)
       patch.status = 'error'
-      
+
       message['title'] = t('title.data-archive request failed')
       // may not user-friendly message
       message['body'] = error
@@ -75,7 +91,10 @@ export class DataArchiveMutation {
   @Directive('@privilege(category: "data-archive", privilege: "mutation", domainOwnerGranted: true)')
   @Directive('@transaction')
   @Mutation(returns => DataArchive, { description: 'To create new DataArchive' })
-  async createDataArchive(@Arg('dataArchive') dataArchive: NewDataArchive, @Ctx() context: any): Promise<DataArchive> {
+  async createDataArchive(
+    @Arg('dataArchive') dataArchive: NewDataArchive,
+    @Ctx() context: ResolverContext
+  ): Promise<DataArchive> {
     const { domain, user, tx } = context.state
     const dataArchiveRepo = tx.getRepository(DataArchive)
 
@@ -92,12 +111,16 @@ export class DataArchiveMutation {
   @Directive('@privilege(category: "data-archive", privilege: "mutation", domainOwnerGranted: true)')
   @Directive('@transaction')
   @Mutation(returns => DataArchive, { description: 'To modify DataArchive information' })
-  async updateDataArchive(@Arg('id') id: string, @Arg('patch') patch: DataArchivePatch, @Ctx() context: any): Promise<DataArchive> {
+  async updateDataArchive(
+    @Arg('id') id: string,
+    @Arg('patch') patch: DataArchivePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<DataArchive> {
     const { domain, user, tx } = context.state
     const dataArchiveRepo = tx.getRepository(DataArchive)
 
     const dataArchive = await dataArchiveRepo.findOne({
-      where: { domain, id },
+      where: { domain: { id: domain.id }, id },
       relations: ['domain', 'creator', 'updater']
     })
 
@@ -170,7 +193,7 @@ export class DataArchiveMutation {
   @Directive('@privilege(category: "data-archive", privilege: "mutation", domainOwnerGranted: true)')
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete DataArchive' })
-  async deleteDataArchive(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteDataArchive(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(DataArchive).delete({ domain, id })
@@ -180,7 +203,10 @@ export class DataArchiveMutation {
   @Directive('@privilege(category: "data-archive", privilege: "mutation", domainOwnerGranted: true)')
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple dataArchives' })
-  async deleteDataArchives(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteDataArchives(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(DataArchive).delete({
@@ -196,7 +222,7 @@ export class DataArchiveMutation {
   @Mutation(returns => Boolean, { description: 'To import multiple data-archives' })
   async importDataArchives(
     @Arg('dataArchives', type => [DataArchivePatch]) dataArchives: DataArchive[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
     const { domain, tx } = context.state
     const dataArchiveRepo = tx.getRepository(DataArchive)
@@ -216,14 +242,17 @@ export class DataArchiveMutation {
   @Directive('@privilege(category: "data-archive", privilege: "mutation", domainOwnerGranted: true)')
   @Directive('@transaction')
   @Mutation(returns => [DataArchive], { description: 'To copy multiple data-archives' })
-  async copyDataArchives(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<DataArchive[]> {
+  async copyDataArchives(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<DataArchive[]> {
     const { domain, user, tx } = context.state
     const dataArchiveRepo = tx.getRepository(DataArchive)
 
     const originals = await dataArchiveRepo.find({
       where: {
         id: In(ids),
-        domain
+        domain: { id: domain.id }
       },
       relations: ['domain']
     })

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

@@ -1,8 +1,7 @@
 import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { Role, User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
+import { Domain, getQueryBuilderFromListParams, ListParam, getRepository } from '@things-factory/shell'
 
 import { DataArchive } from './data-archive'
 import { DataArchiveList } from './data-archive-type'
@@ -13,17 +12,17 @@ var parser = require('cron-parser')
 export class DataArchiveQuery {
   @Directive('@privilege(category: "data-archive", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => DataArchive, { description: 'To fetch a DataArchive' })
-  async dataArchive(@Arg('id') id: string, @Ctx() context: any): Promise<DataArchive> {
+  async dataArchive(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<DataArchive> {
     const { domain } = context.state
 
     return await getRepository(DataArchive).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Directive('@privilege(category: "data-archive", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => DataArchiveList, { description: 'To fetch multiple DataArchives' })
-  async dataArchives(@Args() params: ListParam, @Ctx() context: any): Promise<DataArchiveList> {
+  async dataArchives(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<DataArchiveList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -41,16 +40,16 @@ export class DataArchiveQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() dataArchive: DataArchive): Promise<Domain> {
-    return await getRepository(Domain).findOne(dataArchive.domainId)
+    return await getRepository(Domain).findOneBy({ id: dataArchive.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() dataArchive: DataArchive): Promise<User> {
-    return await getRepository(User).findOne(dataArchive.updaterId)
+    return await getRepository(User).findOneBy({ id: dataArchive.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() dataArchive: DataArchive): Promise<User> {
-    return await getRepository(User).findOne(dataArchive.creatorId)
+    return await getRepository(User).findOneBy({ id: dataArchive.creatorId })
   }
 }

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

@@ -1,16 +1,19 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { getRepository, In } from 'typeorm'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
 
 import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
 
 import { DataKeySet } from './data-key-set'
-import { NewDataKeySet, DataKeySetPatch } from './data-key-set-type'
+import { DataKeySetPatch, NewDataKeySet } from './data-key-set-type'
 
 @Resolver(DataKeySet)
 export class DataKeySetMutation {
   @Directive('@transaction')
   @Mutation(returns => DataKeySet, { description: 'To create new DataKeySet' })
-  async createDataKeySet(@Arg('dataKeySet') dataKeySet: NewDataKeySet, @Ctx() context: any): Promise<DataKeySet> {
+  async createDataKeySet(
+    @Arg('dataKeySet') dataKeySet: NewDataKeySet,
+    @Ctx() context: ResolverContext
+  ): Promise<DataKeySet> {
     const { domain, user, tx } = context.state
 
     const result = await tx.getRepository(DataKeySet).save({
@@ -42,13 +45,13 @@ export class DataKeySetMutation {
   async updateDataKeySet(
     @Arg('id') id: string,
     @Arg('patch') patch: DataKeySetPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<DataKeySet> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(DataKeySet)
     const dataKeySet = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
 
     const result = await repository.save({
@@ -79,7 +82,7 @@ export class DataKeySetMutation {
   @Mutation(returns => [DataKeySet], { description: "To modify multiple DataKeySets' information" })
   async updateMultipleDataKeySet(
     @Arg('patches', type => [DataKeySetPatch]) patches: DataKeySetPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<DataKeySet[]> {
     const { domain, user, tx } = context.state
 
@@ -120,7 +123,7 @@ export class DataKeySetMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const updateRecord = _updateRecords[i]
-        const dataKeySet = await dataKeySetRepo.findOne(updateRecord.id)
+        const dataKeySet = await dataKeySetRepo.findOneBy({ id: updateRecord.id })
 
         const result = await dataKeySetRepo.save({
           ...dataKeySet,
@@ -152,10 +155,10 @@ export class DataKeySetMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete DataKeySet' })
-  async deleteDataKeySet(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteDataKeySet(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(DataKeySet).delete({ domain, id })
+    await tx.getRepository(DataKeySet).delete({ domain: { id: domain.id }, id })
     await deleteAttachmentsByRef(null, { refBys: [id] }, context)
 
     return true
@@ -165,12 +168,12 @@ export class DataKeySetMutation {
   @Mutation(returns => Boolean, { description: 'To delete multiple DataKeySets' })
   async deleteDataKeySets(
     @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(DataKeySet).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 
@@ -183,7 +186,7 @@ export class DataKeySetMutation {
   @Mutation(returns => Boolean, { description: 'To import multiple DataKeySets' })
   async importDataKeySets(
     @Arg('dataKeySets', type => [DataKeySetPatch]) dataKeySets: DataKeySetPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
     const { domain, tx } = context.state
 

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

@@ -1,9 +1,8 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { Attachment } from '@things-factory/attachment-base'
 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 { DataKeySet } from './data-key-set'
 import { DataKeySetList } from './data-key-set-type'
@@ -11,16 +10,16 @@ import { DataKeySetList } from './data-key-set-type'
 @Resolver(DataKeySet)
 export class DataKeySetQuery {
   @Query(returns => DataKeySet!, { nullable: true, description: 'To fetch a DataKeySet' })
-  async dataKeySet(@Arg('id') id: string, @Ctx() context: any): Promise<DataKeySet> {
+  async dataKeySet(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<DataKeySet> {
     const { domain } = context.state
 
     return await getRepository(DataKeySet).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Query(returns => DataKeySetList, { description: 'To fetch multiple DataKeySets' })
-  async dataKeySets(@Args() params: ListParam, @Ctx() context: any): Promise<DataKeySetList> {
+  async dataKeySets(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<DataKeySetList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -39,7 +38,7 @@ export class DataKeySetQuery {
   async thumbnail(@Root() dataKeySet: DataKeySet): Promise<string | undefined> {
     const attachment: Attachment = await getRepository(Attachment).findOne({
       where: {
-        domain: dataKeySet.domainId,
+        domain: { id: dataKeySet.domainId },
         refType: DataKeySet.name,
         refBy: dataKeySet.id
       }
@@ -50,16 +49,16 @@ export class DataKeySetQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() dataKeySet: DataKeySet): Promise<Domain> {
-    return await getRepository(Domain).findOne(dataKeySet.domainId)
+    return await getRepository(Domain).findOneBy({ id: dataKeySet.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() dataKeySet: DataKeySet): Promise<User> {
-    return await getRepository(User).findOne(dataKeySet.updaterId)
+    return await getRepository(User).findOneBy({ id: dataKeySet.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() dataKeySet: DataKeySet): Promise<User> {
-    return await getRepository(User).findOne(dataKeySet.creatorId)
+    return await getRepository(User).findOneBy({ id: dataKeySet.creatorId })
   }
 }

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

@@ -8,7 +8,7 @@ export class DataOocMutation {
   @Directive('@privilege(category: "data-ooc", privilege: "mutation", domainOwnerGranted: true)')
   @Directive('@transaction')
   @Mutation(returns => DataOoc, { description: 'To create new DataOoc' })
-  async createDataOoc(@Arg('dataOoc') dataOoc: NewDataOoc, @Ctx() context: any): Promise<DataOoc> {
+  async createDataOoc(@Arg('dataOoc') dataOoc: NewDataOoc, @Ctx() context: ResolverContext): Promise<DataOoc> {
     const { domain, user, tx } = context.state
 
     const state = dataOoc.state || DataOocStatus.CREATED
@@ -36,12 +36,16 @@ export class DataOocMutation {
   @Directive('@privilege(category: "data-ooc", privilege: "mutation", domainOwnerGranted: true)')
   @Directive('@transaction')
   @Mutation(returns => DataOoc, { description: 'To modify DataOoc information' })
-  async updateDataOoc(@Arg('id') id: string, @Arg('patch') patch: DataOocPatch, @Ctx() context: any): Promise<DataOoc> {
+  async updateDataOoc(
+    @Arg('id') id: string,
+    @Arg('patch') patch: DataOocPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<DataOoc> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(DataOoc)
     const dataOoc = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
 
     const state = patch.state || dataOoc.state
@@ -82,7 +86,7 @@ export class DataOocMutation {
   // @Mutation(returns => [DataOoc], { description: "To modify multiple DataOoc' information" })
   // async updateMultipleDataOoc(
   //   @Arg('patches', type => [DataOocPatch]) patches: DataOocPatch[],
-  //   @Ctx() context: any
+  //   @Ctx() context: ResolverContext
   // ): Promise<DataOoc[]> {
   //   const { domain, user, tx } = context.state
 
@@ -109,7 +113,7 @@ export class DataOocMutation {
   //   if (_updateRecords.length > 0) {
   //     for (let i = 0; i < _updateRecords.length; i++) {
   //       const newRecord = _updateRecords[i]
-  //       const dataOoc = await dataOocRepo.findOne(newRecord.id)
+  //       const dataOoc = await dataOocRepo.findOneBy({id: newRecord.id})
 
   //       const result = await dataOocRepo.save({
   //         ...dataOoc,
@@ -127,17 +131,17 @@ export class DataOocMutation {
   // @Directive('@privilege(category: "data-ooc", privilege: "mutation", domainOwnerGranted: true)')
   // @Directive('@transaction')
   // @Mutation(returns => Boolean, { description: 'To delete DataOoc' })
-  // async deleteDataOoc(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  // async deleteDataOoc(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
   //   const { domain, tx } = context.state
 
-  //   await tx.getRepository(DataOoc).delete({ domain, id })
+  //   await tx.getRepository(DataOoc).delete({ domain: { id: domain.id }, id })
   //   return true
   // }
 
   // @Directive('@privilege(category: "data-ooc", privilege: "mutation", domainOwnerGranted: true)')
   // @Directive('@transaction')
   // @Mutation(returns => Boolean, { description: 'To delete multiple dataOocs' })
-  // async deleteDataOocs(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  // async deleteDataOocs(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
   //   const { domain, tx } = context.state
 
   //   await tx.getRepository(DataOoc).delete({

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

@@ -1,8 +1,7 @@
 import { Arg, Args, Ctx, Directive, 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 { DataSetHistory } from '../data-set-history/data-set-history'
 import { DataItem } from '../data-set/data-item-type'
@@ -14,17 +13,17 @@ import { DataOocList } from './data-ooc-type'
 export class DataOocQuery {
   @Directive('@privilege(category: "data-ooc", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => DataOoc, { description: 'To fetch a DataOoc' })
-  async dataOoc(@Arg('id') id: string, @Ctx() context: any): Promise<DataOoc> {
+  async dataOoc(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<DataOoc> {
     const { domain } = context.state
 
     return await getRepository(DataOoc).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Directive('@privilege(category: "data-ooc", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => DataOocList, { description: 'To fetch multiple DataOoc' })
-  async dataOocs(@Args() params: ListParam, @Ctx() context: any): Promise<DataOocList> {
+  async dataOocs(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<DataOocList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -52,23 +51,23 @@ export class DataOocQuery {
 
   @FieldResolver(type => DataSet)
   async dataSet(@Root() dataOoc: DataOoc): Promise<DataSet> {
-    return await getRepository(DataSet).findOne({
+    return await getRepository(DataSet).findOneBy({
       id: dataOoc.dataSetId
     })
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() dataOoc: DataOoc): Promise<Domain> {
-    return await getRepository(Domain).findOne(dataOoc.domainId)
+    return await getRepository(Domain).findOneBy({ id: dataOoc.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() dataOoc: DataOoc): Promise<User> {
-    return await getRepository(User).findOne(dataOoc.updaterId)
+    return await getRepository(User).findOneBy({ id: dataOoc.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() dataOoc: DataOoc): Promise<User> {
-    return await getRepository(User).findOne(dataOoc.creatorId)
+    return await getRepository(User).findOneBy({ id: dataOoc.creatorId })
   }
 }

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

@@ -1,9 +1,8 @@
 import { withFilter } from 'graphql-subscriptions'
 import { Resolver, Root, Subscription } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { pubsub } from '@things-factory/shell'
+import { getRepository, pubsub } from '@things-factory/shell'
 
 import { DataOoc } from './data-ooc'
 

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

@@ -9,7 +9,10 @@ export class DataSampleMutation {
   @Directive('@privilege(category: "data-sample", privilege: "mutation", domainOwnerGranted: true)')
   @Directive('@transaction')
   @Mutation(returns => DataSample, { description: 'To create new data sample' })
-  async createDataSample(@Arg('dataSample') dataSample: NewDataSample, @Ctx() context: any): Promise<DataSample> {
+  async createDataSample(
+    @Arg('dataSample') dataSample: NewDataSample,
+    @Ctx() context: ResolverContext
+  ): Promise<DataSample> {
     return await createDataSample(dataSample, context)
   }
 }

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

@@ -1,8 +1,7 @@
 import { Arg, Args, Ctx, Directive, 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 { DataKeySet } from '../data-key-set/data-key-set'
 import { DataSetHistory } from '../data-set-history/data-set-history'
@@ -15,17 +14,17 @@ import { DataSampleList } from './data-sample-type'
 export class DataSampleQuery {
   @Directive('@privilege(category: "data-sample", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => DataSample, { description: 'To fetch a data sample' })
-  async dataSample(@Arg('id') id: string, @Ctx() context: any): Promise<DataSample> {
+  async dataSample(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<DataSample> {
     const { domain } = context.state
 
     return await getRepository(DataSample).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Directive('@privilege(category: "data-sample", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => DataSampleList, { description: 'To fetch multiple data samples' })
-  async dataSamples(@Args() params: ListParam, @Ctx() context: any): Promise<DataSampleList> {
+  async dataSamples(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<DataSampleList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -45,11 +44,11 @@ export class DataSampleQuery {
   async dataSamplesByDataKeySet(
     @Arg('dataKeySetId') dataKeySetId: string,
     @Args() params: ListParam,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<DataSampleList> {
     const { domain } = context.state
 
-    const dataKeySet = await getRepository(DataKeySet).findOne(dataKeySetId)
+    const dataKeySet = await getRepository(DataKeySet).findOneBy({ id: dataKeySetId })
     const dataKeyItems = dataKeySet?.dataKeyItems || []
     const searchables = dataKeyItems.map((item, index) => `key0${index + 1}`)
 
@@ -81,21 +80,21 @@ export class DataSampleQuery {
 
   @FieldResolver(type => DataSet)
   async dataSet(@Root() dataSample: DataSample): Promise<DataSet> {
-    return await getRepository(DataSet).findOne(dataSample.dataSetId)
+    return await getRepository(DataSet).findOneBy({ id: dataSample.dataSetId })
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() dataSample: DataSample): Promise<Domain> {
-    return await getRepository(Domain).findOne(dataSample.domainId)
+    return await getRepository(Domain).findOneBy({ id: dataSample.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() dataSample: DataSample): Promise<User> {
-    return await getRepository(User).findOne(dataSample.updaterId)
+    return await getRepository(User).findOneBy({ id: dataSample.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() dataSample: DataSample): Promise<User> {
-    return await getRepository(User).findOne(dataSample.creatorId)
+    return await getRepository(User).findOneBy({ id: dataSample.creatorId })
   }
 }