@things-factory/dataset 5.0.12 → 6.0.0-alpha.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@things-factory/dataset",
-  "version": "5.0.12",
+  "version": "6.0.0-alpha.0",
   "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.11",
-    "@things-factory/aws-base": "^5.0.11",
-    "@things-factory/board-service": "^5.0.11",
-    "@things-factory/env": "^5.0.0",
-    "@things-factory/shell": "^5.0.11",
-    "@things-factory/work-shift": "^5.0.11",
+    "@things-factory/auth-base": "^6.0.0-alpha.0",
+    "@things-factory/aws-base": "^6.0.0-alpha.0",
+    "@things-factory/board-service": "^6.0.0-alpha.0",
+    "@things-factory/env": "^6.0.0-alpha.0",
+    "@things-factory/shell": "^6.0.0-alpha.0",
+    "@things-factory/work-shift": "^6.0.0-alpha.0",
     "cron-parser": "^4.3.0",
     "moment-timezone": "^0.5.34"
   },
-  "gitHead": "fc92c5a8449721503a893d67aae8e65ce21a7890"
+  "gitHead": "e5b9823ab3ebc5d6ae5bcb4b5aa60c1306e4dd7e"
 }

package/server/controllers/create-data-sample.ts

@@ -11,6 +11,9 @@ import { NewDataSample } from '../service/data-sample/data-sample-type'
 import { DataSet } from '../service/data-set/data-set'
 import { DataUseCase } from './data-use-case'
 
+// See README.md at ## Data Samples
+process.env.TZ = 'UTC'
+
 const fillDataKeys = (dataKeySet, data) => {
   const keys = dataKeySet?.dataKeyItems || []
   return keys.reduce((sum, key, index) => {
@@ -93,6 +96,7 @@ export async function createDataSample(
     name: dataSet.name,
     description: dataSet.description,
     useCase: dataSet.useCase,
+    type: dataSet.type,
     ...dataSample,
     ...dataKeys,
     dataSetVersion: dataSet.version,

package/server/controllers/jasper-report.ts

@@ -104,20 +104,23 @@ function parseJsonDataField(rows) {
 const athenaClient = new AthenaController()
 
 async function queryAthena(params) {
-  const { table, domain, dataSetId, fromWorkDate, toWorkDate, workShift, timezone } = params
+  const { table, domain, datasetId, startDate, endDate, workShift, timezone } = params
   const queryData = {
-    sql: `SELECT name, description, data, spec, workdate, workshift, 
+    sql: `SELECT ds.name, ds.description, ds.data, dsh.data_items as spec, ds.workdate, ds.workshift,
     DATE_FORMAT(
       FROM_UNIXTIME(collected_at / 1000 / 1000) AT TIME ZONE '${timezone || 'UTC'}', 
       '%Y-%m-%d %H:%i:%s'
-    ) AS collected_at
-    FROM ${table} 
-    WHERE domain='${domain}' 
-    AND datasetid = '${dataSetId}'
-    AND workdate >= '${fromWorkDate}'
-    AND workdate <= '${toWorkDate}'
-    ${workShift ? "AND workshift = '" + workShift + "'" : ''}
-    ORDER BY collected_at`,
+    ) AS dscollected_at
+    FROM ${table} ds
+    JOIN data_set_histories dsh 
+      ON (ds.datasetid = dsh.original_id
+        and ds.data_set_version = dsh.version)
+    WHERE ds.domain='${domain}' 
+    AND ds.datasetid = '${datasetId}'
+    AND ds.workdate >= '${startDate}'
+    AND ds.workdate <= '${endDate}'
+    ${workShift ? "AND ds.workshift = '" + workShift + "'" : ''}
+    ORDER BY ds.collected_at`,
     db: DATABASE
   }
   // and json_extract_scalar(data, '$.dauid') = 'A8032AD81730'
@@ -131,7 +134,7 @@ export async function renderJasperReport(context: any) {
     query
   } = context
 
-  const template = await STORAGE.readFile(query['template'] || 'dynamic_header_sample.jrxml', 'utf-8')
+  const template = await STORAGE.readFile(query['reportTemplate'] || 'dynamic_header_sample.jrxml', 'utf-8')
   let templateType = query['templateType'] || 'crosstab'
   let parsedData = []
 
@@ -169,7 +172,9 @@ export async function renderJasperReport(context: any) {
     formData.append('jsonString', JSON.stringify(parsedData))
     formData.append('parameters', JSON.stringify(parameters))
 
-    const reportUrl = `${PROTOCOL || 'http'}://${HOST}:${PORT}/rest/report/show_html`
+    const { reportView } = query
+    const subpath = reportView ? reportView.split('/').filter(x => x).join('/') : ''
+    const reportUrl = `${PROTOCOL || 'http'}://${HOST}:${PORT}/${subpath}`
     const response = await fetch(reportUrl, {
       method: 'POST',
       body: formData

package/server/controllers/shiny-report.ts

@@ -0,0 +1,63 @@
+import FormData from 'form-data'
+import fetch from 'node-fetch'
+import { config } from '@things-factory/env'
+
+const querystring = require('querystring')
+const debug = require('debug')('things-factory:dataset:shiny-report')
+const dataReportConfig = config.get('dataReport')
+const {
+  shiny: {
+    endpoint: { protocol: PROTOCOL, host: HOST, port: PORT },
+    datasource: { database: DATABASE }
+  }
+} = Object.assign({
+  shiny: {
+    endpoint: {},
+    datasource: {}
+  }}, dataReportConfig)
+
+
+export async function renderShinyReport(context: any) {
+  debug('render:context', context)
+  
+  try {
+    const { access_token: token } = querystring.parse(context.header.cookie, ';')
+    const {
+      state: { domain },
+      query,
+      response,
+    } = context
+    
+    const urlParams = querystring.stringify({ 
+      token,
+      ...query, 
+      ...{ database: DATABASE,  
+      domain: domain?.subdomain }
+    })
+    
+    // const jsonParams = JSON.stringify({ 
+    //   ...query, 
+    //   ...{ database: DATABASE,  
+    //   domain: domain?.subdomain }
+    // })
+    
+    const protocol = `${PROTOCOL || 'http'}://`
+    const host = `${HOST}:${PORT}/`
+    const subpath = query?.reportView || ''
+
+    if (!subpath) {
+      return context.body = ''
+    }
+
+    // filter not empty and join '/'
+    const url = host.split('/').concat(subpath.split('/'))
+      .filter(x => x).join('/')
+    // const reportUrl = `${protocol}${url}/?params=${jsonParams}`
+    const reportUrl = `${protocol}${url}/?${urlParams}`
+
+    response.redirect(reportUrl)
+  } catch(ex) {
+    context.body = `Error: ${ex.message} || ''`
+  }
+  
+}

package/server/routes.ts

@@ -4,6 +4,7 @@ import { User } from '@things-factory/auth-base'
 
 import { createDataSample } from './controllers/create-data-sample'
 import { renderJasperReport } from './controllers/jasper-report'
+import { renderShinyReport } from './controllers/shiny-report'
 import { DataSensor } from './service/data-sensor/data-sensor'
 
 process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
@@ -89,4 +90,13 @@ process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRo
   domainPrivateRouter.get('/data-report/jasper', async (context, next) => {
     context.body = await renderJasperReport(context)
   })
+
+  domainPrivateRouter.get('/data-report/shiny', async (context, next) => {
+    await renderShinyReport(context)
+  })
+
+  domainPrivateRouter.get('/data-report/:reportType', async (context, next) => {
+    let { reportType } = context.params
+    context.body = `${reportType} Not Implemented.`
+  })
 })

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-key-set/data-key-set-type.ts

@@ -4,6 +4,7 @@ import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
 
 import { DataKeyItemPatch } from './data-key-item-type'
 import { DataKeySet } from './data-key-set'
+import { DataSetReportType } from '../data-set/data-set'
 
 @InputType()
 export class NewDataKeySet {
@@ -16,6 +17,12 @@ export class NewDataKeySet {
   @Field({ nullable: true })
   active?: boolean
 
+  @Field({ nullable: true })
+  reportType?: DataSetReportType
+
+  @Field({ nullable: true })
+  reportView?: string
+
   @Field(type => [DataKeyItemPatch], { nullable: true })
   dataKeyItems?: DataKeyItemPatch[]
 
@@ -37,6 +44,12 @@ export class DataKeySetPatch {
   @Field({ nullable: true })
   active?: boolean
 
+  @Field({ nullable: true })
+  reportType?: DataSetReportType
+
+  @Field({ nullable: true })
+  reportView?: string
+
   @Field(type => [DataKeyItemPatch], { nullable: true })
   dataKeyItems?: DataKeyItemPatch[]
 

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

@@ -14,6 +14,7 @@ import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
 
 import { DataKeyItem } from './data-key-item-type'
+import { DataSetReportType } from '../data-set/data-set'
 
 @Entity()
 @Index('ix_data_key_set_0', (dataKeySet: DataKeySet) => [dataKeySet.domain, dataKeySet.name], { unique: true })
@@ -46,6 +47,14 @@ export class DataKeySet {
   @Field({ nullable: true })
   active?: boolean
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  reportType?: DataSetReportType
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  reportView?: string
+
   @Column('simple-json', { nullable: true })
   @Field(type => [DataKeyItem], { nullable: true })
   dataKeyItems: DataKeyItem[]

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 })
   }
 }