@things-factory/inquiry 10.1.253 → 10.1.254

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

@@ -1,45 +0,0 @@
-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

@@ -1,180 +0,0 @@
-/*
- * 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

@@ -1,11 +0,0 @@
-{
-  "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

@@ -1,218 +0,0 @@
-/*
- * 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 })
-  })
-})

package/test/inquiry-rules.test.ts

@@ -1,121 +0,0 @@
-/*
- * The rules of an inquiry (ADR-0184 decisions 1-8), without a database.
- */
-import {
-  answerRefusal,
-  badgeOf,
-  handlersTurn,
-  inputRefusal,
-  mayRead,
-  moveRefusal,
-  newForAsker,
-  noticeWordsOf,
-  replyRefusal,
-  replyRefusalFor,
-  sideOf,
-  statusAfterReply
-} from '../server/service/inquiry/inquiry-rules'
-
-const writer = { userId: 'w', handler: false }
-const handler = { userId: 'h', handler: true }
-const neighbour = { userId: 'n', handler: false }
-const one = (status = 'RECEIVED', extra: any = {}) => ({ kind: 'QUESTION', status, visibility: 'DOMAIN', creatorId: 'w', ...extra })
-
-describe('what may be written', () => {
-  it('★ a kind of the three and a title', () => {
-    expect(inputRefusal({ kind: 'QUESTION', title: '휴가 신청은 어디서?' })).toBeUndefined()
-    expect(inputRefusal({ kind: 'COMPLAINT', title: 'x' })).toBe('unknown-kind')
-    expect(inputRefusal({ kind: 'BUG', title: '   ' })).toBe('no-title')
-    expect(inputRefusal({ kind: 'BUG', title: 'x'.repeat(201) })).toBe('title-too-long')
-    expect(inputRefusal({ kind: 'BUG', title: 'x', visibility: 'SECRET' })).toBe('unknown-visibility')
-    expect(inputRefusal({ kind: 'BUG', title: 'x', pageUrl: 'h'.repeat(2001) })).toBe('page-url-too-long')
-    expect(inputRefusal({ kind: 'BUG', title: 'x', body: 'b'.repeat(20001) })).toBe('body-too-long')
-  })
-
-  it('a reply says something - words or a file', () => {
-    expect(replyRefusal('  ', 0)).toBe('empty-reply')
-    expect(replyRefusal('', 1)).toBeUndefined()
-    expect(replyRefusal('네', 0)).toBeUndefined()
-  })
-})
-
-describe('who reads and replies', () => {
-  it('★ an open one is read by everyone of the domain; a private one by its writer and the handlers', () => {
-    expect(mayRead(one(), neighbour)).toBe(true)
-    const hidden = one('RECEIVED', { visibility: 'PRIVATE' })
-    expect(mayRead(hidden, neighbour)).toBe(false)
-    expect(mayRead(hidden, writer)).toBe(true)
-    expect(mayRead(hidden, handler)).toBe(true)
-  })
-
-  it('★ replies go between the writer and the handlers, until it is closed', () => {
-    expect(replyRefusalFor(one(), writer)).toBeUndefined()
-    expect(replyRefusalFor(one(), handler)).toBeUndefined()
-    expect(replyRefusalFor(one(), neighbour)).toBe('not-a-party')
-    expect(replyRefusalFor(one('CLOSED'), writer)).toBe('closed')
-  })
-
-  it("the writer's own reply is the asker's, even when the writer handles", () => {
-    expect(sideOf(one(), { userId: 'w', handler: true })).toBe('asker')
-    expect(sideOf(one(), handler)).toBe('handler')
-    expect(answerRefusal('asker', true)).toBe('handlers-only')
-    expect(answerRefusal('handler', true)).toBeUndefined()
-  })
-})
-
-describe('where it stands', () => {
-  it('★ a handler answers it, or puts a received one in progress', () => {
-    expect(statusAfterReply(one('RECEIVED'), 'handler', true)).toBe('ANSWERED')
-    expect(statusAfterReply(one('RECEIVED'), 'handler', false)).toBe('IN_PROGRESS')
-    expect(statusAfterReply(one('ANSWERED'), 'handler', false)).toBe('ANSWERED')
-  })
-
-  it('★ the writer replying to an answer or a decision hands it back to the handlers', () => {
-    for (const status of ['ANSWERED', 'PLANNED', 'DECLINED']) expect(statusAfterReply(one(status), 'asker', false)).toBe('IN_PROGRESS')
-    expect(statusAfterReply(one('RECEIVED'), 'asker', false)).toBe('RECEIVED')
-  })
-
-  it('★ the writer closes their own; the rest is the handlers\'', () => {
-    expect(moveRefusal(one('ANSWERED'), 'CLOSED', writer)).toBeUndefined()
-    expect(moveRefusal(one('ANSWERED'), 'CLOSED', neighbour)).toBe('handlers-only')
-    expect(moveRefusal(one('RECEIVED'), 'ANSWERED', writer)).toBe('handlers-only')
-    expect(moveRefusal(one('RECEIVED'), 'IN_PROGRESS', handler)).toBeUndefined()
-    expect(moveRefusal(one('CLOSED'), 'IN_PROGRESS', handler)).toBe('closed')
-    expect(moveRefusal(one('IN_PROGRESS'), 'RECEIVED', handler)).toBe('not-a-move')
-    expect(moveRefusal(one('IN_PROGRESS'), 'IN_PROGRESS', handler)).toBe('same-status')
-    expect(moveRefusal(one('IN_PROGRESS'), 'DONE', handler)).toBe('unknown-status')
-  })
-
-  it('★ planned and declined are a proposal\'s', () => {
-    expect(moveRefusal(one('IN_PROGRESS'), 'PLANNED', handler)).toBe('not-a-proposal')
-    expect(moveRefusal(one('IN_PROGRESS', { kind: 'PROPOSAL' }), 'PLANNED', handler)).toBeUndefined()
-    expect(moveRefusal(one('IN_PROGRESS', { kind: 'PROPOSAL' }), 'DECLINED', handler)).toBeUndefined()
-  })
-
-  it('it waits on the handlers while received or in progress', () => {
-    expect(['RECEIVED', 'IN_PROGRESS', 'ANSWERED', 'PLANNED', 'DECLINED', 'CLOSED'].filter(handlersTurn)).toEqual(['RECEIVED', 'IN_PROGRESS'])
-  })
-})
-
-describe('the badge', () => {
-  it("★ a handler's word is new to the writer until they open it", () => {
-    expect(newForAsker(one('ANSWERED'))).toBe(false)
-    expect(newForAsker(one('ANSWERED', { handlerActivityAt: '2026-11-04T10:00:00Z' }))).toBe(true)
-    expect(newForAsker(one('ANSWERED', { handlerActivityAt: '2026-11-04T10:00:00Z', askerSeenAt: '2026-11-04T09:00:00Z' }))).toBe(true)
-    expect(newForAsker(one('ANSWERED', { handlerActivityAt: '2026-11-04T10:00:00Z', askerSeenAt: '2026-11-04T11:00:00Z' }))).toBe(false)
-  })
-
-  it('★ new answers for everyone, and those waiting for a handler', () => {
-    expect(badgeOf({ newAnswers: 2, unhandled: 5, handler: false })).toBe(2)
-    expect(badgeOf({ newAnswers: 2, unhandled: 5, handler: true })).toBe(7)
-  })
-})
-
-describe('the notice', () => {
-  const say = (key: string, english: string, params: Record<string, unknown> = {}) => english.replace(/\{(\w+)\}/g, (_, name) => String(params[name] ?? ''))
-
-  it('names the kind to the handlers and the move to the writer', () => {
-    expect(noticeWordsOf({ title: '엑셀 내보내기', kind: 'PROPOSAL' }, 'received', { body: '목록을 엑셀로' }, say)).toMatchObject({ subject: 'New PROPOSAL: 엑셀 내보내기', summary: '목록을 엑셀로' })
-    expect(noticeWordsOf({ title: '엑셀 내보내기', kind: 'PROPOSAL' }, 'moved', { status: 'PLANNED' }, say).subject).toBe('PLANNED: 엑셀 내보내기')
-  })
-})

package/test/open-doors.test.ts

@@ -1,44 +0,0 @@
-/*
- * Every door of inquiry is open on purpose but one: anyone signed in to the domain writes, reads and replies, and each
- * door asks the inquiry itself (ADR-0184 decision 6). Taking one is the handlers' - `inquiry:mutation`, the domain owner
- * admitted.
- */
-import { gatesOf, openFields } from '../../../test/helpers/open-doors'
-
-const ASKS_THE_INQUIRY = 'anyone of the domain - the door asks the inquiry who may (ADR-0184 decision 6)'
-
-const OPEN: Record<'Query' | 'Mutation', Record<string, string>> = {
-  Query: {
-    inquiries: ASKS_THE_INQUIRY,
-    inquiry: ASKS_THE_INQUIRY,
-    inquirySummary: ASKS_THE_INQUIRY
-  },
-  Mutation: {
-    createInquiry: ASKS_THE_INQUIRY,
-    replyInquiry: ASKS_THE_INQUIRY,
-    moveInquiry: ASKS_THE_INQUIRY,
-    readInquiry: ASKS_THE_INQUIRY
-  }
-}
-
-let gates: Awaited<ReturnType<typeof gatesOf>>
-
-beforeAll(async () => {
-  gates = await gatesOf('inquiry')
-})
-
-it.each(['Query', 'Mutation'] as const)('★ every open %s door has a written reason', root => {
-  expect(openFields(gates[root])).toEqual(Object.keys(OPEN[root]).sort())
-})
-
-it.each(['Query', 'Mutation'] as const)('★ every other %s door asks for inquiry:mutation and admits the domain owner', root => {
-  for (const [field, gate] of Object.entries(gates[root])) {
-    if (field in OPEN[root]) continue
-    expect({ field, ...gate }).toEqual({ field, category: 'inquiry', privilege: 'mutation', owner: true, super: false })
-  }
-})
-
-it('the walk reaches every door', () => {
-  expect(Object.keys(gates.Query)).toHaveLength(3)
-  expect(Object.keys(gates.Mutation)).toHaveLength(5)
-})