@things-factory/notification 10.1.250 → 10.1.254

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/notification",
-  "version": "10.1.250",
+  "version": "10.1.254",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -30,17 +30,17 @@
     "@material/web": "^2.0.0",
     "@operato/layout": "^10.0.0",
     "@operato/styles": "^10.0.0",
-    "@things-factory/auth-base": "^10.1.250",
-    "@things-factory/email-base": "^10.1.250",
-    "@things-factory/i18n-base": "^10.1.250",
-    "@things-factory/organization": "^10.1.250",
-    "@things-factory/setting-base": "^10.1.250",
-    "@things-factory/shell": "^10.1.247",
+    "@things-factory/auth-base": "^10.1.254",
+    "@things-factory/email-base": "^10.1.254",
+    "@things-factory/i18n-base": "^10.1.254",
+    "@things-factory/organization": "^10.1.254",
+    "@things-factory/setting-base": "^10.1.254",
+    "@things-factory/shell": "^10.1.254",
     "clipboard": "^2.0.6",
     "firebase": "^9.14.0",
     "firebase-admin": "^11.3.0",
     "google": "^2.1.0",
     "marked": "^15.0.0"
   },
-  "gitHead": "4fdb6d24ef24f43d9e158d4c6d6396ad3097bb9e"
+  "gitHead": "793e2fd617db5bb917ec892e64956fb690f7e7b0"
 }

package/tests/push-tokens.test.ts

@@ -0,0 +1,190 @@
+/*
+ * Web push reaches a person at every browser that registered an FCM token for them, sent one token at a time over
+ * FCM HTTP v1. A token FCM says is gone is forgotten.
+ *
+ * Until 2026-11-05 a person was reached through a legacy FCM device group, keyed by a server key no config set and
+ * that Google shut down in 2024 - register made no group and notify found none, so web push reached no one.
+ *
+ * FCM is a fake: what it was handed is what is checked. Reads dist-server (entities need tsc's decorator metadata) -
+ * run the package's build:server first.
+ */
+import { DataSource } from 'typeorm'
+
+import { NamingStrategy, addDataSource, entities as shellEntities } from '@things-factory/shell'
+import { User, entities as authEntities } from '@things-factory/auth-base'
+import { config } from '@things-factory/env'
+
+const mockMessaging = {
+  multicasts: [] as any[],
+  answer: (tokens: string[]) => tokens.map(() => ({ success: true }) as any),
+  async sendEachForMulticast(message: any) {
+    this.multicasts.push(message)
+    const responses = this.answer(message.tokens)
+    return { responses, successCount: responses.filter(r => r.success).length, failureCount: responses.filter(r => !r.success).length }
+  },
+  async send() {
+    return 'sent'
+  }
+}
+
+jest.mock('firebase-admin/app', () => ({ initializeApp: () => ({}), cert: (account: any) => account }))
+jest.mock('firebase-admin/messaging', () => ({ getMessaging: () => mockMessaging }))
+
+let dataSource: DataSource
+let fcm: any
+let notifierOf: any
+let deliverNotice: any
+let NotificationToken: any
+let kim: User
+let lee: User
+
+const tokensOf = async (user: User) =>
+  (await dataSource.getRepository(NotificationToken).find({ where: { user: { id: user.id } } })).map((one: any) => one.token).sort()
+
+beforeAll(async () => {
+  config.set('notification', { fcm: { serviceAccount: { project_id: 'test' } } })
+  fcm = require('../dist-server/controllers/fcm.js')
+  NotificationToken = require('../dist-server/service/notification-token/notification-token.js').NotificationToken
+  notifierOf = require('../dist-server/middlewares/notification-middleware.js').notifierOf
+  deliverNotice = require('../dist-server/controllers/notice/deliver-notice.js').deliverNotice
+
+  dataSource = new DataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new NamingStrategy(),
+    entities: [...shellEntities, ...authEntities, NotificationToken],
+    logging: false
+  })
+  await dataSource.initialize()
+  addDataSource('default', dataSource)
+
+  const users = dataSource.getRepository(User)
+  kim = await users.save({ name: 'kim', username: 'kim', email: 'kim@test.com' } as any)
+  lee = await users.save({ name: 'lee', username: 'lee', email: 'lee@test.com' } as any)
+})
+
+afterAll(async () => {
+  await dataSource?.destroy()
+})
+
+beforeEach(async () => {
+  await dataSource.getRepository(NotificationToken).clear()
+  mockMessaging.multicasts = []
+  mockMessaging.answer = tokens => tokens.map(() => ({ success: true }))
+})
+
+describe('registering a browser', () => {
+  test('keeps each browser of a person, once', async () => {
+    expect(await fcm.register(kim, { subscription: 'kim-phone' })).toBe(true)
+    await fcm.register(kim, { subscription: 'kim-laptop' })
+    await fcm.register(kim, { subscription: 'kim-phone' })
+
+    expect(await tokensOf(kim)).toEqual(['kim-laptop', 'kim-phone'])
+  })
+
+  test('a browser someone else signs in on and turns notices on for moves to them', async () => {
+    await fcm.register(kim, { subscription: 'shared-tablet' })
+    await fcm.register(lee, { subscription: 'shared-tablet' })
+
+    expect(await tokensOf(kim)).toEqual([])
+    expect(await tokensOf(lee)).toEqual(['shared-tablet'])
+  })
+
+  test('turning notices off forgets the browser - only for the person holding it', async () => {
+    await fcm.register(kim, { subscription: 'kim-phone' })
+
+    await fcm.unregister(lee, { subscription: 'kim-phone' })
+    expect(await tokensOf(kim)).toEqual(['kim-phone'])
+
+    await fcm.unregister(kim, { subscription: 'kim-phone' })
+    expect(await tokensOf(kim)).toEqual([])
+  })
+})
+
+describe('pushing to people', () => {
+  test('goes to every browser of each receiver over HTTP v1, with data as strings', async () => {
+    await fcm.register(kim, { subscription: 'kim-phone' })
+    await fcm.register(kim, { subscription: 'kim-laptop' })
+    await fcm.register(lee, { subscription: 'lee-phone' })
+
+    await fcm.notify({
+      receivers: [kim.id],
+      title: '결재 차례',
+      body: '지출결의 1건',
+      data: { type: 'approval', url: 'https://office.example.com/domain/hatiolab/activity-approval/a-1', timestamp: 1, missing: undefined }
+    })
+
+    expect(mockMessaging.multicasts).toHaveLength(1)
+    const [sent] = mockMessaging.multicasts
+    expect([...sent.tokens].sort()).toEqual(['kim-laptop', 'kim-phone'])
+    expect(sent.notification).toEqual({ title: '결재 차례', body: '지출결의 1건' })
+    expect(sent.data).toEqual({ type: 'approval', url: 'https://office.example.com/domain/hatiolab/activity-approval/a-1', timestamp: '1' })
+  })
+
+  test('a person with no browser registered is not pushed to', async () => {
+    await fcm.notify({ receivers: [lee.id], title: 't', body: 'b', data: {} })
+
+    expect(mockMessaging.multicasts).toEqual([])
+  })
+
+  test('a token FCM says is gone is forgotten; one that failed for another reason is kept', async () => {
+    await fcm.register(kim, { subscription: 'kim-old-phone' })
+    await fcm.register(kim, { subscription: 'kim-phone' })
+    mockMessaging.answer = tokens =>
+      tokens.map(token =>
+        token === 'kim-old-phone'
+          ? { success: false, error: { code: 'messaging/registration-token-not-registered', message: 'gone' } }
+          : { success: false, error: { code: 'messaging/internal-error', message: 'try later' } }
+      )
+
+    await fcm.notify({ receivers: [kim.id], title: 't', body: 'b', data: {} })
+
+    expect(await tokensOf(kim)).toEqual(['kim-phone'])
+  })
+})
+
+/*
+ * The service worker that opens a web push knows no domain: a page relative to the domain resolved against it loses
+ * /domain/<x>/ and a tap lands nowhere. A notice sent with no request (a scheduled reminder) has no full link either.
+ */
+describe('the page a web push opens', () => {
+  const domain = { subdomain: 'hatiolab', extType: 'domain' }
+
+  test('a notice sent with no request opens its page within the domain, from the origin', async () => {
+    await fcm.register(kim, { subscription: 'kim-phone' })
+
+    await deliverNotice(
+      {
+        type: 'approval-overdue',
+        receivers: [{ id: kim.id }],
+        words: () => ({ subject: '늦은 결재', body: '1건' }),
+        address: 'activity-approval/a-1',
+        label: 'overdue reminder'
+      },
+      { attributes: async () => ({}), push: notifierOf(domain), mail: async () => undefined, teams: async () => ({ ok: true }), report: () => {} }
+    )
+
+    expect(mockMessaging.multicasts.map(sent => sent.data.url)).toEqual(['/domain/hatiolab/activity-approval/a-1'])
+  })
+
+  test('the open screen is told the page within its domain, as it navigates', async () => {
+    const { pubsub } = require('@things-factory/shell')
+    const published = jest.spyOn(pubsub, 'publish').mockImplementation(async () => undefined)
+
+    await notifierOf(domain)({ receivers: [kim.id], title: 't', url: 'activity-approval/a-1', mode: 'foreground' })
+
+    expect((published.mock.calls[0][1] as any).notification.url).toBe('activity-approval/a-1')
+    published.mockRestore()
+  })
+
+  test('an address with a scheme or from the origin is handed on as it is', async () => {
+    await fcm.register(kim, { subscription: 'kim-phone' })
+
+    await notifierOf(domain)({ receivers: [kim.id], title: 't', url: 'https://example.com/x' })
+    await notifierOf(domain)({ receivers: [kim.id], title: 't', url: '/domain/other/y' })
+
+    expect(mockMessaging.multicasts.map(sent => sent.data.url)).toEqual(['https://example.com/x', '/domain/other/y'])
+  })
+})