@things-factory/notification 10.1.215 → 10.1.222

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/notification",
-  "version": "10.1.215",
+  "version": "10.1.222",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -30,15 +30,17 @@
     "@material/web": "^2.0.0",
     "@operato/layout": "^10.0.0",
     "@operato/styles": "^10.0.0",
-    "@things-factory/auth-base": "^10.1.215",
-    "@things-factory/i18n-base": "^10.1.215",
-    "@things-factory/organization": "^10.1.215",
-    "@things-factory/setting-base": "^10.1.215",
+    "@things-factory/auth-base": "^10.1.218",
+    "@things-factory/email-base": "^10.1.208",
+    "@things-factory/i18n-base": "^10.1.218",
+    "@things-factory/organization": "^10.1.222",
+    "@things-factory/setting-base": "^10.1.218",
     "@things-factory/shell": "^10.1.208",
     "clipboard": "^2.0.6",
     "firebase": "^9.14.0",
     "firebase-admin": "^11.3.0",
-    "google": "^2.1.0"
+    "google": "^2.1.0",
+    "marked": "^15.0.0"
   },
-  "gitHead": "7de5e80eb1f4e2e268746aee39f820e7563f454d"
+  "gitHead": "afdd6a9b1c8b440e39d4fec48bfbad1a0c02fccc"
 }

package/tests/notice-channel-setting.test.ts

@@ -0,0 +1,107 @@
+/*
+ * The notice channels on the Settings screen (ADR-0164): mail on or off, and the two Teams webhooks. A webhook address
+ * is a secret - it goes in and never comes back; the screen learns only that it is set, and its host.
+ *
+ * The rules run from the source; the writing reads dist-server (entities need tsc's decorator metadata) - run the
+ * package's build:server first.
+ */
+import { DataSource } from 'typeorm'
+
+import { addDataSource, Domain, EnvVar, NamingStrategy, entities as shellEntities } from '@things-factory/shell'
+
+import { noticeChannelState, noticeChannelWrites, secretState, WEBHOOK_NOT_HTTPS } from '../server/service/notice-channel/notice-channel-rules'
+import { NOTICE_EMAIL, NOTICE_TEAMS_CHANNEL } from '../server/controllers/notice/notice-channels'
+import { writeNoticeChannels } from '../dist-server/service/notice-channel/notice-channel-resolver.js'
+
+const CHANNEL = 'https://prod-12.koreacentral.logic.azure.com:443/workflows/abc/triggers/manual/paths/invoke?sig=SECRET'
+const OTHER = 'https://prod-34.koreacentral.logic.azure.com/workflows/def?sig=OTHER'
+
+describe('what the screen sees', () => {
+  test('a webhook shows as set with its host, never as its address', () => {
+    const state = noticeChannelState({ [NOTICE_EMAIL]: 'on', [NOTICE_TEAMS_CHANNEL]: CHANNEL })
+
+    expect(state).toEqual({
+      email: true,
+      teamsChannel: { set: true, host: 'prod-12.koreacentral.logic.azure.com' }
+    })
+    expect(JSON.stringify(state)).not.toContain('sig=')
+  })
+
+  test('nothing set is all off', () => {
+    expect(noticeChannelState({})).toEqual({ email: false, teamsChannel: { set: false } })
+    expect(secretState('  ')).toEqual({ set: false })
+  })
+})
+
+describe('what a change writes', () => {
+  test('mail on and off', () => {
+    expect(noticeChannelWrites({ email: true })).toEqual([{ name: NOTICE_EMAIL, value: 'on' }])
+    expect(noticeChannelWrites({ email: false })).toEqual([{ name: NOTICE_EMAIL, value: 'off' }])
+  })
+
+  test('a webhook is kept trimmed; an empty one is cleared; one left out is not touched', () => {
+    expect(noticeChannelWrites({ teamsChannelWebhook: ` ${CHANNEL} ` })).toEqual([{ name: NOTICE_TEAMS_CHANNEL, value: CHANNEL }])
+    expect(noticeChannelWrites({ teamsChannelWebhook: '' })).toEqual([{ name: NOTICE_TEAMS_CHANNEL, value: null }])
+    expect(noticeChannelWrites({ teamsWebhook: 'https://x.example' } as any)).toEqual([])
+    expect(noticeChannelWrites({})).toEqual([])
+  })
+
+  test('a webhook that is not https is refused by name', () => {
+    for (const bad of ['http://x.example/hook', 'not a url', 'javascript:alert(1)']) {
+      expect(() => noticeChannelWrites({ teamsChannelWebhook: bad })).toThrow(expect.objectContaining({ code: WEBHOOK_NOT_HTTPS }))
+    }
+  })
+})
+
+describe('writing the domain attributes', () => {
+  let dataSource: DataSource
+  let home: Domain
+
+  beforeAll(async () => {
+    dataSource = new DataSource({
+      type: 'sqlite',
+      database: ':memory:',
+      synchronize: true,
+      dropSchema: true,
+      namingStrategy: new NamingStrategy(),
+      entities: [...shellEntities],
+      logging: false
+    })
+    await dataSource.initialize()
+    addDataSource('default', dataSource)
+    home = await dataSource.getRepository(Domain).save({ name: 'home', subdomain: 'home' } as any)
+  })
+
+  afterAll(async () => dataSource?.destroy())
+
+  const own = () => dataSource.getRepository(EnvVar).find({ where: { domain: { id: home.id } } as any })
+
+  test('setting writes the domain’s own attributes and answers without the address', async () => {
+    const state = await writeNoticeChannels(home, { email: true, teamsChannelWebhook: CHANNEL }, dataSource.manager)
+
+    expect(state).toEqual({ email: true, teamsChannel: { set: true, host: 'prod-12.koreacentral.logic.azure.com' } })
+    expect(JSON.stringify(state)).not.toContain('sig=')
+    const rows = Object.fromEntries((await own()).map(row => [row.name, row.value]))
+    expect(rows).toEqual({ [NOTICE_EMAIL]: 'on', [NOTICE_TEAMS_CHANNEL]: CHANNEL })
+  })
+
+  test('setting again replaces the value in the same row', async () => {
+    await writeNoticeChannels(home, { email: false, teamsChannelWebhook: OTHER }, dataSource.manager)
+
+    const rows = await own()
+    expect(rows).toHaveLength(2)
+    expect(Object.fromEntries(rows.map(row => [row.name, row.value]))).toEqual({ [NOTICE_EMAIL]: 'off', [NOTICE_TEAMS_CHANNEL]: OTHER })
+  })
+
+  test('clearing removes the row', async () => {
+    const state = await writeNoticeChannels(home, { teamsChannelWebhook: '' }, dataSource.manager)
+
+    expect(state.teamsChannel).toEqual({ set: false })
+    expect((await own()).map(row => row.name)).toEqual([NOTICE_EMAIL])
+  })
+
+  test('a refused webhook writes nothing', async () => {
+    await expect(writeNoticeChannels(home, { email: true, teamsChannelWebhook: 'http://x.example' }, dataSource.manager)).rejects.toMatchObject({ code: WEBHOOK_NOT_HTTPS })
+    expect(Object.fromEntries((await own()).map(row => [row.name, row.value]))).toEqual({ [NOTICE_EMAIL]: 'off' })
+  })
+})

package/tests/notice-delivery.test.ts

@@ -0,0 +1,328 @@
+/*
+ * A notice goes in the app and by web push always, by mail and Teams when the domain turned them on (ADR-0164).
+ * A channel that fails does not stop the others, and nothing throws - what the notice tells of has already happened.
+ *
+ * The channels are fakes: what each one was handed is what is checked.
+ */
+import { deliverNotice, type Notice, type NoticeChannelFunctions } from '../server/controllers/notice/deliver-notice'
+import { languageOf, noticeChannels, NOTICE_EMAIL, NOTICE_TEAMS_CHANNEL, teamsMessage } from '../server/controllers/notice/notice-channels'
+import { escapeHtml, noticeEmailForm, renderNoticeMarkdown, safeNoticeHref } from '../server/controllers/notice/notice-email'
+
+type Calls = { push: any[]; mail: any[]; teams: { url: string; body: any }[]; reports: string[] }
+
+function fakeChannels(attributes: Record<string, string>, overrides: Partial<NoticeChannelFunctions> = {}): { channels: NoticeChannelFunctions; calls: Calls } {
+  const calls: Calls = { push: [], mail: [], teams: [], reports: [] }
+  const channels: NoticeChannelFunctions = {
+    attributes: async () => attributes,
+    push: payload => void calls.push.push(payload),
+    mail: async mail => (calls.mail.push(mail), { messageId: 'm' }),
+    teams: async (url, body) => (calls.teams.push({ url, body }), { ok: true, status: 202 }),
+    report: message => void calls.reports.push(message),
+    ...overrides
+  }
+  return { channels, calls }
+}
+
+const notice = (over: Partial<Notice> = {}): Notice => ({
+  type: 'approval',
+  receivers: [
+    { id: 'u-kim', email: 'kim@example.com', locale: 'ko-KR' },
+    { id: 'u-lee', email: 'lee@example.com', locale: 'en-US' }
+  ],
+  words: lng => ({ subject: `${lng}: subject`, body: `${lng}: body`, action: `${lng}: open`, note: `${lng}: see the box` }),
+  address: 'activity-approval/a-1',
+  link: 'https://office.example.com/domain/hatiolab/activity-approval/a-1',
+  defaultLanguage: 'ko',
+  label: 'test notice',
+  ...over
+})
+
+const CHANNEL_HOOK = 'https://prod.example.logic.azure.com/workflows/x'
+const ALL_ON = { [NOTICE_EMAIL]: 'on', [NOTICE_TEAMS_CHANNEL]: CHANNEL_HOOK }
+
+describe('notice channels a domain turns on', () => {
+  test('mail is on only when the domain says on', () => {
+    expect(noticeChannels({ [NOTICE_EMAIL]: 'on' }).email).toBe(true)
+    expect(noticeChannels({ [NOTICE_EMAIL]: ' ON ' }).email).toBe(true)
+    expect(noticeChannels({ [NOTICE_EMAIL]: 'true' }).email).toBe(false)
+    expect(noticeChannels({}).email).toBe(false)
+    expect(noticeChannels(undefined).email).toBe(false)
+  })
+
+  test('Teams takes an https channel webhook and nothing else', () => {
+    expect(noticeChannels({ [NOTICE_TEAMS_CHANNEL]: 'not a url' }).teamsChannelWebhook).toBeUndefined()
+  })
+
+  test('there is no Teams to each person - a per-person webhook is not read', () => {
+    expect(noticeChannels({ 'Notice::teamsWebhook': 'https://x.example/hook' })).toEqual({ email: false, teamsChannelWebhook: undefined })
+  })
+
+  test('a person reads their language; a person without one reads the default', () => {
+    expect(languageOf('ko-KR', 'en')).toBe('ko')
+    expect(languageOf('zh_CN', 'en')).toBe('zh')
+    expect(languageOf(null, 'ko-KR')).toBe('ko')
+    expect(languageOf(undefined, undefined)).toBe('en')
+  })
+})
+
+describe('delivering a notice', () => {
+  test('in the app and by web push, to each person alone, with nothing else turned on', async () => {
+    const { channels, calls } = fakeChannels({})
+    const result = await deliverNotice(notice(), channels)
+
+    expect(calls.push.map(p => [p.receivers, p.mode])).toEqual([
+      [['u-kim'], 'foreground'],
+      [['u-kim'], 'background'],
+      [['u-lee'], 'foreground'],
+      [['u-lee'], 'background']
+    ])
+    expect(calls.push[0]).toMatchObject({ type: 'approval', subject: 'info', title: 'ko: subject', body: 'ko: body', url: 'activity-approval/a-1' })
+    expect(calls.mail).toEqual([])
+    expect(calls.teams).toEqual([])
+    expect(result).toEqual({ receivers: 2, email: { sent: 0, failed: 0 }, teams: { sent: 0, failed: 0 } })
+  })
+
+  test('by mail too when the domain turned it on, each in the person’s language - a notice to some people never goes to Teams', async () => {
+    const { channels, calls } = fakeChannels(ALL_ON)
+    const result = await deliverNotice(notice(), channels)
+
+    expect(calls.mail.map(m => [m.receiver, m.subject])).toEqual([
+      ['kim@example.com', 'ko: subject'],
+      ['lee@example.com', 'en: subject']
+    ])
+    expect(calls.mail[0].content).toContain('href="https://office.example.com/domain/hatiolab/activity-approval/a-1"')
+    expect(calls.teams).toEqual([])
+    expect(result).toEqual({ receivers: 2, email: { sent: 2, failed: 0 }, teams: { sent: 0, failed: 0 } })
+  })
+
+  test('a sender that says no mail for this notice is heard; it cannot turn on what the domain has not', async () => {
+    const off = fakeChannels(ALL_ON)
+    await deliverNotice(notice({ channels: { email: false } }), off.channels)
+    expect(off.calls.mail).toEqual([])
+
+    const notOn = fakeChannels({})
+    await deliverNotice(notice({ channels: { email: true, teams: true } }), notOn.channels)
+    expect(notOn.calls.mail).toEqual([])
+    expect(notOn.calls.teams).toEqual([])
+  })
+
+  test('a person with no address gets the app and push only', async () => {
+    const { channels, calls } = fakeChannels(ALL_ON)
+    await deliverNotice(notice({ receivers: [{ id: 'u-park', email: null }] }), channels)
+
+    expect(calls.push).toHaveLength(2)
+    expect(calls.mail).toEqual([])
+    expect(calls.teams).toEqual([])
+  })
+
+  test('a failing channel is reported by name and the others still go - nothing throws', async () => {
+    const { channels, calls } = fakeChannels(ALL_ON, {
+      push: () => {
+        throw new Error('fcm down')
+      },
+      mail: async () => undefined,
+      teams: async () => {
+        throw new Error('teams down')
+      }
+    })
+
+    const result = await deliverNotice(notice({ broadcast: true }), channels)
+
+    expect(result).toEqual({ receivers: 2, email: { sent: 0, failed: 2 }, teams: { sent: 0, failed: 1 } })
+    expect(calls.reports.filter(r => r.includes('foreground notice'))).toHaveLength(2)
+    expect(calls.reports.filter(r => r.includes('did not go out'))).toHaveLength(2)
+    expect(calls.reports.filter(r => r.includes('Teams channel post'))).toHaveLength(1)
+  })
+
+  test('Teams answering no is a failure', async () => {
+    const { channels, calls } = fakeChannels(ALL_ON, { teams: async () => ({ ok: false, status: 400 }) })
+    const result = await deliverNotice(notice({ broadcast: true }), channels)
+
+    expect(result.teams).toEqual({ sent: 0, failed: 1 })
+    expect(calls.reports.some(r => r.includes('(400)'))).toBe(true)
+  })
+
+  test('channels that cannot be read leave the app and push', async () => {
+    const { channels, calls } = fakeChannels({}, {
+      attributes: async () => {
+        throw new Error('db')
+      }
+    })
+    await deliverNotice(notice(), channels)
+
+    expect(calls.push).toHaveLength(4)
+    expect(calls.mail).toEqual([])
+    expect(calls.reports[0]).toContain('could not be read')
+  })
+
+  test('no receivers, nothing sent', async () => {
+    const { channels, calls } = fakeChannels(ALL_ON)
+    await deliverNotice(notice({ receivers: [] }), channels)
+
+    expect(calls.push).toEqual([])
+    expect(calls.mail).toEqual([])
+  })
+})
+
+describe('what a notice carries', () => {
+  const words = { subject: '[결재 요청] <b>A&B</b>', body: 'line "one"\nline two', action: '열기', note: '결재함에서 확인' }
+
+  test('the mail shows values as text', () => {
+    const html = noticeEmailForm({ lang: 'ko', words, link: 'https://x.example/a?b=1&c="2"' })
+
+    expect(html).toContain('&lt;b&gt;A&amp;B&lt;/b&gt;')
+    expect(html).not.toContain('<b>A&B</b>')
+    expect(html).toContain('href="https://x.example/a?b=1&amp;c=&quot;2&quot;"')
+    expect(escapeHtml(`'`)).toBe('&#39;')
+  })
+
+  test('with no link the mail shows the note instead of a button', () => {
+    const html = noticeEmailForm({ lang: 'ko', words })
+
+    expect(html).not.toContain('href=')
+    expect(html).toContain('결재함에서 확인')
+  })
+
+  test('the Teams message is one Adaptive Card for the channel, the link as its action', () => {
+    const message = teamsMessage({ words, link: 'https://x.example/a' })
+
+    expect(message).toMatchObject({ type: 'message', summary: words.subject })
+    expect(message).not.toHaveProperty('recipient')
+    expect(message.attachments).toHaveLength(1)
+    expect(message.attachments[0].contentType).toBe('application/vnd.microsoft.card.adaptive')
+    expect(message.attachments[0].content.actions).toEqual([{ type: 'Action.OpenUrl', title: '열기', url: 'https://x.example/a' }])
+
+    const noLink = teamsMessage({ words })
+    expect(noLink.attachments[0].content.actions).toEqual([])
+    expect(noLink.attachments[0].content.body[1].text).toContain('결재함에서 확인')
+  })
+})
+
+describe('a Markdown body in the mail (an announcement)', () => {
+  const BASE = 'https://office.example.com/domain/hatiolab/'
+
+  test('it is rendered as mail HTML', () => {
+    const html = renderNoticeMarkdown('# Title\n\n**bold** and a list:\n\n- one\n- two', BASE)
+
+    expect(html).toContain('<h1>Title</h1>')
+    expect(html).toContain('<strong>bold</strong>')
+    expect(html).toContain('<li>one</li>')
+  })
+
+  test('raw HTML is shown as text, never as markup', () => {
+    const html = renderNoticeMarkdown('<script>alert(1)</script>\n\nhi <img src=x onerror=alert(1)> <b>b</b>', BASE)
+
+    expect(html).not.toMatch(/<script|<img|<b>/)
+    expect(html).toContain('&lt;script&gt;')
+  })
+
+  test('links go to http(s), mailto and app addresses only', () => {
+    expect(safeNoticeHref('https://hatiolab.com/a', BASE)).toBe('https://hatiolab.com/a')
+    expect(safeNoticeHref('mailto:hr@hatiolab.com', BASE)).toBe('mailto:hr@hatiolab.com')
+    expect(safeNoticeHref('announcement-view?id=1', BASE)).toBe(`${BASE}announcement-view?id=1`)
+
+    for (const bad of ['javascript:alert(1)', ' JaVaScRiPt:alert(1)', 'java\tscript:alert(1)', 'data:text/html,<b>x</b>', 'vbscript:x', 'file:///etc/passwd']) {
+      expect(safeNoticeHref(bad, BASE)).toBeUndefined()
+    }
+  })
+
+  test('an app address has nowhere to go without the domain’s address', () => {
+    expect(safeNoticeHref('announcement-view?id=1')).toBeUndefined()
+    expect(safeNoticeHref('https://hatiolab.com/a')).toBe('https://hatiolab.com/a')
+  })
+
+  test('a link that is not allowed keeps its text and loses its address; an image is a link, never loaded', () => {
+    const html = renderNoticeMarkdown('[click](javascript:alert(1)) [form](announcement-view?id=1) ![logo](https://cdn.example.com/l.png)', BASE)
+
+    expect(html).not.toContain('javascript:')
+    expect(html).toContain('click')
+    expect(html).toContain(`<a href="${BASE}announcement-view?id=1">form</a>`)
+    expect(html).not.toContain('<img')
+    expect(html).toContain('<a href="https://cdn.example.com/l.png">logo</a>')
+  })
+
+  test('the mail renders a Markdown notice; push shows the summary; the type stays as given', async () => {
+    const { channels, calls } = fakeChannels({ [NOTICE_EMAIL]: 'on' })
+    await deliverNotice(
+      notice({
+        type: 'announcement',
+        format: 'markdown',
+        address: 'announcement-view?id=n-1',
+        link: 'https://office.example.com/domain/hatiolab/announcement-view?id=n-1',
+        receivers: [{ id: 'u-kim', email: 'kim@example.com' }],
+        words: () => ({ subject: '공지', body: '**휴무** 안내 [규정](rules-view?id=r-1)', summary: '휴무 안내', action: '열기', note: '' })
+      }),
+      channels
+    )
+
+    expect(calls.push.map(p => [p.type, p.body])).toEqual([
+      ['announcement', '휴무 안내'],
+      ['announcement', '휴무 안내']
+    ])
+    expect(calls.mail[0].content).toContain('<strong>휴무</strong>')
+    expect(calls.mail[0].content).toContain('<a href="https://office.example.com/domain/hatiolab/rules-view?id=r-1">규정</a>')
+  })
+
+  test('a text notice stays text in the mail', async () => {
+    const { channels, calls } = fakeChannels({ [NOTICE_EMAIL]: 'on' })
+    await deliverNotice(notice({ receivers: [{ id: 'u-kim', email: 'kim@example.com' }], words: () => ({ subject: 's', body: '**not bold**', action: 'a', note: '' }) }), channels)
+
+    expect(calls.mail[0].content).toContain('**not bold**')
+    expect(calls.push[0].body).toBe('**not bold**')
+  })
+})
+
+describe('a notice to everyone in the domain (broadcast)', () => {
+  const CHANNEL = 'https://prod.example.logic.azure.com/workflows/channel'
+  const BOTH = { [NOTICE_EMAIL]: 'on', [NOTICE_TEAMS_CHANNEL]: CHANNEL }
+
+  test('Teams posts once to the channel, in the default language, with no recipient; push and mail still go to each person', async () => {
+    const { channels, calls } = fakeChannels(BOTH)
+    const result = await deliverNotice(notice({ broadcast: true, defaultLanguage: 'ko-KR' }), channels)
+
+    expect(calls.teams).toHaveLength(1)
+    expect(calls.teams[0].url).toBe(CHANNEL)
+    expect(calls.teams[0].body).not.toHaveProperty('recipient')
+    expect(calls.teams[0].body.summary).toBe('ko: subject')
+    expect(calls.teams[0].body.attachments[0].content.actions[0].url).toBe(notice().link)
+    expect(calls.push).toHaveLength(4)
+    expect(calls.mail).toHaveLength(2)
+    expect(result).toEqual({ receivers: 2, email: { sent: 2, failed: 0 }, teams: { sent: 1, failed: 0 } })
+  })
+
+  test('a broadcast needs the channel webhook', async () => {
+    const { channels, calls } = fakeChannels({ 'Notice::teamsWebhook': 'https://prod.example.logic.azure.com/workflows/person' })
+    const result = await deliverNotice(notice({ broadcast: true }), channels)
+
+    expect(calls.teams).toEqual([])
+    expect(result.teams).toEqual({ sent: 0, failed: 0 })
+  })
+
+  test('a notice to some people never goes to the channel', async () => {
+    const { channels, calls } = fakeChannels(BOTH)
+    await deliverNotice(notice(), channels)
+
+    expect(calls.teams).toEqual([])
+  })
+
+  test('a sender that says no Teams stops the channel post too', async () => {
+    const { channels, calls } = fakeChannels(BOTH)
+    await deliverNotice(notice({ broadcast: true, channels: { teams: false } }), channels)
+
+    expect(calls.teams).toEqual([])
+  })
+
+  test('the channel webhook must be https', () => {
+    expect(noticeChannels({ [NOTICE_TEAMS_CHANNEL]: 'http://x.example/hook' }).teamsChannelWebhook).toBeUndefined()
+    expect(noticeChannels({ [NOTICE_TEAMS_CHANNEL]: ' https://x.example/hook ' }).teamsChannelWebhook).toBe('https://x.example/hook')
+  })
+
+  test('a refused or failed channel post counts one failure and is reported', async () => {
+    const refused = fakeChannels({ [NOTICE_TEAMS_CHANNEL]: CHANNEL }, { teams: async () => ({ ok: false, status: 429 }) })
+    expect((await deliverNotice(notice({ broadcast: true }), refused.channels)).teams).toEqual({ sent: 0, failed: 1 })
+    expect(refused.calls.reports.some(r => r.includes('channel post (429)'))).toBe(true)
+
+    const thrown = fakeChannels({ [NOTICE_TEAMS_CHANNEL]: CHANNEL }, { teams: async () => { throw new Error('down') } })
+    expect((await deliverNotice(notice({ broadcast: true }), thrown.channels)).teams).toEqual({ sent: 0, failed: 1 })
+  })
+})

package/tests/open-doors.test.ts

@@ -7,7 +7,10 @@
 import { gatesOf, openFields } from '../../../test/helpers/open-doors'
 
 /** The category each mutation asks for; anything not named here asks for `notification-rule`. */
-const CATEGORY: Record<string, string> = {}
+const CATEGORY: Record<string, string> = {
+  /* the notice channels are domain attributes (EnvVar) - the EnvVar screen's privilege opens them (ADR-0164) */
+  updateNoticeChannelSetting: 'env-var'
+}
 
 /*
  * A notification is one person's inbox entry, so a privilege category is not what guards it: these doors
@@ -50,5 +53,5 @@ it('every declared mutation asks for its category and admits the domain owner',
 
 it('the walk reaches every mutation', () => {
   /* If the resolver list shrank, the checks above would pass by having nothing to look at. */
-  expect(Object.keys(gates.Mutation)).toHaveLength(11)
+  expect(Object.keys(gates.Mutation)).toHaveLength(12)
 })

package/tests/store-once.test.ts

@@ -0,0 +1,88 @@
+/*
+ * A notice is kept once in the inbox however many tabs of the app received it (client/store-once.ts).
+ *
+ * The tabs share one IndexedDB store and each receives the published notice. The fake store yields between reading and
+ * writing, as IndexedDB does, so tabs that do not take turns all read "not kept yet" and all write.
+ */
+import { NOTICE_STORE_LOCK, sameNotice, storeOnce, type NoticeLocks, type NoticeStore } from '../client/store-once'
+
+const tick = () => new Promise(resolve => setTimeout(resolve, 0))
+
+function sharedStore(): NoticeStore & { rows: any[] } {
+  const rows: any[] = []
+  return {
+    rows,
+    getAll: async () => {
+      await tick()
+      return [...rows]
+    },
+    add: async notice => {
+      await tick()
+      rows.push(notice)
+    },
+    limit: async () => undefined
+  }
+}
+
+/** One lock per name, granted in turn - what navigator.locks does for the tabs of one origin. */
+function turnTaking(): NoticeLocks & { names: string[] } {
+  const queues = new Map<string, Promise<unknown>>()
+  const names: string[] = []
+  return {
+    names,
+    request<T>(name: string, callback: () => Promise<T>): Promise<T> {
+      names.push(name)
+      const turn = (queues.get(name) ?? Promise.resolve()).then(callback)
+      queues.set(name, turn.catch(() => undefined))
+      return turn
+    }
+  }
+}
+
+const published = { timestamp: 1793003153772, subject: 'info', type: 'approval', title: '[결재 요청] 휴가 신청', body: '…', url: 'activity-approval/a-1' }
+
+test('three tabs that received one notice keep it once', async () => {
+  const store = sharedStore()
+  const locks = turnTaking()
+
+  const kept = await Promise.all([1, 2, 3].map(() => storeOnce(store, { ...published }, locks)))
+
+  expect(store.rows).toHaveLength(1)
+  expect(kept.filter(Boolean)).toHaveLength(1)
+  expect(new Set(locks.names)).toEqual(new Set([NOTICE_STORE_LOCK]))
+})
+
+test('without taking turns the tabs keep it three times - the lock is what keeps it once', async () => {
+  const store = sharedStore()
+  const noLock: NoticeLocks = { request: (_name, callback) => callback() }
+
+  await Promise.all([1, 2, 3].map(() => storeOnce(store, { ...published }, noLock)))
+
+  expect(store.rows).toHaveLength(3)
+})
+
+test('two notices are two, even with the same words at another time', async () => {
+  const store = sharedStore()
+  const locks = turnTaking()
+
+  await storeOnce(store, published, locks)
+  await storeOnce(store, { ...published, timestamp: published.timestamp + 1 }, locks)
+  await storeOnce(store, { ...published, title: 'other' }, locks)
+
+  expect(store.rows).toHaveLength(3)
+})
+
+test('a browser without locks keeps the notice', async () => {
+  const store = sharedStore()
+
+  expect(await storeOnce(store, published, undefined)).toBe(true)
+  expect(store.rows).toEqual([published])
+})
+
+test('a notice is the same one by its time, subject, type, title, body and address', () => {
+  expect(sameNotice(published, { ...published, id: 7, __typename: 'Notification' })).toBe(true)
+  for (const field of ['timestamp', 'subject', 'type', 'title', 'body', 'url']) {
+    expect(sameNotice(published, { ...published, [field]: 'x' })).toBe(false)
+  }
+  expect(sameNotice(published, undefined)).toBe(false)
+})

package/translations/en.json

@@ -30,5 +30,14 @@
   "title.notification-rule list": "notification rules",
   "title.notification-sender": "notification sender",
   "task.notification.rules.name": "Changing notification rules",
-  "task.notification.rules.description": "Changes who is told of what."
+  "task.notification.rules.description": "Changes who is told of what.",
+  "title.notice channels": "mail · Teams notices",
+  "label.notice by email": "also send notices by mail",
+  "label.teams channel webhook": "Teams channel — announcements to everyone",
+  "text.notice webhook set": "set · {host}",
+  "text.notice webhook not set": "not set",
+  "button.notice webhook save": "save",
+  "button.notice webhook clear": "clear",
+  "text.notice channels saved": "Saved.",
+  "error.notice-webhook-not-https": "A Teams webhook address starts with https://"
 }

package/translations/es.json

@@ -30,5 +30,14 @@
   "title.notification-rule list": "reglas de notificación",
   "title.notification-sender": "remitente de notificaciones",
   "task.notification.rules.name": "Cambiar reglas de notificación",
-  "task.notification.rules.description": "Cambia a quién se avisa de qué."
+  "task.notification.rules.description": "Cambia a quién se avisa de qué.",
+  "title.notice channels": "avisos por correo · Teams",
+  "label.notice by email": "enviar también los avisos por correo",
+  "label.teams channel webhook": "Canal de Teams — anuncios para todos",
+  "text.notice webhook set": "configurado · {host}",
+  "text.notice webhook not set": "sin configurar",
+  "button.notice webhook save": "guardar",
+  "button.notice webhook clear": "borrar",
+  "text.notice channels saved": "Guardado.",
+  "error.notice-webhook-not-https": "La dirección del webhook de Teams debe empezar por https://"
 }

package/translations/ja.json

@@ -30,5 +30,14 @@
   "title.notification-rule list": "通知ルール",
   "title.notification-sender": "通知送信",
   "task.notification.rules.name": "通知ルールの変更",
-  "task.notification.rules.description": "誰に何を知らせるかを変更する。"
+  "task.notification.rules.description": "誰に何を知らせるかを変更する。",
+  "title.notice channels": "メール · Teams 通知",
+  "label.notice by email": "通知をメールでも送る",
+  "label.teams channel webhook": "Teams チャネル — 全社へのお知らせ",
+  "text.notice webhook set": "設定済み · {host}",
+  "text.notice webhook not set": "未設定",
+  "button.notice webhook save": "保存",
+  "button.notice webhook clear": "削除",
+  "text.notice channels saved": "保存しました。",
+  "error.notice-webhook-not-https": "Teams の Webhook アドレスは https:// で始まる必要があります。"
 }

package/translations/ko.json

@@ -30,5 +30,14 @@
   "title.notification-rule list": "알림 규칙",
   "title.notification-sender": "알림 전송",
   "task.notification.rules.name": "알림 규칙 바꾸기",
-  "task.notification.rules.description": "누구에게 무엇을 알릴지 바꾼다."
+  "task.notification.rules.description": "누구에게 무엇을 알릴지 바꾼다.",
+  "title.notice channels": "메일 · Teams 알림",
+  "label.notice by email": "알림을 메일로도 보내기",
+  "label.teams channel webhook": "Teams 채널 — 사업장 전체 공지",
+  "text.notice webhook set": "설정됨 · {host}",
+  "text.notice webhook not set": "설정 안 됨",
+  "button.notice webhook save": "저장",
+  "button.notice webhook clear": "지우기",
+  "text.notice channels saved": "저장했습니다.",
+  "error.notice-webhook-not-https": "Teams 웹후크 주소는 https:// 로 시작해야 합니다."
 }

package/translations/ms.json

@@ -30,5 +30,14 @@
   "title.notification-rule list": "peraturan pemberitahuan",
   "title.notification-sender": "pengirim pemberitahuan",
   "task.notification.rules.name": "Mengubah peraturan pemberitahuan",
-  "task.notification.rules.description": "Mengubah siapa diberitahu tentang apa."
+  "task.notification.rules.description": "Mengubah siapa diberitahu tentang apa.",
+  "title.notice channels": "notis mel · Teams",
+  "label.notice by email": "hantar notis melalui mel juga",
+  "label.teams channel webhook": "Saluran Teams — pengumuman kepada semua",
+  "text.notice webhook set": "ditetapkan · {host}",
+  "text.notice webhook not set": "tidak ditetapkan",
+  "button.notice webhook save": "simpan",
+  "button.notice webhook clear": "kosongkan",
+  "text.notice channels saved": "Disimpan.",
+  "error.notice-webhook-not-https": "Alamat webhook Teams mesti bermula dengan https://"
 }