@derivesome/sockets 1.0.0

package/src/server/app.ts

@@ -0,0 +1,171 @@
+import { Server } from "./server";
+import { WebSocketServer } from "ws";
+import { PubSub, pubsub } from "@derivesome/core";
+import { ServerEvent } from "./events";
+import { Socket } from "../socket";
+import { BinaryBuffer, BinaryType, serial } from "binencode";
+import { Plugin } from "./plugin";
+
+export type AppConfig = {
+  host: string;
+  port: number;
+  certPath?: string;
+};
+
+export class App {
+  config: AppConfig;
+  server: Server;
+  ps: PubSub<ServerEvent>;
+  plugins: Map<string, Plugin> = new Map();
+
+  constructor(cfg: AppConfig) {
+    this.config = cfg;
+    this.server = new Server(cfg);
+    this.ps = pubsub();
+  }
+
+  use(plugin: Plugin) {
+    this.plugins.set(plugin.name, plugin);
+    this.ps.subscribe(async (event) => {
+      if (event.type === 'client-message') {
+        const data = event.message;
+        if (data.type === BinaryType.OBJECT) {
+          const channelBin = data.data.get('channel');
+          if (channelBin && channelBin.type === BinaryType.STRING) {
+            const channel = channelBin.data.with((buff) => buff.readString(channelBin.count)); 
+            if (channel !== plugin.name) return;
+          }
+        }
+      }
+      
+      await plugin.handler(event);
+    }, async () => {
+      if (plugin.onDestroy) {
+        await plugin.onDestroy();
+      }
+      this.plugins.delete(plugin.name);
+    });
+  }
+
+  private init(ws: WebSocketServer) {
+    ws.addListener("listening", async () => {
+      await this.ps.publishAsync({
+        type: "server-ready",
+        app: this,
+        ws,
+      });
+    });
+    ws.addListener("headers", async (headers, req) => {
+      await this.ps.publishAsync({
+        type: "server-headers",
+        app: this,
+        ws,
+        req,
+        headers,
+      });
+    });
+    ws.addListener("connection", async (client, req) => {
+      const socket = new Socket(() => client);
+      await this.ps.publishAsync({
+        type: "client-connection",
+        app: this,
+        ws,
+        req,
+        socket,
+      });
+
+      socket.connection.addEventListener("open", async (ev) => {
+        await this.ps.publishAsync({
+          type: "client-open",
+          app: this,
+          ws,
+          event: ev,
+          socket,
+        });
+      });
+
+      socket.connection.addEventListener("close", async (ev) => {
+        await this.ps.publishAsync({
+          type: "client-close",
+          app: this,
+          ws,
+          event: ev,
+          socket,
+        });
+      });
+
+      socket.connection.addEventListener("error", async (ev) => {
+        await this.ps.publishAsync({
+          type: "client-error",
+          app: this,
+          ws,
+          event: ev,
+          socket,
+        });
+      });
+
+      socket.connection.on("upgrade", async (req) => {
+        await this.ps.publishAsync({
+          type: "client-upgrade",
+          app: this,
+          ws,
+          req,
+          socket,
+        });
+      });
+
+      socket.connection.on("message", async (data, isBinary) => {
+        await this.ps.publishAsync({
+          type: "client-message-raw",
+          app: this,
+          isBinary,
+          message: data,
+          socket,
+          ws,
+        });
+
+        let buffer;
+
+        try {
+          buffer = new BinaryBuffer();
+          buffer.data = new Uint8Array(data as any);
+        } catch (e) {
+          console.error(e);
+        }
+
+        if (!buffer) {
+          console.error("Invalid client message");
+          return;
+        }
+
+        let decoded;
+
+        try {
+          decoded = serial.decode(buffer);
+        } catch (e) {
+          console.error(e);
+        }
+
+        if (!decoded) return;
+
+        await this.ps.publishAsync({
+          type: "client-message",
+          app: this,
+          message: decoded,
+          socket,
+          ws,
+        });
+      });
+    });
+  }
+
+  start() {
+    const { certPath } = this.config;
+
+    if (certPath) {
+      this.init(this.server.startSecure(certPath));
+    } else {
+      this.init(this.server.start());
+    }
+  }
+}

package/src/server/app.ts~

@@ -0,0 +1,171 @@
+import { Server } from "./server";
+import { WebSocketServer } from "ws";
+import { PubSub, pubsub } from "@derivesome/core";
+import { ServerEvent } from "./events";
+import { Socket } from "../socket";
+import { BinaryBuffer, BinaryType, serial } from "binencode";
+import { Plugin } from "./plugin";
+
+export type AppConfig = {
+  host: string;
+  port: number;
+  certPath?: string;
+};
+
+export class App {
+  config: AppConfig;
+  server: Server;
+  ps: PubSub<ServerEvent>;
+  plugins: Map<string, Plugin> = new Map();
+
+  constructor(cfg: AppConfig) {
+    this.config = cfg;
+    this.server = new Server(cfg);
+    this.ps = pubsub();
+  }
+
+  use(plugin: Plugin) {
+    this.plugins.set(plugin.name, plugin);
+    this.ps.subscribe(async (event) => {
+      if (event.type === 'client-message') {
+        const data = event.message;
+        if (data.type === BinaryType.OBJECT) {
+          const channelBin = data.data.get('channel');
+          if (channelBin && channelBin.type === BinaryType.STRING) {
+            const channel = channelBin.data.with((buff) => buff.readString(channelBin.count)); 
+            if (channel !== plugin.name) return;
+          }
+        }
+      }
+      
+      await plugin.handler(event);
+    }, async () => {
+      if (plugin.onDestroy) {
+        await plugin.onDestroy();
+      }
+      this.plugins.delete(plugin.name);
+    });
+  }
+
+  private init(ws: WebSocketServer) {
+    ws.addListener("listening", async () => {
+      await this.ps.publishAsync({
+        type: "server-ready",
+        app: this,
+        ws,
+      });
+    });
+    ws.addListener("headers", async (headers, req) => {
+      await this.ps.publishAsync({
+        type: "server-headers",
+        app: this,
+        ws,
+        req,
+        headers,
+      });
+    });
+    ws.addListener("connection", async (client, req) => {
+      const socket = new Socket(client);
+      await this.ps.publishAsync({
+        type: "client-connection",
+        app: this,
+        ws,
+        req,
+        socket,
+      });
+
+      socket.connection.addEventListener("open", async (ev) => {
+        await this.ps.publishAsync({
+          type: "client-open",
+          app: this,
+          ws,
+          event: ev,
+          socket,
+        });
+      });
+
+      socket.connection.addEventListener("close", async (ev) => {
+        await this.ps.publishAsync({
+          type: "client-close",
+          app: this,
+          ws,
+          event: ev,
+          socket,
+        });
+      });
+
+      socket.connection.addEventListener("error", async (ev) => {
+        await this.ps.publishAsync({
+          type: "client-error",
+          app: this,
+          ws,
+          event: ev,
+          socket,
+        });
+      });
+
+      socket.connection.on("upgrade", async (req) => {
+        await this.ps.publishAsync({
+          type: "client-upgrade",
+          app: this,
+          ws,
+          req,
+          socket,
+        });
+      });
+
+      socket.connection.on("message", async (data, isBinary) => {
+        await this.ps.publishAsync({
+          type: "client-message-raw",
+          app: this,
+          isBinary,
+          message: data,
+          socket,
+          ws,
+        });
+
+        let buffer;
+
+        try {
+          buffer = new BinaryBuffer();
+          buffer.data = new Uint8Array(data as any);
+        } catch (e) {
+          console.error(e);
+        }
+
+        if (!buffer) {
+          console.error("Invalid client message");
+          return;
+        }
+
+        let decoded;
+
+        try {
+          decoded = serial.decode(buffer);
+        } catch (e) {
+          console.error(e);
+        }
+
+        if (!decoded) return;
+
+        await this.ps.publishAsync({
+          type: "client-message",
+          app: this,
+          message: decoded,
+          socket,
+          ws,
+        });
+      });
+    });
+  }
+
+  start() {
+    const { certPath } = this.config;
+
+    if (certPath) {
+      this.init(this.server.startSecure(certPath));
+    } else {
+      this.init(this.server.start());
+    }
+  }
+}

package/src/server/events.ts

@@ -0,0 +1,41 @@
+import { type Binary } from "binencode";
+import { type App } from "./app";
+import { type WebSocketServer, type RawData } from "ws";
+import { type IncomingMessage } from "http";
+import { type Socket } from "../socket";
+import { type ErrorEvent, type CloseEvent, type Event as WSEvent } from "ws";
+
+export type BaseServerEvent<
+  Type extends string,
+  Data extends Record<string, unknown> = {},
+> = Data & {
+  type: Type;
+  app: App;
+  ws: WebSocketServer;
+};
+
+export type ServerEvent =
+  | BaseServerEvent<
+      "server-headers",
+      { headers: string[]; req: IncomingMessage }
+    >
+  | BaseServerEvent<
+      "client-headers",
+      { headers: string[]; req: IncomingMessage }
+    >
+  | BaseServerEvent<
+      "client-connection",
+      { socket: Socket; req: IncomingMessage }
+    >
+  | BaseServerEvent<"client-message", { socket: Socket; message: Binary }>
+  | BaseServerEvent<
+      "client-message-raw",
+      { socket: Socket; message: RawData; isBinary: boolean }
+    >
+  | BaseServerEvent<"client-error", { socket: Socket; event: ErrorEvent }>
+  | BaseServerEvent<"client-open", { socket: Socket; event: WSEvent }>
+  | BaseServerEvent<"client-close", { socket: Socket; event: CloseEvent }>
+  | BaseServerEvent<"client-upgrade", { socket: Socket; req: IncomingMessage }>
+  | BaseServerEvent<"server-ready">
+  | BaseServerEvent<"server-error">
+  | BaseServerEvent<"server-close">;

package/src/server/events.ts~

@@ -0,0 +1,47 @@
+import { type Binary } from "binencode";
+import { type App } from "./app";
+import { type WebSocketServer, type WebSocket, type RawData } from "ws";
+import { type IncomingMessage } from "http";
+import { type Socket } from "../socket";
+import { type ErrorEvent, type CloseEvent, type Event as WSEvent } from "ws";
+
+export type BaseServerEvent<
+  Type extends string,
+  Data extends Record<string, unknown> = {},
+> = Data & {
+  type: Type;
+  app: App;
+  ws: WebSocketServer;
+};
+
+export type ServerEvent =
+  | BaseServerEvent<
+      "server-headers",
+      { headers: string[]; req: IncomingMessage }
+    >
+  | BaseServerEvent<
+      "client-headers",
+      { headers: string[]; req: IncomingMessage }
+    >
+  | BaseServerEvent<
+      "client-connection",
+      { socket: Socket; req: IncomingMessage }
+    >
+  | BaseServerEvent<"client-message", { socket: Socket; message: Binary }>
+  | BaseServerEvent<
+      "client-message-raw",
+      { socket: Socket; message: RawData; isBinary: boolean }
+    >
+  | BaseServerEvent<
+      "client-error",
+      { socket: Socket; event: ErrorEvent }
+    >
+  | BaseServerEvent<"client-open", { socket: Socket; event: WSEvent }>
+  | BaseServerEvent<
+      "client-close",
+      { socket: Socket; event: CloseEvent }
+    >
+  | BaseServerEvent<"client-upgrade", { socket: Socket; req: IncomingMessage }>
+  | BaseServerEvent<"server-ready">
+  | BaseServerEvent<"server-error">
+  | BaseServerEvent<"server-close">;

package/src/server/index.ts

@@ -0,0 +1,4 @@
+export * from "./server";
+export * from "./app";
+export * from "./events";
+export * from "./plugin";

package/src/server/index.ts~

@@ -0,0 +1 @@
+export * from './server';

package/src/server/plugin.ts

@@ -0,0 +1,8 @@
+import { Subscription } from "@derivesome/core";
+import { ServerEvent } from "./events";
+
+export type Plugin = {
+  name: string;
+  handler: Subscription<ServerEvent>;
+  onDestroy?: () => void | Promise<void>;
+};

package/src/server/plugin.ts~

@@ -0,0 +1,8 @@
+import { Subscription } from "@derivesome/core";
+import { ServerEvent } from "./events";
+
+export type Plugin = {
+  name: string;
+  handler: Subscription<ServerEvent>;
+  onDestroy?: () => void | Promise<void>;
+};

package/src/server/server.ts

@@ -0,0 +1,62 @@
+import { WebSocketServer } from "ws";
+import { createServer as createHTTPSServer } from "https";
+import fs from "fs";
+import pathlib from "path";
+
+export type ServerConfig = {
+  host: string;
+  port: number;
+};
+
+export class Server {
+  config: ServerConfig;
+  connection: WebSocketServer | null = null;
+
+  constructor(cfg: ServerConfig) {
+    this.config = cfg;
+  }
+
+  startSecure(certPath: string) {
+    const pemPath = pathlib.join(certPath, "cert.pem");
+    const privKeyPath = pathlib.join(certPath, "privkey.pem");
+    const chainPemPath = pathlib.join(certPath, "chain.pem");
+    if (!fs.existsSync(pemPath)) throw new Error(`Could not find: ${pemPath}`);
+    if (!fs.existsSync(privKeyPath))
+      throw new Error(`Could not find: ${privKeyPath}`);
+    if (!fs.existsSync(chainPemPath))
+      throw new Error(`Could not find: ${chainPemPath}`);
+
+    const httpsServer = createHTTPSServer({
+      cert: fs.readFileSync(pemPath, "utf8"),
+      key: fs.readFileSync(privKeyPath, "utf8"),
+      ca: fs.readFileSync(chainPemPath, "utf8"),
+    });
+
+    httpsServer.listen({
+      port: this.config.port,
+      host: this.config.host,
+    });
+
+    const server = new WebSocketServer({
+      server: httpsServer,
+    });
+
+    this.connection = server;
+    console.log(
+      `Secure websocket server listening on ${this.config.host}:${this.config.port}`,
+    );
+    return server;
+  }
+
+  start() {
+    const server = new WebSocketServer({
+      host: this.config.host,
+      port: this.config.port,
+    });
+    this.connection = server;
+    console.log(
+      `Insecure websocket server listening on ${this.config.host}:${this.config.port}`,
+    );
+    return server;
+  }
+}

package/src/server/server.ts~

@@ -0,0 +1,62 @@
+import { WebSocketServer } from "ws";
+import { createServer as createHTTPSServer } from "https";
+import fs from "fs";
+import pathlib from "path";
+
+export type ServerConfig = {
+  host: string;
+  port: number;
+};
+
+export class Server {
+  config: ServerConfig;
+  connection: WebSocketServer | null = null;
+
+  constructor(cfg: ServerConfig) {
+    this.config = cfg;
+  }
+
+  startSecure(certPath: string) {
+    const pemPath = pathlib.join(certPath, "cert.pem");
+    const privKeyPath = pathlib.join(certPath, "privkey.pem");
+    const chainPemPath = pathlib.join(certPath, "chain.pem");
+    if (!fs.existsSync(pemPath)) throw new Error(`Could not find: ${pemPath}`);
+    if (!fs.existsSync(privKeyPath))
+      throw new Error(`Could not find: ${privKeyPath}`);
+    if (!fs.existsSync(chainPemPath))
+      throw new Error(`Could not find: ${chainPemPath}`);
+
+    const httpsServer = createHTTPSServer({
+      cert: fs.readFileSync(pemPath, "utf8"),
+      key: fs.readFileSync(privKeyPath, "utf8"),
+      ca: fs.readFileSync(chainPemPath, "utf8"),
+    });
+
+    httpsServer.listen({
+      port: this.config.port,
+      host: this.config.host,
+    });
+
+    const server = new WebSocketServer({
+      server: httpsServer,
+    });
+
+    this.connection = server;
+    console.log(
+      `Secure websocket server listening on ${this.config.host}:${this.config.port}`,
+    );
+    return server;
+  }
+
+  start() {
+    const server = new WebSocketServer({
+      host: this.config.host,
+      port: this.config.port,
+    });
+    this.connection = server;
+    console.log(
+      `Insecure websocket server listening on ${this.config.host}:${this.config.port}`,
+    );
+    return server;
+  }
+}

package/src/server.ts~

@@ -0,0 +1,73 @@
+import { WebSocketServer } from "ws";
+import { createServer as createHTTPSServer } from "https";
+import fs from "fs";
+import pathlib from "path";
+
+export type ServerConfig = {
+  host: string;
+  port: number;
+};
+
+export class Server {
+  config: ServerConfig;
+  connection: WebSocketServer | null = null;
+
+  constructor(cfg: ServerConfig) {
+    this.config = cfg;
+  }
+
+  private init(server: WebSocketServer) {}
+
+  startSecure(certPath: string) {
+    const pemPath = pathlib.join(certPath, "cert.pem");
+    const privKeyPath = pathlib.join(certPath, "privkey.pem");
+    const chainPemPath = pathlib.join(certPath, "chain.pem");
+    if (!fs.existsSync(pemPath)) throw new Error(`Could not find: ${pemPath}`);
+    if (!fs.existsSync(privKeyPath))
+      throw new Error(`Could not find: ${privKeyPath}`);
+    if (!fs.existsSync(chainPemPath))
+      throw new Error(`Could not find: ${chainPemPath}`);
+
+    const httpsServer = createHTTPSServer({
+      cert: fs.readFileSync(pemPath, "utf8"),
+      key: fs.readFileSync(privKeyPath, "utf8"),
+      ca: fs.readFileSync(chainPemPath, "utf8"),
+    });
+
+    httpsServer.listen({
+      port: this.config.port,
+      host: this.config.host,
+    });
+
+    const server = new WebSocketServer({
+      server: httpsServer,
+    });
+
+    this.connection = server;
+    console.log(
+      `Secure websocket server listening on ${this.config.host}:${this.config.port}`,
+    );
+    this.init(server);
+    return server;
+  }
+
+  start() {
+    const server = new WebSocketServer({
+      host: this.config.host,
+      port: this.config.port,
+    });
+    this.connection = server;
+    console.log(
+      `Insecure websocket server listening on ${this.config.host}:${this.config.port}`,
+    );
+    this.init(server);
+    return server;
+  }
+}
+
+const s = new Server({
+  host: "localhost",
+  port: 5596,
+});
+
+s.start();

package/src/socket-impl.ts~

@@ -0,0 +1,5 @@
+const _global = typeof global !== 'undefined' && typeof global.WebSocket !== 'undefined' ? global : typeof window !== 'undefined' ? window : undefined;
+
+
+export const SocketImplementation = _global?.WebSocket || require('ws');
+export type SocketType = InstanceType<typeof SocketImplementation>;