@afterlink/server 1.0.0

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@afterlink/server",
+  "version": "1.0.0",
+  "description": "AfterLink Protocol Server SDK - TCP server with routing, middleware, and pub/sub",
+  "main": "src/index.js",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AJAYMYTH/AfterLink.git",
+    "directory": "packages/server"
+  },
+  "keywords": [
+    "afterlink",
+    "server",
+    "tcp",
+    "protocol",
+    "pubsub",
+    "messaging",
+    "routing",
+    "middleware"
+  ],
+  "files": [
+    "src/**/*.js"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@afterlink/core": "1.0.0"
+  },
+  "devDependencies": {
+    "vitest": "^1.6.0"
+  }
+}

package/src/Connection.js

@@ -0,0 +1,146 @@
+const {
+  Frame,
+  FrameTypes: { HELLO, HELLO_ACK, ERROR },
+  Serializer,
+} = require('@afterlink/core');
+const FrameAccumulator = require('./FrameAccumulator');
+
+class Connection {
+  constructor(socket, router, options = {}) {
+    this.socket = socket;
+    this.router = router;
+    this.session = null;
+    this.options = options;
+    this._id = `conn_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    this._closed = false;
+
+    try {
+      this.accumulator = new FrameAccumulator(this._handleFrame.bind(this));
+    } catch (err) {
+      this._onError(err);
+      socket.destroy();
+      return;
+    }
+
+    socket.on('data', (data) => this._onData(data));
+    socket.on('close', () => this._onClose());
+    socket.on('error', (err) => this._onError(err));
+  }
+
+  getId() {
+    return this._id;
+  }
+
+  getSession() {
+    return this.session;
+  }
+
+  getRemoteAddress() {
+    return this.socket.remoteAddress || 'unknown';
+  }
+
+  _onData(data) {
+    if (this._closed) return;
+    try {
+      this.accumulator.push(data);
+    } catch (err) {
+      this._onError(err);
+      this.sendError('PROTOCOL_ERROR', err.message);
+      this.socket.destroy();
+    }
+  }
+
+  _handleFrame(frame) {
+    if (this._closed) return;
+
+    if (frame.type === HELLO && !this.session) {
+      this._handleHandshake(frame);
+    } else if (this.session) {
+      this.router.dispatch(frame, this).catch((err) => {
+        this._onError(err);
+      });
+    } else {
+      this.sendError('AUTH_REQUIRED', 'Send HELLO first');
+      this.socket.destroy();
+    }
+  }
+
+  _handleHandshake(frame) {
+    try {
+      const data = Serializer.decode(frame.payload);
+      const sessionId = `session_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+
+      if (this.options.auth && data.auth) {
+        this._validateAuth(data.auth);
+      }
+
+      this.session = {
+        id: sessionId,
+        version: data.version || 'AL/1',
+        capabilities: data.capabilities || [],
+        connectedAt: new Date().toISOString(),
+        remoteAddress: this.getRemoteAddress(),
+      };
+
+      const ackPayload = Serializer.encode({
+        session_id: sessionId,
+        server_version: 'AL/1',
+        capabilities: ['streaming', 'pubsub', 'compression'],
+      });
+      this.send(HELLO_ACK, 0, frame.messageId, ackPayload);
+    } catch (err) {
+      this.sendError('AUTH_INVALID', err.message);
+      this.socket.destroy();
+    }
+  }
+
+  _validateAuth(token) {
+    if (this.options.auth?.type === 'jwt' && this.options.auth.secret) {
+      const { jwtVerify } = require('jose');
+      return jwtVerify(token, new TextEncoder().encode(this.options.auth.secret));
+    }
+  }
+
+  send(type, flags, messageId, payload) {
+    if (this._closed || this.socket.destroyed) return;
+    try {
+      const frame = Frame.encode(type, flags, messageId, payload);
+      this.socket.write(frame);
+    } catch (err) {
+      this._onError(err);
+    }
+  }
+
+  sendError(code, message, messageId = 0) {
+    if (this._closed || this.socket.destroyed) return;
+    try {
+      const payload = Serializer.encode({ code, message });
+      this.send(ERROR, 0, messageId, payload);
+    } catch (err) {
+      this._onError(err);
+    }
+  }
+
+  _onError(err) {
+    if (err.code === 'ECONNRESET' || err.code === 'EPIPE') return;
+    console.error(`[AfterLink] Connection ${this._id} error:`, err.message);
+  }
+
+  _onClose() {
+    this._closed = true;
+    this.router.onDisconnect(this);
+  }
+
+  destroy() {
+    this._closed = true;
+    if (!this.socket.destroyed) {
+      this.socket.destroy();
+    }
+  }
+
+  isActive() {
+    return !this._closed && !this.socket.destroyed && this.session !== null;
+  }
+}
+
+module.exports = Connection;

package/src/FrameAccumulator.js

@@ -0,0 +1,35 @@
+const { Frame } = require('@afterlink/core');
+
+class FrameAccumulator {
+  constructor(onFrame, options = {}) {
+    this.buffer = Buffer.alloc(0);
+    this.onFrame = onFrame;
+    this.maxBufferSize = options.maxBufferSize || 64 * 1024 * 1024; // 64MB
+  }
+
+  push(data) {
+    this.buffer = Buffer.concat([this.buffer, data]);
+
+    if (this.buffer.length > this.maxBufferSize) {
+      this.buffer = Buffer.alloc(0);
+      throw new Error(`Accumulator buffer exceeded maximum size of ${this.maxBufferSize} bytes`);
+    }
+
+    while (this.buffer.length > 0) {
+      const frame = Frame.decode(this.buffer);
+      if (!frame) break;
+      this.buffer = this.buffer.slice(frame.totalSize);
+      this.onFrame(frame);
+    }
+  }
+
+  reset() {
+    this.buffer = Buffer.alloc(0);
+  }
+
+  getBufferLength() {
+    return this.buffer.length;
+  }
+}
+
+module.exports = FrameAccumulator;

package/src/Router.js

@@ -0,0 +1,252 @@
+const {
+  FrameTypes: {
+    REQUEST,
+    RESPONSE,
+    ERROR,
+    SUBSCRIBE,
+    UNSUBSCRIBE,
+    PUBLISH,
+  },
+  Serializer,
+} = require('@afterlink/core');
+
+class Router {
+  constructor() {
+    this.routes = new Map();
+    this.middlewares = [];
+    this.pubSubBroker = new PubSubBroker();
+  }
+
+  register(route, handler, schema = null) {
+    if (typeof handler !== 'function') {
+      throw new TypeError(`Handler for route '${route}' must be a function`);
+    }
+    this.routes.set(route, { handler, schema });
+  }
+
+  addMiddleware(middleware) {
+    if (typeof middleware !== 'function') {
+      throw new TypeError('Middleware must be a function');
+    }
+    this.middlewares.push(middleware);
+  }
+
+  async dispatch(frame, connection) {
+    const { type, messageId, payload } = frame;
+
+    switch (type) {
+      case REQUEST:
+        await this._handleRequest(payload, messageId, connection);
+        break;
+      case SUBSCRIBE:
+        this._handleSubscribe(payload, messageId, connection);
+        break;
+      case UNSUBSCRIBE:
+        this._handleUnsubscribe(payload, messageId, connection);
+        break;
+      case PUBLISH:
+        this._handlePublish(payload, connection);
+        break;
+      default:
+        connection.sendError('PROTOCOL_ERROR', `Unexpected frame type: 0x${type.toString(16)}`, messageId);
+    }
+  }
+
+  async _handleRequest(payload, messageId, connection) {
+    let route, body;
+    try {
+      const decoded = Serializer.decode(payload);
+      route = decoded.route;
+      body = decoded.body || {};
+    } catch (err) {
+      connection.sendError('PROTOCOL_ERROR', 'Invalid request payload', messageId);
+      return;
+    }
+
+    const routeConfig = this.routes.get(route);
+    if (!routeConfig) {
+      connection.sendError('ROUTE_NOT_FOUND', `Route '${route}' not found`, messageId);
+      return;
+    }
+
+    if (routeConfig.schema) {
+      try {
+        routeConfig.schema.parse(body);
+      } catch (err) {
+        const message = err.errors?.[0]?.message || err.message;
+        connection.sendError('VALIDATION_ERROR', message, messageId);
+        return;
+      }
+    }
+
+    let responseSent = false;
+    const req = { body, session: connection.session, route };
+    const res = {
+      send: (data) => {
+        if (responseSent) return;
+        responseSent = true;
+        try {
+          const responsePayload = Serializer.encode({ status: 'ok', body: data });
+          connection.send(RESPONSE, 0, messageId, responsePayload);
+        } catch (err) {
+          connection.sendError('INTERNAL_ERROR', 'Failed to encode response', messageId);
+        }
+      },
+    };
+
+    try {
+      await this._runMiddlewares(req, async () => {
+        await routeConfig.handler(req, res);
+      });
+    } catch (err) {
+      if (!responseSent) {
+        connection.sendError('INTERNAL_ERROR', err.message, messageId);
+      }
+    }
+  }
+
+  async _runMiddlewares(req, next) {
+    let index = 0;
+    const run = async () => {
+      if (index >= this.middlewares.length) {
+        return next();
+      }
+      const middleware = this.middlewares[index++];
+      await middleware(req, run);
+    };
+    await run();
+  }
+
+  _handleSubscribe(payload, messageId, connection) {
+    let topic;
+    try {
+      topic = Serializer.decode(payload).topic;
+    } catch {
+      connection.sendError('PROTOCOL_ERROR', 'Invalid subscribe payload', messageId);
+      return;
+    }
+
+    if (!topic || typeof topic !== 'string') {
+      connection.sendError('VALIDATION_ERROR', 'Topic must be a non-empty string', messageId);
+      return;
+    }
+
+    this.pubSubBroker.subscribe(topic, connection);
+    const ackPayload = Serializer.encode({ topic, sub_id: `s_${Date.now()}` });
+    connection.send(RESPONSE, 0, messageId, ackPayload);
+  }
+
+  _handleUnsubscribe(payload, messageId, connection) {
+    let topic;
+    try {
+      topic = Serializer.decode(payload).topic;
+    } catch {
+      connection.sendError('PROTOCOL_ERROR', 'Invalid unsubscribe payload', messageId);
+      return;
+    }
+
+    this.pubSubBroker.unsubscribe(topic, connection);
+    const ackPayload = Serializer.encode({ topic });
+    connection.send(RESPONSE, 0, messageId, ackPayload);
+  }
+
+  _handlePublish(payload, connection) {
+    let topic, data;
+    try {
+      const decoded = Serializer.decode(payload);
+      topic = decoded.topic;
+      data = decoded.data;
+    } catch {
+      return;
+    }
+
+    this.pubSubBroker.publish(topic, data, connection);
+  }
+
+  publish(topic, data) {
+    this.pubSubBroker.publishToAll(topic, data);
+  }
+
+  onDisconnect(connection) {
+    this.pubSubBroker.cleanupConnection(connection);
+  }
+
+  getRouteCount() {
+    return this.routes.size;
+  }
+
+  getSubscribers(topic) {
+    const subs = this.pubSubBroker.topics.get(topic);
+    return subs ? subs.size : 0;
+  }
+}
+
+class PubSubBroker {
+  constructor() {
+    this.topics = new Map();
+  }
+
+  subscribe(topic, connection) {
+    if (!this.topics.has(topic)) {
+      this.topics.set(topic, new Set());
+    }
+    this.topics.get(topic).add(connection);
+  }
+
+  unsubscribe(topic, connection) {
+    const subs = this.topics.get(topic);
+    if (subs) {
+      subs.delete(connection);
+      if (subs.size === 0) {
+        this.topics.delete(topic);
+      }
+    }
+  }
+
+  publish(topic, data, excludeConnection) {
+    const subs = this.topics.get(topic);
+    if (!subs || subs.size === 0) return;
+
+    let payload;
+    try {
+      payload = Serializer.encode({ topic, data });
+    } catch {
+      return;
+    }
+
+    for (const conn of subs) {
+      if (conn !== excludeConnection && conn.isActive()) {
+        conn.send(PUBLISH, 0, 0, payload);
+      }
+    }
+  }
+
+  publishToAll(topic, data) {
+    const subs = this.topics.get(topic);
+    if (!subs || subs.size === 0) return;
+
+    let payload;
+    try {
+      payload = Serializer.encode({ topic, data });
+    } catch {
+      return;
+    }
+
+    for (const conn of subs) {
+      if (conn.isActive()) {
+        conn.send(PUBLISH, 0, 0, payload);
+      }
+    }
+  }
+
+  cleanupConnection(connection) {
+    for (const [topic, subs] of this.topics) {
+      subs.delete(connection);
+      if (subs.size === 0) {
+        this.topics.delete(topic);
+      }
+    }
+  }
+}
+
+module.exports = Router;

package/src/Server.js

@@ -0,0 +1,101 @@
+const net = require('net');
+const Connection = require('./Connection');
+const Router = require('./Router');
+
+class Server {
+  constructor(config = {}) {
+    this.config = {
+      port: 4000,
+      host: '0.0.0.0',
+      maxConnections: 10000,
+      ...config,
+    };
+    this.router = new Router();
+    this.connections = new Set();
+    this.tcp = null;
+    this._listening = false;
+  }
+
+  on(route, handler, schema = null) {
+    this.router.register(route, handler, schema);
+    return this;
+  }
+
+  use(middleware) {
+    this.router.addMiddleware(middleware);
+    return this;
+  }
+
+  publish(topic, data) {
+    this.router.publish(topic, data);
+    return this;
+  }
+
+  listen(port = this.config.port) {
+    return new Promise((resolve, reject) => {
+      if (this._listening) {
+        return reject(new Error('Server is already listening'));
+      }
+
+      this.tcp = net.createServer((socket) => {
+        if (this.connections.size >= this.config.maxConnections) {
+          socket.destroy();
+          return;
+        }
+
+        socket.setKeepAlive(true, 60000);
+        socket.setNoDelay(true);
+
+        const conn = new Connection(socket, this.router, {
+          auth: this.config.auth,
+        });
+        this.connections.add(conn);
+        socket.on('close', () => this.connections.delete(conn));
+      });
+
+      this.tcp.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+          reject(new Error(`Port ${port} is already in use`));
+        } else {
+          console.error('[AfterLink] Server error:', err.message);
+        }
+      });
+
+      this.tcp.listen(port, this.config.host, () => {
+        this._listening = true;
+        console.log(`[AfterLink] Server listening on ${this.config.host}:${port}`);
+        resolve(this);
+      });
+    });
+  }
+
+  close() {
+    return new Promise((resolve) => {
+      if (!this.tcp || !this._listening) {
+        return resolve();
+      }
+
+      this._listening = false;
+
+      for (const conn of this.connections) {
+        conn.destroy();
+      }
+
+      this.tcp.close(() => resolve());
+    });
+  }
+
+  getConnectionCount() {
+    return this.connections.size;
+  }
+
+  getRouteCount() {
+    return this.router.getRouteCount();
+  }
+
+  isListening() {
+    return this._listening;
+  }
+}
+
+module.exports = Server;

package/src/index.js

@@ -0,0 +1,3 @@
+const Server = require('./Server');
+
+module.exports = { Server };