@eleven-am/pondsocket 0.1.11 → 0.1.13

package/dist/server/pondChannel/pondChannel.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PondChannel = void 0;
+const joinRequest_1 = require("./joinRequest");
+const joinResponse_1 = require("./joinResponse");
+const middleware_1 = require("../abstracts/middleware");
+const channelEngine_1 = require("../channel/channelEngine");
+class PondChannel {
+    constructor() {
+        this._authorize = undefined;
+        this._channels = new Set();
+        this._middleware = new middleware_1.Middleware();
+    }
+    /**
+     * @desc Authorize a user to join a channel
+     * @param handler - The handler to authorize the user
+     * @example
+     * const pond = new PondChannelEngine();
+     * pond.onJoinRequest((request, response) => {
+     *     if (request.event.assigns.admin)
+     *          response.accept();
+     *     else
+     *         response.reject('You are not an admin', 403);
+     * });
+     */
+    onJoinRequest(handler) {
+        this._authorize = handler;
+    }
+    /**
+     * @desc Handles an event request made by a user
+     * @param event - The event to listen for
+     * @param handler - The handler to execute when the event is received
+     * @example
+     * pond.onEvent('echo', (request, response) => {
+     *     response.send('echo', {
+     *         message: request.payload,
+     *     });
+     * });
+     */
+    onEvent(event, handler) {
+        this._middleware.use((request, response, next) => {
+            if (request._parseQueries(event)) {
+                return handler(request, response);
+            }
+            next();
+        });
+    }
+    /**
+     * @desc Builds a PondChannelManager from the current engine
+     */
+    _buildManager() {
+        return {
+            addUser: this._addUser.bind(this),
+            execute: this._execute.bind(this),
+            removeUser: this._removeUser.bind(this),
+            getChannels: this._getChannels.bind(this),
+            listChannels: this._listChannels.bind(this),
+        };
+    }
+    /**
+     * @desc Adds a user to a channel
+     * @param user - The user to add
+     * @private
+     */
+    _addUser(user) {
+        const newChannel = this._getChannel(user.channelName) || this._createChannel(user.channelName);
+        if (this._authorize) {
+            const socketCache = {
+                clientId: user.clientId,
+                socket: user.socket,
+                assigns: user.assigns,
+            };
+            const request = new joinRequest_1.JoinRequest(user, newChannel);
+            const response = new joinResponse_1.JoinResponse(socketCache, newChannel);
+            void this._authorize(request, response);
+            if (!response.responseSent) {
+                throw new Error('PondChannelEngine: Response was not resolved');
+            }
+        }
+        else {
+            newChannel.addUser(user.clientId, user.assigns, (event) => {
+                user.socket.send(JSON.stringify(event));
+            });
+        }
+    }
+    /**
+     * @desc Removes a user from all channels
+     * @param clientId - The client id of the user to remove
+     * @private
+     */
+    _removeUser(clientId) {
+        this._channels.forEach((channel) => {
+            channel.removeUser(clientId, true);
+        });
+    }
+    /**
+     * @desc Creates a new channel
+     * @param channelName - The name of the channel to create
+     * @private
+     */
+    _createChannel(channelName) {
+        const destroyChannel = this._destroyChannel.bind(this, channelName);
+        const execute = this._middleware.run.bind(this._middleware);
+        const parentEngine = {
+            execute,
+            destroyChannel,
+        };
+        const newChannel = new channelEngine_1.ChannelEngine(channelName, parentEngine);
+        this._channels.add(newChannel);
+        return newChannel;
+    }
+    /**
+     * @desc Executes a function on a channel
+     * @param channelName - The name of the channel to execute the function on
+     * @param handler - The function to execute
+     * @private
+     */
+    _execute(channelName, handler) {
+        const newChannel = this._getChannel(channelName);
+        if (newChannel) {
+            return handler(newChannel);
+        }
+        throw new Error(`GatewayEngine: Channel ${channelName} does not exist`);
+    }
+    /**
+     * @desc Gets a channel by name
+     * @param channelName - The name of the channel to get
+     * @private
+     */
+    _getChannel(channelName) {
+        return Array.from(this._channels)
+            .find((channel) => channel.name === channelName);
+    }
+    /**
+     * @desc Destroys a channel
+     * @param channel - The name of the channel to destroy
+     * @private
+     */
+    _destroyChannel(channel) {
+        const newChannel = this._getChannel(channel);
+        if (newChannel) {
+            this._channels.delete(newChannel);
+        }
+    }
+    /**
+     * @desc Lists all channels
+     * @private
+     */
+    _listChannels() {
+        return Array.from(this._channels)
+            .map((channel) => channel.name);
+    }
+    /**
+     * @desc Gets all channels
+     * @private
+     */
+    _getChannels() {
+        return Array.from(this._channels);
+    }
+}
+exports.PondChannel = PondChannel;

package/dist/server/pondChannel/pondChannelResponse.test.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const joinResponse_1 = require("./joinResponse");
+const channelEngine_1 = require("../channel/channelEngine");
+const channelResponse_test_1 = require("../channel/channelResponse.test");
+const createPondResponse = () => {
+    const channelEngine = (0, channelResponse_test_1.createChannelEngine)();
+    const socket = {
+        clientId: 'sender',
+        assigns: { assign: 'assign' },
+        socket: {
+            send: jest.fn(),
+        },
+    };
+    const response = new joinResponse_1.JoinResponse(socket, channelEngine);
+    return { channelEngine,
+        socket,
+        response };
+};
+/* eslint-disable line-comment-position, no-inline-comments */
+describe('pondChannelResponse', () => {
+    it('should create a new PondChannelResponse', () => {
+        const { response } = createPondResponse();
+        expect(response).toBeDefined();
+    });
+    it('should return the responseSent', () => {
+        const { response } = createPondResponse();
+        expect(response.responseSent).toEqual(false);
+    });
+    it('should accept the request', () => {
+        const { response, channelEngine, socket } = createPondResponse();
+        // spy on the channelEngine to see if the user was added
+        jest.spyOn(channelEngine, 'addUser');
+        response.accept();
+        // check if the response was sent
+        expect(response.responseSent).toEqual(true);
+        expect(response.responseSent).toEqual(true);
+        expect(channelEngine.addUser).toHaveBeenCalledWith(socket.clientId, socket.assigns, expect.any(Function));
+        expect(channelEngine.getUserData(socket.clientId)).not.toBeNull();
+    });
+    it('should reject the request', () => {
+        const { response, channelEngine, socket } = createPondResponse();
+        // spy on the channelEngine to see if the user was added
+        jest.spyOn(channelEngine, 'addUser');
+        response.reject();
+        // check if the response was sent
+        expect(response.responseSent).toEqual(true);
+        expect(channelEngine.addUser).not.toHaveBeenCalled();
+        expect(channelEngine.getUserData(socket.clientId)).toBeUndefined();
+        // also check if the socket was sent a message
+        expect(socket.socket.send).toHaveBeenCalledWith(JSON.stringify({
+            event: 'POND_ERROR',
+            payload: {
+                message: 'Request to join channel test rejected: Unauthorized request',
+                code: 403,
+            },
+            channelName: 'test',
+            action: channelEngine_1.ServerActions.ERROR,
+        }));
+    });
+    it('should send a direct message', () => {
+        const { response, channelEngine, socket } = createPondResponse();
+        // spy on the channelEngine to see if the user was added
+        jest.spyOn(channelEngine, 'addUser');
+        response.send('POND_MESSAGE', { message: 'message' });
+        // check if the response was sent
+        expect(response.responseSent).toEqual(true);
+        expect(channelEngine.addUser).toHaveBeenCalled();
+        expect(channelEngine.getUserData(socket.clientId)).toStrictEqual({ assigns: { assign: 'assign' },
+            id: 'sender',
+            presence: {} });
+        // also check if the socket was sent a message
+        expect(socket.socket.send).toHaveBeenCalledWith(JSON.stringify({
+            action: channelEngine_1.ServerActions.SYSTEM,
+            event: 'POND_MESSAGE',
+            payload: {
+                message: 'message',
+            },
+            channelName: 'test',
+        }));
+    });
+    // auxiliary functions
+    it('should send messages to different users', () => {
+        const { response, channelEngine } = createPondResponse();
+        // spy on the channelEngine to see if any messages were published
+        const broadcast = jest.spyOn(channelEngine, 'sendMessage');
+        // add a second user to the channel
+        channelEngine.addUser('user2', { assign: 'assign' }, () => { });
+        // send a message to a single user
+        expect(() => response.sendToUsers('hello_everyone', { message: 'hello' }, ['user2'])).toThrow(); // this is because the sender does not exist in the channel yet
+        // clear the spy
+        broadcast.mockClear();
+        // add the sender to the channel by using the response.accept() method
+        response.accept().sendToUsers('hello_everyone', { message: 'hello' }, ['user2']);
+        // check if the message was sent
+        expect(broadcast).toHaveBeenCalledWith('sender', ['user2'], channelEngine_1.ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' });
+        // clear the spy
+        broadcast.mockClear();
+        // send a message to all users
+        response.broadcast('hello_everyone', { message: 'hello' });
+        expect(broadcast).toHaveBeenCalledWith('sender', 'all_users', channelEngine_1.ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' });
+        // clear the spy
+        broadcast.mockClear();
+        // send a message to all users except the sender
+        response.broadcastFromUser('hello_everyone', { message: 'hello' });
+        expect(broadcast).toHaveBeenCalledWith('sender', 'all_except_sender', channelEngine_1.ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' });
+    });
+});

package/dist/server/presence/presenceEngine.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresenceEngine = exports.PresenceEventTypes = void 0;
+const subjectUtils_1 = require("../utils/subjectUtils");
+var PresenceEventTypes;
+(function (PresenceEventTypes) {
+    PresenceEventTypes["JOIN"] = "JOIN";
+    PresenceEventTypes["LEAVE"] = "LEAVE";
+    PresenceEventTypes["UPDATE"] = "UPDATE";
+})(PresenceEventTypes = exports.PresenceEventTypes || (exports.PresenceEventTypes = {}));
+class PresenceEngine {
+    constructor() {
+        this._presence = new subjectUtils_1.BehaviorSubject();
+        this._presenceMap = new Map();
+    }
+    /**
+     * @desc Lists all the presence of the users
+     */
+    getPresence() {
+        return Array.from(this._presenceMap.entries())
+            .reduce((acc, [key, value]) => {
+            acc[key] = value;
+            return acc;
+        }, {});
+    }
+    /**
+     * @desc Returns the presence of a user
+     * @param userId - The id of the user
+     */
+    getUserPresence(userId) {
+        return this._presenceMap.get(userId);
+    }
+    /**
+     * @desc Removes a presence from the presence engine
+     * @param presenceKey - The key of the presence
+     */
+    removePresence(presenceKey) {
+        const presence = this._presenceMap.get(presenceKey);
+        if (presence) {
+            this._presence.unsubscribe(presenceKey);
+            this._presenceMap.delete(presenceKey);
+            if (this._presenceMap.size > 0) {
+                this._presence.next({
+                    type: PresenceEventTypes.LEAVE,
+                    changed: presence,
+                    presence: Array.from(this._presenceMap.values()),
+                });
+            }
+        }
+        else {
+            throw new Error(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
+        }
+    }
+    /**
+     * @desc Updates a presence
+     * @param presenceKey - The key of the presence
+     * @param presence - The new presence
+     */
+    updatePresence(presenceKey, presence) {
+        const oldPresence = this._presenceMap.get(presenceKey);
+        if (oldPresence) {
+            this._presenceMap.set(presenceKey, presence);
+            this._presence.next({
+                type: PresenceEventTypes.UPDATE,
+                changed: Object.assign(Object.assign({}, oldPresence), presence),
+                presence: Array.from(this._presenceMap.values()),
+            });
+        }
+        else {
+            throw new Error(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
+        }
+    }
+    /**
+     * @desc Tracks a presence
+     * @param presenceKey - The key of the presence
+     * @param presence - The presence
+     * @param onPresenceChange - The callback to be called when the presence changes
+     */
+    trackPresence(presenceKey, presence, onPresenceChange) {
+        this._insertPresence(presenceKey, presence);
+        return this._subscribe(presenceKey, onPresenceChange);
+    }
+    /**
+     * @desc Inserts a presence into the presence engine
+     * @param presenceKey - The key of the presence
+     * @param presence - The presence
+     * @private
+     */
+    _insertPresence(presenceKey, presence) {
+        if (!this._presenceMap.has(presenceKey)) {
+            this._presenceMap.set(presenceKey, presence);
+            this._presence.next({
+                type: PresenceEventTypes.JOIN,
+                changed: presence,
+                presence: Array.from(this._presenceMap.values()),
+            });
+        }
+        else {
+            throw new Error(`PresenceEngine: Presence with key ${presenceKey} already exists`);
+        }
+    }
+    /**
+     * @desc Subscribes to the presence engine
+     * @param identifier - The identifier of the observer
+     * @param observer - The observer
+     * @private
+     */
+    _subscribe(identifier, observer) {
+        return this._presence.subscribe(identifier, observer);
+    }
+}
+exports.PresenceEngine = PresenceEngine;

package/dist/server/presence/presenceEngine.test.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const presenceEngine_1 = require("./presenceEngine");
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+describe('PresenceEngine', () => {
+    let presenceEngine;
+    let presence;
+    let presenceKey;
+    let onPresenceChange;
+    beforeEach(() => {
+        presenceEngine = new presenceEngine_1.PresenceEngine();
+        presence = {
+            id: 'id',
+            name: 'name',
+            color: 'color',
+            type: 'type',
+            location: 'location',
+        };
+        presenceKey = 'presenceKey';
+        onPresenceChange = jest.fn();
+    });
+    describe('trackPresence', () => {
+        it('should insert a presence into the presence engine', () => {
+            // spy on the private method _insertPresence
+            // @ts-ignore
+            jest.spyOn(presenceEngine, '_insertPresence');
+            presenceEngine.trackPresence(presenceKey, presence, onPresenceChange);
+            // @ts-ignore
+            expect(presenceEngine._insertPresence).toHaveBeenCalledWith(presenceKey, presence);
+            expect(onPresenceChange).toHaveBeenCalledWith({
+                type: presenceEngine_1.PresenceEventTypes.JOIN,
+                changed: presence,
+                presence: [presence],
+            });
+        });
+        it('should subscribe to the presence engine', () => {
+            // spy on the private method _subscribe
+            // @ts-ignore
+            jest.spyOn(presenceEngine, '_subscribe');
+            presenceEngine.trackPresence(presenceKey, presence, onPresenceChange);
+            // @ts-ignore
+            expect(presenceEngine._subscribe).toHaveBeenCalledWith(presenceKey, onPresenceChange);
+            expect(onPresenceChange).toHaveBeenCalledWith({
+                type: presenceEngine_1.PresenceEventTypes.JOIN,
+                changed: presence,
+                presence: [presence],
+            });
+        });
+        it('should throw an error if the presence already exists', () => {
+            presenceEngine.trackPresence(presenceKey, presence, onPresenceChange);
+            expect(() => presenceEngine.trackPresence(presenceKey, presence, onPresenceChange)).toThrowError(`PresenceEngine: Presence with key ${presenceKey} already exists`);
+        });
+    });
+    describe('updatePresence', () => {
+        it('should update a presence', () => {
+            presenceEngine.trackPresence(presenceKey, presence, onPresenceChange);
+            const newPresence = {
+                id: 'id',
+                name: 'name',
+                color: 'color',
+                type: 'type',
+                location: 'location',
+            };
+            presenceEngine.updatePresence(presenceKey, newPresence);
+            expect(onPresenceChange).toHaveBeenCalledWith({
+                type: presenceEngine_1.PresenceEventTypes.UPDATE,
+                changed: Object.assign(Object.assign({}, presence), newPresence),
+                presence: [newPresence],
+            });
+        });
+        it('should throw an error if the presence does not exist', () => {
+            expect(() => presenceEngine.updatePresence(presenceKey, presence)).toThrowError(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
+        });
+    });
+    describe('removePresence', () => {
+        it('should remove a presence from the presence engine', () => {
+            presenceEngine.trackPresence(presenceKey, presence, onPresenceChange);
+            presenceEngine.trackPresence('presenceKey2', Object.assign(Object.assign({}, presence), { key: 'presence2' }), onPresenceChange);
+            presenceEngine.removePresence(presenceKey);
+            expect(onPresenceChange).toHaveBeenCalledWith({
+                type: presenceEngine_1.PresenceEventTypes.LEAVE,
+                changed: presence,
+                presence: [
+                    Object.assign(Object.assign({}, presence), { key: 'presence2' }),
+                ],
+            });
+            // @ts-ignore
+            onPresenceChange.mockClear();
+            presenceEngine.removePresence('presenceKey2');
+            expect(onPresenceChange).not.toHaveBeenCalled();
+        });
+        it('should throw an error if the presence does not exist', () => {
+            expect(() => presenceEngine.removePresence(presenceKey)).toThrowError(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
+        });
+    });
+    describe('getPresence', () => {
+        it('should return the presence', () => {
+            presenceEngine.trackPresence(presenceKey, presence, onPresenceChange);
+            const data = {};
+            data[presenceKey] = presence;
+            expect(presenceEngine.getPresence()).toEqual(data);
+        });
+    });
+});

package/dist/server/server/pondSocket.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PondSocket = void 0;
+const http_1 = require("http");
+const ws_1 = require("ws");
+const endpoint_1 = require("../endpoint/endpoint");
+const matchPattern_1 = require("../utils/matchPattern");
+class PondSocket {
+    constructor(server, socketServer) {
+        this._middleware = [];
+        this._matcher = new matchPattern_1.MatchPattern();
+        this._server = server || new http_1.Server();
+        this._socketServer = socketServer || new ws_1.WebSocketServer({ noServer: true });
+        this._init();
+    }
+    /**
+     * @desc Specifies the port to listen on
+     * @param port - the port to listen on
+     * @param callback - the callback to call when the server is listening
+     */
+    listen(port, callback) {
+        return this._server.listen(port, callback);
+    }
+    /**
+     * @desc Closes the server
+     * @param callback - the callback to call when the server is closed
+     */
+    close(callback) {
+        return this._server.close(callback);
+    }
+    /**
+     * @desc Accepts a new socket upgrade request on the provided endpoint using the handler function to authenticate the socket
+     * @param path - the pattern to accept || can also be a regex
+     * @param handler - the handler function to authenticate the socket
+     * @example
+     * const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
+     *    const token = req.query.token;
+     *    if (!token)
+     *       return res.reject("No token provided");
+     *    res.accept({
+     *       assign: {
+     *           token
+     *       }
+     *    });
+     * })
+     */
+    createEndpoint(path, handler) {
+        const endpoint = new endpoint_1.Endpoint(this._socketServer);
+        this._middleware.push((req, socket, head, next) => {
+            const address = req.url || '';
+            const dataEndpoint = this._matcher.parseEvent(path, address);
+            if (!dataEndpoint) {
+                return next();
+            }
+            endpoint._authoriseConnection(req, socket, head, dataEndpoint, handler);
+        });
+        return endpoint;
+    }
+    /**
+     * @desc Adds a middleware function to the socket server
+     * @param middleware - the middleware function to add
+     */
+    use(middleware) {
+        this._middleware.push(middleware);
+    }
+    /**
+     * @desc managed the heartbeat of the socket server
+     * @private
+     */
+    _manageHeartbeat() {
+        this._socketServer.on('connection', (socket) => {
+            socket.on('pong', () => {
+                socket.isAlive = true;
+            });
+        });
+        const interval = setInterval(() => {
+            this._socketServer.clients.forEach((socket) => {
+                if (socket.isAlive === false) {
+                    return socket.terminate();
+                }
+                socket.isAlive = false;
+                socket.ping(() => { });
+            });
+        }, 30000);
+        this._socketServer.on('close', () => clearInterval(interval));
+    }
+    /**
+     * @desc executes the middleware functions
+     * @param req - the request object
+     * @param socket - the socket object
+     * @param head - the head buffer
+     * @private
+     */
+    _execute(req, socket, head) {
+        const temp = this._middleware.concat();
+        const next = () => {
+            const middleware = temp.shift();
+            if (middleware) {
+                middleware(req, socket, head, next);
+            }
+            else {
+                socket.write('HTTP/1.1 400 Bad Request\r\n\r');
+                socket.destroy();
+            }
+        };
+        next();
+    }
+    /**
+     * @desc initialises the socket server
+     * @private
+     */
+    _init() {
+        this._manageHeartbeat();
+        this._server.on('error', (error) => {
+            throw new Error(error.message);
+        });
+        this._server.on('upgrade', (req, socket, head) => {
+            this._execute(req, socket, head);
+        });
+    }
+}
+exports.PondSocket = PondSocket;

package/{pondSocket → dist/server/server}/server.test.js

@@ -12,24 +12,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const endpoint_1 = require("./endpoint");
-const pondSocket_1 = require("./pondSocket");
-const superwstest_1 = __importDefault(require("superwstest"));
-const enums_1 = require("./enums");
 const http_1 = require("http");
+const superwstest_1 = __importDefault(require("superwstest"));
 const ws_1 = require("ws");
+const pondSocket_1 = require("./pondSocket");
+const channelEngine_1 = require("../channel/channelEngine");
+const endpoint_1 = require("../endpoint/endpoint");
 describe('server', () => {
-    it('should be defined', () => {
-        expect(pondSocket_1.PondSocket).toBeDefined();
-    });
-    it('should be instantiable', () => {
-        expect(new pondSocket_1.PondSocket()).toBeInstanceOf(pondSocket_1.PondSocket);
-    });
-    it('should ba able to create its own server and websocket server if none is provided', () => {
-        const socket = new pondSocket_1.PondSocket();
-        expect(socket['_server']).toBeDefined();
-        expect(socket['_socketServer']).toBeDefined();
-    });
     it('should take a server and websocket server if provided', () => {
         const server = (0, http_1.createServer)();
         const socketServer = new ws_1.Server({ noServer: true });
@@ -50,7 +39,6 @@ describe('server', () => {
             console.log('socket');
         });
         expect(endpoint).toBeInstanceOf(endpoint_1.Endpoint);
-        expect(endpoint['_handler']).toEqual(expect.any(Function));
     });
     it('should be able to create multiple endpoints', () => {
         const server = (0, http_1.createServer)();
@@ -63,9 +51,7 @@ describe('server', () => {
             console.log('socket2');
         });
         expect(endpoint).toBeInstanceOf(endpoint_1.Endpoint);
-        expect(endpoint['_handler']).toEqual(expect.any(Function));
         expect(endpoint2).toBeInstanceOf(endpoint_1.Endpoint);
-        expect(endpoint2['_handler']).toEqual(expect.any(Function));
     });
     it('should be able to reject a socket', () => {
         const server = (0, http_1.createServer)();
@@ -99,7 +85,7 @@ describe('server', () => {
         });
         yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
-            .expectUpgrade(res => expect(res.statusCode).toBe(101))
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
             .close()
             .expectClosed();
         server.close();
@@ -131,12 +117,12 @@ describe('server', () => {
         });
         yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
-            .expectUpgrade(res => expect(res.statusCode).toBe(101))
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
             .expectJson({
-            action: enums_1.ServerActions.MESSAGE,
             event: 'testEvent',
             channelName: 'SERVER',
             payload: { test: 'test' },
+            action: channelEngine_1.ServerActions.SYSTEM,
         })
             .close()
             .expectClosed();