wassocket 0.1.2

package/README.md

@@ -0,0 +1,54 @@
+# WASSocket (CommonJS)
+
+High-performance WebSocket framework with JWT authentication, auto TLS,
+middleware, plugins, rooms, namespaces and Redis scaling.
+
+## Installation
+```bash
+npm install wassocket
+```
+## Server Example
+```js
+const { WASSocketServer } = require("wassocket"); const server = new
+WASSocketServer({ port: 3000, jwtSecret: "secret" }); server.start();
+```
+
+## Client Example
+```js
+const { WASSocketClient } = require("wassocket"); const client = new
+WASSocketClient("ws://localhost:3000", { token: "JWT" });
+client.connect();
+```
+## Advanced API
+
+### Namespace
+```js
+const chat = server.namespace("/chat"); chat.on("connection", client =\>
+{});
+```
+### Rooms
+```js
+client.join("room1"); server.to("room1").emit("msg", "hello");
+```
+### Middleware
+```js
+server.middleware.usePre(async (ctx, next) =\> { await next(); });
+```
+### Plugin
+```js
+function LoggerPlugin(server) { server.on("connection", c =\>
+console.log(c.id)); } server.use(LoggerPlugin);
+```
+## Cluster & Redis Scaling
+
+Use RedisAdapter to synchronize packets across multiple instances.
+```js
+const { RedisAdapter } = require("wassocket/adapters");
+server.useAdapter(new RedisAdapter({ url: "redis://localhost:6379" }));
+```
+Deploy multiple node processes behind a load balancer.
+
+## Admin Dashboard JWT
+
+Dashboard endpoint requires JWT token. Generate token with same secret
+as server. Attach Authorization header: Bearer `<token>`{=html}.

package/dist/adapter/RedisAdapter.d.ts

@@ -0,0 +1,11 @@
+export type RedisMessageHandler = (channel: string, data: any) => void;
+export declare class RedisAdapter {
+    private pub;
+    private sub;
+    private handlers;
+    constructor(url?: string);
+    connect(): Promise<void>;
+    subscribe(channel: string): Promise<void>;
+    onMessage(handler: RedisMessageHandler): void;
+    publish(channel: string, data: any): void;
+}

package/dist/binary.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Packet opcode
+ */
+export declare enum OpCode {
+    PING = 1,
+    PONG = 2,
+    EVENT = 3,
+    JOIN = 4,
+    LEAVE = 5,
+    ACK = 6
+}
+export interface Packet {
+    op: OpCode;
+    id?: number;
+    ack?: number;
+    event?: string;
+    room?: string;
+    data?: any;
+}
+/**
+ * Encryption options
+ */
+export interface EncryptionOptions {
+    mode: "none" | "xor" | "aes";
+    secret: string;
+}
+/**
+ * Binary Transport
+ * Encode / Decode Packet to Buffer
+ */
+export declare class BinaryTransport {
+    private encryption?;
+    constructor(encryption?: EncryptionOptions);
+    encode(packet: Packet): Buffer;
+    decode(buffer: Buffer): Packet;
+    private encrypt;
+    private decrypt;
+    private xor;
+    private aesEncrypt;
+    private aesDecrypt;
+}

package/dist/client/WASSocketClient.d.ts

@@ -0,0 +1,36 @@
+type Handler = (data: any) => void;
+export interface ClientOptions {
+    encryption?: {
+        mode: "none" | "xor" | "aes";
+        secret: string;
+    };
+    reconnect?: {
+        enabled?: boolean;
+        maxDelay?: number;
+    };
+}
+export declare class WASSocketClient {
+    private options?;
+    private socket?;
+    private handlers;
+    private transport;
+    private url;
+    private connected;
+    private reconnectAttempts;
+    private reconnectTimer?;
+    private offlineQueue;
+    private packetId;
+    private pendingAck;
+    constructor(options?: ClientOptions | undefined);
+    connect(url: string): void;
+    private createSocket;
+    private scheduleReconnect;
+    private flushQueue;
+    private send;
+    emit(event: string, data?: any, room?: string): Promise<void>;
+    join(room: string): void;
+    leave(room: string): void;
+    on(event: string, handler: Handler): void;
+    private handleMessage;
+}
+export {};

package/dist/client.d.ts

@@ -0,0 +1 @@
+export { WASSocketClient } from "./client/WASSocketClient";

package/dist/cluster/cluster.d.ts

@@ -0,0 +1,5 @@
+export interface ClusterOptions {
+    workers?: number;
+    respawn?: boolean;
+}
+export declare function startCluster(startWorker: () => void, options?: ClusterOptions): void;

package/dist/dashboard/dashboardPlugin.d.ts

@@ -0,0 +1,9 @@
+export interface DashboardOptions {
+    port?: number;
+    jwtSecret: string;
+    adminUser?: {
+        username: string;
+        password: string;
+    };
+}
+export declare function dashboardPlugin(options: DashboardOptions): () => void;

package/dist/index.cjs

@@ -0,0 +1,542 @@
+'use strict';
+
+var WebSocket = require('ws');
+var https = require('https');
+var fs = require('fs');
+var crypto = require('crypto');
+var http = require('http');
+var greenlock = require('greenlock-express');
+var redis = require('redis');
+
+function createAutoTLSServer(handler, options) {
+    return new Promise(resolve => {
+        const glx = greenlock.init({
+            packageRoot: process.cwd(),
+            configDir: "./greenlock",
+            maintainerEmail: options.email,
+            cluster: false,
+            staging: options.production === false
+        });
+        const httpServer = http.createServer(glx.middleware());
+        const httpsServer = https.createServer(glx.httpsOptions, handler);
+        glx.ready(() => {
+            console.log("[AutoTLS] Greenlock ready");
+            resolve({
+                httpServer,
+                httpsServer
+            });
+        });
+    });
+}
+
+exports.OpCode = void 0;
+(function (OpCode) {
+    OpCode[OpCode["EVENT"] = 1] = "EVENT";
+    OpCode[OpCode["ACK"] = 2] = "ACK";
+    OpCode[OpCode["JOIN"] = 3] = "JOIN";
+    OpCode[OpCode["LEAVE"] = 4] = "LEAVE";
+    OpCode[OpCode["PING"] = 5] = "PING";
+    OpCode[OpCode["PONG"] = 6] = "PONG";
+})(exports.OpCode || (exports.OpCode = {}));
+
+class CryptoBox {
+    constructor(options) {
+        this.options = options;
+        if ((options === null || options === void 0 ? void 0 : options.mode) === "aes") {
+            this.key = crypto
+                .createHash("sha256")
+                .update(options.secret)
+                .digest();
+        }
+        else {
+            this.key = Buffer.alloc(0);
+        }
+    }
+    encrypt(data) {
+        if (!this.options || this.options.mode === "none") {
+            return data;
+        }
+        if (this.options.mode === "xor") {
+            return this.xor(data);
+        }
+        if (this.options.mode === "aes") {
+            const iv = crypto.randomBytes(12);
+            const cipher = crypto.createCipheriv("aes-256-gcm", this.key, iv);
+            const encrypted = Buffer.concat([
+                cipher.update(data),
+                cipher.final()
+            ]);
+            const tag = cipher.getAuthTag();
+            return Buffer.concat([
+                Buffer.from([iv.length]),
+                iv,
+                Buffer.from([tag.length]),
+                tag,
+                encrypted
+            ]);
+        }
+        return data;
+    }
+    decrypt(data) {
+        if (!this.options || this.options.mode === "none") {
+            return data;
+        }
+        if (this.options.mode === "xor") {
+            return this.xor(data);
+        }
+        if (this.options.mode === "aes") {
+            let offset = 0;
+            const ivLen = data.readUInt8(offset++);
+            const iv = data.subarray(offset, offset + ivLen);
+            offset += ivLen;
+            const tagLen = data.readUInt8(offset++);
+            const tag = data.subarray(offset, offset + tagLen);
+            offset += tagLen;
+            const encrypted = data.subarray(offset);
+            const decipher = crypto.createDecipheriv("aes-256-gcm", this.key, iv);
+            decipher.setAuthTag(tag);
+            return Buffer.concat([
+                decipher.update(encrypted),
+                decipher.final()
+            ]);
+        }
+        return data;
+    }
+    xor(buf) {
+        var _a;
+        const key = Buffer.from(((_a = this.options) === null || _a === void 0 ? void 0 : _a.secret) || "x");
+        const out = Buffer.allocUnsafe(buf.length);
+        for (let i = 0; i < buf.length; i++) {
+            out[i] = buf[i] ^ key[i % key.length];
+        }
+        return out;
+    }
+}
+
+class BinaryTransport {
+    constructor(encryption) {
+        this.crypto = new CryptoBox(encryption);
+    }
+    encode(packet) {
+        const json = JSON.stringify(packet);
+        const raw = Buffer.from(json);
+        return this.crypto.encrypt(raw);
+    }
+    decode(buffer) {
+        const raw = this.crypto.decrypt(buffer);
+        return JSON.parse(raw.toString());
+    }
+}
+
+class RoomManager {
+    constructor() {
+        this.rooms = new Map();
+    }
+    join(room, clientId) {
+        if (!this.rooms.has(room)) {
+            this.rooms.set(room, new Set());
+        }
+        this.rooms.get(room).add(clientId);
+    }
+    leave(room, clientId) {
+        var _a;
+        (_a = this.rooms.get(room)) === null || _a === void 0 ? void 0 : _a.delete(clientId);
+    }
+    removeClient(clientId) {
+        for (const set of this.rooms.values()) {
+            set.delete(clientId);
+        }
+    }
+    getClients(room) {
+        var _a;
+        return (_a = this.rooms.get(room)) !== null && _a !== void 0 ? _a : new Set();
+    }
+}
+
+class RateLimiter {
+    constructor(options) {
+        this.options = options;
+        this.buckets = new Map();
+    }
+    allow(id) {
+        const now = Date.now();
+        let bucket = this.buckets.get(id);
+        if (!bucket) {
+            bucket = {
+                tokens: this.options.capacity,
+                last: now
+            };
+            this.buckets.set(id, bucket);
+        }
+        const delta = (now - bucket.last) / 1000;
+        bucket.tokens = Math.min(this.options.capacity, bucket.tokens + delta * this.options.refillPerSecond);
+        bucket.last = now;
+        if (bucket.tokens < 1)
+            return false;
+        bucket.tokens -= 1;
+        return true;
+    }
+    clear(id) {
+        this.buckets.delete(id);
+    }
+}
+
+class PacketInspector {
+    constructor() {
+        this.listeners = new Set();
+    }
+    onPacket(cb) {
+        this.listeners.add(cb);
+    }
+    emit(packet) {
+        for (const cb of this.listeners) {
+            cb(packet);
+        }
+    }
+}
+const packetInspector = new PacketInspector();
+
+class RedisAdapter {
+    constructor(url = "redis://127.0.0.1:6379") {
+        this.handlers = new Set();
+        this.pub = redis.createClient({ url });
+        this.sub = redis.createClient({ url });
+    }
+    async connect() {
+        await this.pub.connect();
+        await this.sub.connect();
+        console.log("[RedisAdapter] Connected");
+    }
+    async subscribe(channel) {
+        await this.sub.subscribe(channel, message => {
+            try {
+                const data = JSON.parse(message);
+                for (const h of this.handlers) {
+                    h(channel, data);
+                }
+            }
+            catch { }
+        });
+    }
+    onMessage(handler) {
+        this.handlers.add(handler);
+    }
+    publish(channel, data) {
+        this.pub.publish(channel, JSON.stringify(data));
+    }
+}
+
+class WASSocketServer {
+    constructor(port, options) {
+        var _a;
+        this.namespaces = new Map();
+        this.transport = new BinaryTransport(options === null || options === void 0 ? void 0 : options.encryption);
+        this.authProvider = (_a = options === null || options === void 0 ? void 0 : options.auth) === null || _a === void 0 ? void 0 : _a.provider;
+        if (options === null || options === void 0 ? void 0 : options.rateLimit) {
+            this.rateLimiter = new RateLimiter(options.rateLimit);
+        }
+        if (options === null || options === void 0 ? void 0 : options.redisUrl) {
+            this.redis = new RedisAdapter(options.redisUrl);
+            this.redis.connect();
+            this.redis.subscribe("wassocket:broadcast");
+            this.redis.onMessage((_ch, packet) => {
+                // broadcast packet from other nodes
+                for (const [, ns] of this.namespaces) {
+                    for (const [, client] of ns.clients) {
+                        this.send(client, packet);
+                    }
+                }
+            });
+        }
+        if (options === null || options === void 0 ? void 0 : options.autoTLS) {
+            console.log("[WASSocket] Starting AutoTLS...");
+            createAutoTLSServer((req, res) => {
+                // WebSocket upgrade handled by ws internally
+            }, {
+                email: options.autoTLS.email,
+                domain: options.autoTLS.domain,
+                production: options.autoTLS.production
+            }).then(({ httpsServer }) => {
+                this.wss = new WebSocket.WebSocketServer({ server: httpsServer });
+                httpsServer.listen(port);
+                console.log(`[WASSocket] WSS AutoTLS running on :${port}`);
+            });
+        }
+        else if (options === null || options === void 0 ? void 0 : options.tls) {
+            const httpsServer = https.createServer({
+                key: fs.readFileSync(options.tls.key),
+                cert: fs.readFileSync(options.tls.cert)
+            });
+            this.wss = new WebSocket.WebSocketServer({ server: httpsServer });
+            httpsServer.listen(port);
+            console.log(`[WASSocket] WSS running on ${port}`);
+        }
+        else {
+            this.wss = new WebSocket.WebSocketServer({ port });
+            console.log(`[WASSocket] WS running on ${port}`);
+        }
+        this.wss.on("connection", (socket, req) => this.handleConnection(socket, req.url || "/"));
+        this.namespace("/");
+    }
+    // ================= NAMESPACE =================
+    namespace(name) {
+        if (!name.startsWith("/"))
+            name = "/" + name;
+        if (!this.namespaces.has(name)) {
+            this.namespaces.set(name, {
+                name,
+                clients: new Map(),
+                rooms: new RoomManager()
+            });
+        }
+        return this.namespaces.get(name);
+    }
+    // ================= CONNECTION =================
+    async handleConnection(socket, url) {
+        const path = url.split("?")[0] || "/";
+        const ns = this.namespace(path);
+        // ================= AUTH =================
+        const queryString = url.split("?")[1];
+        const query = new URLSearchParams(queryString);
+        const token = query.get("token") || undefined;
+        let user = undefined;
+        if (this.authProvider) {
+            if (!token) {
+                console.warn("[WASSocket] Missing auth token");
+                socket.close();
+                return;
+            }
+            try {
+                const verified = await this.authProvider.verifyToken(token);
+                if (!verified) {
+                    console.warn("[WASSocket] Invalid token");
+                    socket.close();
+                    return;
+                }
+                user = verified;
+            }
+            catch (err) {
+                console.warn("[WASSocket] Auth error", err);
+                socket.close();
+                return;
+            }
+        }
+        // ================= CLIENT =================
+        const id = crypto.randomUUID();
+        const client = {
+            id,
+            socket,
+            lastPing: Date.now(),
+            user
+        };
+        ns.clients.set(id, client);
+        // ================= EVENTS =================
+        socket.on("message", (data) => {
+            if (Buffer.isBuffer(data)) {
+                this.handleMessage(ns, client, data);
+            }
+        });
+        socket.on("close", () => {
+            ns.clients.delete(id);
+            ns.rooms.removeClient(id);
+        });
+    }
+    // ================= MESSAGE =================
+    handleMessage(ns, client, buffer) {
+        try {
+            const packet = this.transport.decode(buffer);
+            packetInspector.emit(packet);
+            if (packet.id) {
+                this.send(client, {
+                    op: exports.OpCode.ACK,
+                    ack: packet.id
+                });
+            }
+            switch (packet.op) {
+                case exports.OpCode.PING:
+                    client.lastPing = Date.now();
+                    this.send(client, { op: exports.OpCode.PONG });
+                    break;
+                case exports.OpCode.JOIN:
+                    packet.room && ns.rooms.join(packet.room, client.id);
+                    break;
+                case exports.OpCode.LEAVE:
+                    packet.room && ns.rooms.leave(packet.room, client.id);
+                    break;
+                case exports.OpCode.EVENT:
+                    if (!packet.event)
+                        break;
+                    if (packet.room) {
+                        this.broadcastRoom(ns, packet.room, packet, client.id);
+                    }
+                    else {
+                        this.broadcast(ns, packet, client.id);
+                    }
+                    break;
+            }
+        }
+        catch (err) {
+            console.warn("[WASSocket] Message error", err);
+        }
+    }
+    // ================= SEND =================
+    send(client, packet) {
+        const buffer = this.transport.encode(packet);
+        client.socket.send(buffer);
+        packetInspector.emit(packet);
+    }
+    broadcast(ns, packet, exceptId) {
+        for (const [id, client] of ns.clients) {
+            if (id === exceptId)
+                continue;
+            this.send(client, packet);
+        }
+        if (this.redis) {
+            this.redis.publish("wassocket:broadcast", packet);
+        }
+    }
+    broadcastRoom(ns, room, packet, exceptId) {
+        const ids = ns.rooms.getClients(room);
+        for (const id of ids) {
+            if (id === exceptId)
+                continue;
+            const client = ns.clients.get(id);
+            if (client)
+                this.send(client, packet);
+        }
+        if (this.redis) {
+            this.redis.publish("wassocket:broadcast", packet);
+        }
+    }
+}
+
+class WASSocketClient {
+    constructor(options) {
+        this.options = options;
+        this.handlers = new Map();
+        this.url = "";
+        this.connected = false;
+        this.reconnectAttempts = 0;
+        this.offlineQueue = [];
+        this.packetId = 1;
+        this.pendingAck = new Map();
+        this.transport = new BinaryTransport(options === null || options === void 0 ? void 0 : options.encryption);
+    }
+    // ================= CONNECT =================
+    connect(url) {
+        this.url = url;
+        this.createSocket();
+    }
+    createSocket() {
+        this.socket = new WebSocket(this.url);
+        this.socket.on("open", () => {
+            console.log("[WASSocket] Connected");
+            this.connected = true;
+            this.reconnectAttempts = 0;
+            this.flushQueue();
+        });
+        this.socket.on("message", data => {
+            if (Buffer.isBuffer(data)) {
+                this.handleMessage(data);
+            }
+        });
+        this.socket.on("close", () => {
+            console.warn("[WASSocket] Disconnected");
+            this.connected = false;
+            this.scheduleReconnect();
+        });
+    }
+    // ================= RECONNECT =================
+    scheduleReconnect() {
+        var _a, _b, _c, _d, _e;
+        if (((_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.reconnect) === null || _b === void 0 ? void 0 : _b.enabled) === false)
+            return;
+        const maxDelay = (_e = (_d = (_c = this.options) === null || _c === void 0 ? void 0 : _c.reconnect) === null || _d === void 0 ? void 0 : _d.maxDelay) !== null && _e !== void 0 ? _e : 15000;
+        const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), maxDelay);
+        this.reconnectAttempts++;
+        clearTimeout(this.reconnectTimer);
+        console.log(`[WASSocket] Reconnect in ${delay}ms`);
+        this.reconnectTimer = setTimeout(() => {
+            this.createSocket();
+        }, delay);
+    }
+    // ================= QUEUE =================
+    flushQueue() {
+        while (this.offlineQueue.length > 0) {
+            this.send(this.offlineQueue.shift());
+        }
+    }
+    // ================= SEND =================
+    send(packet) {
+        if (!this.connected || !this.socket) {
+            this.offlineQueue.push(packet);
+            return;
+        }
+        const buffer = this.transport.encode(packet);
+        this.socket.send(buffer);
+    }
+    // ================= API =================
+    emit(event, data, room) {
+        const id = this.packetId++;
+        const packet = {
+            op: exports.OpCode.EVENT,
+            event,
+            data,
+            room,
+            id
+        };
+        return new Promise(resolve => {
+            const timer = setTimeout(() => {
+                console.warn("[WASSocket] ACK timeout, retry", id);
+                this.send(packet);
+            }, 3000);
+            this.pendingAck.set(id, {
+                resolve,
+                timer,
+                packet
+            });
+            this.send(packet);
+        });
+    }
+    join(room) {
+        this.send({ op: exports.OpCode.JOIN, room });
+    }
+    leave(room) {
+        this.send({ op: exports.OpCode.LEAVE, room });
+    }
+    on(event, handler) {
+        if (!this.handlers.has(event)) {
+            this.handlers.set(event, new Set());
+        }
+        this.handlers.get(event).add(handler);
+    }
+    // ================= MESSAGE =================
+    handleMessage(buffer) {
+        try {
+            const packet = this.transport.decode(buffer);
+            if (packet.op === exports.OpCode.ACK && packet.ack) {
+                const pending = this.pendingAck.get(packet.ack);
+                if (pending) {
+                    clearTimeout(pending.timer);
+                    pending.resolve();
+                    this.pendingAck.delete(packet.ack);
+                }
+                return;
+            }
+            if (packet.op === exports.OpCode.EVENT && packet.event) {
+                const set = this.handlers.get(packet.event);
+                if (!set)
+                    return;
+                for (const fn of set)
+                    fn(packet.data);
+            }
+        }
+        catch (err) {
+            console.warn("[WASSocket] Decode error", err);
+        }
+    }
+}
+
+exports.WASSocketClient = WASSocketClient;
+exports.WASSocketServer = WASSocketServer;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { WASSocketServer } from "./server/WASSocketServer";
+export { WASSocketClient } from "./client/WASSocketClient";
+export * from "./protocol";

package/dist/middleware.d.ts

@@ -0,0 +1,15 @@
+import { Packet } from "./protocol";
+export interface MiddlewareContext {
+    clientId: string;
+    packet: Packet;
+}
+export type Middleware = (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void | boolean>;
+export declare class MiddlewareManager {
+    private pre;
+    private post;
+    usePre(fn: Middleware): void;
+    usePost(fn: Middleware): void;
+    runPre(ctx: MiddlewareContext): Promise<boolean>;
+    runPost(ctx: MiddlewareContext): Promise<boolean>;
+    private runChain;
+}

package/dist/monitoring/metrics.d.ts

@@ -0,0 +1,13 @@
+export declare class Metrics {
+    connections: number;
+    packetsIn: number;
+    packetsOut: number;
+    startTime: number;
+    snapshot(): {
+        uptime: number;
+        connections: number;
+        packetsIn: number;
+        packetsOut: number;
+    };
+}
+export declare const metrics: Metrics;

package/dist/monitoring/metricsPlugin.d.ts

@@ -0,0 +1,12 @@
+import { Packet } from "../protocol";
+export interface PacketLog {
+    time: number;
+    direction: "IN" | "OUT";
+    clientId: string;
+    packet: Packet;
+}
+export declare class PacketInspector {
+    private logs;
+    record(direction: "IN" | "OUT", clientId: string, packet: Packet): void;
+    snapshot(limit?: number): PacketLog[];
+}

package/dist/monitoring/packetInspector.d.ts

@@ -0,0 +1,8 @@
+type PacketListener = (packet: any) => void;
+export declare class PacketInspector {
+    private listeners;
+    onPacket(cb: PacketListener): void;
+    emit(packet: any): void;
+}
+export declare const packetInspector: PacketInspector;
+export {};

package/dist/namespace.d.ts

@@ -0,0 +1,23 @@
+import { ClientContext } from "./server/WASSocketServer";
+export declare class RoomManager {
+    private rooms;
+    join(room: string, clientId: string): void;
+    leave(room: string, clientId: string): void;
+    getClients(room: string): Set<string>;
+}
+export declare class Middleware {
+    private pre;
+    private post;
+    use(fn: Function): void;
+    runPre(ctx: any): Promise<boolean>;
+    runPost(ctx: any): Promise<void>;
+}
+export declare class Namespace {
+    name: string;
+    clients: Map<string, ClientContext>;
+    rooms: RoomManager;
+    middleware: Middleware;
+    constructor(name: string);
+    addClient(client: ClientContext): void;
+    removeClient(id: string): void;
+}

package/dist/plugin.d.ts

@@ -0,0 +1,15 @@
+import { WASSocketServer } from "./server/WASSocketServer";
+import { Namespace } from "./namespace";
+export interface WASSocketPlugin {
+    name: string;
+    install(server: WASSocketServer): void;
+    uninstall?(server: WASSocketServer): void;
+    onNamespaceCreate?(ns: Namespace): void;
+}
+export declare class PluginManager {
+    private plugins;
+    install(plugin: WASSocketPlugin, server: WASSocketServer): void;
+    uninstall(name: string, server: WASSocketServer): void;
+    notifyNamespaceCreate(ns: Namespace): void;
+    list(): string[];
+}

package/dist/protocol.d.ts

@@ -0,0 +1,16 @@
+export declare enum OpCode {
+    EVENT = 1,
+    ACK = 2,
+    JOIN = 3,
+    LEAVE = 4,
+    PING = 5,
+    PONG = 6
+}
+export interface Packet {
+    op: OpCode;
+    id?: number;
+    ack?: number;
+    event?: string;
+    data?: any;
+    room?: string;
+}

package/dist/security/Auth.d.ts

@@ -0,0 +1,17 @@
+export interface AuthUser {
+    id: string;
+    name?: string;
+    roles?: string[];
+}
+export interface AuthProvider {
+    verifyToken(token: string): Promise<AuthUser | null>;
+}
+export interface JwtOptions {
+    secret: string;
+}
+export declare class JwtAuthProvider implements AuthProvider {
+    private options;
+    constructor(options: JwtOptions);
+    verifyToken(token: string): Promise<AuthUser | null>;
+    static sign(payload: AuthUser, secret: string, expiresIn?: string): any;
+}

package/dist/security/authPlugin.d.ts

@@ -0,0 +1,2 @@
+import { AuthProvider } from "./Auth";
+export declare function authPlugin(provider: AuthProvider): (server: any) => void;

package/dist/security/autoTLS.d.ts

@@ -0,0 +1,13 @@
+import http from "http";
+import https from "https";
+export interface AutoTLSOptions {
+    email: string;
+    domain: string;
+    agreeTos?: boolean;
+    production?: boolean;
+}
+export interface AutoTLSServer {
+    httpServer: http.Server;
+    httpsServer: https.Server;
+}
+export declare function createAutoTLSServer(handler: (req: http.IncomingMessage, res: http.ServerResponse) => void, options: AutoTLSOptions): Promise<AutoTLSServer>;

package/dist/security/rateLimit.d.ts

@@ -0,0 +1,11 @@
+export interface RateLimitOptions {
+    capacity: number;
+    refillPerSecond: number;
+}
+export declare class RateLimiter {
+    private options;
+    private buckets;
+    constructor(options: RateLimitOptions);
+    allow(id: string): boolean;
+    clear(id: string): void;
+}

package/dist/server/RoomManager.d.ts

@@ -0,0 +1,7 @@
+export declare class RoomManager {
+    private rooms;
+    join(room: string, clientId: string): void;
+    leave(room: string, clientId: string): void;
+    removeClient(clientId: string): void;
+    getClients(room: string): Set<string>;
+}

package/dist/server/WASSocketServer.d.ts

@@ -0,0 +1,56 @@
+import WebSocket from "ws";
+import { Packet } from "../protocol";
+import { BinaryTransport } from "../transport/binary";
+import { RoomManager } from "./RoomManager";
+import { AuthProvider } from "../security/Auth";
+export interface ServerOptions {
+    encryption?: {
+        mode: "none" | "xor" | "aes";
+        secret: string;
+    };
+    auth?: {
+        provider: AuthProvider;
+    };
+    rateLimit?: {
+        capacity: number;
+        refillPerSecond: number;
+    };
+    tls?: {
+        key: string;
+        cert: string;
+    };
+    autoTLS?: {
+        email: string;
+        domain: string;
+        production?: boolean;
+    };
+}
+export interface ClientContext {
+    id: string;
+    socket: WebSocket;
+    lastPing: number;
+    user?: any;
+}
+interface Namespace {
+    name: string;
+    clients: Map<string, ClientContext>;
+    rooms: RoomManager;
+}
+export declare class WASSocketServer {
+    private authProvider?;
+    private rateLimiter?;
+    private redis?;
+    private wss;
+    private namespaces;
+    transport: BinaryTransport;
+    constructor(port: number, options?: ServerOptions & {
+        redisUrl?: string;
+    });
+    namespace(name: string): Namespace;
+    private handleConnection;
+    private handleMessage;
+    private send;
+    private broadcast;
+    protected broadcastRoom(ns: Namespace, room: string, packet: Packet, exceptId?: string): void;
+}
+export {};

package/dist/transport/binary.d.ts

@@ -0,0 +1,8 @@
+import { Packet } from "../protocol";
+import { EncryptionOptions } from "./crypto";
+export declare class BinaryTransport {
+    private crypto;
+    constructor(encryption?: EncryptionOptions);
+    encode(packet: Packet): Buffer;
+    decode(buffer: Buffer): Packet;
+}

package/dist/transport/crypto.d.ts

@@ -0,0 +1,13 @@
+export type EncryptionMode = "none" | "xor" | "aes";
+export interface EncryptionOptions {
+    mode: EncryptionMode;
+    secret: string;
+}
+export declare class CryptoBox {
+    private options?;
+    private key;
+    constructor(options?: EncryptionOptions | undefined);
+    encrypt(data: Buffer): Buffer;
+    decrypt(data: Buffer): Buffer;
+    private xor;
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "wassocket",
+  "version": "0.1.2",
+  "description": "High performance WebSocket framework with rooms, middleware, redis adapter",
+  "type": "commonjs",
+  "main": "dist/index.cjs",
+  "module": "../wassocketesm/dist/index.mjs",
+  "types": "../core/dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs",
+      "types": "./core/dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "ws": "^8.16.0",
+    "redis": "^4.6.0",
+    "jsonwebtoken": "^9.0.0",
+    "greenlock-express": "^4.0.0"
+  }
+}