@things-factory/inquiry 0.0.0-stage → 10.1.251

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@things-factory/inquiry",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "10.1.251",
+  "main": "dist-server/index.js",
+  "browser": "dist-client/index.js",
+  "things-factory": true,
+  "license": "MIT",
+  "author": "heartyoh <heartyoh@hatiolab.com>",
+  "description": "Inquiries - a question, a bug report or a feature proposal, written from any screen and answered by the domain's handlers",
+  "publishConfig": {
+    "access": "public",
+    "@things-factory:registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hatiolab/things-factory.git",
+    "directory": "packages/inquiry"
+  },
+  "scripts": {
+    "build": "npm run build:server && npm run build:client",
+    "copy:files": "copyfiles -e \"./client/**/*.{ts,js,json}\" -u 1 \"./client/**/*\" dist-client",
+    "build:client": "npm run clean:client && npm run copy:files && npx tsc --p ./client/tsconfig.json",
+    "build:server": "npm run clean:server && npx tsc --p ./server/tsconfig.json",
+    "clean:server": "rm -rf dist-server",
+    "clean:client": "rm -rf dist-client",
+    "clean": "npm run clean:server && npm run clean:client"
+  },
+  "dependencies": {
+    "@material/web": "^2.0.0",
+    "@operato/data-grist": "^10.0.0",
+    "@operato/graphql": "^10.29.39",
+    "@operato/i18n": "^10.0.0",
+    "@operato/input": "^10.29.43",
+    "@operato/layout": "^10.29.49",
+    "@operato/popup": "^10.29.39",
+    "@operato/shell": "^10.29.39",
+    "@operato/styles": "^10.29.1",
+    "@operato/utils": "^10.0.0",
+    "@things-factory/apptool-base": "^10.1.247",
+    "@things-factory/attachment-base": "^10.1.250",
+    "@things-factory/auth-base": "^10.1.250",
+    "@things-factory/env": "^10.1.149",
+    "@things-factory/i18n-base": "^10.1.250",
+    "@things-factory/notification": "^10.1.250",
+    "@things-factory/shell": "^10.1.247",
+    "@things-factory/worklist": "^10.1.250",
+    "graphql-scalars": "^1.22.0",
+    "graphql-tag": "^2.12.6",
+    "graphql-upload": "^15.0.2",
+    "lit": "^3.1.2"
+  },
+  "gitHead": "6a4c45983e1d8aa4193bbbca1bd79ea3596d2175"
+}

package/server/attachment-reader.ts

@@ -0,0 +1,18 @@
+/*
+ * Who may open an inquiry's file by its path - whoever may read the inquiry (ADR-0184 decision 5), a reply's file as
+ * its inquiry's. attachment-base has already checked the file is of the request's domain.
+ */
+import { registerAttachmentReader } from '@things-factory/attachment-base'
+import { getRepository } from '@things-factory/shell'
+
+import { InquiryReply } from './service/inquiry/inquiry'
+import { INQUIRY_REF_TYPE, INQUIRY_REPLY_REF_TYPE, visibleInquiry } from './service/inquiry/inquiry-service'
+
+export function registerInquiryFiles(): void {
+  registerAttachmentReader(INQUIRY_REF_TYPE, async (attachment, context) => !!attachment.refBy && !!(await visibleInquiry(attachment.refBy, context)))
+  registerAttachmentReader(INQUIRY_REPLY_REF_TYPE, async (attachment, context) => {
+    if (!attachment.refBy) return false
+    const reply = await getRepository(InquiryReply).findOneBy({ id: attachment.refBy })
+    return !!reply?.inquiryId && !!(await visibleInquiry(reply.inquiryId, context))
+  })
+}

package/server/index.ts

@@ -0,0 +1,18 @@
+export * from './service'
+export { INQUIRY_ACTIVITY, INQUIRY_HANDLING } from './inquiry-activity'
+
+import { registerRoleTask } from '@things-factory/auth-base'
+import { ActivityInstallations } from '@things-factory/worklist'
+
+import { registerInquiryFiles } from './attachment-reader'
+import { INQUIRY_ACTIVITY } from './inquiry-activity'
+import { ROLE_TASKS } from './role-tasks'
+
+for (const task of ROLE_TASKS) registerRoleTask(task)
+registerInquiryFiles()
+
+/*
+ * Importing this file registers the handlers' to-do (ADR-0184 decision 7) - a bootstrap hook would be too late for
+ * worklist to find it. Which domains have it is the application's call: it installs `INQUIRY_ACTIVITY`.
+ */
+ActivityInstallations.installActivityTemplate(INQUIRY_ACTIVITY as any)

package/server/inquiry-activity.ts

@@ -0,0 +1,35 @@
+/*
+ * 문의 처리 (ADR-0184 decision 7) - not an approval: while an inquiry waits on the handlers, one case of this activity is
+ * open, pooled on the roles that give inquiry handling. It shows the inquiry through this module's own element
+ * (`inquiry-todo`), which opens it; answering, deciding or closing the inquiry closes the case.
+ *
+ * Data only. An application installs it into its domains (Office `REQUIRED_ACTIVITIES`).
+ */
+export const INQUIRY_HANDLING = 'Inquiry Handling'
+
+export const INQUIRY_ACTIVITY = {
+  name: INQUIRY_HANDLING,
+  label: 'inquiry handling',
+  description: 'Answering a question, a bug report or a feature proposal',
+  guide: [
+    'while an inquiry waits on the handlers, one case is open for the roles that give inquiry handling - whoever of them picks it.',
+    'it opens the inquiry; answering it, deciding a proposal or closing it closes the case.',
+    'the writer replying to an answer opens a new case.'
+  ],
+  release: '1.0.0',
+  provider: 'hatiolab.com',
+  category: 'support',
+  activityType: 'user',
+  priority: 2,
+  startingType: 'issue',
+  multiple: 'single',
+  uiType: 'custom-element',
+  uiSource: 'inquiry-todo',
+  searchKeys: [{ name: 'inquiryId', description: 'The inquiry', inputKey: 'inquiryId', tKey: 'field.subject' }],
+  viewType: '',
+  viewSource: '',
+  model: [
+    { name: 'inquiryId', description: 'The inquiry this to-do answers', tag: 'inquiryId', hidden: true, mandatory: true, inout: 'in', type: 'string', options: {}, unit: null, quantifier: [1], spec: {} }
+  ],
+  standardTime: 3 * 24 * 60 * 60
+}

package/server/role-tasks.ts

@@ -0,0 +1,13 @@
+/*
+ * The work this module names, for the seats applications build (ADR-0139 decision 11).
+ *
+ * Writing an inquiry, and reading one's own and the open ones, is no task: anyone signed in to the domain asks
+ * (ADR-0184 decision 6). Taking, answering, deciding where one stands and reading the private ones is
+ * `inquiry.answering`.
+ *
+ * Data only - `server/index.ts` registers it - so an application's tests read it without starting the framework.
+ */
+
+import type { RoleTask } from '@things-factory/auth-base'
+
+export const ROLE_TASKS: RoleTask[] = [{ id: 'inquiry.answering', grants: [{ category: 'inquiry', axes: ['mutation'] }] }]

package/server/service/index.ts

@@ -0,0 +1,19 @@
+/* EXPORT ENTITY TYPES */
+export * from './inquiry/inquiry'
+export * from './inquiry/inquiry-rules'
+export { INQUIRY_REF_TYPE, INQUIRY_REPLY_REF_TYPE, visibleInquiry } from './inquiry/inquiry-service'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as InquiryEntities, resolvers as InquiryResolvers } from './inquiry'
+
+export const entities = [
+  /* ENTITIES */
+  ...InquiryEntities
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...InquiryResolvers
+  ]
+}

package/server/service/inquiry/index.ts

@@ -0,0 +1,5 @@
+import { Inquiry, InquiryReply } from './inquiry'
+import { InquiryReplyResolver, InquiryResolver } from './inquiry-resolver'
+
+export const entities = [Inquiry, InquiryReply]
+export const resolvers = [InquiryResolver, InquiryReplyResolver]

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

@@ -0,0 +1,321 @@
+/*
+ * The doors of inquiries (ADR-0184 decisions 2-8).
+ *
+ * Writing, reading and replying is not a privilege: anyone signed in to the domain asks, reads the open inquiries and
+ * their own, and replies on their own - each door asks the inquiry itself (inquiry-rules.ts). Taking one is the
+ * handlers' alone - `inquiry:mutation`, the module's task `inquiry.answering`; the handlers' other moves go through the
+ * same doors as the writer's, which ask the rules who may.
+ */
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+import { Arg, Args, Ctx, Directive, FieldResolver, Mutation, Query, Resolver, Root } from 'type-graphql'
+import { In, IsNull, Not } from 'typeorm'
+
+import { Attachment, createAttachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { appPackage } from '@things-factory/env'
+import { getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { Inquiry, InquiryReply } from './inquiry'
+import {
+  answerRefusal,
+  badgeOf,
+  handlersTurn,
+  HANDLERS_TURN,
+  INQUIRY_STATUSES,
+  inputRefusal,
+  moveRefusal,
+  newForAsker,
+  replyRefusal,
+  replyRefusalFor,
+  sideOf,
+  statusAfterReply
+} from './inquiry-rules'
+import {
+  closeTodo,
+  handlerUserIds,
+  INQUIRY_REF_TYPE,
+  INQUIRY_REPLY_REF_TYPE,
+  isHandler,
+  openTodo,
+  tellWhenCommitted,
+  viewerOf,
+  visibleInquiry
+} from './inquiry-service'
+import { InquiryInput, InquiryList, InquirySummary } from './inquiry-types'
+
+const HANDLE = '@privilege(category: "inquiry", privilege: "mutation", domainOwnerGranted: true)'
+
+/** The ways the list is narrowed: every one the person may read, their own, or those waiting on the handlers. */
+const SCOPES = ['all', 'mine', 'handlers-turn']
+
+/** A refusal said in the reader's words, with a code the screen may read. */
+function refuse(context: ResolverContext, code: string, fallback: string): never {
+  const message = context.t ? String(context.t(`inquiry.refusal.${code}`, { defaultValue: fallback })) : fallback
+  const error: any = new Error(message)
+  error.extensions = { code: `inquiry.${code}` }
+  throw error
+}
+
+const NOT_FOUND = 'there is no such inquiry.'
+
+async function visibleOrRefuse(id: string, context: ResolverContext, tx?: any) {
+  const visible = await visibleInquiry(id, context, tx)
+  if (!visible) refuse(context, 'unknown-inquiry', NOT_FOUND)
+  return visible
+}
+
+async function attachFiles(refType: string, refBy: string, files: FileUpload[] | undefined, context: ResolverContext) {
+  for (const file of files ?? []) {
+    await createAttachment(null, { attachment: { file, refType, refBy } } as any, context)
+  }
+}
+
+/** The fields that change with a move to `status`. */
+function stampsOf(status: string, now: Date) {
+  return {
+    status,
+    ...(status === 'ANSWERED' ? { answeredAt: now } : {}),
+    ...(status === 'CLOSED' ? { closedAt: now } : {})
+  }
+}
+
+/** Keeps the handlers' to-do in line with whose turn it is: open while it waits on them, closed otherwise. */
+async function alignTodo(inquiry: Inquiry, context: ResolverContext) {
+  if (handlersTurn(inquiry.status)) await openTodo(inquiry, context)
+  else await closeTodo(inquiry, context, inquiry.status)
+}
+
+@Resolver(Inquiry)
+export class InquiryResolver {
+  /* ---------------------------------------------------------------- reading */
+
+  @Query(returns => InquiryList, {
+    description:
+      "The inquiries the request's person may read - every open one of the domain, their own, and for a handler the private ones too - the newest first. `scope` narrows it: all (the default), mine, or handlers-turn (received or in progress, the oldest first)."
+  })
+  async inquiries(@Args(type => ListParam) params: ListParam, @Arg('scope', { nullable: true }) scope: string, @Ctx() context: ResolverContext): Promise<InquiryList> {
+    const { domain, user } = context.state
+    const narrowing = scope || 'all'
+    if (!SCOPES.includes(narrowing)) refuse(context, 'unknown-scope', `the list cannot be narrowed so (${narrowing}).`)
+    const handler = await isHandler(context)
+    const qb = getQueryBuilderFromListParams({
+      domain,
+      params: { ...params, sortings: [] },
+      repository: getRepository(Inquiry),
+      alias: 'I',
+      searchables: ['title', 'body']
+    })
+    if (!handler) qb.andWhere("(I.visibility <> 'PRIVATE' OR I.creator = :me)", { me: user.id })
+    if (narrowing === 'mine') qb.andWhere('I.creator = :me', { me: user.id })
+    if (narrowing === 'handlers-turn') qb.andWhere('I.status IN (:...turn)', { turn: [...HANDLERS_TURN] }).orderBy('I.createdAt', 'ASC')
+    else qb.orderBy('I.createdAt', 'DESC')
+    const [items, total] = await qb.getManyAndCount()
+    return { items, total }
+  }
+
+  @Query(returns => Inquiry, { nullable: true, description: 'One inquiry, when the request may read it.' })
+  async inquiry(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Inquiry | undefined> {
+    return (await visibleInquiry(id, context))?.inquiry
+  }
+
+  @Query(returns => InquirySummary, { description: 'What the menu counts: new words on the person\'s own inquiries, and for a handler those waiting on the handlers.' })
+  async inquirySummary(@Ctx() context: ResolverContext): Promise<InquirySummary> {
+    const { domain, user } = context.state
+    const handler = await isHandler(context)
+    const own = await getRepository(Inquiry).find({ where: { domain: { id: domain.id }, creator: { id: user.id }, handlerActivityAt: Not(IsNull()) } as any })
+    const newAnswers = own.filter(one => newForAsker(one)).length
+    const unhandled = handler ? await getRepository(Inquiry).count({ where: { domain: { id: domain.id }, status: In([...HANDLERS_TURN]) } as any }) : 0
+    return { newAnswers, unhandled, handler, badge: badgeOf({ newAnswers, unhandled, handler }) }
+  }
+
+  /* ---------------------------------------------------------------- writing and replying */
+
+  @Directive('@transaction')
+  @Mutation(returns => Inquiry, {
+    description: 'Writes an inquiry. The application and its version, the writer and the domain are taken from the request; the screen it was written from is sent by the browser. The handlers are told.'
+  })
+  async createInquiry(
+    @Arg('input', type => InquiryInput) input: InquiryInput,
+    @Arg('attachments', type => [GraphQLUpload], { nullable: true }) attachments: FileUpload[],
+    @Ctx() context: ResolverContext
+  ): Promise<Inquiry> {
+    const { domain, user, tx } = context.state as any
+    const refusal = inputRefusal(input)
+    if (refusal) refuse(context, refusal, `the inquiry cannot be kept (${refusal}).`)
+    const { name, version } = (appPackage as any) ?? {}
+    const saved = await getRepository(Inquiry, tx).save({
+      domain,
+      kind: input.kind,
+      title: input.title.trim(),
+      body: input.body ?? null,
+      status: 'RECEIVED',
+      visibility: input.visibility || 'DOMAIN',
+      pageUrl: input.pageUrl?.trim() || null,
+      appName: name ?? null,
+      appVersion: version ?? null,
+      replyCount: 0,
+      creator: user,
+      updater: user
+    } as any)
+    await attachFiles(INQUIRY_REF_TYPE, saved.id, attachments, context)
+    const inquiry = await getRepository(Inquiry, tx).findOneBy({ id: saved.id })
+    await openTodo(inquiry!, context)
+    await tellWhenCommitted(context, inquiry!, 'received', await handlerUserIds(domain, tx), { body: inquiry!.body })
+    return inquiry!
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Inquiry, {
+    description:
+      "Replies on an inquiry - its writer or a handler. A handler may send the reply as the answer; the writer replying to an answer or a decision hands it back to the handlers. The other side is told."
+  })
+  async replyInquiry(
+    @Arg('id') id: string,
+    @Arg('body', { nullable: true }) body: string,
+    @Arg('answer', { nullable: true }) answer: boolean,
+    @Arg('attachments', type => [GraphQLUpload], { nullable: true }) attachments: FileUpload[],
+    @Ctx() context: ResolverContext
+  ): Promise<Inquiry> {
+    const { domain, user, tx } = context.state as any
+    const { inquiry, viewer } = await visibleOrRefuse(id, context, tx)
+    const refusal = replyRefusalFor(inquiry, viewer) ?? replyRefusal(body, attachments?.length ?? 0)
+    if (refusal) refuse(context, refusal, `the reply cannot be kept (${refusal}).`)
+    const side = sideOf(inquiry, viewer)
+    const asAnswer = !!answer
+    const answerRefused = answerRefusal(side, asAnswer)
+    if (answerRefused) refuse(context, answerRefused, 'only a handler sends the answer.')
+    const status = statusAfterReply(inquiry, side, asAnswer)
+    const now = new Date()
+    const reply = await getRepository(InquiryReply, tx).save({
+      domain,
+      inquiry: { id },
+      body: body?.trim() || null,
+      byHandler: side === 'handler',
+      answer: asAnswer,
+      status: status !== inquiry.status ? status : null,
+      creator: user,
+      updater: user
+    } as any)
+    await attachFiles(INQUIRY_REPLY_REF_TYPE, reply.id, attachments, context)
+    await getRepository(Inquiry, tx).update(id, {
+      ...stampsOf(status, now),
+      replyCount: inquiry.replyCount + 1,
+      ...(side === 'handler' ? { handlerActivityAt: now, ...(inquiry.assigneeId ? {} : { assignee: user }) } : { askerSeenAt: now }),
+      updater: user
+    } as any)
+    const fresh = (await getRepository(Inquiry, tx).findOneBy({ id }))!
+    await alignTodo(fresh, context)
+    if (side === 'handler') await tellWhenCommitted(context, fresh, asAnswer ? 'answered' : 'replied', [fresh.creatorId!], { body })
+    else await tellWhenCommitted(context, fresh, 'asker-replied', fresh.assigneeId ? [fresh.assigneeId] : await handlerUserIds(domain, tx), { body })
+    return fresh
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Inquiry, {
+    description:
+      'Moves an inquiry - its writer closes it; a handler puts it in progress, answered, planned or declined (a proposal only) or closed. The reason, when given, stays on the thread. The writer is told of a handler\'s move.'
+  })
+  async moveInquiry(@Arg('id') id: string, @Arg('status') status: string, @Arg('reason', { nullable: true }) reason: string, @Ctx() context: ResolverContext): Promise<Inquiry> {
+    const { domain, user, tx } = context.state as any
+    const { inquiry, viewer } = await visibleOrRefuse(id, context, tx)
+    const refusal = moveRefusal(inquiry, status, viewer)
+    if (refusal) refuse(context, refusal, `the inquiry cannot be moved so (${refusal}).`)
+    const side = sideOf(inquiry, viewer)
+    const now = new Date()
+    await getRepository(InquiryReply, tx).save({ domain, inquiry: { id }, body: reason?.trim() || null, byHandler: side === 'handler', answer: false, status, creator: user, updater: user } as any)
+    await getRepository(Inquiry, tx).update(id, {
+      ...stampsOf(status, now),
+      replyCount: inquiry.replyCount + 1,
+      ...(side === 'handler' ? { handlerActivityAt: now, ...(inquiry.assigneeId ? {} : { assignee: user }) } : { askerSeenAt: now }),
+      updater: user
+    } as any)
+    const fresh = (await getRepository(Inquiry, tx).findOneBy({ id }))!
+    await alignTodo(fresh, context)
+    if (side === 'handler') await tellWhenCommitted(context, fresh, 'moved', [fresh.creatorId!], { body: reason, status })
+    return fresh
+  }
+
+  @Directive(HANDLE)
+  @Directive('@transaction')
+  @Mutation(returns => Inquiry, { description: 'A handler takes an inquiry - it is theirs to answer, and in progress when it was received.' })
+  async takeInquiry(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Inquiry> {
+    const { user, tx } = context.state as any
+    const { inquiry } = await visibleOrRefuse(id, context, tx)
+    if (inquiry.status === 'CLOSED') refuse(context, 'closed', 'a closed inquiry is not taken.')
+    await getRepository(Inquiry, tx).update(id, { assignee: user, ...(inquiry.status === 'RECEIVED' ? { status: 'IN_PROGRESS' } : {}), updater: user } as any)
+    return (await getRepository(Inquiry, tx).findOneBy({ id }))!
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Inquiry, { description: "Records that its writer opened it - the handlers' words on it are no longer new. Anyone else opening it leaves no trace." })
+  async readInquiry(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Inquiry> {
+    const { user, tx } = context.state as any
+    const { inquiry } = await visibleOrRefuse(id, context, tx)
+    if (inquiry.creatorId !== user.id) return inquiry
+    await getRepository(Inquiry, tx).update(id, { askerSeenAt: new Date() } as any)
+    return (await getRepository(Inquiry, tx).findOneBy({ id }))!
+  }
+
+  /* ---------------------------------------------------------------- fields */
+
+  @FieldResolver(type => [InquiryReply], { description: 'Its replies, the oldest first.' })
+  async replies(@Root() one: Inquiry): Promise<InquiryReply[]> {
+    return await getRepository(InquiryReply).find({ where: { inquiry: { id: one.id } } as any, order: { createdAt: 'ASC' } as any })
+  }
+
+  @FieldResolver(type => [Attachment], { description: 'Its files.' })
+  async attachments(@Root() one: Inquiry, @Ctx() context: ResolverContext): Promise<Attachment[]> {
+    return await getRepository(Attachment).find({ where: { domain: { id: context.state.domain.id }, refType: INQUIRY_REF_TYPE, refBy: one.id } as any, order: { createdAt: 'ASC' } as any })
+  }
+
+  @FieldResolver(type => Boolean, { description: "Whether the request's person wrote it." })
+  mine(@Root() one: Inquiry, @Ctx() context: ResolverContext): boolean {
+    return one.creatorId === context.state.user.id
+  }
+
+  @FieldResolver(type => Boolean, { description: "Whether it has a handler's word its writer has not seen - for its writer." })
+  isNew(@Root() one: Inquiry, @Ctx() context: ResolverContext): boolean {
+    return one.creatorId === context.state.user.id && newForAsker(one)
+  }
+
+  @FieldResolver(type => Boolean, { description: 'Whether the request may reply on it.' })
+  async canReply(@Root() one: Inquiry, @Ctx() context: ResolverContext): Promise<boolean> {
+    return !replyRefusalFor(one, await viewerOf(context))
+  }
+
+  @FieldResolver(type => Boolean, { description: 'Whether the request replies on it as a handler - and so may send the answer.' })
+  async asHandler(@Root() one: Inquiry, @Ctx() context: ResolverContext): Promise<boolean> {
+    const viewer = await viewerOf(context)
+    return viewer.handler && sideOf(one, viewer) === 'handler'
+  }
+
+  @FieldResolver(type => [String], { description: 'Where the request may move it.' })
+  async moves(@Root() one: Inquiry, @Ctx() context: ResolverContext): Promise<string[]> {
+    const viewer = await viewerOf(context)
+    return INQUIRY_STATUSES.filter(status => !moveRefusal(one, status, viewer))
+  }
+
+  @FieldResolver(type => User, { nullable: true, description: 'Who wrote it.' })
+  async creator(@Root() one: Inquiry): Promise<User | null> {
+    return one.creatorId ? await getRepository(User).findOneBy({ id: one.creatorId }) : null
+  }
+
+  @FieldResolver(type => User, { nullable: true, description: 'The handler who took it.' })
+  async assignee(@Root() one: Inquiry): Promise<User | null> {
+    return one.assigneeId ? await getRepository(User).findOneBy({ id: one.assigneeId }) : null
+  }
+}
+
+@Resolver(InquiryReply)
+export class InquiryReplyResolver {
+  @FieldResolver(type => [Attachment], { description: 'Its files.' })
+  async attachments(@Root() one: InquiryReply, @Ctx() context: ResolverContext): Promise<Attachment[]> {
+    return await getRepository(Attachment).find({ where: { domain: { id: context.state.domain.id }, refType: INQUIRY_REPLY_REF_TYPE, refBy: one.id } as any, order: { createdAt: 'ASC' } as any })
+  }
+
+  @FieldResolver(type => User, { nullable: true, description: 'Who wrote it.' })
+  async creator(@Root() one: InquiryReply): Promise<User | null> {
+    return one.creatorId ? await getRepository(User).findOneBy({ id: one.creatorId }) : null
+  }
+}

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

@@ -0,0 +1,173 @@
+/*
+ * The rules of an inquiry (ADR-0184 decisions 1-8) - what may be written, who reads and answers it, where it stands
+ * after a reply or a move, whose turn it is, and what its notice says.
+ *
+ * Pure - the rules are tested without a database. The doors (inquiry-resolver.ts) ask them.
+ */
+
+/** The kinds of inquiry - a question, a bug report, a feature proposal (`inquiry.kind.<code>`). */
+export const INQUIRY_KINDS = ['QUESTION', 'BUG', 'PROPOSAL'] as const
+
+/** Where an inquiry stands (`inquiry.status.<code>`). PLANNED and DECLINED are a proposal's only. */
+export const INQUIRY_STATUSES = ['RECEIVED', 'IN_PROGRESS', 'ANSWERED', 'PLANNED', 'DECLINED', 'CLOSED'] as const
+
+/** Who reads it: everyone of the domain, or its writer and the handlers (`inquiry.visibility.<code>`). */
+export const INQUIRY_VISIBILITIES = ['DOMAIN', 'PRIVATE'] as const
+
+export type InquiryKind = (typeof INQUIRY_KINDS)[number]
+export type InquiryStatus = (typeof INQUIRY_STATUSES)[number]
+
+export const MAX_TITLE = 200
+export const MAX_BODY = 20000
+export const MAX_PAGE_URL = 2000
+
+/** The states that wait on the handlers - a to-do is open for them, and the handlers' badge counts them. */
+export const HANDLERS_TURN: readonly string[] = ['RECEIVED', 'IN_PROGRESS']
+
+export interface InquiryFacts {
+  kind: string
+  status: string
+  visibility: string
+  creatorId?: string | null
+  handlerActivityAt?: Date | string | null
+  askerSeenAt?: Date | string | null
+}
+
+/** The request's person as an inquiry sees them. */
+export interface Viewer {
+  userId: string
+  /** Holds `inquiry:mutation` (the task `inquiry.answering`), or owns the domain. */
+  handler: boolean
+}
+
+export interface InquiryInputFacts {
+  kind?: string | null
+  title?: string | null
+  body?: string | null
+  visibility?: string | null
+  pageUrl?: string | null
+}
+
+/** Why what was written cannot be kept, or nothing. */
+export function inputRefusal(input: InquiryInputFacts): string | undefined {
+  if (!(INQUIRY_KINDS as readonly string[]).includes(String(input.kind ?? ''))) return 'unknown-kind'
+  const title = String(input.title ?? '').trim()
+  if (!title) return 'no-title'
+  if (title.length > MAX_TITLE) return 'title-too-long'
+  if (String(input.body ?? '').length > MAX_BODY) return 'body-too-long'
+  if (input.visibility && !(INQUIRY_VISIBILITIES as readonly string[]).includes(input.visibility)) return 'unknown-visibility'
+  if (String(input.pageUrl ?? '').length > MAX_PAGE_URL) return 'page-url-too-long'
+  return undefined
+}
+
+/** Whether a reply says something - words, or files. */
+export function replyRefusal(body: string | null | undefined, files: number): string | undefined {
+  const text = String(body ?? '').trim()
+  if (!text && !files) return 'empty-reply'
+  if (text.length > MAX_BODY) return 'body-too-long'
+  return undefined
+}
+
+const isAuthor = (one: InquiryFacts, viewer: Viewer) => !!one.creatorId && one.creatorId === viewer.userId
+
+/** An open inquiry is read by everyone of the domain; a private one by its writer and the handlers (decision 5). */
+export function mayRead(one: InquiryFacts, viewer: Viewer): boolean {
+  return one.visibility !== 'PRIVATE' || isAuthor(one, viewer) || viewer.handler
+}
+
+/** Replies go back and forth between the writer and the handlers, until it is closed (decision 3). */
+export function replyRefusalFor(one: InquiryFacts, viewer: Viewer): string | undefined {
+  if (!isAuthor(one, viewer) && !viewer.handler) return 'not-a-party'
+  if (one.status === 'CLOSED') return 'closed'
+  return undefined
+}
+
+/** Which side a reply is from - the writer's own reply is the asker's, even when the writer is a handler. */
+export function sideOf(one: InquiryFacts, viewer: Viewer): 'asker' | 'handler' {
+  return isAuthor(one, viewer) ? 'asker' : 'handler'
+}
+
+/**
+ * Where it stands after a reply (decision 2). A handler's reply marked as the answer answers it; any other handler's
+ * reply puts a received one in progress. The asker replying to an answer or a decision hands it back to the handlers.
+ */
+export function statusAfterReply(one: InquiryFacts, side: 'asker' | 'handler', asAnswer: boolean): string {
+  if (side === 'handler') {
+    if (asAnswer) return 'ANSWERED'
+    return one.status === 'RECEIVED' ? 'IN_PROGRESS' : one.status
+  }
+  return ['ANSWERED', 'PLANNED', 'DECLINED'].includes(one.status) ? 'IN_PROGRESS' : one.status
+}
+
+/** Whether `side` may mark a reply as the answer - the handlers' only. */
+export function answerRefusal(side: 'asker' | 'handler', asAnswer: boolean): string | undefined {
+  return asAnswer && side !== 'handler' ? 'handlers-only' : undefined
+}
+
+/**
+ * Why the request may not move it to `to`, or nothing (decision 2). The writer closes their own; everything else is the
+ * handlers'. A closed one stays closed; PLANNED and DECLINED are a proposal's; nothing goes back to RECEIVED.
+ */
+export function moveRefusal(one: InquiryFacts, to: string, viewer: Viewer): string | undefined {
+  if (!(INQUIRY_STATUSES as readonly string[]).includes(to)) return 'unknown-status'
+  if (one.status === 'CLOSED') return 'closed'
+  if (to === one.status) return 'same-status'
+  if (to === 'RECEIVED') return 'not-a-move'
+  if ((to === 'PLANNED' || to === 'DECLINED') && one.kind !== 'PROPOSAL') return 'not-a-proposal'
+  if (to === 'CLOSED' && isAuthor(one, viewer)) return undefined
+  if (!viewer.handler) return 'handlers-only'
+  return undefined
+}
+
+/** Whether it waits on the handlers. */
+export const handlersTurn = (status: string) => HANDLERS_TURN.includes(status)
+
+/** Whether the writer has a handler's word they have not seen - a reply or a move since they last opened it. */
+export function newForAsker(one: InquiryFacts): boolean {
+  const said = one.handlerActivityAt ? new Date(one.handlerActivityAt).getTime() : undefined
+  if (said === undefined) return false
+  const seen = one.askerSeenAt ? new Date(one.askerSeenAt).getTime() : undefined
+  return seen === undefined || said > seen
+}
+
+/** The count on the menu entry (decision 8): new words on one's own inquiries, and for a handler those waiting on them. */
+export function badgeOf(summary: { newAnswers: number; unhandled: number; handler: boolean }): number {
+  return summary.newAnswers + (summary.handler ? summary.unhandled : 0)
+}
+
+/** The screen an inquiry opens on. */
+export const viewAddressOf = (id: string) => `inquiry-list?id=${id}`
+
+/** Why the people are told. */
+export type NoticeKind = 'received' | 'replied' | 'answered' | 'moved' | 'asker-replied'
+
+/** A sentence in one language, with the English one when that language has none. */
+export type Say = (key: string, english: string, params?: Record<string, unknown>) => string
+
+/** The body as one line of plain words - the notice's summary. */
+export function plainSummary(body: string | null | undefined, max = 120): string {
+  const text = String(body ?? '')
+    .replace(/\s+/g, ' ')
+    .trim()
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text
+}
+
+/** Who is told of what (decision 7): the handlers of a new one, the writer of a handler's word, the handler of the writer's. */
+export function noticeWordsOf(one: { title: string; kind: string }, kind: NoticeKind, said: { body?: string | null; status?: string }, say: Say) {
+  const kindWord = say(`inquiry.kind.${one.kind}`, one.kind)
+  const title = one.title
+  const subject = {
+    received: say('inquiry.notice.received-subject', 'New {kind}: {title}', { kind: kindWord, title }),
+    replied: say('inquiry.notice.replied-subject', 'A reply to your {kind}: {title}', { kind: kindWord, title }),
+    answered: say('inquiry.notice.answered-subject', 'Answered: {title}', { title }),
+    moved: say('inquiry.notice.moved-subject', '{status}: {title}', { status: say(`inquiry.status.${said.status}`, String(said.status ?? '')), title }),
+    'asker-replied': say('inquiry.notice.asker-replied-subject', 'The writer replied: {title}', { title })
+  }[kind]
+  return {
+    subject,
+    summary: plainSummary(said.body) || subject,
+    body: said.body ?? '',
+    action: say('inquiry.notice.action', 'Open the inquiry'),
+    note: say('inquiry.notice.note', 'Open Inquiries in the application to read it.')
+  }
+}