@jmealo/fastify-uws 1.0.4

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+import { ContextConfigDefault, FastifyBaseLogger, FastifyInstance, FastifyRequest, FastifyReply, FastifySchema, FastifyServerFactory, FastifyTypeProvider, FastifyTypeProviderDefault, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault, RequestGenericInterface } from 'fastify';
+import { SSEContext } from './plugin-sse';
+import { Server } from './server';
+import { Request } from './request';
+import { Response } from './response';
+import { WebSocket as UwsWebSocket, WebSocketServer, WebSocketStream } from './websocket-server';
+export type UwsServer = RawServerDefault & Server;
+export type UwsRequest = Request;
+export type UwsResponse = Response;
+export type FastifyUwsInstance<TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, Logger extends FastifyBaseLogger = FastifyBaseLogger> = FastifyInstance<any, any, any, Logger, TypeProvider>;
+export type FastifyUwsRequest<RequestGeneric extends RequestGenericInterface = RequestGenericInterface, SchemaCompiler extends FastifySchema = FastifySchema, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, ContextConfig = ContextConfigDefault, Logger extends FastifyBaseLogger = FastifyBaseLogger> = FastifyRequest<RequestGeneric, any, any, SchemaCompiler, TypeProvider, ContextConfig, Logger>;
+export type FastifyUwsReply<RequestGeneric extends RequestGenericInterface = RequestGenericInterface, SchemaCompiler extends FastifySchema = FastifySchema, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, ContextConfig = ContextConfigDefault> = FastifyReply<RequestGeneric, any, any, any, ContextConfig, SchemaCompiler, TypeProvider>;
+export declare const serverFactory: FastifyServerFactory<any>;
+export type { SSEContext } from './plugin-sse';
+export { default as sse } from './plugin-sse';
+export { default as websocket } from './plugin-websocket';
+export { UwsWebSocket as WebSocket, WebSocketServer, WebSocketStream, Server, Request, Response };
+declare module 'fastify' {
+    interface FastifyReply {
+        sse: SSEContext;
+    }
+    interface RouteOptions {
+        websocket?: boolean;
+        sse?: boolean | {
+            heartbeat?: boolean;
+            serializer?: (data: any) => string;
+        };
+        ws?: {
+            topics?: string[];
+        };
+    }
+    interface RouteShorthandOptions<RawServer extends RawServerBase = RawServerDefault> {
+        websocket?: boolean;
+        sse?: boolean | {
+            heartbeat?: boolean;
+            serializer?: (data: any) => string;
+        };
+        ws?: {
+            topics?: string[];
+        };
+    }
+    interface RouteShorthandMethod<RawServer extends RawServerBase = RawServerDefault, RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>, RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, Logger extends FastifyBaseLogger = FastifyBaseLogger> {
+        <RequestGeneric extends RequestGenericInterface = RequestGenericInterface, ContextConfig = ContextConfigDefault, SchemaCompiler extends FastifySchema = FastifySchema, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, Logger extends FastifyBaseLogger = FastifyBaseLogger>(path: string, opts: RouteShorthandOptions<RawServer, RawRequest, RawReply, RequestGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger> & {
+            websocket: true;
+        }, handler?: (socket: UwsWebSocket, req: FastifyRequest<RequestGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider, ContextConfig, Logger>) => void | Promise<any>): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+    }
+}

package/dist/index.js

@@ -0,0 +1,18 @@
+import { Server as o } from "./server.js";
+import { Request as p } from "./request.js";
+import { Response as c } from "./response.js";
+import { WebSocket as S, WebSocketServer as b, WebSocketStream as k } from "./websocket-server.js";
+import { default as u } from "./plugin-sse.js";
+import { default as W } from "./plugin-websocket.js";
+const s = (e, r) => new o(e, r);
+export {
+  p as Request,
+  c as Response,
+  o as Server,
+  S as WebSocket,
+  b as WebSocketServer,
+  k as WebSocketStream,
+  s as serverFactory,
+  u as sse,
+  W as websocket
+};

package/dist/plugin-sse.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const E=require("node:stream"),y=require("fastify-plugin"),c=require("./symbols.cjs"),k=3e4,p=32,H=1024*1024;function d(i){return String(i).replace(/[\r\n]/g,"")}const S=/\r\n|\r|\n/;function f(i,t){let e="";if(typeof i=="string")for(const s of i.split(S))e+=`data: ${s}
+`;else if(Buffer.isBuffer(i)){const s=i.toString("utf-8");for(const r of s.split(S))e+=`data: ${r}
+`}else{if(i.id&&(e+=`id: ${d(i.id)}
+`),i.event&&(e+=`event: ${d(i.event)}
+`),i.data!==void 0){const s=t(i.data);for(const r of s.split(S))e+=`data: ${r}
+`}i.retry&&(e+=`retry: ${d(String(i.retry))}
+`)}return e&&(e+=`
+`),e}const T=[{name:"Content-Type",value:"text/event-stream",isMultiValue:!1},{name:"Cache-Control",value:"no-cache",isMultiValue:!1},{name:"Connection",value:"keep-alive",isMultiValue:!1},{name:"X-Accel-Buffering",value:"no",isMultiValue:!1}];function m(i){return typeof i=="object"&&i!==null&&"data"in i}function C(i){return i!=null&&typeof i[Symbol.asyncIterator]=="function"}function I(i,t){if(t.status&&i.writeStatus(t.status),t.headers)for(const e of t.headers.values())if(e.isMultiValue)for(const s of e.value)i.writeHeader(e.name,s);else i.writeHeader(e.name,e.value)}class v{reply;serializer;heartbeatTimer=null;closeCallbacks=[];#e;#a;#t=!0;#c=!1;#f=!1;#o;#r=null;#i="";#l=0;#h=!1;#n=null;#u;#d=!0;constructor(t){this.reply=t.reply,this.#e=t.socket,this.#a=t.socket[c.kRes],this.#o=t.lastEventId||null,this.serializer=t.serializer,this.#u=this._corkFlush.bind(this);const e=()=>{if(!this.#t)return;this.#t=!1,this.#n=null;const s=this.#r;this.#r=null,s&&s(),this.cleanup()};t.socket.once("close",e),t.socket.once("aborted",e),t.heartbeatInterval>0&&this.startHeartbeat(t.heartbeatInterval)}get lastEventId(){return this.#o}get isConnected(){return this.#t}get shouldKeepAlive(){return this.#c}keepAlive(){this.#c=!0}flush(){this.#i&&this.#t&&this.#s()}close(){if(this.#t&&(this.#i&&this.#s(),this.#t=!1,this.cleanup(),!this.#e.destroyed&&!this.#e.writableEnded))try{this.#e.end(void 0,void 0)}catch{}}onClose(t){this.closeCallbacks.push(t)}async replay(t){this.#o&&await t(this.#o)}sendHeaders(){if(this.#f)return;this.#f=!0;const t=new Map;for(const e of T)t.set(e.name.toLowerCase(),e);try{const e=this.reply.getHeaders();for(const[s,r]of Object.entries(e)){const n=s.toLowerCase();t.has(n)||t.set(n,{name:s,value:String(r),isMultiValue:!1})}}catch{}this.#e[c.kHead]={status:"200 OK",headers:t}}async send(t){if(!this.#t)throw new Error("SSE connection is closed");if(typeof t=="string"||Buffer.isBuffer(t)||m(t)){const e=f(t,this.serializer);return this.writeToSocket(e)}if(t instanceof E.Readable){try{for await(const e of t){if(!this.#t){t.destroy();break}const s=f(e,this.serializer);await this.writeToSocket(s)}this.#i&&this.#t&&this.#s()}catch(e){this.#i&&this.#t&&this.#s(),this.#t=!1,this.cleanup(),e?.code!=="ECONNRESET"&&e?.code!=="EPIPE"&&this.reply.log?.error?.({err:e},"Unexpected error in SSE stream")}return}if(C(t)){try{for await(const e of t){if(!this.#t)break;const s=f(e,this.serializer);await this.writeToSocket(s)}this.#i&&this.#t&&this.#s()}catch(e){this.#i&&this.#t&&this.#s(),this.#t=!1,this.cleanup(),e?.code!=="ECONNRESET"&&e?.code!=="EPIPE"&&this.reply.log?.error?.({err:e},"Unexpected error in SSE async iterable")}return}throw new TypeError("Invalid SSE source type")}stream(){if(!this.#t)throw new Error("SSE connection is closed");const t=this;return new E.Writable({objectMode:!0,write(e,s,r){if(!t.#t){r(new Error("SSE connection is closed"));return}try{const n=f(e,t.serializer),o=t.writeToSocket(n);o===void 0?r():o.then(()=>r(),r)}catch(n){r(n)}}})}writeToSocket(t){if(!this.#t)throw new Error("SSE connection is closed");if(this.sendHeaders(),this.#h&&this.#i.length+t.length>H)throw this.close(),new Error("SSE buffer overflow: client too slow");if(this.#i+=t,this.#l++,this.#h)return this.#n;if(this.#l>=p)return this.#s()}#s(){if(!(!this.#i||!this.#t)&&(this.#a.cork(this.#u),this.#i="",this.#l=0,!this.#d))return this.#h=!0,this.#n=new Promise(t=>{this.#r=t,this.#e.writableNeedDrain=!0,this.#e._drainCb=()=>{this.#e.writableNeedDrain=!1,this.#h=!1,this.#n=null;const e=this.#r;this.#r=null,e&&e()},this.#e._drainTimer=setTimeout(this.#e._boundDrainTimeout,k)}),this.#n}_corkFlush(){const t=this.#e[c.kHead];t&&(I(this.#a,t),this.#e[c.kHead]=null),this.#d=this.#a.write(this.#i)}startHeartbeat(t){this.heartbeatTimer=setInterval(()=>{this.#t?(this.sendHeaders(),this.#i+=`: heartbeat
+
+`,this.#l++,this.#s()):this.stopHeartbeat()},t),this.heartbeatTimer.unref()}stopHeartbeat(){this.heartbeatTimer&&(clearInterval(this.heartbeatTimer),this.heartbeatTimer=null)}cleanup(){this.stopHeartbeat();for(const t of this.closeCallbacks)try{t()}catch{}this.closeCallbacks=[]}}function _(i,t,e){const{heartbeatInterval:s=3e4,serializer:r=JSON.stringify}=t;i.addHook("onRoute",n=>{if(!n.sse)return;const o=n.handler,b=typeof n.sse=="object"?n.sse:{};n.handler=async function(l,h){if(!(l.headers.accept||"").includes("text/event-stream"))return o.call(this,l,h);h.hijack();const u=l.raw.socket;if(u.aborted||u.destroyed)return;const a=new v({reply:h,socket:u,lastEventId:l.headers["last-event-id"]||null,heartbeatInterval:b.heartbeat!==!1?s:0,serializer:b.serializer||r});h.sse=a;try{await o.call(this,l,h)}catch(w){throw a.shouldKeepAlive||a.close(),w}a.flush(),a.shouldKeepAlive||a.close()}}),e()}const M=y(_,{fastify:"5.x",name:"@fastify/sse"});exports.SSEContext=v;exports.default=M;

package/dist/plugin-sse.d.ts

@@ -0,0 +1,50 @@
+import { Writable } from 'node:stream';
+import { HTTPSocket } from './http-socket';
+declare class SSEContext {
+    #private;
+    reply: any;
+    serializer: (data: any) => string;
+    heartbeatTimer: ReturnType<typeof setInterval> | null;
+    closeCallbacks: (() => void)[];
+    constructor(opts: {
+        reply: any;
+        socket: HTTPSocket;
+        lastEventId: string | null;
+        heartbeatInterval: number;
+        serializer: (data: any) => string;
+    });
+    get lastEventId(): string | null;
+    get isConnected(): boolean;
+    get shouldKeepAlive(): boolean;
+    keepAlive(): void;
+    flush(): void;
+    close(): void;
+    onClose(callback: () => void): void;
+    replay(callback: (lastEventId: string) => Promise<void>): Promise<void>;
+    sendHeaders(): void;
+    send(source: any): Promise<void>;
+    stream(): Writable;
+    /**
+     * Write-combining SSE writer.
+     *
+     * Events are accumulated in a string buffer. When the buffer reaches
+     * FLUSH_BATCH_SIZE events, all events are flushed in a single corked write
+     * to the uWS HttpResponse. This reduces C++ boundary crossings from
+     * one-per-event to one-per-batch.
+     *
+     * If there's active backpressure from a previous flush, the send() caller
+     * receives a Promise that resolves when the drain completes.
+     */
+    writeToSocket(data: string): Promise<void> | undefined;
+    /**
+     * Pre-bound cork callback. Writes headers (first call only) + buffered data.
+     */
+    _corkFlush(): void;
+    startHeartbeat(interval: number): void;
+    stopHeartbeat(): void;
+    cleanup(): void;
+}
+declare function fastifySSE(fastify: any, opts: any, next: (err?: Error) => void): void;
+export { SSEContext };
+declare const _default: typeof fastifySSE;
+export default _default;

package/dist/plugin-sse.js

@@ -0,0 +1,285 @@
+import { Readable as w, Writable as v } from "node:stream";
+import y from "fastify-plugin";
+import { kRes as p, kHead as u } from "./symbols.js";
+const k = 3e4, m = 32, T = 1024 * 1024;
+function d(i) {
+  return String(i).replace(/[\r\n]/g, "");
+}
+const S = /\r\n|\r|\n/;
+function c(i, t) {
+  let e = "";
+  if (typeof i == "string")
+    for (const s of i.split(S))
+      e += `data: ${s}
+`;
+  else if (Buffer.isBuffer(i)) {
+    const s = i.toString("utf-8");
+    for (const r of s.split(S))
+      e += `data: ${r}
+`;
+  } else {
+    if (i.id && (e += `id: ${d(i.id)}
+`), i.event && (e += `event: ${d(i.event)}
+`), i.data !== void 0) {
+      const s = t(i.data);
+      for (const r of s.split(S))
+        e += `data: ${r}
+`;
+    }
+    i.retry && (e += `retry: ${d(String(i.retry))}
+`);
+  }
+  return e && (e += `
+`), e;
+}
+const H = [
+  { name: "Content-Type", value: "text/event-stream", isMultiValue: !1 },
+  { name: "Cache-Control", value: "no-cache", isMultiValue: !1 },
+  { name: "Connection", value: "keep-alive", isMultiValue: !1 },
+  { name: "X-Accel-Buffering", value: "no", isMultiValue: !1 }
+];
+function I(i) {
+  return typeof i == "object" && i !== null && "data" in i;
+}
+function C(i) {
+  return i != null && typeof i[Symbol.asyncIterator] == "function";
+}
+function _(i, t) {
+  if (t.status && i.writeStatus(t.status), t.headers)
+    for (const e of t.headers.values())
+      if (e.isMultiValue)
+        for (const s of e.value)
+          i.writeHeader(e.name, s);
+      else
+        i.writeHeader(e.name, e.value);
+}
+class M {
+  reply;
+  serializer;
+  heartbeatTimer = null;
+  closeCallbacks = [];
+  #e;
+  #a;
+  #t = !0;
+  #c = !1;
+  #f = !1;
+  #o;
+  #r = null;
+  // Write-combining buffer: accumulate events, flush when batch is full
+  #i = "";
+  #h = 0;
+  #l = !1;
+  #n = null;
+  // Pre-bound methods
+  #u;
+  // Cork state
+  #d = !0;
+  constructor(t) {
+    this.reply = t.reply, this.#e = t.socket, this.#a = t.socket[p], this.#o = t.lastEventId || null, this.serializer = t.serializer, this.#u = this._corkFlush.bind(this);
+    const e = () => {
+      if (!this.#t) return;
+      this.#t = !1, this.#n = null;
+      const s = this.#r;
+      this.#r = null, s && s(), this.cleanup();
+    };
+    t.socket.once("close", e), t.socket.once("aborted", e), t.heartbeatInterval > 0 && this.startHeartbeat(t.heartbeatInterval);
+  }
+  get lastEventId() {
+    return this.#o;
+  }
+  get isConnected() {
+    return this.#t;
+  }
+  get shouldKeepAlive() {
+    return this.#c;
+  }
+  keepAlive() {
+    this.#c = !0;
+  }
+  flush() {
+    this.#i && this.#t && this.#s();
+  }
+  close() {
+    if (this.#t && (this.#i && this.#s(), this.#t = !1, this.cleanup(), !this.#e.destroyed && !this.#e.writableEnded))
+      try {
+        this.#e.end(void 0, void 0);
+      } catch {
+      }
+  }
+  onClose(t) {
+    this.closeCallbacks.push(t);
+  }
+  async replay(t) {
+    this.#o && await t(this.#o);
+  }
+  sendHeaders() {
+    if (this.#f) return;
+    this.#f = !0;
+    const t = /* @__PURE__ */ new Map();
+    for (const e of H)
+      t.set(e.name.toLowerCase(), e);
+    try {
+      const e = this.reply.getHeaders();
+      for (const [s, r] of Object.entries(e)) {
+        const n = s.toLowerCase();
+        t.has(n) || t.set(n, { name: s, value: String(r), isMultiValue: !1 });
+      }
+    } catch {
+    }
+    this.#e[u] = {
+      status: "200 OK",
+      headers: t
+    };
+  }
+  async send(t) {
+    if (!this.#t) throw new Error("SSE connection is closed");
+    if (typeof t == "string" || Buffer.isBuffer(t) || I(t)) {
+      const e = c(t, this.serializer);
+      return this.writeToSocket(e);
+    }
+    if (t instanceof w) {
+      try {
+        for await (const e of t) {
+          if (!this.#t) {
+            t.destroy();
+            break;
+          }
+          const s = c(e, this.serializer);
+          await this.writeToSocket(s);
+        }
+        this.#i && this.#t && this.#s();
+      } catch (e) {
+        this.#i && this.#t && this.#s(), this.#t = !1, this.cleanup(), e?.code !== "ECONNRESET" && e?.code !== "EPIPE" && this.reply.log?.error?.({ err: e }, "Unexpected error in SSE stream");
+      }
+      return;
+    }
+    if (C(t)) {
+      try {
+        for await (const e of t) {
+          if (!this.#t) break;
+          const s = c(e, this.serializer);
+          await this.writeToSocket(s);
+        }
+        this.#i && this.#t && this.#s();
+      } catch (e) {
+        this.#i && this.#t && this.#s(), this.#t = !1, this.cleanup(), e?.code !== "ECONNRESET" && e?.code !== "EPIPE" && this.reply.log?.error?.({ err: e }, "Unexpected error in SSE async iterable");
+      }
+      return;
+    }
+    throw new TypeError("Invalid SSE source type");
+  }
+  stream() {
+    if (!this.#t) throw new Error("SSE connection is closed");
+    const t = this;
+    return new v({
+      objectMode: !0,
+      write(e, s, r) {
+        if (!t.#t) {
+          r(new Error("SSE connection is closed"));
+          return;
+        }
+        try {
+          const n = c(e, t.serializer), o = t.writeToSocket(n);
+          o === void 0 ? r() : o.then(() => r(), r);
+        } catch (n) {
+          r(n);
+        }
+      }
+    });
+  }
+  /**
+   * Write-combining SSE writer.
+   *
+   * Events are accumulated in a string buffer. When the buffer reaches
+   * FLUSH_BATCH_SIZE events, all events are flushed in a single corked write
+   * to the uWS HttpResponse. This reduces C++ boundary crossings from
+   * one-per-event to one-per-batch.
+   *
+   * If there's active backpressure from a previous flush, the send() caller
+   * receives a Promise that resolves when the drain completes.
+   */
+  writeToSocket(t) {
+    if (!this.#t) throw new Error("SSE connection is closed");
+    if (this.sendHeaders(), this.#l && this.#i.length + t.length > T)
+      throw this.close(), new Error("SSE buffer overflow: client too slow");
+    if (this.#i += t, this.#h++, this.#l)
+      return this.#n;
+    if (this.#h >= m)
+      return this.#s();
+  }
+  /**
+   * Flush buffered events to the uWS HttpResponse in a single corked write.
+   */
+  #s() {
+    if (!(!this.#i || !this.#t) && (this.#a.cork(this.#u), this.#i = "", this.#h = 0, !this.#d))
+      return this.#l = !0, this.#n = new Promise((t) => {
+        this.#r = t, this.#e.writableNeedDrain = !0, this.#e._drainCb = () => {
+          this.#e.writableNeedDrain = !1, this.#l = !1, this.#n = null;
+          const e = this.#r;
+          this.#r = null, e && e();
+        }, this.#e._drainTimer = setTimeout(this.#e._boundDrainTimeout, k);
+      }), this.#n;
+  }
+  /**
+   * Pre-bound cork callback. Writes headers (first call only) + buffered data.
+   */
+  _corkFlush() {
+    const t = this.#e[u];
+    t && (_(this.#a, t), this.#e[u] = null), this.#d = this.#a.write(this.#i);
+  }
+  startHeartbeat(t) {
+    this.heartbeatTimer = setInterval(() => {
+      this.#t ? (this.sendHeaders(), this.#i += `: heartbeat
+
+`, this.#h++, this.#s()) : this.stopHeartbeat();
+    }, t), this.heartbeatTimer.unref();
+  }
+  stopHeartbeat() {
+    this.heartbeatTimer && (clearInterval(this.heartbeatTimer), this.heartbeatTimer = null);
+  }
+  cleanup() {
+    this.stopHeartbeat();
+    for (const t of this.closeCallbacks)
+      try {
+        t();
+      } catch {
+      }
+    this.closeCallbacks = [];
+  }
+}
+function g(i, t, e) {
+  const { heartbeatInterval: s = 3e4, serializer: r = JSON.stringify } = t;
+  i.addHook("onRoute", (n) => {
+    if (!n.sse) return;
+    const o = n.handler, E = typeof n.sse == "object" ? n.sse : {};
+    n.handler = async function(h, l) {
+      if (!(h.headers.accept || "").includes("text/event-stream"))
+        return o.call(this, h, l);
+      l.hijack();
+      const f = h.raw.socket;
+      if (f.aborted || f.destroyed) return;
+      const a = new M({
+        reply: l,
+        socket: f,
+        lastEventId: h.headers["last-event-id"] || null,
+        heartbeatInterval: E.heartbeat !== !1 ? s : 0,
+        serializer: E.serializer || r
+      });
+      l.sse = a;
+      try {
+        await o.call(this, h, l);
+      } catch (b) {
+        throw a.shouldKeepAlive || a.close(), b;
+      }
+      a.flush(), a.shouldKeepAlive || a.close();
+    };
+  }), e();
+}
+const B = y(g, {
+  fastify: "5.x",
+  name: "@fastify/sse"
+});
+export {
+  M as SSEContext,
+  B as default
+};

package/dist/plugin-websocket.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const E=require("fastify-plugin"),r=require("./symbols.cjs"),k=require("./websocket-server.cjs"),H=/^[A-Za-z0-9+/]{22}==$/;function y(o){return typeof o!="string"||!H.test(o)?!1:Buffer.from(o,"base64").byteLength===16}function R(o,f,n){n.log.error(o),f.close()}const T=(o,f,n)=>{const{server:W}=o,{errorHandler:a=R,options:m}=f;if(a&&typeof a!="function")return n(new Error("invalid errorHandler function"));const b=new k.WebSocketServer(m);W[r.kWs]=b,o.decorate("websocketServer",b),o.addHook("onRoute",t=>{if(!!!t.websocket||t.method==="HEAD"||t.method==="OPTIONS")return;const u=typeof t.ws=="object"?t.ws:{},h=t.handler,w=Buffer.from(t.url||"/"),S={};if(u.topics)for(const c of u.topics)S[c]=k.WebSocket.allocTopic(w,c);t.handler=function(c,i){const e=c.raw;if(e[r.kWs]){const g=e.headers["sec-websocket-key"];if(!y(g)){i.code(400).send("Invalid sec-websocket-key header");return}i.hijack();const p=e.socket[r.kRes];if(e.socket[r.kWs]=!0,e.socket.aborted||e.socket.destroyed)return;p.upgrade({req:e,handler:v=>{const s=new k.WebSocket(w,v,S);let l;try{e.once("error",()=>{s.close()}),e.once("close",()=>{s.end(1e3,"Normal Closure")}),l=h.call(this,s,c,i)}catch(d){return a.call(this,d,s,c)}l&&typeof l.catch=="function"&&l.catch(d=>a.call(this,d,s,c))}},e.headers["sec-websocket-key"],e.headers["sec-websocket-protocol"],e.headers["sec-websocket-extensions"],e[r.kWs])}else return h.call(this,c,i)}}),n()},K=E(T,{fastify:"5.x",name:"@fastify/websocket"});exports.default=K;exports.isValidWebSocketKey=y;

package/dist/plugin-websocket.d.ts

@@ -0,0 +1,9 @@
+import { FastifyPluginCallback, FastifyRequest } from 'fastify';
+import { WebSocket } from './websocket-server';
+export declare function isValidWebSocketKey(value: unknown): value is string;
+declare function defaultErrorHandler(err: Error, conn: WebSocket, request: FastifyRequest): void;
+declare const _default: FastifyPluginCallback<{
+    errorHandler?: typeof defaultErrorHandler;
+    options?: any;
+}, any>;
+export default _default;

package/dist/plugin-websocket.js

@@ -0,0 +1,67 @@
+import E from "fastify-plugin";
+import { kWs as i, kRes as H } from "./symbols.js";
+import { WebSocketServer as R, WebSocket as m } from "./websocket-server.js";
+const v = /^[A-Za-z0-9+/]{22}==$/;
+function T(o) {
+  return typeof o != "string" || !v.test(o) ? !1 : Buffer.from(o, "base64").byteLength === 16;
+}
+function A(o, l, s) {
+  s.log.error(o), l.close();
+}
+const K = (o, l, s) => {
+  const { server: p } = o, { errorHandler: n = A, options: y } = l;
+  if (n && typeof n != "function")
+    return s(new Error("invalid errorHandler function"));
+  const k = new R(y);
+  p[i] = k, o.decorate("websocketServer", k), o.addHook("onRoute", (c) => {
+    if (!!!c.websocket || c.method === "HEAD" || c.method === "OPTIONS") return;
+    const h = typeof c.ws == "object" ? c.ws : {}, b = c.handler, w = Buffer.from(c.url || "/"), u = {};
+    if (h.topics)
+      for (const t of h.topics)
+        u[t] = m.allocTopic(w, t);
+    c.handler = function(t, a) {
+      const e = t.raw;
+      if (e[i]) {
+        const S = e.headers["sec-websocket-key"];
+        if (!T(S)) {
+          a.code(400).send("Invalid sec-websocket-key header");
+          return;
+        }
+        a.hijack();
+        const W = e.socket[H];
+        if (e.socket[i] = !0, e.socket.aborted || e.socket.destroyed) return;
+        W.upgrade(
+          {
+            req: e,
+            handler: (g) => {
+              const r = new m(w, g, u);
+              let f;
+              try {
+                e.once("error", () => {
+                  r.close();
+                }), e.once("close", () => {
+                  r.end(1e3, "Normal Closure");
+                }), f = b.call(this, r, t, a);
+              } catch (d) {
+                return n.call(this, d, r, t);
+              }
+              f && typeof f.catch == "function" && f.catch((d) => n.call(this, d, r, t));
+            }
+          },
+          e.headers["sec-websocket-key"],
+          e.headers["sec-websocket-protocol"],
+          e.headers["sec-websocket-extensions"],
+          e[i]
+        );
+      } else
+        return b.call(this, t, a);
+    };
+  }), s();
+}, I = E(K, {
+  fastify: "5.x",
+  name: "@fastify/websocket"
+});
+export {
+  I as default,
+  T as isValidWebSocketKey
+};

package/dist/request.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u=require("streamx"),s=require("./symbols.cjs"),c=()=>{};class a extends u.Readable{socket;method;httpVersion="1.1";httpVersionMajor=1;httpVersionMinor=1;readableEnded;complete=!1;headersDistinct=Object.create(null);trailersDistinct=Object.create(null);trailers=Object.create(null);[s.kUrl];[s.kHeaders];[s.kWs];constructor(e,t,r){super(),this.socket=t,this.method=r,this.readableEnded=!1;const i=e.getQuery();this[s.kUrl]=e.getUrl()+(i&&i.length>0?`?${i}`:"");const o=Object.create(null);e.forEach((d,h)=>{o[d]=h,this.headersDistinct[d]=[h]}),this[s.kHeaders]=o,this.once("error",c);const n=super.destroy.bind(this);t.once("error",n),t.once("close",n),t.once("aborted",()=>{this.emit("aborted")})}get aborted(){return this.socket.aborted}get url(){return this[s.kUrl]}set url(e){this[s.kUrl]=e}get headers(){return this[s.kHeaders]}setEncoding(e){return this.socket.setEncoding(e),this}setTimeout(e,t){return this.socket.setTimeout(e),t&&this.once("timeout",t),this}destroy(e){return this.destroyed||this.destroying?this:(this.socket.destroy(e),this)}unpipe(e){return e.destroy&&e.destroy(),this}_read(e){if(this.destroyed||this.destroying||this.socket.destroyed)return e();this.socket.onRead((t,r)=>{if(t)return e(t);if(this.destroyed||this.destroying)return e();this.push(r),r||(this.complete=!0,this.readableEnded=!0,e())})}}exports.Request=a;

package/dist/request.d.ts

@@ -0,0 +1,29 @@
+import { default as uws } from 'uWebSockets.js';
+import { Readable } from 'streamx';
+import { HTTPSocket } from './http-socket';
+import { kHeaders, kUrl, kWs } from './symbols';
+export declare class Request extends Readable {
+    socket: HTTPSocket;
+    method: string;
+    httpVersion: string;
+    httpVersionMajor: number;
+    httpVersionMinor: number;
+    readableEnded: boolean;
+    complete: boolean;
+    headersDistinct: Record<string, string[]>;
+    trailersDistinct: Record<string, string[]>;
+    trailers: Record<string, string>;
+    [kUrl]: string;
+    [kHeaders]: Record<string, string>;
+    [kWs]?: uws.us_socket_context_t;
+    constructor(req: uws.HttpRequest, socket: HTTPSocket, method: string);
+    get aborted(): boolean;
+    get url(): string;
+    set url(url: string);
+    get headers(): Record<string, string>;
+    setEncoding(encoding: string): this;
+    setTimeout(timeout: number, cb?: () => void): this;
+    destroy(err?: Error): this;
+    unpipe(writable: any): this;
+    _read(cb: (err?: Error | null) => void): void;
+}

package/dist/request.js

@@ -0,0 +1,67 @@
+import { Readable as u } from "streamx";
+import { kUrl as r, kHeaders as o, kWs as a } from "./symbols.js";
+const l = () => {
+};
+class m extends u {
+  socket;
+  method;
+  httpVersion = "1.1";
+  httpVersionMajor = 1;
+  httpVersionMinor = 1;
+  readableEnded;
+  complete = !1;
+  headersDistinct = /* @__PURE__ */ Object.create(null);
+  trailersDistinct = /* @__PURE__ */ Object.create(null);
+  trailers = /* @__PURE__ */ Object.create(null);
+  [r];
+  [o];
+  [a];
+  constructor(t, e, s) {
+    super(), this.socket = e, this.method = s, this.readableEnded = !1;
+    const i = t.getQuery();
+    this[r] = t.getUrl() + (i && i.length > 0 ? `?${i}` : "");
+    const n = /* @__PURE__ */ Object.create(null);
+    t.forEach((d, c) => {
+      n[d] = c, this.headersDistinct[d] = [c];
+    }), this[o] = n, this.once("error", l);
+    const h = super.destroy.bind(this);
+    e.once("error", h), e.once("close", h), e.once("aborted", () => {
+      this.emit("aborted");
+    });
+  }
+  get aborted() {
+    return this.socket.aborted;
+  }
+  get url() {
+    return this[r];
+  }
+  set url(t) {
+    this[r] = t;
+  }
+  get headers() {
+    return this[o];
+  }
+  setEncoding(t) {
+    return this.socket.setEncoding(t), this;
+  }
+  setTimeout(t, e) {
+    return this.socket.setTimeout(t), e && this.once("timeout", e), this;
+  }
+  destroy(t) {
+    return this.destroyed || this.destroying ? this : (this.socket.destroy(t), this);
+  }
+  unpipe(t) {
+    return t.destroy && t.destroy(), this;
+  }
+  _read(t) {
+    if (this.destroyed || this.destroying || this.socket.destroyed) return t();
+    this.socket.onRead((e, s) => {
+      if (e) return t(e);
+      if (this.destroyed || this.destroying) return t();
+      this.push(s), s || (this.complete = !0, this.readableEnded = !0, t());
+    });
+  }
+}
+export {
+  m as Request
+};

package/dist/response.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const d=require("node:http"),u=require("streamx"),o=require("./errors.cjs"),i=require("./symbols.cjs");class f{isMultiValue;name;value;constructor(e,t){this.isMultiValue=Array.isArray(t),this.name=e,this.value=this.isMultiValue?t:String(t)}}const a=Buffer.alloc(0);function h(n,e=!1){return n?{chunk:n,empty:!1,end:e,byteLength:Buffer.isBuffer(n)?n.byteLength:Buffer.byteLength(n)}:{chunk:a,empty:!0,end:e,byteLength:0}}const c=()=>{},y={byteLength(n){return n.byteLength}};class l extends u.Writable{socket;statusCode=200;statusMessage;headersSent=!1;chunked=!1;contentLength=null;writableEnded=!1;firstChunk=!0;_boundEmitDrain;[i.kHeaders];constructor(e){super(y),this.socket=e,this._boundEmitDrain=this._emitDrain.bind(this),this[i.kHeaders]=new Map;const t=this.destroy.bind(this);this.once("error",c),e.once("error",t),e.once("close",t),e.once("aborted",()=>{this.emit("aborted")})}get aborted(){return this.socket.aborted}get finished(){return this.socket.writableEnded&&!this.socket.aborted}get status(){return`${this.statusCode} ${this.statusMessage||d.STATUS_CODES[this.statusCode]}`}get bytesWritten(){return this.socket.bytesWritten}hasHeader(e){return this[i.kHeaders].has(e.toLowerCase())}getHeader(e){return this[i.kHeaders].get(e.toLowerCase())?.value}getHeaders(){const e={};return this[i.kHeaders].forEach((t,s)=>{e[s]=t.value}),e}setHeader(e,t){if(this.headersSent)throw new o.ERR_HEAD_SET;e=e.replace(/[\r\n]/g,"");const s=e.toLowerCase();return s==="content-length"?(this.contentLength=Number(t),this):s==="transfer-encoding"?(this.chunked=String(t).includes("chunked"),this):(typeof t=="string"?t=t.replace(/[\r\n]/g,""):Array.isArray(t)&&(t=t.map(r=>typeof r=="string"?r.replace(/[\r\n]/g,""):r)),this[i.kHeaders].set(s,new f(e,t)),this)}removeHeader(e){if(this.headersSent)throw new o.ERR_HEAD_SET;this[i.kHeaders].delete(e.toLowerCase())}writeHead(e,t,s){if(this.headersSent)throw new o.ERR_HEAD_SET;if(this.statusCode=e,typeof t=="object"?s=t:t&&(this.statusMessage=typeof t=="string"?t.replace(/[\r\n]/g,""):t),s)for(const r of Object.keys(s))this.setHeader(r,s[r]);return this}end(e,t,s){if(typeof e=="function"?(s=e,e=void 0):typeof t=="function"&&(s=t),this.aborted)return s&&process.nextTick(s),this;if(this.destroyed)throw new o.ERR_STREAM_DESTROYED;return this.writableEnded=!0,s&&this.once("finish",s),super.end(h(e,!0)),this}addTrailers(){}destroy(e){return this.destroyed||this.destroying||this.aborted?this:(this.socket.destroy(e),this)}write(e,t,s){if(typeof t=="function"&&(s=t),this.aborted)return s&&process.nextTick(s),!1;if(this.destroyed)throw new o.ERR_STREAM_DESTROYED;const r=h(e);return this.firstChunk&&this.contentLength!==null&&this.contentLength===r.byteLength?(r.end=!0,this.writableEnded=!0,super.end(r),s&&process.nextTick(s),!0):(this.firstChunk=!1,this.headersSent||(this.headersSent=!0,this.socket[i.kHead]={headers:this[i.kHeaders],status:this.status}),this.socket.write(r,null,()=>{this._boundEmitDrain(),s&&s()}),!this.socket.writableNeedDrain)}_emitDrain(){this.emit("drain")}_write(e,t){if(this.aborted)return t();if(this.headersSent||(this.headersSent=!0,this.socket[i.kHead]={headers:this[i.kHeaders],status:this.status}),e.end){this.socket.end(e,null,t);return}this.socket.write(e,null,t)}_destroy(e){if(this.socket.destroyed)return e();this.socket.once("close",e)}}exports.Response=l;

package/dist/response.d.ts

@@ -0,0 +1,40 @@
+import { Writable } from 'streamx';
+import { HTTPSocket } from './http-socket';
+import { kHeaders } from './symbols';
+declare class Header {
+    isMultiValue: boolean;
+    name: string;
+    value: unknown;
+    constructor(name: string, value: unknown);
+}
+export declare class Response extends Writable {
+    socket: HTTPSocket;
+    statusCode: number;
+    statusMessage?: string;
+    headersSent: boolean;
+    chunked: boolean;
+    contentLength: number | null;
+    writableEnded: boolean;
+    firstChunk: boolean;
+    _boundEmitDrain: () => void;
+    [kHeaders]: Map<string, Header>;
+    constructor(socket: HTTPSocket);
+    get aborted(): boolean;
+    get finished(): boolean;
+    get status(): string;
+    get bytesWritten(): number;
+    hasHeader(name: string): boolean;
+    getHeader(name: string): unknown;
+    getHeaders(): Record<string, string>;
+    setHeader(name: string, value: string | string[] | number): this;
+    removeHeader(name: string): void;
+    writeHead(statusCode: number, statusMessage?: string | Record<string, any>, headers?: Record<string, any>): this;
+    end(data?: any, encoding?: any, callback?: () => void): this;
+    addTrailers(): void;
+    destroy(err?: Error): this;
+    write(data: any, encoding?: any, cb?: (err?: Error | null) => void): boolean;
+    _emitDrain(): void;
+    _write(data: any, cb: (err?: Error | null) => void): void;
+    _destroy(cb: (err?: Error | null) => void): void;
+}
+export {};