@cocreate/notification 1.0.1 → 1.1.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+# [1.1.0](https://github.com/CoCreate-app/CoCreate-notification/compare/v1.0.1...v1.1.0) (2023-10-09)
+
+
+### Bug Fixes
+
+* generates Vapid keys per client and returns publicKey to client, the public key is used to create a subscription object and return to server ([0267c19](https://github.com/CoCreate-app/CoCreate-notification/commit/0267c1904a6e6d03c73e4c767cb39f26287776d9))
+
+
+### Features
+
+* Use subscription.endpoint to get the apikey ([5fdb66d](https://github.com/CoCreate-app/CoCreate-notification/commit/5fdb66d52ca996ca096f3c935a75bd98c812a9cc))
+
 ## [1.0.1](https://github.com/CoCreate-app/CoCreate-notification/compare/v1.0.0...v1.0.1) (2023-09-24)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/notification",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Simple HTML5 & JavaScript component add, update & remove values in element's notification from input, select or js api. Easily configured using HTML5 notification and/or JavaScript API.",
   "keywords": [
     "cocreate",

package/src/client.js

@@ -10,14 +10,9 @@ async function handlePushPermission() {
         const registration = await navigator.serviceWorker.ready;
         try {
             // Create a new subscription or retrieve the existing one
-            const existingSubscription = await registration.pushManager.getSubscription();
+            let subscription = await registration.pushManager.getSubscription();
 
-            if (existingSubscription) {
-                // Update the existing subscription if needed
-                // This might involve generating a new public key or other changes
-                // For this example, we'll assume no updates are needed
-                console.log('Subscription already exists:', existingSubscription);
-            } else {
+            if (!subscription) {
                 //TODO: getPublicKey
                 let response = await socket.send({
                     method: 'notification.publicKey',
@@ -27,31 +22,31 @@ async function handlePushPermission() {
                     return
 
                 // Create a new subscription
-                const newSubscription = await registration.pushManager.subscribe({
+                subscription = await registration.pushManager.subscribe({
                     userVisibleOnly: true,
                     applicationServerKey: response.publicKey,
                 });
 
-                await socket.send({
-                    method: 'notification.subscription',
-                    subscription: newSubscription
-                })
+            }
 
-                console.log('New subscription created:', newSubscription);
+            await socket.send({
+                method: 'notification.subscription',
+                subscription: subscription
+            })
 
-                navigator.serviceWorker.addEventListener('pushsubscriptionchange', (event) => {
-                    // Handle the subscription change here
-                    const newSubscription = event.newSubscription;
-                    const oldSubscription = event.oldSubscription;
+            console.log('New subscription created:', subscription);
 
-                    socket.send({
-                        method: 'notification.subscription',
-                        subscription: newSubscription
-                    })
+            navigator.serviceWorker.addEventListener('pushsubscriptionchange', (event) => {
+                // Handle the subscription change here
+                const newSubscription = event.newSubscription;
+                const oldSubscription = event.oldSubscription;
 
-                });
+                socket.send({
+                    method: 'notification.subscription',
+                    subscription: subscription
+                })
 
-            }
+            });
         } catch (error) {
             console.error('Error handling push subscription:', error);
         }

package/src/server.js

@@ -24,66 +24,99 @@ class CoCreateNotification {
         let subscription = this.subscriptions.has(data.clientId)
         if (!subscription) {
             // let newKeys = this.generateVapidKeys()
-            let newKeys = webpush.generateVAPIDKeys()
-
-            console.log('Before: ', newKeys.publicKey)
-            webpush.setVapidDetails(
-                'mailto:contact@cocreate.app',
-                newKeys.publicKey,
-                newKeys.privateKey
-            );
-
-            // Request a VAPID key
-            const vapidRequest = webpush.generateRequestDetails();
-            console.log('vapidRequest: ', vapidRequest)
-
-            data.publicKey = this.base64URLEncode(base64URLEncode(vapidRequest.keys.p256dh))
-            this.newKeyMap.set(data.clientId, { publicKey: data.publicKey, privateKey: this.base64URLEncode(vapidRequest.keys.auth) })
-        } else {
-            data.publicKey = subscription.publicKey
+            subscription = webpush.generateVAPIDKeys()
+            this.newKeyMap.set(data.clientId, subscription)
         }
 
-        console.log('After: ', data.publicKey)
+        console.log('subscription: ', subscription)
+
+        data.publicKey = subscription.publicKey
         if (data.socket)
             this.socket.send(data)
-
     }
 
     async subscription(data) {
         let newKeys = this.newKeyMap.get(data.clientId)
         if (newKeys) {
             this.newKeyMap.delete(data.clientId)
+
             this.subscriptions.set(data.clientId, { ...newKeys, ...data.subscription })
         } else {
             newKeys = this.subscriptions.get(data.clientId)
             if (newKeys) {
                 newKeys = { ...newKeys, ...data.subscription }
             } else {
-                newKeys = {}
+                newKeys = await this.crud.send({
+                    method: 'read.object',
+                    array: 'clients',
+                    object: {
+                        _id: data.clientId
+                    }
+                })
+                if (newKeys && newKeys.object && newKeys.object[0]) {
+                    newKeys = newKeys.object[0]
+                    newKeys = { ...newKeys, ...data.subscription }
+                    this.subscriptions.set(data.clientId, { ...newKeys, ...data.subscription })
+                } else {
+                    this.publicKey(data)
+                    this.subscription(data)
+                }
             }
-        }
 
-        crud.send({
-            method: 'update.object',
-            array: 'keys',
-            object: {
-                ...data.subscription,
-                ...newKeys
-            }
-        });
+        }
 
+        if (newKeys) {
+            let tokenOptions = {
+                vapidDetails: {
+                    subject: 'mailto:contact@cocreate.app',
+                    publicKey: newKeys.publicKey,
+                    privateKey: newKeys.privateKey
+                },
+                // Other optional options can be included here
+            };
+
+            const jwt = webpush.generateRequestDetails(data.subscription, null, tokenOptions);
+
+            this.crud.send({
+                method: 'update.object',
+                array: 'clients',
+                object: {
+                    _id: data.clientId,
+                    ...data.subscription,
+                    ...newKeys,
+                    jwt
+                },
+                upsert: true,
+                organization_id: data.organization_id
+            });
+        }
     };
 
     // Load the client's subscription object from storage
-    send(data) {
-        const key = crud.send({ array: 'keys', filter: { query: [{}] } });
-
-        const subscription = key.object[0]
+    async send(data) {
+        let subscription = this.subscriptions.get(data.clientId)
+        if (!subscription) {
+            try {
+                subscription = await this.crud.send({
+                    method: 'read.object',
+                    array: 'clients',
+                    object: {
+                        _id: data.clientId
+                    },
+                    organization_id: data.organization_id
+
+                })
+            } catch (error) {
+                console.log(error)
+            }
+            if (subscription && subscription.object && subscription.object[0])
+                subscription = subscription.object[0]
+        }
         if (!subscription || !subscription.privateKey)
             return
 
         const cutoffDate = new Date();
-        cutoffDate.setDate(cutoffDate.getDate() - subscription.rotateKeysIn || 90);
+        cutoffDate.setDate(cutoffDate.getDate() - 90);
 
         // Compare the modification time with the cutoff date
         if (!this.newKeyMap.has(data.clientId) && subscription.privateKeyCreatedOn < cutoffDate) {
@@ -94,15 +127,27 @@ class CoCreateNotification {
         if (data.payload && !data.payload.timestamp)
             data.payload.timestamp = Date.now()
 
-        let payload = { ...subscription, ...data.payload }
-        delete payload.privateKey
-        delete payload.publicKey
-        payload = JSON.stringify(payload);
+        // let payload = data.payload
+        // delete payload.privateKey
+        // delete payload.publicKey
+
+        let tokenOptions = {
+            vapidDetails: {
+                subject: 'mailto:contact@cocreate.app',
+                publicKey: subscription.publicKey,
+                privateKey: subscription.privateKey
+            },
+            // Other optional options can be included here
+        };
+
+        const jwt = webpush.generateRequestDetails(subscription.endpoint, payload, tokenOptions);
+        const apiKey = getAPIKeyForEndpoint(subscrption.endpoint);
+
 
         const options = {
             method: 'POST',
             headers: {
-                'Authorization': `Bearer ${this.getVapidJWT(subscription.privateKey)}`,
+                'Authorization': `Bearer ${apiKey || jwt.headers.Authorization}`,
                 'Content-Type': 'application/json',
             },
         };
@@ -119,6 +164,26 @@ class CoCreateNotification {
         pushRequest.end();
     }
 
+    getAPIKeyForEndpoint(endpoint) {
+        // Define the mapping of browser endpoints to API keys
+        const browserEndpointsAndAPIKeys = {
+            'https://fcm.googleapis.com/': 'yourFCMApiKey',
+            'https://updates.push.services.mozilla.com/wpush/v2/': 'yourMozillaPushServiceApiKey',
+            'https://api.push.apple.com/': 'yourAPNsApiKey', // For Safari on Mac
+            'https://api.sandbox.push.apple.com/': 'yourAPNsDevApiKey', // For Safari on iOS (Development)
+            'https://api.push.apple.com/': 'yourAPNsProdApiKey', // For Safari on iOS (Production)
+            // Add more browser endpoints and their API keys as needed
+        };
+
+        // Iterate through the keys in the mapping
+        for (const browserEndpoint of Object.keys(browserEndpointsAndAPIKeys)) {
+            if (endpoint.startsWith(browserEndpoint)) {
+                // Return the associated API key if the endpoint starts with a known browser endpoint
+                return browserEndpointsAndAPIKeys[browserEndpoint];
+            }
+        }
+    }
+
     generateVapidKeys() {
         const { privateKey, publicKey } = crypto.generateKeyPairSync('rsa', {
             modulusLength: 4096, // Choose an appropriate key length