@mojaloop/event-sdk/dist/Recorder.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DefaultSidecarRecorderAsync = exports.DefaultSidecarRecorder = exports.DefaultLoggerRecorder = void 0;
const EventMessage_1 = require("./model/EventMessage");
const config_1 = __importDefault(require("./lib/config"));
const Logger = require('./lib/logger');
const logWithLevel = async (message) => {
    return new Promise((resolve, reject) => {
        try {
            let type;
            let action;
            if (message && ('metadata' in message) && ('event' in message.metadata)) {
                type = message.metadata.event.type;
                action = message.metadata.event.action;
            }
            else if (message && ('event' in message)) {
                type = message.event.type;
                action = message.event.action;
            }
            else {
                type = EventMessage_1.EventType.log;
                action = EventMessage_1.LogEventAction.info;
            }
            if (type === EventMessage_1.EventType.log && Object.values(EventMessage_1.LogEventAction).includes(action)) {
                Logger.log(action, JSON.stringify(message, null, 2));
            }
            else {
                Logger.log(type, JSON.stringify(message, null, 2));
            }
            resolve({ status: EventMessage_1.LogResponseStatus.accepted });
        }
        catch (e) {
            reject({ status: EventMessage_1.LogResponseStatus.error, error: e });
        }
    });
};
class DefaultLoggerRecorder {
    recorder;
    constructor(recorder) {
        this.recorder = recorder ? recorder : Logger;
        return this;
    }
    preProcess = (event) => {
        if (config_1.default.EVENT_LOGGER_LOG_METADATA_ONLY) {
            return event.metadata;
        }
        return event;
    };
    postProcess = (result) => {
        return result;
    };
    async record(event, doLog = true) {
        if (!doLog) {
            return Promise.resolve({ status: EventMessage_1.LogResponseStatus.accepted });
        }
        let updatedEvent = this.preProcess(event);
        let result = await logWithLevel(updatedEvent);
        return this.postProcess(result);
    }
}
exports.DefaultLoggerRecorder = DefaultLoggerRecorder;
class DefaultSidecarRecorder {
    recorder;
    constructor(recorder) {
        this.recorder = recorder;
        return this;
    }
    preProcess = (event) => {
        return event;
    };
    logLoad = (event) => {
        if (config_1.default.EVENT_LOGGER_LOG_METADATA_ONLY) {
            return event.metadata;
        }
        return event;
    };
    postProcess = (result) => {
        return result;
    };
    async record(event, doLog = true) {
        doLog && await logWithLevel(this.logLoad(event));
        let updatedEvent = this.preProcess(event);
        let result = await this.recorder.log(updatedEvent);
        return this.postProcess(result);
    }
}
exports.DefaultSidecarRecorder = DefaultSidecarRecorder;
class DefaultSidecarRecorderAsync {
    recorder;
    constructor(recorder) {
        this.recorder = recorder;
        return this;
    }
    preProcess = (event) => {
        return event;
    };
    logLoad = (event) => {
        if (config_1.default.EVENT_LOGGER_LOG_METADATA_ONLY) {
            return event.metadata;
        }
        return event;
    };
    async record(event, doLog = true, callback) {
        doLog && logWithLevel(this.logLoad(event));
        let updatedEvent = this.preProcess(event);
        let result = this.recorder.log(updatedEvent);
        if (callback) {
            return callback(result);
        }
        else {
            return result;
        }
    }
}
exports.DefaultSidecarRecorderAsync = DefaultSidecarRecorderAsync;
//# sourceMappingURL=Recorder.js.map