@cocreate/notification 1.0.0

package/src/index.js

@@ -0,0 +1,38 @@
+/********************************************************************************
+ * Copyright (C) 2023 CoCreate and Contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ ********************************************************************************/
+
+/**
+ * Commercial Licensing Information:
+ * For commercial use of this software without the copyleft provisions of the AGPLv3,
+ * you must obtain a commercial license from CoCreate LLC.
+ * For details, visit <https://cocreate.app/licenses/> or contact us at sales@cocreate.app.
+ */
+
+(function (root, factory) {
+    if (typeof define === 'function' && define.amd) {
+        define(["./client"], function (CoCreateNotification) {
+            return factory(CoCreateNotification)
+        });
+    } else if (typeof module === 'object' && module.exports) {
+        const CoCreateNotification = require("./server.js")
+        module.exports = factory(CoCreateNotification);
+    } else {
+        root.returnExports = factory(root["./client.js"]);
+    }
+}(typeof self !== 'undefined' ? self : this, function (CoCreateNotification) {
+    return CoCreateNotification;
+}));

package/src/server.js

@@ -0,0 +1,173 @@
+const crypto = require('crypto');
+const https = require('https');
+
+class CoCreateNotification {
+    constructor(crud) {
+        this.wsManager = crud.wsManager
+        this.crud = crud
+        this.newKeyMap = new Map()
+        this.subscriptions = new Map()
+        this.init();
+    }
+
+    init() {
+        if (this.wsManager) {
+            this.wsManager.on('notification.publicKey', (data) => this.publicKey(data));
+            this.wsManager.on('notification.subscription', (data) => this.subscription(data));
+            this.wsManager.on('notification.send', (data) => this.send(data));
+        }
+    }
+
+    // Function to generate VAPID keys (public and private)
+    publicKey(data) {
+        let subscription = this.subscriptions.has(data.clientId)
+        if (!subscription) {
+            let newKeys = this.generateVapidKeys()
+            this.newKeyMap.set(data.clientId, newKeys)
+            data.publicKey = newKeyMap.publicKey
+        } else {
+            data.publicKey = subscription.publicKey
+        }
+
+        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 = {}
+            }
+        }
+
+        crud.send({
+            method: 'update.object',
+            array: 'keys',
+            object: {
+                ...data.subscription,
+                ...newKeys
+            }
+        });
+
+    };
+
+    // Load the client's subscription object from storage
+    send(data) {
+        const key = crud.send({ array: 'keys', filter: { query: [{}] } });
+
+        const subscription = key.object[0]
+        if (!subscription || !subscription.privateKey)
+            return
+
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - subscription.rotateKeysIn || 90);
+
+        // Compare the modification time with the cutoff date
+        if (!this.newKeyMap.has(data.clientId) && subscription.privateKeyCreatedOn < cutoffDate) {
+            let newKeys = this.generateVapidKeys()
+            this.newKeyMap.set(data.clientId, newKeys)
+        }
+
+        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);
+
+        const options = {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.getVapidJWT(subscription.privateKey)}`,
+                'Content-Type': 'application/json',
+            },
+        };
+
+        const pushRequest = https.request(subscription.endpoint, options, (response) => {
+            console.log(`Push notification status: ${response.statusCode}`);
+        });
+
+        pushRequest.on('error', (error) => {
+            console.error('Error sending push notification:', error);
+        });
+
+        pushRequest.write(payload);
+        pushRequest.end();
+    }
+
+    generateVapidKeys() {
+        const { privateKey, publicKey } = crypto.generateKeyPairSync('rsa', {
+            modulusLength: 4096, // Choose an appropriate key length
+            privateKeyEncoding: {
+                type: 'pkcs8',
+                format: 'pem',
+            },
+            publicKeyEncoding: {
+                type: 'spki',
+                format: 'pem',
+            },
+        });
+        return { privateKey, publicKey, privateKeyCreatedOn: new Date().toISOString() };
+    }
+
+    // Function to generate a VAPID JWT
+    getVapidJWT(privateKey, subscription) {
+        const header = { 'alg': 'RS256', 'typ': 'JWT' };
+        const currentTimestamp = Math.floor(Date.now() / 1000);
+        const expirationTimeInSeconds = 90 * 24 * 60 * 60; // 90 days in seconds
+        const expirationTime = currentTimestamp + expirationTimeInSeconds;
+
+        const payload = {
+            'aud': subscription.endpoint,
+            'exp': expirationTime,
+            'sub': 'mailto:contact@cocreate.app'
+        };
+
+        const jwt = this.base64URLEncode(JSON.stringify(header)) + '.' + this.base64URLEncode(JSON.stringify(payload));
+        const signature = crypto.createSign('sha256').update(jwt).sign(privateKey, 'base64');
+        return jwt + '.' + this.base64URLEncode(signature);
+    }
+
+    // Function to base64 URL encode
+    base64URLEncode(value) {
+        return value.toString('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=/g, '');
+    }
+
+
+}
+module.exports = CoCreateNotification;
+
+const payloadExample = {
+    body: 'This is the notification body text',
+    icon: '/path/to/notification-icon.png',
+    badge: '/path/to/notification-badge.png',
+    actions: [
+        { action: 'action-1', title: 'Action 1' },
+        { action: 'action-2', title: 'Action 2' },
+    ],
+    tag: 'notification-tag', // A unique identifier for the notification
+    data,
+    vibrate: [100, 50, 100], // Vibration pattern (milliseconds)
+    image: '/path/to/notification-image.jpg', // An image to display within the notification
+    requireInteraction: true, // Requires user interaction to close the notification
+    silent: true, // Delivers a silent notification (no sound or vibration)
+    renotify: true, // Allows a notification with the same tag to renotify the user
+    actions: [
+        { action: 'action-1', title: 'Action 1' },
+        { action: 'action-2', title: 'Action 2' },
+    ],
+    timestamp: Date.now(), // A timestamp for the notification
+}
+
+

package/webpack.config.js

@@ -0,0 +1,90 @@
+const path = require("path")
+const TerserPlugin = require("terser-webpack-plugin")
+const MiniCssExtractPlugin = require("mini-css-extract-plugin")
+const { CleanWebpackPlugin } = require("clean-webpack-plugin")
+
+module.exports = (env, argv) => {
+    let isProduction = false
+    if (argv.mode === 'production')
+        isProduction = true
+
+    const config = {
+        entry: {
+            "CoCreate-notification": "./src/index.js",
+        },
+        output: {
+            path: path.resolve(__dirname, "dist"),
+            filename: isProduction ? "[name].min.js" : "[name].js",
+            libraryTarget: "umd",
+            libraryExport: "default",
+            library: ["CoCreate", "notification"],
+            globalObject: "this",
+        },
+
+        plugins: [
+            new CleanWebpackPlugin(),
+            new MiniCssExtractPlugin({
+                filename: "[name].css",
+            }),
+        ],
+        // Default mode for Webpack is production.
+        // Depending on mode Webpack will apply different things
+        // on final bundle. For now we don't need production's JavaScript
+        // minifying and other thing so let's set mode to development
+        mode: isProduction ? "production" : "development",
+        module: {
+            rules: [
+                {
+                    test: /.js$/,
+                    exclude: /(node_modules)/,
+                    use: {
+                        loader: "babel-loader",
+                        options: {
+                            plugins: ["@babel/plugin-transform-modules-commonjs"],
+                        },
+                    },
+                },
+                {
+                    test: /.css$/i,
+                    use: [
+                        { loader: "style-loader", options: { injectType: "linkTag" } },
+                        "file-loader",
+                    ],
+                },
+            ],
+        },
+
+        // add source map
+        ...(isProduction ? {} : { devtool: "eval-source-map" }),
+
+        optimization: {
+            minimize: true,
+            minimizer: [
+                new TerserPlugin({
+                    extractComments: true,
+                    // cache: true,
+                    parallel: true,
+                    // sourceMap: true, // Must be set to true if using source-maps in production
+                    terserOptions: {
+                        // https://github.com/webpack-contrib/terser-webpack-plugin#terseroptions
+                        // extractComments: 'all',
+                        compress: {
+                            drop_console: true,
+                        },
+                    },
+                }),
+            ],
+            splitChunks: {
+                chunks: "all",
+                minSize: 200,
+                // maxSize: 99999,
+                //minChunks: 1,
+
+                cacheGroups: {
+                    defaultVendors: false,
+                },
+            },
+        },
+    }
+    return config
+}