@things-factory/inquiry 10.1.252 → 10.1.254

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

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

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

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

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