@things-factory/dataset 6.2.54 → 6.2.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/dataset",
-  "version": "6.2.54",
+  "version": "6.2.57",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -39,17 +39,17 @@
     "@operato/utils": "^1.0.1",
     "@things-factory/auth-base": "^6.2.54",
     "@things-factory/aws-base": "^6.2.54",
-    "@things-factory/board-service": "^6.2.54",
+    "@things-factory/board-service": "^6.2.57",
     "@things-factory/env": "^6.2.33",
     "@things-factory/organization": "^6.2.54",
     "@things-factory/scheduler-client": "^6.2.54",
     "@things-factory/shell": "^6.2.52",
     "@things-factory/work-shift": "^6.2.54",
-    "@things-factory/worklist": "^6.2.54",
+    "@things-factory/worklist": "^6.2.57",
     "cron-parser": "^4.3.0",
     "moment-timezone": "^0.5.40",
     "simple-statistics": "^7.8.3",
     "statistics": "^3.3.0"
   },
-  "gitHead": "db6b9a9109a090c4dd705058949fce624f15b0ef"
+  "gitHead": "de09b15757a2bad601a2e23dc52f16b0d816a420"
 }

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

@@ -196,8 +196,8 @@ export async function createDataSample(dataSample: NewDataSample, context: Resol
       history: [
         {
           user: {
-            id: user.id,
-            name: user.name
+            id: user?.id,
+            name: user?.name
           },
           state: DataOocStatus.ISSUED,
           timestamp: collectedAt
@@ -262,7 +262,7 @@ export async function createDataSample(dataSample: NewDataSample, context: Resol
     } catch (err) {
       logger.error('Notification', err)
     }
-  } else if(dataSet.requiresReview) {
+  } else if (dataSet.requiresReview) {
     const activity = (await tx.getRepository(Activity).findOneBy({
       domain: { id: domain.id },
       name: 'Data Review'

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

@@ -40,16 +40,16 @@ export class DataArchiveQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() dataArchive: DataArchive): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: dataArchive.domainId })
+    return dataArchive.domainId && (await getRepository(Domain).findOneBy({ id: dataArchive.domainId }))
   }
 
   @FieldResolver(type => User)
   async updater(@Root() dataArchive: DataArchive): Promise<User> {
-    return await getRepository(User).findOneBy({ id: dataArchive.updaterId })
+    return dataArchive.updaterId && (await getRepository(User).findOneBy({ id: dataArchive.updaterId }))
   }
 
   @FieldResolver(type => User)
   async creator(@Root() dataArchive: DataArchive): Promise<User> {
-    return await getRepository(User).findOneBy({ id: dataArchive.creatorId })
+    return dataArchive.creatorId && (await getRepository(User).findOneBy({ id: dataArchive.creatorId }))
   }
 }

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

@@ -50,16 +50,16 @@ export class DataKeySetQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() dataKeySet: DataKeySet): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: dataKeySet.domainId })
+    return dataKeySet.domainId && (await getRepository(Domain).findOneBy({ id: dataKeySet.domainId }))
   }
 
   @FieldResolver(type => User)
   async updater(@Root() dataKeySet: DataKeySet): Promise<User> {
-    return await getRepository(User).findOneBy({ id: dataKeySet.updaterId })
+    return dataKeySet.updaterId && (await getRepository(User).findOneBy({ id: dataKeySet.updaterId }))
   }
 
   @FieldResolver(type => User)
   async creator(@Root() dataKeySet: DataKeySet): Promise<User> {
-    return await getRepository(User).findOneBy({ id: dataKeySet.creatorId })
+    return dataKeySet.creatorId && (await getRepository(User).findOneBy({ id: dataKeySet.creatorId }))
   }
 }

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

@@ -180,16 +180,16 @@ export class DataSampleQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() dataSample: DataSample): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: dataSample.domainId })
+    return dataSample.domainId && (await getRepository(Domain).findOneBy({ id: dataSample.domainId }))
   }
 
   @FieldResolver(type => User)
   async updater(@Root() dataSample: DataSample): Promise<User> {
-    return await getRepository(User).findOneBy({ id: dataSample.updaterId })
+    return dataSample.updaterId && (await getRepository(User).findOneBy({ id: dataSample.updaterId }))
   }
 
   @FieldResolver(type => User)
   async creator(@Root() dataSample: DataSample): Promise<User> {
-    return await getRepository(User).findOneBy({ id: dataSample.creatorId })
+    return dataSample.creatorId && (await getRepository(User).findOneBy({ id: dataSample.creatorId }))
   }
 }

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

@@ -46,16 +46,16 @@ export class DataSensorQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() dataSensor: DataSensor): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: dataSensor.domainId })
+    return dataSensor.domainId && (await getRepository(Domain).findOneBy({ id: dataSensor.domainId }))
   }
 
   @FieldResolver(type => User)
   async updater(@Root() dataSensor: DataSensor): Promise<User> {
-    return await getRepository(User).findOneBy({ id: dataSensor.updaterId })
+    return dataSensor.updaterId && (await getRepository(User).findOneBy({ id: dataSensor.updaterId }))
   }
 
   @FieldResolver(type => User)
   async creator(@Root() dataSensor: DataSensor): Promise<User> {
-    return await getRepository(User).findOneBy({ id: dataSensor.creatorId })
+    return dataSensor.creatorId && (await getRepository(User).findOneBy({ id: dataSensor.creatorId }))
   }
 }

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

@@ -268,17 +268,17 @@ export class DataSetQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() dataSet: DataSet): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: dataSet.domainId })
+    return dataSet.domainId && (await getRepository(Domain).findOneBy({ id: dataSet.domainId }))
   }
 
   @FieldResolver(type => User)
   async updater(@Root() dataSet: DataSet): Promise<User> {
-    return await getRepository(User).findOneBy({ id: dataSet.updaterId })
+    return dataSet.updaterId && (await getRepository(User).findOneBy({ id: dataSet.updaterId }))
   }
 
   @FieldResolver(type => User)
   async creator(@Root() dataSet: DataSet): Promise<User> {
-    return await getRepository(User).findOneBy({ id: dataSet.creatorId })
+    return dataSet.creatorId && (await getRepository(User).findOneBy({ id: dataSet.creatorId }))
   }
 
   @FieldResolver(type => Date, { nullable: true })

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

@@ -97,17 +97,17 @@ export class DataSetHistoryQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() dataSetHistory: DataSetHistory): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: dataSetHistory.domainId })
+    return dataSetHistory.domainId && (await getRepository(Domain).findOneBy({ id: dataSetHistory.domainId }))
   }
 
   @FieldResolver(type => User)
   async updater(@Root() dataSetHistory: DataSetHistory): Promise<User> {
-    return await getRepository(User).findOneBy({ id: dataSetHistory.updaterId })
+    return dataSetHistory.updaterId && (await getRepository(User).findOneBy({ id: dataSetHistory.updaterId }))
   }
 
   @FieldResolver(type => User)
   async creator(@Root() dataSetHistory: DataSetHistory): Promise<User> {
-    return await getRepository(User).findOneBy({ id: dataSetHistory.creatorId })
+    return dataSetHistory.creatorId && (await getRepository(User).findOneBy({ id: dataSetHistory.creatorId }))
   }
 
   @FieldResolver(type => String)

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

@@ -161,16 +161,16 @@ export class DataSummaryQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() dataSummary: DataSummary): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: dataSummary.domainId })
+    return dataSummary.domainId && (await getRepository(Domain).findOneBy({ id: dataSummary.domainId }))
   }
 
   @FieldResolver(type => User)
   async updater(@Root() dataSummary: DataSummary): Promise<User> {
-    return await getRepository(User).findOneBy({ id: dataSummary.updaterId })
+    return dataSummary.updaterId && (await getRepository(User).findOneBy({ id: dataSummary.updaterId }))
   }
 
   @FieldResolver(type => User)
   async creator(@Root() dataSummary: DataSummary): Promise<User> {
-    return await getRepository(User).findOneBy({ id: dataSummary.creatorId })
+    return dataSummary.creatorId && (await getRepository(User).findOneBy({ id: dataSummary.creatorId }))
   }
 }