@cocreate/socket-server 1.18.1 → 1.19.0

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+# [1.19.0](https://github.com/CoCreate-app/CoCreate-socket-server/compare/v1.18.1...v1.19.0) (2023-10-09)
+
+
+### Bug Fixes
+
+* added '@cocreate/utlis' ([cc8267a](https://github.com/CoCreate-app/CoCreate-socket-server/commit/cc8267abf7ded45033929bd4c4997eb9adc89d42))
+* handling of socket.id and clientId ([9e66f16](https://github.com/CoCreate-app/CoCreate-socket-server/commit/9e66f16f4e869e7ec29a261068fb61c46569f408))
+* Improved handling of data.sync ([190ebd6](https://github.com/CoCreate-app/CoCreate-socket-server/commit/190ebd6c10f337fbd4e8be81caba865cfffb5c0a))
+* send _id with syncMessage ([e37e2de](https://github.com/CoCreate-app/CoCreate-socket-server/commit/e37e2de8aff8945a3884c416514adc1e89fc54e2))
+* update to use data.socketId and data.clientId ([125f2be](https://github.com/CoCreate-app/CoCreate-socket-server/commit/125f2bedd6090488ae26dc2228b53bb4aa63d4ff))
+* use message_log ([d4b4c4a](https://github.com/CoCreate-app/CoCreate-socket-server/commit/d4b4c4ad2708cd61567d7172ac7bcb0635349a6a))
+
+
+### Features
+
+* Authentication happens during upgrade ([c01cb0e](https://github.com/CoCreate-app/CoCreate-socket-server/commit/c01cb0eeb5fc4e135a8d9855fbab7e8b9535423d))
+* get, set, delete socket functions ([9066911](https://github.com/CoCreate-app/CoCreate-socket-server/commit/9066911016072841cd08463c8354eeef892b41e3))
+* method sync sent to server with sync details ([3c914b7](https://github.com/CoCreate-app/CoCreate-socket-server/commit/3c914b74d720949c8ae56f3f9159041ef1d5f24f))
+* on socket connection the data is parsed from ([0b69b35](https://github.com/CoCreate-app/CoCreate-socket-server/commit/0b69b357c891da63c3e94aaca8361866f252de98))
+
 ## [1.18.1](https://github.com/CoCreate-app/CoCreate-socket-server/compare/v1.18.0...v1.18.1) (2023-09-18)
 
 

package/docs/index.html

@@ -218,7 +218,6 @@
                 </div>
             </div>
         </div>
-        <script src="/apikey.js"></script>
         <script src="https://CoCreate.app/dist/CoCreate.js"></script>
     </body>
 </html>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/socket-server",
-  "version": "1.18.1",
+  "version": "1.19.0",
   "description": "CoCreate-socket-server",
   "keywords": [
     "cocreate-socket",
@@ -40,8 +40,9 @@
   },
   "homepage": "https://cocreate.app/docs/CoCreate-socket-server",
   "dependencies": {
-    "@cocreate/config": "^1.5.1",
-    "@cocreate/uuid": "^1.7.1",
+    "@cocreate/config": "^1.5.2",
+    "@cocreate/uuid": "^1.7.2",
+    "@cocreate/utils": "^1.24.2",
     "ws": "7.5.9"
   }
 }

package/src/index.js

@@ -2,105 +2,266 @@ const WebSocket = require('ws');
 const { URL } = require("url");
 const EventEmitter = require("events").EventEmitter;
 const uid = require('@cocreate/uuid')
+const { ObjectId } = require('@cocreate/utils')
 const config = require('@cocreate/config')
 
 class SocketServer extends EventEmitter {
-    constructor(server, prefix) {
+    constructor(server) {
         super();
+        this.serverId = uid.generate(12)
         this.organizations = new Map();
         this.clients = new Map();
-        this.prefix = prefix || "ws";
+        this.sockets = new Map();
+        this.users = new Map();
+
         config({ organization_id: { prompt: 'Enter your organization_id: ' } })
 
         this.wss = new WebSocket.Server({ noServer: true });
+
         this.wss.on('headers', (headers, request) => {
             headers.push('Access-Control-Allow-Origin: *');
         });
 
+        this.wss.on('error', (error) => {
+            socket.destroy();
+        });
+
         server.on('upgrade', (request, socket, head) => {
-            if (!this.handleUpgrade(request, socket, head)) {
-                socket.destroy();
+            const self = this;
+            let organization_id = request.url.split('/')
+            organization_id = organization_id[organization_id.length - 1]
+
+            if (organization_id) {
+                this.wss.handleUpgrade(request, socket, head, function (socket) {
+                    let options = decodeURIComponent(request.headers['sec-websocket-protocol'])
+                    options = JSON.parse(options)
+
+                    socket.organization_id = organization_id
+                    socket.id = options.socketId;
+                    socket.clientId = options.clientId;
+                    socket.pathname = request.url
+                    socket.origin = request.headers.origin || request.headers.host
+
+                    if (socket.origin.startsWith('http'))
+                        socket.origin = socket.origin.replace('http', 'ws')
+
+                    socket.socketUrl = socket.origin + socket.pathname
+
+                    if (socket.origin && socket.origin !== 'null') {
+                        const url = new URL(socket.origin);
+                        socket.host = url.host || socket.origin;
+                    }
+
+                    let data = {
+                        socket,
+                        method: 'read.object',
+                        array: 'message_log',
+                        $filter: {
+                            sort: [
+                                { key: '_id', direction: 'desc' }
+                            ]
+                        },
+                        sync: true,
+                        organization_id
+                    }
+
+                    if (options.lastSynced)
+                        data.$filter.query = [
+                            { key: '_id', value: options.lastSynced, operator: '$gt' }
+                        ]
+                    else
+                        data.$filter.limit = 1
+
+                    self.emit('read.object', data);
+
+                    if (self.authenticate && options.token)
+                        self.authenticate.decodeToken(options.token).then(({ user_id, expires }) => {
+                            if (user_id) {
+                                socket.user_id = user_id;
+                                socket.expires = expires;
+                                self.emit('userStatus', { socket, method: 'userStatus', user_id, userStatus: 'on', organization_id });
+                            } else
+                                this.emit('userStatus', { socket, user_id, status: 'off', organization_id });
+
+                            self.onWebSocket(socket);
+                        })
+                    else
+                        self.onWebSocket(socket);
+                })
             }
         });
     }
 
-    handleUpgrade(req, socket, head) {
+    onWebSocket(socket) {
         const self = this;
-        // const url = new URL(req.url);
-        // const pathname = req.url;
-        const config = this.getKeyFromUrl(req.url)
-        if (config.type == this.prefix) {
-            this.wss.handleUpgrade(req, socket, head, function (socket) {
-                socket.config = config
-                self.onWebSocket(req, socket);
-            })
-            return true;
-        }
-        return false;
-    }
-
-    onWebSocket(req, socket) {
-        const self = this;
-
-        this.addClient(socket);
+        this.add(socket);
 
         socket.on('message', async (message) => {
-            self.onMessage(req, socket, message);
+            self.onMessage(socket, message);
         })
 
-        socket.on('close', function () {
-            self.removeClient(socket)
+        socket.on('close', () => {
+            self.delete(socket)
         })
 
         socket.on("error", () => {
-            self.removeClient(socket)
+            self.delete(socket)
         });
 
-        this.send(socket, { socket, method: 'connect', connectedKey: socket.config.key });
+        socket.send(JSON.stringify({ method: 'connect', connectedKey: socket.pathname }))
 
     }
 
-    addClient(socket) {
-        let organization_id = socket.config.organization_id
-        if (!this.organizations.has(organization_id))
-            this.organizations.set(organization_id, true)
-
-        let user_id = socket.config.user_id
-        let key = socket.config.key
-        let clients = this.clients.get(key);
-        if (!clients) {
-            clients = new Map();
-            this.clients.set(key, clients);
+    add(socket) {
+        let organization_id = socket.organization_id
+
+        let organization = this.organizations.get(organization_id)
+        if (!organization) {
+            organization = {
+                status: true,
+                clients: {}
+            }
+
+            this.organizations.set(organization_id, organization)
+
+            this.emit('update.object', {
+                method: 'update.object',
+                array: 'organizations',
+                object: {
+                    _id: organization_id, ['$push.activeHost']: socket.socketUrl // needs socketId
+                },
+                organization_id
+            });
+
+            this.emit('mesh.create', {
+                url: socket.socketUrl,
+                organization_id
+            });
+
+        }
+
+        if (!this.clients.has(socket.clientId)) {
+            this.clients.set(socket.clientId, []);
+            organization.clients[socket.clientId] = []
+        }
+
+        if (!this.sockets.has(socket.id)) {
+            this.sockets.set(socket.id, socket);
+            this.clients.get(socket.clientId).push(socket);
+            organization.clients[socket.clientId].push(socket)
+        }
+
+        if (socket.user_id) {
+            this.emit('userStatus', { socket, user_id: socket.user_id, userStatus: 'on', organization_id });
+
+            if (!this.users.has(socket.user_id)) {
+                this.users.set(socket.user_id, [socket])
+            } else {
+                this.users.get(socket.user_id).push(socket)
+            }
+        }
+
+    }
+
+    get(data) {
+        let sockets = []
+        if (data.broadcast !== false) {
+            let organization = this.organizations.get(data.organization_id)
+            if (organization) {
+                const clients = organization.clients
+                for (let client of Object.keys(clients)) {
+                    if (data.broadcastSender === false && client === data.clientId) continue
+
+                    if (data.broadcastClient)
+                        sockets.push(clients[client][0])
+                    else
+                        sockets.push(...clients[client])
+                }
+            } else {
+                // TODO: requires a messageQueue that expires
+                console.log('organization could not be found', data)
+            }
+        } else if (data.broadcastSender !== false) {
+            sockets.push(data.socket)
         }
-        if (!clients.has(socket))
-            clients.set(socket, true);
-        else
-            console.log('has client')
-        if (user_id)
-            this.emit('userStatus', socket, { socket, user_id, userStatus: 'on', organization_id });
+        return sockets
     }
 
-    removeClient(socket) {
-        let organization_id = socket.config.organization_id
-        let user_id = socket.config.user_id
-        let key = socket.config.key
-        let clients = this.clients.get(key);
-        clients.delete(socket);
+    delete(socket) {
+        let organization_id = socket.organization_id
+        if (this.organizations.has(organization_id)) {
+            const clients = this.organizations.get(organization_id).clients;
 
-        if (user_id)
-            this.emit('userStatus', socket, { socket, user_id, status: 'off', organization_id });
+            // Check if the client exists
+            if (clients && clients[socket.clientId]) {
+                const client = clients[socket.clientId]
 
-        if (clients.size == 0) {
-            this.organizations.delete(organization_id)
-            // this.clients.delete(key);
-            this.emit('disconnect', organization_id)
+                // Check if the socket exists in the client's sockets
+                const index = client.findIndex(item => item.id === socket.id);
+                if (index !== -1) {
+                    client.splice(index, 1);
+                }
+
+                if (!client.length) {
+                    delete clients[socket.clientId];
+                }
+
+                if (!Object.keys(clients).length) {
+                    this.organizations.delete(socket.organization_id);
+                    this.emit('update.object', {
+                        method: 'update.object',
+                        array: 'organizations',
+                        object: {
+                            _id: organization_id, ['$pull.activeHost']: socket.socketUrl
+                        },
+                        organization_id
+                    });
+
+                    this.emit('mesh.update', {
+                        url: socket.socketUrl,
+                        organization_id
+                    });
+                }
+
+            }
+        }
+
+        if (this.clients.has(socket.clientId)) {
+            const client = this.clients.get(socket.clientId)
+            const index = client.findIndex(item => item.id === socket.id);
+            if (index !== -1) {
+                client.splice(index, 1);
+            }
+
+            if (!client.length) {
+                this.clients.delete(socket.clientId);
+            }
+        }
+
+        if (this.clients.size === 0) {
+            this.organizations.delete(socket.organization_id);
         }
 
+        this.sockets.delete(socket.id);
+
+        if (socket.user_id) {
+            let sockets = this.users.get(socket.user_id)
+            if (sockets) {
+                const index = sockets.findIndex(item => item.id === socket.id);
+                if (index !== -1) {
+                    sockets.splice(index, 1);
+                }
+                if (!sockets.length) {
+                    this.users.delete(socket.user_id);
+                    this.emit('userStatus', { socket, user_id, status: 'off', organization_id });
+                }
+            }
+        }
     }
 
-    async onMessage(req, socket, message) {
+    async onMessage(socket, message) {
         try {
-            const organization_id = socket.config.organization_id
+            const organization_id = socket.organization_id
 
             this.emit("setBandwidth", {
                 type: 'in',
@@ -108,34 +269,37 @@ class SocketServer extends EventEmitter {
                 organization_id
             });
 
-            let active = this.organizations.get(organization_id)
-            if (active === false)
+            if (this.organizations.has(organization_id) && !this.organizations.get(organization_id).status)
                 return this.send({ socket, method: 'Access Denied', balance: 'Your balance has fallen bellow 0' })
 
             let data = JSON.parse(message)
-
             if (data.method) {
-                let user_id = null;
-                if (this.authenticate)
-                    user_id = await this.authenticate.decodeToken(req);
+                if (data.method === 'region.added' || data.method === 'region.removed')
+                    console.log('data.method: ', data.method)
+
+                if (socket.user_id && socket.expires && new Date().getTime() >= socket.expires) {
+                    socket.user_id = socket.expires = null
+                    this.send({ socket, method: 'updateUserStatus', userStatus: 'off', socketId: data.socketId, organization_id })
+                }
 
                 if (this.authorize) {
+                    if (!this.sockets.has(socket.id)) {
+                        if (!this.organizations.get(organization_id).status)
+                            return this.send({ socket, method: 'Access Denied', balance: 'Your balance has fallen bellow 0' })
+                    }
+
                     data.socket = socket
 
-                    data.host = this.getHost(req)
-                    const authorized = await this.authorize.check(data, user_id)
+                    const authorized = await this.authorize.check(data, socket.user_id)
                     if (authorized.storage === false) {
                         data.database = process.env.organization_id
                         data.organization_id = process.env.organization_id
 
-                        const authorized2 = await this.authorize.check(data, req, user_id)
+                        const authorized2 = await this.authorize.check(data, req, socket.user_id)
                         if (!authorized2 || authorized2.error) {
                             return this.send({ socket, method: 'Access Denied', authorized2, ...data })
                         }
                     } else if (!authorized || authorized.error) {
-                        if (!user_id)
-                            this.send({ socket, method: 'updateUserStatus', userStatus: 'off', clientId: data.clientId, organization_id })
-
                         return this.send({ socket, method: 'Access Denied', authorized, ...data })
                     }
                     // dburl is true and db does not have 'keys' array
@@ -148,15 +312,6 @@ class SocketServer extends EventEmitter {
                     if (authorized.authorized)
                         data = authorized.authorized
 
-                    if (user_id) {
-                        if (!socket.config.user_id) {
-                            socket.config.user_id = user_id
-                            this.emit('userStatus', { socket, method: 'userStatus', user_id, userStatus: 'on', organization_id });
-                        }
-                    } else {
-                        this.send({ socket, method: 'updateUserStatus', userStatus: 'off', clientId: data.clientId, organization_id })
-                    }
-
                     this.emit(data.method, data);
 
                 }
@@ -166,85 +321,77 @@ class SocketServer extends EventEmitter {
         }
     }
 
-    broadcast(data) {
-        if (!data.uid)
-            data.uid = uid.generate()
-
-        let organization_id = data.socket.config.organization_id;
-        let url = `/${this.prefix}/${organization_id}`;
-
-        let namespace = data.namespace;
-        if (namespace) {
-            url += `/${namespace}`
-        }
+    async send(data) {
+        // const socket = this.sockets.get(data.socketId)
+        const socket = data.socket
 
+        if (data.sync) {
+            if (!data.object || !data.object.length)
+                return
 
-        let rooms = data.room;
-        if (rooms) {
-            if (!rooms.isArray())
-                rooms = [rooms]
-            for (let room of rooms) {
-                let url = url;
-                url += `/${room}`;
+            for (let i = 0; i < data.object.length; i++) {
+                data.object[i].data._id = data.object[i]._id
+                data.object[i].data.sync = true
 
-                this.send(data, url)
+                const authorized = await this.authorize.check(data.object[i].data, socket.user_id)
+                if (authorized && authorized.authorized)
+                    socket.send(JSON.stringify(authorized.authorized));
+                else
+                    socket.send(JSON.stringify(data.object[i].data));
             }
         } else {
-            this.send(data, url)
-        }
-    }
+            const sent = []
+
+            const authorized = await this.authorize.check(data, socket.user_id)
+            if (authorized && authorized.authorized)
+                data = authorized.authorized
+
+            if (!data.method.startsWith('read.') || data.log) {
+                let object = { url: socket.socketUrl, data }
+                delete object.socket
+                this.emit('create.object', {
+                    method: 'create.object',
+                    array: 'message_log',
+                    object,
+                    organization_id: data.organization_id
+                });
+            }
 
-    async send(data, url) {
-        const socket = data.socket
-        delete data.socket
-
-        let clients
-        if (!url)
-            clients = new Map([[socket, true]])
-        else
-            clients = this.clients.get(url);
-
-        if (clients) {
-            for (let client of clients.keys()) {
-                if (socket != client && data.broadcast != false || socket == client && data.broadcastSender != false) {
-                    const authorized = await this.authorize.check(data, socket.config.user_id)
-                    if (authorized && authorized.authorized)
-                        data = authorized.authorized
-                    let responseData = JSON.stringify(data);
-                    client.send(responseData);
-
-                    if (socket.config && socket.config.organization_id)
-                        this.emit("setBandwidth", {
-                            type: 'out',
-                            data: responseData,
-                            organization_id: socket.config.organization_id
-                        })
-                }
+            let sockets = this.get(data);
+
+            delete data.socket
+
+            for (let i = 0; i < sockets.length; i++) {
+                const authorized = await this.authorize.check(data, sockets[i].user_id)
+                if (authorized && authorized.authorized)
+                    sockets[i].send(JSON.stringify(authorized.authorized));
+                else
+                    sockets[i].send(JSON.stringify(data));
+                sent.push(socket.clientId)
+                this.emit("setBandwidth", {
+                    type: 'out',
+                    data: authorized.authorized || data,
+                    organization_id: socket.organization_id
+                })
             }
-        }
 
+            // TODO: sent is an array of clientId's so that notification can send to subscribed clients that are not currently connected
+            this.emit("notification", { sent })
+        }
     }
 
-    getKeyFromUrl(pathname) {
-        var path = pathname.split("/");
-        var params = {
-            type: null,
-            key: pathname
+    getConfigFromUrl(pathname) {
+        const path = pathname.split("/");
+        if (path[2]) {
+            path[2] = decodeURIComponent(path[2]);
+            path[2] = JSON.parse(path[2]) || {};
         }
-        if (path.length > 0) {
-            params.type = path[1];
-            params.organization_id = path[2]
-        }
-        return params
-    }
 
-    getHost(req) {
-        if (req.headers.origin && req.headers.origin !== 'null') {
-            const url = new URL(req.headers.origin);
-            return url.host;
-        } else if (req.headers.host && req.headers.host !== 'null') {
-            return req.headers.host;
+        const config = {
+            organization_id: path[1],
+            ...path[2]
         }
+        return config
     }
 
 }

package/src/mesh.js

@@ -0,0 +1,71 @@
+const socket = require('@cocreate/socket-client')
+const crud = require('@cocreate/crud-client')
+const EventEmitter = require('events');
+const eventEmitter = new EventEmitter();
+
+
+const organizations = {}
+const urls = new Map()
+const servers = {}
+
+async function addServer(data) {
+    if (!servers[data.url])
+        servers[data.url] = { [data.serverId]: { [data.organization_id]: true } }
+    else
+        servers[data.url][data.serverId][data.organization_id] = true
+
+    // TODO: needs to get orgaizations activeRegions
+    let activeRegions = await crud.send({
+        method: 'read.object',
+        array: 'organizations',
+        object: { _id: data.organization_id },
+        organization_id: data.organization_id
+    })
+
+    console.log('mesh activeRegions: ', activeRegions)
+    // socket.send({
+    //     method: 'region.added',
+    //     host: data.url,
+    //     activeRegions: '',
+    //     serverId: data.serverId,
+    //     broadcast: false,
+    //     broadcastSender: false,
+    //     organization_id: data.organization_id
+    // })
+}
+
+function deleteServer(data) {
+    delete servers[data.url][data.serverId][data.organization_id]
+    if (!Object.keys(servers[data.url][data.serverId]).length)
+        delete servers[data.url][data.serverId]
+    if (!Object.keys(servers[data.url]).length) {
+        console.log('mesh deleteServer: ', data.url)
+
+        // socket.send({
+        //     method: 'region.removed', // delete.region
+        //     host: data.url,
+        //     serverId: data.serverId,
+        //     organization_id: data.organization_id
+        // })
+        socket.delete(data.url)
+    }
+
+}
+
+socket.listen('region.added', function (data) {
+    addServer(data)
+});
+
+socket.listen('region.removed', function (data) {
+    delete servers[data.url][data.serverId]
+    if (!Object.keys(servers[data.url]).length)
+        socket.delete(data.url)
+});
+
+eventEmitter.on('mesh.create', addServer);
+eventEmitter.on('mesh.delete', deleteServer);
+
+// eventEmitter.emit('customEvent', 'Hello, Node.js!');
+
+
+// let response = await crud.send(request)