@things-factory/inquiry 0.0.0-stage → 10.1.251

package/server/service/inquiry/inquiry-service.ts

@@ -0,0 +1,143 @@
+/*
+ * What the doors of inquiries do with the database (ADR-0184 decisions 5-7): who is a handler, who reads one, the
+ * handlers' turn as a worklist to-do, and telling people of it through notification.
+ */
+import { EntityManager, In } from 'typeorm'
+
+import { checkPermission, Role, User, UserStatus } from '@things-factory/auth-base'
+import { logger } from '@things-factory/env'
+import { translatorFor } from '@things-factory/i18n-base/translator'
+import { noticeLinkOf, sendNoticeWhenCommitted, type Notice } from '@things-factory/notification'
+import { Domain, getRepository } from '@things-factory/shell'
+import { abort, Activity, ActivityThread, issue } from '@things-factory/worklist'
+
+import { INQUIRY_HANDLING } from '../../inquiry-activity'
+import { Inquiry } from './inquiry'
+import { mayRead, noticeWordsOf, viewAddressOf, type NoticeKind, type Say, type Viewer } from './inquiry-rules'
+
+/** The attachments of an inquiry hang on it under this `refType`, a reply's under the next (attachment-base). */
+export const INQUIRY_REF_TYPE = 'Inquiry'
+export const INQUIRY_REPLY_REF_TYPE = 'InquiryReply'
+
+/** Whether the request handles inquiries - the one privilege of the module (`inquiry.answering`). */
+export async function isHandler(context: any): Promise<boolean> {
+  const state = context?.state ?? {}
+  const { domain, user, unsafeIP, prohibitedPrivileges } = state
+  if (!domain || !user) return false
+  /* Asked once per request - a list asks it for each row. */
+  state.__inquiryHandler ??= checkPermission({ category: 'inquiry', privilege: 'mutation', owner: true } as any, user, domain, unsafeIP, prohibitedPrivileges).then(Boolean)
+  return await state.__inquiryHandler
+}
+
+export async function viewerOf(context: any): Promise<Viewer> {
+  return { userId: context.state.user.id, handler: await isHandler(context) }
+}
+
+/** The inquiry as the request may read it, or nothing - one answer for "none" and "not yours". */
+export async function visibleInquiry(id: string, context: any, tx?: EntityManager): Promise<{ inquiry: Inquiry; viewer: Viewer } | undefined> {
+  const { domain, user } = context?.state ?? {}
+  if (!id || !domain || !user || !/^[0-9a-f-]{36}$/i.test(id)) return undefined
+  const inquiry = await getRepository(Inquiry, tx).findOne({ where: { id, domain: { id: domain.id } } as any })
+  if (!inquiry) return undefined
+  const viewer = await viewerOf(context)
+  return mayRead(inquiry, viewer) ? { inquiry, viewer } : undefined
+}
+
+/** The roles of the domain that give `inquiry:mutation` - the handlers' pool. */
+export async function handlerRoleIds(domain: Domain, tx?: EntityManager): Promise<string[]> {
+  const roles = await getRepository(Role, tx)
+    .createQueryBuilder('R')
+    .innerJoin('R.privileges', 'P')
+    .where('R.domain = :domain', { domain: domain.id })
+    .andWhere('P.category = :category', { category: 'inquiry' })
+    /* A privilege row's axis is its name. */
+    .andWhere('P.name = :axis', { axis: 'mutation' })
+    .getMany()
+  return roles.map(one => one.id)
+}
+
+/** The handlers to tell - those in a handler role, and the domain's owner, who handles as owners do. */
+export async function handlerUserIds(domain: Domain, tx?: EntityManager): Promise<string[]> {
+  const roleIds = await handlerRoleIds(domain, tx)
+  const roles = roleIds.length ? await getRepository(Role, tx).find({ where: { id: In(roleIds) } as any, relations: ['users'] }) : []
+  const ids = new Set<string>(roles.flatMap(one => (one.users ?? []).map(user => user.id)))
+  if (domain.owner) ids.add(domain.owner)
+  return [...ids]
+}
+
+/*
+ * ---------------------------------------------------------------- the handlers' turn, as worklist holds it (decision 7)
+ */
+
+/**
+ * Opens the handlers' to-do on it, unless one is open: one case, pooled on the handler roles - whoever of them picks it.
+ * With the activity not installed in the domain, or no handler role, there is no to-do: the notice and the badge still
+ * reach the handlers.
+ */
+export async function openTodo(inquiry: Inquiry, context: any): Promise<void> {
+  const { domain, tx } = context.state
+  if (inquiry.todoInstanceId) return
+  const activity = await tx.getRepository(Activity).findOne({ where: { domain: { id: domain.id }, name: INQUIRY_HANDLING } as any })
+  if (!activity) {
+    logger.warn(`[inquiry] ${domain.subdomain}: the activity "${INQUIRY_HANDLING}" is not installed - no to-do for inquiry ${inquiry.id}`)
+    return
+  }
+  const pool = await handlerRoleIds(domain, tx)
+  if (!pool.length) {
+    logger.warn(`[inquiry] ${domain.subdomain}: no role gives inquiry handling - no to-do for inquiry ${inquiry.id}`)
+    return
+  }
+  const name = inquiry.title.slice(0, 200)
+  const instance = await issue({ name, description: name, activityId: activity.id, input: { inquiryId: inquiry.id }, assignees: [], assigneeRoles: pool, threadsMin: 1 } as any, context)
+  await tx.getRepository(Inquiry).update(inquiry.id, { todoInstanceId: instance.id })
+  inquiry.todoInstanceId = instance.id
+}
+
+/** Closes the handlers' to-do when it is no longer their turn - left alone when it is closed already. */
+export async function closeTodo(inquiry: Inquiry, context: any, reason: string): Promise<void> {
+  const { tx } = context.state
+  if (!inquiry.todoInstanceId) return
+  const open = await tx.getRepository(ActivityThread).count({ where: { activityInstance: { id: inquiry.todoInstanceId }, state: In(['assigned', 'started', 'unassigned']) } as any })
+  if (open) await abort({ id: inquiry.todoInstanceId, reason } as any, context)
+  await tx.getRepository(Inquiry).update(inquiry.id, { todoInstanceId: null } as any)
+  inquiry.todoInstanceId = null as any
+}
+
+/*
+ * ---------------------------------------------------------------- telling people (decision 7)
+ */
+
+/** The sentences in `lng` from this module's translations, the English one where `lng` has none. */
+const sayIn =
+  (lng: string): Say =>
+  (key, english, params = {}) =>
+    translatorFor(lng)(key, { ...params, defaultValue: english.replace(/\{(\w+)\}/g, (_, name) => String(params[name] ?? '')) })
+
+/** The people to tell, as notification takes them - only those who can sign in, each with their mail and language. */
+async function receiversOf(userIds: string[], tx?: EntityManager) {
+  if (!userIds.length) return []
+  const people = await getRepository(User, tx).find({ where: { id: In(userIds) } as any })
+  return people.filter(one => one.status === UserStatus.ACTIVATED).map(one => ({ id: one.id, email: one.email, locale: (one as any).locale }))
+}
+
+/**
+ * Tells `userIds` - never the request's own person - once the request's transaction has committed. A notice that does
+ * not arrive undoes nothing: the list and the badge still reach them.
+ */
+export async function tellWhenCommitted(context: any, one: Inquiry, kind: NoticeKind, userIds: string[], said: { body?: string | null; status?: string } = {}): Promise<void> {
+  const receivers = await receiversOf(
+    userIds.filter(id => id !== context.state.user?.id),
+    context.state.tx
+  )
+  if (!receivers.length) return
+  const notice: Notice = {
+    type: 'inquiry',
+    level: 'info',
+    receivers,
+    words: lng => noticeWordsOf(one, kind, said, sayIn(lng)),
+    address: viewAddressOf(one.id),
+    link: noticeLinkOf(context, viewAddressOf(one.id)),
+    label: `inquiry ${kind} ${one.id}`
+  } as Notice
+  sendNoticeWhenCommitted(context, notice)
+}

package/server/service/inquiry/inquiry-types.ts

@@ -0,0 +1,45 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { Inquiry } from './inquiry'
+
+@InputType({ description: 'What an inquiry asks, and who reads it.' })
+export class InquiryInput {
+  @Field({ description: 'QUESTION, BUG or PROPOSAL.' })
+  kind: string
+
+  @Field({ description: 'The title.' })
+  title: string
+
+  @Field({ nullable: true, description: 'The body, plain text.' })
+  body?: string
+
+  @Field({ nullable: true, description: 'DOMAIN (everyone of the domain reads it, the default) or PRIVATE (its writer and the handlers).' })
+  visibility?: string
+
+  @Field({ nullable: true, description: 'The address of the screen it is written from - the browser sends it.' })
+  pageUrl?: string
+}
+
+@ObjectType({ description: 'A page of inquiries.' })
+export class InquiryList {
+  @Field(type => [Inquiry], { description: 'The inquiries of the page.' })
+  items: Inquiry[]
+
+  @Field(type => Int, { description: 'How many there are in all.' })
+  total: number
+}
+
+@ObjectType({ description: "What the menu counts for the request's person." })
+export class InquirySummary {
+  @Field(type => Int, { description: 'Their own inquiries with a handler\'s word they have not seen.' })
+  newAnswers: number
+
+  @Field(type => Int, { description: 'For a handler, the inquiries waiting on the handlers - received or in progress; 0 otherwise.' })
+  unhandled: number
+
+  @Field({ description: 'Whether the person handles inquiries.' })
+  handler: boolean
+
+  @Field(type => Int, { description: 'The count the menu shows - new answers, and for a handler those waiting too.' })
+  badge: number
+}

package/server/service/inquiry/inquiry.ts

@@ -0,0 +1,180 @@
+/*
+ * The tables of inquiries (ADR-0184 decisions 1-4): one thread - a question, a bug report or a feature proposal - and
+ * its replies. What was on the screen when it was written, and which application, are kept on it.
+ */
+import { Column, CreateDateColumn, DeleteDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId, UpdateDateColumn } from 'typeorm'
+import { Field, ID, Int, ObjectType } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+@Entity()
+@Index('ix_inquiry_0', (one: Inquiry) => [one.domain, one.status])
+@Index('ix_inquiry_1', (one: Inquiry) => [one.domain, one.creator])
+@ObjectType({ description: "An inquiry of a domain - a question, a bug report or a feature proposal, answered by the domain's handlers." })
+export class Inquiry {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { description: 'Inquiry id.' })
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true, description: 'The domain the inquiry is in.' })
+  domain?: Domain
+
+  @RelationId((one: Inquiry) => one.domain)
+  domainId?: string
+
+  @Column()
+  @Field({ description: 'QUESTION, BUG or PROPOSAL.' })
+  kind: string
+
+  @Column()
+  @Field({ description: 'The title.' })
+  title: string
+
+  @Column({ type: 'text', nullable: true })
+  @Field({ nullable: true, description: 'The body, plain text.' })
+  body?: string
+
+  @Column({ default: 'RECEIVED' })
+  @Field({ description: 'RECEIVED, IN_PROGRESS, ANSWERED, PLANNED, DECLINED or CLOSED - PLANNED and DECLINED for a proposal only.' })
+  status: string
+
+  @Column({ default: 'DOMAIN' })
+  @Field({ description: 'DOMAIN - everyone of the domain reads it; PRIVATE - its writer and the handlers only.' })
+  visibility: string
+
+  @Column({ length: 2000, nullable: true })
+  @Field({ nullable: true, description: 'The address of the screen it was written from.' })
+  pageUrl?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'The application it was written in.' })
+  appName?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'The version of that application.' })
+  appVersion?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'The handler who took it.' })
+  assignee?: User
+
+  @RelationId((one: Inquiry) => one.assignee)
+  assigneeId?: string
+
+  @Column('int', { default: 0 })
+  @Field(type => Int, { description: 'How many replies it has.' })
+  replyCount: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'When a handler last replied or moved it - the writer sees it as new until they open it.' })
+  handlerActivityAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'When its writer last opened it.' })
+  askerSeenAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'When it was last answered.' })
+  answeredAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'When it was closed.' })
+  closedAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: "The worklist case that holds the handlers' turn on it, while there is one." })
+  todoInstanceId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'Who wrote it.' })
+  creator?: User
+
+  @RelationId((one: Inquiry) => one.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'Who changed it last.' })
+  updater?: User
+
+  @RelationId((one: Inquiry) => one.updater)
+  updaterId?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true, description: 'When it was written.' })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true, description: 'Last update timestamp.' })
+  updatedAt?: Date
+
+  @DeleteDateColumn()
+  @Field({ nullable: true, description: 'Soft delete timestamp.' })
+  deletedAt?: Date
+}
+
+@Entity()
+@Index('ix_inquiry_reply_0', (one: InquiryReply) => [one.inquiry, one.createdAt])
+@ObjectType({ description: 'One reply on an inquiry - the writer\'s or a handler\'s words, or a move of where it stands.' })
+export class InquiryReply {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { description: 'Reply id.' })
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true, description: 'The domain.' })
+  domain?: Domain
+
+  @RelationId((one: InquiryReply) => one.domain)
+  domainId?: string
+
+  @ManyToOne(type => Inquiry, { onDelete: 'CASCADE' })
+  inquiry?: Inquiry
+
+  @RelationId((one: InquiryReply) => one.inquiry)
+  @Field({ description: 'The inquiry.' })
+  inquiryId?: string
+
+  @Column({ type: 'text', nullable: true })
+  @Field({ nullable: true, description: 'The words, plain text.' })
+  body?: string
+
+  @Column({ default: false })
+  @Field({ description: 'From a handler - not the writer.' })
+  byHandler: boolean
+
+  @Column({ default: false })
+  @Field({ description: 'Sent as the answer.' })
+  answer: boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Where it moved the inquiry, when it moved it.' })
+  status?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'Who wrote it.' })
+  creator?: User
+
+  @RelationId((one: InquiryReply) => one.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'Who changed it last.' })
+  updater?: User
+
+  @RelationId((one: InquiryReply) => one.updater)
+  updaterId?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true, description: 'When it was written.' })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true, description: 'Last update timestamp.' })
+  updatedAt?: Date
+
+  @DeleteDateColumn()
+  @Field({ nullable: true, description: 'Soft delete timestamp.' })
+  deletedAt?: Date
+}

package/server/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig-base.json",
+  "compilerOptions": {
+    "strict": false,
+    "module": "commonjs",
+    "outDir": "../dist-server",
+    "baseUrl": "./"
+  },
+  "include": ["./**/*"],
+  "exclude": ["**/*.spec.ts", "**/*.test.ts"]
+}

package/test/inquiry-persistence.test.ts

@@ -0,0 +1,218 @@
+/*
+ * An inquiry on sqlite with the real entities (ADR-0184 decisions 2-8): what writing one keeps and whom it tells, who
+ * reads it, the replies back and forth with where it stands after each, the handlers' to-do opened and closed with
+ * their turn, and the badge's counts.
+ *
+ * Reads the built server (`dist-server`) - type-graphql needs tsc's decorator metadata. worklist's issue and abort are
+ * recorded, not run: the cases themselves are worklist's tests.
+ */
+import 'reflect-metadata'
+
+const { existsSync } = require('fs')
+const { join } = require('path')
+const { DataSource } = require('typeorm')
+
+const told: { label: string; receivers: string[]; subject: string }[] = []
+jest.mock('@things-factory/notification', () => ({
+  sendNoticeWhenCommitted: (_context: any, notice: any) =>
+    told.push({ label: notice.label, receivers: notice.receivers.map((one: any) => one.id), subject: notice.words('en').subject }),
+  noticeLinkOf: () => undefined
+}))
+
+const cases: { op: string; id: string; pool?: string[]; reason?: string }[] = []
+jest.mock('@things-factory/worklist', () => {
+  const actual = jest.requireActual('@things-factory/worklist')
+  return {
+    ...actual,
+    /* A pooled case has one unassigned thread, as worklist's issue leaves it - closing it is what abort is asked for. */
+    issue: async (one: any, context: any) => {
+      const id = `00000000-0000-4000-8000-${String(cases.length + 1).padStart(12, '0')}`
+      cases.push({ op: 'issue', id, pool: one.assigneeRoles })
+      await context.state.tx.getRepository(actual.ActivityInstance).save({ id, domain: context.state.domain, name: one.name, state: 'issued' })
+      await context.state.tx.getRepository(actual.ActivityThread).save({ domain: context.state.domain, activityInstance: { id }, state: 'unassigned' })
+      return { id }
+    },
+    abort: async ({ id, reason }: any, context: any) => {
+      cases.push({ op: 'abort', id, reason })
+      await context.state.tx.getRepository(actual.ActivityThread).update({ activityInstance: { id } }, { state: 'aborted' })
+    }
+  }
+})
+
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+const attachmentBase = require('@things-factory/attachment-base')
+const worklist = require('@things-factory/worklist')
+
+function loadCompiled(modulePath: string): any {
+  const resolved = join(__dirname, '..', 'dist-server', `${modulePath}.js`)
+  if (!existsSync(resolved)) throw new Error(`inquiry build output is missing: ${resolved}\nBuild it first: npm run build:server`)
+  return require(resolved)
+}
+
+const { InquiryResolver } = loadCompiled('service/inquiry/inquiry-resolver')
+const { Inquiry, InquiryReply } = loadCompiled('service/inquiry/inquiry')
+const { INQUIRY_HANDLING } = loadCompiled('inquiry-activity')
+
+let dataSource: any
+let domain: any
+let people: Record<string, any>
+let desk: any
+const resolver = new InquiryResolver()
+
+beforeAll(async () => {
+  dataSource = new DataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, ...attachmentBase.entities, ...worklist.entities, Inquiry, InquiryReply],
+    logging: false
+  })
+  await dataSource.initialize()
+  shell.addDataSource('default', dataSource)
+  shell.addDataSource('tx', dataSource)
+})
+
+afterAll(async () => {
+  if (!dataSource) return
+  shell.removeDataSource('default')
+  shell.removeDataSource('tx')
+  await dataSource.destroy()
+})
+
+/* writer · neighbour - members; desk - holds the role that gives inquiry:mutation; owner - owns the domain. */
+beforeEach(async () => {
+  told.length = 0
+  cases.length = 0
+  await dataSource.synchronize(true)
+  const user = (name: string) => dataSource.getRepository(authBase.User).save({ name, email: `${name}@inquiry.test`, status: 'activated' })
+  people = { writer: await user('writer'), neighbour: await user('neighbour'), desk: await user('desk'), owner: await user('owner') }
+  domain = await dataSource.getRepository(shell.Domain).save({ name: 'ask', subdomain: 'ask', owner: people.owner.id })
+  const privilege = await dataSource.getRepository(authBase.Privilege).save({ name: 'mutation', category: 'inquiry' })
+  desk = await dataSource.getRepository(authBase.Role).save({ name: 'DESK', domain, privileges: [privilege], users: [people.desk] })
+  await dataSource.getRepository(authBase.Role).save({ name: 'OTHER', domain, users: [people.neighbour] })
+  await dataSource.getRepository(worklist.Activity).save({ domain, name: INQUIRY_HANDLING, activityType: 'user', startingType: 'issue' })
+})
+
+const contextOf = (who: string, handler = false) => ({ state: { domain, user: people[who], tx: dataSource.manager, __inquiryHandler: Promise.resolve(handler) } })
+const as = (who: string) => contextOf(who, who === 'desk' || who === 'owner')
+const ask = (input: any = {}) =>
+  resolver.createInquiry({ kind: 'QUESTION', title: '휴가는 어디서 신청하나요?', body: '메뉴에서 못 찾겠습니다', pageUrl: 'https://office.test/ask/leave-list', ...input }, undefined, as('writer'))
+const fresh = (id: string) => dataSource.getRepository(Inquiry).findOneBy({ id })
+const list = async (who: string, scope?: string) => (await resolver.inquiries({ filters: [], pagination: { page: 1, limit: 50 } }, scope, as(who))).items.map((one: any) => one.title).sort()
+
+describe('writing one', () => {
+  it('★ keeps the screen and the writer, tells the handlers and opens their to-do on the handler roles', async () => {
+    const one = await ask()
+    expect(one).toMatchObject({ status: 'RECEIVED', visibility: 'DOMAIN', pageUrl: 'https://office.test/ask/leave-list', creatorId: people.writer.id, domainId: domain.id })
+    expect(told).toEqual([{ label: `inquiry received ${one.id}`, receivers: [people.desk.id, people.owner.id].sort(), subject: 'New QUESTION: 휴가는 어디서 신청하나요?' }].map(t => ({ ...t, receivers: expect.arrayContaining(t.receivers) })))
+    expect(cases).toEqual([{ op: 'issue', id: expect.any(String), pool: [desk.id] }])
+    expect((await fresh(one.id)).todoInstanceId).toBe(cases[0].id)
+  })
+
+  it('opens no to-do where the domain has not installed it - the notice still goes', async () => {
+    await dataSource.getRepository(worklist.Activity).delete({ name: INQUIRY_HANDLING })
+    await ask()
+    expect(cases).toEqual([])
+    expect(told).toHaveLength(1)
+  })
+})
+
+describe('who reads it', () => {
+  it('★ an open one everyone of the domain, a private one its writer and the handlers', async () => {
+    await ask({ title: 'open' })
+    await ask({ title: 'private', visibility: 'PRIVATE' })
+    expect(await list('neighbour')).toEqual(['open'])
+    expect(await list('writer')).toEqual(['open', 'private'])
+    expect(await list('desk')).toEqual(['open', 'private'])
+    expect(await list('neighbour', 'mine')).toEqual([])
+  })
+
+  it('the handlers see those waiting on them', async () => {
+    const one = await ask({ title: 'answered' })
+    await ask({ title: 'waiting' })
+    await resolver.replyInquiry(one.id, '근태 › 휴가에 있습니다', true, undefined, as('desk'))
+    expect(await list('desk', 'handlers-turn')).toEqual(['waiting'])
+  })
+})
+
+describe('the replies', () => {
+  it('★ a handler answers: answered, the writer told and shown it as new, the to-do closed', async () => {
+    const one = await ask()
+    told.length = 0
+    const answered = await resolver.replyInquiry(one.id, '근태 › 휴가에 있습니다', true, undefined, as('desk'))
+    expect(answered).toMatchObject({ status: 'ANSWERED', assigneeId: people.desk.id, replyCount: 1, todoInstanceId: null })
+    expect(cases.map(one => one.op)).toEqual(['issue', 'abort'])
+    expect(told).toEqual([{ label: `inquiry answered ${one.id}`, receivers: [people.writer.id], subject: 'Answered: 휴가는 어디서 신청하나요?' }])
+    expect(await resolver.inquirySummary(as('writer'))).toMatchObject({ newAnswers: 1, badge: 1, handler: false })
+    await resolver.readInquiry(one.id, as('writer'))
+    expect(await resolver.inquirySummary(as('writer'))).toMatchObject({ newAnswers: 0, badge: 0 })
+  })
+
+  it('★ the writer replying to an answer hands it back: in progress, a new to-do, the handler who answered told', async () => {
+    const one = await ask()
+    await resolver.replyInquiry(one.id, '근태 › 휴가에 있습니다', true, undefined, as('desk'))
+    told.length = 0
+    const back = await resolver.replyInquiry(one.id, '거기 없는데요', false, undefined, as('writer'))
+    expect(back.status).toBe('IN_PROGRESS')
+    expect(cases.map(one => one.op)).toEqual(['issue', 'abort', 'issue'])
+    expect(told).toEqual([{ label: `inquiry asker-replied ${one.id}`, receivers: [people.desk.id], subject: 'The writer replied: 휴가는 어디서 신청하나요?' }])
+    const replies = await dataSource.getRepository(InquiryReply).find({ where: { inquiry: { id: one.id } }, order: { createdAt: 'ASC' } })
+    expect(replies.map((one: any) => [one.byHandler, one.answer, one.status])).toEqual([
+      [true, true, 'ANSWERED'],
+      [false, false, 'IN_PROGRESS']
+    ])
+  })
+
+  it('★ someone else of the domain reads but does not reply; the writer may not send the answer', async () => {
+    const one = await ask()
+    await expect(resolver.replyInquiry(one.id, '저도 궁금해요', false, undefined, as('neighbour'))).rejects.toMatchObject({ extensions: { code: 'inquiry.not-a-party' } })
+    await expect(resolver.replyInquiry(one.id, '스스로 답', true, undefined, as('writer'))).rejects.toMatchObject({ extensions: { code: 'inquiry.handlers-only' } })
+    await expect(resolver.replyInquiry(one.id, '   ', false, undefined, as('writer'))).rejects.toMatchObject({ extensions: { code: 'inquiry.empty-reply' } })
+  })
+
+  it('a private one is not there for someone else', async () => {
+    const one = await ask({ visibility: 'PRIVATE' })
+    expect(await resolver.inquiry(one.id, as('neighbour'))).toBeUndefined()
+    await expect(resolver.replyInquiry(one.id, 'x', false, undefined, as('neighbour'))).rejects.toMatchObject({ extensions: { code: 'inquiry.unknown-inquiry' } })
+  })
+})
+
+describe('the moves', () => {
+  it('★ a handler plans a proposal: the writer told, the reason on the thread, the to-do closed', async () => {
+    const one = await ask({ kind: 'PROPOSAL', title: '엑셀 내보내기' })
+    told.length = 0
+    const planned = await resolver.moveInquiry(one.id, 'PLANNED', '다음 달 반영', as('desk'))
+    expect(planned).toMatchObject({ status: 'PLANNED', todoInstanceId: null })
+    expect(told).toEqual([{ label: `inquiry moved ${one.id}`, receivers: [people.writer.id], subject: 'PLANNED: 엑셀 내보내기' }])
+    expect(await dataSource.getRepository(InquiryReply).findOneBy({ inquiry: { id: one.id } })).toMatchObject({ status: 'PLANNED', body: '다음 달 반영', byHandler: true })
+  })
+
+  it('★ the writer closes their own; nothing replies on it after', async () => {
+    const one = await ask()
+    const closed = await resolver.moveInquiry(one.id, 'CLOSED', undefined, as('writer'))
+    expect(closed.status).toBe('CLOSED')
+    expect(closed.closedAt).toBeTruthy()
+    expect(cases.map(one => one.op)).toEqual(['issue', 'abort'])
+    await expect(resolver.replyInquiry(one.id, '하나 더', false, undefined, as('desk'))).rejects.toMatchObject({ extensions: { code: 'inquiry.closed' } })
+    await expect(resolver.moveInquiry(one.id, 'ANSWERED', undefined, as('writer'))).rejects.toMatchObject({ extensions: { code: 'inquiry.closed' } })
+  })
+
+  it('only a handler moves the rest', async () => {
+    const one = await ask()
+    await expect(resolver.moveInquiry(one.id, 'IN_PROGRESS', undefined, as('writer'))).rejects.toMatchObject({ extensions: { code: 'inquiry.handlers-only' } })
+    await expect(resolver.moveInquiry(one.id, 'PLANNED', undefined, as('desk'))).rejects.toMatchObject({ extensions: { code: 'inquiry.not-a-proposal' } })
+  })
+})
+
+describe('the badge of a handler', () => {
+  it('★ counts those waiting on the handlers', async () => {
+    await ask()
+    const two = await ask()
+    await resolver.replyInquiry(two.id, '답', true, undefined, as('desk'))
+    expect(await resolver.inquirySummary(as('desk'))).toMatchObject({ unhandled: 1, handler: true, badge: 1 })
+    expect(await resolver.inquirySummary(as('neighbour'))).toMatchObject({ unhandled: 0, badge: 0 })
+  })
+})