@filemap/events-sdk/dist/services/message-handler.service.js

SDK for Filemap events. Desktop client for Filemap dev server.

"use strict";
var __decorate = (this && this.__decorate) || function (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;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.MessageHandlerService = void 0;
const tsyringe_1 = require("tsyringe");
const logger_service_1 = require("./logger.service");
const key_fetcher_service_1 = require("./key-fetcher.service");
const signature_verifier_service_1 = require("./signature-verifier.service");
let MessageHandlerService = class MessageHandlerService {
    logger;
    keyFetcher;
    signatureVerifier;
    onOpenFileListeners = [];
    onOpenElementListeners = [];
    constructor(logger, keyFetcher, signatureVerifier) {
        this.logger = logger;
        this.keyFetcher = keyFetcher;
        this.signatureVerifier = signatureVerifier;
    }
    onAddOnOpenFileListener(callback) {
        this.onOpenFileListeners.push(callback);
    }
    onAddOnOpenElementListener(callback) {
        this.onOpenElementListeners.push(callback);
    }
    onRemoveOnOpenFileListener(callback) {
        this.onOpenFileListeners.filter(fn => fn !== callback);
    }
    onRemoveOnOpenElementListener(callback) {
        this.onOpenElementListeners.filter(fn => fn !== callback);
    }
    handleMessage(message) {
        if ('event' in message && message.event === 'register_uuid') {
            this.handleRegisterUuid(message);
        }
        else if ('event_name' in message && 'signature' in message && 'referrer' in message) {
            this.handleForwardedMessage(message);
        }
        else {
            this.logger.warn(`Unknown message type received: ${JSON.stringify(message)}`);
        }
    }
    handleRegisterUuid(message) {
        const { uuid, expirationTime, referrer } = message.data;
        this.logger.debug(`Received UUID registration from ${referrer}: ${uuid}`);
        this.keyFetcher.startFetching(uuid, referrer, expirationTime);
    }
    handleForwardedMessage(message) {
        const { signature, referrer, ...messageWithoutSignature } = message;
        const signedPayload = {
            event_name: messageWithoutSignature.event_name,
            params: messageWithoutSignature.params,
            message_id: messageWithoutSignature.message_id
        };
        const verificationResult = this.signatureVerifier.verify(signedPayload, signature, referrer);
        if (!verificationResult.isValid) {
            this.logger.debug(`Invalid signature for message from ${referrer}, discarding`);
            return;
        }
        this.logger.debug(`Verified message from ${referrer}`);
        switch (message.event_name) {
            case 'open_element':
                this.handleOpenElement(message, referrer);
                break;
            case 'open_file':
                this.handleOpenFile(message, referrer);
                break;
            default:
                this.logger.debug(`Unknown event type: ${message.event_name}`);
        }
    }
    handleOpenElement(message, referrer) {
        if (message.event_name !== 'open_element')
            return;
        const { file_path, line_number, column_number } = message.params;
        this.logger.debug(`Open element request: ${file_path}:${line_number}:${column_number}`);
        this.onOpenElementListeners.forEach(callback => {
            try {
                callback({
                    filePath: file_path,
                    lineNumber: line_number,
                    columnNumber: column_number
                });
            }
            catch (e) {
                this.logger.error(e.message.toString());
            }
        });
    }
    handleOpenFile(message, referrer) {
        if (message.event_name !== 'open_file')
            return;
        const { file_path } = message.params;
        this.logger.debug(`Open file request: ${file_path}`);
        this.onOpenFileListeners.forEach(callback => {
            try {
                callback({
                    filePath: file_path
                });
            }
            catch (e) {
                this.logger.error(e.message.toString());
            }
        });
    }
};
exports.MessageHandlerService = MessageHandlerService;
exports.MessageHandlerService = MessageHandlerService = __decorate([
    (0, tsyringe_1.singleton)(),
    (0, tsyringe_1.injectable)(),
    __param(0, (0, tsyringe_1.inject)(logger_service_1.Logger)),
    __param(1, (0, tsyringe_1.inject)(key_fetcher_service_1.KeyFetcher)),
    __param(2, (0, tsyringe_1.inject)(signature_verifier_service_1.SignatureVerifierService)),
    __metadata("design:paramtypes", [logger_service_1.Logger,
        key_fetcher_service_1.KeyFetcher,
        signature_verifier_service_1.SignatureVerifierService])
], MessageHandlerService);
//# sourceMappingURL=message-handler.service.js.map