@things-factory/inquiry 10.1.253 → 10.1.255

package/client/pages/inquiry-list.ts

@@ -1,218 +0,0 @@
-import '@material/web/icon/icon.js'
-import '@operato/data-grist/ox-grist.js'
-import '@operato/data-grist/ox-filters-form.js'
-import '@operato/input/ox-select.js'
-import '@operato/popup/ox-popup-list.js'
-import '../components/inquiry-thread.js'
-
-import gql from 'graphql-tag'
-import { css, html, nothing } from 'lit'
-import { customElement, query, state } from 'lit/decorators.js'
-
-import { DataGrist, FetchOption } from '@operato/data-grist'
-import { client } from '@operato/graphql'
-import { i18next, localize } from '@operato/i18n'
-import { navigate, PageView } from '@operato/shell'
-import { CommonGristStyles, CommonHeaderStyles, ScrollbarStyles, WorkSurfacePageStyles } from '@operato/styles'
-import { isMobileDevice } from '@operato/utils'
-
-import { openInquiryWriter } from '../components/inquiry-writer.js'
-import type { InquiryThread } from '../components/inquiry-thread.js'
-import { inquiryApi, LIST_FIELDS } from '../utils/inquiry-api.js'
-import { KIND_ICONS, KINDS, kindWord, STATUSES, statusWord, t, visibilityWord, when } from '../utils/inquiry-words.js'
-
-/**
- * 문의 · 제안 — the questions, bug reports and proposals of the domain that the person may read, and with `?id=` one of
- * them as its thread (ADR-0184 decision 8). Handlers work from here too: they open on those waiting on them.
- */
-@customElement('inquiry-list')
-export class InquiryList extends localize(i18next)(PageView) {
-  static styles = [
-    WorkSurfacePageStyles,
-    CommonGristStyles,
-    CommonHeaderStyles,
-    ScrollbarStyles,
-    css`
-      .filters {
-        display: flex;
-        flex-wrap: wrap;
-        align-items: center;
-        gap: var(--spacing-medium, 8px);
-      }
-      ox-select {
-        min-width: 140px;
-      }
-      .thread {
-        overflow: auto;
-        padding: var(--spacing-large, 12px) var(--spacing-huge, 16px);
-        max-width: 880px;
-        width: 100%;
-        box-sizing: border-box;
-      }
-    `
-  ]
-
-  @state() gristConfig: any
-  @state() scope = 'all'
-  @state() handler = false
-  /* The inquiry shown as its thread - none shows the list. */
-  @state() openId = ''
-  @query('ox-grist') private grist!: DataGrist
-  @query('inquiry-thread') private thread!: InquiryThread
-
-  private onChanged = () => {
-    if (this.openId) return
-    this.grist?.fetch()
-  }
-
-  get context() {
-    return {
-      title: t('inquiry.title.list'),
-      ...(this.openId
-        ? {}
-        : {
-            search: {
-              handler: (search: string) => {
-                this.grist.searchText = search
-              },
-              value: this.grist?.searchText || ''
-            },
-            filter: {
-              handler: () => {
-                this.grist.toggleHeadroom()
-              }
-            }
-          }),
-      actions: [
-        ...(this.openId ? [{ title: t('inquiry.button.back'), icon: 'arrow_back', action: () => navigate('inquiry-list') }] : []),
-        { title: t('inquiry.button.send'), icon: 'add', emphasis: { raised: true }, action: () => openInquiryWriter() }
-      ]
-    }
-  }
-
-  render() {
-    if (this.openId) return html`<div class="thread"><inquiry-thread .inquiryId=${this.openId}></inquiry-thread></div>`
-    const scopes = [
-      { value: 'all', display: t('inquiry.scope.all') },
-      { value: 'mine', display: t('inquiry.scope.mine') },
-      ...(this.handler ? [{ value: 'handlers-turn', display: t('inquiry.scope.handlers-turn') }] : [])
-    ]
-    return html`<ox-grist class="page-fill" search-mode="term" .mode=${isMobileDevice() ? 'CARD' : 'GRID'} .config=${this.gristConfig} .fetchHandler=${this.fetchHandler.bind(this)}>
-      <div slot="headroom" class="header">
-        <div class="filters">
-          <ox-select
-            .value=${this.scope}
-            aria-label=${t('inquiry.text.scope')}
-            @change=${(e: CustomEvent) => {
-              const next = String(e.detail ?? 'all')
-              if (next === this.scope) return
-              this.scope = next
-              this.grist.fetch()
-            }}
-          >
-            <span slot="label">${scopes.find(one => one.value === this.scope)?.display}</span>
-            <ox-popup-list align-left nowrap>${scopes.map(one => html`<div option value=${one.value}>${one.display}</div>`)}</ox-popup-list>
-          </ox-select>
-          <ox-filters-form without-search autofocus></ox-filters-form>
-        </div>
-      </div>
-    </ox-grist>`
-  }
-
-  connectedCallback() {
-    super.connectedCallback()
-    window.addEventListener('inquiries-changed', this.onChanged)
-  }
-
-  disconnectedCallback() {
-    window.removeEventListener('inquiries-changed', this.onChanged)
-    super.disconnectedCallback()
-  }
-
-  async pageUpdated(changes: any, lifecycle: any) {
-    if (!this.active || !(changes.active || changes.params)) return
-    const id = String(lifecycle?.params?.id ?? '')
-    if (id !== this.openId) {
-      this.openId = id
-      this.updateContext()
-    } else if (id) this.thread?.load(true)
-    else if (this.gristConfig) this.grist?.fetch()
-  }
-
-  async pageInitialized() {
-    try {
-      this.handler = (await inquiryApi.summary()).handler
-      /* A handler opens on what waits on them. */
-      if (this.handler) this.scope = 'handlers-turn'
-    } catch {
-      this.handler = false
-    }
-    const open = (record: any) => record?.id && navigate(`inquiry-list?id=${record.id}`)
-    this.gristConfig = {
-      rows: { appendable: false, selectable: false, handlers: { click: (_c: any, _d: any, _col: any, record: any) => open(record) } },
-      pagination: { limit: 50, pages: [50, 100] },
-      emptyNote: { title: t('inquiry.text.empty'), description: t('inquiry.text.empty-description') },
-      list: { fields: ['title', 'status'], details: ['kind', 'createdAt'] },
-      columns: [
-        {
-          type: 'string',
-          name: 'kind',
-          header: t('inquiry.field.kind'),
-          width: 110,
-          record: {
-            editable: false,
-            renderer: (value: string) => html`<span style="display:inline-flex;align-items:center;gap:2px"><md-icon style="--md-icon-size:16px">${KIND_ICONS[value] ?? 'help'}</md-icon>${kindWord(value)}</span>`
-          },
-          filter: { type: 'select', operator: 'eq', options: [{ display: '', value: '' }, ...KINDS.map(code => ({ display: kindWord(code), value: code }))] }
-        },
-        {
-          type: 'string',
-          name: 'title',
-          header: t('inquiry.field.title'),
-          width: 320,
-          record: {
-            editable: false,
-            renderer: (value: string, _c: any, record: any) =>
-              html`<span style=${record?.isNew ? 'font-weight:600' : ''}
-                >${record?.visibility === 'PRIVATE' ? html`<md-icon style="--md-icon-size:14px" title=${visibilityWord('PRIVATE')}>lock</md-icon> ` : nothing}${value}${record?.replyCount
-                  ? ` (${record.replyCount})`
-                  : ''}</span
-              >`
-          }
-        },
-        {
-          type: 'string',
-          name: 'status',
-          header: t('inquiry.field.status'),
-          width: 100,
-          record: {
-            editable: false,
-            renderer: (value: string, _c: any, record: any) =>
-              html`<span style=${record?.isNew ? 'color:var(--md-sys-color-primary);font-weight:600' : ''}>${statusWord(value)}${record?.isNew ? ` · ${t('inquiry.text.new')}` : ''}</span>`
-          },
-          filter: { type: 'select', operator: 'eq', options: [{ display: '', value: '' }, ...STATUSES.map(code => ({ display: statusWord(code), value: code }))] }
-        },
-        { type: 'string', name: 'creator', header: t('inquiry.field.writer'), width: 110, record: { editable: false, renderer: (value: any) => value?.name ?? '' } },
-        { type: 'string', name: 'assignee', header: t('inquiry.field.assignee'), width: 110, record: { editable: false, renderer: (value: any) => value?.name ?? '' } },
-        { type: 'string', name: 'createdAt', header: t('inquiry.field.created-at'), width: 130, record: { editable: false, renderer: (value: string) => when(value) } }
-      ]
-    }
-  }
-
-  async fetchHandler({ page = 1, limit = 50, filters = [], search }: FetchOption) {
-    const response = await client.query({
-      query: gql`
-        query ($filters: [Filter!], $pagination: Pagination, $search: String, $scope: String) {
-          responses: inquiries(filters: $filters, pagination: $pagination, search: $search, scope: $scope) {
-            items { ${LIST_FIELDS} }
-            total
-          }
-        }
-      `,
-      variables: { filters, pagination: { page, limit }, search: search?.trim() || undefined, scope: this.scope },
-      fetchPolicy: 'network-only'
-    })
-    if (response.errors?.length) throw response
-    return { total: response.data.responses.total, records: response.data.responses.items }
-  }
-}

package/client/route.ts

@@ -1,8 +0,0 @@
-/* The page this module brings to an application that puts it in its menu (ADR-0184 decision 8). */
-export default function route(page: string) {
-  switch (page) {
-    case 'inquiry-list':
-      import('./pages/inquiry-list.js')
-      return page
-  }
-}

package/client/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../tsconfig-base.json",
-  "compilerOptions": {
-    "experimentalDecorators": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "declaration": true,
-    "module": "esnext",
-    "outDir": "../dist-client",
-    "baseUrl": "./"
-  },
-  "include": ["./**/*"]
-}

package/client/utils/inquiry-api.ts

@@ -1,103 +0,0 @@
-/*
- * The inquiry doors as the screens call them (ADR-0184). Every call throws the server's words when it is refused.
- */
-import gql from 'graphql-tag'
-
-import { client, uploadContext } from '@operato/graphql'
-
-export type FileRow = { id: string; name: string; fullpath: string; size?: number; mimetype?: string }
-export type Person = { id: string; name?: string | null } | null
-
-export interface InquiryReplyItem {
-  id: string
-  body?: string | null
-  byHandler: boolean
-  answer: boolean
-  status?: string | null
-  createdAt: string
-  creator?: Person
-  attachments?: FileRow[]
-}
-
-export interface InquiryItem {
-  id: string
-  kind: 'QUESTION' | 'BUG' | 'PROPOSAL' | string
-  title: string
-  body?: string | null
-  status: string
-  visibility: 'DOMAIN' | 'PRIVATE' | string
-  pageUrl?: string | null
-  appName?: string | null
-  appVersion?: string | null
-  replyCount: number
-  createdAt: string
-  answeredAt?: string | null
-  closedAt?: string | null
-  mine?: boolean
-  isNew?: boolean
-  canReply?: boolean
-  asHandler?: boolean
-  moves?: string[]
-  creator?: Person
-  assignee?: Person
-  attachments?: FileRow[]
-  replies?: InquiryReplyItem[]
-}
-
-export interface InquiryInput {
-  kind: string
-  title: string
-  body?: string
-  visibility?: string
-  pageUrl?: string
-}
-
-export type InquirySummary = { newAnswers: number; unhandled: number; handler: boolean; badge: number }
-
-/** The fields a list row needs. */
-export const LIST_FIELDS = `id kind title status visibility replyCount createdAt mine isNew creator { id name } assignee { id name }`
-
-const FILE = `attachments { id name fullpath size mimetype }`
-
-/** Everything one inquiry shows. */
-export const FULL_FIELDS = `${LIST_FIELDS} body pageUrl appName appVersion answeredAt closedAt canReply asHandler moves ${FILE}
-  replies { id body byHandler answer status createdAt creator { id name } ${FILE} }`
-
-function answer<T>(response: any, field: string): T {
-  if (response.errors?.length) throw new Error(response.errors.map((one: any) => one.message).join(' · '))
-  return response.data?.[field] as T
-}
-
-async function ask<T>(query: string, variables: Record<string, unknown>, field: string): Promise<T> {
-  return answer<T>(await client.query({ query: gql(query), variables, fetchPolicy: 'network-only' }), field)
-}
-
-async function change<T>(mutation: string, variables: Record<string, unknown>, field: string, uploading?: (fraction: number) => void): Promise<T> {
-  return answer<T>(await client.mutate({ mutation: gql(mutation), variables, ...(uploading ? { context: uploadContext(uploading) } : {}) }), field)
-}
-
-/** Tells the badge and an open list that an inquiry changed. */
-export const inquiriesChanged = () => window.dispatchEvent(new CustomEvent('inquiries-changed'))
-
-export const inquiryApi = {
-  one: (id: string) => ask<InquiryItem | null>(`query ($id: String!) { inquiry(id: $id) { ${FULL_FIELDS} } }`, { id }, 'inquiry'),
-  summary: () => ask<InquirySummary>(`query { inquirySummary { newAnswers unhandled handler badge } }`, {}, 'inquirySummary'),
-  create: (input: InquiryInput, attachments: File[], uploading?: (fraction: number) => void) =>
-    change<InquiryItem>(
-      `mutation ($input: InquiryInput!, $attachments: [Upload!]) { createInquiry(input: $input, attachments: $attachments) { id } }`,
-      { input, attachments: attachments.length ? attachments : null },
-      'createInquiry',
-      attachments.length ? uploading : undefined
-    ),
-  reply: (id: string, body: string, asAnswer: boolean, attachments: File[], uploading?: (fraction: number) => void) =>
-    change<InquiryItem>(
-      `mutation ($id: String!, $body: String, $answer: Boolean, $attachments: [Upload!]) { replyInquiry(id: $id, body: $body, answer: $answer, attachments: $attachments) { id } }`,
-      { id, body, answer: asAnswer, attachments: attachments.length ? attachments : null },
-      'replyInquiry',
-      attachments.length ? uploading : undefined
-    ),
-  move: (id: string, status: string, reason?: string) =>
-    change<InquiryItem>(`mutation ($id: String!, $status: String!, $reason: String) { moveInquiry(id: $id, status: $status, reason: $reason) { id } }`, { id, status, reason }, 'moveInquiry'),
-  take: (id: string) => change<InquiryItem>(`mutation ($id: String!) { takeInquiry(id: $id) { id } }`, { id }, 'takeInquiry'),
-  read: (id: string) => change<InquiryItem>(`mutation ($id: String!) { readInquiry(id: $id) { id } }`, { id }, 'readInquiry')
-}

package/client/utils/inquiry-badge.ts

@@ -1,46 +0,0 @@
-/*
- * The count the menu shows on 문의 · 제안 (ADR-0184 decision 8) - new words on one's own inquiries, and for a handler
- * those waiting on the handlers. An application puts `generateInquiryBadge` on its menu entry; the count is asked again
- * whenever an inquiry notice arrives or an inquiry changes on a screen.
- */
-import { inquiryApi } from './inquiry-api.js'
-
-let count: number | undefined
-/* One more each time the count is asked again - a badge that was busy drawing the last one still sees the next. */
-let version = 0
-const waiting = new Set<() => void>()
-
-/** Asks the server again and tells every badge. A count that could not be asked is not zero: it draws nothing. */
-export async function refreshInquiryBadge(): Promise<void> {
-  try {
-    count = (await inquiryApi.summary()).badge
-  } catch {
-    count = undefined
-  }
-  version++
-  for (const wake of [...waiting]) wake()
-}
-
-let generation = 0
-
-/** One badge's counts. The menu asks for a new one when it draws again; the one before it then ends, as worklist's do. */
-export async function* generateInquiryBadge() {
-  const mine = ++generation
-  for (const wake of [...waiting]) wake()
-  let seen = version
-  yield count
-  while (true) {
-    if (seen === version) {
-      await new Promise<void>(resolve => {
-        const wake = () => {
-          waiting.delete(wake)
-          resolve()
-        }
-        waiting.add(wake)
-      })
-    }
-    if (mine !== generation) return
-    seen = version
-    yield count
-  }
-}

package/client/utils/inquiry-words.ts

@@ -1,26 +0,0 @@
-/*
- * The words and marks of inquiries - one place for the list, the thread, the writing window and the to-do.
- */
-import { i18next } from '@operato/i18n'
-
-export const t = (key: string, options: Record<string, unknown> = {}) => String(i18next.t(key, options))
-
-export const KINDS = ['QUESTION', 'BUG', 'PROPOSAL']
-export const VISIBILITIES = ['DOMAIN', 'PRIVATE']
-export const STATUSES = ['RECEIVED', 'IN_PROGRESS', 'ANSWERED', 'PLANNED', 'DECLINED', 'CLOSED']
-
-export const kindWord = (code?: string | null) => (code ? t(`inquiry.kind.${code}`, { defaultValue: code }) : '')
-export const statusWord = (code?: string | null) => (code ? t(`inquiry.status.${code}`, { defaultValue: code }) : '')
-export const visibilityWord = (code?: string | null) => (code ? t(`inquiry.visibility.${code}`, { defaultValue: code }) : '')
-
-/** The icon of each kind. */
-export const KIND_ICONS: Record<string, string> = { QUESTION: 'help', BUG: 'bug_report', PROPOSAL: 'lightbulb' }
-
-/** A day and time as the reader's locale writes it. */
-export function when(value?: string | Date | null): string {
-  if (!value) return ''
-  return new Date(value).toLocaleString(i18next.language, { year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' })
-}
-
-/** The words of a refusal the server gave, or the fallback. */
-export const reasonOf = (error: unknown) => (error as Error)?.message || t('inquiry.text.failed')

package/server/attachment-reader.ts

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

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

@@ -1,35 +0,0 @@
-/*
- * 문의 처리 (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

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

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

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