@things-factory/organization 9.1.19 → 9.2.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/organization",
-  "version": "9.1.19",
+  "version": "9.2.13",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -33,10 +33,10 @@
     "@operato/graphql": "^9.0.0",
     "@operato/p13n": "^9.0.0",
     "@operato/shell": "^9.0.0",
-    "@things-factory/auth-base": "^9.1.19",
-    "@things-factory/code-ui": "^9.1.19",
-    "@things-factory/contact": "^9.1.19",
-    "@things-factory/shell": "^9.1.19"
+    "@things-factory/auth-base": "^9.2.13",
+    "@things-factory/code-ui": "^9.2.13",
+    "@things-factory/contact": "^9.2.13",
+    "@things-factory/shell": "^9.2.13"
   },
-  "gitHead": "078438034dbe19915108e89ff24024f7044a85a9"
+  "gitHead": "d65748803a86a1fb6c9810ea4f93519c6f44f6d5"
 }

package/spec/unit/approval-line.spec.ts

@@ -0,0 +1,329 @@
+/**
+ * ApprovalLine Unit Tests
+ * 결재라인 엔티티 단위 테스트
+ */
+
+import { TestDatabase } from '../../../../test/test-database'
+import { withTestTransaction } from '../../../../test/test-context'
+import {
+  domainFactory,
+  userFactory,
+  roleFactory,
+  employeeFactory,
+  approvalLineFactory
+} from '../../../../test/factories'
+import { ApprovalLineOwnerType } from '../../../../test/entities/schemas'
+
+describe('ApprovalLine Entity Tests', () => {
+  let testDb: TestDatabase
+
+  beforeAll(async () => {
+    testDb = TestDatabase.getInstance()
+  })
+
+  describe('ApprovalLine 생성', () => {
+    it('ApprovalLine이 올바르게 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // When
+        const approvalLine = await approvalLineFactory.createWithDomain(
+          {
+            name: 'Standard Approval',
+            description: 'Standard approval process',
+            ownerType: ApprovalLineOwnerType.Common
+          },
+          domain,
+          tx
+        )
+
+        // Then
+        expect(approvalLine).toBeDefined()
+        expect(approvalLine.id).toBeDefined()
+        expect(approvalLine.name).toBe('Standard Approval')
+        expect(approvalLine.description).toBe('Standard approval process')
+        expect(approvalLine.ownerType).toBe(ApprovalLineOwnerType.Common)
+        expect(approvalLine.domain?.id).toBe(domain.id)
+      })
+    })
+
+    it('Employee 소유의 ApprovalLine이 생성될 수 있어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const employee = await employeeFactory.createWithDomain({}, domain, tx)
+
+        // When
+        const approvalLine = await approvalLineFactory.createForEmployee(
+          { name: 'My Approval Line' },
+          employee,
+          tx
+        )
+
+        // Then
+        expect(approvalLine.ownerType).toBe(ApprovalLineOwnerType.Employee)
+        expect(approvalLine.ownerValue).toBe(employee.id)
+        expect(approvalLine.ownerEmployee?.id).toBe(employee.id)
+      })
+    })
+  })
+
+  describe('ApprovalLine Model (결재 단계)', () => {
+    it('Role 타입 결재 아이템이 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const role = await roleFactory.create({ name: 'Approver Role', domain }, tx)
+
+        // When
+        const item = approvalLineFactory.createRoleApprovalItem(role)
+
+        // Then
+        expect(item.type).toBe('Role')
+        expect(item.value).toBe(role.id)
+        expect(item.approver?.id).toBe(role.id)
+        expect(item.approver?.name).toBe('Approver Role')
+      })
+    })
+
+    it('Employee 타입 결재 아이템이 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const employee = await employeeFactory.createWithDomain(
+          { name: 'Approver Employee' },
+          domain,
+          tx
+        )
+
+        // When
+        const item = approvalLineFactory.createEmployeeApprovalItem(employee)
+
+        // Then
+        expect(item.type).toBe('Employee')
+        expect(item.value).toBe(employee.id)
+        expect(item.approver?.id).toBe(employee.id)
+        expect(item.approver?.name).toBe('Approver Employee')
+      })
+    })
+
+    it('Supervisor 타입 결재 아이템이 생성되어야 한다', async () => {
+      // When
+      const item = approvalLineFactory.createSupervisorApprovalItem()
+
+      // Then
+      expect(item.type).toBe('Supervisor')
+      expect(item.value).toBeUndefined()
+    })
+
+    it('DepartmentManager 타입 결재 아이템이 생성되어야 한다', async () => {
+      // When
+      const item = approvalLineFactory.createDepartmentManagerApprovalItem()
+
+      // Then
+      expect(item.type).toBe('DepartmentManager')
+      expect(item.value).toBeUndefined()
+    })
+  })
+
+  describe('단일 레벨 결재라인', () => {
+    it('Role 기반 단일 레벨 결재라인이 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const role = await roleFactory.create({ name: 'Approver', domain }, tx)
+
+        // When
+        const approvalLine = await approvalLineFactory.createSingleRoleApprovalLine(
+          role,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(approvalLine.model).toBeDefined()
+        expect(approvalLine.model?.length).toBe(1)
+        expect(approvalLine.model?.[0].type).toBe('Role')
+        expect(approvalLine.model?.[0].approver?.id).toBe(role.id)
+      })
+    })
+  })
+
+  describe('다중 레벨 결재라인', () => {
+    it('여러 단계의 결재라인이 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const teamLeadRole = await roleFactory.create({ name: 'Team Lead', domain }, tx)
+        const managerRole = await roleFactory.create({ name: 'Manager', domain }, tx)
+        const directorRole = await roleFactory.create({ name: 'Director', domain }, tx)
+
+        const items = [
+          approvalLineFactory.createRoleApprovalItem(teamLeadRole),
+          approvalLineFactory.createRoleApprovalItem(managerRole),
+          approvalLineFactory.createRoleApprovalItem(directorRole)
+        ]
+
+        // When
+        const approvalLine = await approvalLineFactory.createMultiLevelApprovalLine(
+          items,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(approvalLine.model?.length).toBe(3)
+        expect(approvalLine.model?.[0].approver?.name).toBe('Team Lead')
+        expect(approvalLine.model?.[1].approver?.name).toBe('Manager')
+        expect(approvalLine.model?.[2].approver?.name).toBe('Director')
+      })
+    })
+
+    it('표준 2단계 결재라인이 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // When
+        const { approvalLine, teamLeadRole, managerRole } =
+          await approvalLineFactory.createStandardApprovalLine(domain, tx)
+
+        // Then
+        expect(approvalLine.name).toBe('Standard 2-Level Approval')
+        expect(approvalLine.model?.length).toBe(2)
+        expect(approvalLine.model?.[0].approver?.id).toBe(teamLeadRole.id)
+        expect(approvalLine.model?.[1].approver?.id).toBe(managerRole.id)
+      })
+    })
+
+    it('혼합 타입 결재라인이 생성되어야 한다 (Role + Employee)', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const role = await roleFactory.create({ name: 'Team Lead', domain }, tx)
+        const employee = await employeeFactory.createWithDomain(
+          { name: 'Final Approver' },
+          domain,
+          tx
+        )
+
+        const items = [
+          approvalLineFactory.createRoleApprovalItem(role),
+          approvalLineFactory.createEmployeeApprovalItem(employee)
+        ]
+
+        // When
+        const approvalLine = await approvalLineFactory.createMultiLevelApprovalLine(
+          items,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(approvalLine.model?.length).toBe(2)
+        expect(approvalLine.model?.[0].type).toBe('Role')
+        expect(approvalLine.model?.[1].type).toBe('Employee')
+      })
+    })
+
+    it('동적 타입 결재라인이 생성되어야 한다 (Supervisor + DepartmentManager)', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const items = [
+          approvalLineFactory.createSupervisorApprovalItem(),
+          approvalLineFactory.createDepartmentManagerApprovalItem()
+        ]
+
+        // When
+        const approvalLine = await approvalLineFactory.createMultiLevelApprovalLine(
+          items,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(approvalLine.model?.length).toBe(2)
+        expect(approvalLine.model?.[0].type).toBe('Supervisor')
+        expect(approvalLine.model?.[1].type).toBe('DepartmentManager')
+      })
+    })
+  })
+
+  describe('ApprovalLine 조회', () => {
+    it('Domain으로 ApprovalLine을 조회할 수 있어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        await approvalLineFactory.createWithDomain({ name: 'Line A' }, domain, tx)
+        await approvalLineFactory.createWithDomain({ name: 'Line B' }, domain, tx)
+
+        // When
+        const approvalLines = await tx.getRepository('ApprovalLine').find({
+          where: { domain: { id: domain.id } }
+        })
+
+        // Then
+        expect(approvalLines.length).toBe(2)
+      })
+    })
+
+    it('Common 타입 ApprovalLine만 조회할 수 있어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        await approvalLineFactory.createWithDomain(
+          { ownerType: ApprovalLineOwnerType.Common },
+          domain,
+          tx
+        )
+        const employee = await employeeFactory.createWithDomain({}, domain, tx)
+        await approvalLineFactory.createForEmployee({}, employee, tx)
+
+        // When
+        const commonLines = await tx.getRepository('ApprovalLine').find({
+          where: {
+            domain: { id: domain.id },
+            ownerType: ApprovalLineOwnerType.Common
+          }
+        })
+
+        // Then
+        expect(commonLines.length).toBe(1)
+        expect(commonLines[0].ownerType).toBe(ApprovalLineOwnerType.Common)
+      })
+    })
+
+    it('특정 Employee의 ApprovalLine만 조회할 수 있어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const employee1 = await employeeFactory.createWithDomain({ name: 'Emp 1' }, domain, tx)
+        const employee2 = await employeeFactory.createWithDomain({ name: 'Emp 2' }, domain, tx)
+
+        await approvalLineFactory.createForEmployee({ name: 'Line 1' }, employee1, tx)
+        await approvalLineFactory.createForEmployee({ name: 'Line 2' }, employee2, tx)
+
+        // When
+        const employee1Lines = await tx.getRepository('ApprovalLine').find({
+          where: {
+            domain: { id: domain.id },
+            ownerEmployee: { id: employee1.id }
+          }
+        })
+
+        // Then
+        expect(employee1Lines.length).toBe(1)
+      })
+    })
+  })
+})

package/spec/unit/department.spec.ts

@@ -0,0 +1,253 @@
+/**
+ * Department Unit Tests
+ * 부서 엔티티 단위 테스트
+ */
+
+import { TestDatabase } from '../../../../test/test-database'
+import { withTestTransaction } from '../../../../test/test-context'
+import {
+  domainFactory,
+  employeeFactory,
+  departmentFactory
+} from '../../../../test/factories'
+
+describe('Department Entity Tests', () => {
+  let testDb: TestDatabase
+
+  beforeAll(async () => {
+    testDb = TestDatabase.getInstance()
+  })
+
+  describe('Department 생성', () => {
+    it('Department가 올바르게 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // When
+        const department = await departmentFactory.createWithDomain(
+          {
+            controlNo: 'DEPT-001',
+            name: 'Engineering',
+            description: 'Engineering Department'
+          },
+          domain,
+          tx
+        )
+
+        // Then
+        expect(department).toBeDefined()
+        expect(department.id).toBeDefined()
+        expect(department.controlNo).toBe('DEPT-001')
+        expect(department.name).toBe('Engineering')
+        expect(department.description).toBe('Engineering Department')
+        expect(department.domain?.id).toBe(domain.id)
+      })
+    })
+
+    it('controlNo는 필수 필드여야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // When
+        const department = await departmentFactory.createWithDomain(
+          { controlNo: 'REQUIRED-DEPT-001' },
+          domain,
+          tx
+        )
+
+        // Then
+        expect(department.controlNo).toBe('REQUIRED-DEPT-001')
+      })
+    })
+
+    it('active 상태가 관리되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // When: active=true
+        const activeDept = await departmentFactory.createWithDomain(
+          { active: true },
+          domain,
+          tx
+        )
+
+        // When: active=false
+        const inactiveDept = await departmentFactory.createWithDomain(
+          { active: false },
+          domain,
+          tx
+        )
+
+        // Then
+        expect(activeDept.active).toBe(true)
+        expect(inactiveDept.active).toBe(false)
+      })
+    })
+  })
+
+  describe('Department 계층 구조', () => {
+    it('Parent-Child 관계가 설정되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const parent = await departmentFactory.createWithDomain(
+          { name: 'Parent Department' },
+          domain,
+          tx
+        )
+
+        // When
+        const child = await departmentFactory.createChildDepartment(
+          { name: 'Child Department' },
+          parent,
+          tx
+        )
+
+        // Then
+        expect(child.parent?.id).toBe(parent.id)
+      })
+    })
+
+    it('다단계 계층 구조가 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // When
+        const { root, child, grandchild } = await departmentFactory.createHierarchy(domain, tx)
+
+        // Then
+        expect(root.parent).toBeUndefined()
+        expect(child.parent?.id).toBe(root.id)
+        expect(grandchild.parent?.id).toBe(child.id)
+      })
+    })
+
+    it('같은 parent 아래 여러 child가 있을 수 있어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const parent = await departmentFactory.createWithDomain(
+          { name: 'Parent' },
+          domain,
+          tx
+        )
+
+        // When
+        const child1 = await departmentFactory.createChildDepartment(
+          { name: 'Child 1' },
+          parent,
+          tx
+        )
+        const child2 = await departmentFactory.createChildDepartment(
+          { name: 'Child 2' },
+          parent,
+          tx
+        )
+        const child3 = await departmentFactory.createChildDepartment(
+          { name: 'Child 3' },
+          parent,
+          tx
+        )
+
+        // Then
+        expect(child1.parent?.id).toBe(parent.id)
+        expect(child2.parent?.id).toBe(parent.id)
+        expect(child3.parent?.id).toBe(parent.id)
+      })
+    })
+  })
+
+  describe('Department-Manager 관계', () => {
+    it('Department에 Manager를 설정할 수 있어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const department = await departmentFactory.createWithDomain({}, domain, tx)
+        const manager = await employeeFactory.createManager({ department }, domain, tx)
+
+        // When
+        department.manager = manager
+        const updated = await tx.save('Department', department)
+
+        // Then
+        expect(updated.manager?.id).toBe(manager.id)
+      })
+    })
+
+    it('Manager 없이도 Department가 존재할 수 있어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // When
+        const department = await departmentFactory.createWithDomain({}, domain, tx)
+
+        // Then
+        expect(department.manager).toBeUndefined()
+      })
+    })
+  })
+
+  describe('Department 조회', () => {
+    it('Domain으로 부서를 조회할 수 있어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        await departmentFactory.createWithDomain({ name: 'Dept A' }, domain, tx)
+        await departmentFactory.createWithDomain({ name: 'Dept B' }, domain, tx)
+        await departmentFactory.createWithDomain({ name: 'Dept C' }, domain, tx)
+
+        // When
+        const departments = await tx.getRepository('Department').find({
+          where: { domain: { id: domain.id } }
+        })
+
+        // Then
+        expect(departments.length).toBe(3)
+      })
+    })
+
+    it('controlNo로 부서를 조회할 수 있어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        await departmentFactory.createWithDomain(
+          { controlNo: 'UNIQUE-DEPT-001' },
+          domain,
+          tx
+        )
+
+        // When
+        const department = await tx.getRepository('Department').findOne({
+          where: { domain: { id: domain.id }, controlNo: 'UNIQUE-DEPT-001' }
+        })
+
+        // Then
+        expect(department).toBeDefined()
+        expect(department?.controlNo).toBe('UNIQUE-DEPT-001')
+      })
+    })
+  })
+
+  describe('Department 속성', () => {
+    it('extension(내선번호)이 저장되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // When
+        const department = await departmentFactory.createWithDomain(
+          { extension: '1234' },
+          domain,
+          tx
+        )
+
+        // Then
+        expect(department.extension).toBe('1234')
+      })
+    })
+  })
+})