@things-factory/organization 10.1.181 → 10.1.183

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/organization",
-  "version": "10.1.181",
+  "version": "10.1.183",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -36,10 +36,10 @@
     "@operato/p13n": "^10.0.0",
     "@operato/popup": "^10.15.0",
     "@operato/shell": "^10.0.0",
-    "@things-factory/auth-base": "^10.1.181",
-    "@things-factory/code-ui": "^10.1.181",
-    "@things-factory/contact": "^10.1.181",
+    "@things-factory/auth-base": "^10.1.183",
+    "@things-factory/code-ui": "^10.1.183",
+    "@things-factory/contact": "^10.1.183",
     "@things-factory/shell": "^10.1.179"
   },
-  "gitHead": "a4387dbc9c5be49ac7bd0e85a59fbcd650f47138"
+  "gitHead": "c36684e0db8353f5f4523ed55111df3154bae19e"
 }

package/tests/employee-private.test.ts

@@ -0,0 +1,26 @@
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+import { EMPLOYEE_PRIVATE_FIELDS, privateFieldsOf } from '../server/service/employee/employee-private'
+
+/**
+ * An employee's pay account is HR-payroll's (ADR-0139): read under `employee-private`, apart from the roster every
+ * seat reads, and written only by whoever may change it.
+ */
+describe("an employee's pay account", () => {
+  it('★ is declared under employee-private on the employee and its history - the declaration, not a resolver', () => {
+    for (const file of ['employee.ts', 'employee-history.ts']) {
+      const source = readFileSync(join(__dirname, '..', 'server', 'service', 'employee', file), 'utf8')
+      for (const field of EMPLOYEE_PRIVATE_FIELDS) {
+        expect([file, field, new RegExp(`@privilege\\(category: "employee-private", privilege: "query"[^\\n]*\\n  @Field\\(\\{ nullable: true \\}\\)\\n  ${field}\\?:`).test(source)]).toEqual([file, field, true])
+      }
+    }
+  })
+
+  it('★ a patch that writes it is told apart from one that leaves it alone', () => {
+    expect(privateFieldsOf({ name: '홍길동', bankAccount: '123', bankName: undefined })).toEqual(['bankAccount'])
+    expect(privateFieldsOf({ name: '홍길동' })).toEqual([])
+    expect(privateFieldsOf({ bankName: '' })).toEqual(['bankName'])
+    expect(privateFieldsOf(null)).toEqual([])
+  })
+})

package/tests/register-employee-role.test.ts

@@ -0,0 +1,97 @@
+/**
+ * Registering an employee as a system user gives the role named as their job responsibility when the domain has one.
+ *
+ * A domain's roles need not follow its job titles (hatiolab: roles 직원 · 팀장 · 경영지원 …, job responsibilities
+ * 연구원 · 실장 · FDE …). Registering a 연구원 there was refused outright — 「'{name}'라는 이름의 역할이 정의되어
+ * 있지 않습니다」 — so most employees could not be registered at all. The employee is registered; the role comes
+ * along only when it exists, as a job change already swaps it.
+ *
+ * Runs the real controller on sqlite. The account already exists by the contact's work email, so no initial
+ * password is needed.
+ */
+import 'reflect-metadata'
+
+const { existsSync } = require('fs')
+const { join } = require('path')
+const { DataSource } = require('typeorm')
+
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+const contact = require('@things-factory/contact')
+const bizBase = require('@things-factory/biz-base')
+
+function loadCompiled(modulePath: string): any {
+  const resolved = join(__dirname, '..', 'dist-server', `${modulePath}.js`)
+  if (!existsSync(resolved)) {
+    throw new Error(`organization build output is missing: ${resolved}\nBuild it first: npm run build:server`)
+  }
+  return require(resolved)
+}
+
+let dataSource: any
+let organization: any
+let register: any
+let domain: any
+let admin: any
+
+beforeAll(async () => {
+  organization = loadCompiled('service/index')
+  register = loadCompiled('controllers/register-employee-as-system-user').registerEmployeeAsSystemUser
+  dataSource = new DataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, ...bizBase.entities, ...contact.entities, ...organization.entities],
+    logging: false
+  })
+  await dataSource.initialize()
+  shell.addDataSource('default', dataSource)
+  shell.addDataSource('tx', dataSource)
+})
+
+beforeEach(async () => {
+  await dataSource.synchronize(true)
+  domain = await dataSource.getRepository(shell.Domain).save({ name: 'register-role', subdomain: 'register-role' })
+  admin = await dataSource.getRepository(authBase.User).save({ name: 'admin', email: 'admin@register-role.test' })
+  await dataSource.getRepository(authBase.Role).save({ name: '팀장', domain })
+})
+
+afterAll(async () => {
+  if (!dataSource) return
+  shell.removeDataSource('default')
+  shell.removeDataSource('tx')
+  await dataSource.destroy()
+})
+
+async function employeeAs(jobResponsibility: string, email: string) {
+  await dataSource.getRepository(authBase.User).save({ name: email, email, domains: [domain] })
+  const card = await dataSource
+    .getRepository(contact.Contact)
+    .save({ domain, name: email, items: [{ type: 'email', label: 'work', value: email }] })
+  return await dataSource
+    .getRepository(organization.Employee)
+    .save({ domain, controlNo: email, name: email, active: true, jobResponsibility, contact: card })
+}
+
+async function registered(employeeId: string) {
+  await dataSource.transaction((tx: any) => register(employeeId, { state: { domain, user: admin, tx }, t: (key: string) => key }))
+  const employee = await dataSource.getRepository(organization.Employee).findOne({ where: { id: employeeId }, relations: ['user'] })
+  return await dataSource.getRepository(authBase.User).findOne({ where: { id: employee.user.id }, relations: ['roles'] })
+}
+
+describe('an employee is registered as a system user whether or not a role is named as their job', () => {
+  it('a job responsibility with no role of its name registers the employee with no role', async () => {
+    const researcher = await employeeAs('연구원', 'researcher@register-role.test')
+    const user = await registered(researcher.id)
+    expect(user.email).toBe('researcher@register-role.test')
+    expect(user.roles.map((one: any) => one.name)).toEqual([])
+  })
+
+  it('a job responsibility with a role of its name registers the employee with that role', async () => {
+    const lead = await employeeAs('팀장', 'lead@register-role.test')
+    const user = await registered(lead.id)
+    expect(user.roles.map((one: any) => one.name)).toEqual(['팀장'])
+  })
+})