@things-factory/dataset 5.0.0-zeta.8 → 5.0.1

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

@@ -1,10 +1,8 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
+import { In } from 'typeorm'
 
 import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
-import { Domain } from '@things-factory/shell'
 
-import { DataItem } from '../data-item/data-item'
 import { DataSet } from './data-set'
 import { DataSetPatch, NewDataSet } from './data-set-type'
 
@@ -17,9 +15,11 @@ export class DataSetMutation {
   @Mutation(returns => DataSet, { description: 'To create new DataSet' })
   async createDataSet(@Arg('dataSet') dataSet: NewDataSet, @Ctx() context: any): Promise<DataSet> {
     const { domain, user, tx } = context.state
+    const dataSetRepo = tx.getRepository(DataSet)
 
-    const result = await tx.getRepository(DataSet).save({
+    const result = await dataSetRepo.save({
       ...dataSet,
+      version: 1,
       domain,
       creator: user,
       updater: user
@@ -35,13 +35,13 @@ export class DataSetMutation {
   @Mutation(returns => DataSet, { description: 'To modify DataSet information' })
   async updateDataSet(@Arg('id') id: string, @Arg('patch') patch: DataSetPatch, @Ctx() context: any): Promise<DataSet> {
     const { domain, user, tx } = context.state
+    const dataSetRepo = tx.getRepository(DataSet)
 
-    const repository = tx.getRepository(DataSet)
-    const dataSet = await repository.findOne({
+    const dataSet = await dataSetRepo.findOne({
       where: { domain, id }
     })
 
-    const result = await repository.save({
+    const result = await dataSetRepo.save({
       ...dataSet,
       ...patch,
       updater: user
@@ -60,11 +60,11 @@ export class DataSetMutation {
     @Ctx() context: any
   ): Promise<DataSet[]> {
     const { domain, user, tx } = context.state
+    const dataSetRepo = tx.getRepository(DataSet)
 
     let results = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
     const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const dataSetRepo = tx.getRepository(DataSet)
 
     if (_createRecords.length > 0) {
       const cuFlag = '+'
@@ -80,7 +80,12 @@ export class DataSetMutation {
 
         await this._createAttachment(context, newRecord.reportTemplate, { refId: result.id, cuFlag })
 
-        results.push({ ...result, cuFlag })
+        results.push({
+          ...(await dataSetRepo.findOne(result.id, {
+            relations: ['domain', 'creator', 'updater', 'supervisoryRole', 'entryRole']
+          })),
+          cuFlag
+        })
       }
     }
 
@@ -98,7 +103,12 @@ export class DataSetMutation {
 
         await this._createAttachment(context, newRecord.reportTemplate, { refId: result.id, cuFlag })
 
-        results.push({ ...result, cuFlag })
+        results.push({
+          ...(await dataSetRepo.findOne(result.id, {
+            relations: ['domain', 'creator', 'updater', 'supervisoryRole', 'entryRole']
+          })),
+          cuFlag
+        })
       }
     }
 
@@ -139,20 +149,15 @@ export class DataSetMutation {
     @Arg('dataSets', type => [DataSetPatch]) dataSets: DataSet[],
     @Ctx() context: any
   ): Promise<boolean> {
-    const tx: EntityManager = context.state.tx
-    const domain: Domain = context.state.domain
+    const { domain, tx } = context.state
+    const dataSetRepo = tx.getRepository(DataSet)
+
     await Promise.all(
       dataSets.map(async (dataSet: DataSet) => {
-        const createdDataSet: DataSet = await tx.getRepository(DataSet).save({ domain, ...dataSet })
-        if (dataSet.dataItems?.length) {
-          await tx.getRepository(DataItem).save(
-            dataSet.dataItems.map((dataItem: DataItem) => {
-              dataItem.domain = domain
-              dataItem.dataSet = createdDataSet
-              return dataItem
-            })
-          )
-        }
+        const createdDataSet: DataSet = await dataSetRepo.save({
+          domain,
+          ...dataSet
+        })
       })
     )
 
@@ -164,69 +169,37 @@ export class DataSetMutation {
   @Mutation(returns => [DataSet], { description: 'To copy multiple data-sets' })
   async copyDataSets(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<DataSet[]> {
     const { domain, user, tx } = context.state
+    const dataSetRepo = tx.getRepository(DataSet)
 
-    const originals = await tx.getRepository(DataSet).find({
+    const originals = await dataSetRepo.find({
       where: {
         id: In(ids),
         domain
       },
-      relations: ['domain', 'dataItems']
+      relations: ['domain', 'supervisoryRole', 'entryRole']
     })
 
     if (originals.length == 0) {
       return []
     }
 
-    var newDataItems = []
-
     var newCopys = originals.map(dataSet => {
       let dataSetId = crypto.randomUUID()
-      newDataItems.push(
-        ...dataSet.dataItems.map(dataItem => {
-          return {
-            dataSet: dataSetId,
-            name: dataItem.name,
-            description: dataItem.description,
-            sequence: dataItem.sequence,
-            tag: dataItem.tag,
-            active: dataItem.active,
-            type: dataItem.type,
-            quota: dataItem.quota,
-            spec: dataItem.spec,
-            unit: dataItem.unit,
-            options: dataItem.options,
-            hidden: dataItem.hidden,
-            // connection: dataItem.connection,
-            // params: dataItem.params,
-            domain,
-            creator: user,
-            updater: user
-          }
-        })
-      )
 
       return {
+        ...dataSet,
         id: dataSetId,
         name: dataSet.name + ' (' + dataSetId + ')',
-        type: dataSet.type,
-        description: dataSet.description,
         active: false,
-        schedule: dataSet.schedule,
-        timezone: dataSet.timezone,
-
         domain,
         creator: user,
         updater: user
       }
     })
 
-    var copiedDataSets = await tx.getRepository(DataSet).save(newCopys)
-    var copiedDataItems = await tx.getRepository(DataItem).save(newDataItems)
+    var copiedDataSets = await dataSetRepo.save(newCopys)
 
-    return copiedDataSets.map(dataSet => {
-      dataSet.dataItems = copiedDataItems.filter(dataItem => dataItem.dataSet == dataSet.id)
-      return dataSet
-    })
+    return copiedDataSets
   }
 
   async _createAttachment(context, attachment, { refId, cuFlag }) {

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

@@ -103,6 +103,11 @@ export class DataSetQuery {
 
   @FieldResolver(type => [DataItem])
   async dataItems(@Root() dataSet: DataSet): Promise<DataItem[]> {
+    /* TODO this fieldResolver should be removed. This is only for migration temporarily */
+    if (dataSet.dataItems) {
+      return dataSet.dataItems as DataItem[]
+    }
+
     return await getRepository(DataItem).find({
       dataSet
     })

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

@@ -1,8 +1,10 @@
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
 import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
-import { FileUpload, GraphQLUpload } from 'graphql-upload'
 
 import { ObjectRef, ScalarObject } from '@things-factory/shell'
 
+import { DataItemPatch } from './data-item-type'
 import { DataSet, DataSetEntryType, DataSetMonitorType, DataSetReportType } from './data-set'
 
 @InputType()
@@ -31,6 +33,9 @@ export class NewDataSet {
   @Field(type => ScalarObject, { nullable: true })
   partitionKeys?: ScalarObject
 
+  @Field(type => [DataItemPatch], { nullable: true })
+  dataItems?: DataItemPatch[]
+
   @Field({ nullable: true })
   schedule?: string
 
@@ -88,6 +93,9 @@ export class DataSetPatch {
   @Field(type => ScalarObject, { nullable: true })
   partitionKeys?: ScalarObject
 
+  @Field(type => [DataItemPatch], { nullable: true })
+  dataItems?: DataItemPatch[]
+
   @Field({ nullable: true })
   schedule?: string
 

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

@@ -5,16 +5,16 @@ import {
   Entity,
   Index,
   ManyToOne,
-  OneToMany,
   PrimaryGeneratedColumn,
   RelationId,
-  UpdateDateColumn
+  UpdateDateColumn,
+  VersionColumn
 } from 'typeorm'
 
 import { Role, User } from '@things-factory/auth-base'
 import { Domain, ScalarObject } from '@things-factory/shell'
 
-import { DataItem } from '../data-item/data-item'
+import { DataItem } from './data-item-type'
 
 export enum DataSetEntryType {
   Generated = 'generated',
@@ -77,6 +77,10 @@ export class DataSet {
   @Field({ nullable: true })
   description?: string
 
+  @VersionColumn({ nullable: true, default: 1 })
+  @Field({ nullable: true })
+  version?: number = 1
+
   @Column({
     nullable: true
   })
@@ -156,7 +160,7 @@ export class DataSet {
   @Field(type => ScalarObject, { nullable: true })
   partitionKeys?: ScalarObject
 
-  @OneToMany(type => DataItem, dataItem => dataItem.dataSet)
+  @Column('simple-json', { nullable: true })
   @Field(type => [DataItem], { nullable: true })
   dataItems: DataItem[]
 

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

@@ -0,0 +1,110 @@
+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 { DataSetHistory } from './data-set-history'
+import { DataSetHistoryList } from './data-set-history-type'
+
+@Resolver(DataSetHistory)
+export class DataSetHistoryQuery {
+  @Directive('@privilege(category: "data-set-history", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataSetHistory, { description: 'To fetch a DataSetHistory' })
+  async dataSetHistory(
+    @Arg('id') id: string,
+    @Arg('timestamp', type => ScalarDate) timestamp: ScalarDate,
+    @Ctx() context: any
+  ): Promise<DataSetHistory> {
+    const { domain } = context.state
+
+    return await getRepository(DataSetHistory).findOne({
+      where: { domain, 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> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(DataSetHistory),
+      params,
+      domain,
+      searchables: ['name', 'description', 'supervisoryRole']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Role)
+  async entryRole(@Root() dataSetHistory: DataSetHistory): Promise<Role> {
+    return (
+      dataSetHistory.entryRole ||
+      (await getRepository(Role).findOne({
+        id: dataSetHistory.entryRoleId
+      }))
+    )
+  }
+
+  @FieldResolver(type => Role)
+  async supervisoryRole(@Root() dataSetHistory: DataSetHistory): Promise<Role> {
+    return (
+      dataSetHistory.supervisoryRole ||
+      (await getRepository(Role).findOne({
+        id: dataSetHistory.supervisoryRoleId
+      }))
+    )
+  }
+
+  @FieldResolver(type => Board, { nullable: true })
+  async entryBoard(@Root() dataSetHistory: DataSetHistory) {
+    if (dataSetHistory.entryType == 'board' && dataSetHistory.entryView) {
+      return await getRepository(Board).findOne({ 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 })
+    }
+  }
+
+  @FieldResolver(type => User)
+  async timestamp(@Root() dataSetHistory: DataSetHistory): Promise<User> {
+    return dataSetHistory.updatedAt
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() dataSetHistory: DataSetHistory): Promise<Domain> {
+    return await getRepository(Domain).findOne(dataSetHistory.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() dataSetHistory: DataSetHistory): Promise<User> {
+    return await getRepository(User).findOne(dataSetHistory.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() dataSetHistory: DataSetHistory): Promise<User> {
+    return await getRepository(User).findOne(dataSetHistory.creatorId)
+  }
+
+  @FieldResolver(type => String)
+  async reportTemplate(@Root() dataSetHistory: DataSetHistory): Promise<string | undefined> {
+    const attachment: Attachment = await getRepository(Attachment).findOne({
+      where: {
+        domain: dataSetHistory.domainId,
+        refBy: `report-${dataSetHistory.originalId}`
+      }
+    })
+
+    return attachment?.path
+  }
+}

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

@@ -0,0 +1,12 @@
+import { Field, Int, ObjectType } from 'type-graphql'
+
+import { DataSetHistory } from '../data-set-history/data-set-history'
+
+@ObjectType()
+export class DataSetHistoryList {
+  @Field(type => [DataSetHistory])
+  items: DataSetHistory[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,161 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId } from 'typeorm'
+
+import {
+  HistoryActionColumn,
+  HistoryActionType,
+  HistoryEntityInterface,
+  HistoryOriginalIdColumn
+} from '@anchan828/typeorm-history'
+import { Role, User } from '@things-factory/auth-base'
+import { config } from '@things-factory/env'
+import { Domain, ScalarObject } from '@things-factory/shell'
+
+import { DataItem } from '../data-set/data-item-type'
+import { DataSet, DataSetEntryType, DataSetMonitorType, DataSetReportType } from '../data-set/data-set'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+@Entity()
+@Index(
+  'ix_data_set_history_0',
+  (dataSetHistory: DataSetHistory) => [dataSetHistory.originalId, dataSetHistory.version],
+  { unique: true }
+)
+@Index(
+  'ix_data_set_history_1',
+  (dataSetHistory: DataSetHistory) => [dataSetHistory.domain, dataSetHistory.originalId, dataSetHistory.version],
+  { unique: true }
+)
+@ObjectType({ description: 'Entity for DataSetHistory' })
+export class DataSetHistory implements HistoryEntityInterface<DataSet> {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({ default: 1 })
+  @Field({ nullable: true })
+  readonly version: number = 1
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((dataSetHistory: DataSetHistory) => dataSetHistory.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  active?: boolean
+
+  @ManyToOne(type => Role, { nullable: true })
+  @Field(type => Role, { nullable: true })
+  entryRole?: Role
+
+  @RelationId((dataSetHistory: DataSetHistory) => dataSetHistory.entryRole)
+  entryRoleId?: string
+
+  @ManyToOne(type => Role, { nullable: true })
+  @Field(type => Role, { nullable: true })
+  supervisoryRole?: Role
+
+  @RelationId((dataSetHistory: DataSetHistory) => dataSetHistory.supervisoryRole)
+  supervisoryRoleId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  type?: 'manual' | 'automatic' | string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  entryType?: DataSetEntryType
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  entryView?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  monitorType?: DataSetMonitorType
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  monitorView?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  reportType?: DataSetReportType
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  reportView?: string
+
+  @Field({ nullable: true })
+  reportTemplate?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  useCase?: string
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  partitionKeys?: ScalarObject
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => [DataItem], { nullable: true })
+  dataItems: DataItem[]
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  schedule?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  timezone?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((dataSetHistory: DataSetHistory) => dataSetHistory.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((dataSetHistory: DataSetHistory) => dataSetHistory.creator)
+  updaterId?: string
+
+  @HistoryOriginalIdColumn({ nullable: true })
+  public originalId!: string
+
+  @HistoryActionColumn({
+    nullable: false,
+    type:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'enum'
+        : DATABASE_TYPE == 'oracle'
+        ? 'varchar2'
+        : 'smallint',
+    enum: HistoryActionType
+  })
+  public action!: HistoryActionType
+}

package/server/service/data-set-history/event-subscriber.ts

@@ -0,0 +1,17 @@
+import { EventSubscriber } from 'typeorm'
+
+import { HistoryEntitySubscriber } from '@anchan828/typeorm-history'
+
+import { DataSet } from '../data-set/data-set'
+import { DataSetHistory } from './data-set-history'
+
+@EventSubscriber()
+export class DataSetHistoryEntitySubscriber extends HistoryEntitySubscriber<DataSet, DataSetHistory> {
+  public get entity() {
+    return DataSet
+  }
+
+  public get historyEntity() {
+    return DataSetHistory
+  }
+}

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

@@ -0,0 +1,7 @@
+import { DataSetHistory } from './data-set-history'
+import { DataSetHistoryQuery } from './data-set-history-query'
+import { DataSetHistoryEntitySubscriber } from './event-subscriber'
+
+export const entities = [DataSetHistory]
+export const resolvers = [DataSetHistoryQuery]
+export const subscribers = [DataSetHistoryEntitySubscriber]

package/server/service/index.ts

@@ -1,37 +1,49 @@
-import { entities as DataItemEntities, resolvers as DataItemResolvers } from './data-item'
+import { entities as DataItemEntities } from './data-item'
 /* IMPORT ENTITIES AND RESOLVERS */
 import { entities as DataOocEntities, resolvers as DataOocResolvers } from './data-ooc'
 import { entities as DataSampleEntities, resolvers as DataSampleResolvers } from './data-sample'
 import { entities as DataSensorEntities, resolvers as DataSensorResolvers } from './data-sensor'
 import { entities as DataSetEntities, resolvers as DataSetResolvers } from './data-set'
+import {
+  entities as DataSetHistoryEntities,
+  resolvers as DataSetHistoryResolvers,
+  subscribers as DataSetHistorySubscribers
+} from './data-set-history'
 import { entities as DataSpecEntities, resolvers as DataSpecResolvers } from './data-spec'
 
 /* EXPORT ENTITY TYPES */
 export * from './data-ooc/data-ooc'
 export * from './data-sensor/data-sensor'
 export * from './data-sample/data-sample'
-export * from './data-item/data-item'
 export * from './data-set/data-set'
+export * from './data-set-history/data-set-history'
+export * from './data-set/data-item-type'
 export * from './data-spec/data-spec'
 
 export const entities = [
   /* ENTITIES */
+  ...DataItemEntities,
   ...DataOocEntities,
   ...DataSensorEntities,
   ...DataSampleEntities,
-  ...DataItemEntities,
   ...DataSetEntities,
+  ...DataSetHistoryEntities,
   ...DataSpecEntities
 ]
 
+export const subscribers = [
+  /* SUBSCRIBERS */
+  ...DataSetHistorySubscribers
+]
+
 export const schema = {
   resolverClasses: [
     /* RESOLVER CLASSES */
     ...DataOocResolvers,
     ...DataSensorResolvers,
     ...DataSampleResolvers,
-    ...DataItemResolvers,
     ...DataSetResolvers,
+    ...DataSetHistoryResolvers,
     ...DataSpecResolvers
   ]
 }

package/translations/en.json

@@ -32,7 +32,7 @@
   "field.report-view": "report view",
   "field.serial-no": "serial #",
   "field.spec": "spec",
-  "field.state": "state",
+  "field.status": "status",
   "field.supervisory-role": "supervisory role",
   "field.tag": "tag name",
   "field.unit": "unit",
@@ -40,11 +40,11 @@
   "field.work-date": "work date",
   "field.work-shift": "work shift",
   "label.acceptables": "acceptables",
-  "label.critical limits": "critical limits",
+  "label.critical-limits": "critical limits",
   "label.minimum value": "minimum value",
   "label.maximum value": "maximum value",
-  "label.pass limits": "pass limits",
-  "label.target limits": "target limits",
+  "label.pass-limits": "pass limits",
+  "label.target-limits": "target limits",
   "text.automatically collected": "automatically collected",
   "text.data sample created successfully": "a data sample created successfully",
   "text.data ooc updated successfully": "a data ooc updated successfully",
@@ -61,4 +61,4 @@
   "title.data-sensor list": "data sensor list",
   "title.data-set list": "data set list",
   "title.edit code": "edit code"
-}
+}