ws-stomp-server 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 mivui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,103 @@
+# ws-stomp-server
+
+[![npm version](https://img.shields.io/npm/v/ws-stomp-server.svg?style=flat-square)](https://www.npmjs.com/package/ws-stomp-server)
+[![Alt](https://img.shields.io/npm/dt/ws-stomp-server?style=flat-square)](https://npmcharts.com/compare/ws-stomp-server?minimal=true)
+![Alt](https://img.shields.io/github/license/mivui/ws-stomp-server?style=flat-square)
+
+## ws-stomp-server is a simple ws stomp server
+
+### install
+
+```shell
+npm i ws-stomp-server
+```
+
+### http
+
+```ts
+import { createServer } from 'http';
+import { Stomp } from 'ws-stomp-server';
+
+const server = createServer();
+Stomp.server(server, '/ws');
+// ws://lcalhost/ws
+```
+
+### express
+
+```ts
+import express from 'express';
+import { Stomp } from 'ws-stomp-server';
+
+const app = express();
+const server = app.listen();
+Stomp.server(server, '/ws');
+// ws://lcalhost/ws
+```
+
+### publish
+
+```ts
+import { Stomp } from 'ws-stomp-server';
+
+function publish() {
+  Stomp.publish('/example', JSON.stringify({ name: 'example' }), { token: 'example' });
+}
+```
+
+### subscribe
+
+```ts
+import { Stomp } from 'ws-stomp-server';
+
+function subscribe() {
+  Stomp.subscribe('/example', (e) => {
+    const body = e.body;
+  });
+}
+```
+
+### subscribe
+
+```ts
+import { Stomp } from 'ws-stomp-server';
+
+function unsubscribe() {
+  Stomp.unsubscribe('/example');
+}
+```
+
+### server and client
+
+### server.js
+
+```ts
+import express from 'express';
+import { Stomp } from 'ws-stomp-server';
+
+const app = express();
+app.get('/send', (req, res) => {
+  Stomp.publish('/topic/test', JSON.stringify({ name: 'hello word!' }));
+  res.status(200);
+});
+const server = app.listen(8080);
+Stomp.server(server, '/ws');
+Stomp.subscribe('/topic/test', (e) => {
+  const body = e.body;
+});
+```
+
+### browser.js
+
+```ts
+import { Client } from '@stomp/stompjs';
+
+const client = new Client({
+  brokerURL: 'ws://localhost:8080/ws',
+  onConnect: () => {
+    client.subscribe('/topic/test', (message) => console.log(message.body);
+    client.publish({ destination: '/topic/test', body: 'First Message' });
+  },
+});
+client.activate();
+```

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+import { Server } from 'http';
+import { Server as Server$1 } from 'https';
+
+declare enum StompCommand {
+    PING = "PING",
+    CONNECT = "CONNECT",
+    CONNECTED = "CONNECTED",
+    SEND = "SEND",
+    SUBSCRIBE = "SUBSCRIBE",
+    UNSUBSCRIBE = "UNSUBSCRIBE",
+    ACK = "ACK",
+    NACK = "NACK",
+    BEGIN = "BEGIN",
+    COMMIT = "COMMIT",
+    ABORT = "ABORT",
+    DISCONNECT = "DISCONNECT",
+    MESSAGE = "MESSAGE",
+    RECEIPT = "RECEIPT",
+    ERROR = "ERROR"
+}
+declare class StompFrame {
+    readonly command: StompCommand;
+    readonly headers: Record<string, string>;
+    readonly body: string;
+    constructor(command: StompCommand, headers?: Record<string, string>, body?: string);
+    serialize(): string;
+    static parse(data: Buffer): StompFrame;
+}
+
+interface AuthProvider {
+    authenticate: (frame: StompFrame) => Promise<boolean> | boolean;
+}
+
+declare class Stomp {
+    private constructor();
+    static server(server: Server | Server$1, path: string, authProvider?: AuthProvider): void;
+    private static get;
+    static publish(destination: string, body: string, headers?: Record<string, string>): void;
+    static subscribe(destination: string, callback: (frame: StompFrame) => void): void;
+    static unsubscribe(destination: string): void;
+}
+
+export { Stomp };

package/dist/index.js

@@ -0,0 +1,263 @@
+import { v4 } from 'uuid';
+import WebSocket, { WebSocketServer } from 'ws';
+
+class Autowired {
+    constructor() { }
+    static container = {};
+    static register(name, instance) {
+        this.container[name] = instance;
+    }
+    static get(name) {
+        return this.container[name];
+    }
+}
+
+var StompCommand;
+(function (StompCommand) {
+    StompCommand["PING"] = "PING";
+    StompCommand["CONNECT"] = "CONNECT";
+    StompCommand["CONNECTED"] = "CONNECTED";
+    StompCommand["SEND"] = "SEND";
+    StompCommand["SUBSCRIBE"] = "SUBSCRIBE";
+    StompCommand["UNSUBSCRIBE"] = "UNSUBSCRIBE";
+    StompCommand["ACK"] = "ACK";
+    StompCommand["NACK"] = "NACK";
+    StompCommand["BEGIN"] = "BEGIN";
+    StompCommand["COMMIT"] = "COMMIT";
+    StompCommand["ABORT"] = "ABORT";
+    StompCommand["DISCONNECT"] = "DISCONNECT";
+    StompCommand["MESSAGE"] = "MESSAGE";
+    StompCommand["RECEIPT"] = "RECEIPT";
+    StompCommand["ERROR"] = "ERROR";
+})(StompCommand || (StompCommand = {}));
+const BYTE = {
+    // LINEFEED byte (octet 10)
+    LF: '\x0A',
+    // NULL byte (octet 0)
+    NULL: '\x00',
+};
+class StompFrame {
+    command;
+    headers = {};
+    body = '';
+    constructor(command, headers = {}, body = '') {
+        this.command = command;
+        this.headers = headers;
+        this.body = body;
+    }
+    // 序列化为STOMP协议字符串
+    serialize() {
+        let output = `${this.command}${BYTE.LF}`;
+        for (const [key, value] of Object.entries(this.headers)) {
+            output += `${key}:${value}${BYTE.LF}`;
+        }
+        output += `${BYTE.LF}${this.body}${BYTE.NULL}`;
+        return output;
+    }
+    // 解析原始数据为STOMP帧
+    static parse(data) {
+        const frame = data.toString();
+        if (frame === BYTE.LF) {
+            return new StompFrame(StompCommand.PING);
+        }
+        const lines = frame.split(BYTE.LF);
+        let command = '';
+        const headers = {};
+        let body = '';
+        let inHeaderSection = true;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (i === 0 && !line.endsWith(BYTE.NULL)) {
+                // 首行为命令行
+                command = line;
+            }
+            else if (!line || line === '') {
+                inHeaderSection = false; // 开始进入 body
+            }
+            else if (inHeaderSection) {
+                const [key, value] = line.split(':', 2);
+                if (key !== undefined && value !== undefined) {
+                    headers[key.trim()] = value.trim();
+                }
+            }
+            else {
+                body += `${line}\n`; // 注意这里可能需要处理最后多出的一个换行
+            }
+            // 如果遇到 \0，则说明是最后一个字符
+            if (line.includes(BYTE.NULL)) {
+                break;
+            }
+        }
+        body = body ? body.slice(0, -1).replace(/\x00/g, '') : ''; //处理body数据
+        return new StompFrame(command, headers, body);
+    }
+}
+
+class StompServer {
+    ws;
+    subscribeClients = []; //已订阅的客户端
+    subscribehandler = new Map(); //服务端订阅处理
+    authProvider;
+    constructor(options) {
+        const { server, path, authProvider } = options;
+        this.authProvider = authProvider;
+        this.ws = new WebSocketServer({ server, path });
+        this.ws.on('connection', (ws) => {
+            ws.on('message', (data) => {
+                this.handleMessage(data, ws);
+            });
+            ws.on('close', () => {
+                this.cleanupSubscriptions(ws);
+            });
+        });
+    }
+    static server(options) {
+        return new StompServer(options);
+    }
+    async handleMessage(data, ws) {
+        try {
+            const frame = StompFrame.parse(data);
+            // console.log(frame);
+            switch (frame.command) {
+                case StompCommand.CONNECT:
+                    await this.handleConnect(frame, ws);
+                    break;
+                case StompCommand.SEND:
+                    this.handleSend(frame, ws);
+                    break;
+                case StompCommand.SUBSCRIBE:
+                    this.handleSubscribe(frame, ws);
+                    break;
+                case StompCommand.UNSUBSCRIBE:
+                    this.handleUnsubscribe(frame, ws);
+                    break;
+                case StompCommand.DISCONNECT:
+                    this.handleDisconnect(ws);
+                    break;
+                case StompCommand.PING: {
+                    this.cleanupWebsockets();
+                    const timer = setTimeout(() => {
+                        clearTimeout(timer);
+                        ws.ping();
+                        ws.send(BYTE.LF);
+                    }, 1000);
+                    // console.log('ping');
+                    break;
+                }
+                case StompCommand.ACK:
+                case StompCommand.NACK:
+                    break;
+                default:
+                    this.sendError(ws, `Unsupported command: ${frame.command}`);
+            }
+        }
+        catch (error) {
+            console.log(error);
+            this.sendError(ws, 'Invalid frame format');
+        }
+    }
+    async handleConnect(frame, ws) {
+        // 认证检查（如果启用）
+        if (this.authProvider && !(await this.authProvider.authenticate(frame))) {
+            this.sendError(ws, 'Authentication failed');
+            ws.close();
+            return;
+        }
+        const heartBeat = frame.headers['heart-beat'] || '0,0';
+        const connectedFrame = new StompFrame(StompCommand.CONNECTED, {
+            version: '1.2',
+            'heart-beat': heartBeat,
+        });
+        ws.send(connectedFrame.serialize());
+    }
+    handleSend(frame, _ws) {
+        const { destination } = frame.headers;
+        this.subscribehandler.forEach((callback, key) => {
+            if (destination === key) {
+                callback(frame);
+            }
+        });
+    }
+    handleSubscribe(frame, ws) {
+        const subId = frame.headers.id;
+        const { destination } = frame.headers;
+        if (!subId || !destination) {
+            this.sendError(ws, 'Missing subscription headers');
+            return;
+        }
+        this.subscribeClients.push({
+            id: subId,
+            destination,
+            ws,
+        });
+    }
+    handleUnsubscribe(frame, ws) {
+        const subId = frame.headers.id;
+        this.subscribeClients = this.subscribeClients.filter((sub) => !(sub.id === subId && sub.ws === ws));
+    }
+    handleDisconnect(ws) {
+        this.cleanupSubscriptions(ws);
+        ws.close();
+    }
+    // 清理断开连接的订阅
+    cleanupSubscriptions(ws) {
+        this.subscribeClients = this.subscribeClients.filter((sub) => sub.ws !== ws);
+    }
+    // 清理断开连接的WebSocket
+    cleanupWebsockets() {
+        this.subscribeClients = this.subscribeClients.filter((sub) => sub.ws.readyState === WebSocket.OPEN);
+    }
+    // 服务端主动发送消息
+    send(destination, body, headers = {}) {
+        const subs = this.subscribeClients.filter((sub) => sub.destination === destination);
+        if (subs.length) {
+            subs.forEach((sub) => {
+                const frame = new StompFrame(StompCommand.MESSAGE, {
+                    destination,
+                    'message-id': v4(),
+                    timestamp: `${Date.now()}`,
+                    subscription: sub.id,
+                    ...headers,
+                }, body);
+                if (sub.ws.readyState === WebSocket.OPEN) {
+                    sub.ws.send(frame.serialize());
+                }
+            });
+            return;
+        }
+        console.log(`${destination} unsubscribed client!`);
+    }
+    subscribe(destination, callback) {
+        this.subscribehandler.set(destination, callback);
+    }
+    unsubscribe(destination) {
+        this.subscribehandler.delete(destination);
+    }
+    sendError(ws, message) {
+        const errorFrame = new StompFrame(StompCommand.ERROR, { 'content-type': 'text/plain' }, message);
+        ws.send(errorFrame.serialize());
+    }
+}
+
+const className = 'stompServer';
+class Stomp {
+    constructor() { }
+    static server(server, path, authProvider) {
+        const stomp = StompServer.server({ server, path, authProvider });
+        Autowired.register(className, stomp);
+    }
+    static get() {
+        return Autowired.get(className);
+    }
+    static publish(destination, body, headers = {}) {
+        this.get()?.send(destination, body, headers);
+    }
+    static subscribe(destination, callback) {
+        this.get()?.subscribe(destination, callback);
+    }
+    static unsubscribe(destination) {
+        this.get()?.unsubscribe(destination);
+    }
+}
+
+export { Stomp };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "ws-stomp-server",
+  "version": "1.0.0",
+  "description": "ws-stomp-server",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "vitest",
+    "eslint": "eslint --fix **/*.{ts,js}",
+    "rollup": "rollup -c rollup.config.js",
+    "build": "npm run rollup"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": "./*"
+  },
+  "dependencies": {
+    "uuid": "^13.0.0",
+    "ws": "^8.19.0",
+    "@types/ws": "^8.18.1"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@types/node": "^25.0.3",
+    "rollup": "^4.55.1",
+    "rollup-plugin-dts": "^6.3.0",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint-standard": "^9.75.0"
+  },
+  "author": "mivui",
+  "license": "MIT",
+  "keywords": [
+    "stomp",
+    "ws",
+    "node"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mivui/ws-stomp-server.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mivui/ws-stomp-server/issues"
+  },
+  "homepage": "https://github.com/mivui/ws-stomp-server#readme"
+}