http-air 1.3.2 → 1.3.4

package/README.md

@@ -4,7 +4,6 @@ HTTP library for batched RPC calls and real-time server-push over a single endpo
 
 - **RPC** — calls made in the same tick are grouped into one HTTP request. The server executes them concurrently and streams each result back as it resolves, matched to the original call by index. The client resolves each promise individually as its result arrives.
 - **Events** — server pushes named events to subscribed clients over a persistent HTTP connection, with heartbeat and auto-reconnect.
-- **SWR cache** — RPC calls support stale-while-revalidate: return a cached value immediately and revalidate in the background, with a cancel handle.
 
 ## Why http-air
 
@@ -81,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 })
 ```
@@ -158,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')
+})
 ```
 
 ---
@@ -209,38 +217,6 @@ const [r1, r2, r3] = await Promise.all([
 ])
 ```
 
-### SWR (stale-while-revalidate)
-
-`callSwr` returns a tuple `[stale, fresh, cancel]` — immediately a cached (stale) value and a background revalidation promise. If no cache exists both point to the same request. If the cached value is within `ttl` (ms) no request is made.
-
-```ts
-const [stale, fresh, cancel] = client.callSwr('getUser', [42], 5000)
-
-// render immediately with cached data
-const user = await stale
-
-// update once revalidated
-const updated = await fresh
-
-// cancel the background revalidation (e.g. component unmounted)
-cancel()
-```
-
-Works well inside a React `useEffect`:
-
-```ts
-useEffect(() => {
-  const [stale, fresh, cancel] = rpcClient.callSwr('getUser', [id], 5_000)
-  stale.then(setUser)
-  fresh.then(setUser)
-  return cancel
-}, [id])
-```
-
-`Client` exposes the same method as `callRpcSwr`.
-
----
-
 ### Events
 
 Connects automatically on the first `subscribe()` call and disconnects when all subscriptions are removed. Multiple subscribe/unsubscribe calls in the same tick are batched. Auto-reconnect is always enabled.

package/lib/client/client.d.ts

@@ -1,4 +1,4 @@
-import { RpcClientConfig, SwrResult } from './rpc';
+import { RpcClientConfig } from './rpc';
 export interface ClientConfig {
     /** Endpoint URL. Defaults to current page location */
     url?: string;
@@ -19,7 +19,6 @@ export declare class Client {
     private events;
     constructor(config?: RpcClientConfig);
     callRpc(method: string, params: any[]): Promise<any>;
-    callRpcSwr(method: string, params: any[], ttl: number): SwrResult;
     subscribeEvent(eventName: string | string[], handler: (data: any) => void): () => void;
     unsubscribeEvent(eventName: string | string[], handler: (data: any) => void): void;
     disconnect(): void;

package/lib/client/client.js

@@ -28,9 +28,6 @@ class Client {
     callRpc(method, params) {
         return this.rpc.call(method, params);
     }
-    callRpcSwr(method, params, ttl) {
-        return this.rpc.callSwr(method, params, ttl);
-    }
     subscribeEvent(eventName, handler) {
         return this.events.subscribe(eventName, handler);
     }

package/lib/client/index.d.ts

@@ -1,5 +1,5 @@
 export { Client } from './client';
 export { RpcClient } from './rpc';
-export type { RpcClientConfig, SwrResult } from './rpc';
+export type { RpcClientConfig } from './rpc';
 export { EventsClient } from './events';
 export type { ClientConfig } from './client';

package/lib/client/rpc.d.ts

@@ -8,7 +8,6 @@ export interface RpcClientConfig extends ClientConfig {
     /** Called on each response message (result or error) */
     onResponse?: (resp: ResponseMessage) => void;
 }
-export type SwrResult = [stale: Promise<any>, fresh: Promise<any>, cancel: () => void];
 export declare class RpcClient {
     private url;
     private fetchFn;
@@ -16,9 +15,7 @@ export declare class RpcClient {
     private deduplicate;
     private batch;
     private batcher;
-    private swrCache;
     constructor(config?: RpcClientConfig);
     call(method: string, params: any[]): Promise<any>;
-    callSwr(method: string, params: any[], ttl: number): SwrResult;
     private send;
 }

package/lib/client/rpc.js

@@ -17,7 +17,6 @@ class RpcClient {
     deduplicate;
     batch;
     batcher;
-    swrCache = new Map();
     constructor(config = {}) {
         const { url, fetchFn } = (0, client_1.resolveConfig)(config);
         this.url = url;
@@ -34,26 +33,6 @@ class RpcClient {
             this.batcher.flush();
         return dp.promise;
     }
-    callSwr(method, params, ttl) {
-        const key = method + JSON.stringify(params);
-        const cached = this.swrCache.get(key);
-        let cancelled = false;
-        const cancel = () => { cancelled = true; };
-        const revalidate = () => this.call(method, params).then(value => {
-            if (!cancelled)
-                this.swrCache.set(key, { value, fetchedAt: Date.now() });
-            return value;
-        });
-        if (!cached) {
-            const fresh = revalidate();
-            return [fresh, fresh, cancel];
-        }
-        const stale = Promise.resolve(cached.value);
-        if (Date.now() - cached.fetchedAt < ttl) {
-            return [stale, stale, cancel];
-        }
-        return [stale, revalidate(), cancel];
-    }
     send(items) {
         const requests = [];
         const deferredGroups = [];

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.2",
+  "version": "1.3.4",
   "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",