@sync-in/server/server/infrastructure/websocket/adapters/web-socket.adapter.js

The secure, open-source platform for file storage, sharing, collaboration, and sync

/*
 * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>
 * This file is part of Sync-in | The open source file sync and share solution
 * See the LICENSE file for licensing details
 */ "use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
Object.defineProperty(exports, "WebSocketAdapter", {
    enumerable: true,
    get: function() {
        return WebSocketAdapter;
    }
});
const _common = require("@nestjs/common");
const _jwt = require("@nestjs/jwt");
const _platformfastify = require("@nestjs/platform-fastify");
const _platformsocketio = require("@nestjs/platform-socket.io");
const _websockets = require("@nestjs/websockets");
const _cookie = require("cookie");
const _nodecluster = /*#__PURE__*/ _interop_require_default(require("node:cluster"));
const _websocket = require("../../../applications/users/constants/websocket");
const _configenvironment = require("../../../configuration/config.environment");
const _utils = require("../utils");
const _clusteradapter = require("./cluster.adapter");
const _redisadapter = require("./redis.adapter");
function _interop_require_default(obj) {
    return obj && obj.__esModule ? obj : {
        default: obj
    };
}
function _ts_decorate(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function _ts_metadata(k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
let WebSocketAdapter = class WebSocketAdapter extends _platformsocketio.IoAdapter {
    async initAdapter() {
        this.adapter = await this.getAdapter();
    }
    createIOServer(port, options) {
        const server = this.adapter.createIOServer(port, {
            ...options,
            cors: {
                origin: _configenvironment.configuration.websocket.corsOrigin
            },
            transports: [
                'websocket'
            ]
        });
        // Authentication
        server.use(this.authenticateSocket.bind(this));
        server.on('new_namespace', (namespace)=>{
            // apply auth on all namespaces
            namespace.use(this.authenticateSocket.bind(this));
        });
        this.logger.log(`Using ${server.of(_websocket.USERS_WS.NAME_SPACE).adapter.constructor.name}`);
        return server;
    }
    async getAdapter() {
        if (_configenvironment.configuration.websocket.adapter === 'redis') {
            try {
                const redisIoAdapter = new _redisadapter.RedisAdapter(this.app);
                await redisIoAdapter.connectToRedis(_configenvironment.configuration.websocket.redis);
                return redisIoAdapter;
            } catch (e) {
                this.logger.error(e.message);
                process.exit(1);
            }
        } else {
            if (_nodecluster.default.isWorker) {
                // setup connection with the primary process
                return new _clusteradapter.ClusterAdapter(this.app);
            } else {
                this.logger.warn('Adapter Cluster only works in clustering mode', 'WEBSOCKET');
            // do not exit for tests (e2e)
            }
        }
    }
    authenticateSocket(socket, next) {
        const cookies = socket.request.headers.cookie ? (0, _cookie.parse)(socket.request.headers.cookie) : {};
        const token = cookies[_configenvironment.configuration.auth.token.ws.name];
        if (!token) {
            this.onAuthError('Authorization is missing', socket, next);
            return;
        }
        let payload;
        try {
            payload = this.jwtService.verify(token, {
                secret: _configenvironment.configuration.auth.token.ws.secret
            });
        } catch (e) {
            this.onAuthError(e.message, socket, next);
            return;
        }
        if (!payload) {
            this.onAuthError('Payload is missing', socket, next);
            return;
        }
        Object.assign(socket, {
            user: payload.identity
        });
        next();
    }
    onAuthError(error, socket, next) {
        this.logger.warn(`${error} - ${(0, _utils.getClientAddress)(socket)} ${socket.id} ${socket.handshake.url} ${socket.handshake.headers['user-agent']}`);
        next(new _websockets.WsException('Unauthorized'));
    }
    constructor(app){
        super(app), this.logger = new _common.Logger(WebSocketAdapter.name);
        this.app = app;
        this.jwtService = app.get(_jwt.JwtService);
    }
};
WebSocketAdapter = _ts_decorate([
    (0, _common.Injectable)(),
    _ts_metadata("design:type", Function),
    _ts_metadata("design:paramtypes", [
        typeof _platformfastify.NestFastifyApplication === "undefined" ? Object : _platformfastify.NestFastifyApplication
    ])
], WebSocketAdapter);

//# sourceMappingURL=web-socket.adapter.js.map