@things-factory/announcement 10.1.265 → 10.1.269

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/announcement",
-  "version": "10.1.265",
+  "version": "10.1.269",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -30,24 +30,24 @@
     "@operato/data-grist": "^10.29.69",
     "@operato/graphql": "^10.29.69",
     "@operato/i18n": "^10.0.0",
-    "@operato/input": "^10.29.43",
+    "@operato/input": "^10.29.79",
     "@operato/layout": "^10.29.49",
     "@operato/popup": "^10.29.39",
     "@operato/shell": "^10.29.69",
     "@operato/styles": "^10.29.1",
     "@operato/utils": "^10.0.0",
-    "@things-factory/ai-assistant": "^10.1.265",
-    "@things-factory/attachment-base": "^10.1.265",
-    "@things-factory/auth-base": "^10.1.265",
+    "@things-factory/ai-assistant": "^10.1.269",
+    "@things-factory/attachment-base": "^10.1.269",
+    "@things-factory/auth-base": "^10.1.269",
     "@things-factory/env": "^10.1.149",
-    "@things-factory/i18n-base": "^10.1.265",
-    "@things-factory/notification": "^10.1.265",
-    "@things-factory/organization": "^10.1.265",
-    "@things-factory/shell": "^10.1.265",
+    "@things-factory/i18n-base": "^10.1.269",
+    "@things-factory/notification": "^10.1.269",
+    "@things-factory/organization": "^10.1.269",
+    "@things-factory/shell": "^10.1.267",
     "graphql-scalars": "^1.22.0",
     "graphql-tag": "^2.12.6",
     "graphql-upload": "^15.0.2",
     "lit": "^3.1.2"
   },
-  "gitHead": "c192450de7dba8d27ec97c34e57d9b9860ebb317"
+  "gitHead": "d4fbddbb97458c60e7c32a2b3c8e4d04bab95464"
 }

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

@@ -13,7 +13,7 @@ import { In, IsNull, MoreThan, Not } from 'typeorm'
 import { Attachment, createAttachment, deleteAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
 import { getDomainAssignees, User } from '@things-factory/auth-base'
 import { audienceTargetRefusal, audienceUserIds, Department, departmentTreeOf, domainRolesOf } from '@things-factory/organization'
-import { getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { getQueryBuilderFromListParams, getRepository, ListParam, tellChange } from '@things-factory/shell'
 
 import { Announcement, AnnouncementAudience, AnnouncementImportance, AnnouncementReceipt, AnnouncementRevision, AnnouncementStatus } from './announcement'
 import { inputRefusal, isCurrent, owedReminder, periodOf, popupDue, publishedStatusOf, publishRefusal, rankOf, readerNarrowingOf, readerStateOf } from './announcement-rules'
@@ -26,6 +26,7 @@ import {
   memberOf,
   reachingIds,
   sendOut,
+  tellRosterChange,
   tellWhenCommitted,
   visibleAnnouncement
 } from './announcement-service'
@@ -243,8 +244,11 @@ export class AnnouncementResolver {
     const patch: any = {}
     if (!receipt?.readAt) patch.readAt = now
     if (acknowledge && !receipt?.acknowledgedAt) patch.acknowledgedAt = now
+    if (!Object.keys(patch).length) return visible.announcement
     if (!receipt) await repository.save({ domain, announcement: { id }, user: { id: user.id }, listed: false, ...patch, creator: user, updater: user } as any)
-    else if (Object.keys(patch).length) await repository.update(receipt.id, { ...patch, updater: user })
+    else await repository.update(receipt.id, { ...patch, updater: user })
+    /* The reader's other windows - their badge asks again. */
+    tellChange(context as any, { kind: 'announcement', id, userIds: [user.id] })
     return visible.announcement
   }
 
@@ -375,6 +379,7 @@ export class AnnouncementResolver {
     if (notifyAgain) await getRepository(AnnouncementReceipt, tx).update({ announcement: { id }, listed: true } as any, { notifiedAt: new Date() } as any)
     /* Told again, everyone hears it - the channel too; people the audience newly names are told one by one. */
     await tellWhenCommitted(context, fresh, notifyAgain ? 'changed' : 'published', receivers.filter(one => one !== user.id), !!notifyAgain)
+    await tellRosterChange(context, id, tx)
     return fresh
   }
 
@@ -395,6 +400,7 @@ export class AnnouncementResolver {
     const receivers = await sendOut(announcement, domain, user, tx)
     const fresh = (await repository.findOneBy({ id }))!
     await tellWhenCommitted(context, fresh, 'published', receivers, true)
+    await tellRosterChange(context, id, tx)
     return fresh
   }
 
@@ -408,6 +414,7 @@ export class AnnouncementResolver {
     if (!reason?.trim()) refuse(context, 'no-reason', 'say why it is withdrawn.')
     const repository = getRepository(Announcement, tx)
     await repository.update(id, { status: AnnouncementStatus.WITHDRAWN, withdrawnAt: new Date(), withdrawReason: reason.trim().slice(0, 500), updater: user } as any)
+    await tellRosterChange(context, id, tx)
     return (await repository.findOneBy({ id }))!
   }
 

package/server/service/announcement/announcement-service.ts

@@ -2,14 +2,14 @@
  * What the doors of announcements do with the database (ADR-0163 decisions 1-5): who may read one, who is on its roster,
  * sending it out, telling people of it, and publishing the scheduled ones when their start comes.
  */
-import { EntityManager, In, IsNull, LessThanOrEqual } from 'typeorm'
+import { Between, EntityManager, In, IsNull, LessThanOrEqual } from 'typeorm'
 
 import { requestHolds, User, UserStatus } from '@things-factory/auth-base'
 import { logger } from '@things-factory/env'
 import { translatorFor } from '@things-factory/i18n-base/translator'
 import { keepNoticeDelivery, noticeDeliveryOf, noticeLinkOf, sendNotice, sendNoticeWhenCommitted, type Notice } from '@things-factory/notification'
 import { audienceMemberOf, audienceUserIds, type AudienceMember } from '@things-factory/organization'
-import { Domain, getDataSource, getRepository } from '@things-factory/shell'
+import { Domain, getDataSource, getRepository, tellChange } from '@things-factory/shell'
 
 import { Announcement, AnnouncementAudience, AnnouncementReceipt, AnnouncementRevision, AnnouncementStatus } from './announcement'
 import { broadcastOf, noticeWordsOf, viewAddressOf, type NoticeKind, type Say } from './announcement-rules'
@@ -182,6 +182,16 @@ export async function tellWhenCommitted(context: any, one: Announcement, kind: N
   )
 }
 
+/**
+ * Tells everyone on its roster - those it names now and those it named before - that it changed, so their badge and
+ * list ask again (shell's myChange). No notice and no words: a notice is only for what people are to be told of.
+ * `context` is a request's, or `{ state: { domain } }` outside one.
+ */
+export async function tellRosterChange(context: any, announcementId: string, tx?: EntityManager): Promise<void> {
+  const receipts = await getRepository(AnnouncementReceipt, tx).find({ where: { announcement: { id: announcementId } } as any })
+  tellChange(context, { kind: 'announcement', id: announcementId, userIds: receipts.map(one => one.userId) })
+}
+
 /**
  * Publishes the scheduled announcements whose start has come. Each is taken by one update from SCHEDULED, so a server
  * among several that loses the race does not send it twice.
@@ -203,6 +213,7 @@ export async function publishDue(now = new Date()): Promise<number> {
       })
       if (!receivers) continue
       published++
+      await tellRosterChange({ state: { domain: one.domain } }, one.id)
       /* No request, so no address to put on a mail button - the mail says where to find it instead. */
       const people = await receiversOf(receivers)
       const broadcast = broadcastOf(await audiencesOf(one.id), one.domain?.id)
@@ -214,11 +225,33 @@ export async function publishDue(now = new Date()): Promise<number> {
   return published
 }
 
+/**
+ * Tells the rosters of the announcements whose period ended after `since` and by `now` - nothing else moves their
+ * badge then. Each server that runs it tells them; a second telling only asks the count again.
+ */
+export async function tellEnded(since: Date, now = new Date()): Promise<number> {
+  const ended = await getRepository(Announcement).find({
+    where: { status: AnnouncementStatus.PUBLISHED, endsAt: Between(new Date(since.getTime() + 1), now), deletedAt: IsNull() } as any,
+    relations: ['domain']
+  })
+  for (const one of ended) await tellRosterChange({ state: { domain: one.domain } }, one.id)
+  return ended.length
+}
+
 let timer: ReturnType<typeof setInterval> | undefined
 
-/** Looks for scheduled announcements every minute. The timer never keeps the process alive. */
+/**
+ * Every minute, publishes the scheduled announcements whose start has come and tells the rosters of those whose period
+ * ended. The timer never keeps the process alive.
+ */
 export function schedulePublishing(): void {
   if (timer) return
-  timer = setInterval(() => void publishDue().catch(error => logger.error('scheduled announcements', error)), 60 * 1000)
+  let since = new Date()
+  timer = setInterval(() => {
+    const now = new Date()
+    void publishDue(now).catch(error => logger.error('scheduled announcements', error))
+    void tellEnded(since, now).catch(error => logger.error('ended announcements', error))
+    since = now
+  }, 60 * 1000)
   timer.unref?.()
 }

package/server/service/announcement/announcement-trigger.ts

@@ -14,7 +14,7 @@ import { getRepository } from '@things-factory/shell'
 
 import { Announcement, AnnouncementAudience, AnnouncementImportance, AnnouncementReceipt, AnnouncementStatus } from './announcement'
 import { ANNOUNCEMENT_CATEGORIES, rankOf } from './announcement-rules'
-import { sendOut, tellWhenCommitted } from './announcement-service'
+import { sendOut, tellRosterChange, tellWhenCommitted } from './announcement-service'
 
 export interface AnnouncementTrigger {
   /** `compliance.regulation-adopted` - the module's name, a dot, the fact. */
@@ -106,6 +106,7 @@ export async function announce(context: any, of: AnnouncementOfTrigger): Promise
   const receivers = await sendOut(saved, domain, user, tx)
   const fresh = (await repository.findOneBy({ id: saved.id }))!
   await tellWhenCommitted(context, fresh, 'published', receivers, true)
+  await tellRosterChange(context, saved.id, tx)
   return fresh
 }
 

package/test/announcement-persistence.test.ts

@@ -297,3 +297,60 @@ describe('계기 (ADR-0163 decision 7)', () => {
     await expect(triggers.announce(txContextOf('writer'), { trigger: 'test.unknown', ...words })).rejects.toThrow(/not registered/)
   })
 })
+
+/*
+ * The badge moves by itself for everyone it concerns (2026-11-10) - without a notice to anyone. Before, only a new
+ * announcement's notice moved it, and only for those told: the person's other windows after reading, the readers
+ * after a withdrawal or a changed audience, and everyone when its period ended stayed where they were until the next
+ * sign-in.
+ */
+describe('who hears that it changed', () => {
+  const heard: any[] = []
+  beforeEach(() => {
+    heard.length = 0
+    jest.spyOn(shell.pubsub, 'publish').mockImplementation(((topic: string, payload: any) => {
+      if (topic === 'my-change' && payload.kind === 'announcement') heard.push([payload.id, [...payload.userIds].sort()])
+    }) as any)
+  })
+  afterEach(() => jest.restoreAllMocks())
+
+  const resolver = new AnnouncementResolver()
+  const sales = () => draft([{ scope: 'DEPARTMENT', targetId: departments.sales.id }, { scope: 'ROLE', targetId: hr.id }])
+
+  it('★ going out, its whole roster - the publisher too; withdrawn, the same; no notice for either but the first', async () => {
+    const one = await sales()
+    await resolver.publishAnnouncement(one.id, contextOf('writer', true))
+    await resolver.withdrawAnnouncement(one.id, '잘못 보냄', contextOf('writer', true))
+    expect(heard).toEqual([
+      [one.id, ids('writer', 'part', 'team')],
+      [one.id, ids('writer', 'part', 'team')]
+    ])
+  })
+
+  it('★ read or acknowledged, the reader alone, in each of their windows - and not again when nothing changed', async () => {
+    const one = await sales()
+    await resolver.publishAnnouncement(one.id, contextOf('writer', true))
+    heard.length = 0
+    await resolver.readAnnouncement(one.id, contextOf('part'))
+    await resolver.readAnnouncement(one.id, contextOf('part'))
+    expect(heard).toEqual([[one.id, ids('part')]])
+  })
+
+  it('★ a scheduled one going out at its start, its roster', async () => {
+    const one = await draft([{ scope: 'DEPARTMENT', targetId: departments['sales-1'].id }], { status: 'SCHEDULED', startsAt: new Date(Date.now() - 1000), publisher: people.writer })
+    await service.publishDue()
+    expect(heard).toEqual([[one.id, ids('part')]])
+  })
+
+  it('★ its period ending, its roster - once, by the minute that saw it end', async () => {
+    const one = await sales()
+    await resolver.publishAnnouncement(one.id, contextOf('writer', true))
+    const ends = new Date(Date.now() + 30 * 1000)
+    await dataSource.getRepository(Announcement).update(one.id, { endsAt: ends })
+    heard.length = 0
+    await service.tellEnded(new Date(ends.getTime() - 60 * 1000), new Date(ends.getTime() - 1))
+    expect(heard).toEqual([])
+    await service.tellEnded(new Date(ends.getTime() - 1), new Date(ends.getTime() + 60 * 1000))
+    expect(heard).toEqual([[one.id, ids('writer', 'part', 'team')]])
+  })
+})