@things-factory/organization 10.1.223 → 10.1.227

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/organization",
-  "version": "10.1.223",
+  "version": "10.1.227",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -36,10 +36,12 @@
     "@operato/p13n": "^10.0.0",
     "@operato/popup": "^10.15.0",
     "@operato/shell": "^10.0.0",
-    "@things-factory/auth-base": "^10.1.223",
-    "@things-factory/code-ui": "^10.1.223",
-    "@things-factory/contact": "^10.1.223",
-    "@things-factory/shell": "^10.1.208"
+    "@things-factory/auth-base": "^10.1.227",
+    "@things-factory/code-ui": "^10.1.227",
+    "@things-factory/contact": "^10.1.227",
+    "@things-factory/pdf": "^10.1.227",
+    "@things-factory/shell": "^10.1.227",
+    "exceljs": "4.2.0"
   },
-  "gitHead": "868f2026b8373371ad04f42b0a097964d0d0ed0f"
+  "gitHead": "f66591e3864aab08a6fb93fb1fcf1c9de6b546ac"
 }

package/tests/employee-profile-db.test.ts

@@ -0,0 +1,247 @@
+/**
+ * The profile's doors, through GraphQL on sqlite (ADR-0169 decisions 3 · 4): the employee writes their own and nobody
+ * else's, an account not linked to an employee has none, and the list gives every active employee with theirs.
+ *
+ * The real resolvers and types are built into a schema; @privilege and @transaction are the framework's, and the context
+ * below stands in for what they set up. What each door asks is read from its source.
+ */
+import 'reflect-metadata'
+
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+const { DataSource } = require('typeorm')
+const { buildSchema } = 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')
+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 schema: any
+let domain: any
+
+const ROWS = `
+  summary skills updatedAt employeeId
+  educations { school major degree startedOn endedOn }
+  certificates { name issuer acquiredOn }
+  careers { company department position startedOn endedOn duties }
+  projects { name client startedOn endedOn role duties technologies }
+`
+const MINE = `query { myEmployeeProfile { ${ROWS} } }`
+const SAVE = `mutation ($profile: EmployeeProfileInput!) { saveMyEmployeeProfile(profile: $profile) { ${ROWS} } }`
+const LIST = `query { employeeProfiles { employeeId name departmentName jobPosition jobResponsibility hiredOn profile { summary skills } } }`
+
+beforeAll(async () => {
+  organization = loadCompiled('service/index')
+  const { resolvers } = loadCompiled('service/employee-profile/index')
+  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)
+  schema = await buildSchema({ resolvers, validate: false })
+})
+
+beforeEach(async () => {
+  await dataSource.synchronize(true)
+  domain = await dataSource.getRepository(shell.Domain).save({ name: 'profile', subdomain: 'profile' })
+})
+
+afterAll(async () => {
+  if (!dataSource) return
+  shell.removeDataSource('default')
+  shell.removeDataSource('tx')
+  await dataSource.destroy()
+})
+
+async function person(name: string, employee: Record<string, unknown> | null = {}) {
+  const user = await dataSource.getRepository(authBase.User).save({ name, email: `${name}@profile.test` })
+  if (employee) {
+    const department = (await dataSource.getRepository(organization.Department).findOneBy({ name: '개발팀' })) ?? (await dataSource.getRepository(organization.Department).save({ domain, controlNo: 'D-1', name: '개발팀' }))
+    await dataSource.getRepository(organization.Employee).save({ domain, controlNo: name, name, user, department, active: true, ...employee })
+  }
+  return user
+}
+
+async function ask(user: any, source: string, variableValues?: any) {
+  const result = await graphql({ schema, source, variableValues, contextValue: { state: { domain, user, tx: dataSource.manager }, t: (key: string) => key } })
+  return result
+}
+
+describe("an employee's own profile", () => {
+  it('★ an account not linked to an employee has none, and cannot write one', async () => {
+    const stranger = await person('stranger', null)
+    expect((await ask(stranger, MINE)).data.myEmployeeProfile).toBeNull()
+    const refused = await ask(stranger, SAVE, { profile: { summary: 'x' } })
+    expect(refused.errors?.[0]?.extensions?.requires).toBe('no-employee')
+    expect(await dataSource.getRepository(organization.EmployeeProfile).count()).toBe(0)
+  })
+
+  it('★ is written whole and read back; writing again replaces it, one profile per employee', async () => {
+    const kim = await person('kim')
+    expect((await ask(kim, MINE)).data.myEmployeeProfile).toBeNull()
+
+    const first = await ask(kim, SAVE, {
+      profile: {
+        summary: ' MES 10년 ',
+        skills: ['TypeScript', 'TypeScript', 'SQL'],
+        educations: [{ school: '서울대', major: '컴퓨터공학', degree: '학사', startedOn: '2005-03', endedOn: '2009-02' }],
+        projects: [{ name: '미라텍 MES', client: '미라텍', startedOn: '2024-01', role: 'PM' }, { name: '' }]
+      }
+    })
+    expect(first.errors).toBeUndefined()
+    const mine = (await ask(kim, MINE)).data.myEmployeeProfile
+    expect(mine).toMatchObject({
+      summary: 'MES 10년',
+      skills: ['TypeScript', 'SQL'],
+      educations: [{ school: '서울대', major: '컴퓨터공학', degree: '학사', startedOn: '2005-03', endedOn: '2009-02' }],
+      certificates: [],
+      projects: [{ name: '미라텍 MES', client: '미라텍', startedOn: '2024-01', endedOn: null, role: 'PM', duties: null, technologies: null }]
+    })
+
+    await ask(kim, SAVE, { profile: { summary: '바꿈', certificates: [{ name: '정보처리기사' }] } })
+    const again = (await ask(kim, MINE)).data.myEmployeeProfile
+    expect(again).toMatchObject({ summary: '바꿈', skills: [], educations: [], certificates: [{ name: '정보처리기사' }], projects: [] })
+    expect(await dataSource.getRepository(organization.EmployeeProfile).count()).toBe(1)
+  })
+
+  it('★ adding from a résumé takes nothing away, and reaches only one\'s own', async () => {
+    const kim = await person('kim')
+    const park = await person('park')
+    await ask(park, SAVE, { profile: { summary: 'park' } })
+    await ask(kim, SAVE, { profile: { summary: '옛 요약', skills: ['TypeScript'], projects: [{ name: 'A' }] } })
+    const ADD = `mutation ($profile: EmployeeProfileInput!) { addToMyEmployeeProfile(profile: $profile) { ${ROWS} } }`
+    const added = await ask(kim, ADD, { profile: { skills: ['typescript', 'PLC'], projects: [{ name: 'A' }, { name: 'B', role: 'PM' }] } })
+    expect(added.errors).toBeUndefined()
+    expect(added.data.addToMyEmployeeProfile).toMatchObject({ summary: '옛 요약', skills: ['TypeScript', 'PLC'], projects: [{ name: 'A' }, { name: 'B', role: 'PM' }] })
+    expect((await ask(park, MINE)).data.myEmployeeProfile.summary).toBe('park')
+    const stranger = await person('stranger', null)
+    expect((await ask(stranger, ADD, { profile: { summary: 'x' } })).errors?.[0]?.extensions?.requires).toBe('no-employee')
+  })
+
+  it("★ one employee's save never touches another's profile", async () => {
+    const kim = await person('kim')
+    const park = await person('park')
+    await ask(kim, SAVE, { profile: { summary: 'kim' } })
+    await ask(park, SAVE, { profile: { summary: 'park' } })
+    expect((await ask(kim, MINE)).data.myEmployeeProfile.summary).toBe('kim')
+    expect((await ask(park, MINE)).data.myEmployeeProfile.summary).toBe('park')
+    expect(await dataSource.getRepository(organization.EmployeeProfile).count()).toBe(2)
+  })
+})
+
+describe('the profiles of every active employee', () => {
+  it('★ lists each active employee with the basics and their profile, empty when none was written', async () => {
+    const kim = await person('kim', { jobPosition: '과장', jobResponsibility: '팀장', hiredOn: '2020-03-02' })
+    await person('lee')
+    await person('gone', { retiredOn: '2020-01-01' })
+    await person('off', { active: false })
+    await ask(kim, SAVE, { profile: { summary: 'S', skills: ['A'] } })
+
+    const list = await ask(kim, LIST)
+    expect(list.errors).toBeUndefined()
+    expect(list.data.employeeProfiles.map((one: any) => [one.name, one.departmentName, one.profile?.summary ?? null])).toEqual([
+      ['kim', '개발팀', 'S'],
+      ['lee', '개발팀', null]
+    ])
+    expect(list.data.employeeProfiles[0]).toMatchObject({ jobPosition: '과장', jobResponsibility: '팀장', hiredOn: '2020-03-02', profile: { skills: ['A'] } })
+  })
+
+  it('★ the document of the chosen: active ones only, in the order chosen, as an Excel workbook', async () => {
+    const kim = await person('kim')
+    await person('lee')
+    await person('gone', { retiredOn: '2020-01-01' })
+    const ids = (await ask(kim, LIST)).data.employeeProfiles.map((one: any) => one.employeeId)
+    const goneId = (await dataSource.getRepository(organization.Employee).findOneBy({ name: 'gone' })).id
+    const answer = await ask(kim, `query ($ids: [String!]!) { employeeProfileDocument(employeeIds: $ids, format: XLSX) { fileName mimeType content } }`, { ids: [ids[1], goneId, ids[0]] })
+    expect(answer.errors).toBeUndefined()
+    const file = answer.data.employeeProfileDocument
+    expect(file.fileName).toMatch(/^text\.employee-profile-file-\d{8}\.xlsx$/)
+    expect(file.mimeType).toBe('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
+    const { Workbook } = require('exceljs')
+    const book = new Workbook()
+    await book.xlsx.load(Buffer.from(file.content, 'base64'))
+    expect(book.worksheets.map((sheet: any) => sheet.name)).toEqual(['Text.employee-profile-doc-roste', 'lee', 'kim'])
+  })
+
+  it('the preview is an HTML page of the same people', async () => {
+    const kim = await person('kim')
+    const ids = (await ask(kim, LIST)).data.employeeProfiles.map((one: any) => one.employeeId)
+    const answer = await ask(kim, `query ($ids: [String!]!) { employeeProfileDocument(employeeIds: $ids, format: HTML) { fileName mimeType content } }`, { ids })
+    expect(answer.errors).toBeUndefined()
+    const file = answer.data.employeeProfileDocument
+    expect(file.mimeType).toBe('text/html')
+    expect(file.fileName).toMatch(/\.html$/)
+    expect(Buffer.from(file.content, 'base64').toString('utf8')).toContain('<td class="name" colspan="6">kim</td>')
+  })
+
+  it("★ the document's own words follow the language asked for - one the application runs - or the reader's", () => {
+    const { documentTranslator } = loadCompiled('service/employee-profile/employee-profile-query')
+    const env = require('@things-factory/env')
+    const runs = jest.spyOn(env.config, 'get').mockImplementation((key: string, fallback: any) => (key === 'i18n/languages' ? [{ code: 'ko-KR' }, { code: 'en-US' }] : fallback))
+    try {
+      const context = { t: (key: string) => `reader:${key}`, i18next: { getFixedT: (lng: string) => (key: string) => `${lng}:${key}` } }
+      expect(documentTranslator(context, null)('text.employee-profile-doc-title')).toBe('reader:text.employee-profile-doc-title')
+      expect(documentTranslator(context, 'en-US')('text.employee-profile-doc-title')).toBe('en-US:text.employee-profile-doc-title')
+      expect(() => documentTranslator(context, 'fr-FR')).toThrow('does not run the language "fr-FR"')
+    } finally {
+      runs.mockRestore()
+    }
+  })
+
+  it('★ reaching a profile does not reach the employee record behind it', () => {
+    const type = schema.getType('EmployeeProfile').getFields()
+    expect(Object.keys(type)).not.toContain('employee')
+    expect(Object.keys(type)).not.toContain('creator')
+    expect(Object.keys(schema.getType('EmployeeWithProfile').getFields()).sort()).toEqual(
+      ['controlNo', 'departmentName', 'employeeId', 'hiredOn', 'jobPosition', 'jobResponsibility', 'name', 'profile'].sort()
+    )
+  })
+})
+
+describe('what each door asks', () => {
+  const source = (file: string) => readFileSync(join(__dirname, '..', 'server', 'service', 'employee-profile', file), 'utf8')
+  const asks = (text: string, door: string) => {
+    const before = text.slice(0, text.indexOf(`async ${door}(`))
+    return before.slice(before.lastIndexOf('@Directive(\'@privilege')).match(/category: "([a-z-]+)", privilege: "(\w+)", domainOwnerGranted: (\w+)/)?.slice(1)
+  }
+
+  it('★ one\'s own under employee-self, everyone\'s under employee-profile - and no door writes another\'s', () => {
+    expect(asks(source('employee-profile-query.ts'), 'myEmployeeProfile')).toEqual(['employee-self', 'query', 'true'])
+    expect(asks(source('employee-profile-query.ts'), 'employeeProfiles')).toEqual(['employee-profile', 'query', 'true'])
+    const mutation = source('employee-profile-mutation.ts')
+    /* Two doors write - saving the whole and adding from a résumé - and each finds the profile from the caller alone. */
+    expect([...mutation.matchAll(/@Mutation\(/g)]).toHaveLength(2)
+    for (const door of ['saveMyEmployeeProfile', 'addToMyEmployeeProfile']) {
+      expect(asks(mutation, door)).toEqual(['employee-self', 'mutation', 'true'])
+      const body = mutation.slice(mutation.indexOf(`async ${door}(`)).split('\n  }')[0]
+      expect(body).toMatch(/requireMyEmployee\(context\)/)
+      expect(body).not.toMatch(/@Arg\('(employee|employeeId|user|userId)'/)
+    }
+    expect([...mutation.matchAll(/@Directive\('@transaction'\)\n  @Directive\('@privilege\(category: "employee-self", privilege: "mutation"/g)]).toHaveLength(2)
+  })
+
+  it('★ the tasks grant them: own-profile to write one\'s own, profiles-reading to read everyone\'s', () => {
+    const { ROLE_TASKS } = loadCompiled('role-tasks')
+    expect(ROLE_TASKS.find((task: any) => task.id === 'organization.own-profile').grants).toEqual([{ category: 'employee-self', axes: ['query', 'mutation'] }])
+    expect(ROLE_TASKS.find((task: any) => task.id === 'organization.profiles-reading').grants).toEqual([{ category: 'employee-profile', axes: ['query'] }])
+  })
+})

package/tests/employee-profile-document.test.ts

@@ -0,0 +1,219 @@
+import { Workbook } from 'exceljs'
+
+import {
+  careerLengthOf,
+  careerMonths,
+  heightOf,
+  rosterTaglineOf,
+  taglineOf,
+  dotted,
+  layoutHtml,
+  periodOf,
+  profileFileName,
+  profileFooterHtml,
+  profileHtml,
+  profilePreviewHtml,
+  profileSheetLayout,
+  profileWorkbook,
+  profileWordsOf,
+  lead,
+  rosterLayout,
+  sheetNamesOf,
+  type ProfileSheetWords
+} from '../server/service/employee-profile/employee-profile-document'
+
+/** The profiles a quotation attaches - one layout, painted as Excel and as HTML for PDF (ADR-0169 decision 5). */
+const COUNTS: Record<string, (...args: number[]) => string> = {
+  years: (years, months) => `${years}y${months}m`,
+  projectCount: n => `${n}p`,
+  certificateCount: n => `${n}c`,
+  peopleCount: n => `${n}people`
+}
+const WORDS = new Proxy({} as any, { get: (_target, key) => COUNTS[String(key)] ?? `<${String(key)}>` }) as ProfileSheetWords
+
+const TODAY = new Date('2026-10-28T00:00:00Z')
+
+const KIM = {
+  name: '김하늘',
+  departmentName: '개발팀',
+  jobPosition: '과장',
+  jobResponsibility: '팀장',
+  hiredOn: '2020-03-02',
+  profile: {
+    summary: 'MES 10년',
+    skills: ['TypeScript', 'PostgreSQL'],
+    educations: [{ school: '서울대', major: '컴퓨터공학', degree: '학사', startedOn: '2005-03', endedOn: '2009-02' }],
+    certificates: [{ name: '정보처리기사', issuer: '한국산업인력공단', acquiredOn: '2010-05-01' }],
+    careers: [{ company: 'A사', department: '연구소', position: '대리', startedOn: '2009-03', endedOn: '2019-12', duties: 'ERP' }],
+    projects: [{ name: '미라텍 MES', client: '미라텍', startedOn: '2024-01', role: 'PM', duties: '설계', technologies: 'Node' }]
+  }
+}
+
+const valuesOf = (line: { cells: { value: string }[] }) => line.cells.map(cell => cell.value)
+
+describe('one layout of a staffing profile', () => {
+  const cellsOf = (lines: ReturnType<typeof profileSheetLayout>, role: string) => lines.flatMap(line => line.cells.filter(cell => cell.role === role).map(cell => cell.value))
+
+  it('★ the name large with where the person stands, then the figures a buyer weighs', () => {
+    const lines = profileSheetLayout(KIM, WORDS, '(주)하티오랩', TODAY)
+    expect(valuesOf(lines[0])).toEqual(['(주)하티오랩', '<title>'])
+    expect(lines[1].cells).toEqual([{ col: 1, span: 6, value: '김하늘', role: 'name' }])
+    expect(valuesOf(lines[2])).toEqual(['개발팀  ·  과장 / 팀장  ·  <hiredOn> 2020.03.02'])
+    expect(lines[3].cells[0].role).toBe('rule')
+    expect(cellsOf(lines, 'statLabel')).toEqual(['<careerLength>', '<projectsDone>', '<certificatesHeld>'])
+    expect(cellsOf(lines, 'statValue')).toEqual([careerLengthOf(KIM, WORDS, TODAY), '1p', '1c'])
+  })
+
+  it('★ the expertise, then the projects first - careers, certificates and education after; no line to sign', () => {
+    const lines = profileSheetLayout(KIM, WORDS, '(주)하티오랩', TODAY)
+    expect(cellsOf(lines, 'section')).toEqual(['<expertise>', '<projects>', '<careers>', '<certificates>', '<educations>'])
+    expect(cellsOf(lines, 'summary')).toEqual(['MES 10년'])
+    expect(cellsOf(lines, 'skills')).toEqual(['TypeScript, PostgreSQL'])
+    const rowAfter = (section: string) => valuesOf(lines[lines.findIndex(line => line.cells[0]?.value === section && line.cells[0].role === 'section') + 3])
+    expect(rowAfter('<projects>')).toEqual(['2024.01 ~ <ongoing>', '미라텍 MES', '미라텍', 'PM', '설계', 'Node'])
+    expect(rowAfter('<careers>')).toEqual(['2009.03 ~ 2019.12', 'A사', '연구소', '대리', 'ERP'])
+    expect(rowAfter('<certificates>')).toEqual(['2010.05.01', '정보처리기사', '한국산업인력공단'])
+    expect(rowAfter('<educations>')).toEqual(['2005.03 ~ 2009.02', '서울대', '컴퓨터공학', '학사'])
+    expect(JSON.stringify(lines)).not.toMatch(/affirmation|signature/)
+  })
+
+  it('every other row of a table is shaded', () => {
+    const two = { ...KIM, profile: { ...KIM.profile, projects: [KIM.profile.projects[0], KIM.profile.projects[0], KIM.profile.projects[0]] } }
+    const lines = profileSheetLayout(two, WORDS, '', TODAY)
+    const rows = lines.filter(line => line.cells[0]?.role === 'value' && line.cells.length === 6)
+    expect(rows.map(line => !!line.zebra)).toEqual([false, true, false])
+  })
+
+  it('a person with nothing written: dashes for the figures, no summary box, every table says so', () => {
+    const lines = profileSheetLayout({ name: '박지민', profile: null }, WORDS, '', TODAY)
+    expect(cellsOf(lines, 'statValue')).toEqual(['—', '—', '—'])
+    expect(cellsOf(lines, 'summary')).toEqual([])
+    expect(cellsOf(lines, 'none')).toEqual(['<none>', '<none>', '<none>', '<none>'])
+    expect(taglineOf({ name: '박지민' }, WORDS)).toBe('')
+  })
+
+  it('★ the career counts the months worked once - earlier jobs and the time here, overlaps not twice', () => {
+    expect(careerMonths({ hiredOn: '2026-01-15' }, TODAY)).toBe(10)
+    expect(careerMonths({ hiredOn: '2025-10-01', profile: { careers: [{ startedOn: '2025-01', endedOn: '2025-12' }] } }, TODAY)).toBe(22)
+    expect(careerMonths({ profile: { careers: [{ startedOn: '2024-01' }] } }, TODAY)).toBe(34)
+    expect(careerMonths({ profile: { careers: [{ endedOn: '2020-01' }] } }, TODAY)).toBe(0)
+    expect(careerLengthOf(KIM, WORDS, TODAY)).toBe(`${Math.floor(careerMonths(KIM, TODAY) / 12)}y${careerMonths(KIM, TODAY) % 12}m`)
+    expect(careerLengthOf({}, WORDS, TODAY)).toBe('')
+  })
+
+  it('periods and days in the dotted form, an open end still going on', () => {
+    expect(dotted('2023-03')).toBe('2023.03')
+    expect(periodOf('2024-01', '', 'now')).toBe('2024.01 ~ now')
+    expect(periodOf('', '2024-01', 'now')).toBe('~ 2024.01')
+    expect(periodOf(undefined, undefined, 'now')).toBe('')
+  })
+
+  it('a roster: how many and their experience on average, then one line a person in the order picked', () => {
+    const lines = rosterLayout([KIM, { name: '박지민', hiredOn: '2025-10-01' }], WORDS, 'C', TODAY)
+    expect(valuesOf(lines[0])).toEqual(['C', '<writtenOn> 2026.10.28'])
+    expect(valuesOf(lines[1])).toEqual(['<rosterTitle>'])
+    const average = Math.round((careerMonths(KIM, TODAY) + 13) / 2)
+    expect(valuesOf(lines[2])).toEqual([`2people  ·  <averageCareer> ${Math.floor(average / 12)}y${average % 12}m`])
+    expect(valuesOf(lines[5])).toEqual(['<number>', '<name>', '<department>', '<jobPosition>', '<careerLength>', '<skills>'])
+    expect(lines.slice(6).map(line => valuesOf(line).slice(0, 2))).toEqual([['1', '김하늘'], ['2', '박지민']])
+    expect(rosterTaglineOf([], WORDS, TODAY)).toBe('0people')
+  })
+})
+
+describe('painted as Excel', () => {
+  it('★ a ruled line is as tall as its longest cell wraps - Excel does not grow it for written text', () => {
+    const one = heightOf({ cells: [{ col: 1, value: '2012.03 ~ 2019.02', role: 'value' }, { col: 2, span: 5, value: '짧음', role: 'value' }] })!
+    const wrapped = heightOf({ cells: [{ col: 5, value: '요구 분석, 설계, 일정·인력 관리와 고객 보고', role: 'value' }] })!
+    expect(one).toBe(22)
+    expect(wrapped).toBeGreaterThan(one)
+    expect(heightOf({ cells: [{ col: 1, span: 6, value: 'x', role: 'name' }] })).toBeUndefined()
+    expect(heightOf({ cells: [{ col: 1, value: 'a\nb\nc', role: 'value' }] })).toBe(52)
+    expect(heightOf({ cells: [{ col: 1, span: 6, value: '짧은 소개', role: 'summary' }] })).toBe(30)
+  })
+
+  async function readBack(people: any[]) {
+    const buffer = await profileWorkbook(people, WORDS, '(주)하티오랩', TODAY).xlsx.writeBuffer()
+    const book = new Workbook()
+    await book.xlsx.load(buffer as any)
+    return book
+  }
+
+  it('★ several people open with the roster, then a sheet a person in the order picked - read back from the file', async () => {
+    const book = await readBack([KIM, { name: '박지민' }])
+    expect(book.worksheets.map(sheet => sheet.name)).toEqual(['<rosterTitle>', '김하늘', '박지민'])
+    expect((await readBack([KIM])).worksheets.map(sheet => sheet.name)).toEqual(['김하늘'])
+  })
+
+  it('★ the title spans the page, labels and heads are shaded and ruled, values ruled and wrapped, A4 to one page wide', async () => {
+    const sheet = (await readBack([KIM])).getWorksheet('김하늘')!
+    expect(sheet.getCell('A2').value).toBe('김하늘')
+    expect(sheet.getCell('A2').font).toMatchObject({ bold: true, size: 22, color: { argb: 'FF1F3A5F' } })
+    expect(sheet.getCell('F2').isMerged).toBe(true)
+    expect(sheet.getCell('A4').border?.bottom?.style).toBe('thick')
+    const rows = sheet.getRows(1, sheet.rowCount)!
+    const head = rows.find(row => row.getCell(1).value === '<period>')!
+    expect((head.getCell(1).fill as any)?.fgColor?.argb).toBe('FF1F3A5F')
+    expect(head.getCell(1).font?.color?.argb).toBe('FFFFFFFF')
+    const value = sheet.getRow(head.number + 1).getCell(2)
+    expect(value.value).toBe('미라텍 MES')
+    expect(value.border?.right?.style).toBe('thin')
+    expect(value.alignment).toMatchObject({ wrapText: true, indent: 1 })
+    expect(sheet.headerFooter.oddFooter).toBe('&L&8(주)하티오랩  ·  <title>&R&8&P / &N')
+    expect(sheet.pageSetup).toMatchObject({ paperSize: 9, orientation: 'portrait', fitToWidth: 1, fitToHeight: 0 })
+    expect(sheet.views[0]).toMatchObject({ showGridLines: false })
+    expect(sheet.getColumn(1).width).toBe(18)
+  })
+
+  it('★ sheet names Excel takes: at most 31 characters, none of \\ / ? * [ ] :, no two alike, none the roster has', () => {
+    const names = sheetNamesOf(['홍길동', '홍길동', 'HONG', 'hong', 'a/b:c*d?[e]', '', null, 'x'.repeat(40), 'x'.repeat(40), '인력 현황'], ['인력 현황'])
+    expect(names.slice(0, 7)).toEqual(['홍길동', '홍길동 (2)', 'HONG', 'hong (2)', 'a b c d  e', '#6', '#7'])
+    expect(names[7]).toBe('x'.repeat(31))
+    expect(names[8]).toBe('x'.repeat(27) + ' (2)')
+    expect(names[9]).toBe('인력 현황 (2)')
+  })
+})
+
+describe('painted as HTML for the PDF', () => {
+  it('★ a page a person after the roster, the same cells, spans as colspan, text escaped', () => {
+    const html = profileHtml([KIM, { name: '<b>박</b>' }], WORDS, 'C', TODAY)
+    expect(html.match(/<section class="sheet">/g)).toHaveLength(3)
+    expect(html).toContain('<td class="name" colspan="6">김하늘</td>')
+    expect(html).toContain('<span class="tag">TypeScript</span><span class="tag">PostgreSQL</span>')
+    expect(html).toMatch(/<tr class="zebra"|<tr style/)
+    expect(html).toContain('&lt;b&gt;박&lt;/b&gt;')
+    expect(html).not.toContain('<b>박</b>')
+  })
+
+  it('a line keeps its line breaks, an empty line is a gap, a cell left of the first one is filled', () => {
+    expect(layoutHtml([{ cells: [{ col: 2, value: 'a\nb', role: 'value' }] }])).toContain('<td colspan="1"></td><td class="value">a<br>b</td><td colspan="4"></td>')
+    expect(layoutHtml([{ cells: [] }])).toContain('<tr class="gap">')
+  })
+
+  it('the foot of every PDF page: the employer and the page of how many, a brace in the name opening no template', () => {
+    const footer = profileFooterHtml('{{evil}} & Co', WORDS)
+    expect(footer).toContain('&#123;&#123;evil&#125;&#125; &amp; Co  ·  &lt;title&gt;')
+    expect(footer).toContain('<span class="pageNumber"></span> / <span class="totalPages"></span>')
+  })
+
+  it('★ the preview is the same pages as one document, shown as sheets of A4 on a screen', () => {
+    const page = profilePreviewHtml([KIM], WORDS, 'C', TODAY)
+    expect(page.startsWith('<!doctype html>')).toBe(true)
+    expect(page).toContain(profileHtml([KIM], WORDS, 'C', TODAY))
+    expect(page).toMatch(/@media screen \{[\s\S]*\.sheet \{[^}]*width: 210mm/)
+  })
+
+  it('the words head as a document heads - a capital first where the language has one', () => {
+    expect(lead('proyectos')).toBe('Proyectos')
+    expect(lead('프로젝트 이력')).toBe('프로젝트 이력')
+    expect(lead('')).toBe('')
+    const words = profileWordsOf(key => (key === 'text.employee-profile-doc-years' ? '{years} años' : 'habilidades'))
+    expect(words.skills).toBe('Habilidades')
+    expect(words.years(2, 0)).toBe('{years} años')
+  })
+
+  it('the file is named by the word and the day', () => {
+    expect(profileFileName('인력프로필', 'xlsx', new Date(2026, 9, 7))).toBe('인력프로필-20261007.xlsx')
+    expect(profileFileName('인력프로필', 'pdf', new Date(2026, 9, 7))).toBe('인력프로필-20261007.pdf')
+    expect(profileFileName('인력프로필', 'html', new Date(2026, 9, 7))).toBe('인력프로필-20261007.html')
+  })
+})

package/tests/employee-profile-entry.test.ts

@@ -0,0 +1,72 @@
+/*
+ * The person's own profile as the assistant's 입력안 (ADR-0169 decision 10): a résumé read into rows of sections, each
+ * section added to one's own profile by one call of addToMyEmployeeProfile, nothing kept taken away.
+ */
+import { clearEntryTargets, declareEntryTarget } from '../../ai-assistant/server/service/data-entry/entry-target'
+import { profileAdditionOf, profileEntryIssues, PROFILE_ENTRY_FIELDS } from '../server/ai-entry/employee-profile-entry'
+import { employeeProfileEntryTarget, ORGANIZATION_EMPLOYEE_PROFILE } from '../server/ai-entry/organization-entry-targets'
+import { addedProfileOf } from '../server/service/employee-profile/employee-profile-rules'
+
+import en from '../translations/en.json'
+import es from '../translations/es.json'
+import ko from '../translations/ko.json'
+
+const row = (values: Record<string, unknown>, index = 0) => ({ index, values, sources: [], issues: [] })
+
+describe("the assistant's 입력안 of one's own profile", () => {
+  afterEach(() => clearEntryTargets())
+
+  it('★ is accepted by the assistant as declared - one call of addToMyEmployeeProfile a section', () => {
+    const target = employeeProfileEntryTarget()
+    expect(() => declareEntryTarget(target as any)).not.toThrow()
+    expect(target.key).toBe(ORGANIZATION_EMPLOYEE_PROFILE)
+    expect(target.mutation).toMatch(/addToMyEmployeeProfile\(profile: \$profile\)/)
+    expect(target.group?.by).toBe('section')
+    expect(target.description).toMatch(/OWN/)
+  })
+
+  it('★ the rows of a section become what the door adds - only the section fields', () => {
+    expect(profileAdditionOf([row({ section: 'summary', text: ' MES 12년 ' })])).toEqual({ summary: 'MES 12년' })
+    expect(profileAdditionOf([row({ section: 'skill', text: 'TypeScript' }), row({ section: 'skill', text: 'PLC' }, 1)])).toEqual({ skills: ['TypeScript', 'PLC'] })
+    expect(profileAdditionOf([row({ section: 'project', name: '미라텍 MES', client: '미라텍', startedOn: '2024-01', role: 'PM', school: '섞임' })])).toEqual({
+      projects: [{ name: '미라텍 MES', client: '미라텍', startedOn: '2024-01', endedOn: '', role: 'PM', duties: '', technologies: '' }]
+    })
+    expect(profileAdditionOf([row({ section: 'education', school: '한양대', degree: '학사' })])).toEqual({
+      educations: [{ school: '한양대', major: '', degree: '학사', startedOn: '', endedOn: '' }]
+    })
+  })
+
+  it('a row without what its section needs is kept out, and so is a second summary', () => {
+    const issues = profileEntryIssues([
+      row({ section: 'project', client: '미라텍' }),
+      row({ section: 'certificate', name: 'PMP' }, 1),
+      row({ section: 'summary', text: 'a' }, 2),
+      row({ section: 'summary', text: 'b' }, 3)
+    ])
+    expect(issues[0]).toEqual([{ field: 'name', code: 'required', blocking: true }])
+    expect(issues[1]).toEqual([])
+    expect(issues[2]).toEqual([])
+    expect(issues[3].map(issue => issue.code)).toEqual(['one-summary'])
+  })
+
+  it('★ adding takes nothing away: a summary given replaces, skills and rows are added unless already there', () => {
+    const held = { summary: '옛 요약', skills: ['TypeScript'], projects: [{ name: 'A', client: 'X' }], educations: [], certificates: [], careers: [] }
+    const added = addedProfileOf(held, { summary: '새 요약', skills: ['typescript', 'PLC'], projects: [{ name: ' a ', client: 'x' }, { name: 'B' }] })
+    expect(added).toEqual({ summary: '새 요약', skills: ['TypeScript', 'PLC'], educations: [], certificates: [], careers: [], projects: [{ name: 'A', client: 'X' }, { name: 'B' }] })
+    expect(addedProfileOf(held, { skills: ['Go'] }).summary).toBe('옛 요약')
+    expect(addedProfileOf(null, { certificates: [{ name: 'PMP' }] }).certificates).toEqual([{ name: 'PMP' }])
+  })
+
+  it('every word the card shows is in the languages the application runs', () => {
+    const keys = [
+      employeeProfileEntryTarget().labelKey,
+      ...PROFILE_ENTRY_FIELDS.map(field => field.labelKey!),
+      ...PROFILE_ENTRY_FIELDS.find(field => field.name === 'section')!.values!.map(value => `text.organization-entry-profile-section-${value}`),
+      'text.organization-entry-profile-one-summary'
+    ]
+    for (const [language, words] of Object.entries({ ko, en, es } as Record<string, Record<string, string>>)) {
+      const missing = keys.filter(key => !(key in words) && !['label.department'].includes(key))
+      expect([language, missing]).toEqual([language, []])
+    }
+  })
+})