http-air 1.3.3 → 1.3.5

package/README.md

@@ -80,6 +80,12 @@ server.handleRpc(async ({ method, params }) => {
   return myService[method](...params)
 })
 
+// validate session before accepting an events connection
+server.handleEventsConnect(async (req, res) => {
+  const token = req.getHeader('authorization')
+  if (!isValid(token)) throw new Error('unauthorized')
+})
+
 // push to all subscribers whenever something happens
 server.notifyEvent('price-update', { symbol: 'BTC', price: 70000 })
 ```
@@ -157,6 +163,9 @@ const router = new Router()
 const rpc = new RpcServer(router)
 rpc.handle(handler)
 const events = new EventsServer(router)
+events.handleEventsConnect(async (req, res) => {
+  if (!isValid(req.getHeader('authorization'))) throw new Error('unauthorized')
+})
 ```
 
 ---

package/lib/client/events.d.ts

@@ -6,6 +6,7 @@ export declare class EventsClient {
     private response;
     private abortController;
     private status;
+    private connectionGen;
     private listenersMap;
     private subscribedSet;
     private subscribeBatch;

package/lib/client/events.js

@@ -54,6 +54,7 @@ class EventsClient {
     response;
     abortController;
     status = Status.Disconnected;
+    connectionGen = 0;
     listenersMap = new Map();
     subscribedSet = new Set();
     subscribeBatch;
@@ -103,12 +104,19 @@ class EventsClient {
         if (this.status !== Status.Disconnected)
             return;
         this.status = Status.Connecting;
-        return (0, p_retry_1.default)(() => this.performConnect(), {
+        const gen = ++this.connectionGen;
+        return (0, p_retry_1.default)(() => this.performConnect(gen), {
             retries: connectRetries,
-            onFailedAttempt: () => { this.status = Status.Disconnected; },
+            onFailedAttempt: () => {
+                if (this.connectionGen !== gen)
+                    throw new p_retry_1.AbortError(new Error('cancelled'));
+                this.status = Status.Disconnected;
+            },
         });
     }
-    async performConnect() {
+    async performConnect(gen) {
+        if (this.connectionGen !== gen)
+            return;
         if (this.status === Status.Connected)
             return;
         const [pResponse, abortController] = this.fetcher({ action: 'events-connect' });
@@ -178,6 +186,7 @@ class EventsClient {
         }
     }
     disconnect() {
+        this.connectionGen++;
         this.status = Status.Disconnected;
         this.abortController?.abort();
         this.listenersMap.forEach((_, name) => this.unsubscribeBatch.add(name));

package/lib/server/events.d.ts

@@ -1,12 +1,15 @@
-import { Router } from './router';
+import { Router, ServerReq, ServerRes } from './router';
+export type EventsConnectHandler = (req: ServerReq, res: ServerRes) => Promise<void> | void;
 export declare class EventsServer {
     readonly serverId: string;
+    private connectHandler;
     private responsesMap;
     private messageQueueMap;
     private drainingSet;
     private listenersMap;
     private heartbeatInterval;
     constructor(server: Router);
+    handleEventsConnect(handler: EventsConnectHandler): void;
     notify(eventName: string, data: any): void;
     private push;
     private drain;

package/lib/server/events.js

@@ -6,6 +6,7 @@ const json_stream_1 = require("../shared/json-stream");
 const stream_constants_1 = require("../shared/stream-constants");
 class EventsServer {
     serverId = (0, crypto_1.randomBytes)(16).toString('base64url');
+    connectHandler;
     responsesMap = new Map();
     messageQueueMap = new Map();
     drainingSet = new Set();
@@ -16,6 +17,9 @@ class EventsServer {
         server.setHandler('events-subscribe', this.handleSubscribe.bind(this));
         server.setHandler('events-unsubscribe', this.handleUnsubscribe.bind(this));
     }
+    handleEventsConnect(handler) {
+        this.connectHandler = handler;
+    }
     notify(eventName, data) {
         const sessions = this.listenersMap.get(eventName) ?? [];
         sessions.forEach(sessionId => this.push(sessionId, { type: 'event', name: eventName, data }));
@@ -86,7 +90,17 @@ class EventsServer {
         parser.close();
         return names;
     }
-    handleConnect(req, res) {
+    async handleConnect(req, res) {
+        if (this.connectHandler) {
+            try {
+                await this.connectHandler(req, res);
+            }
+            catch {
+                res.writeHead(401, {});
+                res.end();
+                return;
+            }
+        }
         let sessionId = req.getHeader(stream_constants_1.SESSION_ID_KEY).trim();
         if (!sessionId.startsWith(stream_constants_1.SESSION_ID_PREFIX)) {
             sessionId = stream_constants_1.SESSION_ID_PREFIX + (0, crypto_1.randomBytes)(60).toString('base64url');

package/lib/server/index.d.ts

@@ -2,5 +2,6 @@ export { Server } from './server';
 export { RpcServer } from './rpc';
 export type { RpcHandler } from './rpc';
 export { EventsServer } from './events';
+export type { EventsConnectHandler } from './events';
 export { Router } from './router';
 export type { ServerReq, ServerRes, HttpHandler } from './router';

package/lib/server/server.d.ts

@@ -1,5 +1,6 @@
 import { HttpHandler, Router, ServerReq, ServerRes } from './router';
 import { RpcHandler } from './rpc';
+import { EventsConnectHandler } from './events';
 export { ServerReq, ServerRes, HttpHandler, Router };
 export declare class Server implements HttpHandler {
     private router;
@@ -7,6 +8,7 @@ export declare class Server implements HttpHandler {
     private eventsServer;
     constructor();
     handleRpc(handler: RpcHandler): void;
+    handleEventsConnect(handler: EventsConnectHandler): void;
     notifyEvent(eventName: string, data: any): void;
     handleHttp(req: ServerReq, res: ServerRes): void;
 }

package/lib/server/server.js

@@ -17,6 +17,9 @@ class Server {
     handleRpc(handler) {
         this.rpcServer.handle(handler);
     }
+    handleEventsConnect(handler) {
+        this.eventsServer.handleEventsConnect(handler);
+    }
     notifyEvent(eventName, data) {
         this.eventsServer.notify(eventName, data);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "http-air",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "HTTP library for batched RPC calls and real-time server-push over a single endpoint.",
   "main": "index.js",
   "repository": "https://github.com/yosbelms/http-air",