@things-factory/dataset 9.1.19 → 9.2.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/dataset",
-  "version": "9.1.19",
+  "version": "9.2.13",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -40,21 +40,21 @@
     "@operato/shell": "^9.0.0",
     "@operato/styles": "^9.0.0",
     "@operato/utils": "^9.0.0",
-    "@things-factory/auth-base": "^9.1.19",
-    "@things-factory/aws-base": "^9.1.19",
-    "@things-factory/board-service": "^9.1.19",
-    "@things-factory/env": "^9.1.13",
-    "@things-factory/integration-base": "^9.1.19",
-    "@things-factory/organization": "^9.1.19",
-    "@things-factory/personalization": "^9.1.19",
-    "@things-factory/scheduler-client": "^9.1.19",
-    "@things-factory/shell": "^9.1.19",
-    "@things-factory/work-shift": "^9.1.19",
-    "@things-factory/worklist": "^9.1.19",
+    "@things-factory/auth-base": "^9.2.13",
+    "@things-factory/aws-base": "^9.2.13",
+    "@things-factory/board-service": "^9.2.13",
+    "@things-factory/env": "^9.2.13",
+    "@things-factory/integration-base": "^9.2.13",
+    "@things-factory/organization": "^9.2.13",
+    "@things-factory/personalization": "^9.2.13",
+    "@things-factory/scheduler-client": "^9.2.13",
+    "@things-factory/shell": "^9.2.13",
+    "@things-factory/work-shift": "^9.2.13",
+    "@things-factory/worklist": "^9.2.13",
     "cron-parser": "^4.3.0",
     "moment-timezone": "^0.5.45",
     "simple-statistics": "^7.8.3",
     "statistics": "^3.3.0"
   },
-  "gitHead": "078438034dbe19915108e89ff24024f7044a85a9"
+  "gitHead": "d65748803a86a1fb6c9810ea4f93519c6f44f6d5"
 }

package/spec/integration/debug.spec.ts

@@ -0,0 +1,42 @@
+/**
+ * Debug Test
+ * 엔티티 등록 디버깅
+ */
+
+import { TestDatabase } from '../../../../test/test-database'
+
+describe('Debug Entity Registration', () => {
+  let testDb: TestDatabase
+
+  beforeAll(async () => {
+    testDb = TestDatabase.getInstance()
+  })
+
+  it('should debug entity registration', () => {
+    const ds = testDb.getDataSource()
+
+    console.log('DataSource initialized:', ds.isInitialized)
+    console.log('Number of entity metadatas:', ds.entityMetadatas.length)
+
+    ds.entityMetadatas.forEach((meta) => {
+      console.log('Registered entity:', meta.name)
+    })
+  })
+
+  it('should create and retrieve a Domain using entity name', async () => {
+    const manager = testDb.getManager()
+
+    const domain = await manager.save('Domain', {
+      name: 'Test',
+      subdomain: 'test',
+      timezone: 'UTC'
+    })
+
+    expect(domain.id).toBeDefined()
+    expect(domain.name).toBe('Test')
+
+    const found = await manager.findOne('Domain', { where: { id: domain.id } })
+    expect(found).toBeDefined()
+    expect(found?.name).toBe('Test')
+  })
+})

package/spec/integration/ooc-lifecycle.spec.ts

@@ -0,0 +1,484 @@
+/**
+ * OOC Lifecycle Integration Tests
+ * DataOoc 전체 생명주기 통합 테스트
+ */
+
+import { TestDatabase } from '../../../../test/test-database'
+import { withTestTransaction } from '../../../../test/test-context'
+import {
+  domainFactory,
+  userFactory,
+  roleFactory,
+  dataSetFactory,
+  dataSampleFactory,
+  dataOocFactory,
+  activityFactory,
+  activityInstanceFactory,
+  activityThreadFactory
+} from '../../../../test/factories'
+
+import {
+  DataOocStatus,
+  ActivityInstanceStatus,
+  ActivityThreadStatus
+} from '../../../../test/entities/schemas'
+
+import {
+  simulateOocReviewCompletion,
+  simulateOocResolveCompletion,
+  createHistoryEntry,
+  isValidOocTransition
+} from '../../../../test/helpers/workflow-helpers'
+
+describe('OOC Complete Lifecycle Integration Tests', () => {
+  let testDb: TestDatabase
+
+  beforeAll(async () => {
+    testDb = TestDatabase.getInstance()
+  })
+
+  describe('OOC Creation from DataSample', () => {
+    it('DataSample에서 ooc=true일 때 DataOoc이 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+
+        // Given: OOC 조건의 DataSample
+        const { dataSet } = await dataSetFactory.createWithRoles({}, undefined, tx)
+        const dataSample = await dataSampleFactory.createOocSample({}, dataSet, tx)
+
+        // When: DataOoc 생성
+        const dataOoc = await dataOocFactory.createWithDataSetAndSample(
+          {
+            state: DataOocStatus.ISSUED,
+            data: dataSample.data,
+            ooc: true,
+            oos: false
+          },
+          dataSet,
+          dataSample,
+          tx
+        )
+
+        // Then: OOC이 생성되어야 함
+        expect(dataOoc).toBeDefined()
+        expect(dataOoc.id).toBeDefined()
+        expect(dataOoc.ooc).toBe(true)
+        expect(dataOoc.state).toBe(DataOocStatus.ISSUED)
+        expect(dataOoc.dataSet?.id).toBe(dataSet.id)
+        expect(dataOoc.dataSample?.id).toBe(dataSample.id)
+      })
+    })
+
+    it('DataOoc 생성 시 초기 상태는 ISSUED여야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+
+        // Given & When: DataOoc 생성
+        const dataOoc = await dataOocFactory.create(
+          { state: DataOocStatus.ISSUED },
+          tx
+        )
+
+        // Then
+        expect(dataOoc.state).toBe(DataOocStatus.ISSUED)
+      })
+    })
+
+    it('DataOoc 생성 시 history 배열이 초기화되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, user } = context.state
+
+        // Given & When
+        const dataOoc = await dataOocFactory.create(
+          {
+            state: DataOocStatus.ISSUED,
+            history: [createHistoryEntry(user, DataOocStatus.ISSUED)]
+          },
+          tx
+        )
+
+        // Then
+        expect(dataOoc.history).toBeDefined()
+        expect(dataOoc.history?.length).toBe(1)
+        expect(dataOoc.history?.[0].state).toBe(DataOocStatus.ISSUED)
+      })
+    })
+
+    it('DataOoc의 data, judgment 필드가 DataSample에서 복사되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+
+        // Given
+        const { dataSet } = await dataSetFactory.createWithRoles({}, undefined, tx)
+        const sampleData = { temperature: 95, humidity: 50 }
+        const sampleJudgment = {
+          temperature: { ooc: true, oos: false },
+          humidity: { ooc: false, oos: false }
+        }
+
+        // When
+        const dataOoc = await dataOocFactory.createWithDataSetAndSample(
+          {
+            data: sampleData,
+            judgment: sampleJudgment,
+            ooc: true
+          },
+          dataSet,
+          undefined,
+          tx
+        )
+
+        // Then
+        expect(dataOoc.data).toEqual(sampleData)
+        expect(dataOoc.judgment).toEqual(sampleJudgment)
+      })
+    })
+  })
+
+  describe('OOC Review Activity Workflow', () => {
+    it('OOC Review 발행 시 supervisoryRole로 할당되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+
+        // Given: DataSet with supervisoryRole
+        const { dataSet, supervisoryRole } = await dataSetFactory.createWithRoles(
+          {},
+          domain,
+          tx
+        )
+
+        // When: OOC Review Activity 발행 시뮬레이션
+        const reviewActivity = await activityFactory.createOocReviewActivity(domain, tx)
+        const dataOoc = await dataOocFactory.createWithDataSetAndSample(
+          { state: DataOocStatus.ISSUED },
+          dataSet,
+          undefined,
+          tx
+        )
+
+        const reviewInstance = await activityInstanceFactory.createWithActivity(
+          {
+            name: `[OOC 검토] ${dataSet.name}`,
+            state: ActivityInstanceStatus.Issued,
+            assigneeRole: supervisoryRole,
+            input: { dataOocId: dataOoc.id }
+          },
+          reviewActivity,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(reviewInstance.assigneeRole?.id).toBe(supervisoryRole.id)
+        expect(reviewInstance.input?.dataOocId).toBe(dataOoc.id)
+      })
+    })
+
+    it('OOC Review 완료 시 DataOoc 상태가 REVIEWED로 전이되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, user } = context.state
+
+        // Given
+        const dataOoc = await dataOocFactory.create(
+          { state: DataOocStatus.ISSUED },
+          tx
+        )
+
+        // When: Review 완료 시뮬레이션
+        const reviewed = await simulateOocReviewCompletion(
+          dataOoc,
+          'Temperature 조절 필요',
+          user,
+          { tx, domain: context.state.domain, user }
+        )
+
+        // Then
+        expect(reviewed.state).toBe(DataOocStatus.REVIEWED)
+        expect(reviewed.reviewedAt).toBeDefined()
+        expect(reviewed.reviewer?.id).toBe(user.id)
+        expect(reviewed.correctiveInstruction).toBe('Temperature 조절 필요')
+      })
+    })
+
+    it('OOC Review 완료 시 history에 기록이 추가되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, user } = context.state
+
+        // Given
+        const initialHistory = [createHistoryEntry(user, DataOocStatus.ISSUED)]
+        const dataOoc = await dataOocFactory.create(
+          {
+            state: DataOocStatus.ISSUED,
+            history: initialHistory
+          },
+          tx
+        )
+
+        // When
+        const reviewed = await simulateOocReviewCompletion(
+          dataOoc,
+          'Instruction',
+          user,
+          { tx, domain: context.state.domain, user }
+        )
+
+        // Then
+        expect(reviewed.history?.length).toBe(2)
+        expect(reviewed.history?.[1].state).toBe(DataOocStatus.REVIEWED)
+      })
+    })
+  })
+
+  describe('OOC Resolve Activity Workflow', () => {
+    it('OOC Resolve 발행 시 resolverRole로 할당되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+
+        // Given
+        const { dataSet, resolverRole } = await dataSetFactory.createWithRoles(
+          {},
+          domain,
+          tx
+        )
+        const resolveActivity = await activityFactory.createOocResolveActivity(domain, tx)
+        const dataOoc = await dataOocFactory.createWithDataSetAndSample(
+          { state: DataOocStatus.REVIEWED, correctiveInstruction: 'Fix temperature' },
+          dataSet,
+          undefined,
+          tx
+        )
+
+        // When
+        const resolveInstance = await activityInstanceFactory.createWithActivity(
+          {
+            name: `[OOC 조치] ${dataSet.name}`,
+            state: ActivityInstanceStatus.Issued,
+            assigneeRole: resolverRole,
+            input: {
+              dataOocId: dataOoc.id,
+              instruction: dataOoc.correctiveInstruction
+            }
+          },
+          resolveActivity,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(resolveInstance.assigneeRole?.id).toBe(resolverRole.id)
+        expect(resolveInstance.input?.instruction).toBe('Fix temperature')
+      })
+    })
+
+    it('OOC Resolve 발행 시 outlierApprovalLine이 적용되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const approverRole = await roleFactory.create({ name: 'Approver', domain }, tx)
+
+        // Given: DataSet with outlierApprovalLine
+        const outlierApprovalLine = [
+          { type: 'Role', value: approverRole.id, approver: { id: approverRole.id, name: approverRole.name } }
+        ]
+        const dataSet = await dataSetFactory.createWithDomain(
+          { outlierApprovalLine },
+          domain,
+          tx
+        )
+        const resolveActivity = await activityFactory.createOocResolveActivity(domain, tx)
+
+        // When
+        const resolveInstance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Issued,
+            approvalLine: dataSet.outlierApprovalLine
+          },
+          resolveActivity,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(resolveInstance.approvalLine?.length).toBe(1)
+        expect(resolveInstance.approvalLine?.[0].type).toBe('Role')
+      })
+    })
+
+    it('OOC Resolve 완료 시 DataOoc 상태가 CORRECTED로 전이되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, user } = context.state
+
+        // Given: REVIEWED 상태의 DataOoc
+        const dataOoc = await dataOocFactory.create(
+          {
+            state: DataOocStatus.REVIEWED,
+            reviewedAt: new Date(),
+            correctiveInstruction: 'Fix it'
+          },
+          tx
+        )
+
+        // When: Resolve 완료 시뮬레이션
+        const corrected = await simulateOocResolveCompletion(
+          dataOoc,
+          'Temperature를 정상 범위로 조절함',
+          user,
+          { tx, domain: context.state.domain, user }
+        )
+
+        // Then
+        expect(corrected.state).toBe(DataOocStatus.CORRECTED)
+        expect(corrected.correctedAt).toBeDefined()
+        expect(corrected.corrector?.id).toBe(user.id)
+        expect(corrected.correctiveAction).toBe('Temperature를 정상 범위로 조절함')
+      })
+    })
+  })
+
+  describe('Complete OOC Workflow End-to-End', () => {
+    it('전체 워크플로우: ISSUED -> REVIEWED -> CORRECTED', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain, user } = context.state
+
+        // 1. Setup
+        const { dataSet, supervisoryRole, resolverRole } = await dataSetFactory.createWithRoles(
+          {},
+          domain,
+          tx
+        )
+        const reviewer = await userFactory.create({ name: 'Reviewer' }, tx)
+        const corrector = await userFactory.create({ name: 'Corrector' }, tx)
+
+        // 2. OOC 생성 (ISSUED)
+        const dataOoc = await dataOocFactory.createWithDataSetAndSample(
+          {
+            state: DataOocStatus.ISSUED,
+            history: [createHistoryEntry(user, DataOocStatus.ISSUED)]
+          },
+          dataSet,
+          undefined,
+          tx
+        )
+        expect(dataOoc.state).toBe(DataOocStatus.ISSUED)
+
+        // 3. Review 완료 (REVIEWED)
+        const reviewed = await simulateOocReviewCompletion(
+          dataOoc,
+          'Temperature 조절 필요',
+          reviewer,
+          { tx, domain, user: reviewer }
+        )
+        expect(reviewed.state).toBe(DataOocStatus.REVIEWED)
+        expect(reviewed.correctiveInstruction).toBe('Temperature 조절 필요')
+
+        // 4. Resolve 완료 (CORRECTED)
+        const corrected = await simulateOocResolveCompletion(
+          reviewed,
+          'Temperature를 정상 범위로 조절함',
+          corrector,
+          { tx, domain, user: corrector }
+        )
+        expect(corrected.state).toBe(DataOocStatus.CORRECTED)
+        expect(corrected.correctiveAction).toBe('Temperature를 정상 범위로 조절함')
+
+        // 5. 최종 상태 검증
+        expect(corrected.reviewedAt).toBeDefined()
+        expect(corrected.correctedAt).toBeDefined()
+        expect(corrected.reviewer?.id).toBe(reviewer.id)
+        expect(corrected.corrector?.id).toBe(corrector.id)
+        expect(corrected.history?.length).toBe(3)
+      })
+    })
+
+    it('워크플로우 중 잘못된 상태 전이는 불가능해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+
+        // Given: ISSUED 상태의 DataOoc
+        const dataOoc = await dataOocFactory.create(
+          { state: DataOocStatus.ISSUED },
+          tx
+        )
+
+        // Then: ISSUED에서 CORRECTED로 직접 전이는 불가
+        expect(isValidOocTransition(DataOocStatus.ISSUED, DataOocStatus.CORRECTED)).toBe(false)
+      })
+    })
+  })
+
+  describe('Edge Cases', () => {
+    it('supervisoryRole이 없으면 Review Activity가 발행되지 않아야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+
+        // Given: supervisoryRole이 없는 DataSet
+        const dataSet = await dataSetFactory.createWithDomain(
+          { supervisoryRole: undefined },
+          domain,
+          tx
+        )
+
+        // Then: supervisoryRole이 없음
+        expect(dataSet.supervisoryRole).toBeUndefined()
+      })
+    })
+
+    it('resolverRole이 없으면 Resolve Activity가 발행되지 않아야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+
+        // Given: resolverRole이 없는 DataSet
+        const dataSet = await dataSetFactory.createWithDomain(
+          { resolverRole: undefined },
+          domain,
+          tx
+        )
+
+        // Then: resolverRole이 없음
+        expect(dataSet.resolverRole).toBeUndefined()
+      })
+    })
+
+    it('CORRECTED 상태의 DataOoc은 더 이상 전이할 수 없다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+
+        // Given: CORRECTED 상태의 DataOoc
+        const dataOoc = await dataOocFactory.create(
+          {
+            state: DataOocStatus.CORRECTED,
+            correctedAt: new Date()
+          },
+          tx
+        )
+
+        // Then
+        expect(dataOoc.state).toBe(DataOocStatus.CORRECTED)
+        expect(isValidOocTransition(DataOocStatus.CORRECTED, DataOocStatus.ISSUED)).toBe(false)
+        expect(isValidOocTransition(DataOocStatus.CORRECTED, DataOocStatus.REVIEWED)).toBe(false)
+      })
+    })
+
+    it('DataOoc 생성 시 domain이 설정되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given & When
+        const { dataSet } = await dataSetFactory.createWithRoles({}, domain, tx)
+        const dataOoc = await dataOocFactory.createWithDataSetAndSample(
+          { state: DataOocStatus.ISSUED },
+          dataSet,
+          undefined,
+          tx
+        )
+
+        // Then
+        expect(dataOoc.domain?.id).toBe(domain.id)
+      })
+    })
+  })
+})