2597eb56f3
* Parse internal refs to links * Item mention notifications * Also parse item mentions as URLs * Fix subType determined by referrer item instead of referee item * Ignore subType Considering if the item that was referred to was a post or comment made the code more complex than initially necessary. For example, notifications for /notifications are deduplicated based on item id and the same item could refer to posts and comments, so to include "one of your posts" or "one of your comments" in the title would require splitting notifications based on the type of referred item. I didn't want to do this but also wanted to have consistent notification titles between push and /notifications, so I use "items" in both places now, even though I think using "items" isn't ideal from a user perspective. I think it might be confusing. * Fix rootText * Replace full links to #<id> syntax in push notifications * Refactor mention code into separate functions
399 lines
14 KiB
JavaScript
399 lines
14 KiB
JavaScript
import webPush from 'web-push'
|
|
import removeMd from 'remove-markdown'
|
|
import { USER_ID, COMMENT_DEPTH_LIMIT, FOUND_BLURBS, LOST_BLURBS } from './constants'
|
|
import { msatsToSats, numWithUnits } from './format'
|
|
import models from '@/api/models'
|
|
import { isMuted } from '@/lib/user'
|
|
|
|
const webPushEnabled = process.env.NODE_ENV === 'production' ||
|
|
(process.env.VAPID_MAILTO && process.env.NEXT_PUBLIC_VAPID_PUBKEY && process.env.VAPID_PRIVKEY)
|
|
|
|
if (webPushEnabled) {
|
|
webPush.setVapidDetails(
|
|
process.env.VAPID_MAILTO,
|
|
process.env.NEXT_PUBLIC_VAPID_PUBKEY,
|
|
process.env.VAPID_PRIVKEY
|
|
)
|
|
} else {
|
|
console.warn('VAPID_* env vars not set, skipping webPush setup')
|
|
}
|
|
|
|
const createPayload = (notification) => {
|
|
// https://web.dev/push-notifications-display-a-notification/#visual-options
|
|
let { title, body, ...options } = notification
|
|
if (body) body = removeMd(body)
|
|
return JSON.stringify({
|
|
title,
|
|
options: {
|
|
body,
|
|
timestamp: Date.now(),
|
|
icon: '/icons/icon_x96.png',
|
|
...options
|
|
}
|
|
})
|
|
}
|
|
|
|
const createUserFilter = (tag) => {
|
|
// filter users by notification settings
|
|
const tagMap = {
|
|
REPLY: 'noteAllDescendants',
|
|
MENTION: 'noteMentions',
|
|
ITEM_MENTION: 'noteItemMentions',
|
|
TIP: 'noteItemSats',
|
|
FORWARDEDTIP: 'noteForwardedSats',
|
|
REFERRAL: 'noteInvites',
|
|
INVITE: 'noteInvites',
|
|
EARN: 'noteEarning',
|
|
DEPOSIT: 'noteDeposits',
|
|
WITHDRAWAL: 'noteWithdrawals',
|
|
STREAK: 'noteCowboyHat'
|
|
}
|
|
const key = tagMap[tag.split('-')[0]]
|
|
return key ? { user: { [key]: true } } : undefined
|
|
}
|
|
|
|
const createItemUrl = async ({ id }) => {
|
|
const [rootItem] = await models.$queryRawUnsafe(
|
|
'SELECT subpath(path, -LEAST(nlevel(path), $1::INTEGER), 1)::text AS id FROM "Item" WHERE id = $2::INTEGER',
|
|
COMMENT_DEPTH_LIMIT + 1, Number(id)
|
|
)
|
|
return `/items/${rootItem.id}` + (rootItem.id !== id ? `?commentId=${id}` : '')
|
|
}
|
|
|
|
const sendNotification = (subscription, payload) => {
|
|
if (!webPushEnabled) {
|
|
console.warn('webPush not configured. skipping notification')
|
|
return
|
|
}
|
|
const { id, endpoint, p256dh, auth } = subscription
|
|
return webPush.sendNotification({ endpoint, keys: { p256dh, auth } }, payload)
|
|
.catch(async (err) => {
|
|
if (err.statusCode === 400) {
|
|
console.log('[webPush] invalid request: ', err)
|
|
} else if ([401, 403].includes(err.statusCode)) {
|
|
console.log('[webPush] auth error: ', err)
|
|
} else if (err.statusCode === 404 || err.statusCode === 410) {
|
|
console.log('[webPush] subscription has expired or is no longer valid: ', err)
|
|
const deletedSubscripton = await models.pushSubscription.delete({ where: { id } })
|
|
console.log(`[webPush] deleted subscription ${id} of user ${deletedSubscripton.userId} due to push error`)
|
|
} else if (err.statusCode === 413) {
|
|
console.log('[webPush] payload too large: ', err)
|
|
} else if (err.statusCode === 429) {
|
|
console.log('[webPush] too many requests: ', err)
|
|
} else {
|
|
console.log('[webPush] error: ', err)
|
|
}
|
|
})
|
|
}
|
|
|
|
async function sendUserNotification (userId, notification) {
|
|
try {
|
|
if (!userId) {
|
|
throw new Error('user id is required')
|
|
}
|
|
notification.data ??= {}
|
|
if (notification.item) {
|
|
notification.data.url ??= await createItemUrl(notification.item)
|
|
notification.data.itemId ??= notification.item.id
|
|
delete notification.item
|
|
}
|
|
const userFilter = createUserFilter(notification.tag)
|
|
const payload = createPayload(notification)
|
|
const subscriptions = await models.pushSubscription.findMany({
|
|
where: { userId, ...userFilter }
|
|
})
|
|
await Promise.allSettled(
|
|
subscriptions.map(subscription => sendNotification(subscription, payload))
|
|
)
|
|
} catch (err) {
|
|
console.log('[webPush] error sending user notification: ', err)
|
|
}
|
|
}
|
|
|
|
export async function replyToSubscription (subscriptionId, notification) {
|
|
try {
|
|
const payload = createPayload(notification)
|
|
const subscription = await models.pushSubscription.findUnique({ where: { id: subscriptionId } })
|
|
await sendNotification(subscription, payload)
|
|
} catch (err) {
|
|
console.log('[webPush] error sending subscription reply: ', err)
|
|
}
|
|
}
|
|
|
|
export const notifyUserSubscribers = async ({ models, item }) => {
|
|
try {
|
|
const isPost = !!item.title
|
|
const userSubsExcludingMutes = await models.$queryRawUnsafe(`
|
|
SELECT "UserSubscription"."followerId", "UserSubscription"."followeeId", users.name as "followeeName"
|
|
FROM "UserSubscription"
|
|
INNER JOIN users ON users.id = "UserSubscription"."followeeId"
|
|
WHERE "followeeId" = $1 AND ${isPost ? '"postsSubscribedAt"' : '"commentsSubscribedAt"'} IS NOT NULL
|
|
AND NOT EXISTS (SELECT 1 FROM "Mute" WHERE "Mute"."muterId" = "UserSubscription"."followerId" AND "Mute"."mutedId" = $1)
|
|
`, Number(item.userId))
|
|
const subType = isPost ? 'POST' : 'COMMENT'
|
|
const tag = `FOLLOW-${item.userId}-${subType}`
|
|
await Promise.allSettled(userSubsExcludingMutes.map(({ followerId, followeeName }) => sendUserNotification(followerId, {
|
|
title: `@${followeeName} ${isPost ? 'created a post' : 'replied to a post'}`,
|
|
body: isPost ? item.title : item.text,
|
|
item,
|
|
data: { followeeName, subType },
|
|
tag
|
|
})))
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
|
|
export const notifyTerritorySubscribers = async ({ models, item }) => {
|
|
try {
|
|
const isPost = !!item.title
|
|
const { subName } = item
|
|
|
|
// only notify on posts in subs
|
|
if (!isPost || !subName) return
|
|
|
|
const territorySubsExcludingMuted = await models.$queryRawUnsafe(`
|
|
SELECT "userId" FROM "SubSubscription"
|
|
WHERE "subName" = $1
|
|
AND NOT EXISTS (SELECT 1 FROM "Mute" m WHERE m."muterId" = "SubSubscription"."userId" AND m."mutedId" = $2)
|
|
`, subName, Number(item.userId))
|
|
|
|
const author = await models.user.findUnique({ where: { id: item.userId } })
|
|
|
|
const tag = `TERRITORY_POST-${subName}`
|
|
await Promise.allSettled(
|
|
territorySubsExcludingMuted
|
|
// don't send push notification to author itself
|
|
.filter(({ userId }) => userId !== author.id)
|
|
.map(({ userId }) =>
|
|
sendUserNotification(userId, {
|
|
title: `@${author.name} created a post in ~${subName}`,
|
|
body: item.title,
|
|
item,
|
|
data: { subName },
|
|
tag
|
|
})))
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
|
|
export const notifyItemParents = async ({ models, item, me }) => {
|
|
try {
|
|
const user = await models.user.findUnique({ where: { id: me?.id || USER_ID.anon } })
|
|
const parents = await models.$queryRawUnsafe(
|
|
'SELECT DISTINCT p."userId" FROM "Item" i JOIN "Item" p ON p.path @> i.path WHERE i.id = $1 and p."userId" <> $2 ' +
|
|
'AND NOT EXISTS (SELECT 1 FROM "Mute" m WHERE m."muterId" = p."userId" AND m."mutedId" = $2)',
|
|
Number(item.parentId), Number(user.id))
|
|
Promise.allSettled(
|
|
parents.map(({ userId }) => sendUserNotification(userId, {
|
|
title: `@${user.name} replied to you`,
|
|
body: item.text,
|
|
item,
|
|
tag: 'REPLY'
|
|
}))
|
|
)
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
|
|
export const notifyZapped = async ({ models, id }) => {
|
|
try {
|
|
const updatedItem = await models.item.findUnique({ where: { id: Number(id) } })
|
|
const forwards = await models.itemForward.findMany({ where: { itemId: Number(id) } })
|
|
const userPromises = forwards.map(fwd => models.user.findUnique({ where: { id: fwd.userId } }))
|
|
const userResults = await Promise.allSettled(userPromises)
|
|
const mappedForwards = forwards.map((fwd, index) => ({ ...fwd, user: userResults[index].value ?? null }))
|
|
let forwardedSats = 0
|
|
let forwardedUsers = ''
|
|
if (mappedForwards.length) {
|
|
forwardedSats = Math.floor(msatsToSats(updatedItem.msats) * mappedForwards.map(fwd => fwd.pct).reduce((sum, cur) => sum + cur) / 100)
|
|
forwardedUsers = mappedForwards.map(fwd => `@${fwd.user.name}`).join(', ')
|
|
}
|
|
let notificationTitle
|
|
if (updatedItem.title) {
|
|
if (forwards.length > 0) {
|
|
notificationTitle = `your post forwarded ${numWithUnits(forwardedSats)} to ${forwardedUsers}`
|
|
} else {
|
|
notificationTitle = `your post stacked ${numWithUnits(msatsToSats(updatedItem.msats))}`
|
|
}
|
|
} else {
|
|
if (forwards.length > 0) {
|
|
// I don't think this case is possible
|
|
notificationTitle = `your reply forwarded ${numWithUnits(forwardedSats)} to ${forwardedUsers}`
|
|
} else {
|
|
notificationTitle = `your reply stacked ${numWithUnits(msatsToSats(updatedItem.msats))}`
|
|
}
|
|
}
|
|
await sendUserNotification(updatedItem.userId, {
|
|
title: notificationTitle,
|
|
body: updatedItem.title ? updatedItem.title : updatedItem.text,
|
|
item: updatedItem,
|
|
tag: `TIP-${updatedItem.id}`
|
|
})
|
|
|
|
// send push notifications to forwarded recipients
|
|
if (mappedForwards.length) {
|
|
await Promise.allSettled(mappedForwards.map(forward => sendUserNotification(forward.user.id, {
|
|
title: `you were forwarded ${numWithUnits(Math.round(msatsToSats(updatedItem.msats) * forward.pct / 100))}`,
|
|
body: updatedItem.title ?? updatedItem.text,
|
|
item: updatedItem,
|
|
tag: `FORWARDEDTIP-${updatedItem.id}`
|
|
})))
|
|
}
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
|
|
export const notifyMention = async ({ models, userId, item }) => {
|
|
try {
|
|
const muted = await isMuted({ models, muterId: userId, mutedId: item.userId })
|
|
if (!muted) {
|
|
await sendUserNotification(userId, {
|
|
title: 'you were mentioned',
|
|
body: item.text,
|
|
item,
|
|
tag: 'MENTION'
|
|
})
|
|
}
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
|
|
export const notifyItemMention = async ({ models, referrerItem, refereeItem }) => {
|
|
try {
|
|
const muted = await isMuted({ models, muterId: refereeItem.userId, mutedId: referrerItem.userId })
|
|
if (!muted) {
|
|
const referrer = await models.user.findUnique({ where: { id: referrerItem.userId } })
|
|
|
|
// replace full links to #<id> syntax as rendered on site
|
|
const body = referrerItem.text.replace(new RegExp(`${process.env.NEXT_PUBLIC_URL}/items/(\\d+)`, 'gi'), '#$1')
|
|
|
|
await sendUserNotification(refereeItem.userId, {
|
|
title: `@${referrer.name} mentioned one of your items`,
|
|
body,
|
|
item: referrerItem,
|
|
tag: 'ITEM_MENTION'
|
|
})
|
|
}
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
|
|
export const notifyReferral = async (userId) => {
|
|
try {
|
|
await sendUserNotification(userId, { title: 'someone joined via one of your referral links', tag: 'REFERRAL' })
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
|
|
export const notifyInvite = async (userId) => {
|
|
try {
|
|
await sendUserNotification(userId, { title: 'your invite has been redeemed', tag: 'INVITE' })
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
|
|
export const notifyTerritoryTransfer = async ({ models, sub, to }) => {
|
|
try {
|
|
await sendUserNotification(to.id, {
|
|
title: `~${sub.name} was transferred to you`,
|
|
tag: `TERRITORY_TRANSFER-${sub.name}`
|
|
})
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
|
|
export async function notifyEarner (userId, earnings) {
|
|
const fmt = msats => numWithUnits(msatsToSats(msats, { abbreviate: false }))
|
|
|
|
const title = `you stacked ${fmt(earnings.msats)} in rewards`
|
|
const tag = 'EARN'
|
|
let body = ''
|
|
if (earnings.POST) body += `#${earnings.POST.bestRank} among posts with ${fmt(earnings.POST.msats)} in total\n`
|
|
if (earnings.COMMENT) body += `#${earnings.COMMENT.bestRank} among comments with ${fmt(earnings.COMMENT.msats)} in total\n`
|
|
if (earnings.TIP_POST) body += `#${earnings.TIP_POST.bestRank} in post zapping with ${fmt(earnings.TIP_POST.msats)} in total\n`
|
|
if (earnings.TIP_COMMENT) body += `#${earnings.TIP_COMMENT.bestRank} in comment zapping with ${fmt(earnings.TIP_COMMENT.msats)} in total`
|
|
|
|
try {
|
|
await sendUserNotification(userId, { title, tag, body })
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
|
|
export async function notifyDeposit (userId, invoice) {
|
|
try {
|
|
await sendUserNotification(userId, {
|
|
title: `${numWithUnits(msatsToSats(invoice.received_mtokens), { abbreviate: false, unitSingular: 'sat was', unitPlural: 'sats were' })} deposited in your account`,
|
|
body: invoice.comment || undefined,
|
|
tag: 'DEPOSIT',
|
|
data: { sats: msatsToSats(invoice.received_mtokens) }
|
|
})
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
|
|
export async function notifyWithdrawal (userId, wdrwl) {
|
|
try {
|
|
await sendUserNotification(userId, {
|
|
title: `${numWithUnits(msatsToSats(wdrwl.payment.mtokens), { abbreviate: false, unitSingular: 'sat was', unitPlural: 'sats were' })} withdrawn from your account`,
|
|
tag: 'WITHDRAWAL',
|
|
data: { sats: msatsToSats(wdrwl.payment.mtokens) }
|
|
})
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
|
|
export async function notifyNewStreak (userId, streak) {
|
|
const index = streak.id % FOUND_BLURBS.length
|
|
const blurb = FOUND_BLURBS[index]
|
|
|
|
try {
|
|
await sendUserNotification(userId, {
|
|
title: 'you found a cowboy hat',
|
|
body: blurb,
|
|
tag: 'STREAK-FOUND'
|
|
})
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
|
|
export async function notifyStreakLost (userId, streak) {
|
|
const index = streak.id % LOST_BLURBS.length
|
|
const blurb = LOST_BLURBS[index]
|
|
|
|
try {
|
|
await sendUserNotification(userId, {
|
|
title: 'you lost your cowboy hat',
|
|
body: blurb,
|
|
tag: 'STREAK-LOST'
|
|
})
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
|
|
export async function notifyReminder ({ userId, item, itemId }) {
|
|
try {
|
|
await sendUserNotification(userId, {
|
|
title: 'this is your requested reminder',
|
|
body: `you asked to be reminded of this ${item ? item.title ? 'post' : 'comment' : 'item'}`,
|
|
tag: `REMIND-ITEM-${item?.id ?? itemId}`,
|
|
item: item ?? { id: itemId }
|
|
})
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|