@things-factory/notification 8.0.87 → 8.0.93

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/notification",
-  "version": "8.0.87",
+  "version": "8.0.93",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -29,16 +29,16 @@
   "dependencies": {
     "@material/web": "^2.0.0",
     "@operato/layout": "^8.0.0",
-    "@things-factory/auth-base": "^8.0.87",
-    "@things-factory/codelingua": "^8.0.87",
-    "@things-factory/i18n-base": "^8.0.87",
-    "@things-factory/organization": "^8.0.87",
-    "@things-factory/setting-base": "^8.0.87",
-    "@things-factory/shell": "^8.0.86",
+    "@things-factory/auth-base": "^8.0.93",
+    "@things-factory/codelingua": "^8.0.93",
+    "@things-factory/i18n-base": "^8.0.93",
+    "@things-factory/organization": "^8.0.93",
+    "@things-factory/setting-base": "^8.0.93",
+    "@things-factory/shell": "^8.0.93",
     "clipboard": "^2.0.6",
     "firebase": "^9.14.0",
     "firebase-admin": "^11.3.0",
     "google": "^2.1.0"
   },
-  "gitHead": "1804f2446f618e0e5a6978d35130d17e0c22375d"
+  "gitHead": "2e0834bba65b603e01fb6e966e1add625515d4af"
 }

package/server/controllers/fcm.ts

@@ -1,15 +1,25 @@
-import fetch from 'node-fetch'
+import { In } from 'typeorm'
 
 import { config, logger } from '@things-factory/env'
+import { getRepository } from '@things-factory/shell'
 
 import { initializeApp, cert } from 'firebase-admin/app'
 import { getMessaging } from 'firebase-admin/messaging'
 
+import { PushSubscription } from '../service/push-subscription/push-subscription'
+
 const notificationConfig = config.get('notification') || {}
 const { fcm, vapidKey } = notificationConfig
-const { serviceAccount, appConfig, serverKey } = fcm || {}
+const { serviceAccount, appConfig } = fcm || {}
 const { publicKey } = vapidKey || {}
 
+// FCM 전송 시 만료/무효로 판정되어 DB에서 정리할 토큰 에러 코드
+const INVALID_TOKEN_CODES = [
+  'messaging/registration-token-not-registered',
+  'messaging/invalid-registration-token',
+  'messaging/invalid-argument'
+]
+
 var messaging
 
 if (serviceAccount) {
@@ -51,103 +61,106 @@ export async function sendNotification({ receivers, message }) {
   })
 }
 
-export async function register(user, { subscription }) {
-  if (!messaging || !subscription || !user) {
+// 푸시 구독 등록: FCM 토큰을 DB에 저장 (device-group 대체). (domain, token) 기준 upsert
+export async function register(domain, user, { subscription }) {
+  if (!messaging || !subscription || !user || !domain) {
     return false
   }
 
   try {
-    var notification_key = await getDeviceGroup(user.id)
+    const repository = getRepository(PushSubscription)
+    const existing = await repository.findOneBy({ domain: { id: domain.id }, token: subscription })
 
-    if (!notification_key) {
-      await postDeviceGroup({
-        operation: 'create',
-        notification_key_name: user.id,
-        registration_ids: [subscription]
-      })
+    if (existing) {
+      // 재구독/기기 재할당: 소유 user만 갱신
+      await repository.save({ ...existing, user: { id: user.id }, updater: { id: user.id } })
     } else {
-      await postDeviceGroup({
-        operation: 'add',
-        notification_key_name: user.id,
-        notification_key,
-        registration_ids: [subscription]
+      await repository.save({
+        domain: { id: domain.id },
+        user: { id: user.id },
+        token: subscription,
+        creator: { id: user.id },
+        updater: { id: user.id }
       })
     }
 
     return true
   } catch (err) {
-    return
+    logger.error('[FCM] register 실패', err)
+    return false
   }
 }
 
-export async function unregister(user, { subscription }) {
-  if (!messaging || !subscription || !user) {
+// 푸시 구독 해제: 해당 토큰 행을 하드 삭제
+export async function unregister(domain, user, { subscription }) {
+  if (!messaging || !subscription || !user || !domain) {
     return false
   }
 
   try {
-    var notification_key = await getDeviceGroup(user.id)
-
-    if (notification_key) {
-      await postDeviceGroup({
-        operation: 'remove',
-        notification_key_name: user.id,
-        notification_key,
-        registration_ids: [subscription]
-      })
-    }
-
+    await getRepository(PushSubscription).delete({ domain: { id: domain.id }, token: subscription })
     return true
   } catch (err) {
+    logger.error('[FCM] unregister 실패', err)
+    return false
+  }
+}
+
+// 토큰 배열로 FCM HTTP v1 멀티캐스트 전송 + 무효 토큰 DB 정리
+async function sendToTokens(tokens, notification, data) {
+  if (!tokens || tokens.length === 0) {
     return
   }
+
+  // sendEachForMulticast 는 1회 최대 500토큰. 초과 시 청크 (실제 초과 도메인 생기면 대응)
+  const response = await messaging.sendEachForMulticast({ notification, data, tokens })
+  logger.info(`[FCM] sent ${response.successCount}/${tokens.length}, failed ${response.failureCount}`)
+
+  if (response.failureCount > 0) {
+    const deadTokens = []
+    response.responses.forEach((resp, idx) => {
+      if (!resp.success) {
+        const code = resp.error && resp.error.code
+        if (INVALID_TOKEN_CODES.includes(code)) {
+          deadTokens.push(tokens[idx])
+        } else {
+          // 일시적 오류 등 → 토큰 보존, 로그만
+          logger.error('[FCM] send failure (token kept):', code, resp.error && resp.error.message)
+        }
+      }
+    })
+
+    if (deadTokens.length > 0) {
+      await getRepository(PushSubscription).delete({ token: In(deadTokens) })
+      logger.warn(`[FCM] pruned ${deadTokens.length} invalid token(s)`)
+    }
+  }
+
+  return response
 }
 
 export async function notify({ receivers, privileges, tokens, topic, title, body, data, image, actions }) {
   if (!messaging) {
+    logger.error('[FCM] messaging 미초기화 → 전송 중단 (serviceAccount/FCM_PRIVATE_KEY 확인)')
     return
   }
 
-  // Caution: non-string attributes are not allowed in FCM payload validation
-  var notification = {
+  // Caution: non-string attributes are not allowed in FCM payload validation.
+  // image은 빈 문자열이면 HTTP v1이 "invalid URL"로 거부하므로 값이 있을 때만 포함
+  var notification: { title: string; body: string; image?: string } = {
     title: title || '',
-    body: body || '',
-    image: image || ''
+    body: body || ''
+  }
+  if (image) {
+    notification.image = image
   }
 
+  // 1) 명시적 토큰 전송
   if (tokens && tokens instanceof Array && tokens.length > 0) {
-    if (tokens.length > 1) {
-      const response = await messaging.sendMulticast({
-        notification,
-        data,
-        tokens
-      })
-
-      if (response.failureCount > 0) {
-        const failedTokens = []
-        response.responses.forEach((resp, idx) => {
-          if (!resp.success) {
-            failedTokens.push(tokens[idx])
-          }
-        })
-        logger.error('List of tokens that caused failures: ' + failedTokens)
-      }
-    } else {
-      const token = tokens[0]
-
-      try {
-        const response = await messaging.send({
-          notification,
-          data,
-          token
-        })
-        logger.log('Successfully sent message:', response)
-      } catch (err) {
-        logger.error('Error sending message:', err)
-      }
-    }
+    await sendToTokens(tokens, notification, data)
   }
 
+  // 2) 토픽 전송
   if (topic) {
     try {
       const response = await messaging.send({
@@ -161,54 +174,17 @@ export async function notify({ receivers, privileges, tokens, topic, title, body
     }
   }
 
-  if (receivers && receivers instanceof Array) {
-    for (let receiver of receivers) {
-      const notification_key = await getDeviceGroup(receiver)
-
-      if (notification_key) {
-        await messaging.sendToDeviceGroup(notification_key, {
-          notification,
-          data
-        })
-      }
-    }
-  }
-}
-
-async function postDeviceGroup(body) {
-  var response = await fetch('https://fcm.googleapis.com/fcm/notification', {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `key=${serverKey}`,
-      project_id: appConfig.messagingSenderId
-    },
-    body: JSON.stringify(body)
-  })
-
-  if (response.ok) {
-    const { notification_key } = await response.json()
-    return notification_key
-  } else {
-    console.error('postDeviceGroup-notok', response.status, await response.text())
-  }
-}
+  // 3) 수신자(user.id 배열) → 저장된 구독 토큰 조회 후 전송
+  if (receivers && receivers instanceof Array && receivers.length > 0) {
+    const rows = await getRepository(PushSubscription).find({
+      where: { user: { id: In(receivers) } }
+    })
+    const receiverTokens = [...new Set(rows.map(r => r.token))]
 
-async function getDeviceGroup(notificationKeyName) {
-  const response = await fetch(
-    `https://fcm.googleapis.com/fcm/notification?notification_key_name=${notificationKeyName}`,
-    {
-      method: 'GET',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `key=${serverKey}`,
-        project_id: appConfig.messagingSenderId
-      }
+    if (receiverTokens.length === 0) {
+      logger.warn('[FCM] no push subscriptions for receivers:', JSON.stringify(receivers))
+    } else {
+      await sendToTokens(receiverTokens, notification, data)
     }
-  )
-
-  if (response.ok) {
-    const { notification_key } = await response.json()
-    return notification_key
   }
 }

package/server/routers/notification-router.ts

@@ -20,16 +20,16 @@ notificationRouter.get('/config', async (context, next) => {
 })
 
 notificationRouter.post('/register', async (context, next) => {
-  const { user } = context.state
+  const { user, domain } = context.state
   const { body } = context.request
-  context.body = await register(user, body)
+  context.body = await register(domain, user, body)
   context.status = 200
 })
 
 notificationRouter.post('/unregister', async (context, next) => {
-  const { user } = context.state
+  const { user, domain } = context.state
   const { body } = context.request
-  context.body = await unregister(user, body)
+  context.body = await unregister(domain, user, body)
   context.status = 200
 })
 

package/server/service/index.ts

@@ -1,6 +1,7 @@
 /* EXPORT ENTITY TYPES */
 export * from './notification-rule/notification-rule'
 export * from './notification/notification'
+export * from './push-subscription/push-subscription'
 
 /* IMPORT ENTITIES AND RESOLVERS */
 import {
@@ -14,11 +15,13 @@ import {
   resolvers as NotificationResolvers,
   directives as NotificationDirectives
 } from './notification'
+import { entities as PushSubscriptionEntities } from './push-subscription'
 
 export const entities = [
   /* ENTITIES */
   ...NotificationRuleEntities,
-  ...NotificationEntities
+  ...NotificationEntities,
+  ...PushSubscriptionEntities
 ]
 
 export const subscribers = [

package/server/service/push-subscription/index.ts

@@ -0,0 +1,4 @@
+import { PushSubscription } from './push-subscription'
+
+export const entities = [PushSubscription]
+export const resolvers = []

package/server/service/push-subscription/push-subscription.ts

@@ -0,0 +1,70 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, ID } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+// FCM 웹 푸시 구독 토큰 저장 엔티티 (레거시 device-group 대체, HTTP v1 토큰 직접 전송용)
+@Entity()
+@Index('ix_push_subscription_0', (ps: PushSubscription) => [ps.domain, ps.token], { unique: true })
+@Index('ix_push_subscription_1', (ps: PushSubscription) => [ps.user], { unique: false })
+@ObjectType({ description: 'Entity for PushSubscription (FCM registration token)' })
+export class PushSubscription {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((ps: PushSubscription) => ps.domain)
+  domainId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  user?: User
+
+  @RelationId((ps: PushSubscription) => ps.user)
+  userId?: string
+
+  @Column()
+  @Field()
+  token: string // FCM registration token
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @DeleteDateColumn()
+  @Field({ nullable: true })
+  deletedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((ps: PushSubscription) => ps.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((ps: PushSubscription) => ps.updater)
+  updaterId?: string
+}