@things-factory/organization 10.1.81 → 10.1.84

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/organization",
-  "version": "10.1.81",
+  "version": "10.1.84",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -41,5 +41,5 @@
     "@things-factory/contact": "^10.1.79",
     "@things-factory/shell": "^10.1.79"
   },
-  "gitHead": "0c4f91d92c8214a9b2eca6690a7ed48bd2d828cc"
+  "gitHead": "12df439ce09de2bc9aa87d4578766f46bfad48fd"
 }

package/spec/unit/employee.spec.ts

@@ -188,8 +188,8 @@ describe('Employee Entity Tests', () => {
         const { tx, domain } = context.state
 
         // Given
-        const hiredOn = new Date('2020-01-15')
-        const retiredOn = new Date('2024-12-31')
+        const hiredOn = '2020-01-15'
+        const retiredOn = '2024-12-31'
 
         // When
         const employee = await employeeFactory.createWithDomain(

package/tests/department-parent.test.ts

@@ -0,0 +1,185 @@
+/**
+ * A department's parent can be set, changed and cleared from the department list, and a loop is refused.
+ *
+ * The list had no parent cell. Departments made anywhere but "add child node" on a new row stayed top-level
+ * for good — OA's five all were — and the department selector, which drew the first top-level department
+ * only, could offer one of the five.
+ *
+ * This sends the list's patch through the server's own DepartmentPatch and the real updateMultipleDepartment,
+ * on sqlite, and reads the parent back from the table.
+ */
+import 'reflect-metadata'
+
+const { existsSync } = require('fs')
+const { join } = require('path')
+const { DataSource } = require('typeorm')
+const { buildSchema, Resolver, Query, Mutation, Arg, Ctx } = require('type-graphql')
+const { graphql } = require('graphql')
+
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+const contact = require('@things-factory/contact')
+
+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 Department: any
+let schema: any
+let domain: any
+let user: any
+
+const SAVE = `
+  mutation ($patches: [DepartmentPatch!]!) {
+    updateMultipleDepartment(patches: $patches) { id name }
+  }
+`
+
+beforeAll(async () => {
+  const organization = loadCompiled('service/index')
+  Department = loadCompiled('service/department/department').Department
+  const { DepartmentMutation } = loadCompiled('service/department/department-mutation')
+  const { DepartmentPatch } = loadCompiled('service/department/department-type')
+
+  dataSource = new DataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, ...contact.entities, ...organization.entities],
+    logging: false
+  })
+  await dataSource.initialize()
+  shell.addDataSource('default', dataSource)
+  shell.addDataSource('tx', dataSource)
+
+  /* The real mutation behind the real input type; the context stands in for what its directives set up. */
+  class DepartmentParentProbe {
+    probe() {
+      return true
+    }
+
+    async updateMultipleDepartment(patches: any[], context: any) {
+      return await new DepartmentMutation().updateMultipleDepartment(patches, context)
+    }
+  }
+  Query(() => Boolean)(DepartmentParentProbe.prototype, 'probe', Object.getOwnPropertyDescriptor(DepartmentParentProbe.prototype, 'probe'))
+  Arg('patches', () => [DepartmentPatch])(DepartmentParentProbe.prototype, 'updateMultipleDepartment', 0)
+  Ctx()(DepartmentParentProbe.prototype, 'updateMultipleDepartment', 1)
+  Mutation(() => [Department])(
+    DepartmentParentProbe.prototype,
+    'updateMultipleDepartment',
+    Object.getOwnPropertyDescriptor(DepartmentParentProbe.prototype, 'updateMultipleDepartment')
+  )
+  Resolver()(DepartmentParentProbe)
+
+  schema = await buildSchema({ resolvers: [DepartmentParentProbe], validate: false })
+})
+
+let ceo: any
+let team1: any
+let team2: any
+
+beforeEach(async () => {
+  await dataSource.synchronize(true)
+  domain = await dataSource.getRepository(shell.Domain).save({ name: 'department-parent', subdomain: 'department-parent' })
+  user = await dataSource.getRepository(authBase.User).save({ name: 'tester', email: 'tester@department-parent.test' })
+
+  /* OA's shape: every department top-level. */
+  const repository = dataSource.getRepository(Department)
+  ceo = await repository.save({ domain, controlNo: 'CEO', name: 'CEO' })
+  team1 = await repository.save({ domain, controlNo: 'T01', name: '1팀' })
+  team2 = await repository.save({ domain, controlNo: 'T02', name: '2팀' })
+})
+
+afterAll(async () => {
+  if (!dataSource) return
+  shell.removeDataSource('default')
+  shell.removeDataSource('tx')
+  await dataSource.destroy()
+})
+
+async function save(patches: any[]) {
+  return await graphql({
+    schema,
+    source: SAVE,
+    variableValues: { patches },
+    contextValue: { state: { domain, user, tx: dataSource.manager } }
+  })
+}
+
+async function parentOf(department: any) {
+  return (await dataSource.getRepository(Department).findOneBy({ id: department.id })).parentId ?? null
+}
+
+describe("a department's parent is set from the department list", () => {
+  it('an existing top-level department moves under another', async () => {
+    const result = await save([
+      { id: team1.id, cuFlag: 'M', parent: { id: ceo.id } },
+      { id: team2.id, cuFlag: 'M', parent: { id: ceo.id } }
+    ])
+
+    expect(result.errors).toBeUndefined()
+    expect(await parentOf(team1)).toBe(ceo.id)
+    expect(await parentOf(team2)).toBe(ceo.id)
+    expect(await parentOf(ceo)).toBeNull()
+  })
+
+  it('moves from one parent to another, and back to top-level with null', async () => {
+    await save([{ id: team2.id, cuFlag: 'M', parent: { id: ceo.id } }])
+
+    expect((await save([{ id: team2.id, cuFlag: 'M', parent: { id: team1.id } }])).errors).toBeUndefined()
+    expect(await parentOf(team2)).toBe(team1.id)
+
+    expect((await save([{ id: team2.id, cuFlag: 'M', parent: null }])).errors).toBeUndefined()
+    expect(await parentOf(team2)).toBeNull()
+  })
+
+  it('an edit that does not name the parent leaves it where it is', async () => {
+    await save([{ id: team1.id, cuFlag: 'M', parent: { id: ceo.id } }])
+
+    expect((await save([{ id: team1.id, cuFlag: 'M', description: 'first team' }])).errors).toBeUndefined()
+    expect(await parentOf(team1)).toBe(ceo.id)
+  })
+
+  it('a new row added under a department is saved there', async () => {
+    const result = await save([{ cuFlag: '+', controlNo: 'T01-A', name: '1팀 A조', parent: { id: team1.id } }])
+
+    expect(result.errors).toBeUndefined()
+    const created = await dataSource.getRepository(Department).findOneBy({ controlNo: 'T01-A' })
+    expect(created.parentId).toBe(team1.id)
+  })
+
+  it('a department cannot be its own parent', async () => {
+    const result = await save([{ id: team1.id, cuFlag: 'M', parent: { id: team1.id } }])
+
+    expect(result.errors?.[0]?.message).toMatch(/cannot be placed under itself/)
+    expect(await parentOf(team1)).toBeNull()
+  })
+
+  it('a department cannot go under one of its own sub-departments', async () => {
+    await save([{ id: team1.id, cuFlag: 'M', parent: { id: ceo.id } }])
+    await save([{ id: team2.id, cuFlag: 'M', parent: { id: team1.id } }])
+
+    const result = await save([{ id: ceo.id, cuFlag: 'M', parent: { id: team2.id } }])
+
+    expect(result.errors?.[0]?.message).toMatch(/cannot be placed under itself/)
+    expect(await parentOf(ceo)).toBeNull()
+  })
+
+  it('a parent from another domain is not found', async () => {
+    const other = await dataSource.getRepository(shell.Domain).save({ name: 'other', subdomain: 'other' })
+    const stranger = await dataSource.getRepository(Department).save({ domain: other, controlNo: 'X', name: 'X' })
+
+    const result = await save([{ id: team1.id, cuFlag: 'M', parent: { id: stranger.id } }])
+
+    expect(result.errors?.[0]?.message).toMatch(/parent department not found/)
+    expect(await parentOf(team1)).toBeNull()
+  })
+})

package/tests/department-patch.test.ts

@@ -0,0 +1,52 @@
+import { toDepartmentPatch } from '../client/pages/department/department-patch'
+
+/**
+ * The department list's save sends the parent as a reference.
+ *
+ * The parent cell's selector hands back { id, controlNo, name, description }. DepartmentPatch.parent is an
+ * ObjectRef, which has no controlNo, so the whole patch would be refused if the cell's value went as it is.
+ */
+describe('the department list sends a parent as { id } or null', () => {
+  const picked = { id: 'd-ceo', controlNo: 'CEO', name: 'CEO', description: 'office' }
+
+  it('a changed parent cell goes as its id only', () => {
+    const patch = toDepartmentPatch({
+      id: 'd-t01',
+      __dirty__: 'M',
+      __dirtyfields__: { parent: { before: null, after: picked } }
+    })
+
+    expect(patch).toEqual({ id: 'd-t01', parent: { id: 'd-ceo' }, cuFlag: 'M' })
+  })
+
+  it('a cleared parent cell goes as null, which makes the department top-level', () => {
+    const patch = toDepartmentPatch({
+      id: 'd-t01',
+      __dirty__: 'M',
+      __dirtyfields__: { parent: { before: picked, after: null } }
+    })
+
+    expect(patch.parent).toBeNull()
+  })
+
+  it('an edit of another cell does not send the parent the row was drawn with', () => {
+    const patch = toDepartmentPatch({
+      id: 'd-t01',
+      parent: { id: 'd-ceo', name: 'CEO' },
+      __dirty__: 'M',
+      __dirtyfields__: { description: { before: '', after: 'first team' } }
+    })
+
+    expect(patch).toEqual({ id: 'd-t01', description: 'first team', cuFlag: 'M' })
+  })
+
+  it('a row added with "add child node" sends the parent it was added under', () => {
+    const patch = toDepartmentPatch({
+      parent: { id: 'd-t01' },
+      __dirty__: '+',
+      __dirtyfields__: { name: { before: undefined, after: '1팀 A조' } }
+    })
+
+    expect(patch).toEqual({ name: '1팀 A조', parent: { id: 'd-t01' }, cuFlag: '+' })
+  })
+})

package/tests/employee-day.test.ts

@@ -0,0 +1,163 @@
+/**
+ * hiredOn and retiredOn are calendar days, and the grid's date editor sends them as 'YYYY-MM-DD'.
+ *
+ * They were declared `Date`, so GraphQL typed them as a date-time and refused the grid's own value before
+ * any resolver ran: 'Variable "$patches" got invalid value "2025-12-31" at "patches[0].retiredOn"'. The
+ * employee list could not save a retire day at all.
+ *
+ * This sends the grid's patch through the server's own EmployeePatch and Employee types and the real
+ * updateMultipleEmployee, on sqlite, and reads the day back — from the table, from the history row and
+ * through GraphQL — unchanged.
+ */
+import 'reflect-metadata'
+
+const { existsSync } = require('fs')
+const { join } = require('path')
+const { DataSource } = require('typeorm')
+const { buildSchema, Resolver, Query, Mutation, Arg, Ctx } = require('type-graphql')
+const { graphql } = require('graphql')
+
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+const contact = require('@things-factory/contact')
+
+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 Employee: any
+let EmployeeHistory: any
+let schema: any
+let domain: any
+let user: any
+
+const SAVE = `
+  mutation ($patches: [EmployeePatch!]!) {
+    updateMultipleEmployee(patches: $patches) { id hiredOn retiredOn }
+  }
+`
+
+beforeAll(async () => {
+  organization = loadCompiled('service/index')
+  Employee = loadCompiled('service/employee/employee').Employee
+  EmployeeHistory = loadCompiled('service/employee/employee-history').EmployeeHistory
+  const { EmployeeHistoryEntitySubscriber } = loadCompiled('service/employee/event-subscriber')
+  const { EmployeeMutation } = loadCompiled('service/employee/employee-mutation')
+  const { EmployeePatch } = loadCompiled('service/employee/employee-type')
+
+  dataSource = new DataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, ...contact.entities, ...organization.entities],
+    subscribers: [EmployeeHistoryEntitySubscriber],
+    logging: false
+  })
+  await dataSource.initialize()
+  shell.addDataSource('default', dataSource)
+  shell.addDataSource('tx', dataSource)
+
+  /* The real mutation, behind the real input and output types. Its @transaction and @privilege directives are
+   * the framework's; the context below stands in for what they set up. */
+  class EmployeeDayProbe {
+    /* A schema needs a Query field; this one is never asked. */
+    probe() {
+      return true
+    }
+
+    async updateMultipleEmployee(patches: any[], context: any) {
+      return await new EmployeeMutation().updateMultipleEmployee(patches, context)
+    }
+  }
+  Arg('patches', () => [EmployeePatch])(EmployeeDayProbe.prototype, 'updateMultipleEmployee', 0)
+  Ctx()(EmployeeDayProbe.prototype, 'updateMultipleEmployee', 1)
+  Mutation(() => [Employee])(
+    EmployeeDayProbe.prototype,
+    'updateMultipleEmployee',
+    Object.getOwnPropertyDescriptor(EmployeeDayProbe.prototype, 'updateMultipleEmployee')
+  )
+  Query(() => Boolean)(EmployeeDayProbe.prototype, 'probe', Object.getOwnPropertyDescriptor(EmployeeDayProbe.prototype, 'probe'))
+  Resolver()(EmployeeDayProbe)
+
+  schema = await buildSchema({ resolvers: [EmployeeDayProbe], validate: false })
+})
+
+beforeEach(async () => {
+  await dataSource.synchronize(true)
+  domain = await dataSource.getRepository(shell.Domain).save({ name: 'employee-day', subdomain: 'employee-day' })
+  user = await dataSource.getRepository(authBase.User).save({ name: 'tester', email: 'tester@employee-day.test' })
+})
+
+afterAll(async () => {
+  if (!dataSource) return
+  shell.removeDataSource('default')
+  shell.removeDataSource('tx')
+  await dataSource.destroy()
+})
+
+async function save(patches: any[]) {
+  return await graphql({
+    schema,
+    source: SAVE,
+    variableValues: { patches },
+    contextValue: { state: { domain, user, tx: dataSource.manager } }
+  })
+}
+
+async function seedEmployee() {
+  return await dataSource.getRepository(Employee).save({ domain, controlNo: 'E-1', name: 'Kim', hiredOn: '2020-01-15' })
+}
+
+describe('employee hire and retire days are calendar days', () => {
+  it("the grid's patch with retiredOn '2025-12-31' saves and reads back unchanged", async () => {
+    const employee = await seedEmployee()
+
+    const result = await save([{ id: employee.id, cuFlag: 'M', retiredOn: '2025-12-31' }])
+
+    expect(result.errors).toBeUndefined()
+    expect(result.data.updateMultipleEmployee).toEqual([{ id: employee.id, hiredOn: '2020-01-15', retiredOn: '2025-12-31' }])
+
+    const stored = await dataSource.getRepository(Employee).findOneBy({ id: employee.id })
+    expect(stored.retiredOn).toBe('2025-12-31')
+    expect(stored.hiredOn).toBe('2020-01-15')
+
+    const history = await dataSource.getRepository(EmployeeHistory).find({ where: { originalId: employee.id } })
+    expect(history.map(row => row.retiredOn)).toContain('2025-12-31')
+  })
+
+  it('hiredOn edited in the grid saves too', async () => {
+    const employee = await seedEmployee()
+
+    const result = await save([{ id: employee.id, cuFlag: 'M', hiredOn: '2021-03-02' }])
+
+    expect(result.errors).toBeUndefined()
+    expect((await dataSource.getRepository(Employee).findOneBy({ id: employee.id })).hiredOn).toBe('2021-03-02')
+  })
+
+  it("a cleared date cell ('') removes the day", async () => {
+    const employee = await seedEmployee()
+
+    const result = await save([{ id: employee.id, cuFlag: 'M', hiredOn: '' }])
+
+    expect(result.errors).toBeUndefined()
+    expect((await dataSource.getRepository(Employee).findOneBy({ id: employee.id })).hiredOn).toBeNull()
+  })
+
+  it('a value that is not a calendar day is refused, not stored', async () => {
+    const employee = await seedEmployee()
+
+    for (const value of ['2025-12-31T00:00:00.000Z', '2025-02-30', '45657']) {
+      const result = await save([{ id: employee.id, cuFlag: 'M', retiredOn: value }])
+      expect(result.errors?.[0]?.message).toMatch(/retiredOn must be a calendar day/)
+    }
+    expect((await dataSource.getRepository(Employee).findOneBy({ id: employee.id })).retiredOn).toBeNull()
+  })
+})

package/translations/en.json

@@ -19,6 +19,7 @@
   "field.notify-after": "notify at",
   "field.owner": "owner",
   "field.owner-type": "owner type",
+  "field.parent-department": "parent department",
   "field.participation": "capacity",
   "field.register-account": "account",
   "field.supervisor": "supervisor",

package/translations/ja.json

@@ -19,6 +19,7 @@
   "field.notify-after": "通知時点",
   "field.owner": "所有者",
   "field.owner-type": "所有者タイプ",
+  "field.parent-department": "上位部署",
   "field.participation": "資格",
   "field.register-account": "アカウント登録",
   "field.supervisor": "監督者",

package/translations/ko.json

@@ -19,6 +19,7 @@
   "field.notify-after": "알림 시점",
   "field.owner": "소유자",
   "field.owner-type": "소유자 종류",
+  "field.parent-department": "상위 부서",
   "field.participation": "자격",
   "field.register-account": "계정 등록",
   "field.supervisor": "감독자",

package/translations/ms.json

@@ -19,6 +19,7 @@
   "field.notify-after": "masa notis",
   "field.owner": "pemilik",
   "field.owner-type": "jenis pemilik",
+  "field.parent-department": "jabatan induk",
   "field.participation": "kapasiti",
   "field.register-account": "daftar akaun",
   "field.supervisor": "penyelia",

package/translations/zh.json

@@ -19,6 +19,7 @@
   "field.notify-after": "通知时点",
   "field.owner": "所有者",
   "field.owner-type": "所有者类型",
+  "field.parent-department": "上级部门",
   "field.participation": "身份",
   "field.register-account": "注册账户",
   "field.supervisor": "主管",