@things-factory/worklist 9.1.19 → 10.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/worklist",
-  "version": "9.1.19",
+  "version": "10.0.0-beta.2",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -28,20 +28,20 @@
   },
   "dependencies": {
     "@material/web": "^2.0.0",
-    "@operato/event-view": "^9.0.0",
-    "@operato/graphql": "^9.0.0",
-    "@operato/grist-editor": "^9.0.0",
-    "@operato/moment-timezone-es": "^9.0.0",
-    "@operato/p13n": "^9.0.0",
-    "@things-factory/attachment-base": "^9.1.19",
-    "@things-factory/auth-base": "^9.1.19",
-    "@things-factory/board-service": "^9.1.19",
-    "@things-factory/board-ui": "^9.1.19",
-    "@things-factory/context-ui": "^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"
+    "@operato/event-view": "^10.0.0-beta.1",
+    "@operato/graphql": "^10.0.0-beta.1",
+    "@operato/grist-editor": "^10.0.0-beta.1",
+    "@operato/moment-timezone-es": "^10.0.0-beta.1",
+    "@operato/p13n": "^10.0.0-beta.1",
+    "@things-factory/attachment-base": "^10.0.0-beta.2",
+    "@things-factory/auth-base": "^10.0.0-beta.2",
+    "@things-factory/board-service": "^10.0.0-beta.2",
+    "@things-factory/board-ui": "^10.0.0-beta.2",
+    "@things-factory/context-ui": "^10.0.0-beta.2",
+    "@things-factory/organization": "^10.0.0-beta.2",
+    "@things-factory/personalization": "^10.0.0-beta.2",
+    "@things-factory/scheduler-client": "^10.0.0-beta.2",
+    "@things-factory/shell": "^10.0.0-beta.2"
   },
-  "gitHead": "078438034dbe19915108e89ff24024f7044a85a9"
+  "gitHead": "ea8a08ff802ae28a37fdda605b6356482e7a6faf"
 }

package/spec/integration/approval-mixed-types.spec.ts

@@ -0,0 +1,491 @@
+/**
+ * Mixed Approval Line Type Integration Tests
+ * ROLE과 User 타입이 혼합된 다단계 승인라인 통합 테스트
+ */
+
+import { TestDatabase } from '../../../../test/test-database'
+import { withTestTransaction } from '../../../../test/test-context'
+import {
+  domainFactory,
+  userFactory,
+  roleFactory,
+  activityInstanceFactory,
+  activityThreadFactory,
+  activityApprovalFactory
+} from '../../../../test/factories'
+
+import {
+  ActivityInstanceStatus,
+  ActivityThreadStatus,
+  ActivityApprovalJudgment
+} from '../../../../test/entities/schemas'
+
+import {
+  createRoleApprovalLineItem,
+  createUserApprovalLineItem,
+  createMultiLevelApprovalLine
+} from '../../../../test/helpers/workflow-helpers'
+
+describe('Mixed Approval Line Type Integration Tests', () => {
+  let testDb: TestDatabase
+
+  beforeAll(async () => {
+    testDb = TestDatabase.getInstance()
+  })
+
+  describe('ROLE → User 혼합 승인라인', () => {
+    it('첫 번째 레벨 ROLE, 두 번째 레벨 User 승인라인이 처리되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const firstRole = await roleFactory.create({ name: 'First Approver Role', domain }, tx)
+        const secondUser = await userFactory.create({ name: 'Final Approver' }, tx)
+        const firstApprover = await userFactory.createWithRole({}, firstRole, tx)
+
+        // Given: ROLE → User 혼합 승인라인
+        const approvalLine = [
+          createRoleApprovalLineItem(firstRole),
+          createUserApprovalLineItem(secondUser)
+        ]
+
+        // 타입 확인
+        expect(approvalLine[0].type).toBe('Role')
+        expect(approvalLine[1].type).toBe('Employee')
+
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          approvalLine,
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Submitted },
+          instance,
+          firstApprover,
+          tx
+        )
+
+        // When: 첫 번째 ROLE 승인 (에스컬레이션)
+        const firstApproval = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: 1,
+          order: 1,
+          judgment: ActivityApprovalJudgment.Escalated,
+          approverRole: firstRole,
+          approver: firstApprover,
+          terminatedAt: new Date(),
+          creator: firstApprover,
+          updater: firstApprover
+        }) as any
+
+        expect(firstApproval.judgment).toBe(ActivityApprovalJudgment.Escalated)
+        expect(firstApproval.approverRole?.id).toBe(firstRole.id)
+
+        // When: 두 번째 레벨 User 승인 생성
+        const order = firstApproval.order // 1
+        const nextLineItem = approvalLine[order] // approvalLine[1]
+        expect(nextLineItem.type).toBe('Employee')
+
+        const secondApproval = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: 1,
+          order: order + 1,
+          judgment: ActivityApprovalJudgment.Pending,
+          approver: secondUser,
+          transaction: 'escalate',
+          creator: firstApprover,
+          updater: firstApprover
+        }) as any
+
+        // Then: User 타입 approval 생성됨
+        expect(secondApproval.order).toBe(2)
+        expect(secondApproval.approver?.id).toBe(secondUser.id)
+        expect(secondApproval.approverRole).toBeUndefined()
+
+        // When: 최종 User 승인
+        secondApproval.judgment = ActivityApprovalJudgment.Approved
+        secondApproval.terminatedAt = new Date()
+        const approved = await tx.save('ActivityApproval', secondApproval) as any
+
+        expect(approved.judgment).toBe(ActivityApprovalJudgment.Approved)
+      })
+    })
+  })
+
+  describe('User → ROLE 혼합 승인라인', () => {
+    it('첫 번째 레벨 User, 두 번째 레벨 ROLE 승인라인이 처리되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const firstUser = await userFactory.create({ name: 'First Approver' }, tx)
+        const secondRole = await roleFactory.create({ name: 'Final Approver Role', domain }, tx)
+        const secondApprover = await userFactory.createWithRole({}, secondRole, tx)
+
+        // Given: User → ROLE 혼합 승인라인
+        const approvalLine = [
+          createUserApprovalLineItem(firstUser),
+          createRoleApprovalLineItem(secondRole)
+        ]
+
+        expect(approvalLine[0].type).toBe('Employee')
+        expect(approvalLine[1].type).toBe('Role')
+
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          approvalLine,
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Submitted },
+          instance,
+          firstUser,
+          tx
+        )
+
+        // When: 첫 번째 User 승인 (에스컬레이션)
+        const firstApproval = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: 1,
+          order: 1,
+          judgment: ActivityApprovalJudgment.Escalated,
+          approver: firstUser,
+          terminatedAt: new Date(),
+          creator: firstUser,
+          updater: firstUser
+        }) as any
+
+        expect(firstApproval.judgment).toBe(ActivityApprovalJudgment.Escalated)
+        expect(firstApproval.approver?.id).toBe(firstUser.id)
+
+        // When: 두 번째 레벨 ROLE 승인 생성
+        const order = firstApproval.order // 1
+        const nextLineItem = approvalLine[order] // approvalLine[1]
+        expect(nextLineItem.type).toBe('Role')
+
+        const secondApproval = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: 1,
+          order: order + 1,
+          judgment: ActivityApprovalJudgment.Pending,
+          approverRole: secondRole,
+          transaction: 'escalate',
+          creator: firstUser,
+          updater: firstUser
+        }) as any
+
+        // Then: ROLE 타입 approval 생성됨
+        expect(secondApproval.order).toBe(2)
+        expect(secondApproval.approverRole?.id).toBe(secondRole.id)
+        expect(secondApproval.approver).toBeUndefined()
+
+        // When: ROLE 소유자가 최종 승인
+        secondApproval.judgment = ActivityApprovalJudgment.Approved
+        secondApproval.approver = secondApprover
+        secondApproval.terminatedAt = new Date()
+        const approved = await tx.save('ActivityApproval', secondApproval) as any
+
+        expect(approved.judgment).toBe(ActivityApprovalJudgment.Approved)
+        expect(approved.approverRole?.id).toBe(secondRole.id)
+        expect(approved.approver?.id).toBe(secondApprover.id)
+      })
+    })
+  })
+
+  describe('User → ROLE → User 3단계 혼합', () => {
+    it('3단계 혼합 승인라인이 순서대로 처리되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+
+        const firstUser = await userFactory.create({ name: 'Team Lead' }, tx)
+        const middleRole = await roleFactory.create({ name: 'Manager Role', domain }, tx)
+        const finalUser = await userFactory.create({ name: 'Director' }, tx)
+        const middleApprover = await userFactory.createWithRole({ name: 'Manager' }, middleRole, tx)
+
+        // Given: User → ROLE → User 3단계 승인라인
+        const approvalLine = [
+          createUserApprovalLineItem(firstUser),
+          createRoleApprovalLineItem(middleRole),
+          createUserApprovalLineItem(finalUser)
+        ]
+
+        expect(approvalLine[0].type).toBe('Employee')
+        expect(approvalLine[1].type).toBe('Role')
+        expect(approvalLine[2].type).toBe('Employee')
+
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          approvalLine,
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Submitted },
+          instance,
+          firstUser,
+          tx
+        )
+
+        // Level 1: User 승인 → Escalated
+        const approval1 = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: 1,
+          order: 1,
+          judgment: ActivityApprovalJudgment.Escalated,
+          approver: firstUser,
+          terminatedAt: new Date(),
+          creator: firstUser,
+          updater: firstUser
+        }) as any
+
+        // Level 2: ROLE 승인 → Escalated
+        const nextType2 = approvalLine[1].type
+        expect(nextType2).toBe('Role')
+
+        const approval2 = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: 1,
+          order: 2,
+          judgment: ActivityApprovalJudgment.Escalated,
+          approverRole: middleRole,
+          approver: middleApprover,
+          terminatedAt: new Date(),
+          creator: middleApprover,
+          updater: middleApprover
+        }) as any
+
+        expect(approval2.approverRole?.id).toBe(middleRole.id)
+        expect(approval2.approver?.id).toBe(middleApprover.id)
+
+        // Level 3: User 최종 승인 → Approved
+        const nextType3 = approvalLine[2].type
+        expect(nextType3).toBe('Employee')
+
+        const approval3 = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: 1,
+          order: 3,
+          judgment: ActivityApprovalJudgment.Approved,
+          approver: finalUser,
+          terminatedAt: new Date(),
+          creator: finalUser,
+          updater: finalUser
+        }) as any
+
+        expect(approval3.judgment).toBe(ActivityApprovalJudgment.Approved)
+        expect(approval3.order).toBe(3)
+      })
+    })
+  })
+
+  describe('ROLE → ROLE → ROLE 3단계', () => {
+    it('3단계 ROLE 전용 승인라인에서 각 레벨의 roleId가 올바르게 참조되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+
+        const role1 = await roleFactory.create({ name: 'Team Lead Role', domain }, tx)
+        const role2 = await roleFactory.create({ name: 'Manager Role', domain }, tx)
+        const role3 = await roleFactory.create({ name: 'Director Role', domain }, tx)
+
+        const approver1 = await userFactory.createWithRole({}, role1, tx)
+        const approver2 = await userFactory.createWithRole({}, role2, tx)
+        const approver3 = await userFactory.createWithRole({}, role3, tx)
+
+        // Given: ROLE → ROLE → ROLE
+        const approvalLine = [
+          createRoleApprovalLineItem(role1),
+          createRoleApprovalLineItem(role2),
+          createRoleApprovalLineItem(role3)
+        ]
+
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          approvalLine,
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+
+        // 버그 수정 검증: 각 에스컬레이션 시 올바른 인덱스 참조
+        // order=1 완료 후 → approvalLine[1] (role2)
+        expect(approvalLine[1].value).toBe(role2.id)
+
+        // order=2 완료 후 → approvalLine[2] (role3)
+        expect(approvalLine[2].value).toBe(role3.id)
+
+        // 수정 전 버그: 항상 approvalLine[0].value 참조 (role1.id)
+        // 이 테스트는 수정된 코드가 올바르게 작동하는지 확인
+        expect(approvalLine[0].value).not.toBe(role2.id)
+        expect(approvalLine[0].value).not.toBe(role3.id)
+        expect(approvalLine[0].value).toBe(role1.id)
+      })
+    })
+  })
+
+  describe('타입 분기 로직 검증', () => {
+    it('OrgMemberTargetType.Role 체크가 정확해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const role = await roleFactory.create({ name: 'Test Role', domain }, tx)
+        const user = await userFactory.create({ name: 'Test User' }, tx)
+
+        const roleItem = createRoleApprovalLineItem(role)
+        const userItem = createUserApprovalLineItem(user)
+
+        // Role 타입 분기
+        if (roleItem.type === 'Role') {
+          expect(roleItem.value).toBe(role.id)
+        } else {
+          fail('Should be Role type')
+        }
+
+        // Employee 타입 분기
+        if (userItem.type === 'Employee') {
+          expect(userItem.value).toBe(user.id)
+        } else {
+          fail('Should be Employee type')
+        }
+
+        // 타입 불일치
+        expect(roleItem.type).not.toBe('Employee')
+        expect(userItem.type).not.toBe('Role')
+      })
+    })
+  })
+
+  describe('반려 시나리오', () => {
+    it('혼합 승인라인의 어느 레벨에서든 반려할 수 있어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const firstRole = await roleFactory.create({ name: 'First', domain }, tx)
+        const secondUser = await userFactory.create({ name: 'Second' }, tx)
+        const firstApprover = await userFactory.createWithRole({}, firstRole, tx)
+
+        // Given: ROLE → User 승인라인
+        const approvalLine = [
+          createRoleApprovalLineItem(firstRole),
+          createUserApprovalLineItem(secondUser)
+        ]
+
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          approvalLine,
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Submitted },
+          instance,
+          firstApprover,
+          tx
+        )
+
+        // When: 첫 번째 ROLE 승인자가 반려
+        const rejection = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: 1,
+          order: 1,
+          judgment: ActivityApprovalJudgment.Rejected,
+          approverRole: firstRole,
+          approver: firstApprover,
+          comment: 'Needs revision',
+          terminatedAt: new Date(),
+          creator: firstApprover,
+          updater: firstApprover
+        }) as any
+
+        // Then: Rejected 상태
+        expect(rejection.judgment).toBe(ActivityApprovalJudgment.Rejected)
+        expect(rejection.comment).toBe('Needs revision')
+
+        // 스레드도 Rejected 상태
+        thread.state = ActivityThreadStatus.Rejected
+        const rejectedThread = await tx.save('ActivityThread', thread) as any
+        expect(rejectedThread.state).toBe(ActivityThreadStatus.Rejected)
+      })
+    })
+
+    it('반려 후 재시작 시 round가 증가해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const approverRole = await roleFactory.create({ name: 'Approver', domain }, tx)
+        const user = await userFactory.create({}, tx)
+
+        // Given: round=1인 스레드
+        const instance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Rejected, round: 1 },
+          instance,
+          user,
+          tx
+        )
+
+        expect(thread.round).toBe(1)
+
+        // When: 재시작 시 round 증가
+        const newRound = thread.round + 1
+        thread.round = newRound
+        thread.state = ActivityThreadStatus.Started
+        const restarted = await tx.save('ActivityThread', thread) as any
+
+        // Then
+        expect(restarted.round).toBe(2)
+        expect(restarted.state).toBe(ActivityThreadStatus.Started)
+      })
+    })
+  })
+
+  describe('createMultiLevelApprovalLine 헬퍼 테스트', () => {
+    it('User와 Role 혼합 배열에서 올바른 타입으로 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+
+        const user1 = await userFactory.create({ name: 'User 1' }, tx)
+        const role1 = await roleFactory.create({ name: 'Role 1', domain }, tx)
+        const user2 = await userFactory.create({ name: 'User 2' }, tx)
+
+        // When: 혼합 배열로 승인라인 생성
+        const approvalLine = createMultiLevelApprovalLine([user1, role1, user2])
+
+        // Then: 타입이 올바르게 설정됨
+        expect(approvalLine.length).toBe(3)
+
+        expect(approvalLine[0].type).toBe('Employee')
+        expect(approvalLine[0].value).toBe(user1.id)
+
+        expect(approvalLine[1].type).toBe('Role')
+        expect(approvalLine[1].value).toBe(role1.id)
+
+        expect(approvalLine[2].type).toBe('Employee')
+        expect(approvalLine[2].value).toBe(user2.id)
+      })
+    })
+  })
+})