@casual-simulation/aux-records 3.4.6-alpha.14668890889 → 3.5.0-alpha.15117651144

package/notifications/NotificationRecordsController.js

@@ -4,145 +4,135 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { PRIVATE_MARKER } from '@casual-simulation/aux-common';
+import { PRIVATE_MARKER, SUBSCRIPTION_ID_NAMESPACE, } from '@casual-simulation/aux-common';
 import { CrudRecordsController } from '../crud';
 import { getNotificationFeatures } from '../SubscriptionConfiguration';
 import { traced } from '../tracing/TracingDecorators';
 import { SpanStatusCode, trace } from '@opentelemetry/api';
 import { v7 as uuidv7, v5 as uuidv5 } from 'uuid';
-import { SUBSCRIPTION_ID_NAMESPACE } from './WebPushInterface';
 const TRACE_NAME = 'NotificationRecordsController';
 /**
  * Defines a controller that can be used to interact with NotificationRecords.
  */
 export class NotificationRecordsController extends CrudRecordsController {
     constructor(config) {
-        super(Object.assign(Object.assign({}, config), { name: 'NotificationRecordsController', resourceKind: 'notification' }));
+        super({
+            ...config,
+            name: 'NotificationRecordsController',
+            resourceKind: 'notification',
+        });
         this._pushInterface = config.pushInterface;
     }
-    getApplicationServerKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const key = this._pushInterface.getServerApplicationKey();
-                return {
-                    success: true,
-                    key,
-                };
-            }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[NotificationRecordsController] Error subscribing to notification:', err);
-                return {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
-                };
-            }
-        });
+    async getApplicationServerKey() {
+        try {
+            const key = this._pushInterface.getServerApplicationKey();
+            return {
+                success: true,
+                key,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[NotificationRecordsController] Error subscribing to notification:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     /**
      * Subscribes the user to the given notification.
      * Does nothing if the user is already subscribed.
      * @param request The request.
      */
-    subscribeToNotification(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const context = yield this.policies.constructAuthorizationContext({
-                    userId: request.userId,
-                    recordKeyOrRecordName: request.recordName,
-                });
-                if (context.success === false) {
-                    return context;
-                }
-                const recordName = context.context.recordName;
-                const userId = context.context.userId;
-                const notification = yield this.store.getItemByAddress(recordName, request.address);
-                if (!notification) {
-                    return {
-                        success: false,
-                        errorCode: 'data_not_found',
-                        errorMessage: 'Notification not found.',
-                    };
-                }
-                const authorization = yield this.policies.authorizeUserAndInstances(context.context, {
-                    action: 'subscribe',
-                    resourceKind: 'notification',
-                    resourceId: notification.address,
-                    markers: notification.markers,
-                    userId: userId,
-                    instances: request.instances,
-                });
-                if (authorization.success === false) {
-                    return authorization;
-                }
-                const metrics = yield this._checkSubscriptionMetrics('subscribe', context.context, authorization, notification);
-                if (metrics.success === false) {
-                    return metrics;
-                }
-                const pushSubscriptionId = this._getPushSubscriptionId(request.pushSubscription.endpoint);
-                yield this.store.savePushSubscription({
-                    id: pushSubscriptionId,
-                    active: true,
-                    endpoint: request.pushSubscription.endpoint,
-                    keys: request.pushSubscription.keys,
-                });
-                yield this.store.savePushSubscriptionUser({
-                    pushSubscriptionId: pushSubscriptionId,
-                    userId: userId,
-                });
-                let subscriptionId = null;
-                if (userId) {
-                    const sub = yield this.store.getSubscriptionByRecordAddressAndUserId(recordName, notification.address, userId);
-                    if (sub) {
-                        subscriptionId = sub.id;
-                    }
-                }
-                else {
-                    const sub = yield this.store.getSubscriptionByRecordAddressAndPushSubscriptionId(recordName, notification.address, pushSubscriptionId);
-                    if (sub) {
-                        subscriptionId = sub.id;
-                    }
-                }
-                if (!subscriptionId) {
-                    subscriptionId = uuidv7();
-                    yield this.store.saveSubscription({
-                        id: subscriptionId,
-                        recordName,
-                        notificationAddress: notification.address,
-                        userId: userId,
-                        pushSubscriptionId: !userId ? pushSubscriptionId : null,
-                    });
-                }
-                console.log(`[NotificationRecordsController] [userId: ${userId} pushSubscriptionId: ${pushSubscriptionId} subscriptionId: ${subscriptionId}] Subscribed to notification`);
-                return {
-                    success: true,
-                    subscriptionId,
-                };
+    async subscribeToNotification(request) {
+        try {
+            const context = await this.policies.constructAuthorizationContext({
+                userId: request.userId,
+                recordKeyOrRecordName: request.recordName,
+            });
+            if (context.success === false) {
+                return context;
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[NotificationRecordsController] Error subscribing to notification:', err);
+            const recordName = context.context.recordName;
+            const userId = context.context.userId;
+            const notification = await this.store.getItemByAddress(recordName, request.address);
+            if (!notification) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'data_not_found',
+                    errorMessage: 'Notification not found.',
                 };
             }
-        });
+            const authorization = await this.policies.authorizeUserAndInstances(context.context, {
+                action: 'subscribe',
+                resourceKind: 'notification',
+                resourceId: notification.address,
+                markers: notification.markers,
+                userId: userId,
+                instances: request.instances,
+            });
+            if (authorization.success === false) {
+                return authorization;
+            }
+            const metrics = await this._checkSubscriptionMetrics('subscribe', context.context, authorization, notification);
+            if (metrics.success === false) {
+                return metrics;
+            }
+            const pushSubscriptionId = this._getPushSubscriptionId(request.pushSubscription.endpoint);
+            await this.store.savePushSubscription({
+                id: pushSubscriptionId,
+                active: true,
+                endpoint: request.pushSubscription.endpoint,
+                keys: request.pushSubscription.keys,
+            });
+            await this.store.savePushSubscriptionUser({
+                pushSubscriptionId: pushSubscriptionId,
+                userId: userId,
+            });
+            let subscriptionId = null;
+            if (userId) {
+                const sub = await this.store.getSubscriptionByRecordAddressAndUserId(recordName, notification.address, userId);
+                if (sub) {
+                    subscriptionId = sub.id;
+                }
+            }
+            else {
+                const sub = await this.store.getSubscriptionByRecordAddressAndPushSubscriptionId(recordName, notification.address, pushSubscriptionId);
+                if (sub) {
+                    subscriptionId = sub.id;
+                }
+            }
+            if (!subscriptionId) {
+                subscriptionId = uuidv7();
+                await this.store.saveSubscription({
+                    id: subscriptionId,
+                    recordName,
+                    notificationAddress: notification.address,
+                    userId: userId,
+                    pushSubscriptionId: !userId ? pushSubscriptionId : null,
+                });
+            }
+            console.log(`[NotificationRecordsController] [userId: ${userId} pushSubscriptionId: ${pushSubscriptionId} subscriptionId: ${subscriptionId}] Subscribed to notification`);
+            return {
+                success: true,
+                subscriptionId,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[NotificationRecordsController] Error subscribing to notification:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     _getPushSubscriptionId(endpoint) {
         return uuidv5(endpoint, SUBSCRIPTION_ID_NAMESPACE);
@@ -151,144 +141,47 @@ export class NotificationRecordsController extends CrudRecordsController {
      * Unsubscribes the user from the given notification.
      * @param request The request.
      */
-    unsubscribeFromNotification(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const subscription = yield this.store.getSubscriptionById(request.subscriptionId);
-                if (!subscription) {
-                    return {
-                        success: false,
-                        errorCode: 'data_not_found',
-                        errorMessage: 'Subscription not found.',
-                    };
-                }
-                const context = yield this.policies.constructAuthorizationContext({
+    async unsubscribeFromNotification(request) {
+        try {
+            const subscription = await this.store.getSubscriptionById(request.subscriptionId);
+            if (!subscription) {
+                return {
+                    success: false,
+                    errorCode: 'data_not_found',
+                    errorMessage: 'Subscription not found.',
+                };
+            }
+            const context = await this.policies.constructAuthorizationContext({
+                userId: request.userId,
+                recordKeyOrRecordName: subscription.recordName,
+            });
+            if (context.success === false) {
+                return context;
+            }
+            let successfulAuthorization = false;
+            if (subscription.userId) {
+                const userContext = await this.policies.constructAuthorizationContext({
                     userId: request.userId,
-                    recordKeyOrRecordName: subscription.recordName,
+                    recordKeyOrRecordName: subscription.userId,
                 });
-                if (context.success === false) {
-                    return context;
-                }
-                let successfulAuthorization = false;
-                if (subscription.userId) {
-                    const userContext = yield this.policies.constructAuthorizationContext({
+                if (userContext.success === true) {
+                    const userAuthorization = await this.policies.authorizeUserAndInstances(userContext.context, {
                         userId: request.userId,
-                        recordKeyOrRecordName: subscription.userId,
-                    });
-                    if (userContext.success === true) {
-                        const userAuthorization = yield this.policies.authorizeUserAndInstances(userContext.context, {
-                            userId: request.userId,
-                            action: 'unsubscribe',
-                            resourceKind: 'notification',
-                            resourceId: subscription.id,
-                            instances: request.instances,
-                            markers: [PRIVATE_MARKER],
-                        });
-                        if (userAuthorization.success === true) {
-                            successfulAuthorization = true;
-                        }
-                    }
-                }
-                const userId = context.context.userId;
-                const recordName = context.context.recordName;
-                if (!successfulAuthorization) {
-                    const notification = yield this.store.getItemByAddress(recordName, subscription.notificationAddress);
-                    if (!notification) {
-                        return {
-                            success: false,
-                            errorCode: 'data_not_found',
-                            errorMessage: 'Notification not found.',
-                        };
-                    }
-                    const authorization = yield this.policies.authorizeUserAndInstances(context.context, {
-                        userId,
                         action: 'unsubscribe',
                         resourceKind: 'notification',
-                        resourceId: notification.address,
+                        resourceId: subscription.id,
                         instances: request.instances,
-                        markers: notification.markers,
+                        markers: [PRIVATE_MARKER],
                     });
-                    if (authorization.success === false) {
-                        return authorization;
+                    if (userAuthorization.success === true) {
+                        successfulAuthorization = true;
                     }
                 }
-                // allowed
-                yield this.store.deleteSubscription(request.subscriptionId);
-                console.log(`[NotificationRecordsController] [userId: ${userId} subscriptionId: ${request.subscriptionId}] Unsubscribed from notification`);
-                return {
-                    success: true,
-                };
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[NotificationRecordsController] Error subscribing to notification:', err);
-                return {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
-                };
-            }
-        });
-    }
-    /**
-     * Registers a push subscription for the user.
-     * This will allow the device to recieve push notifications for the user.
-     * @param request The request.
-     */
-    registerPushSubscription(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!request.userId) {
-                    return {
-                        success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
-                    };
-                }
-                const pushSubscriptionId = this._getPushSubscriptionId(request.pushSubscription.endpoint);
-                yield this.store.savePushSubscription({
-                    id: pushSubscriptionId,
-                    active: true,
-                    endpoint: request.pushSubscription.endpoint,
-                    keys: request.pushSubscription.keys,
-                });
-                yield this.store.savePushSubscriptionUser({
-                    pushSubscriptionId: pushSubscriptionId,
-                    userId: request.userId,
-                });
-                console.log(`[NotificationRecordsController] [userId: ${request.userId} pushSubscriptionId: ${pushSubscriptionId}] Registered push subscription`);
-                return {
-                    success: true,
-                };
-            }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[NotificationRecordsController] Error registering push subscription:', err);
-                return {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
-                };
-            }
-        });
-    }
-    sendNotification(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const context = yield this.policies.constructAuthorizationContext({
-                    userId: request.userId,
-                    recordKeyOrRecordName: request.recordName,
-                });
-                if (context.success === false) {
-                    return context;
-                }
-                const recordName = context.context.recordName;
-                const userId = context.context.userId;
-                const notification = yield this.store.getItemByAddress(recordName, request.address);
+            const userId = context.context.userId;
+            const recordName = context.context.recordName;
+            if (!successfulAuthorization) {
+                const notification = await this.store.getItemByAddress(recordName, subscription.notificationAddress);
                 if (!notification) {
                     return {
                         success: false,
@@ -296,264 +189,349 @@ export class NotificationRecordsController extends CrudRecordsController {
                         errorMessage: 'Notification not found.',
                     };
                 }
-                const authorization = yield this.policies.authorizeUserAndInstances(context.context, {
-                    action: 'send',
+                const authorization = await this.policies.authorizeUserAndInstances(context.context, {
+                    userId,
+                    action: 'unsubscribe',
                     resourceKind: 'notification',
                     resourceId: notification.address,
-                    markers: notification.markers,
-                    userId: userId,
                     instances: request.instances,
+                    markers: notification.markers,
                 });
                 if (authorization.success === false) {
                     return authorization;
                 }
-                const metrics = yield this._checkSubscriptionMetrics('send', context.context, authorization, notification);
-                if (metrics.success === false) {
-                    return metrics;
-                }
-                const pushSubs = yield this.store.listActivePushSubscriptionsForNotification(recordName, notification.address);
-                if (typeof metrics.features.maxSentPushNotificationsPerPeriod ===
-                    'number') {
-                    if (metrics.metrics.totalSentNotificationsInPeriod +
-                        pushSubs.length >=
-                        metrics.features.maxSentPushNotificationsPerPeriod) {
-                        return {
-                            success: false,
-                            errorCode: 'subscription_limit_reached',
-                            errorMessage: 'The maximum number of sent push notifications has been reached for this period.',
-                        };
-                    }
-                }
-                let promises = [];
-                const sentTimeMs = Date.now();
-                for (let push of pushSubs) {
-                    promises.push(this._pushInterface
-                        .sendNotification({
-                        endpoint: push.endpoint,
-                        keys: push.keys,
-                    }, request.payload, request.topic)
-                        .then((result) => {
-                        return [push, result];
-                    }));
-                }
-                const results = yield Promise.allSettled(promises);
-                const notificationId = uuidv7();
-                yield this.store.saveSentNotification({
-                    id: notificationId,
-                    recordName,
-                    notificationAddress: notification.address,
-                    title: request.payload.title,
-                    body: request.payload.body,
-                    icon: request.payload.icon,
-                    badge: request.payload.badge,
-                    defaultAction: request.payload.action,
-                    actions: request.payload.actions,
-                    silent: request.payload.silent,
-                    tag: request.payload.tag,
-                    timestamp: request.payload.timestamp,
-                    sentTimeMs: sentTimeMs,
-                    topic: request.topic,
-                });
-                let sentPushNotifications = [];
-                let failedPushSubscriptions = [];
-                for (let promiseResult of results) {
-                    if (promiseResult.status === 'rejected') {
-                        console.error('[NotificationRecordsController] Error sending notification:', promiseResult.reason);
-                    }
-                    else {
-                        const [push, result] = promiseResult.value;
-                        sentPushNotifications.push({
-                            id: uuidv7(),
-                            pushSubscriptionId: push.id,
-                            sentNotificationId: notificationId,
-                            userId: push.userId,
-                            subscriptionId: push.subscriptionId,
-                            success: result.success,
-                            errorCode: result.success === false ? result.errorCode : null,
-                        });
-                        if (result.success === false) {
-                            console.error(`[NotificationRecordsController] Error sending notification for ${push.id}:`, result.errorCode);
-                            if (result.errorCode === 'subscription_gone' ||
-                                result.errorCode === 'subscription_not_found') {
-                                failedPushSubscriptions.push(push.id);
-                            }
-                        }
-                    }
-                }
-                if (sentPushNotifications.length > 0) {
-                    yield this.store.createSentPushNotifications(sentPushNotifications);
-                }
-                if (failedPushSubscriptions.length > 0) {
-                    yield this.store.markPushSubscriptionsInactiveAndDeleteUserRelations(failedPushSubscriptions);
-                }
-                console.log(`[NotificationRecordsController] [userId: ${userId} notificationId: ${notificationId} sent: ${sentPushNotifications.length} failed: ${failedPushSubscriptions.length}] Sent notification`);
-                return {
-                    success: true,
-                };
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[NotificationRecordsController] Error sending notification:', err);
+            // allowed
+            await this.store.deleteSubscription(request.subscriptionId);
+            console.log(`[NotificationRecordsController] [userId: ${userId} subscriptionId: ${request.subscriptionId}] Unsubscribed from notification`);
+            return {
+                success: true,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[NotificationRecordsController] Error subscribing to notification:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    /**
+     * Registers a push subscription for the user.
+     * This will allow the device to recieve push notifications for the user.
+     * @param request The request.
+     */
+    async registerPushSubscription(request) {
+        try {
+            if (!request.userId) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
                 };
             }
-        });
+            const pushSubscriptionId = this._getPushSubscriptionId(request.pushSubscription.endpoint);
+            await this.store.savePushSubscription({
+                id: pushSubscriptionId,
+                active: true,
+                endpoint: request.pushSubscription.endpoint,
+                keys: request.pushSubscription.keys,
+            });
+            await this.store.savePushSubscriptionUser({
+                pushSubscriptionId: pushSubscriptionId,
+                userId: request.userId,
+            });
+            console.log(`[NotificationRecordsController] [userId: ${request.userId} pushSubscriptionId: ${pushSubscriptionId}] Registered push subscription`);
+            return {
+                success: true,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[NotificationRecordsController] Error registering push subscription:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
-    listSubscriptionsForUser(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!request.userId) {
-                    return {
-                        success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
-                    };
-                }
-                const subscriptions = yield this.store.listSubscriptionsForUser(request.userId);
-                return {
-                    success: true,
-                    subscriptions: subscriptions.map((sub) => ({
-                        id: sub.id,
-                        userId: sub.userId,
-                        recordName: sub.recordName,
-                        notificationAddress: sub.notificationAddress,
-                        pushSubscriptionId: sub.pushSubscriptionId,
-                    })),
-                };
+    async sendNotification(request) {
+        try {
+            const context = await this.policies.constructAuthorizationContext({
+                userId: request.userId,
+                recordKeyOrRecordName: request.recordName,
+            });
+            if (context.success === false) {
+                return context;
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[NotificationRecordsController] Error listing subscriptions for user:', err);
+            const recordName = context.context.recordName;
+            const userId = context.context.userId;
+            const notification = await this.store.getItemByAddress(recordName, request.address);
+            if (!notification) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'data_not_found',
+                    errorMessage: 'Notification not found.',
                 };
             }
-        });
-    }
-    listSubscriptions(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!request.userId) {
+            const authorization = await this.policies.authorizeUserAndInstances(context.context, {
+                action: 'send',
+                resourceKind: 'notification',
+                resourceId: notification.address,
+                markers: notification.markers,
+                userId: userId,
+                instances: request.instances,
+            });
+            if (authorization.success === false) {
+                return authorization;
+            }
+            const metrics = await this._checkSubscriptionMetrics('send', context.context, authorization, notification);
+            if (metrics.success === false) {
+                return metrics;
+            }
+            const pushSubs = await this.store.listActivePushSubscriptionsForNotification(recordName, notification.address);
+            if (typeof metrics.features.maxSentPushNotificationsPerPeriod ===
+                'number') {
+                if (metrics.metrics.totalSentNotificationsInPeriod +
+                    pushSubs.length >=
+                    metrics.features.maxSentPushNotificationsPerPeriod) {
                     return {
                         success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
+                        errorCode: 'subscription_limit_reached',
+                        errorMessage: 'The maximum number of sent push notifications has been reached for this period.',
                     };
                 }
-                const context = yield this.policies.constructAuthorizationContext({
-                    recordKeyOrRecordName: request.recordName,
-                    userId: request.userId,
-                });
-                if (context.success === false) {
-                    return context;
-                }
-                const recordName = context.context.recordName;
-                const notification = yield this.store.getItemByAddress(recordName, request.address);
-                if (!notification) {
-                    return {
-                        success: false,
-                        errorCode: 'data_not_found',
-                        errorMessage: 'Notification not found.',
-                    };
+            }
+            let promises = [];
+            const sentTimeMs = Date.now();
+            for (let push of pushSubs) {
+                promises.push(this._pushInterface
+                    .sendNotification({
+                    endpoint: push.endpoint,
+                    keys: push.keys,
+                }, request.payload, request.topic)
+                    .then((result) => {
+                    return [push, result];
+                }));
+            }
+            const results = await Promise.allSettled(promises);
+            const notificationId = uuidv7();
+            await this.store.saveSentNotification({
+                id: notificationId,
+                recordName,
+                notificationAddress: notification.address,
+                title: request.payload.title,
+                body: request.payload.body,
+                icon: request.payload.icon,
+                badge: request.payload.badge,
+                defaultAction: request.payload.action,
+                actions: request.payload.actions,
+                silent: request.payload.silent,
+                tag: request.payload.tag,
+                timestamp: request.payload.timestamp,
+                sentTimeMs: sentTimeMs,
+                topic: request.topic,
+            });
+            let sentPushNotifications = [];
+            let failedPushSubscriptions = [];
+            for (let promiseResult of results) {
+                if (promiseResult.status === 'rejected') {
+                    console.error('[NotificationRecordsController] Error sending notification:', promiseResult.reason);
                 }
-                const authorization = yield this.policies.authorizeUserAndInstances(context.context, {
-                    userId: request.userId,
-                    resourceKind: 'notification',
-                    markers: notification.markers,
-                    resourceId: notification.address,
-                    action: 'listSubscriptions',
-                    instances: request.instances,
-                });
-                if (authorization.success === false) {
-                    return authorization;
+                else {
+                    const [push, result] = promiseResult.value;
+                    sentPushNotifications.push({
+                        id: uuidv7(),
+                        pushSubscriptionId: push.id,
+                        sentNotificationId: notificationId,
+                        userId: push.userId,
+                        subscriptionId: push.subscriptionId,
+                        success: result.success,
+                        errorCode: result.success === false ? result.errorCode : null,
+                    });
+                    if (result.success === false) {
+                        console.error(`[NotificationRecordsController] Error sending notification for ${push.id}:`, result.errorCode);
+                        if (result.errorCode === 'subscription_gone' ||
+                            result.errorCode === 'subscription_not_found') {
+                            failedPushSubscriptions.push(push.id);
+                        }
+                    }
                 }
-                const subscriptions = yield this.store.listSubscriptionsForNotification(recordName, request.address);
-                return {
-                    success: true,
-                    subscriptions: subscriptions.map((sub) => ({
-                        id: sub.id,
-                        userId: sub.userId,
-                        recordName: sub.recordName,
-                        notificationAddress: sub.notificationAddress,
-                        pushSubscriptionId: sub.pushSubscriptionId,
-                    })),
-                };
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[NotificationRecordsController] Error listing subscriptions for notification:', err);
+            if (sentPushNotifications.length > 0) {
+                await this.store.createSentPushNotifications(sentPushNotifications);
+            }
+            if (failedPushSubscriptions.length > 0) {
+                await this.store.markPushSubscriptionsInactiveAndDeleteUserRelations(failedPushSubscriptions);
+            }
+            console.log(`[NotificationRecordsController] [userId: ${userId} notificationId: ${notificationId} sent: ${sentPushNotifications.length} failed: ${failedPushSubscriptions.length}] Sent notification`);
+            return {
+                success: true,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[NotificationRecordsController] Error sending notification:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    async listSubscriptionsForUser(request) {
+        try {
+            if (!request.userId) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
                 };
             }
-        });
+            const subscriptions = await this.store.listSubscriptionsForUser(request.userId);
+            return {
+                success: true,
+                subscriptions: subscriptions.map((sub) => ({
+                    id: sub.id,
+                    userId: sub.userId,
+                    recordName: sub.recordName,
+                    notificationAddress: sub.notificationAddress,
+                    pushSubscriptionId: sub.pushSubscriptionId,
+                })),
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[NotificationRecordsController] Error listing subscriptions for user:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
-    _checkSubscriptionMetrics(action, context, authorization, item) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const config = yield this.config.getSubscriptionConfiguration();
-            const metrics = yield this.store.getSubscriptionMetrics({
-                ownerId: context.recordOwnerId,
-                studioId: context.recordStudioId,
-            });
-            const features = getNotificationFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, metrics.subscriptionType, metrics.currentPeriodStartMs, metrics.currentPeriodEndMs);
-            if (!features.allowed) {
+    async listSubscriptions(request) {
+        try {
+            if (!request.userId) {
                 return {
                     success: false,
-                    errorCode: 'not_authorized',
-                    errorMessage: 'Notifications are not allowed for this subscription.',
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
                 };
             }
-            if (action === 'create' && typeof features.maxItems === 'number') {
-                if (metrics.totalItems >= features.maxItems) {
-                    return {
-                        success: false,
-                        errorCode: 'subscription_limit_reached',
-                        errorMessage: 'The maximum number of notification items has been reached for your subscription.',
-                    };
-                }
+            const context = await this.policies.constructAuthorizationContext({
+                recordKeyOrRecordName: request.recordName,
+                userId: request.userId,
+            });
+            if (context.success === false) {
+                return context;
             }
-            if (action === 'subscribe' &&
-                typeof features.maxSubscribersPerItem === 'number') {
-                const totalSubscriptions = yield this.store.countSubscriptionsForNotification(context.recordName, item.address);
-                if (totalSubscriptions >= features.maxSubscribersPerItem) {
-                    return {
-                        success: false,
-                        errorCode: 'subscription_limit_reached',
-                        errorMessage: 'The maximum number of subscriptions has been reached for this notification.',
-                    };
-                }
+            const recordName = context.context.recordName;
+            const notification = await this.store.getItemByAddress(recordName, request.address);
+            if (!notification) {
+                return {
+                    success: false,
+                    errorCode: 'data_not_found',
+                    errorMessage: 'Notification not found.',
+                };
             }
-            if (action === 'send') {
-                if (typeof features.maxSentNotificationsPerPeriod === 'number' &&
-                    metrics.totalSentNotificationsInPeriod >=
-                        features.maxSentNotificationsPerPeriod) {
-                    return {
-                        success: false,
-                        errorCode: 'subscription_limit_reached',
-                        errorMessage: 'The maximum number of sent notifications has been reached for this period.',
-                    };
-                }
+            const authorization = await this.policies.authorizeUserAndInstances(context.context, {
+                userId: request.userId,
+                resourceKind: 'notification',
+                markers: notification.markers,
+                resourceId: notification.address,
+                action: 'listSubscriptions',
+                instances: request.instances,
+            });
+            if (authorization.success === false) {
+                return authorization;
             }
+            const subscriptions = await this.store.listSubscriptionsForNotification(recordName, request.address);
             return {
                 success: true,
-                config,
-                metrics,
-                features,
+                subscriptions: subscriptions.map((sub) => ({
+                    id: sub.id,
+                    userId: sub.userId,
+                    recordName: sub.recordName,
+                    notificationAddress: sub.notificationAddress,
+                    pushSubscriptionId: sub.pushSubscriptionId,
+                })),
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[NotificationRecordsController] Error listing subscriptions for notification:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
             };
+        }
+    }
+    async _checkSubscriptionMetrics(action, context, authorization, item) {
+        const config = await this.config.getSubscriptionConfiguration();
+        const metrics = await this.store.getSubscriptionMetrics({
+            ownerId: context.recordOwnerId,
+            studioId: context.recordStudioId,
         });
+        const features = getNotificationFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, metrics.subscriptionType, metrics.currentPeriodStartMs, metrics.currentPeriodEndMs);
+        if (!features.allowed) {
+            return {
+                success: false,
+                errorCode: 'not_authorized',
+                errorMessage: 'Notifications are not allowed for this subscription.',
+            };
+        }
+        if (action === 'create' && typeof features.maxItems === 'number') {
+            if (metrics.totalItems >= features.maxItems) {
+                return {
+                    success: false,
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: 'The maximum number of notification items has been reached for your subscription.',
+                };
+            }
+        }
+        if (action === 'subscribe' &&
+            typeof features.maxSubscribersPerItem === 'number') {
+            const totalSubscriptions = await this.store.countSubscriptionsForNotification(context.recordName, item.address);
+            if (totalSubscriptions >= features.maxSubscribersPerItem) {
+                return {
+                    success: false,
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: 'The maximum number of subscriptions has been reached for this notification.',
+                };
+            }
+        }
+        if (action === 'send') {
+            if (typeof features.maxSentNotificationsPerPeriod === 'number' &&
+                metrics.totalSentNotificationsInPeriod >=
+                    features.maxSentNotificationsPerPeriod) {
+                return {
+                    success: false,
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: 'The maximum number of sent notifications has been reached for this period.',
+                };
+            }
+        }
+        return {
+            success: true,
+            config,
+            metrics,
+            features,
+        };
     }
 }
 __decorate([