@aviarytech/didcomm-messaging/dist/index.js

DIDComm Messaging library for sending and receiving DIDComm messages

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DIDComm = void 0;
const axios_1 = require("axios");
const event_bus_1 = require("./utils/event-bus");
const didcomm_core_1 = require("@aviarytech/didcomm-core");
class DIDComm {
    constructor(messageHandlers, didResolver, secretResolver) {
        this.messageHandlers = messageHandlers;
        this.didResolver = didResolver;
        this.secretResolver = secretResolver;
        this.core = new didcomm_core_1.DIDCommCore(didResolver, secretResolver);
        this.messageBus = new event_bus_1.EventBus();
        messageHandlers.forEach((handler) => {
            this.messageBus.register(handler.type, handler);
        });
    }
    handleMessage(message) {
        if (this.messageHandlers.find((h) => h.type === message.payload.type)) {
            this.messageBus.dispatch(message.payload.type, {
                message,
                didcomm: this,
            });
            return true;
        }
        return false;
    }
    sendMessage(did, message, serviceId) {
        return __awaiter(this, void 0, void 0, function* () {
            const packedMsg = yield this.core.packMessage(did, message.payload);
            const didDoc = yield this.didResolver.resolve(did);
            const service = serviceId
                ? didDoc.getServiceById(serviceId)
                : didDoc.getServiceByType("DIDCommMessaging");
            if (typeof service.serviceEndpoint !== "string") {
                throw Error("Only string service endpoints are supported");
            }
            try {
                const resp = yield axios_1.default.post(service.serviceEndpoint, packedMsg, {
                    headers: { "Content-Type": "application/didcomm-encrypted+json" /* ENCRYPTED */ },
                });
                return resp.status === 200 || resp.status === 201;
            }
            catch (e) {
                console.log(`error sending didcomm message to ${service.serviceEndpoint}, received ${e.response.statusCode} - ${e.response.message}`);
                return false;
            }
        });
    }
    receiveMessage(msg, mediaType) {
        return __awaiter(this, void 0, void 0, function* () {
            let finalMessage;
            if (mediaType === "application/didcomm-encrypted+json" /* ENCRYPTED */) {
                finalMessage = yield this.core.unpackMessage(msg, mediaType);
            }
            else if (mediaType === "application/didcomm-plain+json" /* PLAIN */) {
                finalMessage = msg;
            }
            else {
                throw new Error(`Unsupported Media Type: ${mediaType}`);
            }
            console.log(`DIDComm received ${finalMessage.type} message`);
            return this.handleMessage({ payload: finalMessage, repudiable: false });
        });
    }
}
exports.DIDComm = DIDComm;
//# sourceMappingURL=index.js.map