Files
speckle-server/packages/server/modules/activitystream/services/summary.ts
T
Daniel Gak Anagrov 3ca4a11ca3 feat(notifications): basic listener structure, notification record, delayed mechanism (#5432)
* feat: basic notification listener sturcuture

* feat: clean up generated gql

* chore: edited structure

* feat: added basic repo

* feat: ported comment email to job queue

* feat: ported stream access request accepted

* feat: added notification insertion

* fix: minor typings

* feat: delayed notifications

* updated types

* feat: fixed gql

* notifications are listed

* index on notifications

* feat: while loop skiping for update locked

* delayed notification for access request

* take into account user prefrences

* on comment view, notification is marked as read

* feat: added gql notifications

* feat: avoid raising errors

* fix: error added scopes

* fix: mr comments

* fix: cursor and service method

* feat: added stronger types to notifications and versioning logic

* minor: rows updated
2025-10-06 12:19:12 +01:00

73 lines
1.9 KiB
TypeScript

import type { NotificationPublisher } from '@/modules/notifications/helpers/types'
import { NotificationType } from '@speckle/shared/notifications'
import type {
CreateActivitySummary,
GetActiveUserStreams,
GetUserStreamActivity
} from '@/modules/activitystream/domain/operations'
import type { GetStream } from '@/modules/core/domain/streams/operations'
import type { GetUser } from '@/modules/core/domain/users/operations'
export const createActivitySummaryFactory =
({
getStream,
getActivity,
getUser
}: {
getStream: GetStream
getActivity: GetUserStreamActivity
getUser: GetUser
}): CreateActivitySummary =>
async ({
userId,
streamIds,
start,
end
}: {
userId: string
streamIds: string[]
start: Date
end: Date
}) => {
const streamActivities = (
await Promise.all(
streamIds.map(async (streamId) => {
return {
stream: (await getStream({ streamId, userId })) ?? null,
activity: await getActivity(streamId, start, end, null) //userId is null for now, to not filter out any activity
}
})
)
).filter((sa) => sa.activity.length)
const user = await getUser(userId)
if (!user) return null
return {
user,
streamActivities
}
}
export const sendActivityNotificationsFactory =
({
publishNotification,
getActiveUserStreams
}: {
publishNotification: NotificationPublisher
getActiveUserStreams: GetActiveUserStreams
}) =>
async (start: Date, end: Date): Promise<void> => {
const activeUserStreams = await getActiveUserStreams(start, end)
await Promise.all(
activeUserStreams.map((userStreams) =>
publishNotification(NotificationType.ActivityDigest, {
targetUserId: userStreams.userId,
data: {
streamIds: userStreams.streamIds,
start,
end
}
})
)
)
}