@things-factory/dataset 8.0.0 → 9.0.0-beta.3

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

@@ -1,326 +0,0 @@
-import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn,
-  VersionColumn
-} from 'typeorm'
-
-import { Role, User } from '@things-factory/auth-base'
-import { ApprovalLineItem } from '@things-factory/organization'
-import { Domain, ScalarObject } from '@things-factory/shell'
-import { AssigneeItem } from '@things-factory/worklist'
-import { Scenario } from '@things-factory/integration-base'
-
-import { DataKeySet } from '../data-key-set/data-key-set'
-import { DataItem } from './data-item-type'
-
-export enum DataSetEntryType {
-  Generated = 'generated',
-  Board = 'board',
-  CustomElement = 'custom-element',
-  Page = 'page',
-  ExternalURL = 'external',
-  Jasper = 'jasper',
-  Shiny = 'shiny'
-}
-
-registerEnumType(DataSetEntryType, {
-  name: 'DataSetEntryType',
-  description: 'entry type enumeration for data-set'
-})
-
-export enum DataSetMonitorType {
-  Generated = 'generated',
-  Board = 'board',
-  CustomElement = 'custom-element',
-  Page = 'page',
-  ExternalURL = 'external'
-}
-
-registerEnumType(DataSetMonitorType, {
-  name: 'DataSetMonitorType',
-  description: 'monitor type enumeration for data-set'
-})
-
-export enum DataSetReportType {
-  Generated = 'generated',
-  Board = 'board',
-  CustomElement = 'custom-element',
-  Page = 'page',
-  ExternalURL = 'external'
-}
-
-registerEnumType(DataSetReportType, {
-  name: 'DataSetReportType',
-  description: 'report type enumeration for data-set'
-})
-
-export enum DataSetSummaryPeriodType {
-  Hour = 'hour',
-  WorkShift = 'work-shift',
-  WorkDate = 'work-date',
-  Day = 'day'
-}
-
-registerEnumType(DataSetSummaryPeriodType, {
-  name: 'DataSetSummaryPeriodType',
-  description: 'summary period type enumeration for data-set'
-})
-
-@ObjectType()
-export class DataSetState {
-  @Field()
-  id: string
-
-  @Field()
-  scheduleId: string
-
-  @Field()
-  state: string
-
-  @Field()
-  startedAt: Date
-
-  @Field()
-  nextSchedule: Date
-}
-
-@Entity()
-@Index('ix_data_set_0', (dataSet: DataSet) => [dataSet.domain, dataSet.name], { unique: true })
-@ObjectType({ description: 'Entity for DataSet' })
-export class DataSet {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID, { description: 'The unique identifier of the dataset' })
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true, description: 'The domain to which the dataset belongs' })
-  domain?: Domain
-
-  @RelationId((dataSet: DataSet) => dataSet.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ description: 'The name of the dataset' })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'A description of the dataset' })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'A tag name of data to be published when a data sample created' })
-  tag?: string
-
-  @VersionColumn({ nullable: true, default: 1 })
-  @Field({ nullable: true, description: 'The version of the dataset' })
-  version?: number = 1
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Indicates whether the dataset is currently active or in use.' })
-  active?: boolean
-
-  @ManyToOne(type => DataKeySet, { nullable: true })
-  @Field(type => DataKeySet, { nullable: true, description: 'The key set used for this dataset' })
-  dataKeySet?: DataKeySet
-
-  @RelationId((dataSet: DataSet) => dataSet.dataKeySet)
-  dataKeySetId?: string
-
-  @ManyToOne(type => Role, { nullable: true })
-  @Field(type => Role, {
-    nullable: true,
-    description: 'The person responsible for manually entering the data for that dataset'
-  })
-  entryRole?: Role
-
-  @RelationId((dataSet: DataSet) => dataSet.entryRole)
-  entryRoleId?: string
-
-  @ManyToOne(type => Role, { nullable: true })
-  @Field(type => Role, { nullable: true, description: 'The final authority on issues related to that dataset.' })
-  supervisoryRole?: Role
-
-  @RelationId((dataSet: DataSet) => dataSet.supervisoryRole)
-  supervisoryRoleId?: string
-
-  @ManyToOne(type => Role, { nullable: true })
-  @Field(type => Role, {
-    nullable: true,
-    description: 'The final authority on resolving outlier related to that dataset.'
-  })
-  resolverRole?: Role
-
-  @RelationId((dataSet: DataSet) => dataSet.resolverRole)
-  resolverRoleId?: string
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [AssigneeItem], { nullable: true, description: 'Who to contact for OOC issues' })
-  assignees?: AssigneeItem[]
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [ApprovalLineItem], {
-    nullable: true,
-    description: 'Approval line for confrim of the dataset'
-  })
-  reviewApprovalLine?: ApprovalLineItem[]
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [ApprovalLineItem], {
-    nullable: true,
-    description: 'Approval line for handling abnormal data occurance issues for that dataset'
-  })
-  outlierApprovalLine?: ApprovalLineItem[]
-
-  @ManyToOne(type => Scenario, { nullable: true })
-  @Field(type => Scenario, {
-    nullable: true,
-    description: 'Scenario for handling normal data-sample occurance for that dataset'
-  })
-  normalScenario?: Scenario
-
-  @RelationId((dataSet: DataSet) => dataSet.normalScenario)
-  normalScenarioId?: string
-
-  @ManyToOne(type => Scenario, { nullable: true })
-  @Field(type => Scenario, {
-    nullable: true,
-    description: 'Scenario for handling abnormal data-sample occurance issues for that dataset'
-  })
-  outlierScenario?: Scenario
-
-  @RelationId((dataSet: DataSet) => dataSet.outlierScenario)
-  outlierScenarioId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The type of the dataset' })
-  type?: 'manual' | 'automatic' | string
-
-  @Column({ nullable: true })
-  @Field({
-    nullable: true,
-    description: `Specifies the method of data entry for the dataset. If set to "generated", data entry screens are automatically generated based on the defined data items. For other types, specific entry screens are configured for each type and specified in the "entryView" field.`
-  })
-  entryType?: DataSetEntryType
-
-  @Column({ nullable: true })
-  @Field({
-    nullable: true,
-    description: `Specifies the custom data entry screen or view for the dataset. When "entryType" is not "generated", this field indicates the screen to be used for data entry. When "entryType" is "generated", this field may not apply.`
-  })
-  entryView?: string
-
-  @Column({ nullable: true })
-  @Field({
-    nullable: true,
-    description: `Specifies the method of data monitoring for the dataset. If set to "generated", monitoring screens are automatically generated based on the dataset configuration. For other types, specific monitoring screens are configured for each type and specified in the "monitorView" field.`
-  })
-  monitorType?: DataSetMonitorType
-
-  @Column({ nullable: true })
-  @Field({
-    nullable: true,
-    description: `Specifies the custom data monitoring screen or view for the dataset. When "monitorType" is not "generated", this field indicates the screen to be used for data monitoring. When "monitorType" is "generated", this field may not apply.`
-  })
-  monitorView?: string
-
-  @Column({ nullable: true })
-  @Field({
-    nullable: true,
-    description: `Specifies the method of reporting for the dataset. If set to "generated", report templates are automatically generated based on the dataset configuration. For other types, specific report templates are configured for each type and specified in the "reportView" field.`
-  })
-  reportType?: DataSetReportType
-
-  @Column({ nullable: true })
-  @Field({
-    nullable: true,
-    description: `Specifies the custom report template or view for the dataset. When "reportType" is not "generated", this field indicates the report template or view to be used for reporting. When "reportType" is "generated", this field may not apply.`
-  })
-  reportView?: string
-
-  @Field({ nullable: true, description: 'The report template of the dataset' })
-  reportTemplate?: string
-
-  @Column({ nullable: true })
-  @Field({
-    nullable: true,
-    description:
-      'Specifies the intended purpose or role of the dataset within the system. It helps users understand why the dataset was created and guides the specification of data items accordingly. Common use case options may include "QA," "CCP," "SPC," and others.'
-  })
-  useCase?: string
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => ScalarObject, {
-    nullable: true,
-    description:
-      "Specifies the partition keys used to distribute and organize the dataset's data. Partition keys are properties or attributes that determine how data is logically grouped, stored, and retrieved. They enable efficient data management and querying by allowing data to be organized into smaller, manageable partitions or segments."
-  })
-  partitionKeys?: { [key: string]: any }
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [DataItem], { nullable: true, description: 'Data items for the dataset' })
-  dataItems: DataItem[]
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The schedule of the dataset' })
-  schedule?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The schedule ID of the dataset' })
-  scheduleId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The timezone of the dataset' })
-  timezone?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Indicates if the dataset requires review' })
-  requiresReview?: boolean
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The summary period of the dataset' })
-  summaryPeriod?: DataSetSummaryPeriodType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The summary schedule of the dataset' })
-  summarySchedule?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The summary schedule ID of the dataset' })
-  summaryScheduleId?: string
-
-  @Column({ nullable: true })
-  @Field({
-    nullable: true,
-    description: 'The maximum allowed time limit (in seconds) for completing the data entry operation'
-  })
-  timeLimit?: number
-
-  @CreateDateColumn()
-  @Field({ nullable: true, description: 'The date and time the dataset was created' })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true, description: 'The date and time the dataset was last updated' })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true, description: 'The user who created the dataset' })
-  creator?: User
-
-  @RelationId((dataSet: DataSet) => dataSet.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true, description: 'The user who last updated the dataset' })
-  updater?: User
-
-  @RelationId((dataSet: DataSet) => dataSet.updater)
-  updaterId?: string
-}

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

@@ -1,6 +0,0 @@
-import { DataSet } from './data-set'
-import { DataSetMutation } from './data-set-mutation'
-import { DataSetQuery } from './data-set-query'
-
-export const entities = [DataSet]
-export const resolvers = [DataSetQuery, DataSetMutation]

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

@@ -1,126 +0,0 @@
-import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-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, getRepository, ListParam, ScalarDate } from '@things-factory/shell'
-
-import { DataKeySet } from '../data-key-set/data-key-set'
-import { DataSet } from '../data-set/data-set'
-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: Date,
-    @Ctx() context: ResolverContext
-  ): Promise<DataSetHistory> {
-    const { domain } = context.state
-
-    return await getRepository(DataSetHistory).findOne({
-      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(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): 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.entryRoleId &&
-      (await getRepository(Role).findOneBy({
-        id: dataSetHistory.entryRoleId
-      }))
-    )
-  }
-
-  @FieldResolver(type => Role)
-  async supervisoryRole(@Root() dataSetHistory: DataSetHistory): Promise<Role> {
-    return (
-      dataSetHistory.supervisoryRoleId &&
-      (await getRepository(Role).findOneBy({
-        id: dataSetHistory.supervisoryRoleId
-      }))
-    )
-  }
-
-  @FieldResolver(type => Board, { nullable: true })
-  async entryBoard(@Root() dataSetHistory: DataSetHistory) {
-    if (dataSetHistory.entryType == 'board' && 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).findOneBy({ id: dataSetHistory.monitorView })
-    }
-  }
-
-  @FieldResolver(type => DataKeySet, { nullable: true })
-  async dataKeySet(@Root() dataSet: DataSet) {
-    return (
-      dataSet.dataKeySet ||
-      (dataSet.dataKeySetId &&
-        (await getRepository(DataKeySet).findOneBy({
-          id: dataSet.dataKeySetId
-        })))
-    )
-  }
-
-  @FieldResolver(type => User)
-  async timestamp(@Root() dataSetHistory: DataSetHistory): Promise<Date> {
-    return dataSetHistory.updatedAt
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() dataSetHistory: DataSetHistory): Promise<Domain> {
-    return dataSetHistory.domainId && (await getRepository(Domain).findOneBy({ id: dataSetHistory.domainId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() dataSetHistory: DataSetHistory): Promise<User> {
-    return dataSetHistory.updaterId && (await getRepository(User).findOneBy({ id: dataSetHistory.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() dataSetHistory: DataSetHistory): Promise<User> {
-    return dataSetHistory.creatorId && (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: { id: dataSetHistory.domainId },
-        refType: `${DataSet.name}-report-template`,
-        refBy: dataSetHistory.originalId
-      }
-    })
-
-    return attachment?.path
-  }
-}

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

@@ -1,12 +0,0 @@
-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

@@ -1,217 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId } from 'typeorm'
-
-import {
-  HistoryActionColumn,
-  HistoryActionType,
-  HistoryEntityInterface,
-  HistoryOriginalIdColumn
-} from '@operato/typeorm-history'
-import { User } from '@things-factory/auth-base'
-import { ApprovalLineItem } from '@things-factory/organization'
-import { Domain, ScalarObject } from '@things-factory/shell'
-import { AssigneeItem } from '@things-factory/worklist'
-import { config } from '@things-factory/env'
-
-import { DataItem } from '../data-set/data-item-type'
-import {
-  DataSet,
-  DataSetEntryType,
-  DataSetMonitorType,
-  DataSetReportType,
-  DataSetSummaryPeriodType
-} 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(type => Domain)
-  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 })
-  tag?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  dataKeySetId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  entryRoleId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  supervisoryRoleId?: string
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [AssigneeItem], { nullable: true })
-  assignees?: AssigneeItem[]
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [ApprovalLineItem], { nullable: true })
-  reviewApprovalLine?: ApprovalLineItem[]
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [ApprovalLineItem], { nullable: true })
-  outlierApprovalLine?: ApprovalLineItem[]
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  normalScenarioId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  outlierScenarioId?: 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?: { [key: string]: any }
-
-  @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 })
-  scheduleId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  timezone?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  requiresReview?: boolean
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  summaryPeriod?: DataSetSummaryPeriodType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  summarySchedule?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  summaryScheduleId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((dataSetHistory: DataSetHistory) => dataSetHistory.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((dataSetHistory: DataSetHistory) => dataSetHistory.updater)
-  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'
-          : DATABASE_TYPE == 'mssql'
-            ? 'nvarchar'
-            : 'varchar',
-    enum:
-      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? HistoryActionType
-        : undefined,
-    length: DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? undefined : 10
-  })
-  public action!: HistoryActionType
-}

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

@@ -1,17 +0,0 @@
-import { EventSubscriber } from 'typeorm'
-
-import { HistoryEntitySubscriber } from '@operato/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
-  }
-}