http-air 1.0.0

package/lib/client/events.js

@@ -0,0 +1,217 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsClient = void 0;
+const p_retry_1 = __importStar(require("p-retry"));
+const json_stream_1 = require("../shared/json-stream");
+const stream_constants_1 = require("../shared/stream-constants");
+const batch_1 = require("./batch");
+const client_1 = require("./client");
+const supportsSessionStorage = typeof sessionStorage !== 'undefined';
+const connectRetries = 10;
+var Status;
+(function (Status) {
+    Status[Status["Connecting"] = 0] = "Connecting";
+    Status[Status["Connected"] = 1] = "Connected";
+    Status[Status["Disconnected"] = 2] = "Disconnected";
+})(Status || (Status = {}));
+class EventsClient {
+    fetcher;
+    sessionId;
+    serverId;
+    response;
+    abortController;
+    status = Status.Disconnected;
+    listenersMap = new Map();
+    subscribedSet = new Set();
+    subscribeBatch;
+    unsubscribeBatch;
+    constructor(config = {}) {
+        this.sessionId = supportsSessionStorage ? sessionStorage.getItem(stream_constants_1.SESSION_ID_KEY) ?? '' : '';
+        this.serverId = supportsSessionStorage ? sessionStorage.getItem(stream_constants_1.SERVER_ID_KEY) ?? '' : '';
+        this.fetcher = this.buildFetcher(config);
+        this.subscribeBatch = new batch_1.Batch(names => {
+            const toAdd = names.filter(n => !this.subscribedSet.has(n));
+            if (!toAdd.length)
+                return;
+            const [promise] = this.fetcher({ action: 'events-subscribe' }, (0, client_1.toNdjson)(toAdd.map(name => ({ name }))));
+            promise.then(() => toAdd.forEach(n => this.subscribedSet.add(n)));
+        }, { key: name => name });
+        this.unsubscribeBatch = new batch_1.Batch(names => {
+            if (!names.length)
+                return;
+            const [promise] = this.fetcher({ action: 'events-unsubscribe' }, (0, client_1.toNdjson)(names.map(name => ({ name }))));
+            promise.then(() => names.forEach(n => this.subscribedSet.delete(n)));
+        }, { key: name => name });
+    }
+    buildFetcher(config) {
+        const { url, fetchFn } = (0, client_1.resolveConfig)(config);
+        const init = config.init ?? {};
+        return (params = {}, body) => {
+            const p = { ...params, _dc: String(Math.random()) };
+            const search = Object.keys(p)
+                .map(k => `${encodeURIComponent(k)}=${encodeURIComponent(p[k])}`)
+                .join('&');
+            const ac = new AbortController();
+            const promise = fetchFn(url + '?' + search, {
+                method: 'POST',
+                ...init,
+                headers: {
+                    ...init.headers,
+                    [stream_constants_1.SESSION_ID_KEY]: this.sessionId,
+                    [stream_constants_1.SERVER_ID_KEY]: this.serverId,
+                },
+                signal: ac.signal,
+                body,
+            });
+            return [promise, ac];
+        };
+    }
+    async connect() {
+        if (this.status !== Status.Disconnected)
+            return;
+        this.status = Status.Connecting;
+        return (0, p_retry_1.default)(() => this.performConnect(), {
+            retries: connectRetries,
+            onFailedAttempt: () => { this.status = Status.Disconnected; },
+        });
+    }
+    async performConnect() {
+        if (this.status === Status.Connected)
+            return;
+        const [pResponse, abortController] = this.fetcher({ action: 'events-connect' });
+        this.abortController = abortController;
+        const response = await pResponse;
+        if (response.status !== 200)
+            throw new p_retry_1.AbortError(response.statusText);
+        this.response = response;
+        this.sessionId = response.headers.get(stream_constants_1.SESSION_ID_KEY) ?? '';
+        this.serverId = response.headers.get(stream_constants_1.SERVER_ID_KEY) ?? '';
+        if (supportsSessionStorage) {
+            sessionStorage.setItem(stream_constants_1.SESSION_ID_KEY, this.sessionId);
+            sessionStorage.setItem(stream_constants_1.SERVER_ID_KEY, this.serverId);
+        }
+        this.status = Status.Connected;
+        this.subscribedSet.clear();
+        this.listenersMap.forEach((_, name) => this.subscribeBatch.add(name));
+        await this.read();
+    }
+    async read() {
+        const onDone = () => {
+            this.status = Status.Disconnected;
+            this.connect().catch(() => { });
+        };
+        let heartbeatTimer = null;
+        const resetHeartbeatTimer = () => {
+            if (heartbeatTimer !== null)
+                clearTimeout(heartbeatTimer);
+            heartbeatTimer = setTimeout(() => {
+                if (this.status === Status.Connected) {
+                    this.abortController.abort();
+                    onDone();
+                }
+            }, stream_constants_1.HEARTBEAT_INTERVAL_MS * 2);
+        };
+        const parser = (0, json_stream_1.createParser)({
+            delimiter: stream_constants_1.DELIMITER,
+            onData: (data) => {
+                resetHeartbeatTimer();
+                if (data?.type === stream_constants_1.HEARTBEAT_TYPE)
+                    return;
+                if (data?.type === 'event' && data.name !== void 0 && this.subscribedSet.has(data.name)) {
+                    this.listenersMap.get(data.name)?.forEach(handler => handler(data));
+                }
+            },
+        });
+        resetHeartbeatTimer();
+        try {
+            await (0, client_1.readResponseBody)(this.response, chunk => {
+                if (this.abortController.signal.aborted || this.status !== Status.Connected)
+                    return;
+                parser.write(chunk);
+            }, () => {
+                if (heartbeatTimer !== null)
+                    clearTimeout(heartbeatTimer);
+                onDone();
+            });
+        }
+        catch (e) {
+            if (heartbeatTimer !== null)
+                clearTimeout(heartbeatTimer);
+            if (e instanceof TypeError) {
+                onDone();
+                return;
+            }
+            throw e;
+        }
+    }
+    disconnect() {
+        this.status = Status.Disconnected;
+        this.abortController?.abort();
+        this.listenersMap.forEach((_, name) => this.unsubscribeBatch.add(name));
+        this.listenersMap.clear();
+    }
+    subscribe(eventName, handler) {
+        const eventNames = Array.isArray(eventName) ? eventName : [eventName];
+        eventNames.forEach(name => {
+            if (!this.listenersMap.has(name))
+                this.listenersMap.set(name, []);
+            this.listenersMap.get(name).push(handler);
+            if (this.status === Status.Connected)
+                this.subscribeBatch.add(name);
+        });
+        this.connect().catch(() => { });
+        return () => eventNames.forEach(name => this.unsubscribe(name, handler));
+    }
+    unsubscribe(eventName, handler) {
+        const eventNames = Array.isArray(eventName) ? eventName : [eventName];
+        eventNames.forEach(name => {
+            const listeners = this.listenersMap.get(name);
+            if (!listeners)
+                return;
+            const idx = listeners.findIndex(h => h === handler);
+            if (idx !== -1)
+                listeners.splice(idx, 1);
+            if (listeners.length === 0) {
+                this.listenersMap.delete(name);
+                if (this.status === Status.Connected)
+                    this.unsubscribeBatch.add(name);
+            }
+        });
+        if (this.listenersMap.size === 0)
+            this.disconnect();
+    }
+}
+exports.EventsClient = EventsClient;

package/lib/client/index.d.ts

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

package/lib/client/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsClient = exports.RpcClient = exports.Client = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
+var rpc_1 = require("./rpc");
+Object.defineProperty(exports, "RpcClient", { enumerable: true, get: function () { return rpc_1.RpcClient; } });
+var events_1 = require("./events");
+Object.defineProperty(exports, "EventsClient", { enumerable: true, get: function () { return events_1.EventsClient; } });

package/lib/client/rpc.d.ts

@@ -0,0 +1,24 @@
+import { ResponseMessage } from '../shared/message';
+import { ClientConfig } from './client';
+export interface RpcClientConfig extends ClientConfig {
+    /** Group calls made in the same tick into one HTTP request. Default: true */
+    batch?: boolean;
+    /** Remove duplicated requests within a batch. Default: true */
+    deduplicate?: boolean;
+    /** 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;
+    private onResponse;
+    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

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcClient = void 0;
+const p_defer_1 = __importDefault(require("p-defer"));
+const json_stream_1 = require("../shared/json-stream");
+const stream_constants_1 = require("../shared/stream-constants");
+const batch_1 = require("./batch");
+const client_1 = require("./client");
+const noop = () => { };
+class RpcClient {
+    url;
+    fetchFn;
+    onResponse;
+    deduplicate;
+    batch;
+    batcher;
+    swrCache = new Map();
+    constructor(config = {}) {
+        const { url, fetchFn } = (0, client_1.resolveConfig)(config);
+        this.url = url;
+        this.fetchFn = fetchFn;
+        this.onResponse = config.onResponse ?? noop;
+        this.deduplicate = config.deduplicate ?? true;
+        this.batch = config.batch ?? true;
+        this.batcher = new batch_1.Batch(items => this.send(items));
+    }
+    call(method, params) {
+        const dp = (0, p_defer_1.default)();
+        this.batcher.add({ method, params, deferred: dp });
+        if (!this.batch)
+            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 = [];
+        if (this.deduplicate) {
+            const requestIndexMap = new Map();
+            items.forEach(({ method, params, deferred }) => {
+                const key = method + JSON.stringify(params);
+                const requestIndex = requestIndexMap.get(key);
+                if (requestIndex !== void 0) {
+                    deferredGroups[requestIndex].push(deferred);
+                    return;
+                }
+                const index = requests.length;
+                requestIndexMap.set(key, index);
+                requests.push({ index, method, params });
+                deferredGroups.push([deferred]);
+            });
+        }
+        else {
+            items.forEach(({ method, params, deferred }, index) => {
+                requests.push({ index, method, params });
+                deferredGroups.push([deferred]);
+            });
+        }
+        const payload = (0, client_1.toNdjson)(requests);
+        const parser = (0, json_stream_1.createParser)({
+            delimiter: stream_constants_1.DELIMITER,
+            onData: resp => {
+                const deferreds = deferredGroups[resp.index];
+                if (!deferreds)
+                    return;
+                this.onResponse(resp);
+                if (resp.error === void 0) {
+                    deferreds.forEach(dp => dp.resolve(resp.result));
+                }
+                else {
+                    const err = new Error(resp.error.message);
+                    err.name = resp.error.name;
+                    deferreds.forEach(dp => dp.reject(err));
+                }
+            },
+            onError: (err, str) => console.error(`parse error: ${str}`, err),
+        });
+        this.fetchFn(this.url + '?action=rpc', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'text/plain;charset=utf-8',
+            },
+            body: payload,
+        }).then(response => {
+            if (response.status === 207) {
+                (0, client_1.readResponseBody)(response, parser.write, parser.close);
+            }
+            else {
+                deferredGroups.flat().forEach(d => d.reject(new Error(`rpc: unexpected status ${response.status}`)));
+            }
+        }).catch(err => {
+            deferredGroups.flat().forEach(d => d.reject(err));
+        });
+    }
+}
+exports.RpcClient = RpcClient;

package/lib/server/adapters/express.d.ts

@@ -0,0 +1,2 @@
+import { HttpHandler } from '../server';
+export declare const expressHandler: (server: HttpHandler) => (req: any, res: any, next: Function) => void;

package/lib/server/adapters/express.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expressHandler = void 0;
+const expressHandler = (server) => {
+    const express = require('express');
+    const text = express.text({ type: '*/*' });
+    return (req, res, next) => {
+        text(req, res, () => {
+            server.handleHttp({
+                getHeader: (key) => req.get(key) ?? '',
+                getUrl: () => req.url,
+                getMethod: () => req.method,
+                getBody: () => req.body,
+            }, {
+                write: (content) => res.write(content),
+                isClosed: () => res.writableEnded,
+                writeHead: (status, headers) => res.writeHead(status, headers),
+                flushHeaders: () => res.flushHeaders(),
+                onClose: (cb) => { res.setMaxListeners(0); res.on('close', cb); },
+                end: () => res.end(),
+                destroy: () => res.destroy(),
+            });
+            next();
+        });
+    };
+};
+exports.expressHandler = expressHandler;

package/lib/server/adapters/hono.d.ts

@@ -0,0 +1,3 @@
+import { Context } from 'hono';
+import { HttpHandler } from '../server';
+export declare const honoHandler: (server: HttpHandler) => (c: Context) => Promise<import("undici-types").Response>;

package/lib/server/adapters/hono.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.honoHandler = void 0;
+const honoHandler = (server) => {
+    return async (c) => {
+        const body = await c.req.text();
+        const { readable, writable } = new TransformStream();
+        const writer = writable.getWriter();
+        const encoder = new TextEncoder();
+        const headers = new Headers();
+        let statusCode = 200;
+        // Do not await — server sets status/headers synchronously before its first
+        // internal await, so they are ready when we return the Response below
+        server.handleHttp({
+            getHeader: (key) => c.req.header(key) ?? '',
+            getUrl: () => c.req.url,
+            getMethod: () => c.req.method,
+            getBody: () => body,
+        }, {
+            write: (content) => { writer.write(encoder.encode(content)); return true; },
+            isClosed: () => false,
+            writeHead: (status, hdrs) => {
+                statusCode = status;
+                Object.entries(hdrs).forEach(([k, v]) => headers.set(k, v));
+            },
+            flushHeaders: () => { },
+            onClose: () => { },
+            end: () => writer.close(),
+            destroy: () => writer.abort(),
+        });
+        return new Response(readable, { status: statusCode, headers });
+    };
+};
+exports.honoHandler = honoHandler;

package/lib/server/adapters/micro.d.ts

@@ -0,0 +1,3 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { HttpHandler } from '../server';
+export declare const microHandler: (server: HttpHandler) => (req: IncomingMessage, res: ServerResponse) => Promise<void>;

package/lib/server/adapters/micro.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.microHandler = void 0;
+const microHandler = (server) => {
+    const { text } = require('micro');
+    return async (req, res) => {
+        const body = await text(req);
+        server.handleHttp({
+            getHeader: (key) => String(req.headers[key] ?? ''),
+            getUrl: () => req.url ?? '',
+            getMethod: () => req.method ?? '',
+            getBody: () => body,
+        }, {
+            write: (content) => res.write(content),
+            isClosed: () => res.writableEnded,
+            writeHead: (status, headers) => res.writeHead(status, headers),
+            flushHeaders: () => res.flushHeaders(),
+            onClose: (cb) => { res.setMaxListeners(0); res.on('close', cb); },
+            end: () => res.end(),
+            destroy: () => res.destroy(),
+        });
+    };
+};
+exports.microHandler = microHandler;

package/lib/server/adapters/next.d.ts

@@ -0,0 +1,3 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { HttpHandler } from '../server';
+export declare const nextHandler: (server: HttpHandler) => (req: IncomingMessage, res: ServerResponse) => void;

package/lib/server/adapters/next.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextHandler = void 0;
+const nextHandler = (server) => {
+    return (req, res) => {
+        server.handleHttp({
+            getHeader: (key) => String(req.headers[key] ?? ''),
+            getUrl: () => req.url ?? '',
+            getMethod: () => req.method ?? '',
+            getBody: () => req.body ?? '',
+        }, {
+            write: (content) => res.write(content),
+            isClosed: () => res.writableEnded,
+            writeHead: (status, headers) => res.writeHead(status, headers),
+            flushHeaders: () => res.flushHeaders(),
+            onClose: (cb) => { res.setMaxListeners(0); res.on('close', cb); },
+            end: () => res.end(),
+            destroy: () => res.destroy(),
+        });
+    };
+};
+exports.nextHandler = nextHandler;

package/lib/server/events.d.ts

@@ -0,0 +1,20 @@
+import { Router } from './router';
+export declare class EventsServer {
+    readonly serverId: string;
+    private responsesMap;
+    private messageQueueMap;
+    private drainingSet;
+    private listenersMap;
+    private heartbeatInterval;
+    constructor(server: Router);
+    notify(eventName: string, data: any): void;
+    private push;
+    private drain;
+    private subscribe;
+    private unsubscribe;
+    private unsubscribeAll;
+    private parseEventNames;
+    private handleConnect;
+    private handleSubscribe;
+    private handleUnsubscribe;
+}

package/lib/server/events.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsServer = void 0;
+const nanoid_1 = require("nanoid");
+const json_stream_1 = require("../shared/json-stream");
+const stream_constants_1 = require("../shared/stream-constants");
+class EventsServer {
+    serverId = (0, nanoid_1.nanoid)();
+    responsesMap = new Map();
+    messageQueueMap = new Map();
+    drainingSet = new Set();
+    listenersMap = new Map();
+    heartbeatInterval;
+    constructor(server) {
+        server.setHandler('events-connect', this.handleConnect.bind(this));
+        server.setHandler('events-subscribe', this.handleSubscribe.bind(this));
+        server.setHandler('events-unsubscribe', this.handleUnsubscribe.bind(this));
+    }
+    notify(eventName, data) {
+        const sessions = this.listenersMap.get(eventName) ?? [];
+        sessions.forEach(sessionId => this.push(sessionId, { type: 'event', name: eventName, data }));
+    }
+    push(sessionId, data) {
+        if (!this.messageQueueMap.has(sessionId)) {
+            this.messageQueueMap.set(sessionId, []);
+        }
+        this.messageQueueMap.get(sessionId).push(data);
+        this.drain(sessionId);
+    }
+    async drain(sessionId) {
+        if (this.drainingSet.has(sessionId))
+            return;
+        this.drainingSet.add(sessionId);
+        try {
+            const res = this.responsesMap.get(sessionId);
+            const queue = this.messageQueueMap.get(sessionId);
+            if (res && queue) {
+                while (queue.length) {
+                    const data = queue[0];
+                    if (!res.isClosed() && res.write(JSON.stringify(data) + stream_constants_1.DELIMITER)) {
+                        queue.shift();
+                        await Promise.resolve(void 0);
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+        }
+        finally {
+            this.drainingSet.delete(sessionId);
+        }
+        // re-drain if items were pushed while we were draining
+        if (this.messageQueueMap.get(sessionId)?.length)
+            this.drain(sessionId);
+    }
+    subscribe(eventName, sessionId) {
+        if (!this.listenersMap.has(eventName)) {
+            this.listenersMap.set(eventName, new Set());
+        }
+        this.listenersMap.get(eventName).add(sessionId);
+    }
+    unsubscribe(eventName, sessionId) {
+        const set = this.listenersMap.get(eventName);
+        if (set) {
+            set.delete(sessionId);
+            if (set.size === 0)
+                this.listenersMap.delete(eventName);
+        }
+    }
+    unsubscribeAll(sessionId) {
+        this.listenersMap.forEach((sessions, eventName) => {
+            sessions.delete(sessionId);
+            if (sessions.size === 0)
+                this.listenersMap.delete(eventName);
+        });
+    }
+    parseEventNames(body) {
+        const names = [];
+        const parser = (0, json_stream_1.createParser)({
+            delimiter: stream_constants_1.DELIMITER,
+            onData: ({ name }) => { if (name)
+                names.push(name); },
+        });
+        parser.write(body);
+        parser.close();
+        return names;
+    }
+    handleConnect(req, res) {
+        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, nanoid_1.nanoid)(80);
+        }
+        const oldRes = this.responsesMap.get(sessionId);
+        if (oldRes) {
+            oldRes.end();
+            oldRes.destroy();
+        }
+        this.responsesMap.set(sessionId, res);
+        if (!this.heartbeatInterval) {
+            this.heartbeatInterval = setInterval(() => {
+                this.responsesMap.forEach((_, sid) => this.push(sid, { type: stream_constants_1.HEARTBEAT_TYPE, ts: Date.now() }));
+            }, stream_constants_1.HEARTBEAT_INTERVAL_MS);
+        }
+        res.onClose(() => {
+            this.responsesMap.delete(sessionId);
+            this.messageQueueMap.delete(sessionId);
+            this.unsubscribeAll(sessionId);
+            if (this.responsesMap.size === 0) {
+                clearInterval(this.heartbeatInterval);
+                this.heartbeatInterval = undefined;
+            }
+        });
+        res.writeHead(200, {
+            [stream_constants_1.SESSION_ID_KEY]: sessionId,
+            [stream_constants_1.SERVER_ID_KEY]: this.serverId,
+            'Cache-Control': 'no-cache, no-transform',
+            'Content-Type': 'text/plain; charset=utf-8',
+            'Content-Encoding': 'none',
+            'Transfer-Encoding': 'chunked',
+            'Access-Control-Allow-Origin': '*',
+            'Connection': 'keep-alive',
+            'X-Accel-Buffering': 'no',
+        });
+        res.flushHeaders();
+        this.drain(sessionId);
+    }
+    handleSubscribe(req, res) {
+        const sessionId = req.getHeader(stream_constants_1.SESSION_ID_KEY).trim();
+        const eventNames = this.parseEventNames(req.getBody());
+        eventNames.forEach(eventName => this.subscribe(eventName, sessionId));
+        res.end();
+    }
+    handleUnsubscribe(req, res) {
+        const sessionId = req.getHeader(stream_constants_1.SESSION_ID_KEY).trim();
+        const eventNames = this.parseEventNames(req.getBody());
+        eventNames.forEach(eventName => this.unsubscribe(eventName, sessionId));
+        res.end();
+    }
+}
+exports.EventsServer = EventsServer;

package/lib/server/index.d.ts

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